Commentaire dans le main refait, url ytb, innovation

jericho/main.py

@@ -1,43 +1,44 @@
-import json
-import time
-import threading
-import math
-import os
-import base64
-import numpy as np
-import sys
-import subprocess
-import shutil  
-import bisect
-from pydantic import BaseModel
+import json # pour lire ecrire json
+import time # gestion du temps
+import threading # multi-taches
+import math # fct maths
+import os # gestion dossiers
+import base64 # decodage video base64
+import numpy as np # calculs vectors
+import sys # acces syst
+import subprocess # lance prog externes
+import shutil # suppr dossiers 
+import bisect # rech rapide liste triee
+from pydantic import BaseModel # structure donnees api
 
 
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import FileResponse
-from fastapi import HTTPException, BackgroundTasks
+from fastapi.staticfiles import StaticFiles # sert fichiers statics
+from fastapi.responses import FileResponse # sert index html
+from fastapi import HTTPException, BackgroundTasks # gestion err et taches fond
 
 
-from reachy_mini import ReachyMini, ReachyMiniApp
-from reachy_mini.utils import create_head_pose
+from reachy_mini import ReachyMini, ReachyMiniApp # import brique robot
+from reachy_mini.utils import create_head_pose # fct pose tete
 
 
-def load_signals(path: str) -> tuple[dict, list[dict]]:
+def load_signals(path: str) -> tuple[dict, list[dict]]: # chargement signaux json
     with open(path, "r", encoding="utf-8") as f:
         data = json.load(f)
-    meta = {k: v for k, v in data.items() if k != "frames"}
-    frames = [fr for fr in data["frames"] if fr.get("face_detected", False)]
+    meta = {k: v for k, v in data.items() if k != "frames"} # recup infos hors frames
+    frames = [fr for fr in data["frames"] if fr.get("face_detected", False)] # garde frames avec visage
     print(f"[Chargement] {len(frames)} frames avec visage.")
     return meta, frames
 
-def moving_average(values: list[float], window: int = 7) -> np.ndarray:
+def moving_average(values: list[float], window: int = 7) -> np.ndarray: # fct lissage signaux
     arr = np.asarray(values, dtype=float)
     pad = window // 2
-    padded = np.pad(arr, pad_width=pad, mode="edge")
+    padded = np.pad(arr, pad_width=pad, mode="edge") # evite bords vides
     kernel = np.ones(window) / window
-    smoothed = np.convolve(padded, kernel, mode="valid")
+    smoothed = np.convolve(padded, kernel, mode="valid") # calcul moyenne glissante
     return smoothed[: len(arr)]
 
-class SignalMapper:
+class SignalMapper: # classe map signaux visage vers robot
+    # constantes limites angles robot
     HEAD_YAW_MAX        = np.deg2rad(5)
     HEAD_PITCH_MAX      = np.deg2rad(15)
     HEAD_ROLL_MAX       = np.deg2rad(15)
@@ -49,6 +50,7 @@ class SignalMapper:
     ANTENNA_MAX_col     = np.deg2rad(110)
     COMBINED_YAW_LIMIT  = np.deg2rad(60)
 
+    # multiplicateurs amplifs mouvements
     YAW_AMP        = 8.0
     PITCH_AMP      = 5.0
     ROLL_AMP       = 3.0
@@ -56,15 +58,16 @@ class SignalMapper:
     CX_TO_BODY_YAW = 0.8
     CY_TO_Z_SCALE  = -0.10
 
+    # fenetres lissage
     SMOOTH_WINDOW_HEAD    = 7
     SMOOTH_WINDOW_EMOTION = 11
 
     def __init__(self, frames: list[dict]):
         self.frames = frames
-        self._compute_baselines()
-        self.commands = self._build_commands()
+        self._compute_baselines() # calcul moyennes ref
+        self.commands = self._build_commands() # genere coms robot
 
-    def _compute_baselines(self):
+    def _compute_baselines(self): # fct valeurs moyennes tte la video
         def mean(key, calc_func=None):
             if calc_func: return float(np.mean([calc_func(f) for f in self.frames]))
             return float(np.mean([f[key] for f in self.frames]))
@@ -72,6 +75,7 @@ class SignalMapper:
             if calc_func: return max(float(np.std([calc_func(f) for f in self.frames])), 1e-6)
             return max(float(np.std([f[key] for f in self.frames])), 1e-6)
 
+        # calcul refs pour chaque signal
         self.yaw_mean   = mean("yaw")
         self.pitch_mean = mean("pitch")
         self.roll_mean  = mean("roll")
@@ -88,13 +92,15 @@ class SignalMapper:
         self.mar_mean = mean("mar")
         self.mar_std  = std("mar")
 
-    def _detect_emotion(self, smile, ear, mar, brow_raise, brow_furrow):
+    def _detect_emotion(self, smile, ear, mar, brow_raise, brow_furrow): # fct regles pr emotions
+        # calcul ecarts par rapport ref
         n_smile       = (smile - self.smile_mean) / self.smile_std
         n_ear         = (ear - self.ear_mean) / self.ear_std
         n_mar         = (mar - self.mar_mean) / self.mar_std
         n_brow_raise  = (brow_raise - self.brow_raise_mean) / self.brow_raise_std
         n_brow_furrow = (brow_furrow - self.brow_furrow_mean) / self.brow_furrow_std
 
+        # conditions choix emotions selon visage
         if n_brow_raise > 0.8 and n_ear > 0.8: return "SURPRISE"
         if n_brow_raise < -0.5 and n_smile < -0.5: return "COLERE"
         if n_brow_raise < -0.3 and n_ear < -0.5: return "TRISTESSE"
@@ -103,7 +109,7 @@ class SignalMapper:
         if n_smile > 0.3: return "CONTENT"
         return "NEUTRE"
         
-    def _colere(self, t_state):
+    def _colere(self, t_state): # bouge antennes mode colere
         if t_state < 0.15:
             angle = -1.0 * (t_state / 0.15) * self.ANTENNA_MAX_col
         elif t_state < 0.40:
@@ -114,34 +120,34 @@ class SignalMapper:
             angle = -1.0 * self.ANTENNA_MAX_col
         return angle, -angle
 
-    def _tristesse(self, t_state):
+    def _tristesse(self, t_state): # bouge antennes mode tristesse
         target_angle = -1.0 * (1.0 - math.exp(-1.5 * t_state)) * self.ANTENNA_MAX
         return (target_angle - 0.2), -(target_angle - 0.2)
 
-    def _joie(self, t_state):
+    def _joie(self, t_state): # bouge antennes mode joie (vibre)
         oscillation = 0.5 * math.sin(2 * math.pi * 4.0 * t_state)
         angle = (0.5 + oscillation) * self.ANTENNA_MAX_alt
         return -angle, angle
 
-    def _content(self, t_state):
+    def _content(self, t_state): # bouge antennes mode content
         oscillation = 0.8 * math.sin(2 * math.pi * 0.5 * t_state)
         angle = oscillation * self.ANTENNA_MAX_alt
         return angle, angle
 
-    def _surprise(self, t_state):
+    def _surprise(self, t_state): # bouge antennes mode surprise
         angle = 1.0 * (1.0 - math.exp(-14.0 * t_state)) * self.ANTENNA_MAX_alt
         return -(angle - 0.8), (angle - 0.8)
 
-    def _neutre(self, t_state):
+    def _neutre(self, t_state): # bouge antennes mode neutre
         angle = 1.0 * (1.0 - math.exp(-14.0 * t_state)) * self.ANTENNA_MAX_alt
         return -(angle - 0.3), (angle - 0.3)
 
-    def _peur(self, t_state):
+    def _peur(self, t_state): # bouge antennes mode peur (tremble)
         tremblement = 0.1 * math.sin(2 * math.pi * 15.0 * t_state)
         angle = -1.0 * (1.0 - math.exp(-1.5 * t_state) + tremblement) * self.ANTENNA_MAX
         return (angle - 0.2), -(angle - 0.2)
 
