🎥 Analyse - Pipeline de Transcription Intelligent Jitsi avec OCR Local

pip install paddleocr paddlepaddle

from paddleocr import PaddleOCR

# Initialiser (une seule fois)
ocr = PaddleOCR(use_angle_cls=True, lang='fr', use_gpu=False)

# OCR sur une image
result = ocr.ocr('screenshot_slide.jpg', cls=True)

# Extraire le texte
text_lines = []
if result and result[0]:
    for line in result[0]:
        text = line[1][0]  # [1][0] = texte détecté
        confidence = line[1][1]  # [1][1] = score de confiance
        text_lines.append(text)

full_text = '\n'.join(text_lines)
print(full_text)

[
    [[[120, 45], [580, 45], [580, 95], [120, 95]], ('Q4 2024 Results', 0.987)],
    [[[150, 180], [520, 180], [520, 220], [150, 220]], ('Revenue: +23% YoY', 0.953)],
    [[[150, 250], [480, 250], [480, 290], [150, 290]], ('Customer growth: 45k', 0.941)]
]

# Optimisations pour screenshots de présentations
ocr = PaddleOCR(
    use_angle_cls=True,      # Correction rotation
    lang='fr',               # ou 'en' pour anglais
    use_gpu=False,           # CPU only
    show_log=False,          # Pas de logs verbeux
    det_db_thresh=0.3,       # Seuil détection texte (plus bas = plus sensible)
    det_db_box_thresh=0.6,   # Seuil bounding boxes
    rec_batch_num=6          # Batch size (augmenter si beaucoup de RAM)
)

pip install ImageHash Pillow

import imagehash
from PIL import Image
from pathlib import Path

def detect_slide_changes(frames: list[str], threshold: int = 5) -> list[int]:
    """
    Détecte les changements de slides en comparant les hashes perceptuels.

    Args:
        frames: Liste de chemins vers les images (frames extraits)
        threshold: Seuil de distance Hamming
            - 0-5  : Images quasi identiques (même slide)
            - 6-10 : Petites variations (curseur, animation)
            - 10+  : Changement significatif (nouvelle slide)

    Returns:
        Liste des indices de frames où un changement de slide est détecté

    Example:
        >>> frames = ["frame_0001.jpg", "frame_0002.jpg", ...]
        >>> changes = detect_slide_changes(frames, threshold=8)
        >>> print(changes)
        [45, 123, 289, 456]  # Nouvelles slides aux frames 45, 123, 289, 456
    """

    changes = []
    prev_hash = None

    for i, frame_path in enumerate(frames):
        img = Image.open(frame_path)

        # Générer hash perceptuel (16x16 = 256 bits)
        current_hash = imagehash.phash(img, hash_size=16)

        if prev_hash is not None:
            # Distance de Hamming = nombre de bits différents
            distance = current_hash - prev_hash

            if distance > threshold:
                changes.append(i)
                print(f"📊 Changement de slide détecté : frame {i} (distance: {distance})")

        prev_hash = current_hash

    return changes

# Cas d'usage : 1h de screenshare, 1 frame/sec = 3600 frames
frames = [f"frame_{i:04d}.jpg" for i in range(3600)]

# Détection avec seuil 8 (équilibre sensibilité/bruit)
slide_changes = detect_slide_changes(frames, threshold=8)

# Résultat typique : 30-50 changements de slides détectés
print(f"Slides détectées : {len(slide_changes)}")
# → Slides détectées : 42

# OCR uniquement sur ces 42 frames au lieu de 3600 !
for idx in slide_changes:
    ocr_result = ocr.ocr(frames[idx])
    # ... traiter résultat

# Tester différents seuils pour trouver le bon équilibre
test_frames = frames[:100]  # Tester sur 100 frames

for threshold in [5, 8, 10, 12, 15]:
    changes = detect_slide_changes(test_frames, threshold=threshold)
    print(f"Seuil {threshold:2d} → {len(changes)} changements détectés")

# Output typique :
# Seuil  5 → 23 changements détectés (trop sensible, curseur = nouveau slide)
# Seuil  8 → 12 changements détectés (bon équilibre)
# Seuil 10 → 9 changements détectés
# Seuil 12 → 7 changements détectés
# Seuil 15 → 4 changements détectés (pas assez sensible, rate des slides)

