Update app.py

app.py

@@ -22,7 +22,6 @@ for cat in CATEGORIAS:
     os.makedirs(os.path.join(BASE_ASSETS, cat, "tutoriais"), exist_ok=True)
     os.makedirs(os.path.join(BASE_SALVOS, cat), exist_ok=True)
 
-# ======================== GERADOR DE VÍDEO ========================
 if pagina == "🎬 Gerador de Vídeo":
     st.title("🎥 TikTok Video Generator - PRO")
 
@@ -58,7 +57,7 @@ if pagina == "🎬 Gerador de Vídeo":
         zoom = st.slider("Zoom", 1.0, 2.0, 1.0, 0.1)
         blur_strength = st.slider("Blur no fundo", 1, 50, 10)
         velocidade_final = st.slider("Velocidade final", 0.5, 2.0, 1.0, 0.1)
-        crf_value = str(18)  # ✅ corrigido para string
+        crf_value = st.slider("Qualidade CRF", 18, 30, 18)
 
         st.write("## Texto no Vídeo")
         ativar_texto = st.checkbox("Ativar texto")
@@ -99,8 +98,6 @@ if pagina == "🎬 Gerador de Vídeo":
             animacao_borda = st.selectbox("Animação", ["Nenhuma", "Pulsante", "Cor Animada", "Neon", "Ondulada"])
 
         salvar_no_gerenciador = st.checkbox("Salvar no gerenciador de arquivos")
-
-        # ======================== GERAÇÃO DOS VÍDEOS ========================
         if st.button("Gerar Vídeo(s)", key="gerar_video_usuario"):
             with st.spinner("🎬 Processando..."):
                 progresso = st.progress(0)
@@ -112,10 +109,7 @@ if pagina == "🎬 Gerador de Vídeo":
                 try:
                     cortes_names = cortes_files.copy()
                     tutorials_salvos = tutoriais_files.copy()
-
-                    # 🎵 embaralhar músicas antes do loop
                     musicas_salvas = musicas_files.copy()
-                    random.shuffle(musicas_salvas)
 
                     for n in range(num_videos_finais):
                         total_etapas = 6
@@ -124,7 +118,6 @@ if pagina == "🎬 Gerador de Vídeo":
                         cortes_prontos = []
                         cortes_usados = []
 
-                        # configs aleatórias ou fixas
                         if aleatorizar:
                             duracao_corte_min_n = random.randint(1, 5)
                             duracao_corte_max_n = random.randint(duracao_corte_min_n + 1, 8)
@@ -145,10 +138,41 @@ if pagina == "🎬 Gerador de Vídeo":
                             tamanho_borda_n = tamanho_borda
                             ativar_blur_fundo_n = ativar_blur_fundo
                             ativar_espelhar_n = ativar_espelhar
