new version

app.py

@@ -4,6 +4,14 @@ import os
 from pathlib import Path
 from video_processor import VideoProcessor
 from audio_processor import AudioProcessor
+from link_processor import LinkDownloader
+
+# Initialize session state for tracking processing status
+if 'processing_complete' not in st.session_state:
+    st.session_state.processing_complete = False
+if 'current_tab' not in st.session_state:
+    st.session_state.current_tab = "URL Processing 🔗"
+
 
 # Utility functions
 def save_uploaded_file(uploaded_file, temp_dir):
@@ -12,124 +20,253 @@ def save_uploaded_file(uploaded_file, temp_dir):
         f.write(uploaded_file.read())
     return file_path
 
+
 def download_file_button(file_path, label, file_name, mime_type):
     with open(file_path, 'rb') as f:
-        st.download_button(
-            label=label,
-            data=f.read(),
-            file_name=file_name,
-            mime=mime_type
-        )
+        if st.download_button(
+                label=label,
+                data=f.read(),
+                file_name=file_name,
+                mime=mime_type
+        ):
+            # Reset the processing state after download
+            st.session_state.processing_complete = False
+            st.rerun()
+
+
+def reset_processing_state():
+    st.session_state.processing_complete = False
+
 
 def process_audio(audio_file):
     with tempfile.TemporaryDirectory() as temp_dir:
-        # Save uploaded file
         input_path = save_uploaded_file(audio_file, temp_dir)
-
-        # Create output directory
         output_dir = Path(temp_dir) / "output"
         output_dir.mkdir(exist_ok=True)
 
         with st.spinner("Processing audio..."):
             try:
                 audio_proc = AudioProcessor(input_path, output_dir)
-
-                # Run Demucs
                 if not audio_proc.run_demucs():
                     raise RuntimeError("Demucs processing failed.")
 
-                # Retrieve processed files
                 vocals_path = audio_proc.get_vocals_path()
                 no_vocals_path = audio_proc.get_no_vocals_path()
 
                 if not vocals_path or not no_vocals_path:
                     raise FileNotFoundError("Processed files not found.")
 
-                # Download buttons
                 col1, col2 = st.columns(2)
-                download_file_button(vocals_path, "Download Vocals", f"vocals_{audio_file.name.rsplit('.', 1)[0]}.wav", "audio/wav")
-               # download_file_button(no_vocals_path, "Download Instrumental", f"instrumental_{audio_file.name.rsplit('.', 1)[0]}.wav", "audio/wav")
+                with col1:
+                    download_file_button(
+                        vocals_path,
+                        "Download Vocals",
+                        f"vocals_{audio_file.name.rsplit('.', 1)[0]}.wav",
+                        "audio/wav"
+                    )
 
                 st.success("Audio processing completed!")
+                st.session_state.processing_complete = True
 
             except Exception as e:
                 st.error(f"An error occurred: {str(e)}")
+                reset_processing_state()
+
 
 def process_video(video_file):
     with tempfile.TemporaryDirectory() as temp_dir:
-        # Save uploaded file
         input_path = save_uploaded_file(video_file, temp_dir)
-
-        # Create output directory
         output_dir = Path(temp_dir) / "output"
         output_dir.mkdir(exist_ok=True)
 
         with st.spinner("Processing video..."):
             try:
-                # Extract audio from video
                 video_proc = VideoProcessor(input_path, output_dir)
                 audio_path = video_proc.extract_audio()
                 if not audio_path:
                     raise RuntimeError("Audio extraction from video failed.")
 
-                # Process extracted audio
                 audio_proc = AudioProcessor(audio_path, output_dir)
                 if not audio_proc.run_demucs():
                     raise RuntimeError("Demucs processing failed.")
 
-                # Retrieve processed audio files
                 vocals_path = audio_proc.get_vocals_path()
                 no_vocals_path = audio_proc.get_no_vocals_path()
                 if not vocals_path or not no_vocals_path:
                     raise FileNotFoundError("Processed audio files not found.")
 
-                # Combine video with vocals
                 final_video_path = video_proc.combine_video_audio(vocals_path)
 
-                # Download buttons
-                col1, col2, col3 = st.columns(3)
+                col1, col2 = st.columns(2)
                 if final_video_path:
-                    download_file_button(final_video_path, "Download Processed Video", f"processed_{video_file.name}", "video/mp4")
-                download_file_button(vocals_path, "Download Vocals", f"vocals_{video_file.name.rsplit('.', 1)[0]}.wav", "audio/wav")
-                #download_file_button(no_vocals_path, "Download Instrumental", f"instrumental_{video_file.name.rsplit('.', 1)[0]}.wav", "audio/wav")
+                    with col1:
+                        download_file_button(
+                            final_video_path,
+                            "Download Processed Video",
+                            f"processed_{video_file.name}",
+                            "video/mp4"
+                        )
+                with col2:
+                    download_file_button(
+                        vocals_path,
+                        "Download Vocals",
+                        f"vocals_{video_file.name.rsplit('.', 1)[0]}.wav",
+                        "audio/wav"
+                    )
 
                 st.success("Video processing completed!")
+                st.session_state.processing_complete = True
 
             except Exception as e:
                 st.error(f"An error occurred: {str(e)}")
+                reset_processing_state()
+
+
+def process_url(url):
+    with tempfile.TemporaryDirectory() as temp_dir:
+        try:
+            output_dir = Path(temp_dir) / "downloaded"
+            output_dir.mkdir(exist_ok=True)
+
+            with st.spinner("Downloading video..."):
+                downloader = LinkDownloader(output_dir)
+                video_path = downloader.download_from_url(url)
+
+                if not video_path:
+                    raise RuntimeError("Video download failed")
+
+            st.info("Processing video...")
+            process_dir = Path(temp_dir) / "output"
+            process_dir.mkdir(exist_ok=True)
+
+            video_proc = VideoProcessor(video_path, process_dir)
+            audio_path = video_proc.extract_audio()
+            if not audio_path:
+                raise RuntimeError("Audio extraction failed")
+
+            st.info("Separating vocals...")
+            audio_proc = AudioProcessor(audio_path, process_dir)
+            if not audio_proc.run_demucs():
+                raise RuntimeError("Demucs processing failed")
+
+            vocals_path = audio_proc.get_vocals_path()
+            no_vocals_path = audio_proc.get_no_vocals_path()
+
+            if not vocals_path or not no_vocals_path:
+                raise FileNotFoundError("Processed audio files not found")
 
-# Streamlit App Layout
+            st.info("Creating final video...")
+            final_video_path = video_proc.combine_video_audio(vocals_path)
+
+            if not final_video_path:
+                raise RuntimeError("Final video creation failed")
+
+            col1, col2 = st.columns(2)
+            if final_video_path:
+                with col1:
+                    download_file_button(
+                        final_video_path,
+                        "Download Processed Video",
+                        "processed_video.mp4",
+                        "video/mp4"
+                    )
+
+            if vocals_path:
+                with col2:
+                    download_file_button(
+                        vocals_path,
+                        "Download Vocals",
+                        "vocals.wav",
+                        "audio/wav"
+                    )
+
+            st.success("Video processing completed!")
+            st.session_state.processing_complete = True
+
+        except Exception as e:
+            st.error(f"An error occurred: {str(e)}")
+            reset_processing_state()
+            raise
+
+
+# Page config
+st.set_page_config(
+    page_title="🎵 Audio/Video Music Separator",
+    page_icon="🎵",
+    layout="wide"
+)
+
+# Main App Layout
 st.title("🎵 Audio/Video Music Separator")
 
 # Tabs for different processing types
-tab1, tab2 = st.tabs(["Audio Processing 🎧", "Video Processing 🎥"])
+tab1, tab2, tab3 = st.tabs(["URL Processing 🔗", "Audio Processing 🎧", "Video Processing 🎥"])
 
 with tab1:
-    st.header("Process Your Audio File")
+    st.header("Process Video from URL")
     with st.expander("Instructions", expanded=True):
         st.markdown("""
-        1. Upload an audio file in MP3, WAV, or OGG format.
-        2. Click the **Process Audio** button.
-        3. Download the separated vocals.
+        1. Paste a video URL from YouTube, Facebook, or other supported platforms
+        2. Click the **Process URL** button
+        3. Download the processed video or vocals
         """)