pip install scenedetect[opencv]

from scenedetect import detect, ContentDetector, AdaptiveDetector

# Détecter les coupures de scène (changement webcam ↔ screenshare)
scene_list = detect('meeting_recording.mp4', ContentDetector(threshold=30))

# scene_list = [(start_timecode, end_timecode), ...]
# Exemple :
# [
#   (00:00:00, 00:07:30),  # Scène 1 : Webcam introduction
#   (00:07:30, 00:35:12),  # Scène 2 : Screenshare présentation
#   (00:35:12, 00:40:00),  # Scène 3 : Retour webcam discussion
#   (00:40:00, 01:00:00)   # Scène 4 : Screenshare démo
# ]

for i, (start, end) in enumerate(scene_list):
    duration = (end - start).get_seconds()
    print(f"Scène {i+1}: {start} → {end} ({duration:.1f}s)")

from scenedetect import detect, ContentDetector
import cv2

# 1. Détecter les scènes
scenes = detect('meeting.mp4', ContentDetector(threshold=27))

# 2. Analyser chaque scène pour déterminer si screenshare
for i, (start, end) in enumerate(scenes):
    # Extraire 1 frame au milieu de la scène pour analyse
    mid_frame_num = (start.frame_num + end.frame_num) // 2

    cap = cv2.VideoCapture('meeting.mp4')
    cap.set(cv2.CAP_PROP_POS_FRAMES, mid_frame_num)
    ret, frame = cap.read()

    # Tester si c'est screenshare (voir section 3 ci-dessous)
    is_screen = is_screenshare_frame(frame)

    if is_screen:
        print(f"Scène {i}: {start} → {end} = SCREENSHARE ✅")
        # Extraire frames de cette scène pour ImageHash + OCR
    else:
        print(f"Scène {i}: {start} → {end} = WEBCAM ⏭️ (skip)")

/tmp/recordings/<MEETING_ID>/metadata.json

{
  "meeting_url": "https://meet.jit.si/MyRoom",
  "participants": [
    {
      "id": "abc123",
      "name": "Julien",
      "jid": "julien@meet.jit.si"
    },
    {
      "id": "def456",
      "name": "Clémence",
      "jid": "clemence@meet.jit.si"
    }
  ],
  "share": true
}

import json

def check_has_screenshare(metadata_path: str) -> bool:
    """Vérifie si la réunion a eu au moins 1 screenshare"""
    with open(metadata_path) as f:
        metadata = json.load(f)

    return metadata.get("share", False)

# Décision rapide avant traitement
if check_has_screenshare("/tmp/recordings/abc123/metadata.json"):
    print("✅ Screenshare détecté → Lancer pipeline OCR")
else:
    print("⏭️ Pas de screenshare → Skip OCR, transcription audio uniquement")

import cv2
import numpy as np
from paddleocr import PaddleOCR

# Initialiser OCR (réutilisé pour chaque frame)
ocr = PaddleOCR(use_angle_cls=False, lang='en', use_gpu=False, show_log=False)

def is_screenshare_frame(frame: np.ndarray) -> tuple[bool, float]:
    """
    Détermine si une frame est un screenshare ou une webcam.

    Args:
        frame: Image numpy array (BGR)

    Returns:
        (is_screenshare, confidence_score)

    Example:
        >>> cap = cv2.VideoCapture('meeting.mp4')
        >>> ret, frame = cap.read()
        >>> is_screen, score = is_screenshare_frame(frame)
        >>> print(f"Screenshare: {is_screen} (score: {score:.2%})")
        Screenshare: True (score: 0.34)
    """

    frame_area = frame.shape[0] * frame.shape[1]

    # ==========================
    # 1. Détection de TEXTE
    # ==========================
    # Beaucoup de texte = probablement screenshare

    result = ocr.ocr(frame, cls=False)

    text_area = 0
    if result and result[0]:
        for detection in result[0]:
            bbox = detection[0]
            # Calculer aire de la bounding box
            width = bbox[1][0] - bbox[0][0]
            height = bbox[2][1] - bbox[1][1]
            text_area += width * height

    text_ratio = text_area / frame_area

    # ==========================
    # 2. Détection de CONTOURS
    # ==========================
    # Slides = beaucoup de contours nets (bordures, séparateurs)

    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    edges = cv2.Canny(gray, 50, 150)
    edge_ratio = np.count_nonzero(edges) / frame_area

    # ==========================
    # 3. Analyse COULEUR
    # ==========================
    # UI = beaucoup de blanc/gris (backgrounds PowerPoint, Google Docs)

    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

    # Masque blanc (Saturation faible, Value élevée)
    white_mask = cv2.inRange(hsv, (0, 0, 200), (180, 30, 255))
    white_ratio = np.count_nonzero(white_mask) / frame_area

    # ==========================
    # 4. SCORE COMPOSITE
    # ==========================

    score = (
        text_ratio * 0.5 +      # 50% poids texte (critère principal)
        edge_ratio * 0.3 +      # 30% poids contours
        white_ratio * 0.2       # 20% poids blanc
    )

    # Seuil : ajuster selon tests
    # - Webcam typique : score 0.05-0.10
    # - Screenshare typique : score 0.20-0.50
    is_screenshare = score > 0.15

    return is_screenshare, score


