Update app.py

app.py

@@ -5,491 +5,399 @@ import random
 import subprocess
 import shutil
 import zipfile
-import threading
-import concurrent.futures
 from datetime import datetime
-import time
+import traceback
 
-class FastVideoProcessor:
-    def __init__(self, max_processing_time=30):
-        self.max_processing_time = max_processing_time
-        self.start_time = None
+def run_ffmpeg_with_debug(command, operation_name):
+    """运行FFmpeg命令并提供详细调试信息"""
+    try:
+        print(f"🔧 执行 {operation_name}...")
+        print(f"📝 命令: {' '.join(command)}")
+        
+        result = subprocess.run(
+            command, 
+            stdout=subprocess.PIPE, 
+            stderr=subprocess.PIPE, 
+            text=True,
+            timeout=60  # 60秒超时
+        )
         
-    def check_time_limit(self):
-        """检查是否超过时间限制"""
-        if self.start_time and time.time() - self.start_time > self.max_processing_time:
+        if result.returncode != 0:
+            print(f"❌ {operation_name} 失败")
+            print(f"错误输出: {result.stderr}")
+            return False
+        else:
+            print(f"✅ {operation_name} 成功")
             return True
+            
+    except subprocess.TimeoutExpired:
+        print(f"⏰ {operation_name} 超时")
+        return False
+    except Exception as e:
+        print(f"💥 {operation_name} 异常: {str(e)}")
         return False
 
-    def ffmpeg_cut_video_fast(self, input_path, start_time, duration, output_path):
-        """高速剪切视频片段"""
-        command = [
-            'ffmpeg',
-            '-ss', str(start_time),
-            '-i', input_path,
-            '-t', str(duration),
-            '-c:v', 'libx264',     # H264编码器
-            '-preset', 'ultrafast',  # 最快编码预设
-            '-crf', '20',          # 高质量（18-24范围）
-            '-c:a', 'aac',
-            '-b:a', '128k',
-            '-threads', '0',       # 使用所有CPU核心
-            '-y',
-            output_path
-        ]
-        process = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        return process.returncode == 0
+def ffmpeg_cut_video_safe(input_path, start_time, duration, output_path):
+    """安全的视频切割，使用兼容性最好的参数"""
+    if not os.path.exists(input_path):
+        print(f"❌ 输入文件不存在: {input_path}")
+        return False
+    
+    command = [
+        'ffmpeg',
+        '-i', input_path,
+        '-ss', str(start_time),
+        '-t', str(duration),
+        '-c:v', 'libx264',
+        '-preset', 'medium',  # 平衡速度和质量
+        '-crf', '23',         # 适中的质量
+        '-c:a', 'aac',
+        '-b:a', '128k',
+        '-avoid_negative_ts', 'make_zero',
+        '-y',
+        output_path
+    ]
+    
+    success = run_ffmpeg_with_debug(command, f"切割视频 ({os.path.basename(input_path)})")
+    
+    if success and os.path.exists(output_path):
+        file_size = os.path.getsize(output_path) / (1024 * 1024)
+        print(f"📁 生成文件: {os.path.basename(output_path)} ({file_size:.1f}MB)")
+        return True
+    else:
+        print(f"❌ 切割后文件不存在: {output_path}")
+        return False
 
-    def ffmpeg_resize_video_fast(self, input_path, output_path, target_ratio):
-        """高速调整视频比例"""
-        if target_ratio == '9:16':
-            scale_filter = "scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2"
-        else:
-            scale_filter = "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2"
+def ffmpeg_resize_video_safe(input_path, output_path, target_ratio):
+    """安全的视频比例调整"""
+    if not os.path.exists(input_path):
+        print(f"❌ 输入文件不存在: {input_path}")
+        return False
+    
+    # 简化的比例调整，使用pad而不是crop
+    if target_ratio == '9:16':
+        filter_complex = "scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2:black"
+    else:
+        filter_complex = "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2:black"
+    
+    command = [
+        'ffmpeg',
+        '-i', input_path,
+        '-vf', filter_complex,
+        '-c:v', 'libx264',
+        '-preset', 'medium',
+        '-crf', '23',
+        '-c:a', 'copy',  # 音频直接复制
+        '-y',
+        output_path
+    ]
+    
+    success = run_ffmpeg_with_debug(command, f"调整比例 ({target_ratio})")
+    
+    if success and os.path.exists(output_path):
+        file_size = os.path.getsize(output_path) / (1024 * 1024)
+        print(f"📁 调整后文件: {os.path.basename(output_path)} ({file_size:.1f}MB)")
+        return True
+    else:
+        print(f"❌ 比例调整后文件不存在: {output_path}")
+        return False
 
+def concat_videos_safe(file_list, output_path):
+    """安全的视频合并"""
+    if not file_list:
+        print("❌ 没有文件需要合并")
+        return False
+    
+    # 检查所有输入文件是否存在
+    valid_files = []
+    for f in file_list:
+        if os.path.exists(f):
+            valid_files.append(f)
+            print(f"✅ 文件存在: {os.path.basename(f)}")
+        else:
+            print(f"❌ 文件不存在: {f}")
+    
+    if not valid_files:
+        print("❌ 没有有效的输入文件")
+        return False
+    
+    # 创建文件列表
+    list_file = tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt', encoding='utf-8')
+    try:
+        for f in valid_files:
+            # 使用绝对路径，避免路径问题
+            abs_path = os.path.abspath(f)
+            list_file.write(f"file '{abs_path}'\n")
+        list_file.close()
+        
+        print(f"📝 文件列表: {list_file.name}")
+        with open(list_file.name, 'r', encoding='utf-8') as lf:
+            print("📋 合并列表内容:")
+            print(lf.read())
+        
         command = [
             'ffmpeg',
-            '-i', input_path,
-            '-vf', scale_filter,
-            '-c:v', 'libx264',
-            '-preset', 'ultrafast',
-            '-crf', '20',
-            '-c:a', 'copy',        # 音频直接复制，不重编码
-            '-threads', '0',
+            '-f', 'concat',
+            '-safe', '0',
+            '-i', list_file.name,
+            '-c', 'copy',
             '-y',
             output_path
         ]
         
-        process = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        return process.returncode == 0
-
-    def concat_videos_fast(self, file_list, output_path):
-        """高速合并视频"""
-        list_file = tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt')
+        success = run_ffmpeg_with_debug(command, "合并视频")
+        
+        if success and os.path.exists(output_path):
+            file_size = os.path.getsize(output_path) / (1024 * 1024)
+            print(f"📁 合并后文件: {os.path.basename(output_path)} ({file_size:.1f}MB)")
+            return True
+        else:
+            print(f"❌ 合并后文件不存在: {output_path}")
+            return False
+            
+    except Exception as e:
+        print(f"💥 合并过程异常: {str(e)}")
+        return False
+    finally:
         try:
-            for f in file_list:
-                list_file.write("file '{}'\n".format(f.replace("'", r"'\''")))
-            list_file.close()
-
-            command = [
-                'ffmpeg', 
-                '-f', 'concat', 
-                '-safe', '0', 
-                '-i', list_file.name,
-                '-c', 'copy',          # 直接复制，无重编码
-                '-threads', '0',
-                '-y', 
-                output_path
-            ]
-            process = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-            return process.returncode == 0
-        finally:
             os.unlink(list_file.name)
+        except:
+            pass
 
-    def extract_clips_parallel(self, video_files, clip_duration):
-        """并行提取视频片段 - 无限制版本"""
-        self.start_time = time.time()
-        clips = []
-        temp_dir = tempfile.mkdtemp()
+def process_videos_with_debug(video_files, clip_duration, num_output_videos, target_ratio):
+    """带调试信息的视频处理"""
+    if not video_files:
+        return "❌ 请上传视频文件", None, "没有上传文件"
+    
+    print("🚀 开始处理视频...")
+    print(f"📊 参数: 切片{clip_duration}秒, 生成{num_output_videos}个, 比例{target_ratio}")
+    
+    temp_dir = tempfile.mkdtemp()
+    print(f"📁 临时目录: {temp_dir}")
+    
+    try:
+        all_clips = []
         
-        def process_single_video(args):
-            idx, video_file = args
-            video_clips = []
+        # 第一步：切割视频
+        print("📹 第一步：切割视频")
+        for idx, video_file in enumerate(video_files):
+            video_path = video_file.name
+            print(f"🎬 处理视频 {idx+1}: {os.path.basename(video_path)}")
             
+            # 获取视频时长
             try:
-                video_path = video_file.name
-                
-                # 快速获取视频时长
-                cmd_duration = [
-                    'ffprobe', '-v', 'quiet', 
+                cmd = [
+                    'ffprobe', '-v', 'quiet',
                     '-show_entries', 'format=duration',
                     '-of', 'default=noprint_wrappers=1:nokey=1',
                     video_path
                 ]
-                result = subprocess.run(cmd_duration, capture_output=True, text=True, timeout=10)
+                result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
                 total_duration = float(result.stdout.strip())
+                print(f"⏱️ 视频时长: {total_duration:.1f}秒")
+            except Exception as e:
+                print(f"❌ 无法获取视频时长: {e}")
+                continue
+            
+            # 切割视频片段
+            start = 0.0
+            count = 0
+            while start < total_duration:
+                duration = min(clip_duration, total_duration - start)
+                clip_path = os.path.join(temp_dir, f"clip_{idx}_{count}.mp4")
                 
-                # 完全按用户设定的时长切片，不限制数量
-                count = 0
-                start = 0.0
-                
-                while start < total_duration:
-                    if self.check_time_limit():
-                        break
-                        
-                    duration = min(clip_duration, total_duration - start)
-                    clip_path = os.path.join(temp_dir, f"clip_{idx}_{count}.mp4")
-                    
-                    success = self.ffmpeg_cut_video_fast(video_path, start, duration, clip_path)
-                    if success:
-                        video_clips.append(clip_path)
-                    
-                    start += clip_duration  # 按用户设定的时长连续切片
-                    count += 1
-                    
-                return video_clips
+                success = ffmpeg_cut_video_safe(video_path, start, duration, clip_path)
+                if success:
+                    all_clips.append(clip_path)
+                else:
+                    print(f"⚠️ 跳过失败的片段: {count}")
                 
-            except Exception as e:
-                print(f"处理视频 {idx} 出错: {e}")
-                return []
+                start += clip_duration
+                count += 1
         
-        # 并行处理所有视频
-        with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
-            video_args = [(idx, vf) for idx, vf in enumerate(video_files)]
-            results = executor.map(process_single_video, video_args)
-            
-            for video_clips in results:
-                clips.extend(video_clips)
+        print(f"📊 总共切割了 {len(all_clips)} 个片段")
         
-        return clips, temp_dir
-
-    def generate_mixed_videos_fast(self, clips, num_output_videos, target_ratio):
-        """高速生成混剪视频 - 无限制版本"""
-        temp_dir = tempfile.mkdtemp()
-        random.shuffle(clips)
+        if not all_clips:
+            return "❌ 没有成功切割任何片段", None, "切割阶段失败"
         
-        # 按用户要求的数量分配片段，不限制
-        clips_per_video = max(1, len(clips) // num_output_videos) if num_output_videos > 0 else len(clips)
-        output_files = []
+        # 第二步：生成混剪视频
+        print("🎭 第二步：生成混剪视频")
+        random.shuffle(all_clips)
         
-        def create_single_mixed_video(args):
-            i, selected_clips = args
-            
-            try:
-                if self.check_time_limit():
-                    return None
-                
-                # 先快速合并
-                temp_video_path = os.path.join(temp_dir, f"temp_mixed_{i+1}.mp4")
-                success = self.concat_videos_fast(selected_clips, temp_video_path)
-                
-                if not success:
-                    return None
-                
-                # 再调整比例
-                timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-                output_path = os.path.join(temp_dir, f"混剪视频_{target_ratio.replace(':', 'x')}_{i+1}_{timestamp}.mp4")
-                
-                success = self.ffmpeg_resize_video_fast(temp_video_path, output_path, target_ratio)
-                
-                if success:
-                    return output_path
-                return None
-                
-            except Exception as e:
-                print(f"生成混剪视频 {i+1} 出错: {e}")
-                return None
+        output_files = []
+        clips_per_video = max(1, len(all_clips) // num_output_videos)
         
-        # 准备任务 - 支持任意数量
-        tasks = []
         for i in range(num_output_videos):
+            print(f"🎬 生成第 {i+1} 个混剪视频")
+            
             start_idx = i * clips_per_video
-            end_idx = len(clips) if i == num_output_videos - 1 else (start_idx + clips_per_video)
-            selected_clips = clips[start_idx:end_idx]
+            end_idx = len(all_clips) if i == num_output_videos - 1 else (start_idx + clips_per_video)
+            selected_clips = all_clips[start_idx:end_idx]
             
-            if selected_clips:
-                tasks.append((i, selected_clips))
-        
-        # 并行生成 - 支持更多线程处理大量视频
-        max_workers = min(8, num_output_videos)  # 最多8个线程
-        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
-            results = executor.map(create_single_mixed_video, tasks)
+            if not selected_clips:
+                print(f"⚠️ 第 {i+1} 个视频没有片段，跳过")
+                continue
             
-            for result in results:
-                if result:
-                    output_files.append(result)
-        
-        return output_files, temp_dir
-
-processor = FastVideoProcessor()
-
-def create_video_package_fast(output_files, original_file_names, target_ratio, processing_time, clip_duration, num_output):
-    """快速打包视频文件"""
-    package_dir = tempfile.mkdtemp()
-    zip_path = os.path.join(package_dir, f"混剪视频包_{target_ratio.replace(':', 'x')}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip")
-    
-    try:
-        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED, compresslevel=1) as zipf:  # 最低压缩级别
-            for video_file in output_files:
-                arcname = os.path.basename(video_file)
-                zipf.write(video_file, arcname)
+            print(f"📝 第 {i+1} 个视频使用 {len(selected_clips)} 个片段")
             
-            readme_content = f"""# 无限制高速混剪视频包
-
-## ⚡ 处理信息
-- 生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-- 处理耗时: {processing_time:.1f} 秒 ⚡
-- 视频数量: {len(output_files)} 个
-- 视频比例: {target_ratio}
-- 切片时长: {clip_duration} 秒
-- 输出数量: {num_output} 个
-
-## 🚀 无限制特性
-- ✅ 切片时长: 用户自定义，无限制
-- ✅ 生成数量: 用户自定义，无限制
-- ✅ 文件数量: 支持批量处理，无限制
-- ✅ 视频长度: 支持任意长度，无限制
-- ✅ 并行处理: 最多8线程同时工作
-- ✅ 高速编码: ultrafast + CRF 20
-
-## 📁 文件列表
-"""
+            # 先合并片段
+            temp_merged = os.path.join(temp_dir, f"merged_{i+1}.mp4")
+            merge_success = concat_videos_safe(selected_clips, temp_merged)
             
-            for i, video_file in enumerate(output_files, 1):
-                file_size = os.path.getsize(video_file) / (1024 * 1024)
-                readme_content += f"- 混剪视频_{i}.mp4 ({file_size:.1f}MB)\n"
+            if not merge_success:
+                print(f"❌ 第 {i+1} 个视频合并失败")
+                continue
             
-            readme_content += f"""
-## 🎬 质量保证
-- CRF 20: 高质量编码
-- 原始音频: 保持音质
-- 智能填充: 完美适配比例
-- 多核加速: 充分利用CPU
-
-## 📱 使用建议
-- 适合任意平台发布
-- 可进一步编辑处理
-- 支持二次剪辑
-- 兼容所有播放器
-
----
-🚀 无限制高速混剪工具 - 自由度最大化
-"""
+            # 再调整比例
+            timestamp = datetime.now().strftime('%H%M%S')
+            final_output = os.path.join(temp_dir, f"混剪视频_{target_ratio.replace(':', 'x')}_{i+1}_{timestamp}.mp4")
+            resize_success = ffmpeg_resize_video_safe(temp_merged, final_output, target_ratio)
             
-            zipf.writestr("README.txt", readme_content.encode('utf-8'))
-        
-        return zip_path
-    
-    except Exception as e:
-        shutil.rmtree(package_dir, ignore_errors=True)
-        raise e
-
-def process_and_package_unlimited(video_files, clip_duration, num_output_videos, target_ratio):
-    if not video_files or len(video_files) == 0:
-        return "❌ 请上传至少一个视频文件", None, ""
-    
-    start_time = time.time()
-    
-    try:
-        original_names = [os.path.basename(f.name) for f in video_files]
-        
-        # 1. 高速提取片段 - 无限制
-        clips, clips_temp_dir = processor.extract_clips_parallel(video_files, clip_duration)
-        
-        if not clips:
-            return "❌ 未能提取到有效片段", None, ""
-        
-        # 2. 高速生成混剪视频 - 无限制
-        output_files, output_temp_dir = processor.generate_mixed_videos_fast(clips, num_output_videos, target_ratio)
-        
-        # 清理切片临时目录
-        shutil.rmtree(clips_temp_dir, ignore_errors=True)
+            if resize_success:
+                output_files.append(final_output)
+                print(f"✅ 第 {i+1} 个混剪视频完成")
+            else:
+                print(f"❌ 第 {i+1} 个视频比例调整失败")
         
         if not output_files:
-            return "❌ 未能生成混剪视频", None, ""
-        
-        # 3. 快速打包
-        processing_time = time.time() - start_time
-        zip_file_path = create_video_package_fast(output_files, original_names, target_ratio, processing_time, clip_duration, num_output_videos)
-        
-        total_size = os.path.getsize(zip_file_path) / (1024 * 1024)
+            error_info = f"生成阶段失败。切割了{len(all_clips)}个片段，但无法生成最终视频。"
+            return "❌ 未能生成任何混剪视频", None, error_info
         
-        platform_info = "📱 短视频平台" if target_ratio == '9:16' else "🖥️ 长视频平台"
+        # 第三步：打包
+        print("📦 第三步：打包文件")
+        package_dir = tempfile.mkdtemp()
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        zip_path = os.path.join(package_dir, f"混剪视频包_{target_ratio.replace(':', 'x')}_{timestamp}.zip")
         
-        status_msg = f"""🚀 无限制处理完成！
-
-📊 **处理统计:**
-• ⚡ 处理时间: {processing_time:.1f} 秒
-• 🎬 混剪视频: {len(output_files)} 个
-• 📐 视频比例: {target_ratio}
-• ⏱️ 切片时长: {clip_duration} 秒
-• 🎯 适合平台: {platform_info}
-• 📦 文件大小: {total_size:.1f}MB
+        try:
+            with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                for video_file in output_files:
+                    arcname = os.path.basename(video_file)
+                    zipf.write(video_file, arcname)
+                    print(f"📦 打包文件: {arcname}")
+                
+                # 添加说明
+                readme = f"""调试版混剪视频包
 
-🔥 **无限制优势:**
-• 任意切片时长设定
-• 任意输出数量设定
-• 支持大量文件批处理
-• 最多8线程并行处理
-• 30秒内完成处理
+生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+成功生成: {len(output_files)} 个视频
+视频比例: {target_ratio}
+切片时长: {clip_duration} 秒
 
-💾 **立即下载:**
-点击下方按钮保存到本地
+文件列表:
 """
-        
-        details = f"""🚀 **无限制处理详情:**
+                for i, vf in enumerate(output_files, 1):
+                    size_mb = os.path.getsize(vf) / (1024 * 1024)
+                    readme += f"- 混剪视频_{i}.mp4 ({size_mb:.1f}MB)\n"
+                
+                zipf.writestr("README.txt", readme.encode('utf-8'))
+            
+            total_size = os.path.getsize(zip_path) / (1024 * 1024)
+            
+            success_msg = f"""✅ 处理成功完成！
 
-🎬 **视频信息:**
-"""
-        for i, video_file in enumerate(output_files, 1):
-            file_size = os.path.getsize(video_file) / (1024 * 1024)
-            details += f"• 混剪视频_{i}: {file_size:.1f}MB\n"
-        
-        details += f"""
-⚡ **处理参数:**
-• 切片时长: {clip_duration}秒 (用户自定义)
-• 输出数量: {num_output_videos}个 (用户自定义)
-• 处理时间: {processing_time:.1f}秒
-• 总片段数: {len(clips)}个
-• 并行线程: {min(8, num_output_videos)}个
+📊 最终统计:
+• 成功生成: {len(output_files)} 个混剪视频
+• 视频比例: {target_ratio}
+• 总文件大小: {total_size:.1f}MB
+• 切片时长: {clip_duration} 秒
+
+💾 点击下方下载按钮获取视频包"""
+            
+            detail_info = f"""详细处理信息:
 
-🔥 **无限制特性:**
-• ✅ 切片时长: 1秒-3600秒，完全自由
-• ✅ 输出数量: 1个-100个，随意设置
-• ✅ 文件处理: 支持大量视频批处理
-• ✅ 视频长度: 支持超长视频处理
-• ✅ 质量保证: 高速处理不牺牲品质
+📹 输入处理:
+• 输入文件数: {len(video_files)}
+• 成功切片数: {len(all_clips)}
 
-🎯 **适用场景:**
+🎬 输出统计:
 """
-        
-        if target_ratio == '9:16':
-            details += """• 抖音、快手批量内容制作
-• 小红书多样化内容输出
-• Instagram Stories系列发布
-• TikTok内容矩阵建设"""
-        else:
-            details += """• YouTube频道批量更新
-• B站UP主内容制作
-• 长视频平台系列发布
-• 教育培训批量制作"""
-        
-        shutil.rmtree(output_temp_dir, ignore_errors=True)
-        
-        return status_msg, zip_file_path, details
-        
+            for i, vf in enumerate(output_files, 1):
+                size_mb = os.path.getsize(vf) / (1024 * 1024)
+                detail_info += f"• 混剪视频_{i}: {size_mb:.1f}MB\n"
+            
+            print("🎉 所有处理完成！")
+            return success_msg, zip_path, detail_info
+            
+        except Exception as e:
+            error_msg = f"打包失败: {str(e)}"
+            print(f"❌ {error_msg}")
+            return f"❌ {error_msg}", None, str(e)
+    
     except Exception as e:
-        processing_time = time.time() - start_time
-        return f"❌ 处理失败 (耗时{processing_time:.1f}秒): {str(e)}", None, ""
+        error_trace = traceback.format_exc()
+        print(f"💥 处理过程发生异常:")
+        print(error_trace)
+        return f"❌ 处理异常: {str(e)}", None, error_trace
+    
+    finally:
+        # 清理临时文件
+        try:
+            shutil.rmtree(temp_dir, ignore_errors=True)
+            print("🧹 临时文件清理完成")
+        except:
+            pass
 
 def main():
-    with gr.Blocks(
-        title="🚀无限制FFmpeg剪辑工具", 
-        theme=gr.themes.Soft()
-    ) as demo:
+    with gr.Blocks(title="调试版FFmpeg剪辑工具") as demo:
         
         gr.HTML("""
-        <div style="text-align: center; padding: 20px; background: linear-gradient(135deg, #FF6B6B 0%, #4ECDC4 100%); border-radius: 15px; color: white; margin-bottom: 20px;">
-            <h1>🚀 无���制 FFmpeg 自动剪辑工具</h1>
-            <p style="margin: 10px 0 0 0; font-size: 18px;">🔥 完全自由 → 无任何限制 → 批量处理 → 高速完成</p>
+        <div style="text-align: center; padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 15px; color: white; margin-bottom: 20px;">
+            <h1>🔧 调试版 FFmpeg 自动剪辑工具</h1>
+            <p style="margin: 10px 0 0 0;">🚀 带详细调试信息，帮助解决处理问题</p>
         </div>
         """)
         
         gr.Markdown("""
-        ### 🔥 无限制特性
-        - 🚀 **切片时长**: 1秒-3600秒，完全自由设定
-        - 🎬 **输出数量**: 1个-100个，任意数量生成
-        - 📁 **文件数量**: 支持大量视频批处理
-        - ⚡ **处理速度**: 30秒内完成，多线程并行
-        - 💎 **品质保证**: CRF 20高质量，不妥协
+        ### 🔧 调试版特性
+        - 📝 **详细日志**: 显示每步处理的详细信息
+        - 🛠️ **错误诊断**: 精确定位问题所在
+        - 🔍 **文件检查**: 验证每个步骤的文件状态
+        - ⚡ **稳定处理**: 使用最兼容的FFmpeg参数
         """)
         
         with gr.Row():
-            with gr.Column(scale=2):
+            with gr.Column():
                 video_input = gr.File(
-                    label="📤 上传视频文件 (支持批量，无数量限制)", 
-                    file_types=[".mp4", ".mov", ".avi", ".mkv"], 
-                    file_count="multiple",
-                    height=120
+                    label="📤 上传视频文件", 
+                    file_types=[".mp4", ".mov", ".avi"], 
+                    file_count="multiple"
                 )
                 
                 with gr.Row():
-                    clip_duration = gr.Number(
-                        value=3, 
-                        label="切片时长(秒)", 
-                        minimum=1, 
-                        maximum=3600,
-                        info="🔥 完全无限制：1-3600秒任意设置"
-                    )
-                    num_output = gr.Number(
-                        value=3, 
-                        label="生成数量", 
-                        minimum=1, 
-                        maximum=100,
-                        info="🎬 无限制：1-100个随意生成"
-                    )
+                    clip_duration = gr.Number(value=3, label="切片时长(秒)", minimum=1, maximum=30)
+                    num_output = gr.Number(value=2, label="生成数量", minimum=1, maximum=5)
                 
-                ratio_selection = gr.Radio(
-                    choices=["9:16", "16:9"], 
-                    value="9:16",
-                    label="📐 视频比例",
-                    info="9:16抖音快手 | 16:9 YouTube B站"
-                )
+                target_ratio = gr.Radio(choices=["9:16", "16:9"], value="9:16", label="视频比例")
                 
-                process_btn = gr.Button(
-                    "🚀 无限制高速处理", 
-                    variant="primary", 
-                    size="lg"
-                )
-            
-            with gr.Column(scale=1):
-                status_output = gr.Textbox(
-                    label="📊 处理状态", 
-                    lines=15, 
-                    interactive=False,
-                    show_copy_button=True
-                )
+                process_btn = gr.Button("🔧 开始调试处理", variant="primary")
         
         with gr.Row():
-            with gr.Column(scale=1):
-                download_file = gr.File(
-                    label="🚀 无限制下载视频包",
-                    interactive=False
-                )
+            with gr.Column():
+                status_output = gr.Textbox(label="处理状态", lines=8, interactive=False)
+                download_file = gr.File(label="下载结果", interactive=False)
             
-            with gr.Column(scale=1):
-                details_output = gr.Textbox(
-                    label="📝 处理详情", 
-                    lines=20, 
-                    interactive=False,
-                    show_copy_button=True
-                )
+            with gr.Column():
+                debug_output = gr.Textbox(label="调试信息", lines=12, interactive=False)
         
         process_btn.click(
-            fn=process_and_package_unlimited,
-            inputs=[video_input, clip_duration, num_output, ratio_selection],
-            outputs=[status_output, download_file, details_output]
+            fn=process_videos_with_debug,
+            inputs=[video_input, clip_duration, num_output, target_ratio],
+            outputs=[status_output, download_file, debug_output]
         )
         
         gr.Markdown("""
         ---
-        ### 🚀 无限制使用指南
-        
-        **🔥 完全自由设定:**
-        - **切片时长**: 1秒到1小时(3600秒)，完全由你决定
-        - **输出数量**: 1个到100个混剪视频，批量生成
-        - **文件处理**: 支持同时处理大量视频文件
-        - **视频长度**: 支持任意长度的源视频
-
-        **⚡ 高速处理保证:**
-        - **并行切片**: 最多4线程同时切割视频
-        - **并行生成**: 最多8线程同时生成混剪
-        - **ultrafast编码**: FFmpeg最快预设
-        - **智能优化**: 30秒内完成所有处理
-        
-        **💎 品质不妥协:**
-        - **CRF 20编码**: 视觉无损高质量
-        - **原音保持**: 音频零损失处理
-        - **完美比例**: 智能适配目标尺寸
-        - **兼容性**: H.264编码，全平台支持
+        ### 🔧 调试说明
         
-        **🎯 适用场景:**
-        - **内容创作者**: 批量制作短视频/长视频
-        - **营销团队**: 大量素材快速处理
-        - **教育机构**: 课程内容批量剪辑
-        - **自媒体**: 多平台内容矩阵建设
+        这个调试版本会显示详细的处理过程，帮助识别问题：
         
-        **📊 处理能力:**
-        - **单次处理**: 最多100个混剪视频
-        - **文件支持**: MP4、MOV、AVI、MKV
-        - **系统要求**: 需安装FFmpeg
-        - **推荐配置**: 多核CPU，8GB+内存
+        - ✅ **成功标志**: 显示每步成功完成
+        - ❌ **失败标志**: 显示具体失败原因  
+        - 📁 **文件信息**: 显示文件大小和路径
+        - 🔧 **命令日志**: 显示执行的FFmpeg命令
         
-        **💡 使用技巧:**
-        - 切片时长越短，混剪节奏越快
-        - 生成数量越多，内容变化越丰富
-        - 建议先小批量测试，再大量处理
-        - CPU核心越多，处理速度越快
+        如果仍然失败，请查看"调试信息"栏中的详细错误信息。
         """)
     
     demo.launch()