Update app.py

app.py

@@ -0,0 +1,198 @@
+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 - Completo")
+
+st.markdown("Envie seus vídeos e gere conteúdo com efeitos, filtros e controle total de duração!")
+
+# Upload dos vídeos
+cortes = st.file_uploader("Envie os vídeos de cortes", type=["mp4"], accept_multiple_files=True)
+video_tutorial = st.file_uploader("Envie o vídeo pronto/tutorial (será inserido automaticamente)", type="mp4")
+
+# Configurações
+num_videos_finais = st.number_input("Quantos vídeos finais gerar?", min_value=1, max_value=10, value=1)
+duracao_final = st.number_input("Duração final do vídeo (em segundos)", min_value=10, max_value=300, value=30)
+duracao_corte = st.number_input("Duração de cada corte aleatório (s)", min_value=1, max_value=30, value=5)
+zoom = st.slider("Zoom Central (1.0 = normal)", 1.0, 2.0, 1.2, 0.1)
+blur_strength = st.slider("Intensidade do Blur", 1, 50, 10)
+velocidade_cortes = st.slider("Velocidade dos cortes", 0.5, 2.0, 1.0, 0.1)
+velocidade_final = st.slider("Velocidade final do vídeo", 0.5, 2.0, 1.0, 0.1)
+crf_value = st.slider("Qualidade CRF (menor = melhor qualidade)", 18, 30, 23)
+
+st.write("### Filtros no Fundo")
+ativar_blur_fundo = st.checkbox("Ativar vídeo de fundo com Blur", value=True)
+ativar_sepia = st.checkbox("Sépia", value=False)
+ativar_granulado = st.checkbox("Granulado", value=False)
+ativar_pb = st.checkbox("Preto e Branco Leve", value=False)
+ativar_vignette = st.checkbox("Vignette", value=False)
+
+st.write("### Outros")
+ativar_espelhar = st.checkbox("Espelhar Vídeo", value=True)
+ativar_filtro_cor = st.checkbox("Filtro de Cor (Contraste/Saturação)", value=True)
+remover_borda = st.checkbox("Remover bordas do vídeo centralizado")
+tamanho_borda = st.slider("Tamanho da borda (px)", 0, 200, 0, 10)
+
+if st.button("Gerar Vídeo(s)"):
+    if not cortes or not video_tutorial:
+        st.error("❌ Envie os vídeos para continuar.")
+    else:
+        with st.spinner('🎥 Seu vídeo está sendo gerado...'):
+            progresso = st.progress(0)
+            temp_dir = tempfile.mkdtemp()
+
+            try:
+                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)
+
+                progresso.progress(10)
+
+                cortes_names = []
+                for idx, corte in enumerate(cortes):
+                    nome = os.path.join(temp_dir, f"corte_{idx}_{random.randint(1000,9999)}.mp4")
+                    with open(nome, "wb") as f:
+                        f.write(corte.read())
+                    cortes_names.append(nome)
+
+                progresso.progress(20)
+
+                for n in range(num_videos_finais):
+                    cortes_prontos = []
+                    random.shuffle(cortes_names)
+                    progresso.progress(20 + int(20 * (n / num_videos_finais)))
+
+                    tempo_total = 0
+                    while tempo_total < duracao_final:
+                        for c in cortes_names:
+                            dur_proc = subprocess.run([
+                                "ffprobe", "-v", "error", "-show_entries", "format=duration",
+                                "-of", "default=noprint_wrappers=1:nokey=1", c
+                            ], stdout=subprocess.PIPE)
+
+                            dur = dur_proc.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_{n}_{random.randint(1000,9999)}.mp4")
+                                    subprocess.run([
+                                        "ffmpeg", "-ss", str(ini), "-i", c, "-t", str(duracao_corte),
+                                        "-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
+
+                    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, "-c:v", "libx264",
+                        "-preset", "ultrafast", "-crf", "30", video_raw
+                    ], check=True, stderr=subprocess.PIPE)
+
+                    progresso.progress(40 + int(20 * (n / num_videos_finais)))
+
+                    filtros_main = []
+                    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")
+
+                    if ativar_blur_fundo:
+                        filtro_complex = "[0:v]split=2[main][bg];"
+                        if filtros_main:
+                            filtro_complex += f"[main]{','.join(filtros_main)}[zoomed];"
+                        else:
+                            filtro_complex += "[main][zoomed];"
+                        filtro_complex += f"[bg]scale=720:1280,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];[blur][zoomed]overlay=(W-w)/2:(H-h)/2"
+                    else:
+                        filtro_complex = "[0:v]scale=720:1280[main];"
+                        if filtros_main:
+                            filtro_complex += f"[main]{','.join(filtros_main)}[zoomed];"
+                        else:
+                            filtro_complex += "[main][zoomed];"
+                        filtro_complex += "color=black:size=720x1280:d=1[bgblack];[bgblack][zoomed]overlay=(W-w)/2:(H-h)/2"
+
+                    video_editado = os.path.join(temp_dir, f"video_editado_{n}.mp4")
+                    subprocess.run([
+                        "ffmpeg", "-i", video_raw, "-filter_complex", filtro_complex, "-c:v", "libx264",
+                        "-preset", "ultrafast", "-crf", str(crf_value), video_editado
+                    ], check=True, stderr=subprocess.PIPE)
+
+                    part1 = os.path.join(temp_dir, f"part1_{n}.mp4")
+                    part2 = os.path.join(temp_dir, f"part2_{n}.mp4")
+
+                    dur_proc = subprocess.run([
+                        "ffprobe", "-v", "error", "-show_entries", "format=duration",
+                        "-of", "default=noprint_wrappers=1:nokey=1", video_editado
+                    ], 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)
+
+                    subprocess.run(["ffmpeg", "-ss", "0", "-i", video_editado, "-t", str(pt), "-c:v", "libx264",
+                                    "-preset", "ultrafast", part1], check=True, stderr=subprocess.PIPE)
+                    subprocess.run(["ffmpeg", "-ss", str(pt), "-i", video_editado, "-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)
+
+                    timestamp = int(time.time())
+                    video_final = f"video_final_{n}_{timestamp}.mp4"
+                    subprocess.run(["ffmpeg", "-y", "-i", video_final_raw, "-filter:v", f"setpts=PTS/{velocidade_final}",
+                                    "-t", str(duracao_final), "-c:v", "libx264", "-preset", "ultrafast",
+                                    "-crf", str(crf_value), video_final], check=True, stderr=subprocess.PIPE)
+
+                    progresso.progress(90 + int(10 * (n / num_videos_finais)))
+
+                    st.video(video_final)
+                    with open(video_final, "rb") as f:
+                        st.download_button(f"📅 Baixar Vídeo {n+1}", f, file_name=video_final)
+
+                progresso.progress(100)
+                st.success("✅ Todos os vídeos foram gerados com sucesso!")
+
+            except subprocess.CalledProcessError as e:
+                st.error(f"Erro durante processamento: {e.stderr.decode()}")
+
+            finally:
+                shutil.rmtree(temp_dir)