@breakside/jskit 2023.40.0 → 2023.44.0

package/Root/Frameworks/MediaKit/QuickTime/MKQuickTimeAtom.js

@@ -0,0 +1,157 @@
+// #import Foundation
+"use strict";
+
+(function(){
+
+var logger = JSLog("medikit", "quicktime");
+
+JSClass("MKQuickTimeAtom", JSObject, {
+
+    type: null,
+    atoms: null,
+    data: null,
+    dataView: null,
+
+    initWithData: function(data){
+        if (data.length < 8){
+            throw new Error("Expecting at least 8 bytes for every atom");
+        }
+        this.atoms = [];
+        this.data = data;
+        this.dataView = data.dataView();
+        this.type = this.dataView.getUint32(4);
+    },
+
+    readAtoms: function(offset){
+        if (offset === undefined){
+            offset = 0;
+        }
+        var i = offset;
+        var l = this.data.length;
+        var size;
+        var type;
+        var a, b;
+        var atomClass, atom;
+        while (i < l - 8){
+            size = this.dataView.getUint32(i);
+            type = this.dataView.getUint32(i + 4);
+            if (size === 0x00000001){
+                if (i < l - 16){
+                    a = this.dataView.getUint32(i + 8);
+                    b = this.dataView.getUint32(i + 12);
+                    size = Math.pow(2, 32) * a + b;
+                    if (size > Number.MAX_SAFE_INTEGER){
+                        throw new Error("cannot retain full precision of 64 bit integer for atom at byte %d".sprintf(i));
+                    }
+                }
+            }else{
+                if (size === 0x00000000){
+                    size = l - i;
+                }
+            }
+            if (i + size > l){
+                throw new Error("invalid size for atom at byte %d, extends beyond file size".sprintf(i));
+            }
+            atomClass = this.classForAtomType(type);
+            atom = atomClass.initWithData(this.data.subdataInRange(JSRange(i, size)));
+            this.atoms.push(atom);
+            i += size;
+        }
+        if (i !== l){
+            logger.warn("unused bytes at end of atom");
+        }
+    },
+
+    classesByAtomType: JSLazyInitProperty(function(){ return {};}),
+
+    registerAtomClass: function(atomClass){
+        this.classesByAtomType[atomClass.prototype.type] = atomClass;
+    },
+
+    classForAtomType: function(type){
+        var atomClass = this.classesByAtomType[type];
+        if (atomClass === undefined){
+            atomClass = MKQuickTimeAtom;
+        }
+        return atomClass;
+    },
+
+    atomOfType: function(type){
+        var i, l;
+        for (i = 0, l = this.atoms.length; i < l; ++i){
+            if (this.atoms[i].type === type){
+                return this.atoms[i];
+            }
+        }
+        return null;
+    },
+
+    atomsOfType: function(type){
+        var i, l;
+        var atoms = [];
+        for (i = 0, l = this.atoms.length; i < l; ++i){
+            if (this.atoms[i].type === type){
+                atoms.push(this.atoms[i]);
+            }
+        }
+        return atoms;
+    },
+
+    dictionaryRepresentation: function(){
+        return {
+            type: MKQuickTimeAtom.stringForType(this.type),
+        };
+    },
+
+    debugRepresentation: function(){
+        var dictionary = this.dictionaryRepresentation();
+        if (this.atoms.length > 0){
+            dictionary.atoms = [];
+            var i, l;
+            for (i = 0, l = this.atoms.length; i < l; ++i){
+                dictionary.atoms.push(this.atoms[i].debugRepresentation());
+            }
+        }
+        return dictionary;
+    }
+
+});
+
+MKQuickTimeAtom.Type = {
+    ftyp: 0x66747970,
+    moov: 0x6d6f6f76,
+    mvhd: 0x6d766864,
+    trak: 0x7472616b,
+    tkhd: 0x746b6864,
+    mdia: 0x6d646961,
+    mdhd: 0x6d646864,
+    hdlr: 0x68646c72,
+    minf: 0x6d696e66,
+    vmhd: 0x766d6864,
+    stbl: 0x7374626c,
+    stts: 0x73747473,
+    stsd: 0x73747364,
+    udta: 0x75647461,
+    meta: 0x6d657461
+};
+
+MKQuickTimeAtom.stringForType = function(type){
+    var bytes = [
+        (type & 0xFF000000) >>> 24,
+        (type & 0x00FF0000) >>> 16,
+        (type & 0x0000FF00) >>> 8,
+        (type & 0x000000FF)
+    ];
+    return JSData.initWithArray(bytes).stringByDecodingLatin1();
+};
+
+MKQuickTimeAtom.stringsForTypes = function(types){
+    var strings = [];
+    var i, l;
+    for (i = 0, l = types.length; i < l; ++i){
+        strings.push(MKQuickTimeAtom.stringForType(types[i]));
+    }
+    return strings;
+};
+
+})();

