Fixes #33

Author: piemonte

README.md

@@ -11,6 +11,7 @@ The library provides customizable audio and video encoding options unlike `AVAss
 
 - **🚀 Modern Async/Await API** - Native Swift concurrency support with `async/await` and `AsyncSequence`
 - **🌈 HDR Video Support** - Automatic detection and preservation of HLG and HDR10 content with 10-bit HEVC
+- **📐 Scaling Mode Fixes** - AVVideoScalingModeKey now works correctly for aspect-fill and resize (#33)
 - **⚡ Better Performance** - Proper memory management with autoreleasepool in encoding loop
 - **🎯 QoS Configuration** - Control export priority to prevent thread priority inversion (PR #44)
 - **🔒 Swift 6 Strict Concurrency** - Full `Sendable` conformance and thread-safety
@@ -242,6 +243,47 @@ exporter.videoOutputConfiguration = [
 ]
 ```
 
+#### Video Scaling Modes
+
+Control how videos are scaled to target dimensions using `AVVideoScalingModeKey` ([Fixed in 1.0.1 - Issue #33](https://github.com/NextLevel/NextLevelSessionExporter/issues/33)):
+
+```swift
+exporter.videoOutputConfiguration = [
+    AVVideoCodecKey: AVVideoCodecType.h264,
+    AVVideoWidthKey: 720,
+    AVVideoHeightKey: 1280,
+    AVVideoScalingModeKey: AVVideoScalingModeResizeAspectFill  // Choose your scaling mode
+]
+```
+
+**Available Scaling Modes:**
+
+- **`AVVideoScalingModeResizeAspectFill`** (Recommended)
+  - Scales video to fill the target dimensions while maintaining aspect ratio
+  - May crop content to fill the entire frame
+  - Ideal for converting landscape → portrait or vice versa
+
+- **`AVVideoScalingModeResize`**
+  - Stretches video to exact target dimensions
+  - Does not maintain aspect ratio
+  - Use when you want non-uniform scaling
+
+- **`AVVideoScalingModeResizeAspect`** (Default if not specified)
+  - Fits entire video within target dimensions while maintaining aspect ratio
+  - May add letterboxing/pillarboxing (black bars)
+  - Legacy behavior for backward compatibility
+
+**Example: Landscape → Portrait Conversion**
+```swift
+// Convert 1920x1080 landscape video to 720x1280 portrait
+exporter.videoOutputConfiguration = [
+    AVVideoCodecKey: AVVideoCodecType.h264,
+    AVVideoWidthKey: 720,
+    AVVideoHeightKey: 1280,
+    AVVideoScalingModeKey: AVVideoScalingModeResizeAspectFill  // Crops sides, fills frame
+]
+```
+
 ### Custom Audio Encoding
 
 Fine-tune audio settings for optimal file size and quality:
@@ -599,12 +641,20 @@ let exporter = NextLevelSessionExporter(withAsset: asset)
 - Avoid frame-by-frame processing if not needed
 - Test on a physical device (simulator performance varies)
 
-### Video Orientation is Wrong
+### Video Orientation or Scaling Issues
 
 The library automatically handles video orientation and transforms. If you're experiencing issues:
+
+**Orientation Problems:**
 - Let the library create the video composition automatically (don't set `videoComposition`)
 - Ensure your video output configuration includes proper width/height
 
+**Scaling Not Working (Fixed in 1.0.1):**
+- If video doesn't fill the target dimensions as expected, use `AVVideoScalingModeKey`
+- See the [Video Scaling Modes](#video-scaling-modes) section for details
+- Common issue: landscape → portrait conversion with black bars
+  - Solution: Use `AVVideoScalingModeResizeAspectFill`
+
 ### Audio Track Missing
 
 **Issue:** Some videos export without audio.

Sources/NextLevelSessionExporter.swift

@@ -787,23 +787,59 @@ extension NextLevelSessionExporter {
                     naturalSize.width = naturalSize.height
                     naturalSize.height = tempWidth
                 }
-                videoComposition.renderSize = naturalSize
 
-                // center the video
+                // Check if user specified a scaling mode (Issue #33)
+                let scalingMode = videoConfiguration[AVVideoScalingModeKey] as? String
 
-                var ratio: CGFloat = 0
-                let xRatio: CGFloat = targetSize.width / naturalSize.width
-                let yRatio: CGFloat = targetSize.height / naturalSize.height
-                ratio = min(xRatio, yRatio)
+                if scalingMode == AVVideoScalingModeResizeAspectFill || scalingMode == AVVideoScalingModeResize {
+                    // User wants aspect-fill or resize - respect their choice
+                    videoComposition.renderSize = targetSize
 
-                let postWidth = naturalSize.width * ratio
-                let postHeight = naturalSize.height * ratio
-                let transX = (targetSize.width - postWidth) * 0.5
-                let transY = (targetSize.height - postHeight) * 0.5
+                    // Calculate scale and translation based on scaling mode
+                    let xRatio: CGFloat = targetSize.width / naturalSize.width
+                    let yRatio: CGFloat = targetSize.height / naturalSize.height
 
-                var matrix = CGAffineTransform(translationX: (transX / xRatio), y: (transY / yRatio))
-                matrix = matrix.scaledBy(x: (ratio / xRatio), y: (ratio / yRatio))
-                transform = transform.concatenating(matrix)
+                    let ratio: CGFloat
+                    if scalingMode == AVVideoScalingModeResizeAspectFill {
+                        // Aspect fill: scale to fill entire target (may crop)
+                        ratio = max(xRatio, yRatio)
+                    } else {
+                        // Resize: stretch to fill target exactly
+                        ratio = 1.0
+                    }
+
+                    let postWidth = naturalSize.width * ratio
+                    let postHeight = naturalSize.height * ratio
+                    let transX = (targetSize.width - postWidth) * 0.5
+                    let transY = (targetSize.height - postHeight) * 0.5
+
+                    var matrix = CGAffineTransform(translationX: (transX / xRatio), y: (transY / yRatio))
+                    if scalingMode == AVVideoScalingModeResize {
+                        // Stretch to exact dimensions
+                        matrix = matrix.scaledBy(x: xRatio, y: yRatio)
+                    } else {
+                        // Scale uniformly for aspect fill
+                        matrix = matrix.scaledBy(x: (ratio / xRatio), y: (ratio / yRatio))
+                    }
+                    transform = transform.concatenating(matrix)
+                } else {
+                    // No scaling mode specified or aspect-fit - use legacy centering logic
+                    videoComposition.renderSize = naturalSize
+
+                    var ratio: CGFloat = 0
+                    let xRatio: CGFloat = targetSize.width / naturalSize.width
+                    let yRatio: CGFloat = targetSize.height / naturalSize.height
+                    ratio = min(xRatio, yRatio)
+
+                    let postWidth = naturalSize.width * ratio
+                    let postHeight = naturalSize.height * ratio
+                    let transX = (targetSize.width - postWidth) * 0.5
+                    let transY = (targetSize.height - postHeight) * 0.5
+
+                    var matrix = CGAffineTransform(translationX: (transX / xRatio), y: (transY / yRatio))
+                    matrix = matrix.scaledBy(x: (ratio / xRatio), y: (ratio / yRatio))
+                    transform = transform.concatenating(matrix)
+                }
 
                 // make the composition