Upload 47 files

README.md

@@ -114,6 +114,7 @@ print(f"TTS提供商: {config['tts_provider']}")
 
 ### 处理流程
 
+#### 标准处理流程
 ```
 视频URL/录制音频
     ↓
@@ -130,6 +131,39 @@ print(f"TTS提供商: {config['tts_provider']}")
 配音音频输出
 ```
 
+#### 流式异步处理流程 (v3.1 新增)
+```
+扩展点击AI配音
+    ↓
+Native Host 下载音频 (yt-dlp)
+    ↓
+扩展端上传到 HF 后端
+    ↓
+SSE 流式处理 ←──────────────────┐
+    ↓                           │
+语音识别 (Whisper V3 带时间戳)   │ 实时进度反馈
+    ↓                           │
+按时间戳智能分段                  │
+    ↓                           │
+┌─────────────────────────────┐ │
+│ 并行处理每段:                │ │
+│   翻译 (Llama 3)            │ │
+│   → TTS (Edge-TTS)          │ │
+│   → 音频同步对齐             │ │
+│   → 分段音频输出 ────────────┼─┘
+└─────────────────────────────┘
+    ↓
+第一段完成即开始播放 (目标 <30秒)
+    ↓
+隐藏遮罩，视频从头播放
+```
+
+**流式处理优势:**
+- 首段配音 30 秒内开始播放
+- 实时进度反馈，用户体验更好
+- 分段并行处理，整体速度更快
+- SSE 连接稳定，兼容 HF Spaces 代理
+
 ## 配置说明
 
 ### API 提供商选择
@@ -223,27 +257,50 @@ A:
 
 ```
 universal-fast-dubbing/
-├── backend/                 # Python后端服务
-│   ├── app.py              # Gradio主入口
-│   ├── requirements.txt    # Python依赖
-│   ├── packages.txt        # 系统依赖 (ffmpeg)
-│   ├── modules/            # 核心处理模块
-│   │   ├── gateway.py      # API网关
-│   │   ├── groq_client.py  # Groq API客户端
-│   │   ├── siliconflow_client.py  # SiliconFlow客户端
-│   │   ├── processor.py    # 配音处理器
-│   │   ├── segmenter.py    # 音频分段器
-│   │   ├── tts_generator.py  # TTS生成器
-│   │   ├── audio_sync.py   # 音频同步
-│   │   ├── router.py       # API路由
-│   │   └── ...
-│   └── temp/               # 临时文件目录
+├── app.py                   # FastAPI 主入口
+├── Dockerfile               # Docker 构建配置
+├── DEPLOYMENT.md            # 部署说明
+│
+├── backend/                 # Python 后端模块
+│   ├── requirements.txt     # Python 依赖
+│   ├── packages.txt         # 系统依赖 (ffmpeg)
+│   ├── modules/             # 核心处理模块
+│   │   ├── gateway.py       # API 网关
+│   │   ├── groq_client.py   # Groq API 客户端 (ASR + LLM)
+│   │   ├── siliconflow_client.py  # SiliconFlow 客户端
+│   │   ├── stream_processor.py    # 流式异步处理器 (v3.1)
+│   │   ├── processor.py     # 配音处理器
+│   │   ├── segmenter.py     # 音频分段器
+│   │   ├── tts_generator.py # Edge-TTS 生成器
+│   │   ├── audio_sync.py    # 音频同步引擎
+│   │   ├── router.py        # API 路由
+│   │   ├── logging_config.py # 结构化日志
+│   │   ├── performance_monitor.py # 性能监控
+│   │   └── errors.py        # 统一错误处理
+│   └── temp/                # 临时文件目录
+│
+├── templates/               # Jinja2 模板
+│   └── index.html           # Web 界面
+│
+├── static/                  # 静态资源
+│   └── style.css            # Tailwind CSS
+│
+├── extension/               # Chrome 扩展
+│   ├── manifest.json        # 扩展配置 (Manifest V3)
+│   ├── background/          # Background Service Worker
+│   │   └── background.js    # 消息处理、Native Messaging
+│   ├── content/             # Content Scripts
+│   │   └── dubbing-ui.js    # 视频页面 UI 注入
+│   ├── popup/               # Popup 界面
+│   ├── options/             # 设置页面
+│   └── icons/               # 扩展图标
 │
-└── extension/              # Chrome扩展（需单独安装）
-    ├── manifest.json       # 扩展配置
-    ├── background/         # Background Service Worker
-    ├── content/            # Content Scripts
-    └── popup/              # Popup界面
+└── local_audio_service/     # Native Host 服务
+    ├── native_host.js       # Node.js Native Messaging Host
+    ├── native_host.bat      # Windows 启动脚本
+    ├── install.bat          # 注册表安装脚本
+    ├── com.ufd.native.json  # Native Host 配置
+    └── yt-dlp.exe           # 视��下载工具
 ```
 
 ## 开发指南

