@pigeonmal/react-native-video 7.0.0-beta.2

package/ios/core/Extensions/AVAsset+estimatedMemoryUsage.swift

@@ -0,0 +1,51 @@
+//
+//  AVAsset+estimatedMemoryUsage.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 23/01/2025.
+//
+
+import AVFoundation
+import Foundation
+
+extension AVAsset {
+  var estimatedMemoryUsage: Int {
+    if let urlAsset = self as? AVURLAsset, urlAsset.url.isFileURL {
+      let resourceValues = try? urlAsset.url.resourceValues(forKeys: [.fileSizeKey])
+      if let fileSize = resourceValues?.fileSize, fileSize > 0 {
+        return fileSize
+      }
+    }
+
+    var estimatedSize = 0
+
+    let videoTracks = tracks(withMediaType: .video)
+    let audioTracks = tracks(withMediaType: .audio)
+
+    for track in videoTracks {
+      let size = track.naturalSize
+      let pixelCount = size.width * size.height
+      let duration = CMTimeGetSeconds(track.timeRange.duration)
+
+      if duration > 0 && !duration.isNaN && !duration.isInfinite {
+        let bitrate = track.estimatedDataRate > 0 ? track.estimatedDataRate : 2_000_000
+        estimatedSize += Int((bitrate * Float(duration)) / 8)
+      } else {
+        estimatedSize += Int(pixelCount * 4)
+      }
+    }
+
+    for track in audioTracks {
+      let duration = CMTimeGetSeconds(track.timeRange.duration)
+      let bitrate = track.estimatedDataRate > 0 ? track.estimatedDataRate : 128_000
+
+      if duration > 0 && !duration.isNaN && !duration.isInfinite {
+        estimatedSize += Int((bitrate * Float(duration)) / 8)
+      } else {
+        estimatedSize += 1_000_000
+      }
+    }
+
+    return estimatedSize > 0 ? estimatedSize : 0
+  }
+}

package/ios/core/Extensions/AVAssetTrack+orientation.swift

@@ -0,0 +1,41 @@
+//
+//  AVAssetTrack+orientation.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 23/01/2025.
+//
+
+import AVFoundation
+
+extension AVAssetTrack {
+  var orientation: VideoOrientation {
+    let transform = preferredTransform
+    let size = naturalSize.applying(transform)
+    
+    // Check if video is square
+    if size.width == size.height {
+      return .square
+    }
+    
+    // Check if video is portrait or landscape
+    let isNaturalSizePortrait = size.width < size.height
+    
+    // Calculate video rotation
+    let angle = atan2(Double(transform.b), Double(transform.a))
+    let degrees = angle * 180 / .pi
+    let rotation = degrees < 0 ? degrees + 360 : degrees
+    
+    switch rotation {
+    case 0:
+      return isNaturalSizePortrait ? .portrait : .landscapeRight
+    case 90, -270:
+      return .portrait
+    case 180, -180:
+      return isNaturalSizePortrait ? .portraitUpsideDown : .landscapeLeft
+    case 270, -90:
+      return .portraitUpsideDown
+    default:
+      return isNaturalSizePortrait ? .portrait : .landscape
+    }
+  }
+}

package/ios/core/Extensions/AVPlayerItem+externalSubtitles.swift

@@ -0,0 +1,35 @@
+//
+//  AVPlayerItem+externalSubtitles.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 08/05/2025.
+//
+
+import AVFoundation
+import Foundation
+
+extension AVPlayerItem {
+  static func withExternalSubtitles(for asset: AVURLAsset, config: NativeVideoConfig) async throws
+    -> AVPlayerItem
+  {
+    if config.externalSubtitles?.isEmpty != false {
+      return AVPlayerItem(asset: asset)
+    }
+
+    if asset.url.pathExtension == "m3u8" {
+      let supportedExternalSubtitles = config.externalSubtitles?.filter { subtitle in
+        ExternalSubtitlesUtils.isSubtitleTypeSupported(subtitle: subtitle)
+      }
+
+      if supportedExternalSubtitles?.isEmpty == true {
+        return AVPlayerItem(asset: asset)
+      } else {
+        return try await ExternalSubtitlesUtils.modifyStreamManifestWithExternalSubtitles(
+          for: asset, config: config)
+      }
+    }
+
+    return try await ExternalSubtitlesUtils.createCompositionWithExternalSubtitles(
+      for: asset, config: config)
+  }
+}