-    def _compute_antennas(self, emotion, t_state):
+    def _compute_antennas(self, emotion, t_state): # fct select mvt selon emotion
         if emotion == "TRISTESSE":
             return self._tristesse(t_state)
         elif emotion == "JOIE":
@@ -157,15 +163,10 @@ class SignalMapper:
         elif emotion == "PEUR":
             return self._peur(t_state)
         else:
-    
             angle = -1.0 * self.ANTENNA_MAX_col
             return angle, -angle
 
-
-
-    
-
-    def _build_commands(self) -> list[dict]:
+    def _build_commands(self) -> list[dict]: # assemble signaux en tab commandes
         n = len(self.frames)
         raw_yaw    = np.array([f["yaw"]   - self.yaw_mean   for f in self.frames])
         raw_pitch  = np.array([f["pitch"] - self.pitch_mean for f in self.frames])
@@ -181,6 +182,7 @@ class SignalMapper:
         w_h = self.SMOOTH_WINDOW_HEAD
         w_e = self.SMOOTH_WINDOW_EMOTION
 
+        # applique fct lissage
         s_yaw    = moving_average(raw_yaw,   w_h)
         s_pitch  = moving_average(raw_pitch, w_h)
         s_roll   = moving_average(raw_roll,  w_h)
@@ -197,9 +199,10 @@ class SignalMapper:
         current_emotion = "NEUTRE"
         emotion_start_time = 0.0
 
-        for i in range(n):
+        for i in range(n): # boucle pr chaque image
             t = self.frames[i]["timestamp_s"]
 
+            # mise a echelle + clamp pos tete
             head_yaw   = self._clamp(np.deg2rad(s_yaw[i] * self.YAW_AMP), self.HEAD_YAW_MAX)
             head_pitch = self._clamp(np.deg2rad(s_pitch[i] * self.PITCH_AMP), self.HEAD_PITCH_MAX)
             head_roll  = self._clamp(np.deg2rad(s_roll[i] * self.ROLL_AMP), self.HEAD_ROLL_MAX)
@@ -207,22 +210,23 @@ class SignalMapper:
             head_z = self._clamp(s_cy[i] * self.CY_TO_Z_SCALE, self.HEAD_Z_MAX)
             body_yaw = self._clamp(s_cx[i] * self.CX_TO_BODY_YAW, self.BODY_YAW_MAX)
 
-            diff = body_yaw - head_yaw
+            diff = body_yaw - head_yaw # verif coherence corps cou
             if abs(diff) > self.COMBINED_YAW_LIMIT:
                 body_yaw = head_yaw + np.sign(diff) * self.COMBINED_YAW_LIMIT
 
+            # trouve emotion frame
             detected_emotion = self._detect_emotion(
                 s_smile[i], s_ear[i], s_mar[i], s_brow_raise[i], s_brow_furrow[i]
             )
 
-            if detected_emotion != current_emotion:
+            if detected_emotion != current_emotion: # top chrono si changmt emo
                 current_emotion = detected_emotion
                 emotion_start_time = t
 
             t_state = t - emotion_start_time
-            ant_left, ant_right = self._compute_antennas(current_emotion, t_state)
+            ant_left, ant_right = self._compute_antennas(current_emotion, t_state) # calcul mvt antennes
 
