@breakside/jskit 2023.35.0 → 2023.44.0

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

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

@@ -0,0 +1,72 @@
+// #import "MKQuickTimeAtom.js"
+"use strict";
+
+(function(){
+
+var logger = JSLog("medikit", "quicktime");
+
+JSClass("MKQuickTimeSampleDescription", MKQuickTimeAtom, {
+
+    type: MKQuickTimeAtom.Type.stsd,
+    version: JSReadOnlyProperty(),
+    flags: JSReadOnlyProperty(),
+    numberOfEntries: JSReadOnlyProperty(),
+
+    getVersion: function(){
+        return this.data[8];
+    },
+
+    getFlags: function(){
+        return this.dataView.getUint32(8) & 0x00FFFFFF;
+    },
+
+    initWithData: function(data){
+        MKQuickTimeSampleDescription.$super.initWithData.call(this, data);
+        if (data.length < 16){
+            throw new Error("expecting at least 16 bytes for stts atom");
+        }
+    },
+
+    getNumberOfEntries: function(){
+        return this.dataView.getUint32(12);
+    },
+
+    formats: JSReadOnlyProperty(),
+
+    getFormats: function(){
+        var formats = [];
+        var i = 16;
+        var l = this.data.length;
+        var n = this.numberOfEntries;
+        var index = 0;
+        var size;
+        while (index < n && i < l - 16){
+            size = this.dataView.getUint32(i);
+            formats.push(this.dataView.getUint32(i + 4));
+            i += size;
+        }
+        return formats;
+    },
+
+    audioSampleRates: JSReadOnlyProperty(),
+
+    getAudioSampleRates: function(){
+        var rates = [];
+        var i = 16;
+        var l = this.data.length;
+        var n = this.numberOfEntries;
+        var index = 0;
+        var size;
+        while (index < n && i < l - 16){
+            size = this.dataView.getUint32(i);
+            if (size >= 36){
+                rates.push(this.dataView.getUint16(i + 32) + this.dataView.getUint16(i + 34) / 0xFFFF);
+            }
+            i += size;
+        }
+        return rates;
+    }
+
+});
+
+})();

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

@@ -0,0 +1,84 @@
+// #import "MKQuickTimeAtom.js"
+// #import "MKQuickTimeTimeToSample.js"
+// #import "MKQuickTimeSampleDescription.js"
+"use strict";
+
+(function(){
+
+var logger = JSLog("medikit", "quicktime");
+
+
+JSClass("MKQuickTimeSampleTable", MKQuickTimeAtom, {
+
+    type: MKQuickTimeAtom.Type.stbl,
+
+    initWithData: function(data){
+        MKQuickTimeSampleTable.$super.initWithData.call(this, data);
+        this.registerAtomClass(MKQuickTimeTimeToSample);
+        this.registerAtomClass(MKQuickTimeSampleDescription);
+        this.readAtoms(8);
+    },
+
+    timeToSample: JSReadOnlyProperty(),
+
+    getTimeToSample: function(){
+        return this.atomOfType(MKQuickTimeAtom.Type.stts);
+    },
+
+    sampleDescription: JSReadOnlyProperty(),
+
+    getSampleDescription: function(){
+        return this.atomOfType(MKQuickTimeAtom.Type.stsd);
+    },
+
+    sampleDurations: JSReadOnlyProperty(),
+
+    getSampleDurations: function(){
+        var timeToSample = this.timeToSample;
+        var durations = [];
+        if (timeToSample !== null){
+            var i, l;
+            for (i = 0, l = timeToSample.numberOfEntries; i < l; ++i){
+                durations.push(timeToSample.durationAtIndex(i));
+            }
+        }
+        return durations;
+    },
+
+    sampleCounts: JSReadOnlyProperty(),
+
+    getSampleCounts: function(){
+        var timeToSample = this.timeToSample;
+        var counts = [];
+        if (timeToSample !== null){
+            var i, l;
+            for (i = 0, l = timeToSample.numberOfEntries; i < l; ++i){
+                counts.push(timeToSample.countAtIndex(i));
+            }
+        }
+        return counts;
+    },
+
+    audioSampleRates: JSReadOnlyProperty(),
+
+    getAudioSampleRates: function(){
+        var description = this.sampleDescription;
+        if (description === null){
+            return [];
+        }
+        return description.audioSampleRates;
+    },
+
+    sampleFormats: JSReadOnlyProperty(),
+
+    getSampleFormats: function(){
+        var description = this.sampleDescription;
+        if (description === null){
+            return [];
+        }
+        return description.formats;
+    }
+
+});
+
+})();

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

@@ -0,0 +1,57 @@
+// #import "MKQuickTimeAtom.js"
+"use strict";
+
+(function(){
+
+var logger = JSLog("medikit", "quicktime");
+
+JSClass("MKQuickTimeTimeToSample", MKQuickTimeAtom, {
+
+    type: MKQuickTimeAtom.Type.stts,
+    version: JSReadOnlyProperty(),
+    flags: JSReadOnlyProperty(),
+    numberOfEntries: JSReadOnlyProperty(),
+
+    getVersion: function(){
+        return this.data[8];
+    },
+
+    getFlags: function(){
+        return this.dataView.getUint32(8) & 0x00FFFFFF;
+    },
+
+    initWithData: function(data){
+        MKQuickTimeTimeToSample.$super.initWithData.call(this, data);
+        if (data.length < 16){
+            throw new Error("expecting at least 16 bytes for stts atom");
+        }
+        var n = this.numberOfEntries;
+        var l = 16 + 8 * n;
+        if (data.length < l){
+            throw new Error("expecting at least %d bytes for stts atom with %d entries".sprintf(l, n));
+        }
+    },
+
+    getNumberOfEntries: function(){
+        return this.dataView.getUint32(12);
+    },
+
+    countAtIndex: function(index){
+        var i = 16 + index * 8;
+        if (i >= 16 && i < this.data.length){
+            return this.dataView.getUint32(i);
+        }
+        return null;
+    },
+
+    durationAtIndex: function(index){
+        var i = 16 + index * 8;
+        if (i >= 16 && i < this.data.length){
+            return this.dataView.getUint32(i + 4);
+        }
+        return null;
+    }
+
+});
+
+})();

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

@@ -0,0 +1,133 @@
+// #import "MKQuickTimeAtom.js"
+// #import "MKQuickTimeTrackHeader.js"
+// #import "MKQuickTimeMedia.js"
+"use strict";
+
+(function(){
+
+var logger = JSLog("medikit", "quicktime");
+
+JSClass("MKQuickTimeTrack", MKQuickTimeAtom, {
+
+    type: MKQuickTimeAtom.Type.trak,
+
+    initWithData: function(data){
+        MKQuickTimeTrack.$super.initWithData.call(this, data);
+        this.registerAtomClass(MKQuickTimeTrackHeader);
+        this.registerAtomClass(MKQuickTimeMedia);
+        this.readAtoms(8);
+    },
+
+    trackHeader: JSReadOnlyProperty(),
+
+    getTrackHeader: function(){
+        return this.atomOfType(MKQuickTimeAtom.Type.tkhd);
+    },
+
+    media: JSReadOnlyProperty(),
+
+    getMedia: function(){
+        return this.atomOfType(MKQuickTimeAtom.Type.mdia);
+    },
+
+    isVideo: JSReadOnlyProperty(),
+
+    getIsVideo: function(){
+        var media = this.media;
+        if (media === null){
+            return false;
+        }
+        var handler = media.mediaHandler;
+        if (handler === null){
+            return false;
+        }
+        return (handler.componentType === MKQuickTimeMediaHandler.ComponentType.unspecified || handler.componentType === MKQuickTimeMediaHandler.ComponentType.mhlr) && handler.componentSubtype === MKQuickTimeMediaHandler.ComponentSubtype.vide;
+    },
+
+    isAudio: JSReadOnlyProperty(),
+
+    getIsAudio: function(){
+        var media = this.media;
+        if (media === null){
+            return false;
+        }
+        var handler = media.mediaHandler;
+        if (handler === null){
+            return false;
+        }
+        return (handler.componentType === MKQuickTimeMediaHandler.ComponentType.unspecified || handler.componentType === MKQuickTimeMediaHandler.ComponentType.mhlr) && handler.componentSubtype === MKQuickTimeMediaHandler.ComponentSubtype.soun;
+    },
+
+    inMovie: JSReadOnlyProperty(),
+
+    getInMovie: function(){
+        var header = this.trackHeader;
+        if (header === null){
+            return false;
+        }
+        return header.inMovie;
+    },
+
+    enabled: JSReadOnlyProperty(),
+
+    getEnabled: function(){
+        var header = this.trackHeader;
+        if (header === null){
+            return false;
+        }
+        return header.enabled;
+    },
+
+    videoResolution: JSReadOnlyProperty(),
+
+    getVideoResolution: function(){
+        var header = this.trackHeader;
+        if (header === null){
+            return null;
+        }
+        return header.videoResolution;
+    },
+
+    videoFrameRates: JSReadOnlyProperty(),
+
+    getVideoFrameRates: function(){
+        var media = this.media;
+        if (media === null){
+            return [];
+        }
+        return media.videoFrameRates;
+    },
+
+    averageVideoFrameRate: JSReadOnlyProperty(),
+
+    getAverageVideoFrameRate: function(){
+        var media = this.media;
+        if (media === null){
+            return [];
+        }
+        return media.averageVideoFrameRate;
+    },
+
+    audioSampleRates: JSReadOnlyProperty(),
+
+    getAudioSampleRates: function(){
+        var media = this.media;
+        if (media === null){
+            return [];
+        }
+        return media.audioSampleRates;
+    },
+
+    sampleFormats: JSReadOnlyProperty(),
+
+    getSampleFormats: function(){
+        var media = this.media;
+        if (media === null){
+            return [];
+        }
+        return media.sampleFormats;
+    }
+
+});
+
+})();

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

@@ -0,0 +1,82 @@
+// #import "MKQuickTimeAtom.js"
+"use strict";
+
+(function(){
+
+var logger = JSLog("medikit", "quicktime");
+
+JSClass("MKQuickTimeTrackHeader", MKQuickTimeAtom, {
+
+    type: MKQuickTimeAtom.Type.tkhd,
+    version: JSReadOnlyProperty(),
+    flags: JSReadOnlyProperty(),
+    trackID: JSReadOnlyProperty(),
+    duration: JSReadOnlyProperty(),
+    width: JSReadOnlyProperty(),
+    height: JSReadOnlyProperty(),
+
+    getVersion: function(){
+        return this.data[8];
+    },
+
+    getFlags: function(){
+        return this.dataView.getUint32(8) & 0x00FFFFFF;
+    },
+
+    enabled: JSReadOnlyProperty(),
+
+    getEnabled: function(){
+        return (this.flags & 0x0001) === 0x0001;
+    },
+
+    inMovie: JSReadOnlyProperty(),
+
+    getInMovie: function(){
+        return (this.flags & 0x0001) === 0x0001;
+    },
+
+    getTrackID: function(){
+        return this.dataView.getUint32(20);
+    },
+
+    getDuration: function(){
+        return this.dataView.getUint32(28);
+    },
+
+    getWidth: function(){
+        return this.dataView.getUint16(84) + this.dataView.getUint16(86) / 0xFFFF;
+    },
+
+    getHeight: function(){
+        return this.dataView.getUint16(88) + this.dataView.getUint16(90) / 0xFFFF;
+    },
+
+    videoResolution: JSReadOnlyProperty(),
+
+    getVideoResolution: function(){
+        return JSSize(this.width, this.height);
+    },
+
+    initWithData: function(data){
+        if (data.length < 92){
+            throw new Error("expecting at least 92 bytes for tkhd atom");
+        }
+        MKQuickTimeTrackHeader.$super.initWithData.call(this, data);
+    },
+
+    dictionaryRepresentation: function(){
+        return {
+            type: MKQuickTimeAtom.stringForType(this.type),
+            version: this.version,
+            enabled: this.enabled,
+            inMovie: this.inMovie,
+            trackID: this.trackID,
+            duration: this.duration,
+            width: this.width,
+            height: this.height
+        };
+    },
+
+});
+
+})();

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

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

package/Root/Frameworks/MediaKitUI/Info.yaml

@@ -1,6 +1,6 @@
 JSBundleType: framework
 JSBundleIdentifier: io.breakside.JSKit.MediaKitUI
-JSBundleVersion: 2023.35.0
+JSBundleVersion: 2023.44.0
 JSDevelopmentLanguage: en
 JSCopyright: Copyright © 2020 Breakside Inc.
 JSBundleEnvironments: