add emproved proccess parameter

hybrid_processor.py

@@ -7,14 +7,19 @@ from typing import List, Optional, Tuple
 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
+    from schemas import LayoutType, ShortsStyle
    
     # If background music is requested, need MoviePy
     if bg_music:
         return False
     
+    # If a specific ShortsStyle is requested that requires MoviePy
+    if output_format and isinstance(output_format, ShortsStyle):
+        if output_format in [ShortsStyle.CINEMATIC, ShortsStyle.SPLIT_SCREEN, ShortsStyle.FIT_BARS]:
+            return False
+    
     # If complex layout is requested, need MoviePy
-    if custom_dims and hasattr(custom_dims, 'layout_type') and custom_dims.layout_type != LayoutType.CROP:
+    if custom_dims and hasattr(custom_dims, 'layout_type') and custom_dims.layout_type != LayoutType.CROP_CENTER:
         return False
     
     # If complex custom dimensions, need MoviePy

requirements.txt

@@ -6,4 +6,5 @@ python-multipart
 yt-dlp
 pydantic
 imageio-ffmpeg
-requests
+requests
+scipy

routers/video.py

@@ -9,7 +9,7 @@ import requests
 import subprocess
 import imageio_ffmpeg
 from typing import List, Optional
-from schemas import VideoFormat, Timestamp, ClipRequest, Dimensions
+from schemas import AspectRatio, ShortsStyle, Timestamp, ClipRequest, Dimensions
 from video_processor import process_video_clips, safe_remove, create_zip_archive
 router = APIRouter()
 
