Update app.py

app.py

@@ -6,10 +6,10 @@ import tempfile
 import shutil
 import time
 
-st.set_page_config(page_title="TikTok Video Generator - PRO + Anti-Flop", layout="centered")
-st.title("🎥 TikTok Video Generator - PRO + Anti-Flop")
+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, filtros e antiflop!")
+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)
@@ -36,6 +36,7 @@ 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)
@@ -58,6 +59,12 @@ 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)
+
 # Efeitos extras
 st.write("### Outros efeitos")
 ativar_espelhar = st.checkbox("Espelhar vídeo", True)
@@ -70,55 +77,7 @@ 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"])
-
-# 🔒 Anti-Flop Completo
-st.write("### 🔒 Anti-Flop (Evitar Detecção)")
-ativar_antiflop = st.checkbox("Ativar Anti-Flop", value=False)
-if ativar_antiflop:
-    aplicar_random = st.button("🎲 RANDOMIZAR Anti-Flop")
-    if 'antiflop_settings' not in st.session_state or aplicar_random:
-        st.session_state.antiflop_settings = {
-            'zoom': random.uniform(1.00, 1.05),
-            'brilho': random.uniform(-0.05, 0.05),
-            'contraste': random.uniform(0.95, 1.05),
-            'saturacao': random.uniform(0.95, 1.05),
-            'ruido': random.randint(3, 15),
-            'rotacao': random.uniform(0.2, 1.5),
-            'pitch': random.uniform(1.00, 1.08),
-            'velocidade': random.uniform(1.00, 1.03),
-            'bitrate': random.randint(900, 1500),
-            'fps': random.choice([30, 29.97, 25])
-        }
-    antiflop = st.session_state.antiflop_settings
-    zoom_af = st.slider("Zoom Anti-Flop (%)", 100, 105, int(antiflop['zoom']*100)) / 100
-    brilho_af = st.slider("Brilho Anti-Flop", -0.1, 0.1, antiflop['brilho'])
-    contraste_af = st.slider("Contraste Anti-Flop", 0.9, 1.1, antiflop['contraste'])
-    saturacao_af = st.slider("Saturação Anti-Flop", 0.9, 1.1, antiflop['saturacao'])
-    ruido_af = st.slider("Ruído Visual Anti-Flop (0-20)", 0, 20, antiflop['ruido'])
-    rotacao_af = st.slider("Rotação Anti-Flop (graus)", 0.0, 2.0, antiflop['rotacao'])
-    pitch_af = st.slider("Pitch do Áudio Anti-Flop (%)", 100, 110, int(antiflop['pitch']*100)) / 100
-    velocidade_af = st.slider("Velocidade do Vídeo Anti-Flop (%)", 100, 103, int(antiflop['velocidade']*100)) / 100
-    bitrate_af = st.slider("Bitrate Anti-Flop (kbps)", 800, 2000, antiflop['bitrate'])
-    fps_af = st.selectbox("FPS Final Anti-Flop", [30, 29.97, 25], index=[30, 29.97, 25].index(antiflop['fps']))
-    st.subheader("🧩 Extras Anti-Detecção")
-    usar_marca = st.checkbox("Marca d’água Fantasma com perfil", value=True)
-    usar_glitch = st.checkbox("Inserir Frame Preto Aleatório", value=True)
-    res_random = st.checkbox("Resolução Aleatória", value=True)
-    cortar = st.checkbox("Cortar trecho aleatório do vídeo", value=True)
-    embaralhar = st.checkbox("Embaralhar trechos do vídeo", value=True)
-    st.subheader("🎨 Avançado Anti-Flop")
-    lote_efeitos = st.checkbox("Aplicar efeitos por lote (aleatórios)", value=True)
-    transicoes = st.checkbox("Transições visuais aleatórias", value=True)
-    st.subheader("🕵️‍♂️ Perfil Fingerprint")
-    fingerprint = st.selectbox("Escolha o Perfil Anti-Flop", ["Android", "iPhone", "Câmera", "CapCut", "Samsung", "Xiaomi", "LG"])
-
-# 💾 Download Automático
-st.write("### 💾 Download Automático")
-download_automatico = st.checkbox("Ativar Download Automático", value=False)
-# Lista para armazenar os vídeos gerados
-videos_gerados = []
-
-# Botão principal
+# BOTÃO PRINCIPAL
 if st.button("Gerar Vídeo(s)"):
     if not cortes:
         st.error("❌ Envie os vídeos de cortes.")
@@ -130,17 +89,19 @@ if st.button("Gerar Vídeo(s)"):
             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:
+                    # Gera fundo preto 720x1280 com duração longa
                     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)
 
-                # Tutorial (opcional)
+                # 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:
@@ -152,7 +113,7 @@ if st.button("Gerar Vídeo(s)"):
                         "-y", tutorial_mp4
                     ], check=True, stderr=subprocess.PIPE)
 
