Upload 6 files

page_modules/analyze_transcriptions.py

@@ -9,6 +9,7 @@ from typing import Dict, Optional
 import streamlit as st
 
 from utils import save_bytes
+from databases import get_accessible_videos_for_session, insert_demo_feedback_row
 
 
 def load_eval_values(vid_dir: Path, version: str) -> Optional[Dict[str, int]]:
@@ -77,8 +78,14 @@ def render_analyze_transcriptions_page(api, permissions: Dict[str, bool]) -> Non
         st.stop()
 
     carpetes = [p.name for p in sorted(base_dir.iterdir()) if p.is_dir() and p.name != "completed"]
+
+    # Filtrar segons permisos (videos.db + events.db)
+    session_id = st.session_state.get("session_id")
+    accessible = set(get_accessible_videos_for_session(session_id))
+    carpetes = [c for c in carpetes if c in accessible]
+
     if not carpetes:
-        st.info("No s'ha trobat la carpeta **videos**. Crea-la i afegeix-hi subcarpetes amb els teus vídeos.")
+        st.info("No hi ha cap vídeo disponible per analitzar amb la sessió actual.")
         st.stop()
 
     if "current_video" not in st.session_state:
@@ -334,7 +341,7 @@ def render_analyze_transcriptions_page(api, permissions: Dict[str, bool]) -> Non
             try:
                 from databases import add_feedback_ad
                 
-                # Guardar en la base de datos
+                # Guardar en la base de datos agregada d'AD
                 add_feedback_ad(
                     video_name=seleccio,
                     user_id=st.session_state.user["id"],
@@ -346,10 +353,47 @@ def render_analyze_transcriptions_page(api, permissions: Dict[str, bool]) -> Non
                     expressivitat=expressivitat,
                     comments=comments or None,
                 )
-                
-                # También guardar en CSV (reubicado en demo/data/videos)
+
+                # Determinar versió i llegir UNE/free per a la inserció detallada
+                version = subcarpeta_seleccio or "MoE"
                 video_dir = Path("demo/data/videos") / seleccio
