@stepincto/expo-video 2.2.2-sicto.0

package/ios/Records/DRMOptions.swift

@@ -0,0 +1,24 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+import Foundation
+import ExpoModulesCore
+
+internal struct DRMOptions: Record {
+  @Field
+  var type: DRMType = .fairplay
+
+  @Field
+  var licenseServer: String?
+
+  @Field
+  var headers: [String: Any]?
+
+  @Field
+  var contentId: String?
+
+  @Field
+  var certificateUrl: URL?
+
+  @Field
+  var base64CertificateData: String?
+}

package/ios/Records/PlaybackError.swift

@@ -0,0 +1,10 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+import Foundation
+import ExpoModulesCore
+
+internal struct PlaybackError: Record {
+  @Field
+  // swiftlint:disable:next redundant_optional_initialization - Initialization with nil is necessary
+  var message: String? = nil
+}

package/ios/Records/Tracks.swift

@@ -0,0 +1,176 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+import AVKit
+
+// swiftlint:disable redundant_optional_initialization - Initialization with nil is necessary
+internal struct SubtitleTrack: Record {
+  @Field
+  var language: String? = nil
+
+  @Field
+  var label: String? = nil
+
+  static func from(mediaSelectionOption option: AVMediaSelectionOption) -> SubtitleTrack? {
+    guard let identifier = option.locale?.identifier else {
+      return nil
+    }
+
+    return SubtitleTrack(language: identifier, label: option.displayName)
+  }
+}
+
+internal struct AudioTrack: Record {
+  @Field var language: String? = nil
+  @Field var label: String? = nil
+
+  static func from(mediaSelectionOption option: AVMediaSelectionOption) -> AudioTrack? {
+    guard let identifier = option.locale?.identifier else {
+      return nil
+    }
+
+    return AudioTrack(language: identifier, label: option.displayName)
+  }
+}
+
+internal struct VideoTrack: Record, Equatable {
+  @Field var id: String? = nil
+  @Field var size: VideoSize? = nil
+  @Field var mimeType: String? = nil
+  @Field var bitrate: Int? = nil
+  @Field var isSupported: Bool = true
+  @Field var frameRate: Float? = nil
+
+  static func == (lhs: VideoTrack, rhs: VideoTrack) -> Bool {
+    guard lhs.id != nil, rhs.id != nil else {
+      return false
+    }
+    return lhs.id == rhs.id
+  }
+
+  static func from(assetTrack: AVAssetTrack) async -> VideoTrack {
+    var bitrate: Int?
+    var size: VideoSize?
+    let supported = (try? await assetTrack.load(.isPlayable)) ?? true
+    let mediaFormat = try? await assetTrack.mediaFormat
+    let frameRate = try? await assetTrack.load(.nominalFrameRate)
+
+    if let bitrateFloat = try? await assetTrack.load(.estimatedDataRate) {
+      bitrate = Int(bitrateFloat)
+    }
+    if let cgSize = try? await assetTrack.load(.naturalSize) {
+      size = VideoSize.from(cgSize)
+    }
+
+    return VideoTrack(id: "\(assetTrack.trackID)", size: size, mimeType: mediaFormat, bitrate: bitrate, isSupported: supported, frameRate: frameRate)
+  }
+
+  static func from(hlsHeaderLine: String, idLine: String) -> VideoTrack? {
+    // The minimum information we require from a video track is it's resolution
+    guard hlsHeaderLine.starts(with: "#EXT-X-STREAM-INF"), hlsHeaderLine.contains("RESOLUTION") else {
+      return nil
+    }
+    // The information about the track is separated with ,
+    let details = hlsHeaderLine.split(separator: ",")
+      .reduce(into: [String: String]()) { dict, detail in
+        let pair = detail.split(separator: "=", maxSplits: 1).map {
+          String($0).trimmingCharacters(in: .whitespacesAndNewlines)
+        }
+        if pair.count == 2 {
+          let (key, value) = (pair[0], pair[1])
+          // Remove possible double quotes
+          dict[key] = value.trimmingCharacters(in: CharacterSet(charactersIn: "\""))
+        }
+      }
+    guard let resolution = details["RESOLUTION"] else {
+      return nil
+    }
+
+    let dimensions = resolution.split(separator: "x").map { Int($0) }
+    guard dimensions.count == 2, let width = dimensions[0], let height = dimensions[1] else {
+      return nil
+    }
+
+    let size = VideoSize(width: width, height: height)
+    let mimeType = codecsToMimeType(codecs: details["CODECS"])
+    var bitrate: Int? = nil
+    var frameRate: Float? = nil
+
+    // Use the default Andorid behavior for reporting the bitrate
+    if let bitrateString = details["BANDWIDTH"] ?? details["AVERAGE-BANDWIDTH"] {
+      bitrate = Int(bitrateString)
+    }
+    if let frameRateString = details["FRAME-RATE"] {
+      frameRate = Float(frameRateString)
+    }
+
+    return VideoTrack(id: idLine, size: size, mimeType: mimeType, bitrate: bitrate, frameRate: frameRate)
+  }
+
+  // I'm not aware of any built in conversion functions. For HLS sources we only need to worry about a few formats though.
+  // https://developer.apple.com/documentation/http-live-streaming/hls-authoring-specification-for-apple-devices#:~:text=1.1.%20All%20video%20MUST%20be%20encoded%20using%20H.264/AVC%2C%20HEVC/H.265%2C%20Dolby%20Vision%2C%20or%20AV1.
+  private static func codecsToMimeType(codecs: String?) -> String? {
+    guard let codecs else {
+      return nil
+    }
+    if codecs.starts(with: "avc1") {
+      return "video/avc"
+    }
+    if codecs.starts(with: "hvc1") {
+      return "video/hevc"
+    }
+    if codecs.starts(with: "dvh1") {
+      return "video/dolby-vision"
+    }
+    if codecs.starts(with: "av11") {
+      return "video/av1"
+    }
+    return nil // Unknown codec
+  }
+}
+// swiftlint:enable redundant_optional_initialization
+
+// https://developer.apple.com/documentation/avfoundation/avpartialasyncproperty/formatdescriptions
+private extension AVAssetTrack {
+  var mediaFormat: String {
+    get async throws {
+      var format = ""
+      let descriptions = try await load(.formatDescriptions)
+      for (index, formatDesc) in descriptions.enumerated() {
+        let subType = CMFormatDescriptionGetMediaSubType(formatDesc).toString()
+
+        // The reported subType is different for iOS and Android, ideally they should be the same
+        let correctedSubType: String
+        switch subType {
+        case "avc1": // H264 videos
+          correctedSubType = "avc"
+        case "hev1": // H265 videos
+          correctedSubType = "hevc"
+        default:
+          correctedSubType = subType
+        }
+        format += "video/\(correctedSubType)"
+        if index < descriptions.count - 1 {
+          format += ","
+        }
+      }
+      return format
+    }
+  }
+}
+
+private extension FourCharCode {
+  // Create a string representation of a FourCC.
+  func toString() -> String {
+    let bytes: [CChar] = [
+      CChar((self >> 24) & 0xff),
+      CChar((self >> 16) & 0xff),
+      CChar((self >> 8) & 0xff),
+      CChar(self & 0xff),
+      0
+    ]
+    let result = String(cString: bytes)
+    let characterSet = CharacterSet.whitespaces
+    return result.trimmingCharacters(in: characterSet)
+  }
+}

package/ios/Records/VideoEventPayloads.swift

@@ -0,0 +1,76 @@
+import Foundation
+import ExpoModulesCore
+
+// swiftlint:disable redundant_optional_initialization - Initialization with nil is necessary
+internal struct StatusChangedEventPayload: Record {
+  @Field var status: PlayerStatus = .idle
+  @Field var oldStatus: PlayerStatus? = nil
+  @Field var error: PlaybackError? = nil
+}
+
+internal struct IsPlayingEventPayload: Record {
+  @Field var isPlaying: Bool = false
+  @Field var oldIsPlaying: Bool? = nil
+}
+
+internal struct VolumeChangedEventPayload: Record {
+  @Field var volume: Float = 1
+  @Field var oldVolume: Float? = nil
+}
+
+internal struct MutedChangedEventPayload: Record {
+  @Field var muted: Bool = false
+  @Field var oldMuted: Bool? = nil
+}
+
+internal struct SourceChangedEventPayload: Record {
+  @Field var source: VideoSource? = nil
+  @Field var oldSource: VideoSource? = nil
+}
+
+internal struct PlaybackRateChangedEventPayload: Record {
+  @Field var playbackRate: Float = 1
+  @Field var oldPlaybackRate: Float? = nil
+}
+
+internal struct SubtitleTracksChangedEventPayload: Record {
+  @Field var availableSubtitleTracks: [SubtitleTrack] = []
+  @Field var oldAvailableSubtitleTracks: [SubtitleTrack] = []
+}
+
+internal struct SubtitleTrackChangedEventPayload: Record {
+  @Field var subtitleTrack: SubtitleTrack? = nil
+  @Field var oldSubtitleTrack: SubtitleTrack? = nil
+}
+
+internal struct AudioTracksChangedEventPayload: Record {
+  @Field var availableAudioTracks: [AudioTrack] = []
+  @Field var oldAvailableAudioTracks: [AudioTrack] = []
+}
+
+internal struct AudioTrackChangedEventPayload: Record {
+  @Field var audioTrack: AudioTrack? = nil
+  @Field var oldAudioTrack: AudioTrack? = nil
+}
+
+internal struct TimeUpdate: Record {
+  @Field var currentTime: Double = 0
+  @Field var currentLiveTimestamp: Double? = nil
+  @Field var currentOffsetFromLive: Double? = nil
+  @Field var bufferedPosition: Double = -1
+}
+
+internal struct  VideoTrackChangedEventPayload: Record {
+  @Field var videoTrack: VideoTrack? = nil
+  @Field var oldVideoTrack: VideoTrack? = nil
+}
+
+internal struct VideoSourceLoadedEventPayload: Record {
+  @Field var videoSource: VideoSource? = nil
+  @Field var duration: Double? = nil
+  @Field var availableVideoTracks: [VideoTrack]? = nil
+  @Field var availableSubtitleTracks: [SubtitleTrack]? = nil
+  @Field var availableAudioTracks: [AudioTrack]? = nil
+}
+
+// swiftlint:enable redundant_optional_initialization

