# Crear un entorno virtual
python -m venv venv
source venv/bin/activate   # Linux/macOS
venv\Scripts\activate      # Windows

# Instalar dependencias
pip install librosa torch torchvision torchaudio scikit-learn numpy soundfile

import librosa, numpy as np

def extract_features(path):
    y, sr = librosa.load(path, sr=16000)
    # MFCC (13 coeficientes) + energía del espectro
    mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)
    rms  = librosa.feature.rms(y=y)
    # Concatenar y promediar por tiempo
    feats = np.concatenate([mfcc, rms], axis=0)
    return np.mean(feats, axis=1)

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
import glob, os

# Carpetas con ejemplos reales y deepfakes
real_paths = glob.glob('data/real/*.wav')
fake_paths = glob.glob('data/fake/*.wav')

X = [extract_features(p) for p in real_paths + fake_paths]
y = [0]*len(real_paths) + [1]*len(fake_paths)   # 0 = real, 1 = deepfake

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

clf = RandomForestClassifier(n_estimators=200, random_state=42)
clf.fit(X_train, y_train)

print('Exactitud en test:', clf.score(X_test, y_test))

{
  "manifest_version": 3,
  "name": "Detecta Deepfake de Voz",
  "description": "Analiza cualquier archivo de audio reproducido en el navegador.",
  "version": "1.0",
  "permissions": ["activeTab", "scripting", "storage"],
  "background": { "service_worker": "background.js" },
  "action": { "default_title": "Escanear audio" }
}

chrome.action.onClicked.addListener(async (tab) => {
  // Inyecta el script que captura el audio del elemento <audio> o <video>
  await chrome.scripting.executeScript({
    target: { tabId: tab.id },
    files: ['content.js']
  });
});

(async () => {
  const audioElems = document.querySelectorAll('audio, video');
  for (const el of audioElems) {
    const blob = await fetch(el.src).then(r => r.blob());
    const arrayBuffer = await blob.arrayBuffer();
    // Enviar al backend Python (puedes usar Flask + fetch)
    const resp = await fetch('http://localhost:5000/predict', {
      method: 'POST',
      body: arrayBuffer,
      headers: { 'Content-Type': 'audio/wav' }
    });
    const {probability} = await resp.json();
    if (probability > 0.7) {
      alert('⚠️ Posible deepfake detectado en este audio');
    }
  }
})();

from flask import Flask, request, jsonify
import joblib, numpy as np, soundfile as sf, io

app = Flask(__name__)
model = joblib.load('detector.pkl')

def wav_to_features(wav_bytes):
    y, sr = sf.read(io.BytesIO(wav_bytes))
    mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)
    rms = librosa.feature.rms(y=y)
    feats = np.concatenate([mfcc, rms], axis=0)
    return np.mean(feats, axis=1).reshape(1, -1)

@app.route('/predict', methods=['POST'])
def predict():
    feats = wav_to_features(request.data)
    prob = model.predict_proba(feats)[0,1]
    return jsonify({'probability': float(prob)})

if __name__ == '__main__':
    app.run(port=5000)