init commit
This commit is contained in:
Carlos
527
remotion/node_modules/@remotion/media-parser/dist/state/parser-state.d.ts
generated
vendored
Normal file
527
remotion/node_modules/@remotion/media-parser/dist/state/parser-state.d.ts
generated
vendored
Normal file
@@ -0,0 +1,527 @@
|
||||
import type { AvcPPs, AvcProfileInfo } from '../containers/avc/parse-avc';
|
||||
import type { SelectM3uAssociatedPlaylistsFn, SelectM3uStreamFn } from '../containers/m3u/select-stream';
|
||||
import type { MediaParserController } from '../controller/media-parser-controller';
|
||||
import type { PrefetchCache } from '../fetch';
|
||||
import type { Options, ParseMediaFields } from '../fields';
|
||||
import { type BufferIterator } from '../iterator/buffer-iterator';
|
||||
import { type MediaParserLogLevel } from '../log';
|
||||
import type { M3uPlaylistContext, OnDiscardedData, ParseMediaCallbacks, ParseMediaMode, ParseMediaSrc } from '../options';
|
||||
import type { MediaParserReaderInterface, Reader } from '../readers/reader';
|
||||
import type { MediaParserOnAudioTrack, MediaParserOnVideoTrack } from '../webcodec-sample-types';
|
||||
export type InternalStats = {
|
||||
skippedBytes: number;
|
||||
finalCursorOffset: number;
|
||||
};
|
||||
export type SpsAndPps = {
|
||||
sps: AvcProfileInfo;
|
||||
pps: AvcPPs;
|
||||
};
|
||||
export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, selectM3uAssociatedPlaylistsFn, m3uPlaylistContext, contentType, name, callbacks, fieldsInReturnValue, mimeType, initialReaderInstance, makeSamplesStartAtZero, prefetchCache, }: {
|
||||
hasAudioTrackHandlers: boolean;
|
||||
hasVideoTrackHandlers: boolean;
|
||||
controller: MediaParserController;
|
||||
onAudioTrack: MediaParserOnAudioTrack | null;
|
||||
onVideoTrack: MediaParserOnVideoTrack | null;
|
||||
contentLength: number;
|
||||
logLevel: MediaParserLogLevel;
|
||||
mode: ParseMediaMode;
|
||||
src: ParseMediaSrc;
|
||||
readerInterface: MediaParserReaderInterface;
|
||||
onDiscardedData: OnDiscardedData | null;
|
||||
selectM3uStreamFn: SelectM3uStreamFn;
|
||||
selectM3uAssociatedPlaylistsFn: SelectM3uAssociatedPlaylistsFn;
|
||||
m3uPlaylistContext: M3uPlaylistContext | null;
|
||||
contentType: string | null;
|
||||
name: string;
|
||||
callbacks: ParseMediaCallbacks;
|
||||
fieldsInReturnValue: Options<ParseMediaFields>;
|
||||
mimeType: string | null;
|
||||
initialReaderInstance: Reader;
|
||||
makeSamplesStartAtZero: boolean;
|
||||
prefetchCache: PrefetchCache;
|
||||
}) => {
|
||||
riff: {
|
||||
getAvcProfile: () => SpsAndPps | null;
|
||||
onProfile: (profile: SpsAndPps) => Promise<void>;
|
||||
registerOnAvcProfileCallback: (callback: (profile: SpsAndPps) => Promise<void>) => void;
|
||||
getNextTrackIndex: () => number;
|
||||
queuedBFrames: {
|
||||
addFrame: ({ frame, maxFramesInBuffer, trackId, timescale, }: {
|
||||
frame: import("./riff/queued-frames").QueuedVideoSample;
|
||||
trackId: number;
|
||||
maxFramesInBuffer: number;
|
||||
timescale: number;
|
||||
}) => void;
|
||||
flush: () => void;
|
||||
getReleasedFrame: () => {
|
||||
sample: import("./riff/queued-frames").QueuedVideoSample;
|
||||
trackId: number;
|
||||
timescale: number;
|
||||
} | null;
|
||||
hasReleasedFrames: () => boolean;
|
||||
clear: () => void;
|
||||
};
|
||||
incrementNextTrackIndex: () => void;
|
||||
lazyIdx1: {
|
||||
triggerLoad: (position: number) => Promise<{
|
||||
entries: import("../containers/riff/riff-box").Idx1Entry[];
|
||||
videoTrackIndex: number | null;
|
||||
}>;
|
||||
getLoadedIdx1: () => Promise<{
|
||||
entries: import("../containers/riff/riff-box").Idx1Entry[];
|
||||
videoTrackIndex: number | null;
|
||||
} | null>;
|
||||
getIfAlreadyLoaded: () => {
|
||||
entries: import("../containers/riff/riff-box").Idx1Entry[];
|
||||
videoTrackIndex: number | null;
|
||||
} | null;
|
||||
setFromSeekingHints: (hints: import("../containers/riff/seeking-hints").RiffSeekingHints) => void;
|
||||
waitForLoaded: () => Promise<{
|
||||
entries: import("../containers/riff/riff-box").Idx1Entry[];
|
||||
videoTrackIndex: number | null;
|
||||
}> | Promise<null>;
|
||||
};
|
||||
sampleCounter: {
|
||||
onAudioSample: (trackId: number, audioSample: import("../webcodec-sample-types").MediaParserAudioSample) => void;
|
||||
onVideoSample: ({ trackId, videoSample, }: {
|
||||
videoSample: import("../webcodec-sample-types").MediaParserVideoSample;
|
||||
trackId: number;
|
||||
}) => void;
|
||||
getSampleCountForTrack: ({ trackId }: {
|
||||
trackId: number;
|
||||
}) => number;
|
||||
setSamplesFromSeek: (samples: Record<number, number>) => void;
|
||||
riffKeys: {
|
||||
addKeyframe: (keyframe: import("./riff/riff-keyframes").RiffKeyframe) => void;
|
||||
getKeyframes: () => import("./riff/riff-keyframes").RiffKeyframe[];
|
||||
setFromSeekingHints: (keyframesFromHints: import("./riff/riff-keyframes").RiffKeyframe[]) => void;
|
||||
};
|
||||
setPocAtKeyframeOffset: ({ keyframeOffset, poc, }: {
|
||||
keyframeOffset: number;
|
||||
poc: number;
|
||||
}) => void;
|
||||
getPocAtKeyframeOffset: ({ keyframeOffset, }: {
|
||||
keyframeOffset: number;
|
||||
}) => number[];
|
||||
getKeyframeAtOffset: (sample: import("./riff/queued-frames").QueuedVideoSample) => number | null;
|
||||
};
|
||||
};
|
||||
transportStream: {
|
||||
nextPesHeaderStore: {
|
||||
setNextPesHeader: (pesHeader: import("../containers/transport-stream/parse-pes").PacketPes) => void;
|
||||
getNextPesHeader: () => import("../containers/transport-stream/parse-pes").PacketPes;
|
||||
};
|
||||
observedPesHeaders: {
|
||||
pesHeaders: import("../containers/transport-stream/parse-pes").PacketPes[];
|
||||
addPesHeader: (pesHeader: import("../containers/transport-stream/parse-pes").PacketPes) => void;
|
||||
markPtsAsKeyframe: (pts: number) => void;
|
||||
getPesKeyframeHeaders: () => import("../containers/transport-stream/parse-pes").PacketPes[];
|
||||
setPesKeyframesFromSeekingHints: (hints: import("../seeking-hints").TransportStreamSeekingHints) => void;
|
||||
};
|
||||
streamBuffers: Map<number, import("../containers/transport-stream/process-stream-buffers").TransportStreamPacketBuffer>;
|
||||
startOffset: {
|
||||
getOffset: (trackId: number) => number;
|
||||
setOffset: ({ newOffset, trackId }: {
|
||||
trackId: number;
|
||||
newOffset: number;
|
||||
}) => void;
|
||||
};
|
||||
resetBeforeSeek: () => void;
|
||||
lastEmittedSample: {
|
||||
setLastEmittedSample: (sample: import("../webcodec-sample-types").MediaParserAudioSample | import("../webcodec-sample-types").MediaParserVideoSample) => void;
|
||||
getLastEmittedSample: () => import("../webcodec-sample-types").MediaParserVideoSample | import("../webcodec-sample-types").MediaParserAudioSample | null;
|
||||
resetLastEmittedSample: () => void;
|
||||
};
|
||||
};
|
||||
webm: {
|
||||
cues: {
|
||||
triggerLoad: (position: number, segmentOffset: number) => Promise<import("../containers/webm/seek/format-cues").MatroskaCue[] | null>;
|
||||
getLoadedCues: () => Promise<{
|
||||
cues: import("../containers/webm/seek/format-cues").MatroskaCue[];
|
||||
segmentOffset: number;
|
||||
} | null>;
|
||||
getIfAlreadyLoaded: () => {
|
||||
cues: import("../containers/webm/seek/format-cues").MatroskaCue[];
|
||||
segmentOffset: number;
|
||||
} | null;
|
||||
setFromSeekingHints: (hints: import("../seeking-hints").WebmSeekingHints) => void;
|
||||
};
|
||||
onTrackEntrySegment: import("../containers/webm/segments").OnTrackEntrySegment;
|
||||
getTrackInfoByNumber: (id: number) => import("../containers/webm/segments/track-entry").TrackInfo;
|
||||
setTimestampOffset: (byteOffset: number, timestamp: number) => void;
|
||||
getTimestampOffsetForByteOffset: (byteOffset: number) => number | undefined;
|
||||
getTimeStampMapForSeekingHints: () => Map<number, number>;
|
||||
setTimeStampMapForSeekingHints: (newTimestampMap: Map<number, number>) => void;
|
||||
getTimescale: () => number;
|
||||
setTimescale: (newTimescale: number) => void;
|
||||
addSegment: (seg: Omit<import("./matroska/webm").SegmentSection, "index">) => void;
|
||||
addCluster: (cluster: import("./matroska/webm").ClusterSection) => void;
|
||||
getFirstCluster: () => import("./matroska/webm").ClusterSection | undefined;
|
||||
isInsideSegment: (iterator: BufferIterator) => import("./matroska/webm").SegmentSection | null;
|
||||
isInsideCluster: (offset: number) => import("./matroska/webm").ClusterSection | null;
|
||||
setAvcProfileForTrackNumber: (trackNumber: number, avcProfile: AvcProfileInfo) => void;
|
||||
getAvcProfileForTrackNumber: (trackNumber: number) => AvcProfileInfo | null;
|
||||
};
|
||||
iso: {
|
||||
flatSamples: {
|
||||
getSamples: (mdatStart: number) => {
|
||||
trackId: number;
|
||||
samplePositions: import("../get-sample-positions").SamplePosition[];
|
||||
}[] | null;
|
||||
setSamples: (mdatStart: number, samples: {
|
||||
trackId: number;
|
||||
samplePositions: import("../get-sample-positions").SamplePosition[];
|
||||
}[]) => void;
|
||||
setCurrentSampleIndex: (mdatStart: number, trackId: number, index: number) => void;
|
||||
getCurrentSampleIndices: (mdatStart: number) => Record<number, number>;
|
||||
updateAfterSeek: (seekedByte: number) => void;
|
||||
};
|
||||
moov: {
|
||||
setMoovBox: (moov: {
|
||||
moovBox: import("../containers/iso-base-media/moov/moov").MoovBox;
|
||||
precomputed: boolean;
|
||||
}) => void;
|
||||
getMoovBoxAndPrecomputed: () => {
|
||||
moovBox: import("../containers/iso-base-media/moov/moov").MoovBox;
|
||||
precomputed: boolean;
|
||||
} | null;
|
||||
};
|
||||
mfra: {
|
||||
triggerLoad: () => Promise<import("../containers/iso-base-media/base-media-box").IsoBaseMediaBox[] | null>;
|
||||
getIfAlreadyLoaded: () => import("../containers/iso-base-media/base-media-box").IsoBaseMediaBox[] | null;
|
||||
setFromSeekingHints: (hints: import("../seeking-hints").IsoBaseMediaSeekingHints) => void;
|
||||
};
|
||||
moof: {
|
||||
getMoofBoxes: () => import("./iso-base-media/precomputed-moof").MoofBox[];
|
||||
setMoofBoxes: (boxes: import("./iso-base-media/precomputed-moof").MoofBox[]) => void;
|
||||
};
|
||||
tfra: {
|
||||
getTfraBoxes: () => import("../containers/iso-base-media/mfra/tfra").TfraBox[];
|
||||
setTfraBoxes: (boxes: import("../containers/iso-base-media/mfra/tfra").TfraBox[]) => void;
|
||||
};
|
||||
movieTimeScale: {
|
||||
getTrackTimescale: () => number | null;
|
||||
setTrackTimescale: (timescale: number) => void;
|
||||
};
|
||||
};
|
||||
mp3: {
|
||||
getMp3Info: () => import("./mp3").Mp3Info | null;
|
||||
setMp3Info: (info: import("./mp3").Mp3Info) => void;
|
||||
getMp3BitrateInfo: () => import("./mp3").Mp3BitrateInfo | null;
|
||||
setMp3BitrateInfo: (info: import("./mp3").Mp3BitrateInfo) => void;
|
||||
audioSamples: {
|
||||
addSample: (audioSampleOffset: import("./audio-sample-map").AudioSampleOffset) => void;
|
||||
getSamples: () => import("./audio-sample-map").AudioSampleOffset[];
|
||||
setFromSeekingHints: (newMap: import("./audio-sample-map").AudioSampleOffset[]) => void;
|
||||
};
|
||||
};
|
||||
aac: {
|
||||
addSample: ({ offset, size }: {
|
||||
offset: number;
|
||||
size: number;
|
||||
}) => {
|
||||
offset: number;
|
||||
index: number;
|
||||
size: number;
|
||||
};
|
||||
getSamples: () => {
|
||||
offset: number;
|
||||
index: number;
|
||||
size: number;
|
||||
}[];
|
||||
audioSamples: {
|
||||
addSample: (audioSampleOffset: import("./audio-sample-map").AudioSampleOffset) => void;
|
||||
getSamples: () => import("./audio-sample-map").AudioSampleOffset[];
|
||||
setFromSeekingHints: (newMap: import("./audio-sample-map").AudioSampleOffset[]) => void;
|
||||
};
|
||||
};
|
||||
flac: {
|
||||
setBlockingBitStrategy: (strategy: number) => void;
|
||||
getBlockingBitStrategy: () => number | undefined;
|
||||
audioSamples: {
|
||||
addSample: (audioSampleOffset: import("./audio-sample-map").AudioSampleOffset) => void;
|
||||
getSamples: () => import("./audio-sample-map").AudioSampleOffset[];
|
||||
setFromSeekingHints: (newMap: import("./audio-sample-map").AudioSampleOffset[]) => void;
|
||||
};
|
||||
};
|
||||
m3u: {
|
||||
setSelectedMainPlaylist: (stream: import("./m3u-state").M3uStreamOrInitialUrl) => void;
|
||||
getSelectedMainPlaylist: () => import("./m3u-state").M3uStreamOrInitialUrl | null;
|
||||
setHasEmittedVideoTrack: (src: string, callback: import("../webcodec-sample-types").MediaParserOnVideoSample | null) => void;
|
||||
hasEmittedVideoTrack: (src: string) => false | import("../webcodec-sample-types").MediaParserOnVideoSample | null;
|
||||
setHasEmittedAudioTrack: (src: string, callback: import("../webcodec-sample-types").MediaParserOnAudioSample | null) => void;
|
||||
hasEmittedAudioTrack: (src: string) => false | import("../webcodec-sample-types").MediaParserOnAudioSample | null;
|
||||
setHasEmittedDoneWithTracks: (src: string) => void;
|
||||
hasEmittedDoneWithTracks: (src: string) => boolean;
|
||||
setReadyToIterateOverM3u: () => void;
|
||||
isReadyToIterateOverM3u: () => boolean;
|
||||
setAllChunksProcessed: (src: string) => void;
|
||||
clearAllChunksProcessed: () => void;
|
||||
getAllChunksProcessedForPlaylist: (src: string) => boolean;
|
||||
getAllChunksProcessedOverall: () => boolean;
|
||||
setHasFinishedManifest: () => void;
|
||||
hasFinishedManifest: () => boolean;
|
||||
setM3uStreamRun: (playlistUrl: string, run: import("./m3u-state").M3uRun | null) => void;
|
||||
setTracksDone: (playlistUrl: string) => boolean;
|
||||
getTrackDone: (playlistUrl: string) => boolean;
|
||||
clearTracksDone: () => void;
|
||||
getM3uStreamRun: (playlistUrl: string) => import("./m3u-state").M3uRun;
|
||||
abortM3UStreamRuns: () => void;
|
||||
setAssociatedPlaylists: (playlists: import("..").M3uAssociatedPlaylist[]) => void;
|
||||
getAssociatedPlaylists: () => import("..").M3uAssociatedPlaylist[] | null;
|
||||
getSelectedPlaylists: () => string[];
|
||||
sampleSorter: {
|
||||
clearSamples: () => void;
|
||||
addToStreamWithTrack: (src: string) => void;
|
||||
addVideoStreamToConsider: (src: string, callback: import("../webcodec-sample-types").MediaParserOnVideoSample) => void;
|
||||
addAudioStreamToConsider: (src: string, callback: import("../webcodec-sample-types").MediaParserOnAudioSample) => void;
|
||||
hasAudioStreamToConsider: (src: string) => boolean;
|
||||
hasVideoStreamToConsider: (src: string) => boolean;
|
||||
addAudioSample: (src: string, sample: import("../webcodec-sample-types").MediaParserAudioSample) => Promise<void>;
|
||||
addVideoSample: (src: string, sample: import("../webcodec-sample-types").MediaParserVideoSample) => Promise<void>;
|
||||
getNextStreamToRun: (streams: string[]) => string;
|
||||
};
|
||||
setMp4HeaderSegment: (playlistUrl: string, structure: import("../parse-result").IsoBaseMediaStructure) => void;
|
||||
getMp4HeaderSegment: (playlistUrl: string) => import("../parse-result").IsoBaseMediaStructure;
|
||||
setSeekToSecondsToProcess: (playlistUrl: string, m3uSeek: {
|
||||
targetTime: number;
|
||||
} | null) => void;
|
||||
getSeekToSecondsToProcess: (playlistUrl: string) => {
|
||||
targetTime: number;
|
||||
} | null;
|
||||
setNextSeekShouldSubtractChunks: (playlistUrl: string, chunks: number) => void;
|
||||
getNextSeekShouldSubtractChunks: (playlistUrl: string) => number;
|
||||
};
|
||||
timings: {
|
||||
timeIterating: number;
|
||||
timeReadingData: number;
|
||||
timeSeeking: number;
|
||||
timeCheckingIfDone: number;
|
||||
timeFreeingData: number;
|
||||
timeInParseLoop: number;
|
||||
};
|
||||
callbacks: {
|
||||
registerVideoSampleCallback: (id: number, callback: import("../webcodec-sample-types").MediaParserOnVideoSample | null) => Promise<void>;
|
||||
onAudioSample: ({ audioSample, trackId, }: {
|
||||
trackId: number;
|
||||
audioSample: import("../webcodec-sample-types").MediaParserAudioSample;
|
||||
}) => Promise<void>;
|
||||
onVideoSample: ({ trackId, videoSample, }: {
|
||||
trackId: number;
|
||||
videoSample: import("../webcodec-sample-types").MediaParserVideoSample;
|
||||
}) => Promise<void>;
|
||||
canSkipTracksState: {
|
||||
doFieldsNeedTracks: () => boolean;
|
||||
canSkipTracks: () => boolean;
|
||||
};
|
||||
registerAudioSampleCallback: (id: number, callback: import("../webcodec-sample-types").MediaParserOnAudioSample | null) => Promise<void>;
|
||||
tracks: {
|
||||
hasAllTracks: () => boolean;
|
||||
getIsDone: () => boolean;
|
||||
setIsDone: (logLevel: MediaParserLogLevel) => void;
|
||||
addTrack: (track: import("..").MediaParserTrack) => void;
|
||||
getTracks: () => import("..").MediaParserTrack[];
|
||||
ensureHasTracksAtEnd: (fields: Options<ParseMediaFields>) => void;
|
||||
};
|
||||
audioSampleCallbacks: Record<number, import("../webcodec-sample-types").MediaParserOnAudioSample>;
|
||||
videoSampleCallbacks: Record<number, import("../webcodec-sample-types").MediaParserOnVideoSample>;
|
||||
hasAudioTrackHandlers: boolean;
|
||||
hasVideoTrackHandlers: boolean;
|
||||
callTracksDoneCallback: () => Promise<void>;
|
||||
};
|
||||
getInternalStats: () => InternalStats;
|
||||
getSkipBytes: () => number;
|
||||
increaseSkippedBytes: (bytes: number) => void;
|
||||
keyframes: {
|
||||
addKeyframe: (keyframe: import("../options").MediaParserKeyframe) => void;
|
||||
getKeyframes: () => import("../options").MediaParserKeyframe[];
|
||||
setFromSeekingHints: (keyframesFromHints: import("../options").MediaParserKeyframe[]) => void;
|
||||
};
|
||||
structure: {
|
||||
getStructureOrNull: () => import("../parse-result").MediaParserStructureUnstable | null;
|
||||
getStructure: () => import("../parse-result").MediaParserStructureUnstable;
|
||||
setStructure: (value: import("../parse-result").MediaParserStructureUnstable) => void;
|
||||
getFlacStructure: () => import("../containers/flac/types").FlacStructure;
|
||||
getIsoStructure: () => import("../parse-result").IsoBaseMediaStructure;
|
||||
getMp3Structure: () => import("../parse-result").Mp3Structure;
|
||||
getM3uStructure: () => import("../containers/m3u/types").M3uStructure;
|
||||
getRiffStructure: () => import("../containers/riff/riff-box").RiffStructure;
|
||||
getTsStructure: () => import("../parse-result").TransportStreamStructure;
|
||||
getWavStructure: () => import("../containers/wav/types").WavStructure;
|
||||
getMatroskaStructure: () => import("../parse-result").MatroskaStructure;
|
||||
};
|
||||
onAudioTrack: MediaParserOnAudioTrack | null;
|
||||
onVideoTrack: MediaParserOnVideoTrack | null;
|
||||
emittedFields: import("../fields").AllOptions<ParseMediaFields>;
|
||||
fields: Partial<import("../fields").AllOptions<ParseMediaFields>>;
|
||||
samplesObserved: {
|
||||
addVideoSample: (videoSample: import("../webcodec-sample-types").MediaParserVideoSample) => void;
|
||||
addAudioSample: (audioSample: import("../webcodec-sample-types").MediaParserAudioSample) => void;
|
||||
getSlowDurationInSeconds: () => number;
|
||||
getFps: () => number;
|
||||
getSlowNumberOfFrames: () => number;
|
||||
getAudioBitrate: () => number | null;
|
||||
getVideoBitrate: () => number | null;
|
||||
getLastSampleObserved: () => boolean;
|
||||
setLastSampleObserved: () => void;
|
||||
getAmountOfSamplesObserved: () => number;
|
||||
};
|
||||
contentLength: number;
|
||||
images: {
|
||||
images: import("./images").MediaParserEmbeddedImage[];
|
||||
addImage: (image: import("./images").MediaParserEmbeddedImage) => void;
|
||||
};
|
||||
mediaSection: {
|
||||
addMediaSection: (section: import("./video-section").MediaSection) => void;
|
||||
getMediaSections: () => import("./video-section").MediaSection[];
|
||||
isCurrentByteInMediaSection: (iterator: BufferIterator) => "no-section-defined" | "in-section" | "outside-section";
|
||||
isByteInMediaSection: ({ position, mediaSections, }: {
|
||||
position: number;
|
||||
mediaSections: import("./video-section").MediaSection[];
|
||||
}) => "no-section-defined" | "in-section" | "outside-section";
|
||||
getCurrentMediaSection: ({ offset, mediaSections, }: {
|
||||
offset: number;
|
||||
mediaSections: import("./video-section").MediaSection[];
|
||||
}) => import("./video-section").MediaSection | null;
|
||||
getMediaSectionAssertOnlyOne: () => import("./video-section").MediaSection;
|
||||
mediaSections: import("./video-section").MediaSection[];
|
||||
};
|
||||
logLevel: "trace" | "verbose" | "info" | "warn" | "error";
|
||||
iterator: {
|
||||
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: 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;
|
||||
};
|
||||
controller: MediaParserController;
|
||||
mode: ParseMediaMode;
|
||||
src: ParseMediaSrc;
|
||||
readerInterface: MediaParserReaderInterface;
|
||||
discardReadBytes: (force: boolean) => Promise<void>;
|
||||
selectM3uStreamFn: SelectM3uStreamFn;
|
||||
selectM3uAssociatedPlaylistsFn: SelectM3uAssociatedPlaylistsFn;
|
||||
m3uPlaylistContext: M3uPlaylistContext | null;
|
||||
contentType: string | null;
|
||||
name: string;
|
||||
returnValue: {
|
||||
dimensions: import("..").MediaParserDimensions | null;
|
||||
durationInSeconds: number | null;
|
||||
slowDurationInSeconds: number;
|
||||
slowNumberOfFrames: number;
|
||||
slowFps: number;
|
||||
slowStructure: import("../parse-result").MediaParserStructureUnstable;
|
||||
fps: number | null;
|
||||
videoCodec: import("..").MediaParserVideoCodec | null;
|
||||
audioCodec: import("..").MediaParserAudioCodec | null;
|
||||
tracks: import("..").MediaParserTrack[];
|
||||
rotation: number | null;
|
||||
unrotatedDimensions: import("..").MediaParserDimensions | null;
|
||||
internalStats: InternalStats;
|
||||
size: number | null;
|
||||
name: string;
|
||||
container: import("../options").MediaParserContainer;
|
||||
isHdr: boolean;
|
||||
metadata: import("..").MediaParserMetadataEntry[];
|
||||
location: import("..").MediaParserLocation | null;
|
||||
mimeType: string | null;
|
||||
keyframes: import("../options").MediaParserKeyframe[] | null;
|
||||
slowKeyframes: import("../options").MediaParserKeyframe[];
|
||||
images: import("./images").MediaParserEmbeddedImage[];
|
||||
sampleRate: number | null;
|
||||
numberOfAudioChannels: number | null;
|
||||
slowVideoBitrate: number | null;
|
||||
slowAudioBitrate: number | null;
|
||||
m3uStreams: import("..").M3uStream[] | null;
|
||||
};
|
||||
callbackFunctions: Partial<import("../options").ParseMediaCallbacksMandatory>;
|
||||
fieldsInReturnValue: Partial<import("../fields").AllOptions<ParseMediaFields>>;
|
||||
mimeType: string | null;
|
||||
errored: Error | null;
|
||||
currentReader: {
|
||||
getCurrent: () => Reader;
|
||||
setCurrent: (newReader: Reader) => void;
|
||||
};
|
||||
seekInfiniteLoop: {
|
||||
registerSeek: (byte: number) => void;
|
||||
reset: () => void;
|
||||
};
|
||||
makeSamplesStartAtZero: boolean;
|
||||
prefetchCache: PrefetchCache;
|
||||
avc: {
|
||||
getPrevPicOrderCntLsb(): number;
|
||||
getPrevPicOrderCntMsb(): number;
|
||||
setPrevPicOrderCntLsb(value: number): void;
|
||||
setPrevPicOrderCntMsb(value: number): void;
|
||||
setSps(value: import("../containers/avc/parse-avc").SpsInfo): void;
|
||||
getSps(): import("../containers/avc/parse-avc").SpsInfo | null;
|
||||
getMaxFramesInBuffer(): number | null;
|
||||
clear(): void;
|
||||
};
|
||||
};
|
||||
export type ParserState = ReturnType<typeof makeParserState>;
|
||||
Reference in New Issue
Block a user