Update app.py

app.py

@@ -186,67 +186,153 @@ if st.button("Gerar Vídeo(s)"):
                 st.error(f"Erro inesperado: {str(e)}")
             finally:
                 shutil.rmtree(temp_dir)
-st.markdown("---")
-st.subheader("🔐 Admin — Enviar cortes para o sistema (opcional)")
-
-# Mesma senha do seu primeiro código: base64 de "admin123"
-SENHA_CODIFICADA = "YWRtaW4xMjM="
-
-if "autenticado_admin" not in st.session_state:
-    st.session_state.autenticado_admin = False
-
-if not st.session_state.autenticado_admin:
-    colA, colB = st.columns([3, 1])
-    with colA:
-        senha_input = st.text_input("Senha do Admin:", type="password", help="Dica: é a mesma do outro app 😉")
-    with colB:
-        if st.button("Entrar"):
-            if base64.b64encode(senha_input.encode()).decode() == SENHA_CODIFICADA:
-                st.session_state.autenticado_admin = True
-                st.success("✅ Acesso liberado!")
-            else:
-                st.error("❌ Senha incorreta.")
-else:
-    st.success("✅ Você está autenticado.")
-
-    cat_admin = st.selectbox("Categoria para salvar os cortes:", CATEGORIAS, key="cat_admin_upload")
-    pasta_admin = os.path.join(BASE_ASSETS, cat_admin, "cortes")
-    st.caption(f"Pasta de destino: `{pasta_admin}`")
-
-    arquivos_admin = st.file_uploader(
-        "Envie os arquivos de CORTES (.mp4) para esta categoria",
-        type=["mp4"], accept_multiple_files=True, key="admin_uploader"
-    )
-
-    if arquivos_admin:
-        with st.spinner("⏳ Processando e padronizando cortes..."):
-            for f in arquivos_admin:
-                ext = os.path.splitext(f.name)[1].lower()
-                nome_aleatorio = f"{random.randint(1000000, 9999999)}{ext}"
-                temp_in = os.path.join(tempfile.gettempdir(), f"adm_input_{nome_aleatorio}")
-                with open(temp_in, "wb") as out:
-                    out.write(f.read())
-
-                final_out = os.path.join(pasta_admin, nome_aleatorio)
-
-                # Padroniza o vídeo (igual ao seu primeiro app)
-                subprocess.run([
-                    "ffmpeg", "-i", temp_in,
-                    "-vf", "scale=trunc(iw/2)*2:trunc(ih/2)*2,fps=30",
-                    "-c:v", "libx264", "-preset", "ultrafast", "-crf", "25",
-                    "-y", final_out
-                ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-
-                os.remove(temp_in)
-
-            st.success("✅ Cortes enviados, padronizados e salvos com sucesso!")
-
-    # Listagem e exclusão
-    st.write("Arquivos existentes nesta categoria:")
-    try:
-        arquivos_existentes = sorted([f for f in os.listdir(pasta_admin) if f.lower().endswith(".mp4")])
-    except FileNotFoundError:
-        arquivos_existentes = []
-
-    if not arquivos_existentes:
-        st.info("Nenhum arquivo encontrado nesta categoria.")
+# Upload dos vídeos (MANTIDO)
+cortes = st.file_uploader("Envie os vídeos de cortes", type=["mp4"], accept_multiple_files=True)
+
+# Configurações (MANTIDO)
+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)
+
+# Min e Max duração dos cortes (MANTIDO)
+duracao_min = st.slider("Duração mínima de cada corte (s)", 1, 30, 3)
+duracao_max = st.slider("Duração máxima de cada corte (s)", 1, 60, 5)
+if duracao_min > duracao_max:
+    st.warning("⚠️ A duração mínima não pode ser maior que a máxima.")
+
+# Corte lateral e zoom (MANTIDO)
+corte_lateral = st.slider("Corte lateral (%)", 0, 50, 0, 5)
+zoom = st.slider("Zoom Central (1.0 = normal)", 1.0, 2.0, 1.0, 0.1)
+
+# Velocidades e qualidade (MANTIDO)
+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, 18)
+
+# Outros (MANTIDO)
+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)
+
+# Botão principal (MANTIDO, mas agora combinando uploads + salvos)
+if st.button("Gerar Vídeo(s)"):
+    # Verifica se temos pelo menos upload OU salvos
+    if not cortes and len(cortes_salvos_paths) == 0:
+        st.error("❌ Envie vídeos OU selecione uma categoria com cortes salvos para continuar.")
+    else:
+        with st.spinner('🎥 Seu vídeo está sendo gerado...'):
+            progresso = st.progress(0)
+            temp_dir = tempfile.mkdtemp()
+
+            try:
+                # === PREPARAR LISTA FINAL DE ARQUIVOS DE CORTE ===
+                cortes_names = []
+
+                # 1) Arquivos enviados (MANTIDO)
+                if cortes:
+                    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)
+
+                # 2) Arquivos salvos na categoria (NOVO – usamos os caminhos diretamente)
+                if len(cortes_salvos_paths) > 0:
+                    cortes_names.extend(cortes_salvos_paths)
+
+                if len(cortes_names) == 0:
+                    st.error("❌ Não há cortes disponíveis após combinar uploads e salvos.")
+                    shutil.rmtree(temp_dir)
+                    st.stop()
+
+                progresso.progress(10)
+
+                for n in range(num_videos_finais):
+                    cortes_prontos = []
+                    random.shuffle(cortes_names)
+                    progresso.progress(10 + 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)
+                                dur_aleatoria = random.uniform(duracao_min, duracao_max)
+                                if d > dur_aleatoria:
+                                    ini = random.uniform(0, d - dur_aleatoria)
+                                    out = os.path.join(temp_dir, f"cut_{n}_{random.randint(1000,9999)}.mp4")
+                                    subprocess.run([
+                                        "ffmpeg", "-ss", str(ini), "-i", c, "-t", str(dur_aleatoria),
+                                        "-an", "-c:v", "libx264", "-preset", "ultrafast", "-crf", "30", out
+                                    ], check=True, stderr=subprocess.PIPE)
+                                    cortes_prontos.append(out)
+                                    tempo_total += dur_aleatoria / 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 corte_lateral > 0:
+                        fator = (100 - corte_lateral) / 100
+                        filtros_main.append(f"crop=iw*{fator}:ih:(iw-iw*{fator})/2:0")
+
+                    if zoom != 1.0:
+                        filtros_main.append(f"scale=iw*{zoom}:ih*{zoom},crop=iw/{zoom}:ih/{zoom}")
+
+                    filtros_main.append(f"setpts=PTS/{velocidade_cortes}")
+                    if ativar_espelhar:
+                        filtros_main.append("hflip")
+                    if ativar_filtro_cor:
+                        filtros_main.append("eq=contrast=1.1:saturation=1.2")
+
+                    filtros_main.append("pad=ceil(iw/2)*2:ceil(ih/2)*2")
+                    filtro_final = ",".join(filtros_main)
+
+                    video_editado = os.path.join(temp_dir, f"video_editado_{n}.mp4")
+                    subprocess.run([
+                        "ffmpeg", "-i", video_raw, "-vf", filtro_final,
+                        "-c:v", "libx264", "-preset", "ultrafast", "-crf", str(crf_value),
+                        video_editado
+                    ], check=True, stderr=subprocess.PIPE)
+
+                    video_final = f"video_final_{n}_{int(time.time())}.mp4"
+                    subprocess.run([
+                        "ffmpeg", "-i", video_editado, "-filter:v", f"setpts=PTS/{velocidade_final}",
+                        "-t", str(duracao_final), "-c:v", "libx264", "-preset", "ultrafast",
+                        "-crf", str(crf_value), "-map_metadata", "-1", "-movflags", "+faststart", 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()}")
+            except Exception as e:
+                st.error(f"Erro inesperado: {str(e)}")
+            finally:
+                shutil.rmtree(temp_dir)