extended-vlc-player 0.1.0

package/ios/ExtendedVlcPlayerViewComponentView.mm

@@ -0,0 +1,101 @@
+#import "ExtendedVlcPlayerViewComponentView.h"
+#import "ExtendedVlcPlayer-Swift.h"
+
+#import <React/RCTConversions.h>
+#import <React/RCTLog.h>
+
+@interface ExtendedVlcPlayerViewComponentView () <ExtendedVlcPlayerViewEventReceiver>
+@property (nonatomic, strong) NSNumber *playerId;
+/// Strong refs to the event blocks the JS side passes via props. Keeping
+/// strong references prevents them from being collected by the runtime.
+@property (nonatomic, copy) RCTBubblingEventBlock onLoadBlock;
+@property (nonatomic, copy) RCTBubblingEventBlock onProgressBlock;
+@property (nonatomic, copy) RCTBubblingEventBlock onPlayingBlock;
+@property (nonatomic, copy) RCTBubblingEventBlock onPausedBlock;
+@property (nonatomic, copy) RCTBubblingEventBlock onEndedBlock;
+@property (nonatomic, copy) RCTBubblingEventBlock onErrorBlock;
+@property (nonatomic, copy) RCTBubblingEventBlock onBufferingBlock;
+@property (nonatomic, copy) RCTBubblingEventBlock onPictureInPictureStartBlock;
+@property (nonatomic, copy) RCTBubblingEventBlock onPictureInPictureStopBlock;
+@end
+
+@implementation ExtendedVlcPlayerViewComponentView
+
+RCT_EXPORT_VIEW_PROPERTY(player, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(contentFit, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(onLoad, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onProgress, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onPlaying, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onPaused, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onEnded, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onError, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onBuffering, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onPictureInPictureStart, RCTBubblingEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onPictureInPictureStop, RCTBubblingEventBlock)
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return [RCTViewComponentView new];
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    self.contentView.backgroundColor = UIColor.blackColor;
+  }
+  return self;
+}
+
+- (void)didMoveToWindow
+{
+  [super didMoveToWindow];
+  if (self.window != nil && self.playerId == nil) {
+    NSNumber *newId = [EXVLCPlayerRegistryBridge createSession];
+    self.playerId = newId;
+    NSValue *boxed = [EXVLCPlayerRegistryBridge sessionForId:newId];
+    PlayerSession *session = (PlayerSession *)[boxed nonretainedObjectValue];
+    if (session != nil) {
+      session.drawable.frame = self.contentView.bounds;
+      session.drawable.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+      [self.contentView addSubview:session.drawable];
+      [EXVLCPlayerRegistryBridge attachEventSinks:newId view:self];
+    }
+  }
+}
+
+- (void)dealloc
+{
+  if (self.playerId != nil) {
+    [EXVLCPlayerRegistryBridge destroySession:self.playerId];
+  }
+}
+
+- (void)updateLayout
+{
+  [super updateLayout];
+  if (self.playerId != nil) {
+    NSValue *boxed = [EXVLCPlayerRegistryBridge sessionForId:self.playerId];
+    PlayerSession *session = (PlayerSession *)[boxed nonretainedObjectValue];
+    if (session != nil) {
+      session.drawable.frame = self.contentView.bounds;
+    }
+  }
+}
+
+#pragma mark - ExtendedVlcPlayerViewEventReceiver
+
+- (void)exvlcEmit:(NSString *)name payload:(NSDictionary *)payload
+{
+  NSDictionary *p = payload ?: @{};
+  if ([name isEqualToString:@"onLoad"] && self.onLoadBlock) { self.onLoadBlock(p); return; }
+  if ([name isEqualToString:@"onProgress"] && self.onProgressBlock) { self.onProgressBlock(p); return; }
+  if ([name isEqualToString:@"onPlaying"] && self.onPlayingBlock) { self.onPlayingBlock(p); return; }
+  if ([name isEqualToString:@"onPaused"] && self.onPausedBlock) { self.onPausedBlock(p); return; }
+  if ([name isEqualToString:@"onEnded"] && self.onEndedBlock) { self.onEndedBlock(p); return; }
+  if ([name isEqualToString:@"onError"] && self.onErrorBlock) { self.onErrorBlock(p); return; }
+  if ([name isEqualToString:@"onBuffering"] && self.onBufferingBlock) { self.onBufferingBlock(p); return; }
+  if ([name isEqualToString:@"onPictureInPictureStart"] && self.onPictureInPictureStartBlock) { self.onPictureInPictureStartBlock(p); return; }
+  if ([name isEqualToString:@"onPictureInPictureStop"] && self.onPictureInPictureStopBlock) { self.onPictureInPictureStopBlock(p); return; }
+}
+
+@end

package/ios/PipBridge.swift

@@ -0,0 +1,144 @@
+import AVFoundation
+import CoreImage
+import CoreVideo
+import Foundation
+import UIKit
+
+/// Bridges UIImage snapshots (from VLC) to a stream of CMSampleBuffers
+/// that are enqueued onto an `AVSampleBufferDisplayLayer`.
+///
+/// MobileVLCKit does not expose decoded frames as `CVPixelBufferRef`. The
+/// only public way to get a rendered frame is the snapshot API, which
+/// returns a `UIImage`. This bridge converts that UIImage into a pooled
+/// `CVPixelBuffer` and a `CMSampleBuffer`, then enqueues it. The
+/// `AVSampleBufferDisplayLayer` is then used as the source for
+/// `AVPictureInPictureController.ContentSource` (set up by the
+/// `PlayerSession`).
+final class PipBridge {
+  private let displayLayer: AVSampleBufferDisplayLayer
+  private let ciContext = CIContext(options: [.useSoftwareRenderer: false])
+  private var pixelBufferPool: CVPixelBufferPool?
+  private let poolAttributes: [String: Any] = [
+    kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA,
+    kCVPixelBufferWidthKey as String: 640,
+    kCVPixelBufferHeightKey as String: 360,
+    kCVPixelBufferIOSurfacePropertiesKey as String: [:] as CFDictionary,
+  ]
+  private let bufferAttributes: [String: Any] = [
+    kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA,
+    kCVPixelBufferIOSurfacePropertiesKey as String: [:] as CFDictionary,
+  ]
+
+  /// Tracks the most recent enqueue's host time so we can compute the
+  /// presentation timestamp of the next sample buffer.
+  private var lastEnqueueTime: CFTimeInterval = 0
+  /// Frame counter used to make the format description identifier stable
+  /// across re-enqueues; AVPictureInPictureContentSource complains if the
+  /// format description changes between enqueues.
+  private var formatDescription: CMFormatDescription?
+  private var formatDescriptionWidth: Int = 0
+  private var formatDescriptionHeight: Int = 0
+
+  init(displayLayer: AVSampleBufferDisplayLayer) {
+    self.displayLayer = displayLayer
+  }
+
+  /// Call with a fresh UIImage from VLC. Performs all conversion on the
+  /// caller's queue (expected: main thread, since UIImage decoding on
+  /// other queues is expensive and can produce memory pressure spikes).
+  func feed(image: UIImage) {
+    guard let cgImage = image.cgImage else { return }
+    let width = cgImage.width
+    let height = cgImage.height
+    if width <= 0 || height <= 0 { return }
+
+    if pixelBufferPool == nil {
+      pixelBufferPool = makePool(width: width, height: height)
+    }
+    guard let pool = pixelBufferPool else { return }
+
+    var pixelBuffer: CVPixelBuffer?
+    let status = CVPixelBufferPoolCreatePixelBuffer(nil, pool, &pixelBuffer)
+    guard status == kCVReturnSuccess, let pb = pixelBuffer else { return }
+
+    // Lock + draw the image into the pixel buffer using Core Graphics.
+    CVPixelBufferLockBaseAddress(pb, [])
+    defer { CVPixelBufferUnlockBaseAddress(pb, []) }
+    let baseAddress = CVPixelBufferGetBaseAddress(pb)
+    let bytesPerRow = CVPixelBufferGetBytesPerRow(pb)
+    let colorSpace = CGColorSpaceCreateDeviceRGB()
+    guard let ctx = CGContext(
+      data: baseAddress,
+      width: width,
+      height: height,
+      bitsPerComponent: 8,
+      bytesPerRow: bytesPerRow,
+      space: colorSpace,
+      bitmapInfo: CGImageAlphaInfo.premultipliedFirst.rawValue | CGBitmapInfo.byteOrder32Little.rawValue
+    ) else { return }
+    ctx.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))
+
+    // Build / update the format description if dimensions changed.
+    if formatDescription == nil || width != formatDescriptionWidth || height != formatDescriptionHeight {
+      var desc: CMFormatDescription?
+      CMVideoFormatDescriptionCreateForImageBuffer(
+        allocator: kCFAllocatorDefault,
+        imageBuffer: pb,
+        formatDescriptionOut: &desc
+      )
+      formatDescription = desc
+      formatDescriptionWidth = width
+      formatDescriptionHeight = height
+    }
+    guard let desc = formatDescription else { return }
+
+    // Build a CMSampleBuffer that wraps the pixel buffer.
+    var timing = CMSampleTimingInfo(
+      duration: CMTime(value: 1, timescale: 30),
+      presentationTimeStamp: CMTime(seconds: CACurrentMediaTime(), preferredTimescale: 600),
+      decodeTimeStamp: .invalid
+    )
+    var sample: CMSampleBuffer?
+    let createStatus = CMSampleBufferCreateForImageBuffer(
+      allocator: kCFAllocatorDefault,
+      imageBuffer: pb,
+      dataReady: true,
+      makeDataReadyCallback: nil,
+      refcon: nil,
+      formatDescription: desc,
+      sampleTiming: &timing,
+      sampleBufferOut: &sample
+    )
+    guard createStatus == kCVReturnSuccess, let sb = sample else { return }
+
+    // Force the display layer to render this sample immediately, so the
+    // PiP overlay never shows a stale frame.
+    if let attachments = CMSampleBufferGetSampleAttachmentsArray(sb, createIfNecessary: true),
+       let dict = CFArrayGetValueAtIndex(attachments, 0) {
+      let dict = unsafeBitCast(dict, to: CFMutableDictionary.self)
+      CFDictionarySetValue(
+        dict,
+        Unmanaged.passUnretained(kCMSampleAttachmentKey_DisplayImmediately).toOpaque(),
+        Unmanaged.passUnretained(kCFBooleanTrue).toOpaque()
+      )
+    }
+    displayLayer.enqueue(sb)
+  }
+
+  private func makePool(width: Int, height: Int) -> CVPixelBufferPool? {
+    var attrs: [String: Any] = [
+      kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA,
+      kCVPixelBufferWidthKey as String: width,
+      kCVPixelBufferHeightKey as String: height,
+      kCVPixelBufferIOSurfacePropertiesKey as String: [:] as CFDictionary,
+    ]
+    var pool: CVPixelBufferPool?
+    let status = CVPixelBufferPoolCreate(
+      kCFAllocatorDefault,
+      nil,
+      attrs as CFDictionary,
+      &pool
+    )
+    return status == kCVReturnSuccess ? pool : nil
+  }
+}

