Update app.py

app.py

@@ -6,51 +6,133 @@ import subprocess
 import shutil
 import zipfile
 from datetime import datetime
-import traceback
+import json
 
-def run_ffmpeg_with_debug(command, operation_name):
-    """运行FFmpeg命令并提供详细调试信息"""
+# 储存目录设置
+STORAGE_DIR = os.path.expanduser("~/video_storage")
+STORAGE_CONFIG = os.path.join(STORAGE_DIR, "storage_config.json")
+
+def init_storage():
+    """初始化储存空间"""
+    os.makedirs(STORAGE_DIR, exist_ok=True)
+    
+    if not os.path.exists(STORAGE_CONFIG):
+        config = {
+            "created_time": datetime.now().isoformat(),
+            "total_videos": 0,
+            "total_size_mb": 0
+        }
+        with open(STORAGE_CONFIG, 'w', encoding='utf-8') as f:
+            json.dump(config, f, ensure_ascii=False, indent=2)
+
+def save_to_storage(file_path, metadata=None):
+    """保存文件到储存空间"""
     try:
-        print(f"🔧 执行 {operation_name}...")
-        print(f"📝 命令: {' '.join(command)}")
-        
-        result = subprocess.run(
-            command, 
-            stdout=subprocess.PIPE, 
-            stderr=subprocess.PIPE, 
-            text=True,
-            timeout=60  # 60秒超时
-        )
+        base_name = os.path.basename(file_path)
+        target_path = os.path.join(STORAGE_DIR, base_name)
         
-        if result.returncode != 0:
-            print(f"❌ {operation_name} 失败")
-            print(f"错误输出: {result.stderr}")
-            return False
+        # 避免重名覆盖
+        count = 1
+        name, ext = os.path.splitext(base_name)
+        while os.path.exists(target_path):
+            target_path = os.path.join(STORAGE_DIR, f"{name}_{count}{ext}")
+            count += 1
+        
+        shutil.copy2(file_path, target_path)
+        
+        # 更新配置
+        update_storage_config()
+        
+        return target_path
+    except Exception as e:
+        print(f"❌ 储存文件失败: {e}")
+        return None
+
+def update_storage_config():
+    """更新储存配置信息"""
+    try:
+        video_files = [f for f in os.listdir(STORAGE_DIR) if f.lower().endswith(('.mp4', '.mov', '.avi', '.mkv'))]
+        total_size = sum(os.path.getsize(os.path.join(STORAGE_DIR, f)) for f in video_files) / (1024 * 1024)
+        
+        config = {
+            "updated_time": datetime.now().isoformat(),
+            "total_videos": len(video_files),
+            "total_size_mb": round(total_size, 1)
+        }
+        
+        with open(STORAGE_CONFIG, 'w', encoding='utf-8') as f:
+            json.dump(config, f, ensure_ascii=False, indent=2)
+    except:
+        pass
+
+def get_storage_info():
+    """获取储存空间信息"""
+    try:
+        if os.path.exists(STORAGE_CONFIG):
+            with open(STORAGE_CONFIG, 'r', encoding='utf-8') as f:
+                config = json.load(f)
         else:
-            print(f"✅ {operation_name} 成功")
-            return True
-            
-    except subprocess.TimeoutExpired:
-        print(f"⏰ {operation_name} 超时")
-        return False
+            config = {"total_videos": 0, "total_size_mb": 0}
+        
+        # 获取视频文件列表
+        video_files = []
+        if os.path.exists(STORAGE_DIR):
+            for f in os.listdir(STORAGE_DIR):
+                if f.lower().endswith(('.mp4', '.mov', '.avi', '.mkv')):
+                    file_path = os.path.join(STORAGE_DIR, f)
+                    size_mb = os.path.getsize(file_path) / (1024 * 1024)
+                    mod_time = datetime.fromtimestamp(os.path.getmtime(file_path))
+                    video_files.append({
+                        "name": f,
+                        "size_mb": round(size_mb, 1),
+                        "modified": mod_time.strftime('%Y-%m-%d %H:%M')
+                    })
+        
+        # 按修改时间排序
+        video_files.sort(key=lambda x: x["modified"], reverse=True)
+        
+        return config, video_files
+    except:
+        return {"total_videos": 0, "total_size_mb": 0}, []
+
+def delete_storage_file(filename):
+    """从储存空间删除文件"""
+    try:
+        file_path = os.path.join(STORAGE_DIR, filename)
+        if os.path.exists(file_path):
+            os.remove(file_path)
+            update_storage_config()
+            return f"✅ 已删除文件: {filename}"
+        else:
+            return f"❌ 文件不存在: {filename}"
     except Exception as e:
-        print(f"💥 {operation_name} 异常: {str(e)}")
-        return False
+        return f"❌ 删除失败: {str(e)}"
 
-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
-    
+def clear_storage():
+    """清空储存空间"""
+    try:
+        count = 0
+        if os.path.exists(STORAGE_DIR):
+            for f in os.listdir(STORAGE_DIR):
+                if f.lower().endswith(('.mp4', '.mov', '.avi', '.mkv')):
+                    os.remove(os.path.join(STORAGE_DIR, f))
+                    count += 1
+        
+        update_storage_config()
+        return f"✅ 已清空储存空间，删除了 {count} 个文件"
+    except Exception as e:
+        return f"❌ 清空失败: {str(e)}"
+
+def ffmpeg_cut_video(input_path, start_time, duration, output_path):
+    """稳定的视频切割"""
     command = [
         'ffmpeg',
         '-i', input_path,
         '-ss', str(start_time),
         '-t', str(duration),
         '-c:v', 'libx264',
-        '-preset', 'medium',  # 平衡速度和质量
-        '-crf', '23',         # 适中的质量
+        '-preset', 'medium',
+        '-crf', '23',
         '-c:a', 'aac',
         '-b:a', '128k',
         '-avoid_negative_ts', 'make_zero',
@@ -58,23 +140,11 @@ def ffmpeg_cut_video_safe(input_path, start_time, duration, output_path):
         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
+    result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    return result.returncode == 0 and os.path.exists(output_path)
 
-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
+def ffmpeg_resize_video(input_path, output_path, target_ratio):
+    """稳定的比例调整"""
     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:
@@ -87,54 +157,30 @@ def ffmpeg_resize_video_safe(input_path, output_path, target_ratio):
         '-c:v', 'libx264',
         '-preset', 'medium',
         '-crf', '23',
-        '-c:a', 'copy',  # 音频直接复制
+        '-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
+    result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    return result.returncode == 0 and os.path.exists(output_path)
 
-def concat_videos_safe(file_list, output_path):
-    """安全的视频合并"""
+def concat_videos(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}")
-    
+    valid_files = [f for f in file_list if os.path.exists(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',
             '-f', 'concat',
@@ -145,46 +191,29 @@ def concat_videos_safe(file_list, output_path):
             output_path
         ]
         
-        success = run_ffmpeg_with_debug(command, "合并视频")
+        result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        return result.returncode == 0 and os.path.exists(output_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
-            
-    except Exception as e:
-        print(f"💥 合并过程异常: {str(e)}")
-        return False
     finally:
         try:
             os.unlink(list_file.name)
         except:
             pass
 
-def process_videos_with_debug(video_files, clip_duration, num_output_videos, target_ratio):
-    """带调试信息的视频处理"""
+def process_videos_with_storage(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}")
+        return "❌ 请上传视频文件", None, "", ""
     
     temp_dir = tempfile.mkdtemp()
-    print(f"📁 临时目录: {temp_dir}")
     
     try:
         all_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:
                 cmd = [
                     'ffprobe', '-v', 'quiet',
@@ -194,210 +223,353 @@ def process_videos_with_debug(video_files, clip_duration, num_output_videos, tar
                 ]
                 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}")
+            except:
                 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")
                 
-                success = ffmpeg_cut_video_safe(video_path, start, duration, clip_path)
-                if success:
+                if ffmpeg_cut_video(video_path, start, duration, clip_path):
                     all_clips.append(clip_path)
-                else:
-                    print(f"⚠️ 跳过失败的片段: {count}")
                 
                 start += clip_duration
                 count += 1
         
-        print(f"📊 总共切割了 {len(all_clips)} 个片段")
-        
         if not all_clips:
-            return "❌ 没有成功切割任何片段", None, "切割阶段失败"
+            return "❌ 切割失败，请检查视频文件", None, "", ""
         
-        # 第二步：生成混剪视频
-        print("🎭 第二步：生成混剪视频")
+        # 随机打乱并分组
         random.shuffle(all_clips)
-        
-        output_files = []
         clips_per_video = max(1, len(all_clips) // num_output_videos)
+        output_files = []
+        stored_files = []
         
+        # 生成混剪视频
         for i in range(num_output_videos):
-            print(f"🎬 生成第 {i+1} 个混剪视频")
-            
             start_idx = i * clips_per_video
             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 not selected_clips:
-                print(f"⚠️ 第 {i+1} 个视频没有片段，跳过")
                 continue
             
-            print(f"📝 第 {i+1} 个视频使用 {len(selected_clips)} 个片段")
-            
-            # 先合并片段
+            # 合并片段
             temp_merged = os.path.join(temp_dir, f"merged_{i+1}.mp4")
-            merge_success = concat_videos_safe(selected_clips, temp_merged)
-            
-            if not merge_success:
-                print(f"❌ 第 {i+1} 个视频合并失败")
+            if not concat_videos(selected_clips, temp_merged):
                 continue
             
-            # 再调整比例
+            # 调整比例
             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)
             
-            if resize_success:
+            if ffmpeg_resize_video(temp_merged, final_output, target_ratio):
                 output_files.append(final_output)
-                print(f"✅ 第 {i+1} 个混剪视频完成")
-            else:
-                print(f"❌ 第 {i+1} 个视频比例调整失败")
+                
+                # 🔥 自动保存到储存空间
+                stored_path = save_to_storage(final_output)
+                if stored_path:
+                    stored_files.append(os.path.basename(stored_path))
         
         if not output_files:
-            error_info = f"生成阶段失败。切割了{len(all_clips)}个片段，但无法生成最终视频。"
-            return "❌ 未能生成任何混剪视频", None, error_info
+            return "❌ 生成混剪视频失败", None, "", ""
         
-        # 第三步：打包
-        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")
         
-        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"""调试版混剪视频包
+        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)
+            
+            readme = f"""# 混剪视频包
 
-生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-成功生成: {len(output_files)} 个视频
-视频比例: {target_ratio}
-切片时长: {clip_duration} 秒
+## 📊 生成信息
+- 生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+- 视频数量: {len(output_files)} 个
+- 视频比例: {target_ratio}
+- 切片时长: {clip_duration} 秒
 
-文件列表:
+## 📁 文件列表
 """
-                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)
+            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"
             
-            success_msg = f"""✅ 处理成功完成！
+            readme += f"""
+## 💾 储存信息
+所有视频已自动保存到本地储存空间:
+{', '.join(stored_files)}
 
-📊 最终统计:
-• 成功生成: {len(output_files)} 个混剪视频
-• 视频比例: {target_ratio}
-• 总文件大小: {total_size:.1f}MB
-• 切片时长: {clip_duration} 秒
+## 📱 使用说明
+视频已按 {target_ratio} 比例优化，可直接发布到相应平台。
 
-💾 点击下方下载按钮获取视频包"""
+---
+FFmpeg 自动混剪工具制作
+"""
             
-            detail_info = f"""详细处理信息:
+            zipf.writestr("README.txt", readme.encode('utf-8'))
+        
+        total_size = os.path.getsize(zip_path) / (1024 * 1024)
+        platform_info = "📱 短视频平台" if target_ratio == '9:16' else "🖥️ 长视频平台"
+        
+        success_msg = f"""✅ 混剪完成并已储存！
+
+📊 **生成统计:**
+• 🎬 混剪视频: {len(output_files)} 个
+• 📐 视频比例: {target_ratio}
+• 🎯 适合平台: {platform_info}
+• 📦 下载包大小: {total_size:.1f}MB
 
-📹 输入处理:
-• 输入文件数: {len(video_files)}
-• 成功切片数: {len(all_clips)}
+💾 **自动储存:**
+• 📁 储存位置: ~/video_storage/
+• 🔥 已保存文件: {len(stored_files)} 个
+• ✅ 永久保存，不会丢失
 
-🎬 输出统计:
+⬇️ **立即下载:**
+点击下方按钮下载打包文件
 """
-            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)
-    
+        
+        details = f"""🎬 **视频详情:**
+
+"""
+        for i, vf in enumerate(output_files, 1):
+            size_mb = os.path.getsize(vf) / (1024 * 1024)
+            details += f"• 混剪视频_{i}: {size_mb:.1f}MB\n"
+        
+        details += f"""
+💾 **储存详情:**
+"""
+        for i, stored_file in enumerate(stored_files, 1):
+            details += f"• 已储存: {stored_file}\n"
+        
+        # 获取最新储存信息
+        config, video_list = get_storage_info()
+        storage_info = f"""📊 **储存空间状态:**
+
+💾 总计: {config['total_videos']} 个视频
+📦 总大小: {config['total_size_mb']}MB
+📁 位置: ~/video_storage/
+
+📋 **最新文件:**
+"""
+        
+        for video in video_list[:5]:  # 只显示最新5个
+            storage_info += f"• {video['name']} ({video['size_mb']}MB) - {video['modified']}\n"
+        
+        return success_msg, zip_path, details, storage_info
+        
     except Exception as e:
-        error_trace = traceback.format_exc()
-        print(f"💥 处理过程发生异常:")
-        print(error_trace)
-        return f"❌ 处理异常: {str(e)}", None, error_trace
+        return f"❌ 处理失败: {str(e)}", None, "", ""
     
     finally:
-        # 清理临时文件
-        try:
-            shutil.rmtree(temp_dir, ignore_errors=True)
-            print("🧹 临时文件清理完成")
-        except:
-            pass
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
+def refresh_storage_display():
+    """刷新储存空间显示"""
+    config, video_list = get_storage_info()
+    
+    storage_display = f"""💾 **储存空间概览**
+
+📊 **统计信息:**
+• 总视频数量: {config['total_videos']} 个
+• 总占用空间: {config['total_size_mb']}MB
+• 储存位置: ~/video_storage/
+
+📁 **文件列表:**
+"""
+    
+    if video_list:
+        for video in video_list:
+            storage_display += f"• {video['name']} ({video['size_mb']}MB) - {video['modified']}\n"
+    else:
+        storage_display += "暂无文件\n"
+    
+    # 生成文件选择列表
+    file_choices = [video['name'] for video in video_list]
+    
+    return storage_display, gr.Dropdown(choices=file_choices, label="选择要删除的文件", interactive=True)
+
+def handle_delete_file(filename):
+    """处理文件删除"""
+    if not filename:
+        return "⚠️ 请选择要删除的文件", refresh_storage_display()[0], refresh_storage_display()[1]
+    
+    result = delete_storage_file(filename)
+    new_display, new_dropdown = refresh_storage_display()
+    return result, new_display, new_dropdown
+
+def handle_clear_storage():
+    """处理清空储存"""
+    result = clear_storage()
+    new_display, new_dropdown = refresh_storage_display()
+    return result, new_display, new_dropdown
+
+# 初始化储存空间
+init_storage()
 
 def main():
-    with gr.Blocks(title="调试版FFmpeg剪辑工具") as demo:
+    with gr.Blocks(title="FFmpeg混剪+储存管理", theme=gr.themes.Soft()) as demo:
         
         gr.HTML("""
         <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>
+            <h1>🎬 FFmpeg 混剪工具 + 储存管理</h1>
+            <p style="margin: 10px 0 0 0;">长视频切片 → 智能混剪 → 比例调整 → 自动储存 → 永久保存</p>
         </div>
         """)
         
-        gr.Markdown("""
-        ### 🔧 调试版特性
-        - 📝 **详细日志**: 显示每步处理的详细信息
-        - 🛠️ **错误诊断**: 精确定位问题所在
-        - 🔍 **文件检查**: 验证每个步骤的文件状态
-        - ⚡ **稳定处理**: 使用最兼容的FFmpeg参数
-        """)
-        
-        with gr.Row():
-            with gr.Column():
-                video_input = gr.File(
-                    label="📤 上传视频文件", 
-                    file_types=[".mp4", ".mov", ".avi"], 
-                    file_count="multiple"
-                )
-                
+        with gr.Tabs():
+            # 第一个标签页：视频处理
+            with gr.TabItem("🎬 视频混剪"):
                 with gr.Row():
-                    clip_duration = gr.Number(value=3, label="切片时长(秒)", minimum=1, maximum=30)
-                    num_output = gr.Number(value=2, label="生成数量", minimum=1, maximum=5)
-                
-                target_ratio = gr.Radio(choices=["9:16", "16:9"], value="9:16", label="视频比例")
+                    with gr.Column(scale=2):
+                        video_input = gr.File(
+                            label="📤 上传视频文件 (支持多个)", 
+                            file_types=[".mp4", ".mov", ".avi", ".mkv"], 
+                            file_count="multiple",
+                            height=120
+                        )
+                        
+                        with gr.Row():
+                            clip_duration = gr.Number(
+                                value=3, 
+                                label="切片时长(秒)", 
+                                minimum=1, 
+                                maximum=3600
+                            )
+                            num_output = gr.Number(
+                                value=3, 
+                                label="生成数量", 
+                                minimum=1, 
+                                maximum=100
+                            )
+                        
+                        ratio_selection = gr.Radio(
+                            choices=["9:16", "16:9"], 
+                            value="9:16",
+                            label="📐 视频比例",
+                            info="9:16适合抖音快手 | 16:9适合YouTube B站"
+                        )
+                        
+                        process_btn = gr.Button("🎬 开始混剪并储存", variant="primary", size="lg")
+                    
+                    with gr.Column(scale=1):
+                        status_output = gr.Textbox(
+                            label="📊 处理状态", 
+                            lines=12, 
+                            interactive=False
+                        )
                 
-                process_btn = gr.Button("🔧 开始调试处理", variant="primary")
-        
-        with gr.Row():
-            with gr.Column():
-                status_output = gr.Textbox(label="处理状态", lines=8, interactive=False)
-                download_file = gr.File(label="下载结果", interactive=False)
+                with gr.Row():
+                    with gr.Column():
+                        download_file = gr.File(label="📦 下载混剪视频包", interactive=False)
+                    
+                    with gr.Column():
+                        details_output = gr.Textbox(
+                            label="📝 处理详情", 
+                            lines=12, 
+                            interactive=False
+                        )
+                    
+                    with gr.Column():
+                        storage_status = gr.Textbox(
+                            label="💾 储存状态", 
+                            lines=12, 
+                            interactive=False
+                        )
             
-            with gr.Column():
-                debug_output = gr.Textbox(label="调试信息", lines=12, interactive=False)
+            # 第二个标签页：储存管理
+            with gr.TabItem("💾 储存管理"):
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        storage_display = gr.Textbox(
+                            label="📁 储存空间", 
+                            lines=15, 
+                            interactive=False,
+                            value="点击刷新按钮查看储存状态"
+                        )
+                    
+                    with gr.Column(scale=1):
+                        refresh_btn = gr.Button("🔄 刷新储存状态", variant="secondary")
+                        
+                        gr.Markdown("### 🗑️ 文件管理")
+                        
+                        file_selector = gr.Dropdown(
+                            choices=[], 
+                            label="选择文件", 
+                            interactive=True
+                        )
+                        
+                        with gr.Row():
+                            delete_btn = gr.Button("🗑️ 删除文件", variant="secondary")
+                            clear_btn = gr.Button("🧹 清空储存", variant="stop")
+                        
+                        operation_result = gr.Textbox(
+                            label="操作结果", 
+                            lines=3, 
+                            interactive=False
+                        )
         
+        # 事件绑定
         process_btn.click(
-            fn=process_videos_with_debug,
-            inputs=[video_input, clip_duration, num_output, target_ratio],
-            outputs=[status_output, download_file, debug_output]
+            fn=process_videos_with_storage,
+            inputs=[video_input, clip_duration, num_output, ratio_selection],
+            outputs=[status_output, download_file, details_output, storage_status]
+        )
+        
+        refresh_btn.click(
+            fn=refresh_storage_display,
+            outputs=[storage_display, file_selector]
+        )
+        
+        delete_btn.click(
+            fn=handle_delete_file,
+            inputs=[file_selector],
+            outputs=[operation_result, storage_display, file_selector]
+        )
+        
+        clear_btn.click(
+            fn=handle_clear_storage,
+            outputs=[operation_result, storage_display, file_selector]
+        )
+        
+        # 页面加载时自动刷新储存显示
+        demo.load(
+            fn=refresh_storage_display,
+            outputs=[storage_display, file_selector]
         )
         
         gr.Markdown("""
         ---
-        ### 🔧 调试说明
+        ### 📖 功能说明
+        
+        **🎬 视频混剪功能:**
+        - ⚡ 自动切片和随机混剪
+        - 📐 支持9:16/16:9比例调整
+        - 📦 打包下载所有生成视频
+        - 💾 **自动储存到本地目录**
         
-        这个调试版本会显示详细的处理过程，帮助识别问题：
+        **💾 储存管理功能:**
+        - 📁 所有生成视频自动保存到 `~/video_storage/`
+        - 🔄 实时查看储存空间使用情况
+        - 🗑️ 支持单个文件删除
+        - 🧹 支持清空全部储存文��
+        - 📊 显示文件详细信息（大小、时间）
         
-        - ✅ **成功标志**: 显示每步成功完成
-        - ❌ **失败标志**: 显示具体失败原因  
-        - 📁 **文件信息**: 显示文件大小和路径
-        - 🔧 **命令日志**: 显示执行的FFmpeg命令
+        **🔥 储存优势:**
+        - ✅ **永久保存**: 文件不会因临时目录清理而丢失
+        - 🚀 **快速访问**: 本地储存，无需重新下载
+        - 📱 **灵活管理**: 随时查看、删除不需要的文件
+        - 💾 **空间监控**: 实时显示储存使用情况
         
-        如果仍然失败，请查看"调试信息"栏中的详细错误信息。
+        **⚠️ 注意事项:**
+        - 储存目录位于用户主目录下的 `video_storage` 文件夹
+        - 请定期清理不需要的文件以节省磁盘空间
+        - 删除操作不可恢复，请谨慎操作
         """)
     
     demo.launch()