package/ios/Records/VideoMetadata.swift

@@ -0,0 +1,16 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+
+// swiftlint:disable redundant_optional_initialization - Initialization with nil is necessary
+internal struct VideoMetadata: Record {
+  @Field
+  var title: String? = nil
+
+  @Field
+  var artist: String? = nil
+
+  @Field
+  var artwork: URL? = nil
+}
+// swiftlint:enable redundant_optional_initialization

package/ios/Records/VideoSize.swift

@@ -0,0 +1,15 @@
+import ExpoModulesCore
+
+// swiftlint:disable redundant_optional_initialization - Initialization with nil is necessary
+internal struct VideoSize: Record {
+  @Field
+  var width: Int? = nil
+
+  @Field
+  var height: Int? = nil
+
+  static func from(_ size: CGSize) -> Self {
+    return VideoSize(width: Int(size.width), height: Int(size.height))
+  }
+}
+// swiftlint:enable redundant_optional_initialization

package/ios/Records/VideoSource.swift

@@ -0,0 +1,25 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+
+// swiftlint:disable redundant_optional_initialization - Initialization with nil is necessary
+internal struct VideoSource: Record {
+  @Field
+  var uri: URL? = nil
+
+  @Field
+  var drm: DRMOptions? = nil
+
+  @Field
+  var metadata: VideoMetadata? = nil
+
+  @Field
+  var headers: [String: String]? = nil
+
+  @Field
+  var useCaching: Bool = false
+
+  @Field
+  var contentType: ContentType = .auto
+}
+// swiftlint:enable redundant_optional_initialization