package/Root/Frameworks/MediaKit/QuickTime/MKQuickTimeFileType.js

@@ -0,0 +1,45 @@
+// #import "MKQuickTimeAtom.js"
+"use strict";
+
+(function(){
+
+var logger = JSLog("medikit", "quicktime");
+
+JSClass("MKQuickTimeFileType", MKQuickTimeAtom, {
+
+    type: MKQuickTimeAtom.Type.ftyp,
+
+    majorBrand: JSReadOnlyProperty(),
+    minorVersion: JSReadOnlyProperty(),
+
+    getMajorBrand: function(){
+        return this.dataView.getUint32(8);
+    },
+
+    getMinorVersion: function(){
+        return this.dataView.getUint32(12);
+    },
+
+    initWithData: function(data){
+        if (data.length < 16){
+            throw new Error("expecting at least 16 bytes for ftyp atom");
+        }
+        MKQuickTimeFileType.$super.initWithData.call(this, data);
+    },
+
+    dictionaryRepresentation: function(){
+        return {
+            type: MKQuickTimeAtom.stringForType(this.type),
+            majorBrand: MKQuickTimeAtom.stringForType(this.majorBrand),
+        };
+    },
+
+});
+
+MKQuickTimeFileType.MajorBrand = {
+    qt: 0x71742020,
+    mp42: 0x6d703432,
+    m4v: 0x4d345620
+};
+
+})();

package/Root/Frameworks/MediaKit/QuickTime/MKQuickTimeMedia.js

@@ -0,0 +1,127 @@
+// #import "MKQuickTimeAtom.js"
+// #import "MKQuickTimeMediaHeader.js"
+// #import "MKQuickTimeMediaHandler.js"
+// #import "MKQuickTimeMediaInformation.js"
+"use strict";
+
+(function(){
+
+var logger = JSLog("medikit", "quicktime");
+
+JSClass("MKQuickTimeMedia", MKQuickTimeAtom, {
+
+    type: MKQuickTimeAtom.Type.mdia,
+
+    initWithData: function(data){
+        MKQuickTimeMedia.$super.initWithData.call(this, data);
+        this.registerAtomClass(MKQuickTimeMediaHeader);
+        this.registerAtomClass(MKQuickTimeMediaHandler);
+        this.registerAtomClass(MKQuickTimeMediaInformation);
+        this.readAtoms(8);
+    },
+
+    mediaHeader: JSReadOnlyProperty(),
+
+    getMediaHeader: function(){
+        return this.atomOfType(MKQuickTimeAtom.Type.mdhd);
+    },
+
+    mediaInformation: JSReadOnlyProperty(),
+
+    getMediaInformation: function(){
+        return this.atomOfType(MKQuickTimeAtom.Type.minf);
+    },
+
+    mediaHandler: JSReadOnlyProperty(),
+
+    getMediaHandler: function(){
+        return this.atomOfType(MKQuickTimeAtom.Type.hdlr);
+    },
+
+    videoFrameRates: JSReadOnlyProperty(),
+
+    getVideoFrameRates: function(){
+        var handler = this.mediaHandler;
+        if (handler === null){
+            return [];
+        }
+        if (handler.componentSubtype !== MKQuickTimeMediaHandler.ComponentSubtype.vide){
+            return [];
+        }
+        var info = this.mediaInformation;
+        if (info === null){
+            return [];
+        }
+        var header = this.mediaHeader;
+        if (header === null){
+            return [];
+        }
+        var rates = [];
+        var durations = info.sampleDurations;
+        var i, l;
+        for (i = 0, l = durations.length; i < l; ++i){
+            rates.push(header.timeScale / durations[i]);
+        }
+        return rates;
+    },
+
+    averageVideoFrameRate: JSReadOnlyProperty(),
+
+    getAverageVideoFrameRate: function(){
+        var handler = this.mediaHandler;
+        if (handler === null){
+            return [];
+        }
+        if (handler.componentSubtype !== MKQuickTimeMediaHandler.ComponentSubtype.vide){
+            return [];
+        }
+        var info = this.mediaInformation;
+        if (info === null){
+            return [];
+        }
+        var header = this.mediaHeader;
+        if (header === null){
+            return [];
+        }
+        var counts = info.sampleCounts;
+        var durations = info.sampleDurations;
+        var totalCount = 0;
+        var totalSeconds = 0;
+        var i, l;
+        for (i = 0, l = durations.length; i < l; ++i){
+            totalCount += counts[i];
+            totalSeconds += (durations[i] * counts[i]) / header.timeScale;
+        }
+        return totalCount / totalSeconds;
+    },
+
+    audioSampleRates: JSReadOnlyProperty(),
+
+    getAudioSampleRates: function(){
+        var handler = this.mediaHandler;
+        if (handler === null){
+            return [];
+        }
+        if (handler.componentSubtype !== MKQuickTimeMediaHandler.ComponentSubtype.soun){
+            return [];
+        }
+        var info = this.mediaInformation;
+        if (info === null){
+            return [];
+        }
+        return info.audioSampleRates;
+    },
+
+    sampleFormats: JSReadOnlyProperty(),
+
+    getSampleFormats: function(){
+        var info = this.mediaInformation;
+        if (info === null){
+            return [];
+        }
+        return info.sampleFormats;
+    }
+
+});
+
+})();

package/Root/Frameworks/MediaKit/QuickTime/MKQuickTimeMediaHandler.js

@@ -0,0 +1,68 @@
+// #import "MKQuickTimeAtom.js"
+"use strict";
+
+(function(){
+
+var logger = JSLog("medikit", "quicktime");
+
+JSClass("MKQuickTimeMediaHandler", MKQuickTimeAtom, {
+
+    type: MKQuickTimeAtom.Type.hdlr,
+    version: JSReadOnlyProperty(),
+    flags: JSReadOnlyProperty(),
+    componentType: JSReadOnlyProperty(),
+    componentSubtype: JSReadOnlyProperty(),
+
+    getVersion: function(){
+        return this.data[8];
+    },
+
+    getFlags: function(){
+        return this.dataView.getUint32(8) & 0x00FFFFFF;
+    },
+
+    getComponentType: function(){
+        return this.dataView.getUint32(12);
+    },
+
+    getComponentSubtype: function(){
+        return this.dataView.getUint32(16);
+    },
+
+    initWithData: function(data){
+        if (data.length < 20){
+            throw new Error("expecting at least 20 bytes for hdlr atom");
+        }
+        MKQuickTimeMediaHandler.$super.initWithData.call(this, data);
+    },
+
+    dictionaryRepresentation: function(){
+        return {
+            type: MKQuickTimeAtom.stringForType(this.type),
+            version: this.version,
+            componentType: MKQuickTimeAtom.stringForType(this.componentType),
+            componentSubtype: MKQuickTimeAtom.stringForType(this.componentSubtype)
+        };
+    },
+
+});
+
+MKQuickTimeMediaHandler.ComponentType = {
+
+    unspecified: 0x00000000,
+    mhlr: 0x6d686c72,
+    dhlr: 0x64686c72
+
+};
+
+
+MKQuickTimeMediaHandler.ComponentSubtype = {
+
+    vide: 0x76696465,
+    soun: 0x736f756e,
+    subt: 0x73756274,
+    alis: 0x616c6973
+
+};
+
+})();

package/Root/Frameworks/MediaKit/QuickTime/MKQuickTimeMediaHeader.js

@@ -0,0 +1,50 @@
+// #import "MKQuickTimeAtom.js"
+"use strict";
+
+(function(){
+
+var logger = JSLog("medikit", "quicktime");
+
+JSClass("MKQuickTimeMediaHeader", MKQuickTimeAtom, {
+
+    type: MKQuickTimeAtom.Type.mdhd,
+    version: JSReadOnlyProperty(),
+    flags: JSReadOnlyProperty(),
+    timeScale: JSReadOnlyProperty(),
+    duration: JSReadOnlyProperty(),
+
+    getVersion: function(){
+        return this.data[8];
+    },
+
+    getFlags: function(){
+        return this.dataView.getUint32(8) & 0x00FFFFFF;
+    },
+
+    getTimeScale: function(){
+        return this.dataView.getUint32(20);
+    },
+
+    getDuration: function(){
+        return this.dataView.getUint32(24);
+    },
+
+    initWithData: function(data){
+        if (data.length < 28){
+            throw new Error("expecting at least 28 bytes for mdhd atom");
+        }
+        MKQuickTimeMediaHeader.$super.initWithData.call(this, data);
+    },
+
+    dictionaryRepresentation: function(){
+        return {
+            type: MKQuickTimeAtom.stringForType(this.type),
+            version: this.version,
+            timeScale: this.timeScale,
+            duration: this.duration
+        };
+    },
+
+});
+
+})();

package/Root/Frameworks/MediaKit/QuickTime/MKQuickTimeMediaInformation.js

@@ -0,0 +1,67 @@
+// #import "MKQuickTimeAtom.js"
+// #import "MKQuickTimeSampleTable.js"
+"use strict";
+
+(function(){
+
+var logger = JSLog("medikit", "quicktime");
+
+JSClass("MKQuickTimeMediaInformation", MKQuickTimeAtom, {
+
+    type: MKQuickTimeAtom.Type.minf,
+
+    initWithData: function(data){
+        MKQuickTimeMediaInformation.$super.initWithData.call(this, data);
+        this.registerAtomClass(MKQuickTimeSampleTable);
+        this.readAtoms(8);
+    },
+
+    sampleTable: JSReadOnlyProperty(),
+
+    getSampleTable: function(){
+        return this.atomOfType(MKQuickTimeAtom.Type.stbl);
+    },
+
+    sampleDurations: JSReadOnlyProperty(),
+
+    getSampleDurations: function(){
+        var sampleTable = this.sampleTable;
+        if (sampleTable === null){
+            return [];
+        }
+        return sampleTable.sampleDurations;
+    },
+
+    sampleCounts: JSReadOnlyProperty(),
+
+    getSampleCounts: function(){
+        var sampleTable = this.sampleTable;
+        if (sampleTable === null){
+            return [];
+        }
+        return sampleTable.sampleCounts;
+    },
+
+    audioSampleRates: JSReadOnlyProperty(),
+
+    getAudioSampleRates: function(){
+        var sampleTable = this.sampleTable;
+        if (sampleTable === null){
+            return [];
+        }
+        return sampleTable.audioSampleRates;
+    },
+
+    sampleFormats: JSReadOnlyProperty(),
+
+    getSampleFormats: function(){
+        var sampleTable = this.sampleTable;
+        if (sampleTable === null){
+            return [];
+        }
+        return sampleTable.sampleFormats;
+    }
+
+});
+
+})();

package/Root/Frameworks/MediaKit/QuickTime/MKQuickTimeMeta.js

@@ -0,0 +1,19 @@
+// #import "MKQuickTimeAtom.js"
+"use strict";
+
+(function(){
+
+var logger = JSLog("medikit", "quicktime");
+
+JSClass("MKQuickTimeMeta", MKQuickTimeAtom, {
+
+    type: MKQuickTimeAtom.Type.meta,
+
+    initWithData: function(data){
+        MKQuickTimeMeta.$super.initWithData.call(this, data);
+        this.readAtoms(8);
+    },
+
+});
+
+})();

package/Root/Frameworks/MediaKit/QuickTime/MKQuickTimeMovie.js

@@ -0,0 +1,78 @@
+// #import "MKQuickTimeAtom.js"
+// #import "MKQuickTimeMovieHeader.js"
+// #import "MKQuickTimeTrack.js"
+// #import "MKQuickTimeUserData.js"
+// #import "MKQuickTimeMeta.js"
+"use strict";
+
+(function(){
+
+var logger = JSLog("medikit", "quicktime");
+
+JSClass("MKQuickTimeMovie", MKQuickTimeAtom, {
+
+    type: MKQuickTimeAtom.Type.moov,
+
+    initWithData: function(data){
+        MKQuickTimeMovie.$super.initWithData.call(this, data);
+        this.registerAtomClass(MKQuickTimeMovieHeader);
+        this.registerAtomClass(MKQuickTimeTrack);
+        this.registerAtomClass(MKQuickTimeUserData);
+        this.registerAtomClass(MKQuickTimeMeta);
+        this.readAtoms(8);
+    },
+
+    movieHeader: JSReadOnlyProperty(),
+
+    getMovieHeader: function(){
+        return this.atomOfType(MKQuickTimeAtom.Type.mvhd);
+    },
+
+    tracks: JSReadOnlyProperty(),
+
+    getTracks: function(){
+        return this.atomsOfType(MKQuickTimeAtom.Type.trak);
+    },
+
+    trackForID: function(trackID){
+        var i, l;
+        var tracks = this.tracks;
+        for (i = 0, l = tracks.length; i < l; ++i){
+            if (tracks[i].trackID === trackID){
+                return tracks[i];
+            }
+        }
+        return null;
+    },
+
+    videoTracks: JSReadOnlyProperty(),
+
+    getVideoTracks: function(){
+        var i, l;
+        var tracks = this.tracks;
+        var videoTracks = [];
+        for (i = 0, l = tracks.length; i < l; ++i){
+            if (tracks[i].enabled && tracks[i].inMovie && tracks[i].isVideo){
+                videoTracks.push(tracks[i]);
+            }
+        }
+        return videoTracks;
+    },
+
+    audioTracks: JSReadOnlyProperty(),
+
+    getAudioTracks: function(){
+        var i, l;
+        var tracks = this.tracks;
+        var videoTracks = [];
+        for (i = 0, l = tracks.length; i < l; ++i){
+            if (tracks[i].enabled && tracks[i].inMovie && tracks[i].isAudio){
+                videoTracks.push(tracks[i]);
+            }
+        }
+        return videoTracks;
+    },
+
+});
+
+})();

package/Root/Frameworks/MediaKit/QuickTime/MKQuickTimeMovieHeader.js

@@ -0,0 +1,62 @@
+// #import "MKQuickTimeAtom.js"
+"use strict";
+
+(function(){
+
+var logger = JSLog("medikit", "quicktime");
+
+JSClass("MKQuickTimeMovieHeader", MKQuickTimeAtom, {
+
+    type: MKQuickTimeAtom.Type.mvhd,
+    version: JSReadOnlyProperty(),
+    flags: JSReadOnlyProperty(),
+    timeScale: JSReadOnlyProperty(),
+    duration: JSReadOnlyProperty(),
+    preferredRate: JSReadOnlyProperty(),
+    posterTime: JSReadOnlyProperty(),
+
+    getVersion: function(){
+        return this.data[8];
+    },
+
+    getFlags: function(){
+        return this.dataView.getUint32(8) & 0x00FFFFFF;
+    },
+
+    getTimeScale: function(){
+        return this.dataView.getUint32(20);
+    },
+
+    getDuration: function(){
+        return this.dataView.getUint32(24);
+    },
+
+    getPreferredRate: function(){
+        return this.dataView.getUint16(28) + this.dataView.getUint16(30) / 0xFFFF;
+    },
+
+    getPosterTime: function(){
+        return this.dataView.getUint32(78);
+    },
+
+    initWithData: function(data){
+        if (data.length < 98){
+            throw new Error("expecting at least 98 bytes for mvhd atom");
+        }
+        MKQuickTimeMovieHeader.$super.initWithData.call(this, data);
+    },
+
+    dictionaryRepresentation: function(){
+        return {
+            type: MKQuickTimeAtom.stringForType(this.type),
+            version: this.version,
+            timeScale: this.timeScale,
+            duration: this.duration,
+            preferredRate: this.preferredRate,
+            posterTime: this.posterTime
+        };
+    },
+
+});
+
+})();