package/ios/PlayerRegistryBridge.swift

@@ -0,0 +1,67 @@
+import Foundation
+
+/// Exposes the Swift-only `PlayerRegistry` to the Obj-C++ Fabric component
+/// view. The class methods are `@objc` so they show up in the generated
+/// `ExtendedVlcPlayer-Swift.h` header.
+@objc(EXVLCPlayerRegistryBridge)
+final class PlayerRegistryBridge: NSObject {
+  @objc static func createSession() -> NSNumber {
+    let (id, _) = PlayerRegistry.shared.next()
+    return NSNumber(value: id)
+  }
+
+  /// Returns a NSNumber-wrapped PlayerSession opaque pointer. The Obj-C++
+  /// view keeps this opaque reference and uses it to call closure setters
+  /// on the session.
+  @objc static func session(forId id: NSNumber) -> NSValue? {
+    guard let session = PlayerRegistry.shared.session(for: id.intValue) else { return nil }
+    return NSValue(nonretainedObject: session)
+  }
+
+  @objc static func destroySession(_ id: NSNumber) {
+    PlayerRegistry.shared.remove(id: id.intValue)
+  }
+
+  /// Forwards a JS event payload into the Fabric event dispatcher. The
+  /// Obj-C++ view's event blocks call into this and we surface them as
+  /// normal Fabric component events.
+  @objc static func attachEventSinks(_ id: NSNumber, _ view: UIView) {
+    guard let session = PlayerRegistry.shared.session(for: id.intValue) else { return }
+    let view = view
+    session.onLoad = { [weak view] payload in
+      (view as? ExtendedVlcPlayerViewEventReceiver)?.exvlcEmit("onLoad", payload)
+    }
+    session.onProgress = { [weak view] payload in
+      (view as? ExtendedVlcPlayerViewEventReceiver)?.exvlcEmit("onProgress", payload)
+    }
+    session.onPlaying = { [weak view] payload in
+      (view as? ExtendedVlcPlayerViewEventReceiver)?.exvlcEmit("onPlaying", payload)
+    }
+    session.onPaused = { [weak view] payload in
+      (view as? ExtendedVlcPlayerViewEventReceiver)?.exvlcEmit("onPaused", payload)
+    }
+    session.onEnded = { [weak view] in
+      (view as? ExtendedVlcPlayerViewEventReceiver)?.exvlcEmit("onEnded", [:])
+    }
+    session.onError = { [weak view] payload in
+      (view as? ExtendedVlcPlayerViewEventReceiver)?.exvlcEmit("onError", payload)
+    }
+    session.onBuffering = { [weak view] payload in
+      (view as? ExtendedVlcPlayerViewEventReceiver)?.exvlcEmit("onBuffering", payload)
+    }
+    session.onPictureInPictureStart = { [weak view] in
+      (view as? ExtendedVlcPlayerViewEventReceiver)?.exvlcEmit("onPictureInPictureStart", [:])
+    }
+    session.onPictureInPictureStop = { [weak view] in
+      (view as? ExtendedVlcPlayerViewEventReceiver)?.exvlcEmit("onPictureInPictureStop", [:])
+    }
+  }
+}
+
+/// Implemented by the Fabric component view (in Obj-C++) so that the
+/// Swift registry bridge can forward events to the view, which in turn
+/// surfaces them via the standard Fabric event system. This indirection
+/// keeps Swift-only types out of the Obj-C++ source.
+@objc protocol ExtendedVlcPlayerViewEventReceiver {
+  func exvlcEmit(_ name: String, _ payload: [AnyHashable: Any])
+}