package/ios/Thumbnails/VideoThumbnail.swift

@@ -0,0 +1,27 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+import CoreImage
+import CoreGraphics
+import ExpoModulesCore
+
+internal final class VideoThumbnail: SharedRef<UIImage> {
+  internal override var nativeRefType: String {
+    "image"
+  }
+
+  var requestedTime: CMTime
+  var actualTime: CMTime
+
+  internal init(_ image: CGImage, requestedTime: CMTime, actualTime: CMTime) {
+    self.requestedTime = requestedTime
+    self.actualTime = actualTime
+    super.init(UIImage(cgImage: image))
+  }
+
+  override func getAdditionalMemoryPressure() -> Int {
+    guard let cgImage = ref.cgImage else {
+      return 0
+    }
+    return cgImage.bytesPerRow * cgImage.height
+  }
+}

package/ios/Thumbnails/VideoThumbnailGenerator.swift

@@ -0,0 +1,68 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+import AVFoundation
+import CoreMedia
+
+/**
+ Generates an array of thumbnails from the given assets and options.
+ */
+internal func generateThumbnails(asset: AVAsset, times: [CMTime], options: VideoThumbnailOptions?) async throws -> [VideoThumbnail] {
+  let generator = AVAssetImageGenerator(asset: asset)
+
+  generator.appliesPreferredTrackTransform = true
+  generator.requestedTimeToleranceAfter = .zero
+  generator.maximumSize = options?.getMaxSize() ?? .zero
+
+  // `requestedTimeToleranceBefore` can only be set if times are less
+  // than the video duration, otherwise it will fail to generate an image.
+  if times.allSatisfy({ $0 < asset.duration }) {
+    generator.requestedTimeToleranceBefore = .zero
+  }
+  return try await generateThumbnails(generator: generator, times: times)
+}
+
+/**
+ Generates an array of thumbnails using the given image generator. It uses two different ways to generate the images, based on the platform version.
+ */
+private func generateThumbnails(generator: AVAssetImageGenerator, times: [CMTime]) async throws -> [VideoThumbnail] {
+  if #available(iOS 16, tvOS 16, *) {
+    return try await generator
+      .images(for: times)
+      .reduce(into: [VideoThumbnail]()) { thumbnails, result in
+        let thumbnail = try VideoThumbnail(result.image, requestedTime: result.requestedTime, actualTime: result.actualTime)
+        thumbnails.append(thumbnail)
+      }
+  }
+  return try await VideoThumbnailLegacyGenerator(generator: generator, times: times)
+    .reduce(into: [VideoThumbnail]()) { thumbnails, thumbnail in
+      thumbnails.append(thumbnail)
+    }
+}
+
+/**
+ A replacement for the `AVAssetImageGenerator.images(for:)` async iterator that is available only as of iOS 16.
+ */
+internal struct VideoThumbnailLegacyGenerator: AsyncSequence, AsyncIteratorProtocol {
+  typealias Element = VideoThumbnail
+
+  let generator: AVAssetImageGenerator
+  let times: [CMTime]
+  var currentIndex: Int = 0
+
+  mutating func next() async throws -> Element? {
+    guard currentIndex < times.count, !Task.isCancelled else {
+      return nil
+    }
+    let requestedTime = times[currentIndex]
+    var actualTime = CMTime.zero
+    let image = try generator.copyCGImage(at: requestedTime, actualTime: &actualTime)
+
+    currentIndex += 1
+
+    return VideoThumbnail(image, requestedTime: requestedTime, actualTime: actualTime)
+  }
+
+  func makeAsyncIterator() -> Self {
+    return self
+  }
+}

package/ios/Thumbnails/VideoThumbnailOptions.swift

@@ -0,0 +1,15 @@
+import ExpoModulesCore
+
+/**
+ Record representing thumbnail generation options.
+ */
+internal struct VideoThumbnailOptions: Record {
+  static let `default` = VideoThumbnailOptions()
+
+  @Field var maxWidth: Int = 0
+  @Field var maxHeight: Int = 0
+
+  func getMaxSize() -> CGSize {
+    return CGSize(width: maxWidth, height: maxHeight)
+  }
+}

package/ios/VideoAsset.swift

@@ -0,0 +1,123 @@
+import Foundation
+import AVFoundation
+import CryptoKit
+import MobileCoreServices
+import ExpoModulesCore
+
+internal class VideoAsset: AVURLAsset, @unchecked Sendable {
+  internal let videoSource: VideoSource
+  private var resourceLoaderDelegate: ResourceLoaderDelegate?
+  private let initialScheme: String?
+  private let saveFilePath: String?
+  private var customFileExtension: String?
+  private let useCaching: Bool
+
+  var cachingError: Error?
+
+  internal var urlRequestHeaders: [String: String]?
+
+  init(url: URL, videoSource: VideoSource) {
+    self.videoSource = videoSource
+    let cachedMimeType = MediaInfo(forResourceUrl: url)?.mimeType
+    let cachedExtension = mimeTypeToExtension(mimeType: cachedMimeType) ?? ""
+    let fileExtension = url.pathExtension.isEmpty ? cachedExtension : url.pathExtension
+    self.saveFilePath = Self.pathForUrl(url: url, fileExtension: fileExtension)
+    self.urlRequestHeaders = videoSource.headers
+    self.initialScheme = URLComponents(url: url, resolvingAgainstBaseURL: false)?.scheme
+
+    // Creates an URL that will delegate it's requests to ResourceLoaderDelegate
+    let urlWithCustomScheme = url.withScheme(VideoCacheManager.expoVideoCacheScheme)
+
+    let assetOptions: [String: Any]? = if let headers = videoSource.headers {
+      ["AVURLAssetHTTPHeaderFieldsKey": headers]
+    } else {
+      nil
+    }
+
+    let canCache = Self.canCache(videoSource: videoSource)
+
+    if saveFilePath == nil && videoSource.useCaching {
+      log.warn("Failed to create a cache file path for the provided source with uri: \(videoSource.uri?.absoluteString ?? "null")")
+    }
+
+    if !canCache && videoSource.useCaching {
+      log.warn("Provided source with uri: \(videoSource.uri?.absoluteString ?? "null") cannot be cached. Caching will be disabled")
+    }
+
+    if urlWithCustomScheme == nil && videoSource.useCaching {
+      log.warn("CachingPlayerItem error: Urls without a scheme are not supported, the resource won't be cached")
+    }
+
+    guard let saveFilePath, let urlWithCustomScheme, videoSource.useCaching else {
+      // Initialize with no caching
+      useCaching = false
+      super.init(url: url, options: assetOptions)
+      return
+    }
+
+    // Enable caching
+    useCaching = true
+    resourceLoaderDelegate = ResourceLoaderDelegate(url: url, saveFilePath: saveFilePath, fileExtension: fileExtension, urlRequestHeaders: urlRequestHeaders)
+    super.init(url: urlWithCustomScheme, options: assetOptions)
+
+    resourceLoaderDelegate?.onError = { [weak self] error in
+      self?.cachingError = error
+    }
+    self.resourceLoader.setDelegate(resourceLoaderDelegate, queue: VideoCacheManager.shared.cacheQueue)
+    self.createCacheDirectoryIfNeeded()
+    VideoCacheManager.shared.ensureCacheIntegrity(forSavePath: saveFilePath)
+  }
+
+  deinit {
+    guard useCaching else {
+      return
+    }
+    if let saveFilePath, let cachedFileUrl = URL(string: saveFilePath) {
+      VideoCacheManager.shared.unregisterOpenFile(at: cachedFileUrl)
+    }
+    VideoCacheManager.shared.ensureCacheSize()
+  }
+
+  static func pathForUrl(url: URL, fileExtension: String) -> String? {
+    let hashedData = SHA256.hash(data: Data(url.absoluteString.utf8))
+    let hashString = hashedData.compactMap { String(format: "%02x", $0) }.joined()
+    let parsedExtension = fileExtension.starts(with: ".") || fileExtension.isEmpty ? fileExtension : ("." + fileExtension)
+    let hashFilename = hashString + parsedExtension
+
+    guard var cachesDirectory = try? FileManager.default.url(
+      for: .cachesDirectory,
+      in: .userDomainMask,
+      appropriateFor: nil,
+      create: true)
+    else {
+      log.warn("CachingPlayerItem error: Can't access default cache directory")
+      return nil
+    }
+
+    cachesDirectory.appendPathComponent(VideoCacheManager.expoVideoCacheScheme, isDirectory: true)
+    cachesDirectory.appendPathComponent(hashFilename)
+
+    return cachesDirectory.path
+  }
+
+  static func canCache(videoSource: VideoSource) -> Bool {
+    guard videoSource.uri?.scheme?.starts(with: "http") == true else {
+      return false
+    }
+    return videoSource.drm == nil
+  }
+
+  private func createCacheDirectoryIfNeeded() {
+    guard var cachesDirectory = try? FileManager.default.url(
+      for: .cachesDirectory,
+      in: .userDomainMask,
+      appropriateFor: nil,
+      create: true)
+    else {
+      return
+    }
+
+    cachesDirectory.appendPathComponent(VideoCacheManager.expoVideoCacheScheme, isDirectory: true)
+    try? FileManager.default.createDirectory(at: cachesDirectory, withIntermediateDirectories: true)
+  }
+}