+
+                        # Etapa 1 - Fundo com ponto aleatório
+                        if usar_fundo:
+                            fundo_origem = random.choice(cortes_names)
+                            fundo_convertido = os.path.join(temp_dir, f"fundo_convertido_{n}.mp4")
+                            dur_proc = subprocess.run([
+                                "ffprobe", "-v", "error", "-show_entries", "format=duration",
+                                "-of", "default=noprint_wrappers=1:nokey=1", fundo_origem
+                            ], stdout=subprocess.PIPE)
+                            try:
+                                dur_total = float(dur_proc.stdout.decode().strip())
+                                ponto_inicio = random.uniform(0, max(0, dur_total - duracao_final))
+                            except:
+                                ponto_inicio = 0.0
+
+                            subprocess.run([
+                                "ffmpeg", "-ss", str(ponto_inicio), "-i", fundo_origem,
+                                "-t", str(duracao_final),
+                                "-vf",
+                                "scale='if(gt(iw/ih,720/1280),max(720,iw),-2)':'if(gt(iw/ih,720/1280),-2,max(1280,ih))',"
+                                "scale=720:1280:force_original_aspect_ratio=increase,crop=720:1280,fps=30",
+                                "-preset", "ultrafast", "-crf", "25",
+                                fundo_convertido
+                            ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                        else:
+                            fundo_convertido = os.path.join(temp_dir, f"fundo_vazio_{n}.mp4")
+                            subprocess.run([
+                                "ffmpeg", "-f", "lavfi", "-i", f"color=color=black:size=720x1280:d={duracao_final}:rate=30",
+                                "-c:v", "libx264", "-t", str(duracao_final), "-preset", "ultrafast", "-crf", "25",
+                                fundo_convertido
+                            ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                         etapa_atual += 1
                         atualizar_barra(n, etapa_atual, num_videos_finais, total_etapas)
 
-                        # ======================== ETAPA 2 - Cortes ========================
+                        # Etapa 2 - Cortes
                         tentativas = 0
                         while tempo_total < duracao_final and tentativas < 100:
                             tentativas += 1
@@ -173,7 +197,7 @@ if pagina == "🎬 Gerador de Vídeo":
                                     subprocess.run([
                                         "ffmpeg", "-ss", str(ini), "-i", c, "-t", str(duracao_aleatoria),
                                         "-vf", "scale=trunc(iw/2)*2:trunc(ih/2)*2",
-                                        "-an", "-c:v", "libx264", "-preset", "veryfast", "-crf", str(18), out
+                                        "-an", "-c:v", "libx264", "-preset", "ultrafast", "-crf", "30", out
                                     ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                                     cortes_prontos.append(out)
                                     cortes_usados.append((c, ini, duracao_aleatoria))
@@ -183,10 +207,6 @@ if pagina == "🎬 Gerador de Vídeo":
                                 except:
                                     continue
 
-                        if not cortes_prontos:
-                            st.error("❌ Nenhum corte válido encontrado para gerar o vídeo.")
-                            continue
-
                         lista = os.path.join(temp_dir, f"lista_{n}.txt")
                         with open(lista, "w") as f:
                             for c in cortes_prontos:
@@ -195,12 +215,13 @@ if pagina == "🎬 Gerador de Vídeo":
                         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", "veryfast", "-crf", str(18), video_raw
+                            "-c:v", "libx264", "-preset", "ultrafast", "-crf", "30", video_raw
                         ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
                         etapa_atual += 1
                         atualizar_barra(n, etapa_atual, num_videos_finais, total_etapas)
 
-                        # ======================== ETAPA 3 - Filtros e Efeitos ========================
+                        # Etapa 3 - Filtros e Efeitos
                         filtros_main = ["scale=720:1280:force_original_aspect_ratio=decrease"]
                         if zoom_n != 1.0:
                             filtros_main.append(f"scale=iw*{zoom_n}:ih*{zoom_n}")
@@ -264,35 +285,26 @@ if pagina == "🎬 Gerador de Vídeo":
                             "ffmpeg", "-i", fundo_convertido, "-i", video_raw,
                             "-filter_complex", filtro_complex,
                             "-map", "[final]",
-                            "-c:v", "libx264", "-preset", "veryfast", "-crf", str(18),
+                            "-c:v", "libx264", "-preset", "ultrafast", "-crf", str(crf_value),
                             video_editado
                         ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
                         etapa_atual += 1
                         atualizar_barra(n, etapa_atual, num_videos_finais, total_etapas)
 
-                        # ======================== ETAPA 3.5 - Aceleração ANTES do Tutorial ========================
-                        video_editado_speed = os.path.join(temp_dir, f"video_editado_speed_{n}.mp4")
-                        subprocess.run([
-                            "ffmpeg", "-y", "-i", video_editado, "-an",
-                            "-filter:v", f"setpts=PTS/{velocidade_final_n}",
-                            "-c:v", "libx264", "-preset", "veryfast", "-crf", str(18),
-                            video_editado_speed
-                        ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-
-                        # ======================== ETAPA 4 - Tutorial ========================
+                        # Etapa 4 - Tutorial
                         if usar_tutorial and tutorials_salvos:
                             tutorial_path = random.choice(tutorials_salvos)
                             tutorial_mp4 = os.path.join(temp_dir, f"tutorial_conv_{n}.mp4")
                             subprocess.run([
                                 "ffmpeg", "-i", tutorial_path, "-vf", "scale=720:1280,fps=30",
-                                "-c:v", "libx264", "-preset", "veryfast", "-crf", str(18),
+                                "-c:v", "libx264", "-preset", "ultrafast", "-crf", str(crf_value),
                                 "-y", tutorial_mp4
                             ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
                             dur_proc = subprocess.run([
                                 "ffprobe", "-v", "error", "-show_entries", "format=duration",
-                                "-of", "default=noprint_wrappers=1:nokey=1", video_editado_speed
+                                "-of", "default=noprint_wrappers=1:nokey=1", video_editado
                             ], stdout=subprocess.PIPE)
                             dur_f = float(dur_proc.stdout.decode().strip() or 0)
                             pt = dur_f / 2 if dur_f < 10 else random.uniform(5, dur_f - 5)
@@ -300,11 +312,11 @@ if pagina == "🎬 Gerador de Vídeo":
                             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_editado_speed, "-ss", "0", "-t", str(pt),
-                                            "-c:v", "libx264", "-preset", "veryfast", "-crf", str(18), part1],
+                            subprocess.run(["ffmpeg", "-i", video_editado, "-ss", "0", "-t", str(pt),
+                                            "-c:v", "libx264", "-preset", "ultrafast", part1],
                                            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-                            subprocess.run(["ffmpeg", "-i", video_editado_speed, "-ss", str(pt),
-                                            "-c:v", "libx264", "-preset", "veryfast", "-crf", str(18), part2],
+                            subprocess.run(["ffmpeg", "-i", video_editado, "-ss", str(pt),
+                                            "-c:v", "libx264", "-preset", "ultrafast", part2],
                                            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
                             final_txt = os.path.join(temp_dir, f"final_{n}.txt")
@@ -313,17 +325,25 @@ if pagina == "🎬 Gerador de Vídeo":
 
                             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", "veryfast", "-crf", str(18),
+                                            "-c:v", "libx264", "-preset", "ultrafast", "-crf", str(crf_value),
                                             video_final_raw], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                         else:
-                            video_final_raw = video_editado_speed
+                            video_final_raw = video_editado
                         etapa_atual += 1
                         atualizar_barra(n, etapa_atual, num_videos_finais, total_etapas)
 
-                        # ======================== ETAPA 5 - FINALIZAÇÃO ========================
+                        # Etapa 5 - Velocidade final
+                        video_com_velocidade = os.path.join(temp_dir, f"video_com_velocidade_{n}.mp4")
+                        subprocess.run([
+                            "ffmpeg", "-y", "-i", video_final_raw, "-an",
+                            "-filter:v", f"setpts=PTS/{velocidade_final_n}",
+                            "-c:v", "libx264", "-preset", "ultrafast", "-crf", str(crf_value),
+                            video_com_velocidade
+                        ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
                         dur_final_str = subprocess.run([
                             "ffprobe", "-v", "error", "-show_entries", "format=duration",
-                            "-of", "default=noprint_wrappers=1:nokey=1", video_final_raw
+                            "-of", "default=noprint_wrappers=1:nokey=1", video_com_velocidade
                         ], stdout=subprocess.PIPE).stdout.decode().strip()
                         if not dur_final_str:
                             continue
@@ -331,18 +351,18 @@ if pagina == "🎬 Gerador de Vídeo":
 
                         final_name = f"video_final_{n}_{int(time.time())}.mp4"
                         if usar_musica and musicas_salvas:
-                            musica_path = musicas_salvas[n % len(musicas_salvas)]  # ✅ diferente a cada vídeo
+                            musica_path = random.choice(musicas_salvas)
                             musica_cortada = os.path.join(temp_dir, f"musica_{n}.aac")
                             subprocess.run(["ffmpeg", "-i", musica_path, "-ss", "0", "-t", str(dur_video_real),
                                             "-vn", "-acodec", "aac", "-y", musica_cortada],
                                            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
-                            subprocess.run(["ffmpeg", "-i", video_final_raw, "-i", musica_cortada,
+                            subprocess.run(["ffmpeg", "-i", video_com_velocidade, "-i", musica_cortada,
                                             "-map", "0:v:0", "-map", "1:a:0",
                                             "-c:v", "copy", "-c:a", "aac", "-shortest", final_name],
                                            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
                         else:
-                            shutil.copy(video_final_raw, final_name)
+                            shutil.copy(video_com_velocidade, final_name)
 
                         if salvar_no_gerenciador:
                             destino = os.path.join(BASE_SALVOS, categoria_selecionada, final_name)
@@ -357,6 +377,7 @@ if pagina == "🎬 Gerador de Vídeo":
                     st.error(f"❌ Erro inesperado: {str(e)}")
                 finally:
                     shutil.rmtree(temp_dir)
+
 # ======================== GERENCIADOR ========================
 elif pagina == "📂 Gerenciador de Arquivos":
     st.header("📂 Vídeos Salvos por Categoria")
@@ -434,7 +455,7 @@ elif pagina == "🔐 Admin":
     arquivos = st.file_uploader("Enviar arquivos", accept_multiple_files=True, key=f"{cat}_{tipo}")
 
     if arquivos:
-        with st.spinner("⏳ Salvando arquivos..."):
+        with st.spinner("⏳ Processando e padronizando arquivos..."):
             for f in arquivos:
                 extensao = os.path.splitext(f.name)[1].lower()
                 nome_aleatorio = f"{random.randint(1000000, 9999999)}{extensao}"
@@ -443,9 +464,20 @@ elif pagina == "🔐 Admin":
                     out.write(f.read())
 
                 final = os.path.join(path, nome_aleatorio)
-                shutil.move(temp, final)  # ✅ agora só move, sem padronizar
 
-            st.success("✅ Arquivos enviados e salvos com sucesso!")
+                if tipo != "Músicas":
+                    subprocess.run([
+                        "ffmpeg", "-i", temp,
+                        "-vf", "scale=trunc(iw/2)*2:trunc(ih/2)*2,fps=30",
+                        "-c:v", "libx264", "-preset", "ultrafast", "-crf", "25",
+                        "-y", final
+                    ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                else:
+                    shutil.move(temp, final)
+
+                os.remove(temp)
+
+            st.success("✅ Arquivos enviados, padronizados e renomeados com sucesso!")
 
     st.write("Arquivos existentes:")
     for arq in os.listdir(path):
@@ -455,4 +487,4 @@ elif pagina == "🔐 Admin":
         with col2:
             if st.button("🗑", key=f"{tipo}_{cat}_{arq}"):
                 os.remove(os.path.join(path, arq))
-                st.rerun()
+                st.rerun()