Update app.py

app.py

@@ -1,374 +1,41 @@
 import streamlit as st
-import subprocess
 import os
-import random
-import tempfile
 import shutil
-import time
 
-st.set_page_config(page_title="TikTok Video Generator", layout="centered")
-st.title("🎥 TikTok Video Generator - PRO")
-
-st.markdown("Envie seus vídeos e gere conteúdo com efeitos, zoom, texto, música e filtros!")
-
-# Uploads dos vídeos de cortes (principal)
-st.markdown("<div style='background-color:#F0F0FF;padding:10px;border-radius:8px'>", unsafe_allow_html=True)
-st.subheader("🎬 Envie os vídeos principais (cortes)")
-cortes = st.file_uploader("Vídeos de cortes", type=["mp4"], accept_multiple_files=True)
-st.markdown("</div>", unsafe_allow_html=True)
-
-# Upload do vídeo de fundo (opcional)
-st.markdown("<div style='background-color:#FFF0F0;padding:10px;border-radius:8px;margin-top:15px;'>", unsafe_allow_html=True)
-st.subheader("🌄 Envie o vídeo de fundo (opcional)")
-video_fundo = st.file_uploader("Vídeo de Fundo (com blur e efeitos)", type=["mp4", "mov"])
-st.markdown("</div>", unsafe_allow_html=True)
-
-# Uploads adicionais
-video_tutorial = st.file_uploader("📎 Tutorial (opcional)", type="mp4")
-musica = st.file_uploader("🎵 Música (opcional, MP3)", type=["mp3"])
-
-# Configurações gerais
-num_videos_finais = st.number_input("Quantos vídeos gerar?", 1, 10, 1)
-duracao_final = st.number_input("Duração final (s)", 10, 300, 30)
-duracao_corte = st.number_input("Duração de cada corte (s)", 1, 30, 5)
-zoom = st.slider("Zoom no vídeo principal", 1.0, 2.0, 1.0, 0.1)
-blur_strength = st.slider("Blur no fundo", 1, 50, 10)
-velocidade_cortes = st.slider("Velocidade dos cortes", 0.5, 2.0, 1.0, 0.1)
-velocidade_final = st.slider("Velocidade final", 0.5, 2.0, 1.0, 0.1)
-crf_value = st.slider("Qualidade CRF", 18, 30, 23)
-
-# Texto com emojis
-st.write("### Texto no Vídeo")
-ativar_texto = st.checkbox("Ativar texto", value=False)
-if ativar_texto:
-    texto_personalizado = st.text_input("Texto (emojis permitidos)", "🔥 Siga para mais!")
-    posicao_texto = st.selectbox("Posição do texto", ["Topo", "Centro", "Base"])
-    duracao_texto = st.radio("Duração do texto", ["Vídeo todo", "Apenas primeiros segundos"])
-    segundos_texto = 5
-    if duracao_texto == "Apenas primeiros segundos":
-        segundos_texto = st.slider("Segundos", 1, 30, 5)
-    cor_texto = st.color_picker("Cor do texto", "#FFFF00")
-    cor_sombra = st.color_picker("Cor da sombra", "#000000")
-    tamanho_texto = st.slider("Tamanho da fonte", 20, 100, 60, step=2)
-
-# Filtros no fundo
-st.write("### Filtros no fundo")
-ativar_blur_fundo = st.checkbox("Ativar blur no fundo", value=True)
-ativar_sepia = st.checkbox("Sépia", False)
-ativar_granulado = st.checkbox("Granulado", False)
-ativar_pb = st.checkbox("Preto e branco", False)
-ativar_vignette = st.checkbox("Vignette", False)
-
-# Novos efeitos PRO
-st.write("### Efeitos PRO")
-ativar_zoom_dinamico = st.checkbox("Ativar Zoom/Pan Dinâmico (Movimento de câmera)", value=False)
-ativar_color_grading = st.checkbox("Aplicar Color Grading Aleatório", value=False)
-ativar_transicoes = st.checkbox("Adicionar Transições Cinemáticas", value=False)
-ativar_freeze_frame = st.checkbox("Aplicar Freeze Frame automático", value=False)
-ativar_slow_motion = st.checkbox("Aplicar Slow Motion Inteligente aleatório", value=False)
-
-# Efeitos extras
-st.write("### Outros efeitos")
-ativar_espelhar = st.checkbox("Espelhar vídeo", True)
-ativar_filtro_cor = st.checkbox("Ajuste de cor", True)
-remover_borda = st.checkbox("Remover borda do vídeo")
-tamanho_borda = st.slider("Tamanho da borda (px)", 0, 200, 0, 5)
-
-# Borda personalizada
-ativar_borda_personalizada = st.checkbox("Borda personalizada", False)
-if ativar_borda_personalizada:
-    cor_borda = st.color_picker("Cor da borda", "#FF0000")
-    animacao_borda = st.selectbox("Animação da borda", ["Nenhuma", "Borda Pulsante", "Cor Animada", "Neon", "Ondulada"])
-# BOTÃO PRINCIPAL
-if st.button("Gerar Vídeo(s)"):
-    if not cortes:
-        st.error("❌ Envie os vídeos de cortes.")
-    else:
-        with st.spinner("🎬 Processando..."):
-            progresso = st.progress(0)
-            temp_dir = tempfile.mkdtemp()
-
-            try:
-                # Salvar ou gerar fundo
-                fundo_path = os.path.join(temp_dir, "fundo.mp4")
-
-                if video_fundo:
-                    with open(fundo_path, "wb") as f:
-                        f.write(video_fundo.read())
-                else:
-                    subprocess.run([
-                        "ffmpeg", "-f", "lavfi", "-i", "color=black:s=720x1280:d=600",
-                        "-c:v", "libx264", "-t", str(duracao_final),
-                        "-pix_fmt", "yuv420p", "-y", fundo_path
-                    ], check=True, stderr=subprocess.PIPE)
-
-                # Salvar e converter tutorial (se enviado)
-                if video_tutorial:
-                    tutorial_path = os.path.join(temp_dir, "tutorial_raw.mp4")
-                    with open(tutorial_path, "wb") as f:
-                        f.write(video_tutorial.read())
-                    tutorial_mp4 = os.path.join(temp_dir, "tutorial.mp4")
-                    subprocess.run([
-                        "ffmpeg", "-i", tutorial_path, "-vf", "scale=720:1280,fps=30",
-                        "-c:v", "libx264", "-preset", "ultrafast", "-crf", str(crf_value),
-                        "-y", tutorial_mp4
-                    ], check=True, stderr=subprocess.PIPE)
-
-                # Padronizar vídeos de cortes
-                cortes_names = []
-                for idx, corte in enumerate(cortes):
-                    path_in = os.path.join(temp_dir, f"corte_in_{idx}.mp4")
-                    path_out = os.path.join(temp_dir, f"corte_padrao_{idx}.mp4")
-                    with open(path_in, "wb") as f:
-                        f.write(corte.read())
-                    subprocess.run([
-                        "ffmpeg", "-i", path_in,
-                        "-vf", "scale=1280:720:force_original_aspect_ratio=decrease,scale=trunc(iw/2)*2:trunc(ih/2)*2",
-                        "-c:v", "libx264", "-preset", "ultrafast", "-crf", "30", path_out
-                    ], check=True, stderr=subprocess.PIPE)
-                    cortes_names.append(path_out)
-
-                # Cortar fundo para a duração final
-                fundo_cortado = os.path.join(temp_dir, "fundo_cortado.mp4")
-                subprocess.run([
-                    "ffmpeg", "-i", fundo_path, "-t", str(duracao_final),
-                    "-c:v", "libx264", "-preset", "ultrafast", "-y", fundo_cortado
-                ], check=True, stderr=subprocess.PIPE)
-
-                for n in range(num_videos_finais):
-                    progresso.progress(10 + n * 5)
-                    random.shuffle(cortes_names)
-                    tempo_total = 0
-                    cortes_prontos = []
-
-                    while tempo_total < duracao_final:
-                        for c in cortes_names:
-                            dur = subprocess.run([
-                                "ffprobe", "-v", "error", "-show_entries", "format=duration",
-                                "-of", "default=noprint_wrappers=1:nokey=1", c
-                            ], stdout=subprocess.PIPE).stdout.decode().strip()
-
-                            try:
-                                d = float(dur)
-                                if d > duracao_corte:
-                                    ini = random.uniform(0, d - duracao_corte)
-                                    out = os.path.join(temp_dir, f"cut_{random.randint(1000,9999)}.mp4")
-
-                                    filtros_corte = []
-
-                                    # ✅ Zoom/Pan Dinâmico corrigido
-                                    if ativar_zoom_dinamico:
-                                        filtros_corte.append("scale=iw*1.05:ih*1.05,crop=iw-20:ih-20")
-                                    else:
-                                        filtros_corte.append("scale=trunc(iw/2)*2:trunc(ih/2)*2")
-
-                                    # ✅ Transições Cinemáticas
-                                    if ativar_transicoes:
-                                        filtros_corte.append("fade=t=in:st=0:d=0.3,fade=t=out:st=4.7:d=0.3")
-
-                                    # ✅ Slow Motion Inteligente (aleatório)
-                                    aplicar_slow = ativar_slow_motion and random.random() < 0.3
-                                    if aplicar_slow:
-                                        filtros_corte.append("setpts=1.5*PTS")
-
-                                    # ✅ Freeze Frame (aleatório, 0.5s no meio)
-                                    aplicar_freeze = ativar_freeze_frame and random.random() < 0.3
-                                    if aplicar_freeze:
-                                        freeze_frame = os.path.join(temp_dir, f"freeze_{random.randint(1000,9999)}.mp4")
-                                        subprocess.run([
-                                            "ffmpeg", "-ss", str(ini + duracao_corte/2), "-i", c,
-                                            "-t", "0.001", "-vf", "scale=1280:720", "-c:v", "libx264",
-                                            "-y", freeze_frame
-                                        ], check=True, stderr=subprocess.PIPE)
-                                        cortes_prontos.append(freeze_frame)
-                                        tempo_total += 0.5
-
-                                    filtro_final = ",".join(filtros_corte)
-
-                                    subprocess.run([
-                                        "ffmpeg", "-ss", str(ini), "-i", c, "-t", str(duracao_corte),
-                                        "-vf", filtro_final,
-                                        "-an", "-c:v", "libx264", "-preset", "ultrafast", "-crf", "30", out
-                                    ], check=True, stderr=subprocess.PIPE)
-
-                                    cortes_prontos.append(out)
-                                    tempo_total += duracao_corte / velocidade_cortes
-                                    if tempo_total >= duracao_final:
-                                        break
-                            except:
-                                continue
-                    # Concatenação dos cortes
-                    lista = os.path.join(temp_dir, f"lista_{n}.txt")
-                    with open(lista, "w") as f:
-                        for c in cortes_prontos:
-                            f.write(f"file '{c}'\n")
-
-                    video_raw = os.path.join(temp_dir, f"video_raw_{n}.mp4")
-                    subprocess.run([
-                        "ffmpeg", "-f", "concat", "-safe", "0", "-i", lista,
-                        "-vf", "scale=trunc(iw/2)*2:trunc(ih/2)*2",
-                        "-c:v", "libx264", "-preset", "ultrafast", "-crf", "30", video_raw
-                    ], check=True, stderr=subprocess.PIPE)
-
-                    progresso.progress(35 + n * 5)
-
-                    # Filtros aplicados ao vídeo principal (sobre o vídeo de cortes)
-                    filtros_main = ["scale=720:1280:force_original_aspect_ratio=decrease"]
-
-                    if zoom != 1.0:
-                        filtros_main.append(f"scale=iw*{zoom}:ih*{zoom}")
-
-                    filtros_main.append(f"setpts=PTS/{velocidade_cortes}")
-
-                    if ativar_espelhar:
-                        filtros_main.append("hflip")
-
-                    if remover_borda and tamanho_borda > 0:
-                        filtros_main.append(f"crop=in_w-{tamanho_borda*2}:in_h-{tamanho_borda*2}")
-
-                    if ativar_filtro_cor:
-                        filtros_main.append("eq=contrast=1.1:saturation=1.2")
-
-                    # ✅ Color Grading aleatório
-                    if ativar_color_grading:
-                        opcoes_color = [
-                            "curves=preset=vintage",
-                            "curves=preset=strong_contrast",
-                            "eq=brightness=0.05:saturation=1.4:contrast=1.3",
-                            "hue=s=0.6",
-                            "colorchannelmixer=.5:0:.5:0:.5:0:.5:0:.5:0:.5"
-                        ]
-                        filtros_main.append(random.choice(opcoes_color))
-
-                    filtros_main.append("scale=trunc(iw/2)*2:trunc(ih/2)*2")
-                    # Montar filter_complex
-                    filtro_complex = (
-                        f"[0:v]scale=720:1280:force_original_aspect_ratio=increase,"
-                        f"crop=720:1280"
-                    )
-
-                    if ativar_blur_fundo:
-                        filtro_complex += f",boxblur={blur_strength}:1"
-                    if ativar_sepia:
-                        filtro_complex += ",colorchannelmixer=.393:.769:.189:0:.349:.686:.168:0:.272:.534:.131"
-                    if ativar_granulado:
-                        filtro_complex += ",noise=alls=20:allf=t+u"
-                    if ativar_pb:
-                        filtro_complex += ",hue=s=0.3"
-                    if ativar_vignette:
-                        filtro_complex += ",vignette"
-                    filtro_complex += "[blur];"
-
-                    filtro_complex += f"[1:v]{','.join(filtros_main)}[zoomed];"
-                    filtro_complex += "[blur][zoomed]overlay=(W-w)/2:(H-h)/2[base]"
-
-                    if ativar_texto and texto_personalizado.strip():
-                        y_pos = "100" if posicao_texto == "Topo" else "(h-text_h)/2" if posicao_texto == "Centro" else "h-text_h-100"
-                        enable = f":enable='lt(t\\,{segundos_texto})'" if duracao_texto == "Apenas primeiros segundos" else ""
-                        texto_clean = texto_personalizado.replace(":", "\\:").replace("'", "\\'")
-                        filtro_complex += f";[base]drawtext=text='{texto_clean}':"
-                        filtro_complex += (
-                            f"fontfile=/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf:"
-                            f"fontcolor={cor_texto}:fontsize={tamanho_texto}:"
-                            f"shadowcolor={cor_sombra}:shadowx=3:shadowy=3:"
-                            f"x=(w-text_w)/2:y={y_pos}{enable}[final]"
-                        )
-                    else:
-                        filtro_complex += ";[base]null[final]"
-
-                    # Gerar vídeo com filtros
-                    video_editado = os.path.join(temp_dir, f"video_editado_{n}.mp4")
-                    subprocess.run([
-                        "ffmpeg", "-i", fundo_cortado, "-i", video_raw,
-                        "-filter_complex", filtro_complex,
-                        "-map", "[final]",
-                        "-c:v", "libx264", "-preset", "ultrafast", "-crf", str(crf_value),
-                        video_editado
-                    ], check=True, stderr=subprocess.PIPE)
-
-                    # Acelerar vídeo (sem áudio ainda)
-                    video_acelerado = os.path.join(temp_dir, f"video_acelerado_{n}.mp4")
-                    subprocess.run([
-                        "ffmpeg", "-y", "-i", video_editado, "-an",
-                        "-filter:v", f"setpts=PTS/{velocidade_final}",
-                        "-c:v", "libx264", "-preset", "ultrafast", "-crf", str(crf_value),
-                        video_acelerado
-                    ], check=True, stderr=subprocess.PIPE)
-
-                    progresso.progress(90)
-                    # Tutorial no meio, se fornecido
-                    video_final_raw = video_acelerado  # Começa com o vídeo acelerado
-                    if video_tutorial:
-                        dur_proc = subprocess.run([
-                            "ffprobe", "-v", "error", "-show_entries", "format=duration",
-                            "-of", "default=noprint_wrappers=1:nokey=1", video_acelerado
-                        ], stdout=subprocess.PIPE)
-                        dur_f = float(dur_proc.stdout.decode().strip())
-                        pt = dur_f / 2 if dur_f < 10 else random.uniform(5, dur_f - 5)
-
-                        part1 = os.path.join(temp_dir, f"part1_{n}.mp4")
-                        part2 = os.path.join(temp_dir, f"part2_{n}.mp4")
-
-                        subprocess.run([
-                            "ffmpeg", "-i", video_acelerado, "-ss", "0", "-t", str(pt),
-                            "-c:v", "libx264", "-preset", "ultrafast", part1
-                        ], check=True, stderr=subprocess.PIPE)
-                        subprocess.run([
-                            "ffmpeg", "-i", video_acelerado, "-ss", str(pt),
-                            "-c:v", "libx264", "-preset", "ultrafast", part2
-                        ], check=True, stderr=subprocess.PIPE)
-
-                        final_txt = os.path.join(temp_dir, f"final_{n}.txt")
-                        with open(final_txt, "w") as f:
-                            f.write(f"file '{part1}'\nfile '{tutorial_mp4}'\nfile '{part2}'\n")
-
-                        video_final_raw = os.path.join(temp_dir, f"video_final_raw_{n}.mp4")
-                        subprocess.run([
-                            "ffmpeg", "-f", "concat", "-safe", "0", "-i", final_txt,
-                            "-c:v", "libx264", "-preset", "ultrafast", "-crf", str(crf_value),
-                            video_final_raw
-                        ], check=True, stderr=subprocess.PIPE)
-
-                    # 🧠 Obter duração real do vídeo final (após tudo)
-                    dur_proc = subprocess.run([
-                        "ffprobe", "-v", "error", "-show_entries", "format=duration",
-                        "-of", "default=noprint_wrappers=1:nokey=1", video_final_raw
-                    ], stdout=subprocess.PIPE)
-                    dur_video_real = float(dur_proc.stdout.decode().strip())
-
-                    # 🎵 Cortar música para a duração real
-                    if musica:
-                        musica_path = os.path.join(temp_dir, "musica_original.mp3")
-                        with open(musica_path, "wb") as f:
-                            f.write(musica.read())
-
-                        musica_cortada = os.path.join(temp_dir, f"musica_cortada_{n}.aac")
-                        subprocess.run([
-                            "ffmpeg", "-i", musica_path, "-ss", "0", "-t", str(dur_video_real),
-                            "-vn", "-acodec", "aac", "-y", musica_cortada
-                        ], check=True, stderr=subprocess.PIPE)
-
-                        final_name = f"video_final_{n}_{int(time.time())}.mp4"
-                        subprocess.run([
-                            "ffmpeg", "-i", video_final_raw, "-i", musica_cortada,
-                            "-map", "0:v:0", "-map", "1:a:0",
-                            "-c:v", "copy", "-c:a", "aac",
-                            "-shortest", final_name
-                        ], check=True, stderr=subprocess.PIPE)
-
-                    else:
-                        final_name = f"video_final_{n}_{int(time.time())}.mp4"
-                        shutil.copy(video_final_raw, final_name)
-
-                    st.video(final_name)
-                    with open(final_name, "rb") as f:
-                        st.download_button(f"📥 Baixar vídeo {n+1}", f, file_name=final_name)
-
-                progresso.progress(100)
-                st.success("✅ Todos os vídeos foram gerados com sucesso!")
-
-            except subprocess.CalledProcessError as e:
-                st.error(f"❌ Erro ao gerar vídeo:\n\n{e.stderr.decode(errors='ignore')}")
-
-            finally:
-                shutil.rmtree(temp_dir)
+UPLOAD_FOLDER = "uploaded_files"
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+st.title("📂 File Manager Simples")
+
+# --- Upload ---
+st.header("📤 Upload de Arquivos")
+uploaded_files = st.file_uploader("Selecione arquivos", accept_multiple_files=True)
+
+if uploaded_files:
+    for uploaded_file in uploaded_files:
+        file_path = os.path.join(UPLOAD_FOLDER, uploaded_file.name)
+        with open(file_path, "wb") as f:
+            f.write(uploaded_file.read())
+    st.success("Arquivos enviados com sucesso!")
+    st.experimental_rerun()  # Atualiza a página após upload
+
+# --- Lista de Arquivos ---
+st.header("📄 Arquivos Disponíveis")
+
+files = os.listdir(UPLOAD_FOLDER)
+
+if not files:
+    st.info("Nenhum arquivo disponível.")
+else:
+    for file in files:
+        col1, col2, col3 = st.columns([4, 1, 1])
+        with col1:
+            st.write(file)
+        with col2:
+            with open(os.path.join(UPLOAD_FOLDER, file), "rb") as f:
+                st.download_button("⬇ Download", f, file_name=file)
+        with col3:
+            if st.button("🗑 Excluir", key=f"delete_{file}"):
+                os.remove(os.path.join(UPLOAD_FOLDER, file))
+                st.success(f"Arquivo '{file}' excluído.")
+                st.experimental_rerun()  # Atualiza a lista após exclusão