-                # Padronizar cortes 1280x720
+                # Padronizar vídeos de cortes para 1280x720 com múltiplos de 2
                 cortes_names = []
                 for idx, corte in enumerate(cortes):
                     path_in = os.path.join(temp_dir, f"corte_in_{idx}.mp4")
@@ -161,11 +122,11 @@ if st.button("Gerar Vídeo(s)"):
                         f.write(corte.read())
                     subprocess.run([
                         "ffmpeg", "-i", path_in,
-                        "-vf", "scale=1280:720:force_original_aspect_ratio=decrease",
+                        "-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
+                # ✅ Cortar o vídeo de 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),
@@ -190,10 +151,32 @@ if st.button("Gerar Vídeo(s)"):
                                 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 = []
+                                    # Aplica zoom dinâmico se ativado
+                                    if ativar_zoom_dinamico:
+                                        # Movimento aleatório para cima/baixo/esquerda/direita
+                                        movimentos = [
+                                            "crop=in_w-20:in_h-20:0:0,zoompan=z='zoom+0.001':d=125",
+                                            "crop=in_w-20:in_h-20:20:0,zoompan=z='zoom+0.0015':d=125",
+                                            "crop=in_w-20:in_h-20:0:20,zoompan=z='zoom+0.0015':d=125"
+                                        ]
+                                        filtros_corte.append(random.choice(movimentos))
+                                    else:
+                                        filtros_corte.append("scale=trunc(iw/2)*2:trunc(ih/2)*2")
+
+                                    # Transição: Adiciona fade in/out aleatório
+                                    if ativar_transicoes:
+                                        filtros_corte.append("fade=t=in:st=0:d=0.5,fade=t=out:st=4.5:d=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:
@@ -201,7 +184,7 @@ if st.button("Gerar Vídeo(s)"):
                             except:
                                 continue
 
-                    # Concatenação dos cortes
+                    # Concatenação dos cortes com ajuste para múltiplos de 2
                     lista = os.path.join(temp_dir, f"lista_{n}.txt")
                     with open(lista, "w") as f:
                         for c in cortes_prontos:
@@ -210,37 +193,45 @@ if st.button("Gerar Vídeo(s)"):
                     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 no vídeo principal (zoom, espelho, borda, etc.)
+                    # Filtros aplicados ao vídeo principal
                     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")
-                    if ativar_borda_personalizada:
-                        cor_ffmpeg = f"0x{cor_borda.lstrip('#')}FF"
-                        anim_map = {
-                            "Nenhuma": "",
-                            "Borda Pulsante": "enable='lt(mod(t,1),0.5)'",
-                            "Cor Animada": "enable='lt(mod(t,1),0.5)'",
-                            "Neon": "enable='lt(mod(t,0.5),0.25)'",
-                            "Ondulada": "enable='gt(sin(t*3.14),0)'"
-                        }
-                        drawbox = f"drawbox=x=0:y=0:w=iw:h=ih:color={cor_ffmpeg}:t=5"
-                        if anim_map[animacao_borda]:
-                            drawbox += f":{anim_map[animacao_borda]}"
-                        filtros_main.append(drawbox)
-
-                    # Fundo com filtros
-                    filtro_complex = f"[0:v]scale=720:1280:force_original_aspect_ratio=increase,crop=720:1280"
+
+                    # Aplica Color Grading aleatório se ativado
+                    if ativar_color_grading:
+                        opcoes_color = [
+                            "curves=preset=vintage",
+                            "curves=preset=strong_contrast",
+                            "curves=preset=color_negative",
+                            "hue=s=0.5",
+                            "eq=brightness=0.05:saturation=1.5:contrast=1.2"
+                        ]
+                        filtros_main.append(random.choice(opcoes_color))
+
+                    # Garantir múltiplos de 2 no final (sempre)
+                    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:
@@ -251,26 +242,36 @@ if st.button("Gerar Vídeo(s)"):
                         filtro_complex += ",hue=s=0.3"
                     if ativar_vignette:
                         filtro_complex += ",vignette"
-                    filtro_complex += "[blur];[1:v]" + ",".join(filtros_main) + "[zoomed];[blur][zoomed]overlay=(W-w)/2:(H-h)/2[base]"
+                    filtro_complex += "[blur];"
 
-                    # Inserir texto se ativado
+                    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}':fontfile=/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf:fontcolor={cor_texto}:fontsize={tamanho_texto}:shadowcolor={cor_sombra}:shadowx=3:shadowy=3:x=(w-text_w)/2:y={y_pos}{enable}[final]"
+                        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),
+                        "-map", "[final]",
+                        "-c:v", "libx264", "-preset", "ultrafast", "-crf", str(crf_value),
                         video_editado
                     ], check=True, stderr=subprocess.PIPE)
 
-                    # Acelerar vídeo final (sem áudio)
+                    # 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",
@@ -279,9 +280,9 @@ if st.button("Gerar Vídeo(s)"):
                         video_acelerado
                     ], check=True, stderr=subprocess.PIPE)
 