-    audio_file = st.file_uploader("Upload your audio file", type=['mp3', 'wav', 'ogg'])
-    if audio_file and st.button("Process Audio"):
-        process_audio(audio_file)
+
+    if not st.session_state.processing_complete:
+        url = st.text_input("Enter video URL")
+        if url and st.button("Process URL"):
+            process_url(url)
 
 with tab2:
+    st.header("Process Your Audio File")
+    with st.expander("Instructions", expanded=True):
+        st.markdown("""
+        1. Upload an audio file in MP3, WAV, or OGG format
+        2. Click the **Process Audio** button
+        3. Download the separated vocals
+        """)
+
+    if not st.session_state.processing_complete:
+        audio_file = st.file_uploader("Upload your audio file", type=['mp3', 'wav', 'ogg'])
+        if audio_file and st.button("Process Audio"):
+            process_audio(audio_file)
+
+with tab3:
     st.header("Process Your Video File")
     with st.expander("Instructions", expanded=True):
         st.markdown("""
-        1. Upload a video file in MP4, MKV, or AVI format.
-        2. Click the **Process Video** button.
-        3. Download the processed video or vocals.
+        1. Upload a video file in MP4, MKV, or AVI format
+        2. Click the **Process Video** button
+        3. Download the processed video or vocals
         """)
