Upload 2 files

app.py

@@ -0,0 +1,1165 @@
+import importlib
+import subprocess
+import sys
+import zipfile
+import os
+import time
+import torch
+import gradio as gr
+from moviepy.editor import VideoFileClip, AudioFileClip
+from pydub import AudioSegment
+import shutil
+import atexit
+
+def install_package(name, pkg_type, upgrade=False, import_name=None, check_cmd=None):
+    if pkg_type == "pip":
+        import_name = import_name or name.replace("-", "_")
+        try:
+            importlib.import_module(import_name)
+            if upgrade:
+                print(f"⏫ Nâng cấp {name} ...")
+                subprocess.check_call([sys.executable, "-m", "pip", "install", "--upgrade", name])
+            else:
+                print(f"✅ Đã có sẵn: {name}")
+        except ImportError:
+            print(f"⏳ Đang cài đặt: {name} ...")
+            subprocess.check_call([sys.executable, "-m", "pip", "install", name])
+
+# Chỉ sửa từ phía dưới này.
+install_package("gradio", "pip", upgrade=False)
+install_package("faster-whisper", "pip", upgrade=False)
+install_package("yt-dlp", "pip", upgrade=False, import_name="yt_dlp")
+
+import os
+import time
+import torch
+import gradio as gr
+from moviepy.editor import VideoFileClip, AudioFileClip
+from pydub import AudioSegment
+import shutil
+import atexit
+
+# ====== LAZY LOADING: Không load model ngay ======
+model = None
+batched_model = None
+device = "cuda" if torch.cuda.is_available() else "cpu"
+compute_type = "float16" if torch.cuda.is_available() else "float32"
+model_size = "large-v3"
+
+# Hallucination blocklist
+HALLUCINATION_BLOCKLIST = [
+    "Hãy subscribe cho kênh Ghiền Mì Gõ",
+    "Để không bỏ lỡ những video hấp dẫn",
+    "Hãy đăng ký kênh để ủng hộ kênh của mình nhé",
+    "Cảm ơn các bạn đã theo dõi",
+]
+
+# ====== [WEBM] Các định dạng được coi là "audio-only" (xử lý như audio, bỏ qua video track) ======
+WEBM_AS_AUDIO_EXTS = {'.webm'}
+
+def load_whisper_model():
+    """Load model chỉ khi cần thiết"""
+    global model, batched_model
+    if model is None:
+        print("🔄 Đang load Whisper model...")
+        from faster_whisper import WhisperModel, BatchedInferencePipeline
+        model = WhisperModel(
+            model_size,
+            device=device,
+            compute_type=compute_type,
+        )
+        batched_model = BatchedInferencePipeline(model=model)
+        print("✅ Model đã load xong!")
+    return model, batched_model
+
+# Lưu danh sách temp directories để cleanup sau
+temp_dirs = []
+
+def cleanup_temp_files():
+    """Xóa tất cả temporary files khi thoát"""
+    for temp_dir in temp_dirs:
+        try:
+            if os.path.exists(temp_dir):
+                shutil.rmtree(temp_dir)
+        except Exception as e:
+            print(f"Không thể xóa {temp_dir}: {e}")
+
+# Đăng ký cleanup khi thoát
+atexit.register(cleanup_temp_files)
+
+def format_timestamp(seconds, include_milliseconds=True):
+    """Format timestamp từ giây sang HH:MM:SS.mmm hoặc HH:MM:SS"""
+    if seconds is None:
+        return "00:00:00.000"
+    h, m, s = int(seconds) // 3600, (int(seconds) % 3600) // 60, int(seconds) % 60
+    if include_milliseconds:
+        ms = int((seconds - int(seconds)) * 1000)
+        return f"{h:02d}:{m:02d}:{s:02d}.{ms:03d}"
+    else:
+        return f"{h:02d}:{m:02d}:{s:02d}"
+
+def webm_to_mp3(webm_path, output_dir=None):
+    """
+    [WEBM] Convert file .webm sang .mp3 bằng FFmpeg (extract audio track).
+    Trả về đường dẫn file mp3 đã tạo.
+    """
+    if output_dir is None:
+        output_dir = os.path.dirname(webm_path)
+    os.makedirs(output_dir, exist_ok=True)
+    file_basename = os.path.splitext(os.path.basename(webm_path))[0]
+    mp3_path = os.path.join(output_dir, f"{file_basename}.mp3")
+    cmd = [
+        'ffmpeg',
+        '-i', webm_path,
+        '-vn',                  # Bỏ video track
+        '-acodec', 'libmp3lame',
+        '-q:a', '2',
+        mp3_path,
+        '-y'
+    ]
+    result = subprocess.run(cmd, capture_output=True)
+    if result.returncode != 0:
+        raise RuntimeError(
+            f"FFmpeg không thể convert WebM sang MP3:\n{result.stderr.decode(errors='replace')}"
+        )
+    return mp3_path
+
+def get_duration(file_path):
+    """Lấy duration từ file"""
+    if not file_path:
+        return 100
+
+    clip = None
+    try:
+        file_ext = os.path.splitext(file_path)[1].lower()
+
+        # [WEBM] Dùng FFmpeg probe thay vì MoviePy để tránh lỗi codec
+        if file_ext in WEBM_AS_AUDIO_EXTS:
+            result = subprocess.run(
+                ['ffprobe', '-v', 'error', '-show_entries', 'format=duration',
+                 '-of', 'default=noprint_wrappers=1:nokey=1', file_path],
+                capture_output=True, text=True
+            )
+            duration_str = result.stdout.strip()
+            return float(duration_str) if duration_str else 100
+
+        if file_ext in ['.mp4', '.mkv', '.avi', '.mov', '.flv']:
+            clip = VideoFileClip(file_path)
+            duration = clip.duration
+            clip.close()
+        else:
+            audio = AudioSegment.from_file(file_path)
+            duration = len(audio) / 1000.0
+        return duration
+    except:
+        return 100
+    finally:
+        if clip:
+            clip.close()
+
+def download_and_convert_to_mp3(url):
+    """Tải video từ URL và convert sang MP3 (giữ lại video gốc)"""
+    if not url or not url.strip():
+        return None, None, "", 999999, 0
+
+    clip = None
+    try:
+        import yt_dlp
+        temp_dir = os.path.join(os.getcwd(), "temp_downloads")
+        os.makedirs(temp_dir, exist_ok=True)
+        temp_dirs.append(temp_dir)
+
+        # Tải video/audio tốt nhất
+        ydl_opts = {
+            'format': 'bestvideo+bestaudio/best',
+            'outtmpl': os.path.join(temp_dir, '%(title)s.%(ext)s'),
+            'quiet': True,
+            'no_warnings': True,
+            'http_headers': {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            }
+        }
+
+        yield None, None, "Đang tải video...", 999999, 0
+
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            info = ydl.extract_info(url)
+            video_filename = ydl.prepare_filename(info)
+            video_title = info.get('title', 'audio')
+            uploader = info.get('uploader', 'N/A')
+            view_count = info.get('view_count', 0)
+
+        yield None, None, "Đang chuyển đổi sang MP3...", 999999, 0
+
+        # Convert sang MP3
+        file_ext = os.path.splitext(video_filename)[1].lower()
+        mp3_filename = os.path.join(temp_dir, f"{video_title}.mp3")
+
+        # [WEBM] Dùng FFmpeg extract audio, không dùng MoviePy
+        if file_ext in WEBM_AS_AUDIO_EXTS:
+            mp3_filename = webm_to_mp3(video_filename, output_dir=temp_dir)
+            duration = get_duration(video_filename)
+        elif file_ext in ['.mp4', '.mkv', '.avi', '.mov', '.flv']:
+            clip = VideoFileClip(video_filename)
+            clip.audio.write_audiofile(mp3_filename, logger=None)
+            duration = clip.duration
+            clip.close()
+        else:
+            audio = AudioSegment.from_file(video_filename)
+            audio.export(mp3_filename, format='mp3')
+            duration = len(audio) / 1000.0
+
+        info_text = f"""📹 **Tiêu đề:** {video_title}
+👤 **Kênh:** {uploader}
+👁️ **Lượt xem:** {view_count:,}
+⏱️ **Thời lượng:** {int(duration//60)}:{int(duration%60):02d} ({duration:.1f} giây)
+✅ **Đã convert sang MP3**"""
+
+        # Trả về cả MP3 (để transcribe) và video gốc (để trim)
+        yield (
+            mp3_filename,
+            video_filename,
+            info_text,
+            duration,
+            0
+        )
+
+    except Exception as e:
+        yield None, None, f"❌ Lỗi: {str(e)}", 999999, 0
+
+    finally:
+        if clip:
+            clip.close()
+
+def process_upload(file_path):
+    """Xử lý file upload"""
+    if not file_path:
+        return None, None, "", 999999, 0
+
+    clip = None
+    try:
+        file_ext = os.path.splitext(file_path)[1].lower()
+        file_name = os.path.basename(file_path)
+        file_size = os.path.getsize(file_path) / (1024 * 1024)  # MB
+
+        yield None, None, "Đang xử lý file upload...", 999999, 0
+
+        # [WEBM] Xử lý như audio: extract MP3 bằng FFmpeg, không dùng VideoFileClip
+        if file_ext in WEBM_AS_AUDIO_EXTS:
+            temp_dir = os.path.join(os.getcwd(), "temp_webm_upload")
+            os.makedirs(temp_dir, exist_ok=True)
+            temp_dirs.append(temp_dir)
+
+            mp3_path = webm_to_mp3(file_path, output_dir=temp_dir)
+            duration = get_duration(file_path)
+            file_type = "Audio (WebM)"
+            video_file = None  # Không treat như video, không hiện preview video
+
+            info_text = f"""📁 **Tên file:** {file_name}
+🎵 **Loại:** {file_type}
+💾 **Kích thước:** {file_size:.2f} MB
+⏱️ **Thời lượng:** {int(duration//60)}:{int(duration%60):02d} ({duration:.1f}s)
+✅ **Đã extract audio sang MP3**"""
+
+            yield (
+                mp3_path,   # current_file → MP3 để transcribe & trim
+                video_file, # video_file_state → None (không có video track)
+                info_text,
+                duration,
+                0
+            )
+            return
+
+        if file_ext in ['.mp4', '.mkv', '.avi', '.mov', '.flv']:
+            clip = VideoFileClip(file_path)
+            duration = clip.duration
+            clip.close()
+            file_type = "Video"
+            video_file = file_path
+        elif file_ext in ['.mp3', '.wav', '.m4a', '.ogg', '.flac', '.aac']:
+            audio = AudioSegment.from_file(file_path)
+            duration = len(audio) / 1000.0
+            file_type = "Audio"
+            video_file = None
+        else:
+            yield None, None, f"⚠️ Định dạng file không đ��ợc hỗ trợ: {file_ext}", 999999, 0
+            return
+
+        info_text = f"""📁 **Tên file:** {file_name}
+🎬 **Loại:** {file_type}
+💾 **Kích thước:** {file_size:.2f} MB
+⏱️ **Thời lượng:** {int(duration//60)}:{int(duration%60):02d} ({duration:.1f}s)"""
+
+        yield (
+            file_path,
+            video_file,
+            info_text,
+            duration,
+            0
+        )
+
+    except Exception as e:
+        yield None, None, f"❌ Lỗi: {str(e)}", 999999, 0
+    finally:
+        if clip:
+            clip.close()
+
+def convert_to_mp3(audio_file, video_file, bitrate, sample_rate):
+    """
+    Convert audio/video sang MP3 với bitrate và sample rate tùy chọn (tối ưu cho transcribe).
+    """
+    if not audio_file and not video_file:
+        yield None, "⚠️ Không có file để convert."
+        return
+
+    try:
+        input_file = video_file if video_file else audio_file
+        file_basename = os.path.splitext(os.path.basename(input_file))[0]
+
+        temp_dir = os.path.join(os.getcwd(), "temp_converted")
+        os.makedirs(temp_dir, exist_ok=True)
+        temp_dirs.append(temp_dir)
+
+        mp3_file = os.path.join(temp_dir, f"{file_basename}_{bitrate}_{sample_rate}hz.mp3")
+
+        yield None, "⏳ Đang convert sang MP3..."
+
+        cmd = [
+            'ffmpeg',
+            '-i', input_file,
+            '-vn',
+            '-acodec', 'libmp3lame',
+            '-b:a', bitrate,
+            '-ar', str(sample_rate),
+            mp3_file,
+            '-y'
+        ]
+        result = subprocess.run(cmd, capture_output=True)
+        if result.returncode != 0:
+            yield None, f"❌ Lỗi FFmpeg: {result.stderr.decode(errors='replace')}"
+            return
+
+        file_size_kb = os.path.getsize(mp3_file) / 1024
+        status_msg = (
+            f"✅ Convert thành công!\n"
+            f"📁 File: {os.path.basename(mp3_file)}\n"
+            f"🎵 Bitrate: {bitrate} | Sample rate: {sample_rate} Hz\n"
+            f"💾 Kích thước: {file_size_kb:.1f} KB"
+        )
+        yield mp3_file, status_msg
+
+    except Exception as e:
+        import traceback
+        yield None, f"❌ Lỗi: {str(e)}\n{traceback.format_exc()}"
+
+def generate_srt(segments, start_offset=0):
+    """Tạo nội dung file SRT từ segments"""
+    srt_content = []
+    for i, segment in enumerate(segments, start=1):
+        start_time = segment.start + start_offset
+        end_time = segment.end + start_offset
+        start_ts = format_timestamp(start_time).replace('.', ',')
+        end_ts = format_timestamp(end_time).replace('.', ',')
+        srt_content.append(f"{i}")
+        srt_content.append(f"{start_ts} --> {end_ts}")
+        srt_content.append(segment.text.strip())
+        srt_content.append("")
+    return "\n".join(srt_content)
+
+def generate_vtt(segments, start_offset=0):
+    """Tạo nội dung file VTT từ segments"""
+    vtt_content = ["WEBVTT", ""]
+    for segment in segments:
+        start_time = segment.start + start_offset
+        end_time = segment.end + start_offset
+        start_ts = format_timestamp(start_time)
+        end_ts = format_timestamp(end_time)
+        vtt_content.append(f"{start_ts} --> {end_ts}")
+        vtt_content.append(segment.text.strip())
+        vtt_content.append("")
+    return "\n".join(vtt_content)
+
+def format_transcript_display(raw_segments, include_timestamps_value, original_trim_start_time):
+    """Formats the transcript text based on stored segments and timestamp preference."""
+    if not raw_segments:
+        return ""
+
+    current_transcript_lines = []
+    for segment in raw_segments:
+        actual_start = segment.start + original_trim_start_time
+        actual_end = segment.end + original_trim_start_time
+
+        text = segment.text.strip()
+        for block_phrase in HALLUCINATION_BLOCKLIST:
+            if block_phrase in text:
+                text = text.replace(block_phrase, "").strip()
+                print(f"Removed hallucination: '{block_phrase}' from segment.")
+
+        if include_timestamps_value:
+            start_ts = format_timestamp(actual_start, include_milliseconds=False)
+            end_ts = format_timestamp(actual_end, include_milliseconds=False)
+            current_transcript_lines.append(f"[{start_ts} → {end_ts}] {text}")
+        else:
+            current_transcript_lines.append(text)
+    return "\n".join(current_transcript_lines)
+
+def transcribe_audio(input_file, video_file, method, beam_size, start_time, end_time, include_timestamps, batch_size, min_silence_duration_ms, speech_pad_ms, no_speech_threshold, condition_on_previous_text, minimum_speech_duration):
+    """Transcribe audio file với các tùy chọn nâng cao (đã tối ưu)"""
+    if not input_file:
+        yield ("⚠️ Không có file audio. Vui lòng upload hoặc nhập URL YouTube.", None, None, None, None, None, None, None, 0)
+        return
+
+    try:
+        # Load model khi cần
+        model, batched_model = load_whisper_model()
+
+        beam_size = int(beam_size)
+        batch_size = int(batch_size)
+        min_silence_duration_ms = int(min_silence_duration_ms)
+        speech_pad_ms = int(speech_pad_ms)
+        no_speech_threshold = float(no_speech_threshold)
+        minimum_speech_duration = float(minimum_speech_duration)
+
+        start_transcribe = time.time()
+
+        # Xác định file cần transcribe (trimmed hoặc full)
+        duration = get_duration(input_file)
+        is_trimmed = not (start_time == 0 and end_time >= duration)
+
+        # Nếu có trim, tạo file trimmed trước khi transcribe
+        actual_start_offset_for_transcription = 0
+        if is_trimmed:
+            if start_time >= end_time:
+                yield ("❌ Thời gian bắt đầu phải nhỏ hơn thời gian kết thúc.", None, None, None, None, None, None, None, 0)
+                return
+
+            temp_dir_trim_for_transcribe = os.path.join(os.getcwd(), "temp_transcribe_for_stream")
+            os.makedirs(temp_dir_trim_for_transcribe, exist_ok=True)
+            temp_dirs.append(temp_dir_trim_for_transcribe)
+
+            file_basename = os.path.splitext(os.path.basename(input_file))[0]
+            import datetime
+            ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            trimmed_file = os.path.join(temp_dir_trim_for_transcribe, f"{file_basename}_transcribe_{ts}.mp3")
+
+            # Trim bằng FFmpeg (nhanh nhất) — input_file lúc này luôn là .mp3 (kể cả từ WebM)
+            cmd = [
+                'ffmpeg',
+                '-ss', str(start_time),
+                '-i', input_file,
+                '-t', str(end_time - start_time),
+                '-acodec', 'libmp3lame',
+                '-q:a', '2',
+                trimmed_file,
+                '-y'
+            ]
+            subprocess.run(cmd, capture_output=True, check=True)
+            audio_to_transcribe = trimmed_file
+            actual_start_offset_for_transcription = start_time
+        else:
+            audio_to_transcribe = input_file
+
+        # Transcribe với VAD optimization
+        segments_generator = None
+        info = None
+        if method == "model.transcribe":
+            segments_generator, info = model.transcribe(
+                audio_to_transcribe,
+                beam_size=beam_size,
+                vad_filter=True,
+                vad_parameters=dict(
+                    min_silence_duration_ms=min_silence_duration_ms,
+                    speech_pad_ms=speech_pad_ms
+                ),
+                temperature=0,
+                word_timestamps=True,
+                condition_on_previous_text=condition_on_previous_text
+            )
+        else:
+            segments_generator, info = batched_model.transcribe(
+                audio_to_transcribe,
+                beam_size=beam_size,
+                batch_size=batch_size,
+                temperature=0,
+                condition_on_previous_text=condition_on_previous_text
+            )
+
+        # --- Streaming part ---
+        current_transcript_lines = []
+        full_text_list = []
+        all_segments_for_files = []
+
+        yield ("Bắt đầu transcription...", None, None, None, None, None, None, None, 0)
+
+        for i, segment in enumerate(segments_generator):
+            all_segments_for_files.append(segment)
+
+            actual_start_stream = segment.start + actual_start_offset_for_transcription
+            actual_end_stream = segment.end + actual_start_offset_for_transcription
+
+            text = segment.text.strip()
+            for block_phrase in HALLUCINATION_BLOCKLIST:
+                if block_phrase in text:
+                    text = text.replace(block_phrase, "").strip()
+                    print(f"Removed hallucination: '{block_phrase}' from segment.")
+
+            if include_timestamps:
+                start_ts = format_timestamp(actual_start_stream, include_milliseconds=False)
+                end_ts = format_timestamp(actual_end_stream, include_milliseconds=False)
+                current_transcript_lines.append(f"[{start_ts} → {end_ts}] {text}")
+            else:
+                current_transcript_lines.append(text)
+
+            full_text_list.append(text)
+
+            yield ("\n".join(current_transcript_lines), None, None, None, None, None, None, None, 0)
+
+        # --- End of Streaming part, now process final files ---
+
+        if not all_segments_for_files:
+            yield ("⚠️ Không có nội dung được transcribe. Vui lòng kiểm tra file hoặc tùy chọn cắt.", None, None, None, None, None, None, None, 0)
+            return
+
+        transcript_text = format_transcript_display(all_segments_for_files, include_timestamps, actual_start_offset_for_transcription)
+
+        srt_content = generate_srt(all_segments_for_files, start_offset=(actual_start_offset_for_transcription))
+        vtt_content = generate_vtt(all_segments_for_files, start_offset=(actual_start_offset_for_transcription))
+
+        transcribe_time = time.time() - start_transcribe
+        detected_lang = info.language if hasattr(info, 'language') else "Unknown"
+        lang_prob = info.language_probability if hasattr(info, 'language_probability') else 0
+
+        file_basename = os.path.splitext(os.path.basename(input_file))[0]
+        import datetime
+        ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        file_suffix = f"_{ts}"
+
+        # Save files
+        txt_file = f"{file_basename}{file_suffix}.txt"
+        with open(txt_file, "w", encoding="utf-8") as f:
+            f.write(f"=== TRANSCRIPTION INFO ===\n")
+            f.write(f"Model: {model_size}\n")
+            f.write(f"Compute type: {compute_type}\n")
+            f.write(f"Device: {device}\n")
+            f.write(f"Method: {method}\n")
+            f.write(f"Beam size: {beam_size}\n")
+            f.write(f"Batch size (BatchedInferencePipeline): {batch_size}\n")
+            f.write(f"VAD min_silence_duration_ms: {min_silence_duration_ms}\n")
+            f.write(f"VAD speech_pad_ms: {speech_pad_ms}\n")
+            f.write(f"VAD no_speech_threshold: {no_speech_threshold} (Not applicable for model.transcribe)\n")
+            f.write(f"VAD minimum_speech_duration: {minimum_speech_duration} (Not applicable for model.transcribe)\n")
+            f.write(f"Condition on previous text: {condition_on_previous_text}\n")
+            f.write(f"Language: {detected_lang} (confidence: {lang_prob:.2%})\n")
+            f.write(f"Processing time: {transcribe_time:.2f}s\n")
+            f.write(f"File: {file_basename}\n")
+            if is_trimmed:
+                f.write(f"Trimmed: {start_time}s - {end_time}s ({end_time - start_time:.1f}s)\n")
+            else:
+                f.write(f"Full file transcription\n")
+            f.write(f"\n=== TIMESTAMPED TRANSCRIPT ===\n")
+            f.write(transcript_text)
+            f.write(f"\n\n=== FULL TEXT ===\n")
+            f.write(" ".join(full_text_list))
+            f.write(f"\n\n=== METADATA ===\n")
+            f.write(f"Total segments: {len(all_segments_for_files)}\n")
+            f.write(f"Total characters: {len(' '.join(full_text_list))}\n")
+
+        srt_file = f"{file_basename}{file_suffix}.srt"
+        with open(srt_file, "w", encoding="utf-8") as f:
+            f.write(srt_content)
+
+        vtt_file = f"{file_basename}{file_suffix}.vtt"
+        with open(vtt_file, "w", encoding="utf-8") as f:
+            f.write(vtt_content)
+
+        info_display = f"""
+⏱️ Processing time            : {transcribe_time:.2f}s
+🌐 Language                   : {detected_lang} ({lang_prob:.2%})
+📊 Segments                   : {len(all_segments_for_files)}
+{'✂️ Trimmed                  :' + str(start_time) + 's - ' + str(end_time) + 's' if is_trimmed else '📄 Full file transcription'}
+💻 Device                     : {device}
+🧠 Model                      : {model_size}
+⚙️ Compute type               : {compute_type}
+Batch size (BatchedInferencePipeline) : {batch_size}
+VAD min_silence_duration_ms  : {min_silence_duration_ms}
+VAD speech_pad_ms            : {speech_pad_ms}
+VAD no_speech_threshold      : {no_speech_threshold} (Not applicable for model.transcribe)
+VAD minimum_speech_duration  : {minimum_speech_duration} (Not applicable for model.transcribe)
+Condition on previous text   : {condition_on_previous_text}
+
+"""
+
+        # Determine which files to return (trimmed or original)
+        return_mp3 = input_file
+        return_mp4 = video_file if video_file else None
+
+        if is_trimmed:
+            temp_dir_final_trimmed = os.path.join(os.getcwd(), "temp_output_final")
+            os.makedirs(temp_dir_final_trimmed, exist_ok=True)
+            temp_dirs.append(temp_dir_final_trimmed)
+
+            trimmed_mp3 = os.path.join(temp_dir_final_trimmed, f"{file_basename}_{ts}.mp3")
+            trimmed_video = None
+
+            if video_file:
+                file_ext = os.path.splitext(video_file)[1]
+                trimmed_video = os.path.join(temp_dir_final_trimmed, f"{file_basename}_{ts}{file_ext}")
+
+                duration_trim = end_time - start_time
+                cmd = [
+                    'ffmpeg',
+                    '-ss', str(start_time),
+                    '-i', video_file,
+                    '-t', str(duration_trim),
+                    '-c', 'copy',
+                    '-avoid_negative_ts', 'make_zero',
+                    trimmed_video,
+                    '-y'
+                ]
+                subprocess.run(cmd, capture_output=True, check=True)
+
+                cmd_audio = [
+                    'ffmpeg',
+                    '-i', trimmed_video,
+                    '-vn',
+                    '-acodec', 'libmp3lame',
+                    '-q:a', '2',
+                    trimmed_mp3,
+                    '-y'
+                ]
+                subprocess.run(cmd_audio, capture_output=True, check=True)
+
+                return_mp3 = trimmed_mp3
+                return_mp4 = trimmed_video
+            else:
+                import shutil
+                shutil.copy2(audio_to_transcribe, trimmed_mp3)
+                return_mp3 = trimmed_mp3
+                return_mp4 = None
+
+        # Clear GPU cache after transcription
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+        # Final yield with all outputs
+        yield (
+            transcript_text,
+            txt_file,
+            srt_file,
+            vtt_file,
+            return_mp3,
+            return_mp4,
+            info_display,
+            all_segments_for_files,
+            actual_start_offset_for_transcription
+        )
+
+    except Exception as e:
+        import traceback
+        error_msg = f"❌ Lỗi transcription: {str(e)}\n\n{traceback.format_exc()}"
+
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+        yield (error_msg, None, None, None, None, None, None, None, 0)
+
+# Function to clear outputs
+def clear_outputs():
+    return (
+        "",                                    # transcript_output
+        gr.update(value=None, visible=False),  # source_mp3_output
+        gr.update(value=None, visible=False),  # converted_mp3_output
+        gr.update(value=None, visible=False),  # file_output
+        gr.update(value=None, visible=False),  # srt_output
+        gr.update(value=None, visible=False),  # vtt_output
+        gr.update(value=None, visible=False),  # trimmed_mp3_output
+        gr.update(value=None, visible=False),  # trimmed_mp4_output
+        gr.update(value=None, visible=False),  # cut_zip_output
+        "",                                    # statistics_output
+        "",                                    # cut_status
+        None,                                  # raw_segments_state
+        0,                                     # transcription_start_offset_state
+        gr.update(visible=False)               # clear_output_btn
+    )
+
+
+def cut_file_by_duration(audio_file, minutes_per_chunk):
+    """Cắt file mp3 thành các đoạn theo số phút"""
+    if not audio_file:
+        return [], "⚠️ Không có file audio để cắt."
+    try:
+        import datetime
+        chunk_secs = int(minutes_per_chunk) * 60
+        total_duration = get_duration(audio_file)
+        if total_duration <= chunk_secs:
+            return [], f"⚠️ File ngắn hơn {minutes_per_chunk} phút ({total_duration:.0f}s). Không cần cắt."
+        temp_dir = os.path.join(os.getcwd(), "temp_cut")
+        os.makedirs(temp_dir, exist_ok=True)
+        temp_dirs.append(temp_dir)
+        ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        file_basename = os.path.splitext(os.path.basename(audio_file))[0]
+        output_files = []
+        part = 1
+        start = 0.0
+        while start < total_duration:
+            end = min(start + chunk_secs, total_duration)
+            out_path = os.path.join(temp_dir, f"{file_basename}_part{part:02d}_{ts}.mp3")
+            cmd = ['ffmpeg', '-ss', str(start), '-i', audio_file,
+                   '-t', str(end - start), '-acodec', 'libmp3lame', '-q:a', '2', out_path, '-y']
+            result = subprocess.run(cmd, capture_output=True)
+            if result.returncode == 0:
+                output_files.append(out_path)
+            start += chunk_secs
+            part += 1
+        status = f"✅ Đã cắt thành {len(output_files)} đoạn × {minutes_per_chunk} phút"
+        return output_files, status
+    except Exception as e:
+        import traceback
+        return [], f"❌ Lỗi: {str(e)}\n{traceback.format_exc()}"
+
+
+def cut_file_by_parts(audio_file, num_parts):
+    """Cắt file mp3 thành N phần bằng nhau"""
+    if not audio_file:
+        return [], "⚠️ Không có file audio để cắt."
+    try:
+        import datetime
+        num_parts = int(num_parts)
+        total_duration = get_duration(audio_file)
+        chunk_secs = total_duration / num_parts
+        temp_dir = os.path.join(os.getcwd(), "temp_cut")
+        os.makedirs(temp_dir, exist_ok=True)
+        temp_dirs.append(temp_dir)
+        ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        file_basename = os.path.splitext(os.path.basename(audio_file))[0]
+        output_files = []
+        for part in range(1, num_parts + 1):
+            start = (part - 1) * chunk_secs
+            out_path = os.path.join(temp_dir, f"{file_basename}_part{part:02d}of{num_parts}_{ts}.mp3")
+            cmd = ['ffmpeg', '-ss', str(start), '-i', audio_file,
+                   '-t', str(chunk_secs), '-acodec', 'libmp3lame', '-q:a', '2', out_path, '-y']
+            result = subprocess.run(cmd, capture_output=True)
+            if result.returncode == 0:
+                output_files.append(out_path)
+        status = f"✅ Đã cắt thành {len(output_files)} phần (~{chunk_secs/60:.1f} phút/phần)"
+        return output_files, status
+    except Exception as e:
+        import traceback
+        return [], f"❌ Lỗi: {str(e)}\n{traceback.format_exc()}"
+
+
+def do_cut_file(audio_file, cut_mode, minutes_val, parts_val):
+    """Dispatcher: cắt theo phút hoặc theo phần, đóng gói zip"""
+    if not audio_file:
+        yield gr.update(value=None, visible=False), "⚠️ Không có file audio."
+        return
+    yield gr.update(visible=False), "⏳ Đang cắt file..."
+    if cut_mode == "Theo phút":
+        files, status = cut_file_by_duration(audio_file, minutes_val)
+    else:
+        files, status = cut_file_by_parts(audio_file, parts_val)
+    if not files:
+        yield gr.update(value=None, visible=False), status
+        return
+    import zipfile, datetime
+    ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    file_basename = os.path.splitext(os.path.basename(audio_file))[0]
+    zip_dir = os.path.join(os.getcwd(), "temp_cut")
+    os.makedirs(zip_dir, exist_ok=True)
+    zip_path = os.path.join(zip_dir, f"{file_basename}_cut_{ts}.zip")
+    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zf:
+        for f in files:
+            zf.write(f, os.path.basename(f))
+    zip_size_mb = os.path.getsize(zip_path) / (1024 * 1024)
+    status += f"\n📦 ZIP: {os.path.basename(zip_path)} ({zip_size_mb:.1f} MB)"
+    yield gr.update(value=zip_path, visible=True), status
+
+
+# ====== GRADIO INTERFACE ======
+
+css = """
+#textbox_id textarea {
+  color: black !important;
+  font-size: 16px !important;
+  font-family: 'IBM Plex Sans', sans-serif !important;
+}
+
+#textbox_id placeholder::textarea {
+  color: black !important;
+  font-size: 16px !important;
+  font-family: 'IBM Plex Sans', sans-serif !important;
+}
+
+#method_dropdown .menu button {
+  color: *primary_50 !important;
+  font-size: 16px !important;
+}
+"""
+
+theme = gr.themes.Default().set(
+    block_background_fill='*primary_50',
+    block_border_color='*button_primary_border_color',
+    block_label_text_color='*secondary_600',
+    block_info_text_color='*primary_700',
+    block_title_text_color='*primary_700',
+    body_text_size='*text_lg'
+)
+
+with gr.Blocks(theme=theme, css=css, title="Media Transcriber with Trimming") as demo:
+
+    gr.Markdown("# 🎤 Media Transcriber with Trimming")
+    gr.Markdown("Download từ YouTube (convert MP3) hoặc upload file, cắt (tùy chọn), và transcribe với faster-whisper")
+
+    with gr.Tab("Transcription"):
+        current_file = gr.State()
+        video_file_state = gr.State()
+        is_from_url = gr.State(False)
+        raw_segments_state = gr.State(None)
+        transcription_start_offset_state = gr.State(0)
+        transcribe_start_state = gr.State(0)
+        transcribe_end_state = gr.State(999999)
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                url_input = gr.Textbox(
+                    label="YouTube URL (tùy chọn)",
+                    autoscroll=False,
+                    elem_id="textbox_id",
+                    lines=1,
+                    max_lines=1,
+                    placeholder="Nhập URL YouTube để tự động tải và convert sang MP3...",
+                )
+                upload_file = gr.File(
+                    label="Upload file audio/video từ máy tính (.mp3 .wav .m4a .ogg .flac .aac .webm .mp4 .mkv .avi .mov .flv)",
+                    file_types=["video", "audio", ".webm"],
+                    type="filepath"
+                )
+                media_info = gr.Markdown(value="Nhập URL hoặc upload file để xem thông tin...")
+                output_preview = gr.Video(label="Preview (Media gốc)", height=300)
+
+                with gr.Row():
+                    bitrate_dropdown = gr.Dropdown(
+                        choices=["32k", "64k"],
+                        value="32k",
+                        label="🎚️ Bitrate",
+                        info="32k: nhỏ hơn | 64k: tốt hơn một chút",
+                        scale=1,
+                    )
+                    sample_rate_dropdown = gr.Dropdown(
+                        choices=["8000", "16000"],
+                        value="16000",
+                        label="📊 Sample Rate (Hz)",
+                        info="8kHz: tối thiểu | 16kHz: khuyến nghị cho transcribe",
+                        scale=1,
+                    )
+
+                convert_btn = gr.Button("🎵 Convert MP3", variant="secondary", size="lg")
+                convert_status = gr.Markdown(value="")
+
+                transcribe_btn = gr.Button("🎙️ Transcribe", variant="primary", size="lg", interactive=False)
+
+                with gr.Accordion("🔧 Phương thức & Timestamps", open=False):
+                    with gr.Row():
+                        method_dropdown = gr.Dropdown(
+                            choices=["model.transcribe", "BatchedInferencePipeline"],
+                            label="Phương thức",
+                            scale=3,
+                            elem_id="method_dropdown",
+                            value="BatchedInferencePipeline",
+                            info="model.transcribe: chất lượng cao | Batched: nhanh hơn"
+                        )
+                        beam_size_dropdown = gr.Dropdown(
+                            choices=["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
+                            label="Beam Size",
+                            scale=2,
+                            elem_id="method_dropdown",
+                            value="3",
+                            info="Cao hơn = chính xác hơn nhưng chậm hơn"
+                        )
+                    include_timestamps_checkbox = gr.Checkbox(
+                        label="Bao gồm Timestamps (HH:MM:SS)",
+                        value=True,
+                        info="Bao gồm timestamps trong kết quả transcription"
+                    )
+
+                with gr.Accordion("⚙️ Tham số nâng cao (Batch & VAD)", open=False):
+                    with gr.Row():
+                        batch_size_slider = gr.Slider(
+                            minimum=1,
+                            maximum=64,
+                            value=16,
+                            step=1,
+                            label="Batch Size (BatchedInferencePipeline)",
+                            info="Số lượng đoạn âm thanh xử lý cùng lúc. Ảnh hưởng đến tốc độ và bộ nhớ GPU.",
+                            visible=True
+                        )
+                    with gr.Row():
+                        min_silence_duration_ms_slider = gr.Slider(
+                            minimum=0,
+                            maximum=2000,
+                            value=500,
+                            step=50,
+                            label="VAD: Min Silence Duration (ms)",
+                            info="Thời lượng im lặng tối thiểu để tách phân đoạn. Ảnh hưởng đến việc phát hiện câu/từ."
+                        )
+                        speech_pad_ms_slider = gr.Slider(
+                            minimum=0,
+                            maximum=1000,
+                            value=400,
+                            step=50,
+                            label="VAD: Speech Pad (ms)",
+                            info="Thêm thời gian vào đầu/cuối mỗi phân đoạn giọng nói. Giúp giữ lại bối cảnh."
+                        )
+                    with gr.Row():
+                        no_speech_threshold_slider = gr.Slider(
+                            minimum=0.0,
+                            maximum=1.0,
+                            value=0.55,
+                            step=0.05,
+                            label="VAD: No Speech Threshold",
+                            info="Ngưỡng xác định khi nào không có lời nói."
+                        )
+                        condition_on_previous_text_checkbox = gr.Checkbox(
+                            label="Condition on Previous Text",
+                            value=False,
+                            info="Sử dụng văn bản trước đó làm điều kiện để cải thiện tính nhất quán."
+                        )
+                    with gr.Row():
+                        minimum_speech_duration_slider = gr.Slider(
+                            minimum=0.0,
+                            maximum=5.0,
+                            value=0.1,
+                            step=0.05,
+                            label="VAD: Minimum Speech Duration (s)",
+                            info="Thời lượng tối thiểu của một đoạn giọng nói. Giúp lọc các âm thanh ngắn, nhiễu."
+                        )
+
+
+
+                with gr.Accordion("✂️ Cắt file MP3", open=False):
+                    cut_mode_radio = gr.Radio(
+                        choices=["Theo phút", "Theo phần"],
+                        value="Theo phút",
+                        label="Chế độ cắt",
+                        info="Chỉ chọn một chế độ"
+                    )
+                    with gr.Row():
+                        cut_minutes_dropdown = gr.Dropdown(
+                            choices=["3", "5", "10", "15"],
+                            value="5",
+                            label="⏱️ Phút mỗi đoạn",
+                            info="Áp dụng khi chọn Theo phút",
+                            interactive=True,
+                            scale=1,
+                        )
+                        cut_parts_dropdown = gr.Dropdown(
+                            choices=["2", "3", "5", "10"],
+                            value="2",
+                            label="🔢 Số phần",
+                            info="Áp dụng khi chọn Theo phần",
+                            interactive=False,
+                            scale=1,
+                        )
+                    cut_btn = gr.Button("✂️ Cut File", variant="secondary", size="lg")
+                    cut_status = gr.Markdown(value="")
+
+
+            with gr.Column(scale=3):
+                placeholder_text = (
+                "📖 Hướng dẫn: Nhập Youtube video URL và bấm ENTER \n\n"
+                "📖 Hoặc: Upload file từ máy tính \n\n"
+                "💡Lưu ý:\n- Nếu không cắt file: -> transcribe toàn bộ.\n"
+                "- Nếu cắt file: -> chỉ transcribe phần được cắt."
+                )
+                transcript_output = gr.Textbox(
+                    label="Kết quả Transcription",
+                    lines=20,
+                    interactive=True,
+                    show_copy_button=True,
+                    autoscroll=True,
+                    elem_id="textbox_id",
+                    placeholder=placeholder_text,
+                )
+                statistics_output = gr.Markdown(label="Thống kê Transcription", value="")
+                gr.Markdown("### 📥 Downloads")
+                source_mp3_output = gr.File(label="⬇️ MP3 từ Upload/URL", visible=False)
+                converted_mp3_output = gr.File(label="⬇️ MP3 đã Convert (Bitrate/Sample Rate)", visible=False)
+                with gr.Row():
+                    file_output = gr.File(label="📄 Transcript (.txt)", visible=False)
+                    srt_output = gr.File(label="📺 Subtitles (.srt)", visible=False)
+                with gr.Row():
+                    vtt_output = gr.File(label="🌐 WebVTT (.vtt)", visible=False)
+                    trimmed_mp3_output = gr.File(label="🎵 Audio MP3 (trimmed)", visible=False)
+                trimmed_mp4_output = gr.File(label="🎬 Video (trimmed - nếu có)", visible=False)
+                gr.Markdown("#### ✂️ File đã cắt")
+                cut_zip_output = gr.File(label="📦 Download ZIP các đoạn đã cắt", visible=False)
+
+                clear_output_btn = gr.Button("🧹 Xóa Kết quả", variant="secondary", visible=False)
+
+        # ====== EVENT HANDLERS ======
+        url_input.submit(
+            download_and_convert_to_mp3,
+            inputs=[url_input],
+            outputs=[current_file, video_file_state, media_info, transcribe_end_state, transcribe_start_state]
+        ).then(
+            lambda x: x,
+            inputs=[video_file_state],
+            outputs=[output_preview]
+        ).then(
+            lambda: True,
+            outputs=[is_from_url]
+        ).then(
+            fn=lambda f: gr.update(value=f, visible=True) if f else gr.update(visible=False),
+            inputs=[current_file],
+            outputs=[source_mp3_output]
+        )
+
+        upload_file.change(
+            process_upload,
+            inputs=[upload_file],
+            outputs=[current_file, video_file_state, media_info, transcribe_end_state, transcribe_start_state]
+        ).then(
+            lambda x: x,
+            inputs=[upload_file],
+            outputs=[output_preview]
+        ).then(
+            lambda: False,
+            outputs=[is_from_url]
+        ).then(
+            fn=lambda f: gr.update(value=f, visible=True) if f else gr.update(visible=False),
+            inputs=[current_file],
+            outputs=[source_mp3_output]
+        )
+
+
+
+        # ====== NÚT CONVERT MP3 ======
+        convert_btn.click(
+            fn=lambda: (gr.update(interactive=False), gr.update(interactive=False), gr.update(value="⏳ Đang convert...")),
+            inputs=None,
+            outputs=[convert_btn, transcribe_btn, convert_status]
+        ).then(
+            fn=convert_to_mp3,
+            inputs=[current_file, video_file_state, bitrate_dropdown, sample_rate_dropdown],
+            outputs=[converted_mp3_output, convert_status]
+        ).then(
+            fn=lambda f: (gr.update(interactive=True), gr.update(interactive=True), gr.update(visible=True) if f else gr.update(visible=False)),
+            inputs=[converted_mp3_output],
+            outputs=[convert_btn, transcribe_btn, converted_mp3_output]
+        )
+
+        # ====== NÚT TRANSCRIBE - Disable Trim button khi đang transcribe ======
+        transcribe_btn.click(
+            fn=lambda: (gr.update(interactive=False), gr.update(interactive=False)),
+            inputs=None,
+            outputs=[transcribe_btn, convert_btn]
+        ).then(
+            fn=transcribe_audio,
+            inputs=[
+                current_file,
+                video_file_state,
+                method_dropdown,
+                beam_size_dropdown,
+                transcribe_start_state,
+                transcribe_end_state,
+                include_timestamps_checkbox,
+                batch_size_slider,
+                min_silence_duration_ms_slider,
+                speech_pad_ms_slider,
+                no_speech_threshold_slider,
+                condition_on_previous_text_checkbox,
+                minimum_speech_duration_slider
+            ],
+            outputs=[
+                transcript_output,
+                file_output,
+                srt_output,
+                vtt_output,
+                trimmed_mp3_output,
+                trimmed_mp4_output,
+                statistics_output,
+                raw_segments_state,
+                transcription_start_offset_state
+            ]
+        ).then(
+            fn=lambda: (gr.update(interactive=True), gr.update(interactive=True)),
+            inputs=None,
+            outputs=[transcribe_btn, convert_btn]
+        ).then(
+            fn=lambda mp4: (
+                gr.update(visible=True), gr.update(visible=True), gr.update(visible=True),
+                gr.update(visible=True),
+                gr.update(visible=True) if mp4 else gr.update(visible=False),
+                gr.update(visible=True)
+            ),
+            inputs=[trimmed_mp4_output],
+            outputs=[
+                file_output, srt_output, vtt_output,
+                trimmed_mp3_output, trimmed_mp4_output,
+                clear_output_btn
+            ]
+        )
+
+        # ====== CUT FILE - Radio toggle interactivity ======
+        cut_mode_radio.change(
+            fn=lambda mode: (
+                gr.update(interactive=(mode == "Theo phút")),
+                gr.update(interactive=(mode == "Theo phần"))
+            ),
+            inputs=[cut_mode_radio],
+            outputs=[cut_minutes_dropdown, cut_parts_dropdown]
+        )
+
+        cut_btn.click(
+            fn=lambda: gr.update(interactive=False),
+            inputs=None,
+            outputs=[cut_btn]
+        ).then(
+            fn=do_cut_file,
+            inputs=[current_file, cut_mode_radio, cut_minutes_dropdown, cut_parts_dropdown],
+            outputs=[cut_zip_output, cut_status]
+        ).then(
+            fn=lambda: gr.update(interactive=True),
+            inputs=None,
+            outputs=[cut_btn]
+        )
+
+        # Clear Output button handler
+        clear_output_btn.click(
+            fn=clear_outputs,
+            inputs=None,
+            outputs=[
+                transcript_output,
+                source_mp3_output,
+                converted_mp3_output,
+                file_output,
+                srt_output,
+                vtt_output,
+                trimmed_mp3_output,
+                trimmed_mp4_output,
+                cut_zip_output,
+                statistics_output,
+                cut_status,
+                raw_segments_state,
+                transcription_start_offset_state,
+                clear_output_btn
+            ]
+        )
+
+        # Dynamic timestamp toggle handler
+        include_timestamps_checkbox.change(
+            fn=format_transcript_display,
+            inputs=[raw_segments_state, include_timestamps_checkbox, transcription_start_offset_state],
+            outputs=[transcript_output]
+        )
+
+        # Event for method_dropdown to control batch_size_slider visibility
+        method_dropdown.change(
+            fn=lambda m: gr.update(visible=(m == "BatchedInferencePipeline")),
+            inputs=[method_dropdown],
+            outputs=[batch_size_slider]
+        )
+
+# ====== QUEUE + LAUNCH ======
+demo.queue(default_concurrency_limit=2)
+demo.launch()

requirements.txt

@@ -0,0 +1,6 @@
+gradio
+faster-whisper
+yt-dlp
+moviepy
+pydub
+torch