-                    progresso.progress(70)
-                    # Inserir tutorial no meio (se enviado)
-                    video_final_raw = video_acelerado
+                    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",
@@ -289,8 +290,10 @@ if st.button("Gerar Vídeo(s)"):
                         ], 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
@@ -299,9 +302,11 @@ if st.button("Gerar Vídeo(s)"):
                             "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,
@@ -309,22 +314,25 @@ if st.button("Gerar Vídeo(s)"):
                             video_final_raw
                         ], check=True, stderr=subprocess.PIPE)
 
-                    # 🎵 Inserir música no final
+                    # 🧠 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,
@@ -332,67 +340,16 @@ if st.button("Gerar Vídeo(s)"):
                             "-c:v", "copy", "-c:a", "aac",
                             "-shortest", final_name
                         ], check=True, stderr=subprocess.PIPE)
+
                     else:
+                        # Se não tiver música, só copia o vídeo final
                         final_name = f"video_final_{n}_{int(time.time())}.mp4"
                         shutil.copy(video_final_raw, final_name)
-                    # 🔒 APLICAR ANTI-FLOP NO FINAL
-                    if ativar_antiflop:
-                        st.info(f"🔒 Aplicando Anti-Flop no vídeo {n+1}...")
-
-                        antiflop_out = f"antiflop_{n}_{int(time.time())}.mp4"
-                        encoder_name = f"{fingerprint}Cam_{random.randint(1000,9999)}"
-
-                        vf_af = (
-                            f"scale=iw*{zoom_af}:ih*{zoom_af},"
-                            f"crop=iw/{zoom_af}:ih/{zoom_af},"
-                            f"eq=brightness={brilho_af}:contrast={contraste_af}:saturation={saturacao_af},"
-                            f"noise=alls={ruido_af}:allf=t,"
-                            f"rotate={rotacao_af}*PI/180:[email protected],"
-                            "scale=trunc(iw/2)*2:trunc(ih/2)*2"
-                        )
-                        if usar_marca:
-                            vf_af += f",drawtext=text='{encoder_name}':[email protected]:x=10:y=10:fontsize=24"
-                        if usar_glitch:
-                            vf_af += ",blackframe=1:0"
-                        if transicoes:
-                            effects = [
-                                "fade=t=in:st=0:d=0.5",
-                                "fade=t=out:st=3:d=0.5",
-                                "zoompan=z='min(pzoom+0.0015,1.5)':d=1",
-                                "drawbox=x=0:y=0:w=iw:h=ih:[email protected]:t=fill"
-                            ]
-                            vf_af += "," + random.choice(effects)
-
-                        af = f"asetrate=44100*{pitch_af},aresample=44100"
-                        profile = "baseline" if fingerprint in ["Android", "Xiaomi"] else "main"
-                        if fingerprint == "iPhone":
-                            profile = "high"
-                        level = "4.0" if fingerprint == "Samsung" else "3.1"
-                        ar = "44100" if fingerprint in ["iPhone", "Xiaomi"] else "48000"
 
-                        subprocess.run([
-                            'ffmpeg', '-i', final_name,
-                            '-vf', vf_af,
-                            '-af', af,
-                            '-r', str(fps_af),
-                            '-c:v', 'libx264', '-profile:v', profile, '-level', level,
-                            '-b:v', f"{bitrate_af}k", '-ar', ar,
-                            '-preset', 'fast', '-tune', 'zerolatency',
-                            '-movflags', '+faststart',
-                            antiflop_out
-                        ], check=True)
-
-                        videos_gerados.append(antiflop_out)
-                        st.video(antiflop_out)
-                        with open(antiflop_out, "rb") as f:
-                            st.download_button(f"📥 Baixar vídeo {n+1} Anti-Flop", f, file_name=antiflop_out)
-                    else:
-                        videos_gerados.append(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)
+                    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)
 
-                # Fim do for n in range(num_videos_finais)
                 progresso.progress(100)
                 st.success("✅ Todos os vídeos foram gerados com sucesso!")
 
@@ -401,28 +358,3 @@ if st.button("Gerar Vídeo(s)"):
 
             finally:
                 shutil.rmtree(temp_dir)
-# Fora do try-finally: Botão "Baixar Todos os Vídeos"
-if videos_gerados:
-    st.markdown("### 📥 Baixar Todos os Vídeos")
-
-    # Criar links ocultos para todos os vídeos
-    download_links = ""
-    for v in videos_gerados:
-        download_links += f"<a href='{v}' download='{v}'></a>\n"
-
-    # Botão com JavaScript para clicar em todos os links
-    st.markdown(
-        f"""
-        <button onclick="baixarTodos()">📥 Baixar Todos</button>
-        <script>
-        function baixarTodos() {{
-            const links = Array.from(document.querySelectorAll('a[download]'));
-            for (let l of links) {{
-                l.click();
-            }}
-        }}
-        </script>
-        {download_links}
-        """,
-        unsafe_allow_html=True
-    )