package/ios/VideoExceptions.swift

@@ -0,0 +1,53 @@
+// Copyright 2023-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+
+private let defaultCause = "unknown cause"
+
+internal final class PictureInPictureUnsupportedException: Exception {
+  override var reason: String {
+    "Picture in picture is not supported on this device"
+  }
+}
+
+internal final class DRMUnsupportedException: GenericException<DRMType> {
+  override var reason: String {
+    "DRMType: `\(param)` is unsupported on iOS"
+  }
+}
+
+internal final class DRMLoadException: GenericException<String?> {
+  override var reason: String {
+    "Failed to decrypt the video stream: \(param ?? defaultCause)"
+  }
+}
+
+internal final class PlayerException: GenericException<String?> {
+  override var reason: String {
+    "Failed to initialise the player: \(param ?? defaultCause)"
+  }
+}
+
+internal final class PlayerItemLoadException: GenericException<String?> {
+  override var reason: String {
+    "Failed to load the player item: \(param ?? defaultCause)"
+  }
+}
+
+internal final class CachingAssetInitializationException: GenericException<URL?> {
+  override var reason: String {
+    "Failed to initialize a caching asset. The provided url: \(param?.absoluteString ?? "nil") doesn't have a valid scheme for caching"
+  }
+}
+
+internal final class VideoCacheException: GenericException<String?> {
+  override var reason: String {
+    param ?? "Unexpected expo-video cache error"
+  }
+}
+
+internal final class VideoCacheUnsupportedFormatException: GenericException<String> {
+  override var reason: String {
+    "The server responded with a resource with mimeType: \(param) which cannot be played with caching enabled"
+  }
+}

package/ios/VideoItem.swift

@@ -0,0 +1,11 @@
+// Copyright 2023-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+
+internal final class VideoItem: SharedObject {
+  let playerItem: AVPlayerItem
+
+  init(url: URL) {
+    playerItem = AVPlayerItem(url: url)
+  }
+}