pgs.js/dist/types/pgs/type.d.ts

PGS (Presentation Graphic Stream) Subtitle For HTML5 Media Playback

import { AsyncByteStream, ByteStream } from "../util/bytestream";
export declare const SegmentType: {
    readonly PDS: 20;
    readonly ODS: 21;
    readonly PCS: 22;
    readonly WDS: 23;
    readonly END: 128;
};
type CompositionObjectWithCropped = {
    objectId: number;
    windowId: number;
    objectCroppedFlag: true;
    objectHorizontalPosition: number;
    objectVerticalPosition: number;
    objectCroppingHorizontalPosition: number;
    objectCroppingVerticalPosition: number;
    objectCroppingWidth: number;
    objectCroppingHeight: number;
};
type CompositionObjectWithoutCropped = {
    objectId: number;
    windowId: number;
    objectCroppedFlag: false;
    objectHorizontalPosition: number;
    objectVerticalPosition: number;
};
export type CompositionObject = CompositionObjectWithCropped | CompositionObjectWithoutCropped;
export declare const CompositionObject: {
    from(stream: ByteStream): CompositionObject;
};
export declare const CompositionState: {
    readonly Normal: 0;
    readonly AcquisitionPoint: 64;
    readonly EpochStart: 128;
};
export type PresentationCompositionSegment = {
    width: number;
    height: number;
    frameRate: number;
    compositionNumber: number;
    compositionState: (typeof CompositionState)[keyof typeof CompositionState];
    paletteUpdateFlag: boolean;
    paletteId: number;
    numberOfCompositionObject: number;
    compositionObjects: CompositionObject[];
};
export declare const PresentationCompositionSegment: {
    from(stream: ByteStream): PresentationCompositionSegment;
};
export type WindowDefinition = {
    windowId: number;
    windowHorizontalPosition: number;
    windowVerticalPosition: number;
    windowWidth: number;
    windowHeight: number;
};
export declare const WindowDefinition: {
    from(stream: ByteStream): WindowDefinition;
};
export type WindowDefinitionSegment = {
    numberOfWindow: number;
    windows: WindowDefinition[];
};
export declare const WindowDefinitionSegment: {
    from(stream: ByteStream): WindowDefinitionSegment;
    valueOf(definision?: WindowDefinitionSegment[]): Map<number, WindowDefinition>;
};
export type PaletteEntry = {
    paletteEntryID: number;
    luminance: number;
    colorDifferenceRed: number;
    colorDifferenceBlue: number;
    transparency: number;
};
export declare const PaletteEntry: {
    from(stream: ByteStream): PaletteEntry;
};
export type PaletteDefinitionSegment = {
    paletteID: number;
    paletteVersionNumber: number;
    paletteEntries: PaletteEntry[];
};
export declare const PaletteDefinitionSegment: {
    from(stream: ByteStream): PaletteDefinitionSegment;
};
export declare const SequenceFlag: {
    readonly LastInSequence: 64;
    readonly FirstInSequence: 128;
    readonly FirstAndLastInSequence: 192;
    readonly IntermediateSequence: 0;
};
type ObjectDefinitionSegmentFirstInSequence = {
    objectId: number;
    objectVersionNumber: number;
    lastInSequenceFlag: typeof SequenceFlag.FirstInSequence | typeof SequenceFlag.FirstAndLastInSequence;
    objectDataLength: number;
    width: number;
    height: number;
    objectData: ArrayBuffer;
};
type ObjectDefinitionSegmentOtherSequence = {
    objectId: number;
    objectVersionNumber: number;
    lastInSequenceFlag: typeof SequenceFlag.LastInSequence | typeof SequenceFlag.IntermediateSequence;
    objectData: ArrayBuffer;
};
export type ObjectDefinitionSegment = ObjectDefinitionSegmentFirstInSequence | ObjectDefinitionSegmentOtherSequence;
export declare const ObjectDefinitionSegment: {
    from(stream: ByteStream): ObjectDefinitionSegment;
    valueOf(definision?: ObjectDefinitionSegment[]): Map<number, ObjectDefinitionSegment[]>;
    isFirstInSequence(definision: ObjectDefinitionSegment): definision is ObjectDefinitionSegmentFirstInSequence;
};
export type DecodedObjectDefinitionSegment = {
    objectId: number;
    objectVersionNumber: number;
    objectDataLength: number;
    width: number;
    height: number;
    rgba: Uint8ClampedArray;
};
export declare const DecodedObjectDefinitionSegment: {
    from(palette: PaletteDefinitionSegment, objects: ObjectDefinitionSegment[]): DecodedObjectDefinitionSegment | null;
    valueOf(palette: PaletteDefinitionSegment, definision?: ObjectDefinitionSegment[]): Map<number, DecodedObjectDefinitionSegment>;
};
export type Segment = {
    type: typeof SegmentType.PDS;
    segment: PaletteDefinitionSegment;
} | {
    type: typeof SegmentType.ODS;
    segment: ObjectDefinitionSegment;
} | {
    type: typeof SegmentType.PCS;
    segment: PresentationCompositionSegment;
} | {
    type: typeof SegmentType.WDS;
    segment: WindowDefinitionSegment;
} | {
    type: typeof SegmentType.END;
};
export declare const Segment: {
    from(stream: ByteStream): Segment;
    fromAsync(stream: AsyncByteStream): Promise<Segment>;
};
export declare const HeaderLengthByFormat: {
    SUP: number;
    MPEGTS: number;
};
export type TimestampedSegment = Segment & {
    pts: number;
    dts: number;
    timescale: number;
};
export declare const TimestampedSegment: {
    fromSUPFormat(stream: ByteStream): TimestampedSegment;
    fromSUPFormatAsync(stream: AsyncByteStream): Promise<TimestampedSegment>;
    fromMpegTSFormat(stream: ByteStream, pts: number, dts: number, timescale?: number): TimestampedSegment;
    fromMpegTSFormatAsync(stream: AsyncByteStream, pts: number, dts: number, timescale?: number): Promise<TimestampedSegment>;
    iterateSupFormat(buffer: ArrayBuffer): Iterable<TimestampedSegment>;
    iterateSupFormatAsync(async: ReadableStream): AsyncIterable<TimestampedSegment>;
    iterateMpegTSFormat(buffer: ArrayBuffer, pts: number, dts: number, timescale?: number): Iterable<TimestampedSegment>;
    iterateMpegTSFormatAsync(readable: ReadableStream, pts: number, dts: number, timescale?: number): AsyncIterable<TimestampedSegment>;
};
type DisplaySetRequiredSegment = {
    PCS: PresentationCompositionSegment;
};
type DisplaySetOptionalSegments = {
    PDS: PaletteDefinitionSegment;
    WDS: WindowDefinitionSegment;
    ODS: ObjectDefinitionSegment[];
};
type DisplaySetIntraInformation = {
    compositionState: typeof CompositionState.AcquisitionPoint | typeof CompositionState.EpochStart;
} & DisplaySetRequiredSegment & DisplaySetOptionalSegments;
type DisplaySetNormalInformation = {
    compositionState: typeof CompositionState.Normal;
} & DisplaySetRequiredSegment & Partial<DisplaySetOptionalSegments>;
type DisplaySetSelfContained = {
    compositionState: (typeof CompositionState)[keyof typeof CompositionState];
    composition: PresentationCompositionSegment;
    palette: PaletteDefinitionSegment;
    windows: Map<number, WindowDefinition>;
    objects: Map<number, ObjectDefinitionSegment[]> | Map<number, DecodedObjectDefinitionSegment>;
};
export type DisplaySet = {
    pts: number;
    timescale: number;
} & (DisplaySetIntraInformation | DisplaySetNormalInformation);
export declare const DisplaySet: {
    isAcquisitionPoint(displayset: DisplaySet): displayset is (DisplaySet & DisplaySetIntraInformation);
    from(segments: TimestampedSegment[]): DisplaySet;
    merge(reference: DisplaySet & DisplaySetIntraInformation, displayset: DisplaySet): DisplaySet & DisplaySetIntraInformation;
    aggregate(iterator: Iterable<TimestampedSegment>): Iterable<DisplaySet>;
    aggregateAsync(iterator: AsyncIterable<TimestampedSegment>): AsyncIterable<DisplaySet>;
};
export type AcquisitionPoint = {
    pts: number;
    timescale: number;
} & DisplaySetSelfContained;
export declare const AcquisitionPoint: {
    from(displayset: DisplaySet & DisplaySetIntraInformation, decode?: boolean): AcquisitionPoint;
    iterate(iterator: Iterable<DisplaySet>, decode?: boolean): Iterable<AcquisitionPoint>;
    iterateAsync(iterator: AsyncIterable<DisplaySet>, decode?: boolean): AsyncIterable<AcquisitionPoint>;
};
export type Epoch = {
    displaySets: DisplaySetSelfContained[];
};
export {};
//# sourceMappingURL=type.d.ts.map