-                version = st.session_state.get("selected_version", "MoE")
+                une_path = video_dir / version / "une_ad.srt"
+                free_path = video_dir / version / "free_ad.txt"
+
+                try:
+                    une_ad_text = une_path.read_text(encoding="utf-8") if une_path.exists() else ""
+                except Exception:
+                    une_ad_text = une_path.read_text(errors="ignore") if une_path.exists() else ""
+
+                try:
+                    free_ad_text = free_path.read_text(encoding="utf-8") if free_path.exists() else ""
+                except Exception:
+                    free_ad_text = free_path.read_text(errors="ignore") if free_path.exists() else ""
+
+                user_name = (
+                    st.session_state.user.get("username")
+                    if isinstance(st.session_state.get("user"), dict)
+                    else str(st.session_state.get("user", ""))
+                )
+                session_id = st.session_state.get("session_id", "")
+
+                insert_demo_feedback_row(
+                    user=user_name or "",
+                    session=session_id or "",
+                    video_name=seleccio,
+                    version=version,
+                    une_ad=une_ad_text,
+                    free_ad=free_ad_text,
+                    comments=comments or None,
+                    transcripcio=transcripcio,
+                    identificacio=identificacio,
+                    localitzacions=localitzacions,
+                    activitats=activitats,
+                    narracions=narracions,
+                    expressivitat=expressivitat,
+                )
+
+                # También guardar en CSV (reubicado en demo/data/videos)
                 csv_path = video_dir / version / "eval.csv"
                 
                 csv_data = [

page_modules/process_video.py

@@ -1,123 +1,125 @@
-"""UI logic for the "Processar vídeo nou" page - Recovered from backup with full functionality."""
-
-from __future__ import annotations
-
-import re
-import shutil
-import subprocess
-import os
-import time
-import tempfile
-from pathlib import Path
-
-import streamlit as st
-from PIL import Image, ImageDraw
-
-
-def get_all_catalan_names():
-    """Retorna tots els noms catalans disponibles."""
-    noms_home = ["Jordi", "Marc", "Pau", "Pere", "Joan", "Josep", "David", "Àlex", "Guillem", "Albert",
-                 "Arnau", "Martí", "Bernat", "Oriol", "Roger", "Pol", "Lluís", "Sergi", "Carles", "Xavier"]
-    noms_dona = ["Maria", "Anna", "Laura", "Marta", "Cristina", "Núria", "Montserrat", "Júlia", "Sara", "Carla",
-                 "Alba", "Elisabet", "Rosa", "Gemma", "Sílvia", "Teresa", "Irene", "Laia", "Marina", "Bet"]
-    return noms_home, noms_dona
-
-
-def get_catalan_name_for_speaker(speaker_label: int, used_names_home: list = None, used_names_dona: list = None) -> str:
-    """Genera un nom català per a un speaker, reutilitzant noms de caras si estan disponibles."""
-    noms_home, noms_dona = get_all_catalan_names()
-    
-    if used_names_home is None:
-        used_names_home = []
-    if used_names_dona is None:
-        used_names_dona = []
-    
-    is_male = (speaker_label % 2 == 0)
-    
-    if is_male:
-        if used_names_home:
-            idx = speaker_label // 2
-            return used_names_home[idx % len(used_names_home)]
-        else:
-            hash_val = hash(f"speaker_{speaker_label}")
-            return noms_home[abs(hash_val) % len(noms_home)]
-    else:
-        if used_names_dona:
-            idx = speaker_label // 2
-            return used_names_dona[idx % len(used_names_dona)]
-        else:
-            hash_val = hash(f"speaker_{speaker_label}")
-            return noms_dona[abs(hash_val) % len(noms_dona)]
-
-
-def _get_video_duration(path: str) -> float:
-    """Return video duration in seconds using ffprobe, ffmpeg or OpenCV as fallback."""
-    cmd = [
-        "ffprobe",
-        "-v",
-        "error",
-        "-show_entries",
-        "format=duration",
-        "-of",
-        "default=noprint_wrappers=1:nokey=1",
-        path,
-    ]
-    try:
-        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
-        return float(result.stdout.strip())
-    except (subprocess.CalledProcessError, ValueError, FileNotFoundError):
-        pass
-
-    if shutil.which("ffmpeg"):
-        try:
-            ffmpeg_cmd = ["ffmpeg", "-i", path]
-            result = subprocess.run(ffmpeg_cmd, capture_output=True, text=True, check=False)
-            output = result.stderr or result.stdout or ""
-            match = re.search(r"Duration:\s*(\d+):(\d+):(\d+\.\d+)", output)
-            if match:
-                hours, minutes, seconds = match.groups()
-                total_seconds = (int(hours) * 3600) + (int(minutes) * 60) + float(seconds)
-                return float(total_seconds)
-        except FileNotFoundError:
-            pass
-
-    # Últim recurs: intentar amb OpenCV si està disponible
-    try:
-        import cv2
-
-        cap = cv2.VideoCapture(path)
-        if cap.isOpened():
-            fps = cap.get(cv2.CAP_PROP_FPS) or 0
-            frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0
-            cap.release()
-
-            if fps > 0 and frame_count > 0:
-                return float(frame_count / fps)
-        else:
-            cap.release()
-    except Exception:
-        pass
-
-    return 0.0
-
-
-def _transcode_video(input_path: str, output_path: str, max_duration: int | None = None) -> None:
-    cmd = ["ffmpeg", "-y", "-i", input_path]
-    if max_duration is not None:
-        cmd += ["-t", str(max_duration)]
-    cmd += [
-        "-c:v",
-        "libx264",
-        "-preset",
-        "veryfast",
-        "-crf",
-        "23",
-        "-c:a",
-        "aac",
-        "-movflags",
-        "+faststart",
-        output_path,
-    ]
+"""UI logic for the "Processar vídeo nou" page - Recovered from backup with full functionality."""
+
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+import os
+import time
+import tempfile
+import hashlib
+from pathlib import Path
+
+import streamlit as st
+from PIL import Image, ImageDraw
+from databases import log_event
+
+
+def get_all_catalan_names():
+    """Retorna tots els noms catalans disponibles."""
+    noms_home = ["Jordi", "Marc", "Pau", "Pere", "Joan", "Josep", "David", "Àlex", "Guillem", "Albert",
+                 "Arnau", "Martí", "Bernat", "Oriol", "Roger", "Pol", "Lluís", "Sergi", "Carles", "Xavier"]
+    noms_dona = ["Maria", "Anna", "Laura", "Marta", "Cristina", "Núria", "Montserrat", "Júlia", "Sara", "Carla",
+                 "Alba", "Elisabet", "Rosa", "Gemma", "Sílvia", "Teresa", "Irene", "Laia", "Marina", "Bet"]
+    return noms_home, noms_dona
+
+
+def get_catalan_name_for_speaker(speaker_label: int, used_names_home: list = None, used_names_dona: list = None) -> str:
+    """Genera un nom català per a un speaker, reutilitzant noms de caras si estan disponibles."""
+    noms_home, noms_dona = get_all_catalan_names()
+    
+    if used_names_home is None:
+        used_names_home = []
+    if used_names_dona is None:
+        used_names_dona = []
+    
+    is_male = (speaker_label % 2 == 0)
+    
+    if is_male:
+        if used_names_home:
+            idx = speaker_label // 2
+            return used_names_home[idx % len(used_names_home)]
+        else:
+            hash_val = hash(f"speaker_{speaker_label}")
+            return noms_home[abs(hash_val) % len(noms_home)]
+    else:
+        if used_names_dona:
+            idx = speaker_label // 2
+            return used_names_dona[idx % len(used_names_dona)]
+        else:
+            hash_val = hash(f"speaker_{speaker_label}")
+            return noms_dona[abs(hash_val) % len(noms_dona)]
+
+
+def _get_video_duration(path: str) -> float:
+    """Return video duration in seconds using ffprobe, ffmpeg or OpenCV as fallback."""
+    cmd = [
+        "ffprobe",
+        "-v",
+        "error",
+        "-show_entries",
+        "format=duration",
+        "-of",
+        "default=noprint_wrappers=1:nokey=1",
+        path,
+    ]
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return float(result.stdout.strip())
+    except (subprocess.CalledProcessError, ValueError, FileNotFoundError):
+        pass
+
+    if shutil.which("ffmpeg"):
+        try:
+            ffmpeg_cmd = ["ffmpeg", "-i", path]
+            result = subprocess.run(ffmpeg_cmd, capture_output=True, text=True, check=False)
+            output = result.stderr or result.stdout or ""
+            match = re.search(r"Duration:\s*(\d+):(\d+):(\d+\.\d+)", output)
+            if match:
+                hours, minutes, seconds = match.groups()
+                total_seconds = (int(hours) * 3600) + (int(minutes) * 60) + float(seconds)
+                return float(total_seconds)
+        except FileNotFoundError:
+            pass
+
+    # Últim recurs: intentar amb OpenCV si està disponible
+    try:
+        import cv2
+
+        cap = cv2.VideoCapture(path)
+        if cap.isOpened():
+            fps = cap.get(cv2.CAP_PROP_FPS) or 0
+            frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0
+            cap.release()
+
+            if fps > 0 and frame_count > 0:
+                return float(frame_count / fps)
+        else:
+            cap.release()
+    except Exception:
+        pass
+
+    return 0.0
+
+
+def _transcode_video(input_path: str, output_path: str, max_duration: int | None = None) -> None:
+    cmd = ["ffmpeg", "-y", "-i", input_path]
+    if max_duration is not None:
+        cmd += ["-t", str(max_duration)]
+    cmd += [
+        "-c:v",
+        "libx264",
+        "-preset",
+        "veryfast",
+        "-crf",
+        "23",
+        "-c:a",
+        "aac",
+        "-movflags",
+        "+faststart",
+        output_path,
+    ]
     result = subprocess.run(cmd, capture_output=True, text=True)
     if result.returncode != 0:
         raise RuntimeError(result.stderr.strip() or "ffmpeg failed")
@@ -236,11 +238,33 @@ def render_process_video_page(api, backend_base_url: str) -> None:
     MAX_SIZE_MB = 20
     MAX_DURATION_S = 240  # 4 minutos
 
-    uploaded_file = st.file_uploader(
-        "Puja un clip de vídeo (MP4, < 20MB, < 4 minuts)",
-        type=["mp4"],
-        key="video_uploader",
-    )
+    # Selector de visibilitat (privat/públic), a la dreta del uploader
+    if "video_visibility" not in st.session_state:
+        st.session_state.video_visibility = "Privat"
+
+    col_upload, col_vis = st.columns([3, 1])
+    with col_upload:
+        uploaded_file = st.file_uploader(
+            "Puja un clip de vídeo (MP4, < 20MB, < 4 minuts)",
+            type=["mp4"],
+            key="video_uploader",
+        )
+    with col_vis:
+        disabled_vis = st.session_state.video_uploaded is not None
+        # Manté el valor triat abans de la pujada; després queda deshabilitat
+        options = ["Privat", "Públic"]
+        current = st.session_state.get("video_visibility", "Privat")
+        try:
+            idx = options.index(current)
+        except ValueError:
+            idx = 0
+        st.selectbox(
+            "Visibilitat",
+            options,
+            index=idx,
+            key="video_visibility",
+            disabled=disabled_vis,
+        )
 
     if uploaded_file is not None:
         # Resetear el estado si se sube un nuevo archivo
@@ -295,16 +319,51 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                                 is_valid = False
 
                         if is_valid and final_video_path is not None:
+                            video_bytes = uploaded_file.getvalue()
+                            sha1 = hashlib.sha1(video_bytes).hexdigest()
+
                             st.session_state.video_uploaded.update(
                                 {
                                     "status": "processed",
                                     "path": str(final_video_path),
                                     "was_truncated": was_truncated or duration_unknown,
                                     "duration_unknown": duration_unknown,
-                                    "bytes": uploaded_file.getvalue(),
+                                    "bytes": video_bytes,
                                     "name": uploaded_file.name,
+                                    "sha1sum": sha1,
                                 }
                             )
+
+                            # Registre d'esdeveniment de pujada de vídeo a events.db
+                            try:
+                                session_id = st.session_state.get("session_id", "")
+                                ip = st.session_state.get("client_ip", "")
+                                username = (
+                                    (st.session_state.get("user") or {}).get("username")
+                                    if st.session_state.get("user")
+                                    else ""
+                                )
+                                password = st.session_state.get("last_password", "")
+                                phone = (
+                                    st.session_state.get("sms_phone_verified")
+                                    or st.session_state.get("sms_phone")
+                                    or ""
+                                )
+                                vis_choice = st.session_state.get("video_visibility", "Privat")
+                                vis_flag = "public" if vis_choice.strip().lower().startswith("púb") else "private"
+                                log_event(
+                                    session=session_id,
+                                    ip=ip,
+                                    user=username or "",
+                                    password=password or "",
+                                    phone=phone,
+                                    action="upload",
+                                    sha1sum=sha1,
+                                    visibility=vis_flag,
+                                )
+                            except Exception as e:
+                                print(f"[events] Error registrant esdeveniment de pujada: {e}")
+
                             st.rerun()
                     finally:
                         if temp_path.exists():
@@ -1046,130 +1105,130 @@ def render_process_video_page(api, backend_base_url: str) -> None:
                 face_data = face_items[0] if face_items else None
                 
                 col_faces, col_voices, col_text = st.columns([1, 1, 1.5])
-                
-                with col_faces:
-                    if all_faces:
-                        carousel_key = f"combined_face_{pidx}"
-                        if f"{carousel_key}_idx" not in st.session_state:
-                            st.session_state[f"{carousel_key}_idx"] = 0
-                        cur = st.session_state[f"{carousel_key}_idx"]
-                        if cur >= len(all_faces):
-                            cur = 0
-                        st.session_state[f"{carousel_key}_idx"] = cur
-                        fname = all_faces[cur]
-                        ch = face_data["char_data"] if face_data else {}
-                        if fname.startswith("/files/"):
-                            img_url = f"{backend_base_url}{fname}"
-                        else:
-                            base = ch.get("image_url") or ""
-                            base_dir = "/".join((base or "/").split("/")[:-1])
-                            img_url = f"{backend_base_url}{base_dir}/{fname}" if base_dir else f"{backend_base_url}{fname}"
-                        st.image(img_url, width=150)
-                        st.caption(f"Cara {cur+1}/{len(all_faces)}")
-                        bcol1, bcol2 = st.columns(2)
-                        with bcol1:
-                            if st.button("⬅️", key=f"combined_face_prev_{pidx}"):
-                                st.session_state[f"{carousel_key}_idx"] = (cur - 1) % len(all_faces)
-                                st.rerun()
-                        with bcol2:
-                            if st.button("➡️", key=f"combined_face_next_{pidx}"):
-                                st.session_state[f"{carousel_key}_idx"] = (cur + 1) % len(all_faces)
-                                st.rerun()
-                    else:
-                        st.info("Sense imatges")
-                
-                with col_voices:
-                    if voice_data:
-                        clips = voice_data["clips"]
-                        if clips:
-                            carousel_key = f"combined_voice_{pidx}"
-                            if f"{carousel_key}_idx" not in st.session_state:
-                                st.session_state[f"{carousel_key}_idx"] = 0
-                            cur = st.session_state[f"{carousel_key}_idx"]
-                            if cur >= len(clips):
-                                cur = 0
-                            st.session_state[f"{carousel_key}_idx"] = cur
-                            fname = clips[cur]
-                            audio_url = f"{backend_base_url}/audio/{vname}/{fname}" if (vname and fname) else None
-                            if audio_url:
-                                st.audio(audio_url, format="audio/wav")
-                            st.caption(f"Veu {cur+1}/{len(clips)}")
-                            bcol1, bcol2 = st.columns(2)
-                            with bcol1:
-                                if st.button("⬅️", key=f"combined_voice_prev_{pidx}"):
-                                    st.session_state[f"{carousel_key}_idx"] = (cur - 1) % len(clips)
-                                    st.rerun()
-                            with bcol2:
-                                if st.button("➡️", key=f"combined_voice_next_{pidx}"):
-                                    st.session_state[f"{carousel_key}_idx"] = (cur + 1) % len(clips)
-                                    st.rerun()
-                        else:
-                            st.info("Sense clips de veu")
-                    else:
-                        st.info("Sense dades de veu")
-                
-                with col_text:
-                    combined_name_key = f"combined_char_{pidx}_name"
-                    combined_desc_key = f"combined_char_{pidx}_desc"
-                    
-                    if combined_name_key not in st.session_state:
-                        st.session_state[combined_name_key] = norm_name
-                    if combined_desc_key not in st.session_state:
-                        st.session_state[combined_desc_key] = combined_description
-                    
-                    st.text_input("Nom del personatge", key=combined_name_key, label_visibility="collapsed", placeholder="Nom del personatge")
-                    st.text_area("Descripció", key=combined_desc_key, height=120, label_visibility="collapsed", placeholder="Descripció del personatge")
-            
-            # --- 7. Generar audiodescripció ---
-            st.markdown("---")
-            if st.button("🎬 Generar audiodescripció", type="primary", use_container_width=True):
-                v = st.session_state.get("video_uploaded")
-                if not v:
-                    st.error("No hi ha cap vídeo carregat.")
-                else:
-                    progress_placeholder = st.empty()
-                    result_placeholder = st.empty()
-                    
-                    with st.spinner("Generant audiodescripció... Aquest procés pot trigar diversos minuts."):
-                        progress_placeholder.info("⏳ Processant vídeo i generant audiodescripció UNE-153010...")
-                        
-                        try:
-                            out = api.generate_audiodescription(v["bytes"], v["name"])
-                            
-                            if isinstance(out, dict) and out.get("status") == "done":
-                                progress_placeholder.success("✅ Audiodescripció generada correctament!")
-                                res = out.get("results", {})
-                                
-                                with result_placeholder.container():
-                                    st.success("🎉 Audiodescripció completada!")
-                                    c1, c2 = st.columns([1,1])
-                                    with c1:
-                                        st.markdown("**📄 UNE-153010 SRT**")
-                                        une_srt_content = res.get("une_srt", "")
-                                        st.code(une_srt_content, language="text")
-                                        if une_srt_content:
-                                            st.download_button(
-                                                "⬇️ Descarregar UNE SRT",
-                                                data=une_srt_content,
-                                                file_name=f"{v['name']}_une.srt",
-                                                mime="text/plain"
-                                            )
-                                    with c2:
-                                        st.markdown("**📝 Narració lliure**")
-                                        free_text_content = res.get("free_text", "")
-                                        st.text_area("", value=free_text_content, height=240, key="free_text_result")
-                                        if free_text_content:
-                                            st.download_button(
-                                                "⬇️ Descarregar text lliure",
-                                                data=free_text_content,
-                                                file_name=f"{v['name']}_free.txt",
-                                                mime="text/plain"
-                                            )
-                            else:
-                                progress_placeholder.empty()
-                                error_msg = str(out.get("error", out)) if isinstance(out, dict) else str(out)
-                                result_placeholder.error(f"❌ Error generant l'audiodescripció: {error_msg}")
-                        
-                        except Exception as e:
-                            progress_placeholder.empty()
-                            result_placeholder.error(f"❌ Excepció durant la generació: {e}")
+                
+                with col_faces:
+                    if all_faces:
+                        carousel_key = f"combined_face_{pidx}"
+                        if f"{carousel_key}_idx" not in st.session_state:
+                            st.session_state[f"{carousel_key}_idx"] = 0
+                        cur = st.session_state[f"{carousel_key}_idx"]
+                        if cur >= len(all_faces):
+                            cur = 0
+                        st.session_state[f"{carousel_key}_idx"] = cur
+                        fname = all_faces[cur]
+                        ch = face_data["char_data"] if face_data else {}
+                        if fname.startswith("/files/"):
+                            img_url = f"{backend_base_url}{fname}"
+                        else:
+                            base = ch.get("image_url") or ""
+                            base_dir = "/".join((base or "/").split("/")[:-1])
+                            img_url = f"{backend_base_url}{base_dir}/{fname}" if base_dir else f"{backend_base_url}{fname}"
+                        st.image(img_url, width=150)
+                        st.caption(f"Cara {cur+1}/{len(all_faces)}")
+                        bcol1, bcol2 = st.columns(2)
+                        with bcol1:
+                            if st.button("⬅️", key=f"combined_face_prev_{pidx}"):
+                                st.session_state[f"{carousel_key}_idx"] = (cur - 1) % len(all_faces)
+                                st.rerun()
+                        with bcol2:
+                            if st.button("➡️", key=f"combined_face_next_{pidx}"):
+                                st.session_state[f"{carousel_key}_idx"] = (cur + 1) % len(all_faces)
+                                st.rerun()
+                    else:
+                        st.info("Sense imatges")
+                
+                with col_voices:
+                    if voice_data:
+                        clips = voice_data["clips"]
+                        if clips:
+                            carousel_key = f"combined_voice_{pidx}"
+                            if f"{carousel_key}_idx" not in st.session_state:
+                                st.session_state[f"{carousel_key}_idx"] = 0
+                            cur = st.session_state[f"{carousel_key}_idx"]
+                            if cur >= len(clips):
+                                cur = 0
+                            st.session_state[f"{carousel_key}_idx"] = cur
+                            fname = clips[cur]
+                            audio_url = f"{backend_base_url}/audio/{vname}/{fname}" if (vname and fname) else None
+                            if audio_url:
+                                st.audio(audio_url, format="audio/wav")
+                            st.caption(f"Veu {cur+1}/{len(clips)}")
+                            bcol1, bcol2 = st.columns(2)
+                            with bcol1:
+                                if st.button("⬅️", key=f"combined_voice_prev_{pidx}"):
+                                    st.session_state[f"{carousel_key}_idx"] = (cur - 1) % len(clips)
+                                    st.rerun()
+                            with bcol2:
+                                if st.button("➡️", key=f"combined_voice_next_{pidx}"):
+                                    st.session_state[f"{carousel_key}_idx"] = (cur + 1) % len(clips)
+                                    st.rerun()
+                        else:
+                            st.info("Sense clips de veu")
+                    else:
+                        st.info("Sense dades de veu")
+                
+                with col_text:
+                    combined_name_key = f"combined_char_{pidx}_name"
+                    combined_desc_key = f"combined_char_{pidx}_desc"
+                    
+                    if combined_name_key not in st.session_state:
+                        st.session_state[combined_name_key] = norm_name
+                    if combined_desc_key not in st.session_state:
+                        st.session_state[combined_desc_key] = combined_description
+                    
+                    st.text_input("Nom del personatge", key=combined_name_key, label_visibility="collapsed", placeholder="Nom del personatge")
+                    st.text_area("Descripció", key=combined_desc_key, height=120, label_visibility="collapsed", placeholder="Descripció del personatge")
+            
+            # --- 7. Generar audiodescripció ---
+            st.markdown("---")
+            if st.button("🎬 Generar audiodescripció", type="primary", use_container_width=True):
+                v = st.session_state.get("video_uploaded")
+                if not v:
+                    st.error("No hi ha cap vídeo carregat.")
+                else:
+                    progress_placeholder = st.empty()
+                    result_placeholder = st.empty()
+                    
+                    with st.spinner("Generant audiodescripció... Aquest procés pot trigar diversos minuts."):
+                        progress_placeholder.info("⏳ Processant vídeo i generant audiodescripció UNE-153010...")
+                        
+                        try:
+                            out = api.generate_audiodescription(v["bytes"], v["name"])
+                            
+                            if isinstance(out, dict) and out.get("status") == "done":
+                                progress_placeholder.success("✅ Audiodescripció generada correctament!")
+                                res = out.get("results", {})
+                                
+                                with result_placeholder.container():
+                                    st.success("🎉 Audiodescripció completada!")
+                                    c1, c2 = st.columns([1,1])
+                                    with c1:
+                                        st.markdown("**📄 UNE-153010 SRT**")
+                                        une_srt_content = res.get("une_srt", "")
+                                        st.code(une_srt_content, language="text")
+                                        if une_srt_content:
+                                            st.download_button(
+                                                "⬇️ Descarregar UNE SRT",
+                                                data=une_srt_content,
+                                                file_name=f"{v['name']}_une.srt",
+                                                mime="text/plain"
+                                            )
+                                    with c2:
+                                        st.markdown("**📝 Narració lliure**")
+                                        free_text_content = res.get("free_text", "")
+                                        st.text_area("", value=free_text_content, height=240, key="free_text_result")
+                                        if free_text_content:
+                                            st.download_button(
+                                                "⬇️ Descarregar text lliure",
+                                                data=free_text_content,
+                                                file_name=f"{v['name']}_free.txt",
+                                                mime="text/plain"
+                                            )
+                            else:
+                                progress_placeholder.empty()
+                                error_msg = str(out.get("error", out)) if isinstance(out, dict) else str(out)
+                                result_placeholder.error(f"❌ Error generant l'audiodescripció: {error_msg}")
+                        
+                        except Exception as e:
+                            progress_placeholder.empty()
+                            result_placeholder.error(f"❌ Excepció durant la generació: {e}")

page_modules/statistics.py

@@ -15,7 +15,8 @@ def render_statistics_page() -> None:
         """
         Aquest panell mostra **estadístiques agregades per vídeo** a partir de la taula
         `feedback` de `demo/data/feedback.db`. Per a cada vídeo es calcula, segons el
-        mode triat, una puntuació per a cadascun dels `score_1` ... `score_6`.
+        mode triat, una puntuació per a cadascuna de les sis característiques
+        d'avaluació (per exemple, *Precisió Descriptiva*, *Sincronització Temporal*, etc.).
         """
     )
 
