init commit

remotion/node_modules/@remotion/media-parser/dist/containers/aac/get-seeking-byte.d.ts

@@ -0,0 +1,6 @@
+import type { SeekResolution } from '../../work-on-seek-request';
+import type { AacSeekingHints } from './seeking-hints';
+export declare const getSeekingByteForAac: ({ time, seekingHints, }: {
+    time: number;
+    seekingHints: AacSeekingHints;
+}) => SeekResolution;

remotion/node_modules/@remotion/media-parser/dist/containers/aac/get-seeking-byte.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSeekingByteForAac = void 0;
+const getSeekingByteForAac = ({ time, seekingHints, }) => {
+    let bestAudioSample;
+    for (const hint of seekingHints.audioSampleMap) {
+        if (hint.timeInSeconds > time) {
+            continue;
+        }
+        // Everything is a keyframe in flac, so if this sample does not cover the time, it's not a good candidate.
+        // Let's go to the next one. Exception: If we already saw the last sample, we use it so we find can at least
+        // find the closest one.
+        if (hint.timeInSeconds + hint.durationInSeconds < time &&
+            !seekingHints.lastSampleObserved) {
+            continue;
+        }
+        if (!bestAudioSample) {
+            bestAudioSample = hint;
+            continue;
+        }
+        if (bestAudioSample.timeInSeconds < hint.timeInSeconds) {
+            bestAudioSample = hint;
+        }
+    }
+    if (bestAudioSample) {
+        return {
+            type: 'do-seek',
+            byte: bestAudioSample.offset,
+            timeInSeconds: bestAudioSample.timeInSeconds,
+        };
+    }
+    return { type: 'valid-but-must-wait' };
+};
+exports.getSeekingByteForAac = getSeekingByteForAac;

remotion/node_modules/@remotion/media-parser/dist/containers/aac/parse-aac.d.ts

@@ -0,0 +1,3 @@
+import type { ParseResult } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseAac: (state: ParserState) => Promise<ParseResult>;

