Fix stretched macOS video by syncing aspect ratio to live frames

Derive the display aspect ratio from AVPlayerItem.presentationSize (pixel
aspect ratio and clean aperture applied) and re-sync it per published frame.
The dimensions known at open time can be wrong or stale — HLS reports a
default/early-variant size and anamorphic content has non-square pixels — so
stretching the full bitmap into a Canvas sized from those dimensions distorted
the image. presentationSize is cached from a KVO observer so it can be read off
the main thread.

Author: Buffersolve

mediaplayer/src/jvmMain/kotlin/io/github/kdroidfilter/composemediaplayer/mac/MacNativeBridge.kt

@@ -65,6 +65,8 @@ internal object MacNativeBridge {
 
     @JvmStatic external fun nGetFrameHeight(handle: Long): Int
 
+    @JvmStatic external fun nGetDisplayAspectRatio(handle: Long): Double
+
     @JvmStatic external fun nSetOutputSize(
         handle: Long,
         width: Int,

mediaplayer/src/jvmMain/kotlin/io/github/kdroidfilter/composemediaplayer/mac/MacVideoPlayerState.kt

@@ -447,6 +447,45 @@ class MacVideoPlayerState : VideoPlayerState {
         macLogger.e { "Unable to retrieve valid dimensions after $maxAttempts attempts" }
     }
 
+    /**
+     * Returns the aspect ratio the video should be displayed at.
+     *
+     * Prefers the display aspect ratio reported by AVFoundation ([MacNativeBridge.nGetDisplayAspectRatio],
+     * i.e. `presentationSize`), which has the pixel aspect ratio and clean aperture applied. Anamorphic /
+     * non-square-pixel videos have a display aspect ratio that differs from the raw decoded pixel-buffer
+     * dimensions; drawing the raw bitmap into a Canvas sized with this display ratio rescales the pixels
+     * back to their intended geometry. Falls back to the raw frame ratio when unavailable.
+     */
+    private fun displayAspectRatio(width: Int, height: Int): Float {
+        val ptr = playerPtr
+        val displayAspect = if (ptr != 0L) MacNativeBridge.nGetDisplayAspectRatio(ptr) else 0.0
+        return if (displayAspect > 0.0) {
+            displayAspect.toFloat()
+        } else {
+            width.toFloat() / height.toFloat()
+        }
+    }
+
+    /**
+     * Aligns the displayed aspect ratio (and reported dimensions) with the live frame.
+     *
+     * Called on every published frame. Both [_aspectRatio] and the [metadata] width/height are
+     * snapshot-backed state, so they can be written safely from the frame-decoding thread, and the
+     * guards keep it a no-op unless a value actually changed. This is what prevents the video from
+     * being stretched when the dimensions known at open time (HLS reports a default/early-variant
+     * size, anamorphic content has non-square pixels) don't match the frames being rendered.
+     */
+    private fun syncAspectRatioToFrame(width: Int, height: Int) {
+        if (width <= 0 || height <= 0) return
+
+        val frameAspect = displayAspectRatio(width, height)
+        if (kotlin.math.abs(frameAspect - _aspectRatio.value) > 0.001f) {
+            _aspectRatio.value = frameAspect
+        }
+        if (metadata.width != width) metadata.width = width
+        if (metadata.height != height) metadata.height = height
+    }
+
     /** Updates the metadata from the native player. */
     private suspend fun updateMetadata() {
         macLogger.d { "updateMetadata()" }
@@ -459,13 +498,12 @@ class MacVideoPlayerState : VideoPlayerState {
             val duration = (MacNativeBridge.nGetVideoDuration(ptr) * 1000).toLong()
             val frameRate = MacNativeBridge.nGetVideoFrameRate(ptr)
 
-            // Calculate aspect ratio
+            // Initial aspect ratio estimate; refined per-frame by syncAspectRatioToFrame().
+            // Keep the previous value if the video isn't ready yet rather than forcing 16:9.
             val newAspectRatio =
                 if (width > 0 && height > 0) {
-                    width.toFloat() / height.toFloat()
+                    displayAspectRatio(width, height)
                 } else {
-                    // Instead of forcing 16f/9f, don’t change the aspect if the video is not ready yet.
-                    // For example, we can keep the previous aspect ratio:
                     _aspectRatio.value
                 }
 
@@ -488,7 +526,6 @@ class MacVideoPlayerState : VideoPlayerState {
                 metadata.audioChannels = if (audioChannels == 0) null else audioChannels
                 metadata.audioSampleRate = if (audioSampleRate == 0) null else audioSampleRate
 
-                // Update the aspect ratio only if width/height are valid
                 _aspectRatio.value = newAspectRatio
             }
 
@@ -621,6 +658,15 @@ class MacVideoPlayerState : VideoPlayerState {
 
                         _currentFrameState.value = targetBitmap.asComposeImageBitmap()
                         framePublished = true
+
+                        // Keep the displayed aspect ratio in sync with the frame we actually draw.
+                        // The dimensions captured by updateMetadata() at open time can be wrong or
+                        // stale (HLS reports a default/early-variant size before the real resolution is
+                        // decoded; anamorphic content has non-square pixels). Since the Canvas is sized
+                        // with aspectRatio and the full bitmap is stretched into it, a mismatch distorts
+                        // the image (e.g. vertical stretch). Re-derive it from the live frame. Cheap:
+                        // only writes snapshot state when the value actually changes.
+                        syncAspectRatioToFrame(width, height)
                     }
                 } finally {
                     MacNativeBridge.nUnlockFrame(ptr)

mediaplayer/src/jvmMain/native/macos/NativeVideoPlayer.swift

@@ -71,6 +71,13 @@ class MacVideoPlayer {
     private var bufferEmptyObserver: NSKeyValueObservation?
     private var bufferLikelyToKeepUpObserver: NSKeyValueObservation?
     private var bufferFullObserver: NSKeyValueObservation?
+    private var presentationSizeObserver: NSKeyValueObservation?
+
+    // Display aspect ratio (width / height) derived from AVPlayerItem.presentationSize.
+    // Cached here and updated from the KVO callback so getDisplayAspectRatio() can be called
+    // from the frame-decoding thread without touching the live AVPlayerItem off the main thread.
+    private let aspectLock = NSLock()
+    private var cachedDisplayAspectRatio: Double = 0.0
 
     // End-of-playback flag (set by AVPlayerItemDidPlayToEndTime, consumed once by the Kotlin side)
     private var didPlayToEnd: Bool = false
@@ -886,6 +893,13 @@ class MacVideoPlayer {
             self?.handleTimeControlStatus(player.timeControlStatus)
         }
 
+        // Cache the display aspect ratio whenever presentationSize changes (e.g. HLS variant
+        // switches). Reading presentationSize here keeps the live AVPlayerItem access on the
+        // observation thread instead of the frame-decoding thread. .initial seeds the value now.
+        presentationSizeObserver = item.observe(\.presentationSize, options: [.initial, .new]) { [weak self] item, _ in
+            self?.updateCachedDisplayAspectRatio(from: item.presentationSize)
+        }
+
         // Observe end of playback for all media types
         playbackEndObserver = NotificationCenter.default.addObserver(
             forName: .AVPlayerItemDidPlayToEndTime,
@@ -1166,6 +1180,29 @@ class MacVideoPlayer {
     /// Returns the height of the video frame in pixels
     func getFrameHeight() -> Int { return frameHeight }
 
+    /// Recomputes the cached display aspect ratio from a presentationSize. Called on the KVO
+    /// observation thread; the value is read elsewhere from the frame-decoding thread.
+    private func updateCachedDisplayAspectRatio(from size: CGSize) {
+        let ratio = (size.width > 0 && size.height > 0) ? Double(size.width) / Double(size.height) : 0.0
+        aspectLock.lock()
+        cachedDisplayAspectRatio = ratio
+        aspectLock.unlock()
+    }
+
+    /// Returns the correct display aspect ratio (width / height) of the current video.
+    ///
+    /// Derived from `AVPlayerItem.presentationSize`, which AVFoundation computes with the pixel
+    /// aspect ratio and clean aperture already applied. This is the geometry the video should be
+    /// drawn at — it can differ from the raw decoded pixel-buffer dimensions for anamorphic /
+    /// non-square pixel content, which would otherwise be stretched. The value is cached from a
+    /// KVO observer (see setup) so this is safe to call off the main thread; returns 0 when not
+    /// yet available so the caller can fall back to the raw frame dimensions.
+    func getDisplayAspectRatio() -> Double {
+        aspectLock.lock()
+        defer { aspectLock.unlock() }
+        return cachedDisplayAspectRatio
+    }
+
     /// Scales the output to fit within (width, height) while preserving the native aspect ratio.
     /// Never upscales beyond the native resolution. Recreates the pixel buffer output at the new size.
     /// Returns true if dimensions actually changed.
@@ -1310,6 +1347,10 @@ class MacVideoPlayer {
         bufferEmptyObserver?.invalidate()
         bufferLikelyToKeepUpObserver?.invalidate()
         bufferFullObserver?.invalidate()
+        presentationSizeObserver?.invalidate()
+        presentationSizeObserver = nil
+        // Drop the cached aspect ratio so a reopened player can't briefly show the old video's ratio.
+        updateCachedDisplayAspectRatio(from: .zero)
 
         if let observer = playbackEndObserver {
             NotificationCenter.default.removeObserver(observer)
@@ -1420,6 +1461,13 @@ public func getFrameHeight(_ context: UnsafeMutableRawPointer?) -> Int32 {
     return Int32(player.getFrameHeight())
 }
 
+@_cdecl("getDisplayAspectRatio")
+public func getDisplayAspectRatio(_ context: UnsafeMutableRawPointer?) -> Double {
+    guard let context = context else { return 0.0 }
+    let player = Unmanaged<MacVideoPlayer>.fromOpaque(context).takeUnretainedValue()
+    return player.getDisplayAspectRatio()
+}
+
 @_cdecl("setOutputSize")
 public func setOutputSize(_ context: UnsafeMutableRawPointer?, _ width: Int32, _ height: Int32) -> Int32 {
     guard let context = context else { return 0 }

mediaplayer/src/jvmMain/native/macos/jni_bridge.c

@@ -19,6 +19,7 @@ extern void*  lockLatestFrame(void* ctx, int32_t* outInfo);
 extern void   unlockLatestFrame(void* ctx);
 extern int32_t getFrameWidth(void* ctx);
 extern int32_t getFrameHeight(void* ctx);
+extern double getDisplayAspectRatio(void* ctx);
 extern int32_t setOutputSize(void* ctx, int32_t width, int32_t height);
 extern float  getVideoFrameRate(void* ctx);
 extern float  getScreenRefreshRate(void* ctx);
@@ -106,6 +107,10 @@ static jint JNICALL jni_GetFrameHeight(JNIEnv* env, jclass cls, jlong handle) {
     return handle ? (jint)getFrameHeight(toCtx(handle)) : 0;
 }
 
+static jdouble JNICALL jni_GetDisplayAspectRatio(JNIEnv* env, jclass cls, jlong handle) {
+    return handle ? (jdouble)getDisplayAspectRatio(toCtx(handle)) : 0.0;
+}
+
 static jint JNICALL jni_SetOutputSize(JNIEnv* env, jclass cls, jlong handle, jint width, jint height) {
     return handle ? (jint)setOutputSize(toCtx(handle), (int32_t)width, (int32_t)height) : 0;
 }
@@ -196,6 +201,7 @@ static const JNINativeMethod g_methods[] = {
     { "nWrapPointer",            "(JJ)Ljava/nio/ByteBuffer;",   (void*)jni_WrapPointer },
     { "nGetFrameWidth",          "(J)I",                        (void*)jni_GetFrameWidth },
     { "nGetFrameHeight",         "(J)I",                        (void*)jni_GetFrameHeight },
+    { "nGetDisplayAspectRatio",  "(J)D",                        (void*)jni_GetDisplayAspectRatio },
     { "nSetOutputSize",          "(JII)I",                      (void*)jni_SetOutputSize },
     { "nGetVideoFrameRate",      "(J)F",                        (void*)jni_GetVideoFrameRate },
     { "nGetScreenRefreshRate",   "(J)F",                        (void*)jni_GetScreenRefreshRate },