@@ -49,7 +50,7 @@ def render_statistics_page() -> None:
             list(order_options.keys()),
             help=(
                 "Indica el camp pel qual s'ordenen els vídeos a la taula: "
-                "nom del vídeo o algun dels score_1 .. score_6."
+                "nom del vídeo o alguna de les sis característiques d'avaluació."
             ),
         )
 
@@ -65,17 +66,26 @@ def render_statistics_page() -> None:
     ascending = order_key == "video_name"
     df = df.sort_values(order_key, ascending=ascending, na_position="last")
 
+    # Preparar taula per mostrar: seleccionar columnes i arrodonir valors numèrics
+    display_cols = [
+        "video_name",
+        "n",
+        "score_1",
+        "score_2",
+        "score_3",
+        "score_4",
+        "score_5",
+        "score_6",
+    ]
+    df_display = df[display_cols].copy()
+
+    # Arrodonir scores a la unitat (0 decimals)
+    score_cols = [c for c in display_cols if c.startswith("score_")]
+    df_display[score_cols] = df_display[score_cols].round(0)
+
     st.subheader("Taula agregada per vídeo")
     st.dataframe(
-        df[[
-            "video_name",
-            "n",
-            "score_1",
-            "score_2",
-            "score_3",
-            "score_4",
-            "score_5",
-            "score_6",
-        ]].rename(columns=label_map),
+        df_display.rename(columns=label_map),
         use_container_width=True,
+        hide_index=True,
     )