-            commands.append({
+            commands.append({ # ajoute com dico complet
                 "timestamp_s": round(t, 4),
                 "head": {
                     "x":     0.0,
@@ -242,23 +246,232 @@ class SignalMapper:
         return commands
 
     @staticmethod
-    def _clamp(value: float, limit: float) -> float:
+    def _clamp(value: float, limit: float) -> float: # limite valeurs min max
         return float(max(-limit, min(limit, value)))
 
 
-class VideoPayload(BaseModel):
+class VideoPayload(BaseModel): # struct payload upload video web
     name: str
     file_data: str
 
-class PlaybackPayload(BaseModel):
+class SequenceItem(BaseModel): # struct element pr list emotion cree
+    emotion: str
+    duration: float
+
+class SequencePayload(BaseModel): # struct payload pack sequence cree
+    name: str
+    sequence: list[SequenceItem]
+
+class YouTubePayload(BaseModel): # struct payload upload yt web
+    name: str
+    url: str
+
+class PlaybackPayload(BaseModel): # struct payload synchro lecture
     project_name: str | None = None
     current_time: float = 0.0
     playing: bool | None = None
     action: str = "sync"
 
-class Jericho(ReachyMiniApp):
+class RobotAudioStreamer: # classe envoi audio robot
+    SAMPLE_RATE = 16000
+    CHANNELS = 2
+    CHUNK_SECONDS = 0.08
+    QUEUE_AHEAD_SECONDS = 0.20
+    RESYNC_THRESHOLD_SECONDS = 0.25
+
+    def __init__(self, app: "Jericho"):
+        self.app = app
+        self.audio_cache: dict[str, np.ndarray] = {} # stock memoire sons charges
+        self.current_project: str | None = None
+        self.next_push_time = 0.0
+        self.output_started = False
+        self.last_state_signature = None
+        self.last_dirty_updated_at = None
+        self.last_playing = False
+        self.audio_available = True
+
+    def _project_video_path(self, project_name: str) -> str: # recup lien video mp4
+        return os.path.join(self.app.projects_dir, project_name, "output_annotated.mp4")
+
+    def _load_audio(self, project_name: str) -> np.ndarray: # extrait son via ffmpeg pipe
+        if project_name in self.audio_cache:
+            return self.audio_cache[project_name]
+
+        video_path = self._project_video_path(project_name)
+        if not os.path.exists(video_path):
+            self.audio_cache[project_name] = np.zeros((0, self.CHANNELS), dtype=np.float32)
+            return self.audio_cache[project_name]
+
+        cmd = [ # params ffmpeg pr recup format brut wav float
+            "ffmpeg", "-v", "error",
+            "-i", video_path,
+            "-vn",
+            "-ac", str(self.CHANNELS),
+            "-ar", str(self.SAMPLE_RATE),
+            "-f", "f32le",
+            "pipe:1",
+        ]
+
+        try:
+            process = subprocess.run(cmd, capture_output=True, check=True)
+            audio = np.frombuffer(process.stdout, dtype=np.float32)
+            if audio.size == 0:
+                samples = np.zeros((0, self.CHANNELS), dtype=np.float32)
+            else:
+                usable = audio.size - (audio.size % self.CHANNELS)
+                samples = audio[:usable].reshape(-1, self.CHANNELS).astype(np.float32, copy=False)
+        except Exception as exc:
+            print(f"[Audio robot] Audio indisponible pour {project_name}: {exc}")
+            samples = np.zeros((0, self.CHANNELS), dtype=np.float32)
+
+        self.audio_cache[project_name] = samples
+        return samples
+
+    def _media(self, reachy_mini: ReachyMini): # racourci module son reachy
+        return getattr(reachy_mini, "media", None)
+
+    def _start_output(self, reachy_mini: ReachyMini): # lance le player reachy
+        if self.output_started or not self.audio_available:
+            return
+
+        media = self._media(reachy_mini)
+        if media is None:
+            self.audio_available = False
+            print("[Audio robot] Backend média non disponible : audio robot désactivé.")
+            return
+
+        try:
+            media.start_playing()
+            for obj in (media, getattr(media, "audio", None)):
+                if obj is not None and hasattr(obj, "set_max_output_buffers"):
+                    obj.set_max_output_buffers(3) # limite latence tampons
+            self.output_started = True
+        except Exception as exc:
+            self.audio_available = False
+            print(f"[Audio robot] Impossible de démarrer la sortie audio : {exc}")
+
+    def _flush_output(self, reachy_mini: ReachyMini): # vide tampons audio si saut
+        media = self._media(reachy_mini)
+        if media is None or not self.output_started:
+            return
+
+        flushed = False
+        for obj in (media, getattr(media, "audio", None)):
+            if obj is None:
+                continue
+            for method_name in ("clear_player", "clear_output_buffer"):
+                method = getattr(obj, method_name, None)
+                if callable(method):
+                    try:
+                        method()
+                        flushed = True
+                    except Exception:
+                        pass
+
+        if not flushed:
+            try:
+                media.stop_playing()
+                media.start_playing()
+            except Exception:
+                pass
+
+    def _stop_output(self, reachy_mini: ReachyMini): # stoppe audio reachy
+        media = self._media(reachy_mini)
+        if media is None or not self.output_started:
+            return
+
+        try:
+            self._flush_output(reachy_mini)
+            media.stop_playing()
+        except Exception:
+            pass
+        finally:
+            self.output_started = False
+
+    def _push_chunk(self, reachy_mini: ReachyMini, samples: np.ndarray, start_time: float) -> bool: # injecte bloc son robot
+        if samples.size == 0:
+            return False
+
+        start_idx = max(0, int(start_time * self.SAMPLE_RATE))
+        chunk_len = max(1, int(self.CHUNK_SECONDS * self.SAMPLE_RATE))
+        end_idx = min(start_idx + chunk_len, len(samples))
+        if start_idx >= len(samples) or end_idx <= start_idx:
+            return False
+
+        chunk = samples[start_idx:end_idx]
+        try:
+            media = self._media(reachy_mini)
+            if media is None:
+                return False
+            media.push_audio_sample(chunk.astype(np.float32, copy=False)) # pousse echantillons reachy
+            self.next_push_time = end_idx / self.SAMPLE_RATE
+            return True
+        except Exception as exc:
+            print(f"[Audio robot] push_audio_sample a échoué : {exc}")
+            self.audio_available = False
+            return False
+
+    def update(self, reachy_mini: ReachyMini, state: dict, stop_event: threading.Event): # synchro continue flux son
+        if stop_event.is_set() or not self.audio_available:
+            return
+
+        project_name = state.get("project_name")
+        playing = bool(state.get("playing", False))
+        updated_at = float(state.get("updated_at", time.time()))
+        current_time = max(0.0, float(state.get("current_time", 0.0)))
+
+        dirty = bool(state.get("dirty", False))
+        signature = (project_name, playing)
+
+        if not project_name or not playing:
+            if self.last_playing:
+                self._flush_output(reachy_mini)
+            self.last_playing = False
+            self.last_state_signature = signature
+            return
+
+        samples = self._load_audio(project_name)
+        if samples.size == 0:
+            self.last_playing = playing
+            self.last_state_signature = signature
+            return
+
+        self._start_output(reachy_mini)
+        if not self.output_started:
+            return
+
+        target_time = current_time + (time.time() - updated_at) # prend en compte delai reseau
+        target_time = max(0.0, min(target_time, len(samples) / self.SAMPLE_RATE))
+
+        must_reposition = ( # check si besoin repositionner lecture son
+            project_name != self.current_project
+            or (playing and not self.last_playing)
+            or (dirty and self.last_dirty_updated_at != updated_at)
+        )
+        if must_reposition:
+            self.current_project = project_name
+            self.next_push_time = target_time
+            self.last_dirty_updated_at = updated_at
+            self._flush_output(reachy_mini)
+
+        if abs(self.next_push_time - target_time) > self.RESYNC_THRESHOLD_SECONDS: # verif si decalage trop gros
+            self.next_push_time = target_time
+            self._flush_output(reachy_mini)
+
+        while ( # rempli tampon avance
+            not stop_event.is_set()
+            and self.next_push_time < target_time + self.QUEUE_AHEAD_SECONDS
+        ):
+            if not self._push_chunk(reachy_mini, samples, self.next_push_time):
+                break
+
+        self.last_playing = playing
+        self.last_state_signature = signature
+
+
+class Jericho(ReachyMiniApp): # appli principale serveur app backend
     custom_app_url: str | None = "http://0.0.0.0:8042"
-    request_media_backend: str | None = None
+    request_media_backend: str | None = "default"
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -266,11 +479,13 @@ class Jericho(ReachyMiniApp):
         self.antennas_enabled = True
         self.sound_play_requested = False
         self.play_robot_requested = False
+        self.manual_emotion = None          
+        self.manual_emotion_lock = threading.Lock() # verrou pr modifs interfs
         self.current_commands = []
         self.current_timestamps = []
         self.current_project_name = None
-        self.playback_lock = threading.Lock()
-        self.playback_state = {
+        self.playback_lock = threading.Lock() # verrou securite thread mvt
+        self.playback_state = { # infos etat lecture courante
             "project_name": None,
             "playing": False,
             "current_time": 0.0,
@@ -284,10 +499,11 @@ class Jericho(ReachyMiniApp):
         os.makedirs(self.projects_dir, exist_ok=True)
         self.static_dir = os.path.join(self.current_dir, "static")
 
-        self._setup_routes()
+        self.robot_audio = RobotAudioStreamer(self) # init streamer audio
+
+        self._setup_routes() # configure routes fastapi
 
-    def _load_project_commands(self, project_name: str) -> int:
-       
+    def _load_project_commands(self, project_name: str) -> int: # charge coms json en cache
         with self.playback_lock:
             if project_name == self.current_project_name and self.current_commands:
                 return len(self.current_commands)
@@ -296,22 +512,31 @@ class Jericho(ReachyMiniApp):
         if not os.path.exists(signals_path):
             raise HTTPException(status_code=404, detail="Fichier signals.json introuvable.")
 
-        meta, frames = load_signals(signals_path)
-        if not frames:
-            raise HTTPException(status_code=400, detail="Aucune frame avec visage dans signals.json.")
-
-        mapper = SignalMapper(frames)
-        commands = mapper.commands
-        timestamps = [cmd["timestamp_s"] for cmd in commands]
-
-        with self.playback_lock:
+        with open(signals_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+
+        if data.get("type") == "creation": # check si sequence creee a la main
+            commands = data.get("commands", [])
+            timestamps = [cmd["timestamp_s"] for cmd in commands]
+        else: # sinon charge video ia classique
+            meta, frames = load_signals(signals_path)
+            if not frames:
+                raise HTTPException(status_code=400, detail="Aucune frame avec visage dans signals.json.")
+            mapper = SignalMapper(frames)
+            commands = mapper.commands
+            timestamps = [cmd["timestamp_s"] for cmd in commands]
+
+        with self.playback_lock: # stocke listes pr thread mvt
             self.current_project_name = project_name
             self.current_commands = commands
             self.current_timestamps = timestamps
 
         return len(commands)
 
-    def _set_playback_state(self, project_name: str | None, current_time: float, playing: bool, *, dirty: bool = True, stop_requested: bool = False):
+    def _set_playback_state(self, project_name: str | None, current_time: float, playing: bool, *, dirty: bool = True, stop_requested: bool = False): # fct modif etat lecture safely
+        if playing:
+            with self.manual_emotion_lock:
+                self.manual_emotion = None # coupe emotion manuelle si play video
         with self.playback_lock:
             self.playback_state.update({
                 "project_name": project_name,
@@ -322,16 +547,16 @@ class Jericho(ReachyMiniApp):
                 "stop_requested": stop_requested,
             })
 
-    def _setup_routes(self):
+    def _setup_routes(self): # routes api web fastapi
         if os.path.exists(self.static_dir):
             self.settings_app.mount("/static", StaticFiles(directory=self.static_dir), name="static")
         self.settings_app.mount("/projects", StaticFiles(directory=self.projects_dir), name="projects")
 
-        @self.settings_app.get("/")
+        @self.settings_app.get("/") # sert page html principale
         def serve_index():
             return FileResponse(os.path.join(self.static_dir, "index.html"))
 
-        def process_in_background(video_path: str, proj_path: str, proj_name: str):
+        def process_in_background(video_path: str, proj_path: str, proj_name: str): # fct fond run script ia
             status_file = os.path.join(proj_path, "status.txt")
             try:
                 with open(status_file, "w") as f: f.write("PROCESSING")
@@ -339,13 +564,12 @@ class Jericho(ReachyMiniApp):
                 
                 emotion_script = os.path.join(self.current_dir, "emotion.py")
                 
-                process = subprocess.run(
+                process = subprocess.run( # lance script emotion.py avec arguments 
                     [sys.executable, emotion_script, "--video", video_path, "--output_dir", proj_path],
                     capture_output=True, text=True
                 )
                 
                 if process.returncode == 0:
-                    
                     signals_path = os.path.join(proj_path, "signals.json")
                     valid_project = False
                     
@@ -354,10 +578,8 @@ class Jericho(ReachyMiniApp):
                             with open(signals_path, "r", encoding="utf-8") as f:
                                 data = json.load(f)
                             frames = [fr for fr in data.get("frames", []) if fr.get("face_detected", False)]
-                            
-                           
                             if frames and (frames[-1]["timestamp_s"] - frames[0]["timestamp_s"] >= 1.0):
-                                valid_project = True
+                                valid_project = True # valide si visage tps min 1s
                         except Exception:
                             valid_project = False
 
@@ -365,11 +587,9 @@ class Jericho(ReachyMiniApp):
                         with open(status_file, "w") as f: f.write("DONE")
                         print(f"[{proj_name}] Analyse terminée avec succès !")
                     else:
-                      
                         output_video = os.path.join(proj_path, "output_annotated.mp4")
                         if os.path.exists(output_video):
                             os.remove(output_video)
-                            
                         with open(status_file, "w") as f: f.write("ERROR: NO_FACE_DETECTED")
                         print(f"[{proj_name}]  Rejeté : pas de visage detecté")
                 else:
@@ -383,7 +603,8 @@ class Jericho(ReachyMiniApp):
                 error_msg = f"ERROR: {type(e).__name__} - {str(e)}"
                 with open(status_file, "w") as f: f.write(error_msg)
                 print(f"[{proj_name}]  Exception système : {error_msg}")
-        @self.settings_app.post("/api/upload")
+
+        @self.settings_app.post("/api/upload") # endpoint reception video upload web
         def upload_video(payload: VideoPayload, bg_tasks: BackgroundTasks):
             project_path = os.path.join(self.projects_dir, payload.name)
             os.makedirs(project_path, exist_ok=True)
@@ -391,12 +612,124 @@ class Jericho(ReachyMiniApp):
             
             header, encoded = payload.file_data.split(",", 1) if "," in payload.file_data else ("", payload.file_data)
             with open(input_video_path, "wb") as f:
-                f.write(base64.b64decode(encoded))
+                f.write(base64.b64decode(encoded)) # decode et save mp4
             
             bg_tasks.add_task(process_in_background, input_video_path, project_path, payload.name)
             return {"status": "accepted"}
 
-        @self.settings_app.get("/api/library")
+        def download_and_process_youtube(url: str, proj_path: str, proj_name: str): # fct fond recup video youtube
+            status_file = os.path.join(proj_path, "status.txt")
+            input_video_path = os.path.join(proj_path, "input.mp4")
+            try:
+                with open(status_file, "w") as f:
+                    f.write("DOWNLOADING")
+                print(f"[{proj_name}] Téléchargement YouTube : {url}")
+
+                cmd = [ # params yt-dlp pr dl format mp4 direct
+                    "yt-dlp",
+                    "-f", "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best",
+                    "--merge-output-format", "mp4",
+                    "--no-playlist",
+                    "--no-overwrites",
+                    "-o", input_video_path,
+                    url,
+                ]
+                result = subprocess.run(cmd, capture_output=True, text=True, timeout=600)
+
+                if result.returncode != 0:
+                    err = result.stderr.strip().split('\n')[-1] if result.stderr.strip() else "Échec yt-dlp"
+                    with open(status_file, "w") as f:
+                        f.write(f"ERROR: Téléchargement échoué. {err}")
+                    print(f"[{proj_name}] Erreur yt-dlp : {err}")
+                    return
+
+                if not os.path.exists(input_video_path):
+                    with open(status_file, "w") as f:
+                        f.write("ERROR: Fichier vidéo introuvable après téléchargement.")
+                    return
+
+                print(f"[{proj_name}] Téléchargement terminé, lancement de l'analyse...")
+                process_in_background(input_video_path, proj_path, proj_name) # enchaîne sur ia visage
+
+            except subprocess.TimeoutExpired:
+                with open(status_file, "w") as f:
+                    f.write("ERROR: Téléchargement trop long (timeout 10 min).")
+                print(f"[{proj_name}] Timeout téléchargement YouTube.")
+            except Exception as e:
+                error_msg = f"ERROR: {type(e).__name__} - {str(e)}"
+                with open(status_file, "w") as f:
+                    f.write(error_msg)
+                print(f"[{proj_name}] Exception YouTube : {error_msg}")
+
+        @self.settings_app.post("/api/upload_youtube") # endpoint dl video youtube
+        def upload_youtube(payload: YouTubePayload, bg_tasks: BackgroundTasks):
+            name = payload.name.strip()
+            url = payload.url.strip()
+
+            if not name:
+                raise HTTPException(status_code=400, detail="Nom du projet requis.")
+            if not url:
+                raise HTTPException(status_code=400, detail="URL requise.")
+
+            project_path = os.path.join(self.projects_dir, name)
+            os.makedirs(project_path, exist_ok=True)
+
+            status_file = os.path.join(project_path, "status.txt")
+            with open(status_file, "w") as f:
+                f.write("DOWNLOADING")
+
+            bg_tasks.add_task(download_and_process_youtube, url, project_path, name)
+            return {"status": "accepted"}
+        
+        @self.settings_app.post("/api/create_sequence") # endpoint genere sequence manuelle
+        def create_sequence(payload: SequencePayload):
+            name = payload.name.strip()
+            if not name:
+                raise HTTPException(status_code=400, detail="Nom du projet requis.")
+
+            project_path = os.path.join(self.projects_dir, name)
+            os.makedirs(project_path, exist_ok=True)
+
+            commands = []
+            t = 0.0
+            fps = 30 # standard 30fps simulation
+            
+            mapper = object.__new__(SignalMapper) # recup fct maths via instance factice
+
+            for item in payload.sequence: # loop ds bloc emotions recu
+                emo = item.emotion.upper()
+                frames_count = int(item.duration * fps)
+                
+                for i in range(frames_count):
+                    t_state = i / fps
+                    try:
+                        ant_left, ant_right = mapper._compute_antennas(emo, t_state) # math antennes
+                    except Exception:
+                        ant_left, ant_right = 0.0, 0.0
+                        
+                    commands.append({ # cree frame robot static
+                        "timestamp_s": round(t, 4),
+                        "head": {"x": 0.0, "y": 0.0, "z": 0.0, "roll": 0.0, "pitch": 0.0, "yaw": 0.0},
+                        "body_yaw": 0.0,
+                        "antennas": [
+                            round(float(SignalMapper._clamp(ant_left, SignalMapper.ANTENNA_MAX)), 5),
+                            round(float(SignalMapper._clamp(ant_right, SignalMapper.ANTENNA_MAX)), 5)
+                        ],
+                        "emotion": emo
+                    })
+                    t += 1.0 / fps
+
+            signals_path = os.path.join(project_path, "signals.json")
+            with open(signals_path, "w", encoding="utf-8") as f:
+                json.dump({"type": "creation", "commands": commands}, f, indent=2) # save format secu
+
+            status_file = os.path.join(project_path, "status.txt")
+            with open(status_file, "w") as f:
+                f.write("CREATION_DONE") # flag type creation dispo bibliothèque
+
+            return {"status": "accepted"}
+
+        @self.settings_app.get("/api/library") # endpoint liste videos dispo
         def get_library():
             projects = []
             for folder in os.listdir(self.projects_dir):
@@ -408,7 +741,13 @@ class Jericho(ReachyMiniApp):
                         with open(status_path, "r") as f:
                             status = f.read().strip()
                     
-                    if os.path.exists(os.path.join(folder_path, "output_annotated.mp4")):
+                    if status == "CREATION_DONE": # charge sans lien mp4
+                        projects.append({
+                            "name": folder,
+                            "url": None,
+                            "status": "CREATION_DONE"
+                        })
+                    elif os.path.exists(os.path.join(folder_path, "output_annotated.mp4")):
                         projects.append({
                             "name": folder,
                             "url": f"/projects/{folder}/output_annotated.mp4",
@@ -422,23 +761,31 @@ class Jericho(ReachyMiniApp):
                         })
             return projects
 
-        
-        @self.settings_app.delete("/api/projects/{project_name}")
+        @self.settings_app.delete("/api/projects/{project_name}") # endpoint suppr dossier projet
         def delete_project(project_name: str):
-           
             project_path = os.path.join(self.projects_dir, project_name)
             if os.path.exists(project_path) and os.path.isdir(project_path):
                 try:
                     shutil.rmtree(project_path)
+                    self.robot_audio.audio_cache.pop(project_name, None) # vide cache du projet
                     print(f"[{project_name}] Projet supprimé avec succès.")
                     return {"status": "success"}
                 except Exception as e:
                     raise HTTPException(status_code=500, detail=f"Erreur de suppression: {str(e)}")
             raise HTTPException(status_code=404, detail="Projet introuvable.")
 
-        @self.settings_app.post("/api/playback")
+        class EmotionPayload(BaseModel):
+            emotion: str | None = None 
+
+        @self.settings_app.post("/api/emotion") # endpoint clic bouton manuel web
+        def set_emotion(payload: EmotionPayload):
+            emotion = (payload.emotion or "").strip().upper() or None
+            with self.manual_emotion_lock:
+                self.manual_emotion = emotion # update emotion active globale
+            return {"status": "ok", "emotion": emotion}
+
+        @self.settings_app.post("/api/playback") # endpoint controle synchro video web
         def sync_playback(payload: PlaybackPayload):
-          
             action = (payload.action or "sync").lower()
             project_name = payload.project_name or self.current_project_name
             current_time = max(0.0, float(payload.current_time or 0.0))
@@ -475,9 +822,8 @@ class Jericho(ReachyMiniApp):
             self._set_playback_state(project_name, current_time, playing, dirty=dirty, stop_requested=False)
             return {"status": "ok", "action": action, "commands_loaded": commands_loaded}
 
-        @self.settings_app.post("/api/play_movement/{project_name}")
+        @self.settings_app.post("/api/play_movement/{project_name}") # route pr lancer direct mvt
         def trigger_movement(project_name: str):
-            
             try:
                 commands_loaded = self._load_project_commands(project_name)
                 self._set_playback_state(project_name, 0.0, True, dirty=True, stop_requested=False)
@@ -487,17 +833,113 @@ class Jericho(ReachyMiniApp):
             except Exception as e:
                 raise HTTPException(status_code=500, detail=str(e))
 
-    def run(self, reachy_mini: ReachyMini, stop_event: threading.Event):
-        reachy_mini.goto_target(create_head_pose(), antennas=[0.0, 0.0], duration=1.0)
+    def _run_manual_emotion_loop(self, reachy_mini: ReachyMini, stop_event: threading.Event): # boucle thread mvt bouton manuel
+        ANTENNA_MAX     = np.deg2rad(120)
+        ANTENNA_MAX_alt = np.deg2rad(45)
+        ANTENNA_MAX_col = np.deg2rad(110)
+        COLERE_PERIOD   = 5.0   
+        COLERE_ANIM     = 1.0   
+
+        current = None
+        t_start = time.time()
+        colere_last = 0.0
+
+        while not stop_event.is_set():
+            with self.manual_emotion_lock:
+                emotion = self.manual_emotion
+            with self.playback_lock:
+                video_playing = bool(self.playback_state.get("playing", False))
+
+            if video_playing or emotion is None: # skip si lecture video on
+                current = None
+                time.sleep(0.05)
+                continue
+
+            if emotion != current: # demarre decompte temps si modif
+                current = emotion
+                t_start = time.time()
+                colere_last = time.time() if emotion == "COLERE" else 0.0
+
+            t_state = time.time() - t_start
+
+            # anims specifiques pr chaque emotion du bouton
+            if emotion == "COLERE":
+                elapsed_since_last = time.time() - colere_last
+                if elapsed_since_last >= COLERE_PERIOD:
+                    colere_last = time.time()
+                    elapsed_since_last = 0.0
+
+                anim_t = elapsed_since_last 
+                if anim_t < COLERE_ANIM:
+                    if anim_t < 0.15:
+                        angle = -1.0 * (anim_t / 0.15) * ANTENNA_MAX_col
+                    elif anim_t < 0.40:
+                        angle = (-1.0 + 1.0 * ((anim_t - 0.15) / 0.15)) * ANTENNA_MAX_col
+                    elif anim_t < 0.65:
+                        angle = -1.0 * ((anim_t - 0.3) / 0.15) * ANTENNA_MAX_col
+                    else:
+                        angle = -1.0 * ANTENNA_MAX_col
+                    left_ant  =  angle
+                    right_ant = -angle
+                else:
+                    neutral_t = anim_t - COLERE_ANIM
+                    angle = 1.0 * (1.0 - math.exp(-14.0 * neutral_t)) * ANTENNA_MAX_alt
+                    left_ant  = -(angle - 0.3)
+                    right_ant =  (angle - 0.3)
+            elif emotion == "JOIE":
+                oscillation = 0.5 * math.sin(2 * math.pi * 4.0 * t_state)
+                angle = (0.5 + oscillation) * ANTENNA_MAX_alt
+                left_ant  = -angle
+                right_ant =  angle
+            elif emotion == "CONTENT":
+                oscillation = 0.8 * math.sin(2 * math.pi * 0.5 * t_state)
+                angle = oscillation * ANTENNA_MAX_alt
+                left_ant = right_ant = angle
+            elif emotion == "SURPRISE":
+                angle = 1.0 * (1.0 - math.exp(-14.0 * t_state)) * ANTENNA_MAX_alt
+                left_ant  = -(angle - 0.8)
+                right_ant =  (angle - 0.8)
+            elif emotion == "TRISTESSE":
+                target = -1.0 * (1.0 - math.exp(-1.5 * t_state)) * ANTENNA_MAX
+                left_ant  =  target - 0.2
+                right_ant = -(target - 0.2)
+            elif emotion == "PEUR":
+                tremblement = 0.1 * math.sin(2 * math.pi * 15.0 * t_state)
+                angle = -1.0 * (1.0 - math.exp(-1.5 * t_state) + tremblement) * ANTENNA_MAX
+                left_ant  =  angle - 0.2
+                right_ant = -(angle - 0.2)
+            else:  
+                angle = 1.0 * (1.0 - math.exp(-14.0 * t_state)) * ANTENNA_MAX_alt
+                left_ant  = -(angle - 0.3)
+                right_ant =  (angle - 0.3)
+
+            clamp = lambda v: float(max(-ANTENNA_MAX, min(ANTENNA_MAX, v)))
+            try:
+                reachy_mini.set_target(antennas=[clamp(left_ant), clamp(right_ant)]) # deplace antennes robot
+            except Exception:
+                pass
+
+            time.sleep(0.02)
+
+    def run(self, reachy_mini: ReachyMini, stop_event: threading.Event): # boucle thread mvt principal synchro video
+        reachy_mini.goto_target(create_head_pose(), antennas=[0.0, 0.0], duration=1.0) # pose initiale neutre
         time.sleep(1.2)
 
+        emotion_thread = threading.Thread( # lance thread parallele boutons manuels
+            target=self._run_manual_emotion_loop,
+            args=(reachy_mini, stop_event),
+            daemon=True,
+        )
+        emotion_thread.start()
+
         while not stop_event.is_set():
             with self.playback_lock:
                 commands_to_play = list(self.current_commands)
                 timestamps = list(self.current_timestamps)
                 state = dict(self.playback_state)
 
-            if state.get("stop_requested"):
+            if state.get("stop_requested"): # check si clic stop web
+                self.robot_audio.update(reachy_mini, {**state, "playing": False}, stop_event)
                 reachy_mini.goto_target(create_head_pose(), antennas=[0.0, 0.0], duration=1.0)
                 with self.playback_lock:
                     self.playback_state["stop_requested"] = False
@@ -516,22 +958,22 @@ class Jericho(ReachyMiniApp):
                 continue
 
             now = time.time()
-            if playing:
+            if playing: # calcul position temporelle cible dans le json
                 target_t = float(state.get("current_time", 0.0)) + (now - float(state.get("updated_at", now)))
             else:
                 target_t = float(state.get("current_time", 0.0))
 
-            if target_t > timestamps[-1] + 0.20:
+            if target_t > timestamps[-1] + 0.20: # stop si video terminee
                 self._set_playback_state(state.get("project_name"), timestamps[-1], False, dirty=False, stop_requested=True)
                 continue
 
-            idx = bisect.bisect_left(timestamps, max(0.0, target_t))
+            idx = bisect.bisect_left(timestamps, max(0.0, target_t)) # recup index commande par dichotomie
             if idx >= len(commands_to_play):
                 idx = len(commands_to_play) - 1
 
             cmd = commands_to_play[idx]
             head_dict = cmd["head"]
-            head_pose = create_head_pose(
+            head_pose = create_head_pose( # genere structure pose reachy mini
                 x=head_dict["x"], y=head_dict["y"], z=head_dict["z"],
                 roll=head_dict["roll"], pitch=head_dict["pitch"], yaw=head_dict["yaw"],
                 degrees=False, mm=False,
@@ -539,22 +981,25 @@ class Jericho(ReachyMiniApp):
 
             antennas_target = cmd["antennas"] if self.antennas_enabled else [0.0, 0.0]
 
-            try:
+            try: # transmet commandes moteurs au robot
                 reachy_mini.set_target(head=head_pose, antennas=antennas_target, body_yaw=cmd["body_yaw"])
             except TypeError:
                 reachy_mini.set_target(head=head_pose, antennas=antennas_target)
 
+            self.robot_audio.update(reachy_mini, state, stop_event) # maj synchro flux audio robot
+
             if dirty:
                 with self.playback_lock:
-                    
                     if self.playback_state.get("updated_at") == state.get("updated_at"):
                         self.playback_state["dirty"] = False
 
             time.sleep(0.01 if playing else 0.03)
 
+        self.robot_audio._stop_output(reachy_mini) # coupe audio fin appli
+
 if __name__ == "__main__":
     app = Jericho()
     try:
-        app.wrapped_run()
+        app.wrapped_run() # run application reachy mini wrapper
     except KeyboardInterrupt:
         app.stop()

jericho/static/index.html

@@ -8,9 +8,13 @@
   </head>
   <body>
     <header>
-      <h1>Jericho projet : Reachy Mini</h1>
+      <h1>【⚙】Jericho projet : Reachy Mini【⚙】</h1>
       <div id="conteneurHeader">
-        <img src="./image/logoReachyMini.png" alt="Photo de Reachy" width="10%" />
+        <img
+          src="static/images/logoReachyMini.png"
+          alt="Photo de Reachy"
+          width="10%"
+        />
         <div id="robot-status">Prêt</div>
       </div>
     </header>
@@ -20,37 +24,111 @@
         <h2>[↓] Importer votre Vidéo</h2>
         <div class="form-group">
           <label>Nom du projet :</label>
-          <input type="text" id="video-name" placeholder="ex: session_joie_01" />
+          <input
+            type="text"
+            id="video-name"
+            placeholder="ex: session_joie_01"
+          />
         </div>
         <div class="form-group">
           <label for="video-file">Fichier Vidéo :</label>
-          <input type="file" id="video-file" accept="video/mp4,video/quicktime" />
+          <input
+            type="file"
+            id="video-file"
+            accept="video/mp4,video/quicktime"
+          />
         </div>
-        <button id="import-btn" class="btn-primary">Analyser et Enregistrer</button>
+        <button id="import-btn" class="btn-primary">
+          Analyser et Enregistrer
+        </button>
         <p id="import-msg"></p>
       </section>
 
       <section class="card">
-        <h2>Votre bibliothèque</h2>
+        <h2>[▶] Importer depuis YouTube</h2>
+        <div class="form-group">
+          <label>Nom du projet :</label>
+          <input
+            type="text"
+            id="yt-name"
+            placeholder="ex: session_youtube_01"
+          />
+        </div>
+        <div class="form-group">
+          <label for="yt-url">URL YouTube :</label>
+          <input
+            type="text"
+            id="yt-url"
+            placeholder="https://www.youtube.com/watch?v=..."
+          />
+        </div>
+        <button id="yt-import-btn" class="btn-primary">
+          Télécharger et Analyser
+        </button>
+        <p id="yt-msg"></p>
+      </section>
+
+      <section class="card">
+        <h2>►► Votre bibliothèque</h2>
         <div id="video-library" class="grid-library">
           <p class="empty-text">Aucune vidéo enregistrée.</p>
         </div>
       </section>
+      <section class="card">
+        <h2>[+] Créer une séquence d'émotions</h2>
+        <div class="form-group">
+          <label>Nom de la création :</label>
+          <input type="text" id="seq-name" placeholder="ex: sequence_test_01" />
+        </div>
+
+        <div id="sequence-list" style="margin-bottom: 15px"></div>
 
+        <button
+          id="add-emotion-btn"
+          class="btn-primary"
+          style="background-color: #27ae60"
+        >
+          + Ajouter une émotion
+        </button>
+        <button
+          id="save-seq-btn"
+          class="btn-primary"
+          style="background-color: #8e44ad; margin-left: 10px"
+        >
+          Enregistrer la séquence
+        </button>
+        <p id="seq-msg"></p>
+      </section>
       <section id="player-section" class="card hidden">
         <h2 id="current-video-title">Lecture</h2>
-        <video id="video-player" controls width="100%"></video>
+        <video id="video-player" controls></video>
 
         <div class="sync-controls">
           <button id="launch-sync-btn" class="btn-success">
-            [->] Lire vidéo + robot synchronisés
+            [►] Lire vidéo + robot synchronisés
+          </button>
+          <button id="launch-seq-btn" class="btn-success" style="display: none">
+            [►] Lire la séquence (sans vidéo)
           </button>
           <p class="sync-hint">
-            Les pauses, reprises et déplacements dans la vidéo sont envoyés au robot.
-            Les frames sans visage sont supprimées de la vidéo traitée et des signaux.
+            Les pauses, reprises et déplacements dans la vidéo sont envoyés au
+            robot.
           </p>
         </div>
       </section>
+
+      <section class="card">
+        <h2>☻ Les émotions</h2>
+        <div id="listeEmotions">
+          <button id="joie">Joie</button>
+          <button id="content">Content</button>
+          <button id="surprise">Surprise</button>
+          <button id="colere">Colère</button>
+          <button id="peur">Peur</button>
+          <button id="tristesse">Tristesse</button>
+          <button id="neutre">Neutre</button>
+        </div>
+      </section>
     </main>
 
     <script src="/static/main.js"></script>

jericho/static/main.js

@@ -1,4 +1,4 @@
-let currentLoadedProject = null; // stocke le nom du projet sélectionné
+let currentLoadedProject = null; 
 let syncTimer = null;
 let lastSyncSent = 0;
 const SYNC_INTERVAL_MS = 250;
@@ -6,6 +6,9 @@ const SYNC_INTERVAL_MS = 250;
 const robotStatus = document.getElementById('robot-status');
 const videoPlayer = document.getElementById('video-player');
 
+videoPlayer.muted = true;
+videoPlayer.defaultMuted = true;
+
 function escapeHtml(value) {
     return String(value)
         .replaceAll('&', '&')
@@ -70,6 +73,25 @@ document.addEventListener('DOMContentLoaded', () => {
             if (currentLoadedProject) videoPlayer.play();
         };
     }
+
+    // Boutons d'émotions
+    const emotionIds = ['joie', 'content', 'surprise', 'colere', 'peur', 'tristesse', 'neutre'];
+    emotionIds.forEach(id => {
+        const el = document.getElementById(id);
+        if (!el) return;
+        el.addEventListener('click', async () => {
+            // Highlight du bouton actif
+            emotionIds.forEach(eid => document.getElementById(eid)?.classList.remove('active-emotion'));
+            el.classList.add('active-emotion');
+
+            await fetch('/api/emotion', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ emotion: id.toUpperCase() })
+            });
+            robotStatus.textContent = `Émotion : ${el.textContent.trim()}`;
+        });
+    });
 });
 
 document.getElementById('import-btn').onclick = function() {
@@ -120,6 +142,47 @@ document.getElementById('import-btn').onclick = function() {
     };
 };
 
+document.getElementById('yt-import-btn').onclick = async function() {
+    const name = document.getElementById('yt-name').value.trim();
+    const url = document.getElementById('yt-url').value.trim();
+    const msg = document.getElementById('yt-msg');
+
+    if (!name || !url) {
+        msg.textContent = 'Erreur : Nom et URL requis.';
+        msg.style.color = 'red';
+        return;
+    }
+
+    msg.textContent = 'Envoi de la demande au serveur...';
+    msg.style.color = '#d35400';
+    document.getElementById('yt-import-btn').disabled = true;
+
+    try {
+        const response = await fetch('/api/upload_youtube', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: name, url: url })
+        });
+
+        if (response.ok) {
+            msg.textContent = 'Téléchargement YouTube en cours, puis analyse automatique.';
+            msg.style.color = '#8269ae';
+            document.getElementById('yt-name').value = '';
+            document.getElementById('yt-url').value = '';
+            loadLibrary();
+        } else {
+            const result = await response.json();
+            msg.textContent = `Erreur du serveur : ${result.detail}`;
+            msg.style.color = 'red';
+        }
+    } catch (error) {
+        msg.textContent = 'Erreur de connexion au serveur.';
+        msg.style.color = 'red';
+    } finally {
+        document.getElementById('yt-import-btn').disabled = false;
+    }
+};
+
 window.deleteProject = async function(event, name) {
     event.stopPropagation();
 
@@ -163,7 +226,7 @@ async function loadLibrary() {
         } else {
             projects.forEach(video => {
                 const safeName = escapeHtml(video.name);
-                const deleteBtn = `<span onclick="deleteProject(event, ${JSON.stringify(video.name).replaceAll('"', '&quot;')})" style="position:absolute; top:2px; right:4px; font-size:16px; cursor:pointer;" title="Supprimer définitivement">x</span>`;
+                const deleteBtn = `<span onclick="deleteProject(event, ${JSON.stringify(video.name).replaceAll('"', '&quot;')})" style="position:absolute; top:2px; right:4px; font-size:16px; cursor:pointer;" title="Supprimer définitivement">✗</span>`;
 
                 if (video.status === 'DONE') {
                     const nameArg = JSON.stringify(video.name).replaceAll('"', '&quot;');
@@ -172,6 +235,18 @@ async function loadLibrary() {
                                     ${deleteBtn}
                                     <br><strong>${safeName}</strong><br><span style="color:green; font-size:12px;">Prêt</span>
                                 </div>`;
+                } else if (video.status === 'CREATION_DONE') {
+                    
+                    const nameArg = JSON.stringify(video.name).replaceAll('"', '&quot;');
+                    newHTML += `<div class="video-item" onclick="loadVideoPlayer(${nameArg}, null)" style="position:relative; border: 2px solid purple;">
+                                    ${deleteBtn}
+                                    <br><strong>${safeName}</strong><br><span style="color:purple; font-size:12px;">Séquence manuelle</span>
+                                </div>`;
+                } else if (video.status === 'DOWNLOADING') {
+                    newHTML += `<div class="video-item" style="position:relative; opacity: 0.7; cursor: wait; border: 2px dashed #3498db;">
+                                    ${deleteBtn}
+                                    <br><strong>${safeName}</strong><br><span style="color:#3498db; font-size:12px;">Téléchargement YouTube...</span>
+                                </div>`;
                 } else if (video.status === 'PROCESSING') {
                     newHTML += `<div class="video-item" style="position:relative; opacity: 0.7; cursor: wait; border: 2px dashed orange;">
                                     ${deleteBtn}
@@ -208,17 +283,43 @@ window.loadVideoPlayer = async function(name, url) {
         await sendPlayback('stop', { projectName: currentLoadedProject, playing: false });
     }
 
+    
+    document.querySelectorAll('#listeEmotions button').forEach(b => b.classList.remove('active-emotion'));
+    await fetch('/api/emotion', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ emotion: null })
+    });
+
     currentLoadedProject = name;
     document.getElementById('player-section').classList.remove('hidden');
     document.getElementById('current-video-title').textContent = 'Projet : ' + name;
-    videoPlayer.src = url;
-    videoPlayer.load();
-    robotStatus.textContent = 'Vidéo chargée';
+    
+    const btnSync = document.getElementById('launch-sync-btn');
+    const btnSeq = document.getElementById('launch-seq-btn');
+
+    if (url) {
+        
+        videoPlayer.src = url;
+        videoPlayer.style.display = 'block';
+        if(btnSync) btnSync.style.display = 'inline-block';
+        if(btnSeq) btnSeq.style.display = 'none';
+        videoPlayer.load();
+        robotStatus.textContent = 'Vidéo chargée — son sur Reachy Mini';
+    } else {
+       
+        videoPlayer.removeAttribute('src');
+        videoPlayer.style.display = 'none';
+        if(btnSync) btnSync.style.display = 'none';
+        if(btnSeq) btnSeq.style.display = 'inline-block';
+        robotStatus.textContent = 'Séquence chargée — Prêt à lire';
+    }
 };
 
 videoPlayer.addEventListener('play', () => {
     if (!currentLoadedProject) return;
-    robotStatus.textContent = 'Lecture synchronisée';
+    videoPlayer.muted = true;
+    robotStatus.textContent = 'Lecture synchronisée — audio robot';
     sendPlayback('play', { playing: true });
     startSyncLoop();
 });
@@ -255,3 +356,212 @@ videoPlayer.addEventListener('ended', () => {
     sendPlayback('stop', { playing: false });
     stopSyncLoop();
 });
+
+let boutonJoie=document.getElementById('joie');
+let boutonContent=document.getElementById('content');
+let boutonSurprise=document.getElementById('surprise');
+let boutonColere=document.getElementById('colere');
+let boutonPeur=document.getElementById('peur');
+let boutonTristesse=document.getElementById('tristesse');
+let boutonNeutre=document.getElementById('neutre');
+
+boutonJoie.addEventListener("click", async () => {
+    document.querySelectorAll('#listeEmotions button').forEach(b => b.classList.remove('active-emotion'));
+    boutonJoie.classList.add('active-emotion');
+
+    await fetch('/api/emotion', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ emotion: 'JOIE' })
+    });
+    robotStatus.textContent = 'Émotion : Joie';
+});
+
+boutonContent.addEventListener("click", async () => {
+    document.querySelectorAll('#listeEmotions button').forEach(b => b.classList.remove('active-emotion'));
+    boutonJoie.classList.add('active-emotion');
+
+    await fetch('/api/emotion', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ emotion: 'CONTENT' })
+    });
+    robotStatus.textContent = 'Émotion : Content';
+});
+
+boutonSurprise.addEventListener("click", async () => {
+    document.querySelectorAll('#listeEmotions button').forEach(b => b.classList.remove('active-emotion'));
+    boutonJoie.classList.add('active-emotion');
+
+    await fetch('/api/emotion', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ emotion: 'SURPRISE' })
+    });
+    robotStatus.textContent = 'Émotion : Surprise';
+});
+
+boutonColere.addEventListener("click", async () => {
+    document.querySelectorAll('#listeEmotions button').forEach(b => b.classList.remove('active-emotion'));
+    boutonJoie.classList.add('active-emotion');
+
+    await fetch('/api/emotion', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ emotion: 'COLERE' })
+    });
+    robotStatus.textContent = 'Émotion : Colère';
+});
+
+boutonPeur.addEventListener("click", async () => {
+    document.querySelectorAll('#listeEmotions button').forEach(b => b.classList.remove('active-emotion'));
+    boutonJoie.classList.add('active-emotion');
+
+    await fetch('/api/emotion', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ emotion: 'PEUR' })
+    });
+    robotStatus.textContent = 'Émotion : Peur';
+});
+
+boutonTristesse.addEventListener("click", async () => {
+    document.querySelectorAll('#listeEmotions button').forEach(b => b.classList.remove('active-emotion'));
+    boutonJoie.classList.add('active-emotion');
+
+    await fetch('/api/emotion', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ emotion: 'TRISTESSE' })
+    });
+    robotStatus.textContent = 'Émotion : Tristesse';
+});
+
+boutonNeutre.addEventListener("click", async () => {
+    document.querySelectorAll('#listeEmotions button').forEach(b => b.classList.remove('active-emotion'));
+    boutonJoie.classList.add('active-emotion');
+
+    await fetch('/api/emotion', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ emotion: 'NEUTRE' })
+    });
+    robotStatus.textContent = 'Émotion : Neutre';
+});
+
+function createEmotionRow() {
+    const row = document.createElement('div');
+    row.className = 'emotion-row';
+    row.style.display = 'flex';
+    row.style.gap = '10px';
+    row.style.marginBottom = '10px';
+    row.style.alignItems = 'center';
+
+    const select = document.createElement('select');
+    const emotions = ['JOIE', 'CONTENT', 'SURPRISE', 'COLERE', 'PEUR', 'TRISTESSE', 'NEUTRE'];
+    emotions.forEach(emo => {
+        const opt = document.createElement('option');
+        opt.value = emo;
+        opt.textContent = emo;
+        select.appendChild(opt);
+    });
+
+    const inputTime = document.createElement('input');
+    inputTime.type = 'number';
+    inputTime.min = '0.5';
+    inputTime.step = '0.5';
+    inputTime.value = '2.0';
+    inputTime.style.width = '70px';
+
+    const span = document.createElement('span');
+    span.textContent = 'secondes';
+
+    const btnRemove = document.createElement('button');
+    btnRemove.textContent = '✗';
+    btnRemove.style.background = '#e74c3c';
+    btnRemove.style.color = 'white';
+    btnRemove.style.border = 'none';
+    btnRemove.style.cursor = 'pointer';
+    btnRemove.style.borderRadius = '3px';
+    btnRemove.style.padding = '5px 10px';
+    btnRemove.onclick = () => row.remove();
+
+    row.appendChild(select);
+    row.appendChild(inputTime);
+    row.appendChild(span);
+    row.appendChild(btnRemove);
+
+    document.getElementById('sequence-list').appendChild(row);
+}
+
+// Ajouter une ligne par défaut au chargement
+document.addEventListener('DOMContentLoaded', () => {
+    const addEmotionBtn = document.getElementById('add-emotion-btn');
+    if(addEmotionBtn) {
+        addEmotionBtn.addEventListener('click', createEmotionRow);
+        createEmotionRow(); 
+    }
+    
+    // Configurer le bouton Play de la séquence
+    const playSeqBtn = document.getElementById('launch-seq-btn');
+    if(playSeqBtn) {
+        playSeqBtn.onclick = () => {
+            if (currentLoadedProject) {
+                sendPlayback('play', { playing: true });
+                robotStatus.textContent = 'Lecture séquence en cours...';
+            }
+        };
+    }
+});
+
+document.getElementById('save-seq-btn').onclick = async function() {
+    const name = document.getElementById('seq-name').value.trim();
+    const msg = document.getElementById('seq-msg');
+
+    if (!name) {
+        msg.textContent = 'Erreur : Nom requis.';
+        msg.style.color = 'red';
+        return;
+    }
+
+    const rows = document.querySelectorAll('.emotion-row');
+    if (rows.length === 0) {
+        msg.textContent = 'Erreur : Ajoutez au moins une émotion.';
+        msg.style.color = 'red';
+        return;
+    }
+
+    const sequence = [];
+    rows.forEach(row => {
+        const emo = row.querySelector('select').value;
+        const dur = parseFloat(row.querySelector('input').value);
+        if (dur > 0) sequence.push({ emotion: emo, duration: dur });
+    });
+
+    msg.textContent = 'Création en cours...';
+    msg.style.color = '#d35400';
+
+    try {
+        const response = await fetch('/api/create_sequence', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: name, sequence: sequence })
+        });
+
+        if (response.ok) {
+            msg.textContent = 'Séquence enregistrée !';
+            msg.style.color = 'green';
+            document.getElementById('seq-name').value = '';
+            document.getElementById('sequence-list').innerHTML = '';
+            createEmotionRow(); // Reset l'interface
+            loadLibrary(); // Met à jour la liste
+        } else {
+            const result = await response.json();
+            msg.textContent = `Erreur : ${result.detail}`;
+            msg.style.color = 'red';
+        }
+    } catch (error) {
+        msg.textContent = 'Erreur réseau.';
+        msg.style.color = 'red';
+    }
+};

jericho/static/style.css

@@ -1,5 +1,5 @@
 body {
-    /*font-family: 'I', Tahoma, Geneva, Verdana, sans-serif;*/
+    
     font-family:'Trebuchet MS', 'Lucida Sans Unicode', 'Lucida Grande', 'Lucida Sans', Arial, sans-serif;
     font-weight: lighter;
     margin: 0;
@@ -62,13 +62,17 @@ label {
     margin-bottom: 0.3rem;
 }
 
-input[type="text"], input[type="number"] {
+input[type="text"], input[type="number"], input[type="url"] {
     width: 100%;
     padding: 0.6rem;
     border: 1px solid #ccc;
     border-radius: 4px;
 }
 
+#yt-url {
+    color: #a34952;
+}
+
 .btn-primary {
     background-color: #a34952;
     color: white;
@@ -114,6 +118,15 @@ input[type="text"], input[type="number"] {
     border-top: 1px solid #eee;
 }
 
+#video-player {
+    height: 80vh;
+    width: auto;
+    max-width: 100%;
+    display: block;
+    margin: 0 auto;
+    object-fit: contain;
+}
+
 #video-file{
     color:#a34952;
 }
@@ -122,3 +135,21 @@ input[type="text"], input[type="number"] {
     color: #74424a;
     margin-bottom: 0;
 }
+
+#listeEmotions{
+    button{
+        color : #a34952;
+        background-color: white;
+        font-family:'Trebuchet MS', 'Lucida Sans Unicode', 'Lucida Grande', 'Lucida Sans', Arial, sans-serif;
+        font-weight: lighter;
+        border-color: #ffffff;
+        border-radius: 10%;
+        margin-top : auto;
+        margin-bottom: auto;
+        padding-top : 0.7%;
+        padding-bottom : 0.7%;
+        font-size:1.2vw;
+        margin-right : 2.5%;
+        width : 11%;
+    }
+}