init commit
This commit is contained in:
Carlos
78
remotion/node_modules/@remotion/media-parser/dist/iterator/buffer-iterator.d.ts
generated
vendored
Normal file
78
remotion/node_modules/@remotion/media-parser/dist/iterator/buffer-iterator.d.ts
generated
vendored
Normal file
@@ -0,0 +1,78 @@
|
||||
import type { MediaParserLogLevel } from '../log';
|
||||
export declare const getArrayBufferIterator: ({ initialData, maxBytes, logLevel, }: {
|
||||
initialData: Uint8Array;
|
||||
maxBytes: number;
|
||||
logLevel: MediaParserLogLevel;
|
||||
}) => {
|
||||
startReadingBits: () => void;
|
||||
stopReadingBits: () => void;
|
||||
skipTo: (offset: number) => void;
|
||||
addData: (newData: Uint8Array) => void;
|
||||
counter: {
|
||||
getOffset: () => number;
|
||||
discardBytes: (bytes: number) => void;
|
||||
increment: (bytes: number) => void;
|
||||
getDiscardedBytes: () => number;
|
||||
setDiscardedOffset: (bytes: number) => void;
|
||||
getDiscardedOffset: () => number;
|
||||
decrement: (bytes: number) => void;
|
||||
};
|
||||
peekB: (length: number) => void;
|
||||
peekD: (length: number) => void;
|
||||
getBits: (bits: number) => number;
|
||||
bytesRemaining: () => number;
|
||||
leb128: () => number;
|
||||
removeBytesRead: (force: boolean, mode: import("../options").ParseMediaMode) => {
|
||||
bytesRemoved: number;
|
||||
removedData: Uint8Array<ArrayBuffer> | null;
|
||||
};
|
||||
discard: (length: number) => void;
|
||||
getEightByteNumber: (littleEndian?: boolean) => number;
|
||||
getFourByteNumber: () => number;
|
||||
getSlice: (amount: number) => Uint8Array<ArrayBuffer>;
|
||||
getAtom: () => string;
|
||||
detectFileType: () => import("../file-types/detect-file-type").FileType;
|
||||
getPaddedFourByteNumber: () => number;
|
||||
getMatroskaSegmentId: () => string | null;
|
||||
getVint: () => number | null;
|
||||
getUint8: () => number;
|
||||
getEBML: () => number;
|
||||
getInt8: () => number;
|
||||
getUint16: () => number;
|
||||
getUint16Le: () => number;
|
||||
getUint24: () => number;
|
||||
getInt24: () => number;
|
||||
getInt16: () => number;
|
||||
getUint32: () => number;
|
||||
getUint64: (littleEndian?: boolean) => bigint;
|
||||
getInt64: (littleEndian?: boolean) => bigint;
|
||||
getFixedPointUnsigned1616Number: () => number;
|
||||
getFixedPointSigned1616Number: () => number;
|
||||
getFixedPointSigned230Number: () => number;
|
||||
getPascalString: () => number[];
|
||||
getUint(length: number): number;
|
||||
getByteString(length: number, trimTrailingZeroes: boolean): string;
|
||||
planBytes: (size: number) => {
|
||||
discardRest: () => Uint8Array<ArrayBuffer>;
|
||||
};
|
||||
getFloat64: () => number;
|
||||
readUntilNullTerminator: () => string;
|
||||
getFloat32: () => number;
|
||||
getUint32Le: () => number;
|
||||
getInt32Le: () => number;
|
||||
getInt32: () => number;
|
||||
destroy: () => void;
|
||||
startBox: (size: number) => {
|
||||
discardRest: () => void;
|
||||
expectNoMoreBytes: () => void;
|
||||
};
|
||||
readExpGolomb: () => number;
|
||||
startCheckpoint: () => {
|
||||
returnToCheckpoint: () => void;
|
||||
};
|
||||
getFlacCodecNumber: () => number;
|
||||
readUntilLineEnd: () => string | null;
|
||||
getSyncSafeInt32: () => number;
|
||||
replaceData: (newData: Uint8Array, seekTo: number) => void;
|
||||
};
|
||||
export type BufferIterator = ReturnType<typeof getArrayBufferIterator>;
|
||||
481
remotion/node_modules/@remotion/media-parser/dist/iterator/buffer-iterator.js
generated
vendored
Normal file
481
remotion/node_modules/@remotion/media-parser/dist/iterator/buffer-iterator.js
generated
vendored
Normal file
@@ -0,0 +1,481 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.getArrayBufferIterator = void 0;
|
||||
/* eslint-disable @typescript-eslint/no-use-before-define */
|
||||
const all_segments_1 = require("../containers/webm/segments/all-segments");
|
||||
const file_types_1 = require("../file-types");
|
||||
const log_1 = require("../log");
|
||||
const buffer_manager_1 = require("./buffer-manager");
|
||||
const offset_counter_1 = require("./offset-counter");
|
||||
const getArrayBufferIterator = ({ initialData, maxBytes, logLevel, }) => {
|
||||
const counter = (0, offset_counter_1.makeOffsetCounter)(0);
|
||||
const { getUint8Array, getView, addData, destroy, removeBytesRead, skipTo, replaceData, } = (0, buffer_manager_1.bufferManager)({ initialData, maxBytes, counter, logLevel });
|
||||
const startCheckpoint = () => {
|
||||
const checkpoint = counter.getOffset();
|
||||
return {
|
||||
returnToCheckpoint: () => {
|
||||
counter.decrement(counter.getOffset() - checkpoint);
|
||||
},
|
||||
};
|
||||
};
|
||||
const getSlice = (amount) => {
|
||||
const value = getUint8Array().slice(counter.getDiscardedOffset(), counter.getDiscardedOffset() + amount);
|
||||
counter.increment(value.length);
|
||||
return value;
|
||||
};
|
||||
const discard = (length) => {
|
||||
counter.increment(length);
|
||||
};
|
||||
const readUntilNullTerminator = () => {
|
||||
const bytes = [];
|
||||
let byte;
|
||||
while ((byte = getUint8()) !== 0) {
|
||||
bytes.push(byte);
|
||||
}
|
||||
counter.decrement(1);
|
||||
return new TextDecoder().decode(new Uint8Array(bytes));
|
||||
};
|
||||
const readUntilLineEnd = () => {
|
||||
const bytes = [];
|
||||
// 10 is "\n"
|
||||
while (true) {
|
||||
if (bytesRemaining() === 0) {
|
||||
return null;
|
||||
}
|
||||
const byte = getUint8();
|
||||
bytes.push(byte);
|
||||
if (byte === 10) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
const str = new TextDecoder().decode(new Uint8Array(bytes)).trim();
|
||||
return str;
|
||||
};
|
||||
const getUint8 = () => {
|
||||
const val = getView().getUint8(counter.getDiscardedOffset());
|
||||
counter.increment(1);
|
||||
return val;
|
||||
};
|
||||
const getEightByteNumber = (littleEndian = false) => {
|
||||
if (littleEndian) {
|
||||
const one = getUint8();
|
||||
const two = getUint8();
|
||||
const three = getUint8();
|
||||
const four = getUint8();
|
||||
const five = getUint8();
|
||||
const six = getUint8();
|
||||
const seven = getUint8();
|
||||
const eight = getUint8();
|
||||
return (((eight << 56) |
|
||||
(seven << 48) |
|
||||
(six << 40) |
|
||||
(five << 32) |
|
||||
(four << 24) |
|
||||
(three << 16) |
|
||||
(two << 8) |
|
||||
one) >>>
|
||||
0);
|
||||
}
|
||||
function byteArrayToBigInt(byteArray) {
|
||||
let result = BigInt(0);
|
||||
for (let i = 0; i < byteArray.length; i++) {
|
||||
result = (result << BigInt(8)) + BigInt(byteArray[i]);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
const bigInt = byteArrayToBigInt([
|
||||
getUint8(),
|
||||
getUint8(),
|
||||
getUint8(),
|
||||
getUint8(),
|
||||
getUint8(),
|
||||
getUint8(),
|
||||
getUint8(),
|
||||
getUint8(),
|
||||
]);
|
||||
return Number(bigInt);
|
||||
};
|
||||
const getFourByteNumber = () => {
|
||||
const unsigned = (getUint8() << 24) | (getUint8() << 16) | (getUint8() << 8) | getUint8();
|
||||
return unsigned >>> 0;
|
||||
};
|
||||
const getPaddedFourByteNumber = () => {
|
||||
let lastInt = 128;
|
||||
while (((lastInt = getUint8()), lastInt === 128)) {
|
||||
// Do nothing
|
||||
}
|
||||
return lastInt;
|
||||
};
|
||||
const getUint32 = () => {
|
||||
const val = getView().getUint32(counter.getDiscardedOffset());
|
||||
counter.increment(4);
|
||||
return val;
|
||||
};
|
||||
const getSyncSafeInt32 = () => {
|
||||
const val = getView().getUint32(counter.getDiscardedOffset());
|
||||
counter.increment(4);
|
||||
return (((val & 0x7f000000) >> 3) |
|
||||
((val & 0x007f0000) >> 2) |
|
||||
((val & 0x00007f00) >> 1) |
|
||||
(val & 0x0000007f));
|
||||
};
|
||||
const getUint64 = (littleEndian = false) => {
|
||||
const val = getView().getBigUint64(counter.getDiscardedOffset(), littleEndian);
|
||||
counter.increment(8);
|
||||
return val;
|
||||
};
|
||||
const getInt64 = (littleEndian = false) => {
|
||||
const val = getView().getBigInt64(counter.getDiscardedOffset(), littleEndian);
|
||||
counter.increment(8);
|
||||
return val;
|
||||
};
|
||||
const startBox = (size) => {
|
||||
const startOffset = counter.getOffset();
|
||||
return {
|
||||
discardRest: () => discard(size - (counter.getOffset() - startOffset)),
|
||||
expectNoMoreBytes: () => {
|
||||
const remaining = size - (counter.getOffset() - startOffset);
|
||||
if (remaining !== 0) {
|
||||
throw new Error('expected 0 bytes, got ' + remaining);
|
||||
}
|
||||
},
|
||||
};
|
||||
};
|
||||
const getUint32Le = () => {
|
||||
const val = getView().getUint32(counter.getDiscardedOffset(), true);
|
||||
counter.increment(4);
|
||||
return val;
|
||||
};
|
||||
const getInt32Le = () => {
|
||||
const val = getView().getInt32(counter.getDiscardedOffset(), true);
|
||||
counter.increment(4);
|
||||
return val;
|
||||
};
|
||||
const getInt32 = () => {
|
||||
const val = getView().getInt32(counter.getDiscardedOffset());
|
||||
counter.increment(4);
|
||||
return val;
|
||||
};
|
||||
const bytesRemaining = () => {
|
||||
return getUint8Array().byteLength - counter.getDiscardedOffset();
|
||||
};
|
||||
const readExpGolomb = () => {
|
||||
if (!bitReadingMode) {
|
||||
throw new Error('Not in bit reading mode');
|
||||
}
|
||||
let zerosCount = 0;
|
||||
// Step 1: Count the number of leading zeros
|
||||
while (getBits(1) === 0) {
|
||||
zerosCount++;
|
||||
}
|
||||
// Step 2: Read the suffix
|
||||
let suffix = 0;
|
||||
for (let i = 0; i < zerosCount; i++) {
|
||||
suffix = (suffix << 1) | getBits(1);
|
||||
}
|
||||
// Step 3: Calculate the value
|
||||
return (1 << zerosCount) - 1 + suffix;
|
||||
};
|
||||
const peekB = (length) => {
|
||||
log_1.Log.info('info', [...getSlice(length)].map((b) => b.toString(16).padStart(2, '0')));
|
||||
counter.decrement(length);
|
||||
};
|
||||
const peekD = (length) => {
|
||||
log_1.Log.info('info', [...getSlice(length)].map((b) => b.toString(16).padStart(2, '0')));
|
||||
counter.decrement(length);
|
||||
};
|
||||
const leb128 = () => {
|
||||
let result = 0;
|
||||
let shift = 0;
|
||||
let byte;
|
||||
do {
|
||||
byte = getBits(8);
|
||||
result |= (byte & 0x7f) << shift;
|
||||
shift += 7;
|
||||
} while (byte >= 0x80); // Continue if the high bit is set
|
||||
return result;
|
||||
};
|
||||
let bitIndex = 0;
|
||||
const stopReadingBits = () => {
|
||||
bitIndex = 0;
|
||||
bitReadingMode = false;
|
||||
};
|
||||
let byteToShift = 0;
|
||||
let bitReadingMode = false;
|
||||
const startReadingBits = () => {
|
||||
bitReadingMode = true;
|
||||
byteToShift = getUint8();
|
||||
};
|
||||
// https://www.rfc-editor.org/rfc/rfc9639.html#name-coded-number
|
||||
const getFlacCodecNumber = () => {
|
||||
let ones = 0;
|
||||
let bits = 0;
|
||||
// eslint-disable-next-line no-constant-binary-expression
|
||||
while ((++bits || true) && getBits(1) === 1) {
|
||||
ones++;
|
||||
}
|
||||
if (ones === 0) {
|
||||
return getBits(7);
|
||||
}
|
||||
const bitArray = [];
|
||||
const firstByteBits = 8 - ones - 1;
|
||||
for (let i = 0; i < firstByteBits; i++) {
|
||||
bitArray.unshift(getBits(1));
|
||||
}
|
||||
const extraBytes = ones - 1;
|
||||
for (let i = 0; i < extraBytes; i++) {
|
||||
for (let j = 0; j < 8; j++) {
|
||||
const val = getBits(1);
|
||||
if (j < 2) {
|
||||
continue;
|
||||
}
|
||||
bitArray.unshift(val);
|
||||
}
|
||||
}
|
||||
const encoded = bitArray.reduce((acc, bit, index) => {
|
||||
return acc | (bit << index);
|
||||
}, 0);
|
||||
return encoded;
|
||||
};
|
||||
const getBits = (bits) => {
|
||||
let result = 0;
|
||||
let bitsCollected = 0;
|
||||
while (bitsCollected < bits) {
|
||||
if (bitIndex >= 8) {
|
||||
bitIndex = 0;
|
||||
byteToShift = getUint8();
|
||||
}
|
||||
const remainingBitsInByte = 8 - bitIndex;
|
||||
const bitsToReadNow = Math.min(bits - bitsCollected, remainingBitsInByte);
|
||||
const mask = (1 << bitsToReadNow) - 1;
|
||||
const shift = remainingBitsInByte - bitsToReadNow;
|
||||
result <<= bitsToReadNow;
|
||||
result |= (byteToShift >> shift) & mask;
|
||||
bitsCollected += bitsToReadNow;
|
||||
bitIndex += bitsToReadNow;
|
||||
}
|
||||
return result;
|
||||
};
|
||||
return {
|
||||
startReadingBits,
|
||||
stopReadingBits,
|
||||
skipTo,
|
||||
addData,
|
||||
counter,
|
||||
peekB,
|
||||
peekD,
|
||||
getBits,
|
||||
bytesRemaining,
|
||||
leb128,
|
||||
removeBytesRead,
|
||||
discard,
|
||||
getEightByteNumber,
|
||||
getFourByteNumber,
|
||||
getSlice,
|
||||
getAtom: () => {
|
||||
const atom = getSlice(4);
|
||||
return new TextDecoder().decode(atom);
|
||||
},
|
||||
detectFileType: () => {
|
||||
return (0, file_types_1.detectFileType)(getUint8Array());
|
||||
},
|
||||
getPaddedFourByteNumber,
|
||||
getMatroskaSegmentId: () => {
|
||||
if (bytesRemaining() === 0) {
|
||||
return null;
|
||||
}
|
||||
const first = getSlice(1);
|
||||
const firstOneString = `0x${Array.from(new Uint8Array(first))
|
||||
.map((b) => {
|
||||
return b.toString(16).padStart(2, '0');
|
||||
})
|
||||
.join('')}`;
|
||||
// Catch void block
|
||||
// https://www.matroska.org/technical/elements.html
|
||||
if (all_segments_1.knownIdsWithOneLength.includes(firstOneString)) {
|
||||
return firstOneString;
|
||||
}
|
||||
if (bytesRemaining() === 0) {
|
||||
return null;
|
||||
}
|
||||
const firstTwo = getSlice(1);
|
||||
const firstTwoString = `${firstOneString}${Array.from(new Uint8Array(firstTwo))
|
||||
.map((b) => {
|
||||
return b.toString(16).padStart(2, '0');
|
||||
})
|
||||
.join('')}`;
|
||||
if (all_segments_1.knownIdsWithTwoLength.includes(firstTwoString)) {
|
||||
return firstTwoString;
|
||||
}
|
||||
if (bytesRemaining() === 0) {
|
||||
return null;
|
||||
}
|
||||
const firstThree = getSlice(1);
|
||||
const firstThreeString = `${firstTwoString}${Array.from(new Uint8Array(firstThree))
|
||||
.map((b) => {
|
||||
return b.toString(16).padStart(2, '0');
|
||||
})
|
||||
.join('')}`;
|
||||
if (all_segments_1.knownIdsWithThreeLength.includes(firstThreeString)) {
|
||||
return firstThreeString;
|
||||
}
|
||||
if (bytesRemaining() === 0) {
|
||||
return null;
|
||||
}
|
||||
const segmentId = getSlice(1);
|
||||
return `${firstThreeString}${Array.from(new Uint8Array(segmentId))
|
||||
.map((b) => {
|
||||
return b.toString(16).padStart(2, '0');
|
||||
})
|
||||
.join('')}`;
|
||||
},
|
||||
getVint: () => {
|
||||
if (bytesRemaining() === 0) {
|
||||
return null;
|
||||
}
|
||||
const firstByte = getUint8();
|
||||
const totalLength = firstByte;
|
||||
if (totalLength === 0) {
|
||||
return 0;
|
||||
}
|
||||
// Calculate the actual length of the data based on the first set bit
|
||||
let actualLength = 0;
|
||||
while (((totalLength >> (7 - actualLength)) & 0x01) === 0) {
|
||||
actualLength++;
|
||||
}
|
||||
if (bytesRemaining() < actualLength) {
|
||||
return null;
|
||||
}
|
||||
const slice = getSlice(actualLength);
|
||||
const d = [firstByte, ...Array.from(new Uint8Array(slice))];
|
||||
actualLength += 1; // Include the first byte set as 1
|
||||
// Combine the numbers to form the integer value
|
||||
let value = 0;
|
||||
// Mask the first byte properly then start combining
|
||||
value = totalLength & (0xff >> actualLength);
|
||||
for (let i = 1; i < actualLength; i++) {
|
||||
value = (value << 8) | d[i];
|
||||
}
|
||||
// Livestreamed segments sometimes have a Cluster length of 0xFFFFFFFFFFFFFF
|
||||
// which we parse as -1
|
||||
// this should be treated as Infinity
|
||||
if (value === -1) {
|
||||
return Infinity;
|
||||
}
|
||||
return value;
|
||||
},
|
||||
getUint8,
|
||||
getEBML: () => {
|
||||
const val = getUint8();
|
||||
// https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/#:~:text=The%20first%20four%20bytes%20(%201A,%E2%80%93%20read%20on%20for%20why).
|
||||
// You drop the initial 0 bits and the first 1 bit to get the value. 0x81 is 0b10000001, so there are zero inital 0 bits, meaning length one byte, and the value is 1. The 0x9F value for length of the EBML header we saw earlier is 0b10011111, still one byte, value is 0b0011111, which is 31 (the python repl is very helpful for these conversions).
|
||||
const actualValue = val & 0x7f; // 0x7F is binary 01111111, which masks out the first bit
|
||||
return actualValue;
|
||||
},
|
||||
getInt8: () => {
|
||||
const val = getView().getInt8(counter.getDiscardedOffset());
|
||||
counter.increment(1);
|
||||
return val;
|
||||
},
|
||||
getUint16: () => {
|
||||
const val = getView().getUint16(counter.getDiscardedOffset());
|
||||
counter.increment(2);
|
||||
return val;
|
||||
},
|
||||
getUint16Le: () => {
|
||||
const val = getView().getUint16(counter.getDiscardedOffset(), true);
|
||||
counter.increment(2);
|
||||
return val;
|
||||
},
|
||||
getUint24: () => {
|
||||
const val1 = getView().getUint8(counter.getDiscardedOffset());
|
||||
const val2 = getView().getUint8(counter.getDiscardedOffset() + 1);
|
||||
const val3 = getView().getUint8(counter.getDiscardedOffset() + 2);
|
||||
counter.increment(3);
|
||||
return (val1 << 16) | (val2 << 8) | val3;
|
||||
},
|
||||
getInt24: () => {
|
||||
const val1 = getView().getInt8(counter.getDiscardedOffset());
|
||||
const val2 = getView().getUint8(counter.getDiscardedOffset() + 1);
|
||||
const val3 = getView().getUint8(counter.getDiscardedOffset() + 2);
|
||||
counter.increment(3);
|
||||
return (val1 << 16) | (val2 << 8) | val3;
|
||||
},
|
||||
getInt16: () => {
|
||||
const val = getView().getInt16(counter.getDiscardedOffset());
|
||||
counter.increment(2);
|
||||
return val;
|
||||
},
|
||||
getUint32,
|
||||
getUint64,
|
||||
getInt64,
|
||||
// https://developer.apple.com/documentation/quicktime-file-format/sound_sample_description_version_1
|
||||
// A 32-bit unsigned fixed-point number (16.16) that indicates the rate at which the sound samples were obtained.
|
||||
getFixedPointUnsigned1616Number: () => {
|
||||
const val = getUint32();
|
||||
return val / 2 ** 16;
|
||||
},
|
||||
getFixedPointSigned1616Number: () => {
|
||||
const val = getInt32();
|
||||
return val / 2 ** 16;
|
||||
},
|
||||
getFixedPointSigned230Number: () => {
|
||||
const val = getInt32();
|
||||
return val / 2 ** 30;
|
||||
},
|
||||
getPascalString: () => {
|
||||
const val = getSlice(32);
|
||||
return [...Array.from(new Uint8Array(val))];
|
||||
},
|
||||
getUint(length) {
|
||||
const bytes = getSlice(length);
|
||||
const numbers = [...Array.from(new Uint8Array(bytes))];
|
||||
return numbers.reduce((acc, byte, index) => acc + (byte << (8 * (numbers.length - index - 1))), 0);
|
||||
},
|
||||
getByteString(length, trimTrailingZeroes) {
|
||||
let bytes = getSlice(length);
|
||||
// This file has trailing zeroes throughout
|
||||
// https://github.com/remotion-dev/remotion/issues/4668#issuecomment-2561904068
|
||||
// eslint-disable-next-line no-unmodified-loop-condition
|
||||
while (trimTrailingZeroes && bytes[bytes.length - 1] === 0) {
|
||||
bytes = bytes.slice(0, -1);
|
||||
}
|
||||
return new TextDecoder().decode(bytes).trim();
|
||||
},
|
||||
planBytes: (size) => {
|
||||
const currentOffset = counter.getOffset();
|
||||
return {
|
||||
discardRest: () => {
|
||||
const toDiscard = size - (counter.getOffset() - currentOffset);
|
||||
if (toDiscard < 0) {
|
||||
throw new Error('read too many bytes');
|
||||
}
|
||||
return getSlice(toDiscard);
|
||||
},
|
||||
};
|
||||
},
|
||||
getFloat64: () => {
|
||||
const val = getView().getFloat64(counter.getDiscardedOffset());
|
||||
counter.increment(8);
|
||||
return val;
|
||||
},
|
||||
readUntilNullTerminator,
|
||||
getFloat32: () => {
|
||||
const val = getView().getFloat32(counter.getDiscardedOffset());
|
||||
counter.increment(4);
|
||||
return val;
|
||||
},
|
||||
getUint32Le,
|
||||
getInt32Le,
|
||||
getInt32,
|
||||
destroy,
|
||||
startBox,
|
||||
readExpGolomb,
|
||||
startCheckpoint,
|
||||
getFlacCodecNumber,
|
||||
readUntilLineEnd,
|
||||
getSyncSafeInt32,
|
||||
replaceData,
|
||||
};
|
||||
};
|
||||
exports.getArrayBufferIterator = getArrayBufferIterator;
|
||||
20
remotion/node_modules/@remotion/media-parser/dist/iterator/buffer-manager.d.ts
generated
vendored
Normal file
20
remotion/node_modules/@remotion/media-parser/dist/iterator/buffer-manager.d.ts
generated
vendored
Normal file
@@ -0,0 +1,20 @@
|
||||
import type { MediaParserLogLevel } from '../log';
|
||||
import type { ParseMediaMode } from '../options';
|
||||
import type { OffsetCounter } from './offset-counter';
|
||||
export declare const bufferManager: ({ initialData, maxBytes, counter, logLevel, }: {
|
||||
initialData: Uint8Array;
|
||||
maxBytes: number;
|
||||
counter: OffsetCounter;
|
||||
logLevel: MediaParserLogLevel;
|
||||
}) => {
|
||||
getView: () => DataView<ArrayBufferLike>;
|
||||
getUint8Array: () => Uint8Array<ArrayBufferLike>;
|
||||
destroy: () => void;
|
||||
addData: (newData: Uint8Array) => void;
|
||||
skipTo: (offset: number) => void;
|
||||
removeBytesRead: (force: boolean, mode: ParseMediaMode) => {
|
||||
bytesRemoved: number;
|
||||
removedData: Uint8Array<ArrayBuffer> | null;
|
||||
};
|
||||
replaceData: (newData: Uint8Array, seekTo: number) => void;
|
||||
};
|
||||
101
remotion/node_modules/@remotion/media-parser/dist/iterator/buffer-manager.js
generated
vendored
Normal file
101
remotion/node_modules/@remotion/media-parser/dist/iterator/buffer-manager.js
generated
vendored
Normal file
@@ -0,0 +1,101 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.bufferManager = void 0;
|
||||
const log_1 = require("../log");
|
||||
const polyfilled_arraybuffer_1 = require("./polyfilled-arraybuffer");
|
||||
const makeBufferWithMaxBytes = (initialData, maxBytes) => {
|
||||
const maxByteLength = Math.min(maxBytes, 2 ** 31);
|
||||
try {
|
||||
const buf = new ArrayBuffer(initialData.byteLength, {
|
||||
maxByteLength,
|
||||
});
|
||||
return new polyfilled_arraybuffer_1.ResizableBuffer(buf);
|
||||
}
|
||||
catch (e) {
|
||||
// Cloudflare Workers have a limit of 128MB max array buffer size
|
||||
if (e instanceof RangeError && maxBytes > 2 ** 27) {
|
||||
return new polyfilled_arraybuffer_1.ResizableBuffer(new ArrayBuffer(initialData.byteLength, {
|
||||
maxByteLength: 2 ** 27,
|
||||
}));
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
};
|
||||
const bufferManager = ({ initialData, maxBytes, counter, logLevel, }) => {
|
||||
const buf = makeBufferWithMaxBytes(initialData, maxBytes);
|
||||
if (!buf.buffer.resize) {
|
||||
log_1.Log.warn(logLevel, '`ArrayBuffer.resize` is not supported in this Runtime. Using slow polyfill.');
|
||||
}
|
||||
buf.uintarray.set(initialData);
|
||||
let view = new DataView(buf.uintarray.buffer);
|
||||
const destroy = () => {
|
||||
buf.uintarray = new Uint8Array(0);
|
||||
buf.resize(0);
|
||||
};
|
||||
const flushBytesRead = (force, mode) => {
|
||||
const bytesToRemove = counter.getDiscardedOffset();
|
||||
// Only do this operation if it is really worth it 😇
|
||||
// let's set the threshold to 3MB
|
||||
if (bytesToRemove < 3000000 && !force) {
|
||||
return { bytesRemoved: 0, removedData: null };
|
||||
}
|
||||
// Don't remove if the data is not even available
|
||||
if (view.byteLength < bytesToRemove && !force) {
|
||||
return { bytesRemoved: 0, removedData: null };
|
||||
}
|
||||
counter.discardBytes(bytesToRemove);
|
||||
const removedData = mode === 'download' ? buf.uintarray.slice(0, bytesToRemove) : null;
|
||||
const newData = buf.uintarray.slice(bytesToRemove);
|
||||
buf.uintarray.set(newData);
|
||||
buf.resize(newData.byteLength);
|
||||
view = new DataView(buf.uintarray.buffer);
|
||||
return { bytesRemoved: bytesToRemove, removedData };
|
||||
};
|
||||
const skipTo = (offset) => {
|
||||
const becomesSmaller = offset < counter.getOffset();
|
||||
if (becomesSmaller) {
|
||||
const toDecrement = counter.getOffset() - offset;
|
||||
if (toDecrement > counter.getDiscardedOffset()) {
|
||||
throw new Error('Cannot count backwards, data has already been flushed');
|
||||
}
|
||||
counter.decrement(toDecrement);
|
||||
}
|
||||
const currentOffset = counter.getOffset();
|
||||
counter.increment(offset - currentOffset);
|
||||
};
|
||||
const addData = (newData) => {
|
||||
const oldLength = buf.buffer.byteLength;
|
||||
const newLength = oldLength + newData.byteLength;
|
||||
if (newLength < oldLength) {
|
||||
throw new Error('Cannot decrement size');
|
||||
}
|
||||
if (newLength > (maxBytes !== null && maxBytes !== void 0 ? maxBytes : Infinity)) {
|
||||
throw new Error(`Exceeded maximum byte length ${maxBytes} with ${newLength}`);
|
||||
}
|
||||
buf.resize(newLength);
|
||||
buf.uintarray = new Uint8Array(buf.buffer);
|
||||
buf.uintarray.set(newData, oldLength);
|
||||
view = new DataView(buf.uintarray.buffer);
|
||||
};
|
||||
const replaceData = (newData, seekTo) => {
|
||||
buf.resize(newData.byteLength);
|
||||
buf.uintarray = new Uint8Array(buf.buffer);
|
||||
buf.uintarray.set(newData);
|
||||
view = new DataView(buf.uintarray.buffer);
|
||||
counter.setDiscardedOffset(seekTo);
|
||||
// reset counter to 0
|
||||
counter.decrement(counter.getOffset());
|
||||
// seek to the new position
|
||||
counter.increment(seekTo);
|
||||
};
|
||||
return {
|
||||
getView: () => view,
|
||||
getUint8Array: () => buf.uintarray,
|
||||
destroy,
|
||||
addData,
|
||||
skipTo,
|
||||
removeBytesRead: flushBytesRead,
|
||||
replaceData,
|
||||
};
|
||||
};
|
||||
exports.bufferManager = bufferManager;
|
||||
10
remotion/node_modules/@remotion/media-parser/dist/iterator/offset-counter.d.ts
generated
vendored
Normal file
10
remotion/node_modules/@remotion/media-parser/dist/iterator/offset-counter.d.ts
generated
vendored
Normal file
@@ -0,0 +1,10 @@
|
||||
export declare const makeOffsetCounter: (initial: number) => {
|
||||
getOffset: () => number;
|
||||
discardBytes: (bytes: number) => void;
|
||||
increment: (bytes: number) => void;
|
||||
getDiscardedBytes: () => number;
|
||||
setDiscardedOffset: (bytes: number) => void;
|
||||
getDiscardedOffset: () => number;
|
||||
decrement: (bytes: number) => void;
|
||||
};
|
||||
export type OffsetCounter = ReturnType<typeof makeOffsetCounter>;
|
||||
31
remotion/node_modules/@remotion/media-parser/dist/iterator/offset-counter.js
generated
vendored
Normal file
31
remotion/node_modules/@remotion/media-parser/dist/iterator/offset-counter.js
generated
vendored
Normal file
@@ -0,0 +1,31 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.makeOffsetCounter = void 0;
|
||||
const makeOffsetCounter = (initial) => {
|
||||
let offset = initial;
|
||||
let discardedBytes = 0;
|
||||
return {
|
||||
getOffset: () => offset,
|
||||
discardBytes: (bytes) => {
|
||||
discardedBytes += bytes;
|
||||
},
|
||||
increment: (bytes) => {
|
||||
if (bytes < 0) {
|
||||
throw new Error('Cannot increment by a negative amount: ' + bytes);
|
||||
}
|
||||
offset += bytes;
|
||||
},
|
||||
getDiscardedBytes: () => discardedBytes,
|
||||
setDiscardedOffset: (bytes) => {
|
||||
discardedBytes = bytes;
|
||||
},
|
||||
getDiscardedOffset: () => offset - discardedBytes,
|
||||
decrement: (bytes) => {
|
||||
if (bytes < 0) {
|
||||
throw new Error('Cannot decrement by a negative amount: ' + bytes);
|
||||
}
|
||||
offset -= bytes;
|
||||
},
|
||||
};
|
||||
};
|
||||
exports.makeOffsetCounter = makeOffsetCounter;
|
||||
6
remotion/node_modules/@remotion/media-parser/dist/iterator/polyfilled-arraybuffer.d.ts
generated
vendored
Normal file
6
remotion/node_modules/@remotion/media-parser/dist/iterator/polyfilled-arraybuffer.d.ts
generated
vendored
Normal file
@@ -0,0 +1,6 @@
|
||||
export declare class ResizableBuffer {
|
||||
buffer: ArrayBuffer;
|
||||
uintarray: Uint8Array;
|
||||
constructor(buffer: ArrayBuffer);
|
||||
resize(newLength: number): void;
|
||||
}
|
||||
21
remotion/node_modules/@remotion/media-parser/dist/iterator/polyfilled-arraybuffer.js
generated
vendored
Normal file
21
remotion/node_modules/@remotion/media-parser/dist/iterator/polyfilled-arraybuffer.js
generated
vendored
Normal file
@@ -0,0 +1,21 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.ResizableBuffer = void 0;
|
||||
class ResizableBuffer {
|
||||
constructor(buffer) {
|
||||
this.buffer = buffer;
|
||||
this.uintarray = new Uint8Array(buffer);
|
||||
}
|
||||
resize(newLength) {
|
||||
if (typeof this.buffer.resize === 'function') {
|
||||
this.buffer.resize(newLength);
|
||||
}
|
||||
else {
|
||||
const newBuffer = new ArrayBuffer(newLength);
|
||||
new Uint8Array(newBuffer).set(new Uint8Array(this.buffer).subarray(0, Math.min(this.buffer.byteLength, newLength)));
|
||||
this.buffer = newBuffer;
|
||||
this.uintarray = new Uint8Array(newBuffer);
|
||||
}
|
||||
}
|
||||
}
|
||||
exports.ResizableBuffer = ResizableBuffer;
|
||||
Reference in New Issue
Block a user