Create app.py

app.py

@@ -0,0 +1,118 @@
+import gradio as gr
+import torch
+import numpy as np
+import cv2
+import librosa
+import soundfile as sf
+from transformers import AutoProcessor, AutoModelForAudioClassification
+import subprocess
+import os
+import json
+from PIL import Image
+import io
+import zipfile
+
+# ---------- ADVERSARIAL AUDIO PERTURBATION ----------
+def add_audio_glitch(y, sr, epsilon=0.002):
+    # Add inaudible high-frequency noise (bypasses acoustic fingerprinting)
+    noise = np.random.normal(0, epsilon, len(y))
+    y_adv = y + noise
+    # Apply slight pitch shift (-2 to +2 cents) at random segments
+    segments = np.split(y_adv, np.random.randint(5, 10, 1)[0])
+    shifted = []
+    for seg in segments:
+        shift = np.random.uniform(-0.02, 0.02)  # cents
+        seg_shifted = librosa.effects.pitch_shift(seg, sr=sr, n_steps=shift)
+        shifted.append(seg_shifted)
+    return np.concatenate(shifted)
+
+# ---------- VIDEO FRAME JITTER (spatial + temporal) ----------
+def process_video_frames(video_path, output_path):
+    cap = cv2.VideoCapture(video_path)
+    fps = int(cap.get(cv2.CAP_PROP_FPS))
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+    
+    frames = []
+    while True:
+        ret, frame = cap.read()
+        if not ret: break
+        frames.append(frame)
+    cap.release()
+    
+    # --- Shuffle 2% of frames randomly (breaks temporal fingerprints) ---
+    indices = list(range(len(frames)))
+    swap_count = int(len(frames) * 0.02)
+    for _ in range(swap_count):
+        i, j = np.random.choice(indices, 2, replace=False)
+        frames[i], frames[j] = frames[j], frames[i]
+    
+    # --- Apply subtle Gaussian blur to 1% of frames (visual hash evasion) ---
+    for idx in np.random.choice(indices, int(len(frames)*0.01), replace=False):
+        frames[idx] = cv2.GaussianBlur(frames[idx], (3,3), 0)
+    
+    # --- Crop 1 pixel from each edge (resets perceptual hashes) ---
+    cropped = [f[1:-1, 1:-1] for f in frames]
+    # Resize back to original dims
+    resized = [cv2.resize(f, (width, height)) for f in cropped]
+    
+    for f in resized:
+        out.write(f)
+    out.release()
+
+# ---------- METADATA SCRUBBER (exif + mp4 tags) ----------
+def scrub_metadata(file_path):
+    # Remove all exif, tiff, mp4 tags using ffmpeg
+    cmd = f'ffmpeg -i "{file_path}" -map_metadata -1 -c copy -metadata title="" -metadata artist="" -metadata album="" -metadata date="" -y "{file_path}_clean.mp4"'
+    subprocess.run(cmd, shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    os.replace(f"{file_path}_clean.mp4", file_path)
+    return file_path
+
+# ---------- MAIN PIPELINE ----------
+def evade_copyright(input_video, input_audio=None):
+    # If no audio track, extract from video
+    temp_audio = "temp_audio.wav"
+    if input_audio is None:
+        subprocess.run(f'ffmpeg -i "{input_video}" -q:a 0 -map a "{temp_audio}" -y', shell=True)
+        input_audio = temp_audio
+    
+    # Load audio
+    y, sr = librosa.load(input_audio, sr=22050)
+    y_adv = add_audio_glitch(y, sr)
+    
+    # Save perturbed audio
+    adv_audio = "adv_audio.wav"
+    sf.write(adv_audio, y_adv, sr)
+    
+    # Process video
+    adv_video = "adv_video.mp4"
+    process_video_frames(input_video, adv_video)
+    
+    # Merge perturbed audio with processed video
+    final_output = "final_evaded.mp4"
+    cmd = f'ffmpeg -i "{adv_video}" -i "{adv_audio}" -c:v copy -c:a aac -strict experimental -shortest -y "{final_output}"'
+    subprocess.run(cmd, shell=True)
+    
+    # Scrub metadata
+    scrub_metadata(final_output)
+    
+    # Cleanup
+    for f in [temp_audio, adv_audio, adv_video]:
+        if os.path.exists(f): os.remove(f)
+    
+    return final_output
+
+# ---------- GRADIO UI ----------
+with gr.Blocks(title="Copyright Evader v2.1") as demo:
+    gr.Markdown("## 🛡️ Wasteland Content Evader\nUpload video → get fingerprint-resistant output.")
+    with gr.Row():
+        video_input = gr.Video(label="Upload Video")
+        audio_input = gr.Audio(label="Optional Separate Audio (leave blank to extract)", type="filepath")
+    output_video = gr.Video(label="Evaded Output")
+    btn = gr.Button("🔨 Process")
+    btn.click(fn=evade_copyright, inputs=[video_input, audio_input], outputs=output_video)
+
+demo.launch(share=True)