fix pgmusic with ffmgep

ffmpeg_utils.py

@@ -124,7 +124,11 @@ def extract_clip_ffmpeg(
     target_height: Optional[int] = None,
     include_audio: bool = True,
     style: Optional[ShortsStyle] = None,
-    aspect_ratio: Optional[AspectRatio] = None
+    aspect_ratio: Optional[AspectRatio] = None,
+    bg_music_path: Optional[str] = None,
+    video_volume: float = 1.0,
+    music_volume: float = 0.2,
+    loop_music: bool = True
 ) -> str:
     """
     Extract video clip using FFmpeg - high speed with advanced filters
@@ -133,9 +137,19 @@ def extract_clip_ffmpeg(
         duration = end_time - start_time
         ffmpeg_exe = imageio_ffmpeg.get_ffmpeg_exe()
         
+        # Get video info to check for audio stream
+        video_info = get_video_info_ffmpeg(video_path)
+        has_orig_audio = video_info.get('has_audio', False) if video_info else False
+        
         # Build FFmpeg command
-        # -ss AFTER -i is slightly slower but MUCH more accurate for audio mapping and sync
-        cmd = [ffmpeg_exe, '-i', video_path, '-ss', str(start_time), '-t', str(duration)]
+        inputs = ['-i', video_path]
+        if bg_music_path and os.path.exists(bg_music_path):
+            if loop_music:
+                inputs.extend(['-stream_loop', '-1', '-i', bg_music_path])
+            else:
+                inputs.extend(['-i', bg_music_path])
+        
+        cmd = [ffmpeg_exe] + inputs + ['-ss', str(start_time), '-t', str(duration)]
         
         # Resolution defaults for Shorts if not provided
         if not target_width or not target_height:
@@ -143,13 +157,17 @@ def extract_clip_ffmpeg(
             
         filter_complex = ""
         
-        if style == ShortsStyle.CINEMATIC:
+        if aspect_ratio == AspectRatio.ORIGINAL or style == ShortsStyle.ORIGINAL:
+            # No filters, just copy/passthrough
+            filter_complex = ""
+        elif style == ShortsStyle.CINEMATIC:
             # Cinematic Blur: BG (Blurred & Cropped) + FG (Scaled to fit width)
+            # Use -2 to ensure height is divisible by 2 for yuv420p
             filter_complex = (
                 f"[0:v]split=2[bg_raw][fg_raw];"
-                f"[bg_raw]scale={target_width}:{target_height}:force_original_aspect_ratio=increase,crop={target_width}:{target_height},boxblur=20:10[bg];"
-                f"[fg_raw]scale={target_width}:-1[fg];"
-                f"[bg][fg]overlay=(W-w)/2:(H-h)/2[v]"
+                f"[bg_raw]scale={target_width}:{target_height}:force_original_aspect_ratio=increase,crop={target_width}:{target_height},boxblur=20:2[bg];"
+                f"[fg_raw]scale={target_width}:-2,setsar=1[fg];"
+                f"[bg][fg]overlay=(W-w)/2:(H-h)/2,setsar=1[v]"
             )
         elif style == ShortsStyle.SPLIT_SCREEN:
             # Split Screen: Top half and Bottom half
@@ -166,22 +184,42 @@ def extract_clip_ffmpeg(
         elif style == ShortsStyle.FIT_BARS:
             # Fit with black bars
             filter_complex = f"scale={target_width}:{target_height}:force_original_aspect_ratio=decrease,pad={target_width}:{target_height}:(ow-iw)/2:(oh-ih)/2"
+        elif aspect_ratio != AspectRatio.ORIGINAL:
+            # Default for non-original ratios: Scale to fit width
+            # Use -2 to ensure dimensions are divisible by 2 for yuv420p
+            filter_complex = f"scale={target_width}:-2,pad={target_width}:{target_height}:(ow-iw)/2:(oh-ih)/2,setsar=1[v]"
         else:
-            # Default: Scale to fit width
-            filter_complex = f"scale={target_width}:-1,pad={target_width}:{target_height}:(ow-iw)/2:(oh-ih)/2"
+            filter_complex = ""
+
+        # Audio Filter logic
+        audio_filter = ""
+        if include_audio:
+            if bg_music_path and os.path.exists(bg_music_path):
+                if has_orig_audio:
+                    # Mix original audio with background music
+                    # Use unique names [a_orig] [a_bg] to avoid collisions with [v]
+                    audio_filter = f"[0:a]volume={video_volume}[a_orig];[1:a]volume={music_volume}[a_bg];[a_orig][a_bg]amix=inputs=2:duration=first[aout]"
+                else:
+                    # Only background music (original has no audio)
+                    audio_filter = f"[1:a]volume={music_volume}[aout]"
+            elif has_orig_audio and video_volume != 1.0:
+                audio_filter = f"[0:a]volume={video_volume}[aout]"
 
         if filter_complex:
-            if "[v]" in filter_complex:
-                # When using complex filters, we MUST map video and audio explicitly
+            # If [v] is not the final tag, ensure it is
+            if "[v]" not in filter_complex:
+                filter_complex += "[v]"
+                
+            if audio_filter:
+                combined_filter = f"{filter_complex};{audio_filter}"
+                cmd.extend(['-filter_complex', combined_filter, '-map', '[v]', '-map', '[aout]'])
+            else:
                 cmd.extend(['-filter_complex', filter_complex, '-map', '[v]'])
                 if include_audio:
-                    # Always try to map audio if it exists
                     cmd.extend(['-map', '0:a?'])
-            else:
-                # For simple filters
-                cmd.extend(['-vf', filter_complex])
-                if include_audio:
-                    cmd.extend(['-map', '0:v:0', '-map', '0:a?'])
+        elif audio_filter:
+            # Only audio filter
+            cmd.extend(['-filter_complex', audio_filter, '-map', '0:v:0', '-map', '[aout]'])
         
         if not include_audio:
             cmd.extend(['-an'])

hybrid_processor.py

@@ -8,22 +8,8 @@ from typing import List, Optional, Tuple, Any
 from ffmpeg_utils import extract_clip_ffmpeg, get_video_info_ffmpeg
 
 def should_use_ffmpeg_processing(timestamps, custom_dims, export_audio, bg_music, output_format) -> bool:
-    from schemas import LayoutType, ShortsStyle
-   
-    # If background music is requested, need MoviePy for audio mixing
-    if bg_music:
-        return False
-    
-    # We can now handle almost all ShortsStyle in FFmpeg!
-    # These styles are now optimized in ffmpeg_utils.py
-    if output_format and isinstance(output_format, ShortsStyle):
-        return True
-    
-    # If a specific LayoutType is requested
-    if custom_dims and hasattr(custom_dims, 'layout_type'):
-        return True
-    
-    # Default fallback
+    # FFmpeg can now handle background music mixing and all ShortsStyle!
+    # Default to True to use FFmpeg optimization for most cases
     return True
 
 def process_single_clip_hybrid(video_path: str, start_time: float, end_time: float, clip_id: str,
@@ -59,7 +45,11 @@ def process_single_clip_hybrid(video_path: str, start_time: float, end_time: flo
                 target_height=custom_dims.height if hasattr(custom_dims, 'height') else None,
                 include_audio=True, # Video should always have audio if it exists
                 style=style,
-                aspect_ratio=aspect_ratio
+                aspect_ratio=aspect_ratio,
+                bg_music_path=bg_music,
+                video_volume=custom_dims.video_volume if hasattr(custom_dims, 'video_volume') else 1.0,
+                music_volume=custom_dims.music_volume if hasattr(custom_dims, 'music_volume') else 0.2,
+                loop_music=custom_dims.loop_music if hasattr(custom_dims, 'loop_music') else True
             )
         else:
             # Use MoviePy for features (fallback)

routers/video.py

@@ -219,7 +219,7 @@ async def process_video(
     background_tasks: BackgroundTasks,
     video: UploadFile = File(...),
     aspect_ratio: AspectRatio = Form(AspectRatio.RATIO_9_16, description="Select target aspect ratio"),
-    style: ShortsStyle = Form(ShortsStyle.CINEMATIC, description="Select the visual style"),
+    style: ShortsStyle = Form(ShortsStyle.ORIGINAL, description="Select the visual style"),
     background_music: UploadFile = File(None, description="Upload an audio file for background music"),
     video_volume: float = Form(1.0, description="Volume of original video (0.0 to 1.0+)"),
     music_volume: float = Form(0.2, description="Volume of background music (0.0 to 1.0+)"),

schemas.py

@@ -19,11 +19,11 @@ class AspectRatio(str, Enum):
     ORIGINAL = "original"    # Keep source ratio
 
 class ShortsStyle(str, Enum):
+    ORIGINAL = "original"        # Keep original style
     CINEMATIC = "cinematic"      # Blurred background
     CROP_FILL = "crop_fill"      # Crop to fill target ratio
     SPLIT_SCREEN = "split"       # Split screen
     FIT_BARS = "fit_bars"        # Letterboxing
-    ORIGINAL = "original"        # No changes
 
 class ProcessingType(str, Enum):
     TRANSCRIPT = "transcript"
@@ -48,7 +48,7 @@ class Dimensions(BaseModel):
     width: Optional[int] = 0
     height: Optional[int] = 0
     target_ratio: AspectRatio = AspectRatio.RATIO_9_16
-    style: ShortsStyle = ShortsStyle.CINEMATIC
+    style: ShortsStyle = ShortsStyle.ORIGINAL
     video_scale: float = 1.0
     vertical_shift: float = 0.0
     blur_intensity: int = 20
@@ -62,7 +62,10 @@ class Dimensions(BaseModel):
 class ClipRequest(BaseModel):
     video_url: Optional[str] = None
     aspect_ratio: AspectRatio = AspectRatio.RATIO_9_16
-    style: ShortsStyle = ShortsStyle.CINEMATIC
+    style: ShortsStyle = ShortsStyle.ORIGINAL
+    video_volume: float = 1.0
+    music_volume: float = 0.2
+    loop_music: bool = True
     custom_dimensions: Optional[Dimensions] = None
     timestamps: Optional[List[Timestamp]] = None
 

video_processor.py

@@ -19,7 +19,7 @@ def get_canvas_dimensions(ratio: AspectRatio) -> tuple:
         return 1080, 1350
     return None, None # For ORIGINAL
 
-def process_video_clips(video_path: str, timestamps, aspect_ratio: AspectRatio = AspectRatio.RATIO_9_16, style: ShortsStyle = ShortsStyle.CINEMATIC, custom_dims: Dimensions = None, export_audio: bool = False, use_parallel: bool = True, use_ffmpeg_optimization: bool = True):
+def process_video_clips(video_path: str, timestamps, aspect_ratio: AspectRatio = AspectRatio.RATIO_9_16, style: ShortsStyle = ShortsStyle.ORIGINAL, custom_dims: Dimensions = None, export_audio: bool = False, use_parallel: bool = True, use_ffmpeg_optimization: bool = True, video_volume: float = 1.0, music_volume: float = 0.2, loop_music: bool = True):
     """
     Processes a video file into multiple clips based on timestamps and style.
     If export_audio is True, also saves the original audio track of each clip.