package/ios/PlayerSession.swift

@@ -0,0 +1,335 @@
+import AVFoundation
+import Foundation
+import MobileVLCKit
+import UIKit
+
+/// Owns the runtime state of a single VLC media player plus the
+/// PiP-related infrastructure. There is one instance per JS player.
+///
+/// Thread-safety: all UIKit/VLC work happens on the main thread.
+final class PlayerSession: NSObject {
+  let id: Int
+  let mediaPlayer = VLCMediaPlayer(options: [
+    "network-caching": 1500,
+    "live-caching": 1500,
+    "file-caching": 1500,
+  ])
+
+  /// The UIView that hosts the `VLCMediaPlayer.drawable`. Created on demand
+  /// so a session that is only used for headless PiP does not allocate a
+  /// drawable. The Fabric component view owns and retains it.
+  lazy var drawable: UIView = {
+    let view = UIView()
+    view.backgroundColor = .black
+    view.translatesAutoresizingMaskIntoConstraints = false
+    mediaPlayer.drawable = view
+    return view
+  }()
+
+  /// Off-screen layer that backs the PiP overlay.
+  private lazy var sampleBufferDisplayLayer: AVSampleBufferDisplayLayer = {
+    let layer = AVSampleBufferDisplayLayer()
+    layer.videoGravity = .resizeAspect
+    layer.backgroundColor = UIColor.black.cgColor
+    return layer
+  }()
+
+  private lazy var pipBridge: PipBridge = PipBridge(displayLayer: sampleBufferDisplayLayer)
+  private var _pipController: AVPictureInPictureController?
+  private var pipController: AVPictureInPictureController? {
+    get { _pipController }
+    set {
+      _pipController?.removeObserver(self, forKeyPath: "pictureInPictureActive", context: nil)
+      _pipController = newValue
+      _pipController?.addObserver(self, forKeyPath: "pictureInPictureActive", options: [.new], context: nil)
+    }
+  }
+
+  private lazy var pipSampleBufferDelegate: SampleBufferPlaybackDelegate = {
+    SampleBufferPlaybackDelegate(session: self)
+  }()
+
+  private var displayLink: CADisplayLink?
+  private var snapshotCounter: UInt64 = 0
+
+  /// Closure-based event sinks. The Fabric component view sets these when
+  /// the session is attached; the session calls them on player events.
+  var onLoad: (([String: Any]) -> Void)?
+  var onProgress: (([String: Any]) -> Void)?
+  var onPlaying: (([String: Any]) -> Void)?
+  var onPaused: (([String: Any]) -> Void)?
+  var onEnded: (() -> Void)?
+  var onError: (([String: Any]) -> Void)?
+  var onBuffering: (([String: Any]) -> Void)?
+  var onPictureInPictureStart: (() -> Void)?
+  var onPictureInPictureStop: (() -> Void)?
+
+  init(id: Int) {
+    self.id = id
+    super.init()
+    mediaPlayer.delegate = self
+  }
+
+  deinit {
+    displayLink?.invalidate()
+    mediaPlayer.stop()
+  }
+
+  // MARK: - Player control
+
+  func play() { mediaPlayer.play() }
+  func pause() { mediaPlayer.pause() }
+  func stop() { mediaPlayer.stop() }
+
+  func seek(to seconds: Double) {
+    let vt = max(0, seconds)
+    mediaPlayer.time = VLCTime(int: Int32(vt * 1000))
+  }
+
+  func setRate(_ rate: Double) {
+    mediaPlayer.rate = Float(max(0.1, rate))
+  }
+
+  func setVolume(_ volume: Float) {
+    mediaPlayer.volume = Int32(volume * 200)
+  }
+
+  func setAudioTrack(index: Int) {
+    if index < 0 {
+      mediaPlayer.currentAudioTrackIndex = -1
+    } else {
+      let tracks = mediaPlayer.audioTrackIndexes as? [Int32] ?? []
+      if index < tracks.count {
+        mediaPlayer.currentAudioTrackIndex = tracks[index]
+      }
+    }
+  }
+
+  func setSubtitleTrack(index: Int) {
+    if index < 0 {
+      mediaPlayer.currentVideoSubTitleIndex = -1
+    } else {
+      let tracks = mediaPlayer.videoSubTitlesIndexes as? [Int32] ?? []
+      if index < tracks.count {
+        mediaPlayer.currentVideoSubTitleIndex = tracks[index]
+      }
+    }
+  }
+
+  func replace(media: VLCMedia) {
+    mediaPlayer.media = media
+    mediaPlayer.play()
+  }
+
+  // MARK: - Picture-in-Picture
+
+  @discardableResult
+  func startPictureInPicture() -> Bool {
+    guard AVPictureInPictureController.isPictureInPictureSupported() else { return false }
+    guard let drawable = mediaPlayer.drawable else { return false }
+
+    if pipController != nil {
+      pipController?.startPictureInPicture()
+      startSnapshotBridge()
+      return true
+    }
+
+    if sampleBufferDisplayLayer.superlayer == nil {
+      drawable.layer.addSublayer(sampleBufferDisplayLayer)
+      sampleBufferDisplayLayer.frame = .zero
+    }
+
+    let contentSource = AVPictureInPictureController.ContentSource(
+      sampleBufferDisplayLayer: sampleBufferDisplayLayer,
+      playbackDelegate: pipSampleBufferDelegate
+    )
+    let controller = AVPictureInPictureController(contentSource: contentSource)
+    controller.delegate = self
+    controller.canStartPictureInPictureAutomaticallyFromInline = false
+    pipController = controller
+
+    startSnapshotBridge()
+    controller.startPictureInPicture()
+    return true
+  }
+
+  @discardableResult
+  func stopPictureInPicture() -> Bool {
+    let wasActive = pipController?.isPictureInPictureActive ?? false
+    pipController?.stopPictureInPicture()
+    stopSnapshotBridge()
+    return wasActive
+  }
+
+  // MARK: - Snapshot bridge
+
+  private func startSnapshotBridge() {
+    stopSnapshotBridge()
+    let link = CADisplayLink(target: self, selector: #selector(snapshotTick))
+    link.add(to: .main, forMode: .common)
+    displayLink = link
+  }
+
+  private func stopSnapshotBridge() {
+    displayLink?.invalidate()
+    displayLink = nil
+  }
+
+  @objc private func snapshotTick() {
+    snapshotCounter &+= 1
+    let tempDir = NSTemporaryDirectory()
+    let path = (tempDir as NSString).appendingPathComponent("exvlc-\(id)-\(snapshotCounter).jpg")
+    mediaPlayer.saveVideoSnapshot(at: path, withWidth: 0, andHeight: 0)
+    DispatchQueue.main.async { [weak self] in
+      self?.consumeSnapshot(at: path)
+    }
+  }
+
+  private func consumeSnapshot(at path: String) {
+    guard FileManager.default.fileExists(atPath: path) else { return }
+    defer { try? FileManager.default.removeItem(atPath: path) }
+    guard let image = UIImage(contentsOfFile: path) else { return }
+    pipBridge.feed(image: image)
+  }
+}
+
+// MARK: - VLCMediaPlayerDelegate
+
+extension PlayerSession: VLCMediaPlayerDelegate {
+  func mediaPlayerStateChanged(_ aNotification: Notification!) {
+    switch mediaPlayer.state {
+    case .opening:
+      onLoad?([
+        "duration": Double(mediaPlayer.length.intValue) / 1000.0,
+        "audioTracks": audioTracksPayload(),
+        "textTracks": textTracksPayload(),
+      ])
+    case .playing:
+      onPlaying?(["duration": Double(mediaPlayer.length.intValue) / 1000.0])
+    case .paused:
+      onPaused?([:])
+    case .stopped:
+      onEnded?()
+    case .ended:
+      onEnded?()
+    case .error:
+      onError?([
+        "message": "VLCMediaPlayer reported error state",
+        "code": "VLC_ERROR",
+        "domain": "MobileVLCKit",
+      ])
+    case .buffering:
+      onBuffering?(["isBuffering": true])
+    @unknown default:
+      break
+    }
+  }
+
+  func mediaPlayerTimeChanged(_ aNotification: Notification!) {
+    let current = Double(mediaPlayer.time.intValue) / 1000.0
+    let total = Double(mediaPlayer.length.intValue) / 1000.0
+    let position = total > 0 ? current / total : 0
+    onProgress?([
+      "currentTime": current,
+      "duration": total,
+      "position": position,
+    ])
+  }
+
+  private func audioTracksPayload() -> [[String: Any]] {
+    let indexes = (mediaPlayer.audioTrackIndexes as? [Int32]) ?? []
+    return indexes.enumerated().map { (i, _) -> [String: Any] in
+      ["index": i]
+    }
+  }
+
+  private func textTracksPayload() -> [[String: Any]] {
+    let indexes = (mediaPlayer.videoSubTitlesIndexes as? [Int32]) ?? []
+    return indexes.enumerated().map { (i, _) -> [String: Any] in
+      ["index": i]
+    }
+  }
+}
+
+// MARK: - AVPictureInPictureControllerDelegate
+
+extension PlayerSession: AVPictureInPictureControllerDelegate {
+  func pictureInPictureControllerWillStartPictureInPicture(_ pictureInPictureController: AVPictureInPictureController) {}
+
+  func pictureInPictureControllerDidStartPictureInPicture(_ pictureInPictureController: AVPictureInPictureController) {
+    onPictureInPictureStart?()
+  }
+
+  func pictureInPictureControllerDidStopPictureInPicture(_ pictureInPictureController: AVPictureInPictureController) {
+    stopSnapshotBridge()
+    onPictureInPictureStop?()
+  }
+
+  func pictureInPictureController(
+    _ pictureInPictureController: AVPictureInPictureController,
+    failedToStartPictureInPictureWithError error: Error
+  ) {
+    stopSnapshotBridge()
+    onError?([
+      "message": "Picture-in-Picture failed to start: \(error.localizedDescription)",
+      "code": "PIP_FAILED",
+      "domain": "AVKit",
+    ])
+  }
+
+  func pictureInPictureController(
+    _ pictureInPictureController: AVPictureInPictureController,
+    restoreUserInterfaceForPictureInPictureStopWithCompletionHandler completionHandler: @escaping (Bool) -> Void
+  ) {
+    completionHandler(true)
+  }
+
+  override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey: Any]?, context: UnsafeMutableRawPointer?) {
+    if keyPath == "pictureInPictureActive" {
+      if let active = change?[.newKey] as? Bool, !active {
+        stopSnapshotBridge()
+      }
+    } else {
+      super.observeValue(forKeyPath: keyPath, of: object, change: change, context: context)
+    }
+  }
+}
+
+// MARK: - SampleBufferPlaybackDelegate
+
+final class SampleBufferPlaybackDelegate: NSObject, AVPictureInPictureSampleBufferPlaybackDelegate {
+  weak var session: PlayerSession?
+
+  init(session: PlayerSession) {
+    self.session = session
+    super.init()
+  }
+
+  func setPlaying(_ playing: Bool) {}
+  func setPlaybackRate(_ playbackRate: Float) { session?.mediaPlayer.rate = playbackRate }
+  func playbackTimeRange() -> CMTimeRange {
+    let start = session?.mediaPlayer.time ?? VLCTime(int: 0)
+    let length = session?.mediaPlayer.length ?? VLCTime(int: 0)
+    let startSec = Double(start.intValue) / 1000.0
+    let lengthSec = Double(length.intValue) / 1000.0
+    if lengthSec <= 0 { return .invalid }
+    return CMTimeRange(
+      start: CMTime(seconds: startSec, preferredTimescale: 600),
+      duration: CMTime(seconds: lengthSec, preferredTimescale: 600)
+    )
+  }
+  func isPlaybackPaused() -> Bool { return !(session?.mediaPlayer.isPlaying ?? false) }
+  func isPlaybackBufferEmpty() -> Bool { return !(session?.mediaPlayer.isPlaying ?? false) }
+  func isPlaybackLikelyToKeepUp() -> Bool { return session?.mediaPlayer.isPlaying ?? false }
+  func didPlayToEnd() -> Bool { return session?.mediaPlayer.state == .ended }
+  func currentTime() -> CMTime {
+    let t = session?.mediaPlayer.time ?? VLCTime(int: 0)
+    return CMTime(seconds: Double(t.intValue) / 1000.0, preferredTimescale: 600)
+  }
+  func seek(to time: CMTime, completionHandler: @escaping (Bool) -> Void) {
+    let secs = CMTimeGetSeconds(time)
+    session?.seek(to: secs)
+    completionHandler(true)
+  }
+  func recommendedPlaybackRate() -> Float { return session?.mediaPlayer.rate ?? 1.0 }
+}