@@ -40,7 +40,8 @@ def background_processing(
     task_id: str,
     temp_path: str, 
     timestamps: list, 
-    format: VideoFormat, 
+    aspect_ratio: AspectRatio,
+    style: ShortsStyle, 
     dims: Dimensions, 
     export_audio: bool, 
     audio_path: str = None, 
@@ -50,15 +51,22 @@ def background_processing(
 ):
     """
     Executes the video processing logic. 
-    If webhook_url is provided, sends the result via POST.
     """
     response_data = {}
     files_to_cleanup = [temp_path]
     if audio_path: files_to_cleanup.append(audio_path)
 
     try:
-        # Process clips with FFmpeg optimization enabled
-        clip_paths, audio_clip_paths = process_video_clips(temp_path, timestamps, format, custom_dims=dims, export_audio=export_audio, use_ffmpeg_optimization=True)
+        # Pass both aspect_ratio and style to the processor
+        clip_paths, audio_clip_paths = process_video_clips(
+            temp_path, 
+            timestamps, 
+            aspect_ratio,
+            style,
+            custom_dims=dims, 
+            export_audio=export_audio, 
+            use_ffmpeg_optimization=True
+        )
         
         # Prepare result
         clips_filenames = [os.path.basename(p) for p in clip_paths]
@@ -210,19 +218,20 @@ async def process_video(
     request: Request,
     background_tasks: BackgroundTasks,
     video: UploadFile = File(...),
-    format: VideoFormat = Form(VideoFormat.FILM, description="Select the output video format"),
-    background_music: UploadFile = File(None, description="Upload an audio file for background music (files only, no URLs)"),
+    aspect_ratio: AspectRatio = Form(AspectRatio.RATIO_9_16, description="Select target aspect ratio"),
+    style: ShortsStyle = Form(ShortsStyle.CINEMATIC, 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+)"),
     loop_music: bool = Form(True, description="Loop background music if shorter than video"),
     timestamps_json: str = Form(
         None, 
         alias="timestamps",
-        description='Optional JSON list of timestamps. If not provided, will process entire video. Recommended duration for weak devices: < 60 seconds per clip.'
+        description='Optional JSON list of timestamps.'
     ),
-    export_audio: bool = Form(False, description="Export separate audio files for each clip (original audio). Returns a ZIP if True."),
-    webhook_url: str = Form(None, description="Optional URL to receive processing results via POST."),
-    return_files: bool = Form(False, description="Return processed files directly instead of URLs (for n8n automation)")
+    export_audio: bool = Form(False, description="Export separate audio files"),
+    webhook_url: str = Form(None, description="Optional URL for results"),
+    return_files: bool = Form(False, description="Return processed files directly")
 ):
     task_id = uuid.uuid4().hex[:8]
     temp_path = None
@@ -271,8 +280,8 @@ async def process_video(
         
         # Prepare dimensions
         dims = Dimensions(
-            width=0, 
-            height=0, 
+            target_ratio=aspect_ratio,
+            style=style,
             audio_path=audio_path,
             video_volume=video_volume,
             music_volume=music_volume,
@@ -283,13 +292,13 @@ async def process_video(
         if webhook_url:
             background_tasks.add_task(
                 background_processing,
-                task_id, temp_file_for_processing, timestamps, format, dims, export_audio, audio_path, webhook_url, str(request.base_url)
+                task_id, temp_file_for_processing, timestamps, aspect_ratio, style, dims, export_audio, audio_path, webhook_url, str(request.base_url)
             )
-            return {"status": "processing", "task_id": task_id, "message": "Processing started. Results will be sent to webhook."}
+            return {"status": "processing", "task_id": task_id, "message": "Processing started."}
         else:
             # Synchronous execution
             return background_processing(
-                task_id, temp_file_for_processing, timestamps, format, dims, export_audio, audio_path, None, str(request.base_url)
+                task_id, temp_file_for_processing, timestamps, aspect_ratio, style, dims, export_audio, audio_path, None, str(request.base_url)
             )
 
     except Exception as e:
@@ -370,60 +379,6 @@ async def list_saved_files():
         }
     except Exception as e:
         return JSONResponse(status_code=500, content={"error": f"Failed to list files: {str(e)}"})
-    try:
-        # Get disk usage
-        total, used, free = shutil.disk_usage("/")
-        
-        # Count files in all subfolders
-        total_files_count = 0
-        total_files_size = 0
-        folder_stats = {}
-        
-        folders = {
-            "originals": ORIGINALS_DIR,
-            "processed": PROCESSED_DIR,
-            "audio": AUDIO_DIR,
-            "bgmusic": BG_MUSIC_DIR,
-            "temp": TEMP_DIR
-        }
-        
-        for name, path in folders.items():
-            count = 0
-            size = 0
-            if os.path.exists(path):
-                for filename in os.listdir(path):
-                    f_path = os.path.join(path, filename)
-                    if os.path.isfile(f_path):
-                        count += 1
-                        size += os.path.getsize(f_path)
-            
-            folder_stats[name] = {
-                "count": count,
-                "size_mb": round(size / (1024**2), 2)
-            }
-            total_files_count += count
-            total_files_size += size
-        
-        return {
-            "status": "healthy",
-            "disk_usage": {
-                "total_gb": round(total / (1024**3), 2),
-                "used_gb": round(used / (1024**3), 2),
-                "free_gb": round(free / (1024**3), 2),
-                "usage_percent": round((used / total) * 100, 1)
-            },
-            "temp_files": {
-                "total_count": total_files_count,
-                "total_size_mb": round(total_files_size / (1024**2), 2),
-                "by_folder": folder_stats
-            },
-            "base_directory": BASE_DIR
-        }
-    except Exception as e:
-        return JSONResponse(
-            status_code=500,
-            content={"error": f"Failed to get status: {str(e)}"}
-        )
 
 @router.api_route("/clear", methods=["GET", "POST"], tags=["Video"])
 async def clear_temp_files(
@@ -632,10 +587,11 @@ async def process_saved_video(
     request: Request,
     background_tasks: BackgroundTasks,
     original_filename: str = Form(..., description="اسم الفيديو الأصلي المحفوظ"),
-    format: VideoFormat = Form(VideoFormat.FILM, description="Select the output video format"),
-    timestamps_json: str = Form(None, description='JSON list of timestamps. If not provided, will process entire video.'),
-    export_audio: bool = Form(False, description="Export separate audio files for each clip"),
-    webhook_url: str = Form(None, description="Optional URL to receive processing results via POST.")
+    aspect_ratio: AspectRatio = Form(AspectRatio.RATIO_9_16, description="Select target aspect ratio"),
+    style: ShortsStyle = Form(ShortsStyle.CINEMATIC, description="Select visual style"),
+    timestamps_json: str = Form(None, description='JSON list of timestamps.'),
+    export_audio: bool = Form(False, description="Export separate audio files"),
+    webhook_url: str = Form(None, description="Optional URL for results")
 ):
     """
     معالجة فيديو محفوظ أصلي بدون رفعه تاني - توفير وقت ومساحة
@@ -674,20 +630,27 @@ async def process_saved_video(
             with VideoFileClip(temp_path) as clip:
                 timestamps = [Timestamp(start_time=0, end_time=clip.duration)]
         
-        # Prepare dimensions (بدون موسيقى خلفية)
-        dims = Dimensions(width=0, height=0, audio_path=None, video_volume=1.0, music_volume=0, loop_music=False)
+        # Prepare dimensions
+        dims = Dimensions(
+            target_ratio=aspect_ratio,
+            style=style,
+            audio_path=None,
+            video_volume=1.0,
+            music_volume=0,
+            loop_music=False
+        )
         
         # Dispatch
         if webhook_url:
             background_tasks.add_task(
                 background_processing,
-                task_id, temp_path, timestamps, format, dims, export_audio, None, webhook_url, host_url
+                task_id, temp_path, timestamps, aspect_ratio, style, dims, export_audio, None, webhook_url, host_url
             )
-            return {"status": "processing", "task_id": task_id, "message": "Processing started using saved video. Results will be sent to webhook.", "original_used": original_filename}
+            return {"status": "processing", "task_id": task_id, "message": "Processing started using saved video.", "original_used": original_filename}
         else:
             # Synchronous execution
             return background_processing(
-                task_id, temp_path, timestamps, format, dims, export_audio, None, None, host_url
+                task_id, temp_path, timestamps, aspect_ratio, style, dims, export_audio, None, None, host_url
             )
 
     except Exception as e:
@@ -696,30 +659,4 @@ async def process_saved_video(
         if isinstance(e, HTTPException): raise e
         return JSONResponse(status_code=500, content={"error": str(e)})
 
-@router.get("/list-saved", tags=["Video"])
-async def list_saved_videos():
-    """
-    عرض قائمة الفيديوهات الأصلية المحفوظة
-    """
-    try:
-        saved_videos = []
-        if os.path.exists(ORIGINALS_DIR):
-            for filename in os.listdir(ORIGINALS_DIR):
-                if filename.endswith(('.mp4', '.avi', '.mov', '.mkv')):
-                    file_path = os.path.join(ORIGINALS_DIR, filename)
-                    file_stats = os.stat(file_path)
-                    saved_videos.append({
-                        "filename": filename,
-                        "size_mb": round(file_stats.st_size / (1024*1024), 2),
-                        "created": file_stats.st_ctime,
-                        "full_path": file_path
-                    })
-        
-        return {
-            "status": "success",
-            "count": len(saved_videos),
-            "videos": saved_videos,
-            "originals_directory": ORIGINALS_DIR
-        }
-    except Exception as e:
-        return JSONResponse(status_code=500, content={"error": f"Failed to list videos: {str(e)}"})
+

schemas.py

@@ -5,20 +5,25 @@ from datetime import datetime
 
 # ======== التعدادات الأساسية ========
 
-class VideoFormat(str, Enum):
-    SHORTS = "Shorts (9:16)"
-    VIDEO = "Video (16:9)"
-    SQUARE = "Square (1:1)"
-    CINEMA = "Cinema (21:9)"
-    FILM = "Film (2.35:1)"
-    ORIGINAL = "Original (No Resize)"
-    CUSTOM = "Custom"
-
 class LayoutType(str, Enum):
-    CROP = "crop"                # Current behavior: Crop to fill
-    CINEMATIC = "cinematic"      # Blurred background + Original video
-    SPLIT_SCREEN = "split"       # Two videos stacked
-    FIT = "fit"                  # Fit within canvas with black bars
+    CINEMATIC_BLUR = "cinematic_blur"
+    SPLIT_SCREEN = "split_screen"
+    CROP_CENTER = "crop_center"
+    FIT_CENTER = "fit_center"
+
+class AspectRatio(str, Enum):
+    RATIO_9_16 = "9:16"      # Shorts, TikTok, Reels
+    RATIO_1_1 = "1:1"        # Instagram Square
+    RATIO_16_9 = "16:9"      # Standard YouTube
+    RATIO_4_5 = "4:5"        # Facebook Portrait
+    ORIGINAL = "original"    # Keep source ratio
+
+class ShortsStyle(str, Enum):
+    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"
@@ -40,19 +45,24 @@ class Timestamp(BaseModel):
     end_time: float
 
 class Dimensions(BaseModel):
-    width: int
-    height: int
+    width: Optional[int] = 0
+    height: Optional[int] = 0
+    target_ratio: AspectRatio = AspectRatio.RATIO_9_16
+    style: ShortsStyle = ShortsStyle.CINEMATIC
+    video_scale: float = 1.0
+    vertical_shift: float = 0.0
+    blur_intensity: int = 20
+    background_image_url: Optional[str] = None
     audio_path: Optional[str] = None
     video_volume: float = 1.0
     music_volume: float = 0.2
     loop_music: bool = True
-    layout_type: LayoutType = LayoutType.CROP
-    blur_intensity: int = 20  # For cinematic layout
-    background_video_url: Optional[str] = None  # For split screen
+    background_video_url: Optional[str] = None
 
 class ClipRequest(BaseModel):
     video_url: Optional[str] = None
-    format: VideoFormat = VideoFormat.FILM
+    aspect_ratio: AspectRatio = AspectRatio.RATIO_9_16
+    style: ShortsStyle = ShortsStyle.CINEMATIC
     custom_dimensions: Optional[Dimensions] = None
     timestamps: Optional[List[Timestamp]] = None
 

video_processor.py

@@ -1,13 +1,27 @@
 import os
 import uuid
 from concurrent.futures import ThreadPoolExecutor
-from moviepy import VideoFileClip, vfx, CompositeVideoClip, ColorClip
-from schemas import VideoFormat, Dimensions, LayoutType
+from moviepy import VideoFileClip, CompositeVideoClip, ColorClip
+import numpy as np
+from scipy.ndimage import gaussian_filter
+from schemas import ShortsStyle, Dimensions, LayoutType, AspectRatio
 from hybrid_processor import process_video_hybrid
 
-def process_video_clips(video_path: str, timestamps, output_format: VideoFormat, custom_dims: Dimensions = None, export_audio: bool = False, use_parallel: bool = True, use_ffmpeg_optimization: bool = True):
+def get_canvas_dimensions(ratio: AspectRatio) -> tuple:
+    """Returns (width, height) for a given aspect ratio."""
+    if ratio == AspectRatio.RATIO_9_16:
+        return 1080, 1920
+    elif ratio == AspectRatio.RATIO_1_1:
+        return 1080, 1080
+    elif ratio == AspectRatio.RATIO_16_9:
+        return 1920, 1080
+    elif ratio == AspectRatio.RATIO_4_5:
+        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):
     """
-    Processes a video file into multiple clips based on timestamps and format.
+    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.
     use_parallel: Enable parallel processing for better performance (default: True)
     use_ffmpeg_optimization: Use FFmpeg for simple operations (much faster) (default: True)
@@ -22,7 +36,7 @@ def process_video_clips(video_path: str, timestamps, output_format: VideoFormat,
             clip_paths, audio_paths = process_video_hybrid(
                 video_path=video_path,
                 timestamps=timestamps,
-                output_format=output_format,
+                output_format=style,
                 custom_dims=custom_dims,
                 export_audio=export_audio
             )
@@ -32,15 +46,6 @@ def process_video_clips(video_path: str, timestamps, output_format: VideoFormat,
         except Exception as e:
             print(f"⚠️  FFmpeg optimization failed: {e}")
             print("🎬 Falling back to MoviePy...")
-    
-    # Target aspect ratios
-    ratios = {
-        VideoFormat.SHORTS: 9/16,
-        VideoFormat.VIDEO: 16/9,
-        VideoFormat.SQUARE: 1/1,
-        VideoFormat.CINEMA: 21/9,
-        VideoFormat.FILM: 2.35/1
-    }
 
     try:
         # Load background music if provided
@@ -62,8 +67,8 @@ def process_video_clips(video_path: str, timestamps, output_format: VideoFormat,
                     clip_id = uuid.uuid4().hex[:8]
                     future = executor.submit(
                         process_single_clip, 
-                        ts, video_path, output_format, custom_dims, 
-                        export_audio, bg_music, ratios, clip_id
+                        ts, video_path, aspect_ratio, style, custom_dims, 
+                        export_audio, bg_music, clip_id
                     )
                     futures.append((future, clip_id))
                 
@@ -84,6 +89,10 @@ def process_video_clips(video_path: str, timestamps, output_format: VideoFormat,
             from moviepy import VideoFileClip, CompositeAudioClip
             import moviepy.audio.fx as afx
             
+            # Define processed directory
+            processed_dir = os.path.join("temp_videos", "processed")
+            os.makedirs(processed_dir, exist_ok=True)
+            
             with VideoFileClip(video_path) as video:
                 print(f"DEBUG: Video loaded. Duration: {video.duration}")
                 
@@ -100,7 +109,7 @@ def process_video_clips(video_path: str, timestamps, output_format: VideoFormat,
                     # Generate unique ID for this clip operation
                     clip_id = uuid.uuid4().hex[:8]
                     output_filename = f"clip_{clip_id}.mp4"
-                    output_path = os.path.join(os.path.dirname(video_path), output_filename)
+                    output_path = os.path.join(processed_dir, output_filename)
                     audio_output_path = None
                     
                     # Extract subclip and process it
@@ -136,29 +145,34 @@ def process_video_clips(video_path: str, timestamps, output_format: VideoFormat,
                                 subclip = subclip.with_audio(music_clip)
 
                         # Apply formatting
-                        if output_format == VideoFormat.ORIGINAL:
+                        if style == ShortsStyle.ORIGINAL:
                             pass # Skip resizing, keep original dimensions
                         else:
-                            # Standardize on 1080x1920 for Shorts if format is Shorts
-                            target_w, target_h = 1080, 1920
-                            if output_format == VideoFormat.VIDEO:
-                                target_w, target_h = 1920, 1080
-                            elif output_format == VideoFormat.SQUARE:
-                                target_w, target_h = 1080, 1080
+                            # 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)
                             
-                            layout = custom_dims.layout_type if custom_dims else LayoutType.CROP
-                            subclip = apply_layout_factory(subclip, layout, target_w, target_h, custom_dims)
+                            if target_w and target_h:
+                                subclip = apply_layout_factory(subclip, layout, target_w, target_h, custom_dims)
                         
-                        # Write file - optimized settings for speed
+                        # Write file - optimized settings for compatibility and speed
                         subclip.write_videofile(
                             output_path, 
                             codec="libx264", 
                             audio_codec="aac",
-                            temp_audiofile=f"temp-audio-{clip_id}.m4a",
+                            temp_audiofile=f"temp-audio-{clip_id}.m4a", # m4a is native for aac
                             remove_temp=True,
                             fps=24,
                             threads=4,
-                            preset="ultrafast",   # Fastest encoding
+                            preset="superfast", # Faster than medium, safer than ultrafast
                             logger=None
                         )
                     
@@ -167,8 +181,8 @@ def process_video_clips(video_path: str, timestamps, output_format: VideoFormat,
                         if export_audio:
                             audio_paths.append(audio_output_path)
         
-        if bg_music: bg_music.close()
-        return clip_paths, audio_paths
+            if bg_music: bg_music.close()
+            return clip_paths, audio_paths
 
     except Exception as e:
         print(f"Error processing video: {str(e)}")
@@ -178,28 +192,57 @@ def apply_layout_factory(clip, layout_type, target_w, target_h, config=None):
     """
     Factory to apply different video layouts.
     """
-    if layout_type == LayoutType.CINEMATIC:
-        return apply_cinematic_blur(clip, target_w, target_h, config.blur_intensity if config else 20)
-    elif layout_type == LayoutType.FIT:
+    if layout_type == LayoutType.CINEMATIC_BLUR:
+        return apply_cinematic_blur(clip, target_w, target_h, config.blur_intensity if config and hasattr(config, 'blur_intensity') else 20)
+    elif layout_type == LayoutType.FIT_CENTER:
         return apply_fit_layout(clip, target_w, target_h)
-    else:
+    elif layout_type == LayoutType.CROP_CENTER:
         # Default to Crop/Fill
         target_ratio = target_w / target_h
         formatted = format_clip(clip, target_ratio)
         return formatted.resized(width=target_w, height=target_h)
+    elif layout_type == LayoutType.SPLIT_SCREEN:
+        return apply_split_screen(clip, target_w, target_h)
+    else:
+        # Fallback
+        return clip.resized(width=target_w) if clip.w > target_w else clip
+
+def apply_split_screen(clip, target_w, target_h):
+    """
+    Splits the screen into two halves (top and bottom) with the same video.
+    """
+    half_h = target_h // 2
+    
+    # Top half: resize to fill
+    top = format_clip(clip, target_w / half_h).resized(width=target_w, height=half_h)
+    
+    # Bottom half: same video
+    bottom = format_clip(clip, target_w / half_h).resized(width=target_w, height=half_h)
+    
+    return CompositeVideoClip([
+        top.with_position(("center", "top")),
+        bottom.with_position(("center", "bottom"))
+    ], size=(target_w, target_h))
 
 def apply_cinematic_blur(clip, target_w, target_h, blur_intensity=20):
     """
     Creates a cinematic blurred background with the original video on top.
+    Uses custom fl_image filter for maximum compatibility.
     """
+    def blur_filter(image):
+        # Apply gaussian filter to the RGB channels (axis 0 and 1)
+        # Sigma is the blur intensity. 
+        # We use (blur_intensity, blur_intensity, 0) to not blur the color channel axis.
+        return gaussian_filter(image, sigma=(blur_intensity, blur_intensity, 0))
+
     # 1. Background: Scale to fill and blur
-    # First, crop/resize to fill target dimensions
     bg = format_clip(clip, target_w / target_h)
     bg = bg.resized(width=target_w, height=target_h)
-    bg = bg.with_effects([vfx.GaussianBlur(blur_intensity)])
+    
+    # Apply our custom blur filter
+    bg = bg.image_transform(blur_filter)
     
     # 2. Foreground: Resize original to fit width while keeping aspect ratio
-    # If original is 16:9, it will have bars top/bottom over the blur
     fg = clip.resized(width=target_w)
     
     # Center the foreground on the background
@@ -295,7 +338,7 @@ def create_zip_archive(file_paths: list, output_filename: str):
                 
     return zip_path
 
-def process_single_clip(ts, video_path, output_format, custom_dims, export_audio, bg_music, ratios, clip_id):
+def process_single_clip(ts, video_path, style, custom_dims, export_audio, bg_music, clip_id):
     """
     Process a single clip - for parallel processing.
     """
@@ -354,15 +397,11 @@ def process_single_clip(ts, video_path, output_format, custom_dims, export_audio
                     subclip = subclip.with_audio(music_clip)
 
             # Apply formatting
-            if output_format == VideoFormat.ORIGINAL:
+            if style == ShortsStyle.ORIGINAL:
                 pass # Skip resizing, keep original dimensions
             else:
-                # Standardize on 1080x1920 for Shorts if format is Shorts
+                # Standardize on 1080x1920 for Shorts styles
                 target_w, target_h = 1080, 1920
-                if output_format == VideoFormat.VIDEO:
-                    target_w, target_h = 1920, 1080
-                elif output_format == VideoFormat.SQUARE:
-                    target_w, target_h = 1080, 1080
                 
                 layout = custom_dims.layout_type if custom_dims else LayoutType.CROP
                 subclip = apply_layout_factory(subclip, layout, target_w, target_h, custom_dims)
@@ -376,7 +415,7 @@ def process_single_clip(ts, video_path, output_format, custom_dims, export_audio
                 remove_temp=True,
                 fps=24,
                 threads=4,
-                preset="ultrafast",   # Fastest encoding
+                preset="superfast",   # Safer than ultrafast
                 logger=None
             )