backend/modules/stream_processor.py

@@ -197,6 +197,14 @@ class StreamProcessor:
         logger.info(f"[{session_id}] 开始流式处理: {audio_path}")
         
         try:
+            # 检查音频文件是否存在
+            if not os.path.exists(audio_path):
+                yield {
+                    'type': 'error',
+                    'message': f'音频文件不存在: {audio_path}'
+                }
+                return
+            
             # 1. 发送初始进度
             yield {
                 'type': 'progress',
@@ -213,18 +221,31 @@ class StreamProcessor:
                 'message': '语音识别中...'
             }
             
-            asr_result = await self._do_asr(audio_path, client_config)
+            try:
+                asr_result = await self._do_asr(audio_path, client_config)
+            except Exception as e:
+                logger.error(f"[{session_id}] ASR 失败: {e}")
+                yield {
+                    'type': 'error',
+                    'message': f'语音识别失败: {str(e)}'
+                }
+                return
             
             if not asr_result.get('segments'):
                 yield {
                     'type': 'error',
-                    'message': '语音识别结果为空'
+                    'message': '语音识别结果为空，请检查音频文件'
                 }
                 return
             
             source_language = asr_result.get('language', 'unknown')
             total_duration = asr_result.get('duration', 0)
             
+            # 如果没有时长信息，从最后一个片段获取
+            if total_duration == 0 and asr_result['segments']:
+                last_seg = asr_result['segments'][-1]
+                total_duration = last_seg.get('end', 0)
+            
             logger.info(
                 f"[{session_id}] ASR完成: 语言={source_language}, "
                 f"时长={total_duration:.1f}s, 片段数={len(asr_result['segments'])}"
@@ -243,6 +264,13 @@ class StreamProcessor:
                 total_duration
             )
             
+            if not segment_groups:
+                yield {
+                    'type': 'error',
+                    'message': '音频分段失败，无有效片段'
+                }
+                return
+            
             logger.info(f"[{session_id}] 分组完成: {len(segment_groups)} 组")
             
             # 4. 流式处理每个分组
@@ -260,73 +288,88 @@ class StreamProcessor:
                     'message': f'处理第 {group_index + 1}/{total_groups} 段...'
                 }
                 
-                # 4.1 翻译当前分组
-                translated_segments = await self._translate_segments(
-                    group,
-                    source_language,
-                    client_config
-                )
-                
-                # 4.2 TTS 生成
-                yield {
-                    'type': 'progress',
-                    'stage': ProcessingStage.TTS.value,
-                    'progress': 25 + (group_index / total_groups) * 60 + 20,
-                    'message': f'生成配音 {group_index + 1}/{total_groups}...'
-                }
-                
-                tts_results = await self._generate_tts(
-                    translated_segments,
-                    client_config
-                )
-                
-                # 4.3 音频同步
-                yield {
-                    'type': 'progress',
-                    'stage': ProcessingStage.SYNC.value,
-                    'progress': 25 + (group_index / total_groups) * 60 + 40,
-                    'message': f'同步音频 {group_index + 1}/{total_groups}...'
-                }
-                
-                synced_audio = await self._sync_audio(
-                    tts_results,
-                    translated_segments,
-                    group_end_time - group_start_time,
-                    client_config
-                )
-                
-                # 4.4 读取音频数据
-                audio_data = None
-                if synced_audio and os.path.exists(synced_audio):
-                    with open(synced_audio, 'rb') as f:
-                        audio_data = f.read()
-                
-                # 4.5 输出分段结果
-                processed_groups += 1
-                
-                yield {
-                    'type': 'segment_ready',
-                    'index': group_index,
-                    'start_time': group_start_time,
-                    'end_time': group_end_time,
-                    'duration': group_end_time - group_start_time,
-                    'audio_data': base64.b64encode(audio_data).decode('utf-8') if audio_data else None,
-                    'segments': [
-                        {
-                            'original': seg.get('text', ''),
-                            'translated': seg.get('cn', ''),
-                            'role': seg.get('role', 'MALE'),
-                            'start': seg.get('start', 0),
-                            'end': seg.get('end', 0)
+                try:
+                    # 4.1 翻译当前分组
+                    translated_segments = await self._translate_segments(
+                        group,
+                        source_language,
+                        client_config
+                    )
+                    
+                    # 4.2 TTS 生成
+                    yield {
+                        'type': 'progress',
+                        'stage': ProcessingStage.TTS.value,
+                        'progress': 25 + (group_index / total_groups) * 60 + 20,
+                        'message': f'生成配音 {group_index + 1}/{total_groups}...'
+                    }
+                    
+                    tts_results = await self._generate_tts(
+                        translated_segments,
+                        client_config
+                    )
+                    
+                    # 4.3 音频同步
+                    yield {
+                        'type': 'progress',
+                        'stage': ProcessingStage.SYNC.value,
+                        'progress': 25 + (group_index / total_groups) * 60 + 40,
+                        'message': f'同步音频 {group_index + 1}/{total_groups}...'
+                    }
+                    
+                    synced_audio = await self._sync_audio(
+                        tts_results,
+                        translated_segments,
+                        group_end_time - group_start_time,
+                        client_config
+                    )
+                    
+                    # 4.4 读取音频数据
+                    audio_data = None
+                    if synced_audio and os.path.exists(synced_audio):
+                        with open(synced_audio, 'rb') as f:
+                            audio_data = f.read()
+                    
+                    # 4.5 输出分段结果
+                    processed_groups += 1
+                    
+                    if audio_data:
+                        yield {
+                            'type': 'segment_ready',
+                            'index': group_index,
+                            'start_time': group_start_time,
+                            'end_time': group_end_time,
+                            'duration': group_end_time - group_start_time,
+                            'audio_data': base64.b64encode(audio_data).decode('utf-8'),
+                            'segments': [
+                                {
+                                    'original': seg.get('text', ''),
+                                    'translated': seg.get('cn', ''),
+                                    'role': seg.get('role', 'MALE'),
+                                    'start': seg.get('start', 0),
+                                    'end': seg.get('end', 0)
+                                }
+                                for seg in translated_segments
+                            ]
                         }
-                        for seg in translated_segments
-                    ]
-                }
-                
-                logger.info(
-                    f"[{session_id}] 分组 {group_index + 1} 完成: "
-                    f"{group_start_time:.1f}s - {group_end_time:.1f}s"
-                )
+                        
+                        logger.info(
+                            f"[{session_id}] 分组 {group_index + 1} 完成: "
+                            f"{group_start_time:.1f}s - {group_end_time:.1f}s, "
+                            f"音频大小: {len(audio_data)} bytes"
+                        )
+                    else:
+                        logger.warning(f"[{session_id}] 分组 {group_index + 1} 无音频输出")
+                        
+                except Exception as e:
+                    logger.error(f"[{session_id}] 分组 {group_index + 1} 处理失败: {e}")
+                    # 继续处理下一个分组，不中断整个流程
+                    yield {
+                        'type': 'progress',
+                        'stage': ProcessingStage.ERROR.value,
+                        'progress': 25 + (group_index / total_groups) * 60,
+                        'message': f'分组 {group_index + 1} 处理失败，继续下一段...'
+                    }
             
             # 5. 处理完成
             processing_time = time.time() - start_time
@@ -345,7 +388,7 @@ class StreamProcessor:
             )
             
         except Exception as e:
-            logger.error(f"[{session_id}] 流式处理失败: {e}")
+            logger.error(f"[{session_id}] 流式处理失败: {e}", exc_info=True)
             yield {
                 'type': 'error',
                 'message': str(e)
@@ -360,20 +403,41 @@ class StreamProcessor:
         执行语音识别
         
         根据配置选择 Groq Whisper 或 SiliconFlow SenseVoice
+        如果两者都不可用，返回错误
         """
         # 获取 ASR 提供商配置
         asr_provider = 'groq'  # 默认使用 Groq
         if client_config:
             asr_provider = client_config.get('asrProvider', 'groq')
         
+        # 尝试使用配置的提供商
         if asr_provider == 'siliconflow' and self.siliconflow_client:
-            logger.info("使用 SiliconFlow SenseVoice 进行语音识别")
+            try:
+                logger.info("使用 SiliconFlow SenseVoice 进行语音识别")
+                return await self.siliconflow_client.transcribe(audio_path)
+            except Exception as e:
+                logger.warning(f"SiliconFlow ASR 失败: {e}，尝试回退到 Groq")
+                if self.groq_client:
+                    return await self.groq_client.transcribe(audio_path)
+                raise
+        
+        if self.groq_client:
+            try:
+                logger.info("使用 Groq Whisper V3 进行语音识别")
+                return await self.groq_client.transcribe(audio_path)
+            except Exception as e:
+                logger.warning(f"Groq ASR 失败: {e}，尝试回退到 SiliconFlow")
+                if self.siliconflow_client:
+                    return await self.siliconflow_client.transcribe(audio_path)
+                raise
+        
+        if self.siliconflow_client:
+            logger.info("使用 SiliconFlow SenseVoice 进行语音识别（Groq 不可用）")
             return await self.siliconflow_client.transcribe(audio_path)
-        elif self.groq_client:
-            logger.info("使用 Groq Whisper V3 进行语音识别")
-            return await self.groq_client.transcribe(audio_path)
-        else:
-            raise RuntimeError("没有可用的 ASR 服务")
+        
+        raise RuntimeError(
+            "没有可用的 ASR 服务。请配置 GROQ_API_KEY 或 SILICONFLOW_API_KEY 环境变量。"
+        )
     
     def _group_segments_for_streaming(
         self,