@@ -29,6 +29,18 @@ def process_video_clips(video_path: str, timestamps, aspect_ratio: AspectRatio =
     clip_paths = []
     audio_paths = []
     
+    # Extract background music path if available
+    bg_music_path = None
+    if custom_dims and hasattr(custom_dims, 'audio_path') and custom_dims.audio_path:
+        if os.path.exists(custom_dims.audio_path):
+            bg_music_path = custom_dims.audio_path
+            
+    # Ensure custom_dims has the volume info for hybrid processing
+    if custom_dims:
+        custom_dims.video_volume = video_volume
+        custom_dims.music_volume = music_volume
+        custom_dims.loop_music = loop_music
+
     # Try FFmpeg optimization first for simple cases
     if use_ffmpeg_optimization:
         try:
@@ -39,7 +51,8 @@ def process_video_clips(video_path: str, timestamps, aspect_ratio: AspectRatio =
                 output_format=style,
                 custom_dims=custom_dims,
                 export_audio=export_audio,
-                aspect_ratio=aspect_ratio
+                aspect_ratio=aspect_ratio,
+                bg_music=bg_music_path
             )
             if clip_paths:  # If FFmpeg worked, return results
                 print(f"✅ FFmpeg optimization successful! Processed {len(clip_paths)} clips")
@@ -49,13 +62,12 @@ def process_video_clips(video_path: str, timestamps, aspect_ratio: AspectRatio =
             print("🎬 Falling back to MoviePy...")
 
     try:
-        # Load background music if provided
+        # Load background music if provided for MoviePy fallback
         bg_music = None
-        if custom_dims and hasattr(custom_dims, 'audio_path') and custom_dims.audio_path:
+        if bg_music_path:
              from moviepy import AudioFileClip, CompositeAudioClip
              import moviepy.audio.fx as afx
-             if os.path.exists(custom_dims.audio_path):
-                 bg_music = AudioFileClip(custom_dims.audio_path)
+             bg_music = AudioFileClip(bg_music_path)
 
         if use_parallel and len(timestamps) > 1:
             # Process clips in parallel for better performance
@@ -69,7 +81,10 @@ def process_video_clips(video_path: str, timestamps, aspect_ratio: AspectRatio =
                     future = executor.submit(
                         process_single_clip, 
                         ts, video_path, aspect_ratio, style, custom_dims, 
-                        export_audio, bg_music, clip_id
+                        export_audio, bg_music, clip_id,
+                        video_volume=video_volume,
+                        music_volume=music_volume,
+                        loop_music=loop_music
                     )
                     futures.append((future, clip_id))
                 
@@ -114,14 +129,40 @@ def process_video_clips(video_path: str, timestamps, aspect_ratio: AspectRatio =
                     
                     # Extract subclip and process it
                     with video.subclipped(ts.start_time, end) as subclip:
-                        # (Removed automatic audio extraction to mp3)
-                        
                         # Apply background music if available
                         if bg_music:
-                            # ... (existing code)
-                            pass
+                            # Setup background music
+                            bg_music_clip = bg_music.with_duration(subclip.duration)
+                            if loop_music:
+                                bg_music_clip = bg_music_clip.fx(afx.AudioLoop, duration=subclip.duration)
+                            
+                            # Apply volumes
+                            if subclip.audio:
+                                original_audio = subclip.audio.with_volume_scaled(video_volume)
+                                bg_music_clip = bg_music_clip.with_volume_scaled(music_volume)
+                                # Combine audio
+                                subclip.audio = CompositeAudioClip([original_audio, bg_music_clip])
+                            else:
+                                subclip.audio = bg_music_clip.with_volume_scaled(music_volume)
 
-                        # ... (existing code)
+                        # Apply formatting
+                        if aspect_ratio == AspectRatio.ORIGINAL or style == ShortsStyle.ORIGINAL:
+                            pass # Skip resizing, keep original dimensions
+                        else:
+                            # Map style to layout
+                            layout_map = {
+                                ShortsStyle.CINEMATIC: LayoutType.CINEMATIC_BLUR,
+                                ShortsStyle.CROP_FILL: LayoutType.CROP_CENTER,
+                                ShortsStyle.FIT_BARS: LayoutType.FIT_CENTER,
+                                ShortsStyle.SPLIT_SCREEN: LayoutType.SPLIT_SCREEN
+                            }
+                            layout = layout_map.get(style, LayoutType.CROP_CENTER)
+                            
+                            # Get target dimensions
+                            target_w, target_h = get_canvas_dimensions(aspect_ratio)
+                            
+                            if target_w and target_h:
+                                subclip = apply_layout_factory(subclip, layout, target_w, target_h, custom_dims)
                         
                         # Write file - optimized settings for compatibility and speed
                         temp_audio = os.path.join(TEMP_DIR, f"temp-audio-{clip_id}.m4a")
@@ -299,13 +340,23 @@ def create_zip_archive(file_paths: list, output_filename: str):
                 
     return zip_path
 
-def process_single_clip(ts, video_path, style, custom_dims, export_audio, bg_music, clip_id):
+def process_single_clip(ts, video_path, aspect_ratio, style, custom_dims, export_audio, bg_music, clip_id, video_volume=1.0, music_volume=0.2, loop_music=True):
     """
     Process a single clip - for parallel processing.
     """
     try:
+        # Ensure custom_dims has the volume info
+        if not custom_dims:
+            from schemas import Dimensions
+            custom_dims = Dimensions()
+        
+        custom_dims.video_volume = video_volume
+        custom_dims.music_volume = music_volume
+        custom_dims.loop_music = loop_music
+
         from moviepy import VideoFileClip, CompositeAudioClip
         import moviepy.audio.fx as afx
+        from schemas import AspectRatio, ShortsStyle, LayoutType
         
         # Open video for this clip (parallel processing)
         with VideoFileClip(video_path) as video:
@@ -330,7 +381,41 @@ def process_single_clip(ts, video_path, style, custom_dims, export_audio, bg_mus
             # (Removed automatic audio extraction to mp3)
             audio_output_path = None
             
-            # ... (existing music code)
+            # Apply background music if available
+            if bg_music:
+                from moviepy import CompositeAudioClip
+                import moviepy.audio.fx as afx
+                
+                # Setup background music
+                bg_music_clip = bg_music.with_duration(subclip.duration)
+                if loop_music:
+                    bg_music_clip = bg_music_clip.fx(afx.AudioLoop, duration=subclip.duration)
+                
+                # Apply volumes
+                original_audio = subclip.audio.with_volume_scaled(video_volume)
+                bg_music_clip = bg_music_clip.with_volume_scaled(music_volume)
+                
+                # Combine audio
+                subclip.audio = CompositeAudioClip([original_audio, bg_music_clip])
+
+            # Apply formatting
+            if aspect_ratio == AspectRatio.ORIGINAL or style == ShortsStyle.ORIGINAL:
+                pass # Skip resizing, keep original dimensions
+            else:
+                # Map style to layout
+                layout_map = {
+                    ShortsStyle.CINEMATIC: LayoutType.CINEMATIC_BLUR,
+                    ShortsStyle.CROP_FILL: LayoutType.CROP_CENTER,
+                    ShortsStyle.FIT_BARS: LayoutType.FIT_CENTER,
+                    ShortsStyle.SPLIT_SCREEN: LayoutType.SPLIT_SCREEN
+                }
+                layout = layout_map.get(style, LayoutType.CROP_CENTER)
+                
+                # Get target dimensions
+                target_w, target_h = get_canvas_dimensions(aspect_ratio)
+                
+                if target_w and target_h:
+                    subclip = apply_layout_factory(subclip, layout, target_w, target_h, custom_dims)
             
             # Write file - optimized settings for speed
             temp_audio = os.path.join(TEMP_DIR, f"temp-audio-{clip_id}.m4a")
@@ -359,21 +444,15 @@ def process_single_clip(ts, video_path, style, custom_dims, export_audio, bg_mus
 def extract_audio_from_video(video_path: str, output_format: str = "mp3"):
     """
     Extract audio from a video file and save it as an audio file.
-    
-    Args:
-        video_path: Path to the input video file
-        output_format: Output audio format (mp3, wav, etc.)
-    
-    Returns:
-        Path to the extracted audio file
     """
     try:
+        from routers.video import AUDIO_DIR
         # Generate output filename
         base_name = os.path.splitext(os.path.basename(video_path))[0]
         audio_filename = f"{base_name}_audio.{output_format}"
-        output_path = os.path.join(os.path.dirname(video_path), audio_filename)
+        output_path = os.path.join(AUDIO_DIR, audio_filename)
         
-        # Try FFmpeg first (fastest method) - use imageio_ffmpeg path
+        # Try FFmpeg first (fastest method)
         try:
             import subprocess
             import imageio_ffmpeg