remotion/node_modules/@remotion/media-parser/dist/containers/aac/parse-aac.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAac = void 0;
+const aac_codecprivate_1 = require("../../aac-codecprivate");
+const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
+const register_track_1 = require("../../register-track");
+const webcodecs_timescale_1 = require("../../webcodecs-timescale");
+const parseAac = async (state) => {
+    const { iterator } = state;
+    const startOffset = iterator.counter.getOffset();
+    iterator.startReadingBits();
+    const syncWord = iterator.getBits(12);
+    if (syncWord !== 0xfff) {
+        throw new Error('Invalid syncword: ' + syncWord);
+    }
+    const id = iterator.getBits(1);
+    if (id !== 0) {
+        throw new Error('Only supporting MPEG-4 for .aac');
+    }
+    const layer = iterator.getBits(2);
+    if (layer !== 0) {
+        throw new Error('Only supporting layer 0 for .aac');
+    }
+    const protectionAbsent = iterator.getBits(1); // protection absent
+    const audioObjectType = iterator.getBits(2); // 1 = 'AAC-LC'
+    const samplingFrequencyIndex = iterator.getBits(4);
+    const sampleRate = (0, aac_codecprivate_1.getSampleRateFromSampleFrequencyIndex)(samplingFrequencyIndex);
+    iterator.getBits(1); // private bit
+    const channelConfiguration = iterator.getBits(3);
+    const codecPrivate = (0, aac_codecprivate_1.createAacCodecPrivate)({
+        audioObjectType,
+        sampleRate,
+        channelConfiguration,
+        codecPrivate: null,
+    });
+    iterator.getBits(1); // originality
+    iterator.getBits(1); // home
+    iterator.getBits(1); // copyright bit
+    iterator.getBits(1); // copy start
+    const frameLength = iterator.getBits(13); // frame length
+    iterator.getBits(11); // buffer fullness
+    iterator.getBits(2); // number of AAC frames minus 1
+    if (!protectionAbsent) {
+        iterator.getBits(16); // crc
+    }
+    iterator.stopReadingBits();
+    iterator.counter.decrement(iterator.counter.getOffset() - startOffset);
+    const data = iterator.getSlice(frameLength);
+    if (state.callbacks.tracks.getTracks().length === 0) {
+        state.mediaSection.addMediaSection({
+            start: startOffset,
+            size: state.contentLength - startOffset,
+        });
+        await (0, register_track_1.registerAudioTrack)({
+            container: 'aac',
+            track: {
+                codec: (0, aac_codecprivate_1.mapAudioObjectTypeToCodecString)(audioObjectType),
+                codecEnum: 'aac',
+                codecData: { type: 'aac-config', data: codecPrivate },
+                description: codecPrivate,
+                numberOfChannels: channelConfiguration,
+                sampleRate,
+                originalTimescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
+                trackId: 0,
+                type: 'audio',
+                startInSeconds: 0,
+                timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
+                trackMediaTimeOffsetInTrackTimescale: 0,
+            },
+            registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
+            tracks: state.callbacks.tracks,
+            logLevel: state.logLevel,
+            onAudioTrack: state.onAudioTrack,
+        });
+        state.callbacks.tracks.setIsDone(state.logLevel);
+    }
+    const duration = 1024 / sampleRate;
+    const { index } = state.aac.addSample({ offset: startOffset, size: frameLength });
+    const timestamp = (1024 / sampleRate) * index;
+    state.aac.audioSamples.addSample({
+        timeInSeconds: timestamp,
+        offset: startOffset,
+        durationInSeconds: duration,
+    });
+    // One ADTS frame contains 1024 samples
+    const audioSample = (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+        sample: {
+            duration,
+            type: 'key',
+            data,
+            offset: startOffset,
+            decodingTimestamp: timestamp,
+            timestamp,
+        },
+        timescale: 1,
+    });
+    await state.callbacks.onAudioSample({
+        audioSample,
+        trackId: 0,
+    });
+    return Promise.resolve(null);
+};
+exports.parseAac = parseAac;

remotion/node_modules/@remotion/media-parser/dist/containers/aac/seeking-hints.d.ts

@@ -0,0 +1,13 @@
+import type { AacState } from '../../state/aac-state';
+import type { AudioSampleOffset } from '../../state/audio-sample-map';
+import type { SamplesObservedState } from '../../state/samples-observed/slow-duration-fps';
+export type AacSeekingHints = {
+    type: 'aac-seeking-hints';
+    audioSampleMap: AudioSampleOffset[];
+    lastSampleObserved: boolean;
+};
+export declare const getSeekingHintsForAac: ({ aacState, samplesObserved, }: {
+    aacState: AacState;
+    samplesObserved: SamplesObservedState;
+}) => AacSeekingHints;
+export declare const setSeekingHintsForAac: () => void;

remotion/node_modules/@remotion/media-parser/dist/containers/aac/seeking-hints.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSeekingHintsForAac = exports.getSeekingHintsForAac = void 0;
+const getSeekingHintsForAac = ({ aacState, samplesObserved, }) => {
+    return {
+        type: 'aac-seeking-hints',
+        audioSampleMap: aacState.audioSamples.getSamples(),
+        lastSampleObserved: samplesObserved.getLastSampleObserved(),
+    };
+};
+exports.getSeekingHintsForAac = getSeekingHintsForAac;
+// TODO: Implement this and maintain index
+const setSeekingHintsForAac = () => { };
+exports.setSeekingHintsForAac = setSeekingHintsForAac;

remotion/node_modules/@remotion/media-parser/dist/containers/aac/types.d.ts

@@ -0,0 +1,4 @@
+export type AacStructure = {
+    type: 'aac';
+    boxes: never[];
+};

remotion/node_modules/@remotion/media-parser/dist/containers/aac/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });