@breakside/jskit 2023.35.0 → 2023.44.0

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

@@ -0,0 +1,216 @@
+// #import "MKQuickTimeAtom.js"
+// #import "MKQuickTimeFileType.js"
+// #import "MKQuickTimeMovie.js"
+"use strict";
+
+(function(){
+
+var logger = JSLog("medikit", "quicktime");
+
+JSClass("MKQuickTime", MKQuickTimeAtom, {
+
+    initWithData: function(data){
+        this.atoms = [];
+        this.data = data;
+        this.dataView = data.dataView();
+        this.registerAtomClass(MKQuickTimeFileType);
+        this.registerAtomClass(MKQuickTimeMovie);
+        this.readAtoms();
+    },
+
+    duration: JSReadOnlyProperty(),
+
+    getDuration: function(){
+        var movie = this.movie;
+        if (movie === null){
+            return -1;
+        }
+        var header = movie.movieHeader;
+        if (header === null){
+            return -1;
+        }
+        return header.duration / header.timeScale;
+    },
+
+    posterTime: JSReadOnlyProperty(),
+
+    getPosterTime: function(){
+        var movie = this.movie;
+        if (movie === null){
+            return 0;
+        }
+        var header = movie.movieHeader;
+        if (header === null){
+            return 0;
+        }
+        return header.posterTime / header.timeScale;
+    },
+
+    fileType: JSReadOnlyProperty(),
+
+    getFileType: function(){
+        return this.atomOfType(MKQuickTimeAtom.Type.ftyp);
+    },
+
+    movie: JSReadOnlyProperty(),
+
+    getMovie: function(){
+        return this.atomOfType(MKQuickTimeAtom.Type.moov);
+    },
+
+    dictionaryRepresentation: function(){
+        return {
+        };
+    },
+
+    videoResolutions: JSReadOnlyProperty(),
+
+    getVideoResolutions: function(){
+        var resolutions = [];
+        var movie = this.movie;
+        if (movie !== null){
+            var videoTracks = movie.videoTracks;
+            var i, l;
+            var track;
+            var resolution;
+            for (i = 0, l = videoTracks.length; i < l; ++i){
+                track = videoTracks[i];
+                resolution = track.videoResolution;
+                if (resolution !== null){
+                    resolutions.push(resolution);
+                }
+            }
+        }
+        return resolutions;
+    },
+
+    videoTracks: JSReadOnlyProperty(),
+
+    getVideoTracks: function(){
+        var movie = this.movie;
+        if (movie === null){
+            return [];
+        }
+        return movie.videoTracks;
+    },
+
+    audioTracks: JSReadOnlyProperty(),
+
+    getAudioTracks: function(){
+        var movie = this.movie;
+        if (movie === null){
+            return [];
+        }
+        return movie.audioTracks;
+    },
+
+    videoFrameRates: JSReadOnlyProperty(),
+
+    getVideoFrameRates: function(){
+        var movie = this.movie;
+        if (movie === null){
+            return [];
+        }
+        var tracks = movie.videoTracks;
+        var i, l;
+        var rates = [];
+        for (i = 0, l = tracks.length; i < l; ++i){
+            rates = rates.concat(tracks[i].sampleRates);
+        }
+        return rates;
+    },
+
+    audioSampleRates: JSReadOnlyProperty(),
+
+    getAudioSampleRates: function(){
+        var movie = this.movie;
+        if (movie === null){
+            return [];
+        }
+        var tracks = movie.audioTracks;
+        var i, l;
+        var rates = [];
+        for (i = 0, l = tracks.length; i < l; ++i){
+            rates = rates.concat(tracks[i].sampleRates);
+        }
+        return rates;
+    },
+
+    videoFormats: JSReadOnlyProperty(),
+
+    getVideoFormats: function(){
+        var movie = this.movie;
+        if (movie === null){
+            return [];
+        }
+        var tracks = movie.videoTracks;
+        var i, l;
+        var formats = [];
+        for (i = 0, l = tracks.length; i < l; ++i){
+            formats = formats.concat(tracks[i].sampleFormats);
+        }
+        return formats;
+    },
+
+    audioFormats: JSReadOnlyProperty(),
+
+    getAudioFormats: function(){
+        var movie = this.movie;
+        if (movie === null){
+            return [];
+        }
+        var tracks = movie.audioTracks;
+        var i, l;
+        var formats = [];
+        for (i = 0, l = tracks.length; i < l; ++i){
+            formats = formats.concat(tracks[i].sampleFormats);
+        }
+        return formats;
+    },
+
+    metadata: JSReadOnlyProperty(),
+
+    getMetadata: function(){
+        var metadata = {
+            format: MKQuickTimeAtom.stringForType(this.fileType !== null ? this.fileType.majorBrand : MKQuickTimeFileType.MajorBrand.qt),
+            duration: this.duration,
+            posterTime: this.posterTime,
+            video: false,
+            audio: false,
+            tracks: []
+        };
+        var i, l;
+        var movie = this.movie;
+        if (movie !== null){
+            var tracks = movie.tracks;
+            var track;
+            for (i = 0, l = tracks.length; i < l; ++i){
+                track = tracks[i];
+                if (track.enabled && track.inMovie){
+                    if (track.isVideo){
+                        metadata.tracks.push({
+                            type: "video",
+                            width: track.videoResolution.width,
+                            height: track.videoResolution.height,
+                            formats: MKQuickTimeAtom.stringsForTypes(track.sampleFormats),
+                            frameRates: track.videoFrameRates,
+                            averageFrameRate: track.averageVideoFrameRate
+                        });
+                        metadata.video = true;
+                    }else if (track.isAudio){
+                        metadata.tracks.push({
+                            type: "audio",
+                            formats: MKQuickTimeAtom.stringsForTypes(track.sampleFormats),
+                            sampleRates: track.audioSampleRates
+                        });
+                        metadata.audio = true;
+                    }
+                }
+            }
+        }
+        return metadata;
+    },
+
+});
+
+})();

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
+        };
+    },
+
+});
+
+})();