# ==========================
# UTILISATION
# ==========================

cap = cv2.VideoCapture('meeting.mp4')
fps = cap.get(cv2.CAP_PROP_FPS)
total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

# Tester toutes les 30 frames (1 fois par seconde si 30fps)
frame_num = 0
screenshare_periods = []
current_period_start = None

while True:
    ret, frame = cap.read()
    if not ret:
        break

    if frame_num % 30 == 0:  # Tester chaque seconde
        is_screen, score = is_screenshare_frame(frame)

        timestamp = frame_num / fps

        if is_screen:
            if current_period_start is None:
                current_period_start = timestamp
                print(f"🖥️ Screenshare START à {timestamp:.1f}s (score: {score:.2%})")
        else:
            if current_period_start is not None:
                screenshare_periods.append((current_period_start, timestamp))
                print(f"📷 Screenshare END à {timestamp:.1f}s")
                current_period_start = None

    frame_num += 1

cap.release()

# Résultat : Liste de périodes screenshare
print(f"\n📊 Périodes de screenshare détectées :")
for start, end in screenshare_periods:
    duration = end - start
    print(f"  {start:.1f}s → {end:.1f}s (durée: {duration:.1f}s)")

# Exemple output :
# 📊 Périodes de screenshare détectées :
#   450.0s → 2100.0s (durée: 1650.0s = 27.5min)
#   2850.0s → 3300.0s (durée: 450.0s = 7.5min)

# Cache OCR pour éviter réinitialisation
_ocr_instance = None

def get_ocr():
    global _ocr_instance
    if _ocr_instance is None:
        _ocr_instance = PaddleOCR(use_angle_cls=False, lang='en', use_gpu=False, show_log=False)
    return _ocr_instance

# Utiliser dans is_screenshare_frame()
ocr = get_ocr()

# Tester sur échantillon connu
test_frames = {
    "webcam_julien.jpg": False,
    "slide_intro.jpg": True,
    "webcam_clemence.jpg": False,
    "slide_results.jpg": True,
    "split_screen.jpg": True  # Split screen webcam + slides = screenshare
}

for filename, expected in test_frames.items():
    frame = cv2.imread(filename)
    is_screen, score = is_screenshare_frame(frame)

    status = "✅" if is_screen == expected else "❌"
    print(f"{status} {filename}: {is_screen} (score: {score:.3f}, attendu: {expected})")

# Ajuster le seuil 0.15 si trop de faux positifs/négatifs

from scenedetect import detect, ContentDetector

# Détecter les changements de scène
scenes = detect('meeting.mp4', ContentDetector(threshold=27))

# Analyser seulement 1 frame par scène (optimisation)
for i, (start, end) in enumerate(scenes):
    # Extraire 1 frame au milieu de la scène
    mid_frame_num = (start.frame_num + end.frame_num) // 2

    cap = cv2.VideoCapture('meeting.mp4')
    cap.set(cv2.CAP_PROP_POS_FRAMES, mid_frame_num)
    ret, frame = cap.read()
    cap.release()

    # Tester avec approche 2
    is_screen, score = is_screenshare_frame(frame)

    if is_screen:
        print(f"✅ Scène {i} ({start} → {end}) = SCREENSHARE → OCR à faire")
        # Extraire frames dans cette période pour ImageHash + OCR
    else:
        print(f"⏭️ Scène {i} ({start} → {end}) = WEBCAM → Skip")