-    video_file = st.file_uploader("Upload your video file", type=['mp4', 'mkv', 'avi'])
-    if video_file and st.button("Process Video"):
-        process_video(video_file)
+
+    if not st.session_state.processing_complete:
+        video_file = st.file_uploader("Upload your video file", type=['mp4', 'mkv', 'avi'])
+        if video_file and st.button("Process Video"):
+            process_video(video_file)
+
+# Add a reset button when processing is complete
+if st.session_state.processing_complete:
+    if st.button("Process Another File"):
+        reset_processing_state()
+        st.rerun()
+
+# Sidebar
+with st.sidebar:
+    st.header("About")
+    st.markdown("""
+    This app helps you separate vocals from music in your audio and video files.
+
+    ### Features:
+    - Process videos from URLs
+    - Upload and process audio files
+    - Upload and process video files
+    - Extract vocals
+    - Download processed files
+    - Click process another file
+    """)
 
 # Footer
 st.markdown("""
 ---
 Made with ❤️ using [Streamlit](https://streamlit.io)
-""")
+""")

audio_processor.py

@@ -14,6 +14,7 @@ class AudioProcessor:
             subprocess.run([
                 "demucs",
                 "--two-stems=vocals",
+               # "-n", "mdx_extra_q",
                 "-o", str(self.output_dir),
                 str(self.input_audio)
             ], check=True)

link_processor.py

@@ -0,0 +1,47 @@
+from pathlib import Path
+import yt_dlp
+import os
+from concurrent.futures import ThreadPoolExecutor
+import streamlit as st
+
+
+class LinkDownloader:
+    def __init__(self, output_dir):
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        self.executor = ThreadPoolExecutor(max_workers=2)
+
+    def download_from_url(self, url):
+        try:
+            temp_filepath = str(self.output_dir / 'downloaded_video.%(ext)s')
+
+            ydl_opts = {
+                'format': 'best[height<=1080]',
+                'outtmpl': temp_filepath,
+                'quiet': True,
+                'no_warnings': True,
+                'extract_audio': False,
+                'concurrent_fragment_downloads': 3,
+                'file_access_retries': 3,
+                'retries': 3,
+                'socket_timeout': 30,
+                'nocheckcertificate': True,
+            }
+
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                info = ydl.extract_info(url, download=False)
+                ext = info.get('ext', 'mp4')
+
+                # Download in a separate thread
+                future = self.executor.submit(ydl.download, [url])
+                future.result()
+
+                actual_filepath = str(self.output_dir / f"downloaded_video.{ext}")
+                return actual_filepath if os.path.exists(actual_filepath) else None
+
+        except Exception as e:
+            print(f"Download error: {e}")
+            return None
+
+    def __del__(self):
+        self.executor.shutdown(wait=False)

video_processor.py

@@ -1,5 +1,7 @@
 from pathlib import Path
 import subprocess
+import os
+import streamlit as st
 
 class VideoProcessor:
     def __init__(self, input_video, output_dir):
@@ -12,31 +14,112 @@ class VideoProcessor:
     def extract_audio(self):
         """Extract audio from video file"""
         try:
-            subprocess.run([
-                "ffmpeg", "-i", str(self.input_video),
-                "-vn", "-acodec", "pcm_s16le", "-ar", "44100",
+            # First, verify the input video file exists and is readable
+            if not self.input_video.exists():
+                st.error(f"Input video file not found: {self.input_video}")
+                return None
+
+            # Print file size and check if it's not empty
+            file_size = os.path.getsize(self.input_video)
+            print(f"Input video file size: {file_size} bytes")
+            if file_size == 0:
+                st.error("Input video file is empty")
+                return None
+
+            # Construct FFmpeg command with detailed logging
+            command = [
+                "ffmpeg",
+                "-v", "verbose",  # Enable verbose logging
+                "-i", str(self.input_video),
+                "-vn",  # No video
+                "-acodec", "pcm_s16le",
+                "-ar", "44100",
+                "-y",  # Overwrite output file if it exists
                 str(self.temp_audio)
-            ], check=True)
+            ]
+
+            # Run FFmpeg command and capture output
+            process = subprocess.run(
+                command,
+                capture_output=True,
+                text=True,
+                check=False  # Don't raise exception immediately
+            )
+
+            # Print FFmpeg output for debugging
+            print("FFmpeg stdout:", process.stdout)
+            print("FFmpeg stderr:", process.stderr)
+
+            # Check if the command was successful
+            if process.returncode != 0:
+                st.error(f"FFmpeg error: {process.stderr}")
+                return None
+
+            # Verify the output audio file exists and is not empty
+            if not self.temp_audio.exists() or os.path.getsize(self.temp_audio) == 0:
+                st.error("Audio extraction failed: Output file is missing or empty")
+                return None
+
             print(f"Audio extracted successfully to {self.temp_audio}")
             return str(self.temp_audio)
-        except subprocess.CalledProcessError as e:
-            print(f"Error extracting audio: {e}")
+
+        except Exception as e:
+            st.error(f"Error during audio extraction: {str(e)}")
+            print(f"Exception details: {str(e)}")
             return None
 
     def combine_video_audio(self, vocals_path):
         """Combine original video with vocals only"""
         try:
-            subprocess.run([
+            # Verify input files exist
+            if not self.input_video.exists():
+                st.error(f"Original video not found: {self.input_video}")
+                return None
+            if not Path(vocals_path).exists():
+                st.error(f"Vocals audio not found: {vocals_path}")
+                return None
+
+            # Construct FFmpeg command
+            command = [
                 "ffmpeg",
+                "-v", "verbose",  # Enable verbose logging
                 "-i", str(self.input_video),
                 "-i", vocals_path,
-                "-c:v", "copy",
-                "-c:a", "aac",
+                "-c:v", "copy",  # Copy video stream without re-encoding
+                "-c:a", "aac",   # Use AAC codec for audio
+                "-b:a", "192k",  # Set audio bitrate
                 "-map", "0:v:0",
                 "-map", "1:a:0",
+                "-y",  # Overwrite output file if it exists
                 str(self.final_video)
-            ], check=True)
+            ]
+
+            # Run FFmpeg command and capture output
+            process = subprocess.run(
+                command,
+                capture_output=True,
+                text=True,
+                check=False
+            )
+
+            # Print FFmpeg output for debugging
+            print("FFmpeg stdout:", process.stdout)
+            print("FFmpeg stderr:", process.stderr)
+
+            # Check if the command was successful
+            if process.returncode != 0:
+                st.error(f"FFmpeg error during video combination: {process.stderr}")
+                return None
+
+            # Verify the output video file exists and is not empty
+            if not self.final_video.exists() or os.path.getsize(self.final_video) == 0:
+                st.error("Video combination failed: Output file is missing or empty")
+                return None
+
+            print(f"Video combined successfully: {self.final_video}")
             return str(self.final_video)
-        except subprocess.CalledProcessError as e:
-            print(f"Error combining video and audio: {e}")
+
+        except Exception as e:
+            st.error(f"Error during video combination: {str(e)}")
+            print(f"Exception details: {str(e)}")
             return None