package/ios/core/Extensions/AVPlayerItem+getBufferedDurration.swift

@@ -0,0 +1,34 @@
+//
+//  AVPlayerItem+getBufferedPosition.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 06/05/2025.
+//
+
+import Foundation
+import AVFoundation
+
+extension AVPlayerItem {
+  
+  // Duration that can be played using only the buffer (seconds)
+  func getbufferDuration() -> Double {
+    var effectiveTimeRange: CMTimeRange?
+    
+    for value in loadedTimeRanges {
+      let timeRange: CMTimeRange = value.timeRangeValue
+      if CMTimeRangeContainsTime(timeRange, time: currentTime()) {
+        effectiveTimeRange = timeRange
+        break
+      }
+    }
+    
+    if let effectiveTimeRange {
+      let playableDuration: Float64 = CMTimeGetSeconds(CMTimeRangeGetEnd(effectiveTimeRange))
+      if playableDuration > 0 {
+        return playableDuration
+      }
+    }
+    
+    return 0
+  }
+}

package/ios/core/Extensions/AVPlayerItem+setBufferConfig.swift

@@ -0,0 +1,37 @@
+//
+//  AVPlayerItem+setBufferConfig.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 13/09/2025.
+//
+
+import Foundation
+import AVFoundation
+
+extension AVPlayerItem {
+  func setBufferConfig(config: BufferConfig) {
+    if let forwardBufferDurationMs = config.preferredForwardBufferDurationMs {
+      preferredForwardBufferDuration = TimeInterval(forwardBufferDurationMs / 1000.0)
+    }
+    
+    if let peakBitRate = config.preferredPeakBitRate {
+      preferredPeakBitRate = Double(peakBitRate)
+    }
+    
+    if let maximumResolution = config.preferredMaximumResolution {
+      preferredMaximumResolution = CGSize(width: maximumResolution.width, height: maximumResolution.height)
+    }
+    
+    if let peakBitRateForExpensiveNetworks = config.preferredPeakBitRateForExpensiveNetworks {
+      preferredPeakBitRateForExpensiveNetworks = Double(peakBitRateForExpensiveNetworks)
+    }
+    
+    if let maximumResolutionForExpensiveNetworks = config.preferredMaximumResolutionForExpensiveNetworks {
+      preferredMaximumResolutionForExpensiveNetworks = CGSize(width: maximumResolutionForExpensiveNetworks.width, height: maximumResolutionForExpensiveNetworks.height)
+    }
+    
+    if let liveTargetOffsetMs = config.livePlayback?.targetOffsetMs {
+      configuredTimeOffsetFromLive = CMTime(seconds: Double(liveTargetOffsetMs) / 1000.0, preferredTimescale: 1000)
+    }
+  }
+}

package/ios/core/Extensions/AVPlayerViewController+Fullscreen.swift

@@ -0,0 +1,21 @@
+//
+//  AVPlayerViewController+Fullscreen.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 27/04/2025.
+//
+
+import Foundation
+import AVKit
+
+extension AVPlayerViewController {
+  // https://stackoverflow.com/a/64466924
+  
+  func enterFullscreen(animated: Bool) {
+    performIfResponds(NSSelectorFromString("enterFullScreenAnimated:completionHandler:"), with: animated, with: nil)
+  }
+  
+  func exitFullscreen(animated: Bool) {
+    performIfResponds(NSSelectorFromString("exitFullScreenAnimated:completionHandler:"), with: animated, with: nil)
+  }
+}

package/ios/core/Extensions/AVPlayerViewController+PictureInPicture.swift

@@ -0,0 +1,24 @@
+//
+//  AVPlayerViewController+PictureInPicture.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 27/04/2025.
+//
+
+import Foundation
+import AVKit
+
+extension AVPlayerViewController {
+  // https://github.com/expo/expo/blob/d37ae17df23c58011a3c5b9f5dedd563bf8e6521/packages/expo-video/ios/VideoView.swift#L110
+  func startPictureInPicture() throws {
+    guard AVPictureInPictureController.isPictureInPictureSupported() else {
+      throw VideoViewError.pictureInPictureNotSupported.error()
+    }
+    
+    performIfResponds(NSSelectorFromString("startPictureInPicture"))
+  }
+  
+  func stopPictureInPicture() {
+    performIfResponds(NSSelectorFromString("stopPictureInPicture"))
+  }
+}