┌─────────────────────────────────┐
│  Vidéo Jibri                    │
│  meeting.mp4                    │
│  + metadata.json                │
└────────┬────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────────┐
│  ÉTAPE 1 : Vérification rapide              │
│  ─────────────────────────────              │
│  Lire metadata.json                         │
│  Si share=false → Skip OCR ⏭️              │
└────────┬────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────────┐
│  ÉTAPE 2 : Détection zones screenshare     │
│  ───────────────────────────────────────    │
│  PySceneDetect → Scènes                     │
│  Pour chaque scène :                        │
│    - Tester 1 frame mid-scene               │
│    - is_screenshare_frame() → bool          │
│  → Périodes screenshare identifiées         │
└────────┬────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────────┐
│  ÉTAPE 3 : Extraction frames screenshare   │
│  ─────────────────────────────────────────  │
│  ffmpeg extract 1 frame/sec                 │
│  SEULEMENT dans périodes screenshare        │
│  Exemple : 30min screenshare = 1800 frames  │
└────────┬────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────────┐
│  ÉTAPE 4 : Détection changements slides    │
│  ────────────────────────────────────────   │
│  ImageHash (phash) sur 1800 frames          │
│  Distance Hamming > 8 = nouvelle slide      │
│  → ~30-50 frames de slides uniques          │
└────────┬────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────────┐
│  ÉTAPE 5 : OCR local PaddleOCR             │
│  ──────────────────────────────────────     │
│  OCR sur 30-50 slides uniques               │
│  Extraction texte + structure               │
│  Temps : ~15 secondes (CPU)                 │
└────────┬────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────────┐
│  ÉTAPE 6 : Fusion avec transcription       │
│  ────────────────────────────────────────   │
│  Transcription audio (faster-whisper)       │
│  + Diarization (pyannote)                   │
│  + Texte OCR avec timestamps                │
│  → Transcription enrichie complète          │
└─────────────────────────────────────────────┘

Vidéo 1h (3600 frames @ 1fps)
         │
         ├─→ metadata.json: share=true ✅
         │
         ▼
   PySceneDetect
         │
         ├─→ Scène 1 (0-450s) : Webcam ⏭️ SKIP
         ├─→ Scène 2 (450-2100s) : Screenshare ✅ → 1650 frames
         ├─→ Scène 3 (2100-2850s) : Webcam ⏭️ SKIP
         └─→ Scène 4 (2850-3300s) : Screenshare ✅ → 450 frames
         │
         ▼
   Extract frames (2100 frames total)
         │
         ▼
   ImageHash perceptual diff
         │
         ├─→ Frame 450 : Hash A
         ├─→ Frame 451 : Hash A (distance=2) → SKIP
         ├─→ Frame 452 : Hash A (distance=1) → SKIP
         ├─→ ...
         ├─→ Frame 498 : Hash B (distance=12) → ✅ NOUVELLE SLIDE
         ├─→ Frame 499 : Hash B (distance=3) → SKIP
         └─→ ...
         │
         ▼
   30-50 slides uniques identifiées
         │
         ▼
   PaddleOCR (30-50 fois)
         │
         ▼
   Texte structuré par slide

# OCR
pip install paddleocr==2.7.3
pip install paddlepaddle==2.6.0  # CPU version

# Détection changement slides
pip install ImageHash==4.3.1
pip install Pillow==10.2.0

# Détection scènes
pip install scenedetect[opencv]==0.6.3

# Traitement vidéo
pip install opencv-python==4.9.0.80

# Utilitaires
pip install numpy

paddleocr==2.7.3
paddlepaddle==2.6.0
ImageHash==4.3.1
Pillow==10.2.0
scenedetect[opencv]==0.6.3
opencv-python==4.9.0.80
numpy>=1.24.0

# Remplacer paddlepaddle CPU par GPU
pip uninstall paddlepaddle
pip install paddlepaddle-gpu  # Nécessite CUDA