Update app.py

app.py

@@ -7,7 +7,7 @@ import shutil
 import time
 
 st.set_page_config(page_title="TikTok Video Generator - PRO", layout="centered")
-st.title("🎥 TikTok Video Generator - PRO")
+st.title("🎥 TikTok Video Generator - PRO + Anti-Flop")
 
 st.markdown("Envie seus vídeos e gere conteúdo com efeitos, zoom, texto, música, filtros e antiflop!")
 
@@ -71,16 +71,50 @@ 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 (Configuração)
+# 🔒 Anti-Flop Completo
 st.write("### 🔒 Anti-Flop (Evitar Detecção)")
 ativar_antiflop = st.checkbox("Ativar Anti-Flop", value=False)
 if ativar_antiflop:
-    zoom_af = st.slider("Zoom Anti-Flop (%)", 100, 105, 101) / 100
-    brilho_af = st.slider("Brilho Anti-Flop", -0.1, 0.1, 0.01)
-    contraste_af = st.slider("Contraste Anti-Flop", 0.9, 1.1, 1.01)
-    saturacao_af = st.slider("Saturação Anti-Flop", 0.9, 1.1, 1.01)
-    ruido_af = st.slider("Ruído Visual Anti-Flop (0-20)", 0, 20, 5)
-    rotacao_af = st.slider("Rotação Anti-Flop (graus)", 0.0, 2.0, 0.5)
+    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)
 # Botão principal
 if st.button("Gerar Vídeo(s)"):
     if not cortes:
@@ -97,7 +131,6 @@ if st.button("Gerar Vídeo(s)"):
                     with open(fundo_path, "wb") as f:
                         f.write(video_fundo.read())
                 else:
-                    # Gera fundo preto 720x1280
                     subprocess.run([
                         "ffmpeg", "-f", "lavfi", "-i", "color=black:s=720x1280:d=600",
                         "-c:v", "libx264", "-t", str(duracao_final),
@@ -233,7 +266,7 @@ if st.button("Gerar Vídeo(s)"):
                         video_editado
                     ], check=True, stderr=subprocess.PIPE)
 
-                    # Acelerar vídeo final
+                    # Acelerar vídeo final (sem áudio)
                     video_acelerado = os.path.join(temp_dir, f"video_acelerado_{n}.mp4")
                     subprocess.run([
                         "ffmpeg", "-y", "-i", video_editado, "-an",
@@ -242,9 +275,9 @@ if st.button("Gerar Vídeo(s)"):
                         video_acelerado
                     ], check=True, stderr=subprocess.PIPE)
 
-                    progresso.progress(90)
+                    progresso.progress(70)
 
-                    # Tutorial no meio
+                    # Tutorial no meio (se enviado)
                     video_final_raw = video_acelerado
                     if video_tutorial:
                         dur_proc = subprocess.run([
@@ -262,13 +295,13 @@ if st.button("Gerar Vídeo(s)"):
                             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)
+
                     # 🎵 Música final
                     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())
-
                     if musica:
                         musica_path = os.path.join(temp_dir, "musica_original.mp3")
                         with open(musica_path, "wb") as f:
@@ -291,26 +324,108 @@ if st.button("Gerar Vídeo(s)"):
 
                     # 🔒 APLICAR ANTI-FLOP NO FINAL
                     if ativar_antiflop:
+                        st.info(f"🔒 Aplicando Anti-Flop no vídeo {n+1}...")
+                        base_video = final_name
+                        # 🌀 Embaralhar trechos se ativado
+                        if embaralhar:
+                            temp_af_dir = f"temp_af_{random.randint(1000,9999)}"
+                            os.makedirs(temp_af_dir, exist_ok=True)
+                            subprocess.run(['ffmpeg', '-i', base_video, '-c', 'copy', '-f', 'segment', '-segment_time', '2', f'{temp_af_dir}/out%03d.mp4'])
+                            files = os.listdir(temp_af_dir)
+                            files.sort()
+                            random.shuffle(files)
+                            concat_list = f"{temp_af_dir}/list.txt"
+                            with open(concat_list, 'w') as f:
+                                for file in files:
+                                    f.write(f"file '{os.path.join(temp_af_dir, file)}'\n")
+                            shuffled_input = f"shuffled_af_{random.randint(1000,9999)}.mp4"
+                            subprocess.run(['ffmpeg', '-f', 'concat', '-safe', '0', '-i', concat_list, '-c', 'copy', shuffled_input])
+                            shutil.rmtree(temp_af_dir)
+                            base_video = shuffled_input if os.path.exists(shuffled_input) else final_name
+
+                        encoder_name = f"{fingerprint}Cam_{random.randint(1000,9999)}"
                         antiflop_out = f"antiflop_{n}_{int(time.time())}.mp4"
+
+                        # 🎨 Efeitos
+                        if lote_efeitos:
+                            zoom_r = random.uniform(1.00, 1.05)
+                            brilho_r = random.uniform(-0.05, 0.05)
+                            contraste_r = random.uniform(0.95, 1.05)
+                            saturacao_r = random.uniform(0.95, 1.05)
+                            ruido_r = random.randint(3, 15)
+                            rot_r = random.uniform(0.2, 1.5) * 0.01745
+                            velocidade_r = random.uniform(1.00, 1.03)
+                            bitrate_r = f"{random.randint(900, 1500)}k"
+                            pitch_r = random.uniform(1.00, 1.08)
+                        else:
+                            zoom_r = zoom_af
+                            brilho_r = brilho_af
+                            contraste_r = contraste_af
+                            saturacao_r = saturacao_af
+                            ruido_r = ruido_af
+                            rot_r = rotacao_af * 0.01745
+                            velocidade_r = velocidade_af
+                            bitrate_r = f"{bitrate_af}k"
+                            pitch_r = pitch_af
+
                         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]"
+                            f"scale=iw*{zoom_r}:ih*{zoom_r},"
+                            f"crop=iw/{zoom_r}:ih/{zoom_r},"
+                            f"eq=brightness={brilho_r}:contrast={contraste_r}:saturation={saturacao_r},"
+                            f"noise=alls={ruido_r}:allf=t,"
+                            f"rotate={rot_r}:[email protected]"
                         )
+                        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 res_random:
+                            w = random.choice([720, 960, 1080])
+                            h = random.choice([1280, 1440, 1920])
+                            vf_af += f",scale={w}:{h}"
+                        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_r},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,
-                            "-c:v", "libx264", "-preset", "fast", "-crf", str(crf_value),
+                            'ffmpeg', '-i', base_video,
+                            '-vf', vf_af,
+                            '-af', af,
+                            '-r', str(fps_af),
+                            '-c:v', 'libx264', '-profile:v', profile, '-level', level,
+                            '-b:v', bitrate_r, '-ar', ar,
+                            '-preset', 'fast', '-tune', 'zerolatency',
+                            '-movflags', '+faststart',
                             antiflop_out
                         ], check=True)
+
+                        # Download Anti-Flop
                         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)
+                            if download_automatico:
+                                st.download_button(f"📥 Baixar vídeo {n+1} Anti-Flop", f, file_name=antiflop_out, disabled=True)
+                            else:
+                                st.download_button(f"📥 Baixar vídeo {n+1} Anti-Flop", f, file_name=antiflop_out)
                     else:
+                        # Download normal
                         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)
+                            if download_automatico:
+                                st.download_button(f"📥 Baixar vídeo {n+1}", f, file_name=final_name, disabled=True)
+                            else:
+                                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!")