capacitor-video-transcoder 0.0.0-stage → 0.0.1

package/ios/Tests/VideoTranscoderCoreTests/TranscoderTests.swift

@@ -0,0 +1,234 @@
+import AVFoundation
+import XCTest
+@testable import VideoTranscoderCore
+
+/// End to end: the fixtures in test/fixtures transcoded with AVFoundation, and the output read back. On a Mac with `swift test`
+/// this is the same AVAssetReader/AVAssetWriter path the phone takes, with the Mac's encoder instead of the phone's.
+final class TranscoderTests: XCTestCase {
+    static let fixtures = URL(fileURLWithPath: #filePath)
+        .deletingLastPathComponent() // VideoTranscoderCoreTests
+        .deletingLastPathComponent() // Tests
+        .deletingLastPathComponent() // ios
+        .deletingLastPathComponent() // the repository
+        .appendingPathComponent("test/fixtures")
+
+    var outputs: URL!
+
+    override func setUpWithError() throws {
+        outputs = FileManager.default.temporaryDirectory.appendingPathComponent("video-transcoder-tests-\(UUID().uuidString)")
+        try FileManager.default.createDirectory(at: outputs, withIntermediateDirectories: true)
+    }
+
+    override func tearDownWithError() throws {
+        try? FileManager.default.removeItem(at: outputs)
+    }
+
+    func fixture(_ name: String) -> URL { TranscoderTests.fixtures.appendingPathComponent(name) }
+
+    func testRotatedVideoWithPCMAudio() async throws {
+        let out = outputs.appendingPathComponent("rotated.mp4")
+        let progress = Recorder()
+        let outcome = try await Transcoder().transcode(
+            TranscodeOptions(source: fixture("rotated-pcm.mov"), destination: out),
+            progress: { progress.add($0) }
+        )
+        XCTAssertEqual(outcome.url, out)
+        // stored 320x240, shown upright as 240x320
+        XCTAssertEqual(outcome.width, 240)
+        XCTAssertEqual(outcome.height, 320)
+        XCTAssertEqual(Double(outcome.durationMs), 2000, accuracy: 100)
+        XCTAssertGreaterThan(outcome.size, 0)
+
+        let facts = try await Facts.read(out)
+        XCTAssertEqual(facts.videoCodec, kCMVideoCodecType_H264)
+        XCTAssertEqual(facts.avcProfile, 100, "H.264 High")
+        XCTAssertEqual(facts.storedSize, CGSize(width: 320, height: 240))
+        // the rotation is carried over as the track transform, unchanged
+        let source = try await Facts.read(fixture("rotated-pcm.mov"))
+        XCTAssertNotEqual(Geometry.rotationDegrees(of: source.transform), 0)
+        XCTAssertEqual(Geometry.rotationDegrees(of: facts.transform), Geometry.rotationDegrees(of: source.transform))
+        XCTAssertEqual(facts.primaries, kCMFormatDescriptionColorPrimaries_ITU_R_709_2 as String)
+        XCTAssertEqual(facts.transfer, kCMFormatDescriptionTransferFunction_ITU_R_709_2 as String)
+        XCTAssertEqual(facts.matrix, kCMFormatDescriptionYCbCrMatrix_ITU_R_709_2 as String)
+        XCTAssertEqual(facts.audioFormat, kAudioFormatMPEG4AAC)
+        XCTAssertEqual(facts.audioChannels, 2)
+        XCTAssertEqual(facts.audioSampleRate, 16_000)
+        XCTAssertEqual(facts.topLevelAtoms.filter { $0 == "moov" || $0 == "mdat" }, ["moov", "mdat"], "faststart")
+
+        let values = progress.values
+        XCTAssertEqual(values.last, 1)
+        XCTAssertEqual(values, values.sorted(), "progress only grows")
+        XCTAssertGreaterThan(values.count, 2)
+    }
+
+    func testHDRIsToneMappedAndAACIsCopied() async throws {
+        let out = outputs.appendingPathComponent("hdr.mp4")
+        let outcome = try await Transcoder().transcode(TranscodeOptions(source: fixture("hdr-hlg.mov"), destination: out))
+        XCTAssertEqual(outcome.width, 256)
+        XCTAssertEqual(outcome.height, 144)
+
+        let facts = try await Facts.read(out)
+        XCTAssertEqual(facts.videoCodec, kCMVideoCodecType_H264)
+        XCTAssertEqual(facts.primaries, kCMFormatDescriptionColorPrimaries_ITU_R_709_2 as String)
+        XCTAssertEqual(facts.transfer, kCMFormatDescriptionTransferFunction_ITU_R_709_2 as String)
+        XCTAssertEqual(facts.audioFormat, kAudioFormatMPEG4AAC)
+        XCTAssertEqual(facts.audioChannels, 1)
+        XCTAssertEqual(facts.audioSampleRate, 44_100)
+    }
+
+    func testScalesDownCutsAndAddsNoAudio() async throws {
+        let out = outputs.appendingPathComponent("nested/dir/silent.mp4")
+        let outcome = try await Transcoder().transcode(TranscodeOptions(
+            source: fixture("long-silent.mp4"), destination: out, maxSize: 320, maxDurationMs: 1500, videoBitrate: 200_000
+        ))
+        XCTAssertEqual(outcome.width, 320)
+        XCTAssertEqual(outcome.height, 180)
+        XCTAssertEqual(Double(outcome.durationMs), 1500, accuracy: 70)
+
+        let facts = try await Facts.read(out)
+        XCTAssertEqual(facts.storedSize, CGSize(width: 320, height: 180))
+        XCTAssertNil(facts.audioFormat)
+    }
+
+    func testReplacesAFileAtTheDestinationAndDefaultsToTheTemporaryDirectory() async throws {
+        let out = outputs.appendingPathComponent("taken.mp4")
+        try Data("not a video".utf8).write(to: out)
+        _ = try await Transcoder().transcode(TranscodeOptions(source: fixture("hdr-hlg.mov"), destination: out))
+        let replaced = try await Facts.read(out)
+        XCTAssertEqual(replaced.videoCodec, kCMVideoCodecType_H264)
+
+        let outcome = try await Transcoder().transcode(TranscodeOptions(source: fixture("hdr-hlg.mov")))
+        defer { try? FileManager.default.removeItem(at: outcome.url) }
+        XCTAssertTrue(outcome.url.path.hasPrefix(FileManager.default.temporaryDirectory.resolvingSymlinksInPath().path)
+            || outcome.url.path.hasPrefix(FileManager.default.temporaryDirectory.path))
+        XCTAssertEqual(outcome.url.pathExtension, "mp4")
+        XCTAssertTrue(FileManager.default.fileExists(atPath: outcome.url.path))
+    }
+
+    func testNotFoundAndNoVideo() async throws {
+        await assertFails(.notFound, TranscodeOptions(source: outputs.appendingPathComponent("missing.mov")))
+        await assertFails(.notFound, TranscodeOptions(source: outputs))
+        let text = outputs.appendingPathComponent("text.mov")
+        try Data("not a video".utf8).write(to: text)
+        let out = outputs.appendingPathComponent("never.mp4")
+        await assertFails(.noVideo, TranscodeOptions(source: text, destination: out))
+        XCTAssertFalse(FileManager.default.fileExists(atPath: out.path))
+    }
+
+    func testOneAtATimeAndCancel() async throws {
+        let transcoder = Transcoder()
+        let out = outputs.appendingPathComponent("cancelled.mp4")
+        let started = expectation(description: "progress")
+        started.assertForOverFulfill = false
+        let first = Task {
+            try await transcoder.transcode(TranscodeOptions(source: fixture("long-silent.mp4"), destination: out)) { _ in
+                started.fulfill()
+            }
+        }
+        await fulfillment(of: [started], timeout: 30)
+        await assertFails(.busy, TranscodeOptions(source: fixture("hdr-hlg.mov")), with: transcoder)
+        transcoder.cancel()
+        do {
+            _ = try await first.value
+            // a fast machine can finish the clip before the cancel lands; then there is nothing to check
+        } catch {
+            XCTAssertEqual((error as? TranscodeError)?.code, .cancelled)
+            XCTAssertFalse(FileManager.default.fileExists(atPath: out.path), "a cancelled transcode leaves no file")
+        }
+        // and the transcoder is free again
+        _ = try await transcoder.transcode(TranscodeOptions(source: fixture("hdr-hlg.mov"), destination: out))
+        transcoder.cancel() // with nothing running, nothing happens
+    }
+
+    func assertFails(
+        _ code: TranscodeErrorCode,
+        _ options: TranscodeOptions,
+        with transcoder: Transcoder = Transcoder(),
+        line: UInt = #line
+    ) async {
+        do {
+            _ = try await transcoder.transcode(options)
+            XCTFail("expected \(code.rawValue)", line: line)
+        } catch {
+            XCTAssertEqual((error as? TranscodeError)?.code, code, "\(error)", line: line)
+        }
+    }
+}
+
+final class Recorder: @unchecked Sendable {
+    private let lock = NSLock()
+    private var list: [Double] = []
+    func add(_ value: Double) {
+        lock.lock()
+        list.append(value)
+        lock.unlock()
+    }
+    var values: [Double] {
+        lock.lock()
+        defer { lock.unlock() }
+        return list
+    }
+}
+
+/// What a written MP4 says about itself, read with AVFoundation and from its top-level boxes.
+struct Facts {
+    var videoCodec: FourCharCode?
+    var avcProfile: UInt8?
+    var storedSize = CGSize.zero
+    var transform = CGAffineTransform.identity
+    var primaries: String?
+    var transfer: String?
+    var matrix: String?
+    var audioFormat: AudioFormatID?
+    var audioChannels: UInt32?
+    var audioSampleRate: Float64?
+    var topLevelAtoms: [String] = []
+
+    static func read(_ url: URL) async throws -> Facts {
+        var facts = Facts()
+        let asset = AVURLAsset(url: url)
+        if let video = try await asset.loadTracks(withMediaType: .video).first {
+            facts.storedSize = try await video.load(.naturalSize)
+            facts.transform = try await video.load(.preferredTransform)
+            if let description = try await video.load(.formatDescriptions).first {
+                facts.videoCodec = CMFormatDescriptionGetMediaSubType(description)
+                let extensions = CMFormatDescriptionGetExtensions(description) as? [String: Any] ?? [:]
+                facts.primaries = extensions[kCMFormatDescriptionExtension_ColorPrimaries as String] as? String
+                facts.transfer = extensions[kCMFormatDescriptionExtension_TransferFunction as String] as? String
+                facts.matrix = extensions[kCMFormatDescriptionExtension_YCbCrMatrix as String] as? String
+                let atoms = extensions[kCMFormatDescriptionExtension_SampleDescriptionExtensionAtoms as String] as? [String: Any]
+                if let avcC = atoms?["avcC"] as? Data, avcC.count > 1 {
+                    facts.avcProfile = avcC[avcC.startIndex + 1]
+                }
+            }
+        }
+        if let audio = try await asset.loadTracks(withMediaType: .audio).first,
+           let description = try await audio.load(.formatDescriptions).first,
+           let basic = CMAudioFormatDescriptionGetStreamBasicDescription(description)?.pointee {
+            facts.audioFormat = basic.mFormatID
+            facts.audioChannels = basic.mChannelsPerFrame
+            facts.audioSampleRate = basic.mSampleRate
+        }
+        facts.topLevelAtoms = try topLevelAtoms(url)
+        return facts
+    }
+
+    static func topLevelAtoms(_ url: URL) throws -> [String] {
+        let data = try Data(contentsOf: url)
+        var atoms: [String] = []
+        var offset = 0
+        while offset + 8 <= data.count {
+            var size = data[offset..<offset + 4].reduce(0) { $0 << 8 | UInt64($1) }
+            let type = String(decoding: data[offset + 4..<offset + 8], as: UTF8.self)
+            if size == 1, offset + 16 <= data.count {
+                size = data[offset + 8..<offset + 16].reduce(0) { $0 << 8 | UInt64($1) }
+            } else if size == 0 {
+                size = UInt64(data.count - offset)
+            }
+            atoms.append(type)
+            guard size >= 8 else { break }
+            offset += Int(size)
+        }
+        return atoms
+    }
+}

package/ios/Tests/VideoTranscoderPluginTests/VideoTranscoderPluginTests.swift

@@ -0,0 +1,32 @@
+import XCTest
+@testable import VideoTranscoderPlugin
+import VideoTranscoderCore
+
+/// The bridge side of the plugin: its name and methods, and how a call's options and a finished transcode cross the bridge. The
+/// transcoding itself is tested in VideoTranscoderCoreTests, which also run on a Mac without a simulator.
+final class VideoTranscoderPluginTests: XCTestCase {
+    func testRegistersTheMethodsOfTheTypeScriptAPI() {
+        let plugin = VideoTranscoderPlugin()
+        XCTAssertEqual(plugin.jsName, "VideoTranscoder")
+        XCTAssertEqual(plugin.pluginMethods.map(\.name), ["transcode", "cancel"])
+    }
+
+    func testKeepsTheStringKeysOfTheCallOptions() {
+        let raw = VideoTranscoderPlugin.raw(["source": "/a.mov", "maxSize": 640, 1: "dropped"])
+        XCTAssertEqual(raw.count, 2)
+        XCTAssertEqual(try TranscodeOptions.parse(raw).maxSize, 640)
+    }
+
+    func testResultCarriesEveryFieldOfTheTypeScriptResult() {
+        let url = URL(fileURLWithPath: "/tmp/out put.mp4")
+        let result = VideoTranscoderPlugin.result(
+            TranscodeOutcome(url: url, width: 720, height: 1280, durationMs: 3000, size: 12345)
+        )
+        XCTAssertEqual(result["path"] as? String, "/tmp/out put.mp4")
+        XCTAssertEqual(result["uri"] as? String, "file:///tmp/out%20put.mp4")
+        XCTAssertEqual(result["width"] as? Int, 720)
+        XCTAssertEqual(result["height"] as? Int, 1280)
+        XCTAssertEqual(result["durationMs"] as? Int, 3000)
+        XCTAssertEqual(result["size"] as? Int, 12345)
+    }
+}

package/package.json

@@ -1,6 +1,103 @@
 {
   "name": "capacitor-video-transcoder",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.1",
+  "description": "Transcode a video into an MP4 that web browsers play, on iOS and Android, from a Capacitor app",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Sources",
+    "ios/Tests",
+    "Package.swift",
+    "CapacitorVideoTranscoder.podspec"
+  ],
+  "author": "Maxim Belov",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MaximBelov/capacitor-video-transcoder.git"
+  },
+  "bugs": {
+    "url": "https://github.com/MaximBelov/capacitor-video-transcoder/issues"
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native",
+    "video",
+    "transcode",
+    "mp4",
+    "h264",
+    "compress",
+    "ffmpeg alternative",
+    "media3",
+    "avfoundation"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "xcodebuild build -scheme CapacitorVideoTranscoder -destination generic/platform=iOS -derivedDataPath build/ios-device",
+    "verify:android": "cd android && ./gradlew clean build test",
+    "verify:web": "npm run build",
+    "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
+    "eslint": "eslint . --ext ts",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api VideoTranscoderPlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build",
+    "test": "npm run test:unit",
+    "test:unit": "vitest run",
+    "test:unit:coverage": "vitest run --coverage",
+    "test:android": "cd android && ./gradlew test",
+    "test:core": "swift test --package-path ios",
+    "test:ios": "./scripts/test-ios.sh",
+    "fixtures": "./test/fixtures/make-fixtures.sh",
+    "example:install": "cd example-app && npm install --no-audit --no-fund",
+    "example:android:build": "npm run example:install && cd example-app && npm run build && npx cap sync android && cd android && ./gradlew assembleDebug",
+    "example:ios:build": "npm run example:install && cd example-app && npm run build && npx cap sync ios && xcodebuild build -project ios/App/App.xcodeproj -scheme App -destination generic/platform=iOS\\ Simulator -derivedDataPath ../build/example-ios CODE_SIGNING_ALLOWED=NO"
+  },
+  "devDependencies": {
+    "@capacitor/android": "^8.0.0",
+    "@capacitor/core": "^8.0.0",
+    "@capacitor/docgen": "^0.3.1",
+    "@capacitor/ios": "^8.0.0",
+    "@ionic/eslint-config": "^0.4.0",
+    "@ionic/prettier-config": "^4.0.0",
+    "@ionic/swiftlint-config": "^2.0.0",
+    "@vitest/coverage-v8": "^4.1.12",
+    "eslint": "^8.57.1",
+    "prettier": "^3.6.2",
+    "prettier-plugin-java": "^2.7.7",
+    "rimraf": "^6.1.0",
+    "rollup": "^4.53.2",
+    "swiftlint": "^2.0.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.12"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=8.0.0"
+  },
+  "prettier": "@ionic/prettier-config",
+  "swiftlint": "@ionic/swiftlint-config",
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}