Upload 2 files

app (5).py

@@ -0,0 +1,331 @@
+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, 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")
+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)
+
+# 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:
+                    # 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)
+
+                # 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 para 1280x720
+                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",
+                        "-c:v", "libx264", "-preset", "ultrafast", "-crf", "30", path_out
+                    ], check=True, stderr=subprocess.PIPE)
+                    cortes_names.append(path_out)
+
+                # ✅ 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),
+                    "-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")
+                                    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
+
+                    # 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,
+                        "-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
+                    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")
+                    # Borda personalizada
+                    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)
+
+                    # 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")
+
+                        # Corte com precisão (ss depois do -i)
+                        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:
+                        # 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)
+
+                    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)

requirements.txt

@@ -0,0 +1,2 @@
+streamlit
+ffmpeg-python