package/ios/core/Extensions/AVURLAsset+getAssetInformation.swift

@@ -0,0 +1,68 @@
+import AVFoundation
+
+extension AVURLAsset {
+  func getAssetInformation() async throws -> VideoInformation {
+    // Initialize with default values
+    var videoInformation = VideoInformation(
+      bitrate: Double.nan,
+      width: Double.nan,
+      height: Double.nan,
+      duration: -1,
+      fileSize: -1,
+      isHDR: false,
+      isLive: false,
+      orientation: .unknown
+    )
+
+    videoInformation.fileSize = try await VideoFileHelper.getFileSize(for: url)
+
+    // Check if asset is live stream
+    if duration.flags.contains(.indefinite) {
+      videoInformation.duration = -1
+      videoInformation.isLive = true
+    } else {
+      videoInformation.duration = Int64(CMTimeGetSeconds(duration))
+      videoInformation.isLive = false
+    }
+
+    if let videoTrack = tracks(withMediaType: .video).first {
+      let size = videoTrack.naturalSize.applying(videoTrack.preferredTransform)
+      videoInformation.width = size.width
+      videoInformation.height = size.height
+
+      videoInformation.bitrate = Double(videoTrack.estimatedDataRate)
+
+      videoInformation.orientation = videoTrack.orientation
+
+      if #available(iOS 14.0, tvOS 14.0, visionOS 1.0, *) {
+        videoInformation.isHDR = videoTrack.hasMediaCharacteristic(.containsHDRVideo)
+      }
+    } else if url.pathExtension == "m3u8" {
+      // For HLS streams, we cannot get video track information directly
+      // So we download manifest and try to extract video information from it
+
+      let manifestContent = try await HLSManifestParser.downloadManifest(from: url)
+      let manifestInfo = try HLSManifestParser.parseM3U8Manifest(manifestContent)
+
+      if let videoStream = manifestInfo.streams.first {
+        videoInformation.width = Double(videoStream.width ?? Int(Double.nan))
+        videoInformation.height = Double(videoStream.height ?? Int(Double.nan))
+        videoInformation.bitrate = Double(videoStream.bandwidth ?? Int(Double.nan))
+      }
+
+      if videoInformation.width > 0 && videoInformation.height > 0 {
+        if videoInformation.width == videoInformation.height {
+          videoInformation.orientation = .square
+        } else if videoInformation.width > videoInformation.height {
+          videoInformation.orientation = .landscapeRight
+        } else if videoInformation.width < videoInformation.height {
+          videoInformation.orientation = .portrait
+        } else {
+          videoInformation.orientation = .unknown
+        }
+      }
+    }
+
+    return videoInformation
+  }
+}

package/ios/core/Extensions/NSObject+PerformIfResponds.swift

@@ -0,0 +1,30 @@
+//
+//  NSObject+PerformIfResponds.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 27/04/2025.
+//
+
+import Foundation
+
+extension NSObject {
+  // Safe perform methods for Objective-C selectors
+  
+  func performIfResponds(_ selector: Selector) {
+    if self.responds(to: selector) {
+      self.perform(selector)
+    }
+  }
+  
+  func performIfResponds(_ selector: Selector, with object: Any?) {
+    if self.responds(to: selector) {
+      self.perform(selector, with: object)
+    }
+  }
+  
+  func performIfResponds(_ selector: Selector, with object1: Any?, with object2: Any?) {
+    if self.responds(to: selector) {
+      self.perform(selector, with: object1, with: object2)
+    }
+  }
+}

package/ios/core/Extensions/ResizeMode+VideoGravity.swift

@@ -0,0 +1,24 @@
+//
+//  ResizeMode.swift
+//  ReactNativeVideo
+//
+//  Created for resizeMode feature
+//
+
+import Foundation
+import AVFoundation
+
+public extension ResizeMode {
+  func toVideoGravity() -> AVLayerVideoGravity {
+    switch self {
+      case .contain:
+        return .resizeAspect
+      case .cover:
+        return .resizeAspectFill
+      case .stretch:
+        return .resize
+      case .none:
+        return .resizeAspect // Default to aspect ratio if none specified
+    }
+  }
+}