864 lines
32 KiB
TypeScript
864 lines
32 KiB
TypeScript
declare namespace GstBase {
|
|
|
|
class AggregatorStartTimeSelection {
|
|
// Enumerations hack...
|
|
toString(radix ? : number | undefined) : string;
|
|
toFixed(fractionDigits ? : number | undefined) : string;
|
|
toExponential(fractionDigits ? : number | undefined) : string;
|
|
toPrecision(precision ? : number | undefined) : string;
|
|
valueOf() : number;
|
|
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
|
|
|
|
static [s:number]: string;
|
|
|
|
static readonly "kZero": AggregatorStartTimeSelection
|
|
static readonly "kFirst": AggregatorStartTimeSelection
|
|
static readonly "kSet": AggregatorStartTimeSelection
|
|
}
|
|
|
|
class BaseParseFrameFlags {
|
|
// Enumerations hack...
|
|
toString(radix ? : number | undefined) : string;
|
|
toFixed(fractionDigits ? : number | undefined) : string;
|
|
toExponential(fractionDigits ? : number | undefined) : string;
|
|
toPrecision(precision ? : number | undefined) : string;
|
|
valueOf() : number;
|
|
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
|
|
|
|
static [s:number]: string;
|
|
|
|
static readonly "kNone": BaseParseFrameFlags
|
|
static readonly "kNewFrame": BaseParseFrameFlags
|
|
static readonly "kNoFrame": BaseParseFrameFlags
|
|
static readonly "kClip": BaseParseFrameFlags
|
|
static readonly "kDrop": BaseParseFrameFlags
|
|
static readonly "kQueue": BaseParseFrameFlags
|
|
}
|
|
|
|
class BaseSrcFlags {
|
|
// Enumerations hack...
|
|
toString(radix ? : number | undefined) : string;
|
|
toFixed(fractionDigits ? : number | undefined) : string;
|
|
toExponential(fractionDigits ? : number | undefined) : string;
|
|
toPrecision(precision ? : number | undefined) : string;
|
|
valueOf() : number;
|
|
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
|
|
|
|
static [s:number]: string;
|
|
|
|
static readonly "kStarting": BaseSrcFlags
|
|
static readonly "kStarted": BaseSrcFlags
|
|
static readonly "kLast": BaseSrcFlags
|
|
}
|
|
|
|
class CollectPadsStateFlags {
|
|
// Enumerations hack...
|
|
toString(radix ? : number | undefined) : string;
|
|
toFixed(fractionDigits ? : number | undefined) : string;
|
|
toExponential(fractionDigits ? : number | undefined) : string;
|
|
toPrecision(precision ? : number | undefined) : string;
|
|
valueOf() : number;
|
|
toLocaleString(locales ? : string | string[] | undefined, options ? : Intl.NumberFormatOptions | undefined) : string;
|
|
|
|
static [s:number]: string;
|
|
|
|
static readonly "kEos": CollectPadsStateFlags
|
|
static readonly "kFlushing": CollectPadsStateFlags
|
|
static readonly "kNewSegment": CollectPadsStateFlags
|
|
static readonly "kWaiting": CollectPadsStateFlags
|
|
static readonly "kLocked": CollectPadsStateFlags
|
|
}
|
|
|
|
|
|
class AdapterClass {
|
|
}
|
|
|
|
class AggregatorClass {
|
|
parentClass : Gst.ElementClass;
|
|
flush : (aggregator: GstBase.Aggregator) => Gst.FlowReturn;
|
|
clip : (aggregator: GstBase.Aggregator, aggregatorPad: GstBase.AggregatorPad, buf: Gst.Buffer) => Gst.Buffer;
|
|
finishBuffer : (aggregator: GstBase.Aggregator, buffer: Gst.Buffer) => Gst.FlowReturn;
|
|
sinkEvent : (aggregator: GstBase.Aggregator, aggregatorPad: GstBase.AggregatorPad, event: Gst.Event) => boolean;
|
|
sinkQuery : (aggregator: GstBase.Aggregator, aggregatorPad: GstBase.AggregatorPad, query: Gst.Query) => boolean;
|
|
srcEvent : (aggregator: GstBase.Aggregator, event: Gst.Event) => boolean;
|
|
srcQuery : (aggregator: GstBase.Aggregator, query: Gst.Query) => boolean;
|
|
srcActivate : (aggregator: GstBase.Aggregator, mode: Gst.PadMode, active: boolean) => boolean;
|
|
aggregate : (aggregator: GstBase.Aggregator, timeout: boolean) => Gst.FlowReturn;
|
|
stop : (aggregator: GstBase.Aggregator) => boolean;
|
|
start : (aggregator: GstBase.Aggregator) => boolean;
|
|
getNextTime : (aggregator: GstBase.Aggregator) => number | bigint;
|
|
createNewPad : void;
|
|
updateSrcCaps : (self: GstBase.Aggregator, caps: Gst.Caps, ret ?: Gst.Caps) => Gst.FlowReturn;
|
|
fixateSrcCaps : (self: GstBase.Aggregator, caps: Gst.Caps) => Gst.Caps;
|
|
negotiatedSrcCaps : (self: GstBase.Aggregator, caps: Gst.Caps) => boolean;
|
|
decideAllocation : (self: GstBase.Aggregator, query: Gst.Query) => boolean;
|
|
proposeAllocation : (self: GstBase.Aggregator, pad: GstBase.AggregatorPad, decideQuery: Gst.Query, query: Gst.Query) => boolean;
|
|
negotiate : (self: GstBase.Aggregator) => boolean;
|
|
sinkEventPreQueue : (aggregator: GstBase.Aggregator, aggregatorPad: GstBase.AggregatorPad, event: Gst.Event) => Gst.FlowReturn;
|
|
sinkQueryPreQueue : (aggregator: GstBase.Aggregator, aggregatorPad: GstBase.AggregatorPad, query: Gst.Query) => boolean;
|
|
finishBufferList : (aggregator: GstBase.Aggregator, bufferlist: Gst.BufferList) => Gst.FlowReturn;
|
|
peekNextSample : (aggregator: GstBase.Aggregator, aggregatorPad: GstBase.AggregatorPad) => Gst.Sample;
|
|
|
|
}
|
|
|
|
class AggregatorPadClass {
|
|
parentClass : Gst.PadClass;
|
|
flush : (aggpad: GstBase.AggregatorPad, aggregator: GstBase.Aggregator) => Gst.FlowReturn;
|
|
skipBuffer : (aggpad: GstBase.AggregatorPad, aggregator: GstBase.Aggregator, buffer: Gst.Buffer) => boolean;
|
|
|
|
}
|
|
|
|
class AggregatorPadPrivate {
|
|
}
|
|
|
|
class AggregatorPrivate {
|
|
}
|
|
|
|
class BaseParseClass {
|
|
parentClass : Gst.ElementClass;
|
|
start : (parse: GstBase.BaseParse) => boolean;
|
|
stop : (parse: GstBase.BaseParse) => boolean;
|
|
setSinkCaps : (parse: GstBase.BaseParse, caps: Gst.Caps) => boolean;
|
|
handleFrame : (parse: GstBase.BaseParse, frame: GstBase.BaseParseFrame, skipsize: number) => Gst.FlowReturn;
|
|
prePushFrame : (parse: GstBase.BaseParse, frame: GstBase.BaseParseFrame) => Gst.FlowReturn;
|
|
convert : (parse: GstBase.BaseParse, srcFormat: Gst.Format, srcValue: number | bigint, destFormat: Gst.Format, destValue: number | bigint) => boolean;
|
|
sinkEvent : (parse: GstBase.BaseParse, event: Gst.Event) => boolean;
|
|
srcEvent : (parse: GstBase.BaseParse, event: Gst.Event) => boolean;
|
|
getSinkCaps : (parse: GstBase.BaseParse, filter: Gst.Caps) => Gst.Caps;
|
|
detect : (parse: GstBase.BaseParse, buffer: Gst.Buffer) => Gst.FlowReturn;
|
|
sinkQuery : (parse: GstBase.BaseParse, query: Gst.Query) => boolean;
|
|
srcQuery : (parse: GstBase.BaseParse, query: Gst.Query) => boolean;
|
|
|
|
}
|
|
|
|
class BaseParseFrame {
|
|
buffer : Gst.Buffer;
|
|
outBuffer : Gst.Buffer;
|
|
flags : number;
|
|
offset : number | bigint;
|
|
overhead : number;
|
|
size : number;
|
|
gstReservedI : number[];
|
|
privateFlags : number;
|
|
|
|
static New(buffer: Gst.Buffer, flags: GstBase.BaseParseFrameFlags, overhead: number): GstBase.BaseParseFrame;
|
|
copy(): GstBase.BaseParseFrame;
|
|
free(): void;
|
|
init(): void;
|
|
}
|
|
|
|
class BaseParsePrivate {
|
|
}
|
|
|
|
class BaseSinkClass {
|
|
parentClass : Gst.ElementClass;
|
|
getCaps : (sink: GstBase.BaseSink, filter: Gst.Caps) => Gst.Caps;
|
|
setCaps : (sink: GstBase.BaseSink, caps: Gst.Caps) => boolean;
|
|
fixate : (sink: GstBase.BaseSink, caps: Gst.Caps) => Gst.Caps;
|
|
activatePull : (sink: GstBase.BaseSink, active: boolean) => boolean;
|
|
getTimes : (sink: GstBase.BaseSink, buffer: Gst.Buffer, start: number | bigint, end: number | bigint) => void;
|
|
proposeAllocation : (sink: GstBase.BaseSink, query: Gst.Query) => boolean;
|
|
start : (sink: GstBase.BaseSink) => boolean;
|
|
stop : (sink: GstBase.BaseSink) => boolean;
|
|
unlock : (sink: GstBase.BaseSink) => boolean;
|
|
unlockStop : (sink: GstBase.BaseSink) => boolean;
|
|
query : (sink: GstBase.BaseSink, query: Gst.Query) => boolean;
|
|
event : (sink: GstBase.BaseSink, event: Gst.Event) => boolean;
|
|
waitEvent : (sink: GstBase.BaseSink, event: Gst.Event) => Gst.FlowReturn;
|
|
prepare : (sink: GstBase.BaseSink, buffer: Gst.Buffer) => Gst.FlowReturn;
|
|
prepareList : (sink: GstBase.BaseSink, bufferList: Gst.BufferList) => Gst.FlowReturn;
|
|
preroll : (sink: GstBase.BaseSink, buffer: Gst.Buffer) => Gst.FlowReturn;
|
|
render : (sink: GstBase.BaseSink, buffer: Gst.Buffer) => Gst.FlowReturn;
|
|
renderList : (sink: GstBase.BaseSink, bufferList: Gst.BufferList) => Gst.FlowReturn;
|
|
|
|
}
|
|
|
|
class BaseSinkPrivate {
|
|
}
|
|
|
|
class BaseSrcClass {
|
|
parentClass : Gst.ElementClass;
|
|
getCaps : (src: GstBase.BaseSrc, filter: Gst.Caps | undefined | null) => Gst.Caps;
|
|
negotiate : (src: GstBase.BaseSrc) => boolean;
|
|
fixate : (src: GstBase.BaseSrc, caps: Gst.Caps) => Gst.Caps;
|
|
setCaps : (src: GstBase.BaseSrc, caps: Gst.Caps) => boolean;
|
|
decideAllocation : (src: GstBase.BaseSrc, query: Gst.Query) => boolean;
|
|
start : (src: GstBase.BaseSrc) => boolean;
|
|
stop : (src: GstBase.BaseSrc) => boolean;
|
|
getTimes : (src: GstBase.BaseSrc, buffer: Gst.Buffer, start: number | bigint, end: number | bigint) => void;
|
|
getSize : (src: GstBase.BaseSrc, size: number | bigint) => boolean;
|
|
isSeekable : (src: GstBase.BaseSrc) => boolean;
|
|
prepareSeekSegment : (src: GstBase.BaseSrc, seek: Gst.Event, segment: Gst.Segment) => boolean;
|
|
doSeek : (src: GstBase.BaseSrc, segment: Gst.Segment) => boolean;
|
|
unlock : (src: GstBase.BaseSrc) => boolean;
|
|
unlockStop : (src: GstBase.BaseSrc) => boolean;
|
|
query : (src: GstBase.BaseSrc, query: Gst.Query) => boolean;
|
|
event : (src: GstBase.BaseSrc, event: Gst.Event) => boolean;
|
|
create : (src: GstBase.BaseSrc, offset: number | bigint, size: number, buf: Gst.Buffer) => Gst.FlowReturn;
|
|
alloc : (src: GstBase.BaseSrc, offset: number | bigint, size: number, buf: Gst.Buffer) => Gst.FlowReturn;
|
|
fill : (src: GstBase.BaseSrc, offset: number | bigint, size: number, buf: Gst.Buffer) => Gst.FlowReturn;
|
|
|
|
}
|
|
|
|
class BaseSrcPrivate {
|
|
}
|
|
|
|
class BaseTransformClass {
|
|
parentClass : Gst.ElementClass;
|
|
passthroughOnSameCaps : boolean;
|
|
transformIpOnPassthrough : boolean;
|
|
transformCaps : (trans: GstBase.BaseTransform, direction: Gst.PadDirection, caps: Gst.Caps, filter: Gst.Caps) => Gst.Caps;
|
|
fixateCaps : (trans: GstBase.BaseTransform, direction: Gst.PadDirection, caps: Gst.Caps, othercaps: Gst.Caps) => Gst.Caps;
|
|
acceptCaps : (trans: GstBase.BaseTransform, direction: Gst.PadDirection, caps: Gst.Caps) => boolean;
|
|
setCaps : (trans: GstBase.BaseTransform, incaps: Gst.Caps, outcaps: Gst.Caps) => boolean;
|
|
query : (trans: GstBase.BaseTransform, direction: Gst.PadDirection, query: Gst.Query) => boolean;
|
|
decideAllocation : (trans: GstBase.BaseTransform, query: Gst.Query) => boolean;
|
|
filterMeta : (trans: GstBase.BaseTransform, query: Gst.Query, api: number, params: Gst.Structure) => boolean;
|
|
proposeAllocation : (trans: GstBase.BaseTransform, decideQuery: Gst.Query, query: Gst.Query) => boolean;
|
|
transformSize : (trans: GstBase.BaseTransform, direction: Gst.PadDirection, caps: Gst.Caps, size: number | bigint, othercaps: Gst.Caps, othersize: number | bigint) => boolean;
|
|
getUnitSize : (trans: GstBase.BaseTransform, caps: Gst.Caps, size: number | bigint) => boolean;
|
|
start : (trans: GstBase.BaseTransform) => boolean;
|
|
stop : (trans: GstBase.BaseTransform) => boolean;
|
|
sinkEvent : (trans: GstBase.BaseTransform, event: Gst.Event) => boolean;
|
|
srcEvent : (trans: GstBase.BaseTransform, event: Gst.Event) => boolean;
|
|
prepareOutputBuffer : (trans: GstBase.BaseTransform, input: Gst.Buffer, outbuf: Gst.Buffer) => Gst.FlowReturn;
|
|
copyMetadata : (trans: GstBase.BaseTransform, input: Gst.Buffer, outbuf: Gst.Buffer) => boolean;
|
|
transformMeta : (trans: GstBase.BaseTransform, outbuf: Gst.Buffer, meta: Gst.Meta, inbuf: Gst.Buffer) => boolean;
|
|
beforeTransform : (trans: GstBase.BaseTransform, buffer: Gst.Buffer) => void;
|
|
transform : (trans: GstBase.BaseTransform, inbuf: Gst.Buffer, outbuf: Gst.Buffer) => Gst.FlowReturn;
|
|
transformIp : (trans: GstBase.BaseTransform, buf: Gst.Buffer) => Gst.FlowReturn;
|
|
submitInputBuffer : (trans: GstBase.BaseTransform, isDiscont: boolean, input: Gst.Buffer) => Gst.FlowReturn;
|
|
generateOutput : (trans: GstBase.BaseTransform, outbuf: Gst.Buffer) => Gst.FlowReturn;
|
|
|
|
}
|
|
|
|
class BaseTransformPrivate {
|
|
}
|
|
|
|
class BitReader {
|
|
data : number[];
|
|
size : number;
|
|
byte : number;
|
|
bit : number;
|
|
|
|
free(): void;
|
|
getBitsUint16(val: number, nbits: number): boolean;
|
|
getBitsUint32(val: number, nbits: number): boolean;
|
|
getBitsUint64(val: number | bigint, nbits: number): boolean;
|
|
getBitsUint8(val: number, nbits: number): boolean;
|
|
getPos(): number;
|
|
getRemaining(): number;
|
|
getSize(): number;
|
|
init(data: number[], size: number): void;
|
|
peekBitsUint16(val: number, nbits: number): boolean;
|
|
peekBitsUint32(val: number, nbits: number): boolean;
|
|
peekBitsUint64(val: number | bigint, nbits: number): boolean;
|
|
peekBitsUint8(val: number, nbits: number): boolean;
|
|
setPos(pos: number): boolean;
|
|
skip(nbits: number): boolean;
|
|
skipToByte(): boolean;
|
|
}
|
|
|
|
class BitWriter {
|
|
data : number;
|
|
bitSize : number;
|
|
bitCapacity : number;
|
|
autoGrow : boolean;
|
|
owned : boolean;
|
|
|
|
alignBytes(trailingBit: number): boolean;
|
|
free(): void;
|
|
freeAndGetBuffer(): Gst.Buffer;
|
|
freeAndGetData(): number[];
|
|
getData(): number[];
|
|
getRemaining(): number;
|
|
getSize(): number;
|
|
putBitsUint16(value: number, nbits: number): boolean;
|
|
putBitsUint32(value: number, nbits: number): boolean;
|
|
putBitsUint64(value: number | bigint, nbits: number): boolean;
|
|
putBitsUint8(value: number, nbits: number): boolean;
|
|
putBytes(data: number[], nbytes: number): boolean;
|
|
reset(): void;
|
|
resetAndGetBuffer(): Gst.Buffer;
|
|
resetAndGetData(): number[];
|
|
setPos(pos: number): boolean;
|
|
}
|
|
|
|
class ByteReader {
|
|
data : number[];
|
|
size : number;
|
|
byte : number;
|
|
|
|
dupData(size: number, val: number[]): boolean;
|
|
dupStringUtf16(str: number[]): boolean;
|
|
dupStringUtf32(str: number[]): boolean;
|
|
dupStringUtf8(str: string[]): boolean;
|
|
free(): void;
|
|
getData(size: number, val: number[]): boolean;
|
|
getFloat32Be(val: number): boolean;
|
|
getFloat32Le(val: number): boolean;
|
|
getFloat64Be(val: number): boolean;
|
|
getFloat64Le(val: number): boolean;
|
|
getInt16Be(val: number): boolean;
|
|
getInt16Le(val: number): boolean;
|
|
getInt24Be(val: number): boolean;
|
|
getInt24Le(val: number): boolean;
|
|
getInt32Be(val: number): boolean;
|
|
getInt32Le(val: number): boolean;
|
|
getInt64Be(val: number | bigint): boolean;
|
|
getInt64Le(val: number | bigint): boolean;
|
|
getInt8(val: number): boolean;
|
|
getPos(): number;
|
|
getRemaining(): number;
|
|
getSize(): number;
|
|
getStringUtf8(str: string[]): boolean;
|
|
getUint16Be(val: number): boolean;
|
|
getUint16Le(val: number): boolean;
|
|
getUint24Be(val: number): boolean;
|
|
getUint24Le(val: number): boolean;
|
|
getUint32Be(val: number): boolean;
|
|
getUint32Le(val: number): boolean;
|
|
getUint64Be(val: number | bigint): boolean;
|
|
getUint64Le(val: number | bigint): boolean;
|
|
getUint8(val: number): boolean;
|
|
init(data: number[], size: number): void;
|
|
maskedScanUint32(mask: number, pattern: number, offset: number, size: number): number;
|
|
maskedScanUint32Peek(mask: number, pattern: number, offset: number, size: number, value: number): number;
|
|
peekData(size: number, val: number[]): boolean;
|
|
peekFloat32Be(val: number): boolean;
|
|
peekFloat32Le(val: number): boolean;
|
|
peekFloat64Be(val: number): boolean;
|
|
peekFloat64Le(val: number): boolean;
|
|
peekInt16Be(val: number): boolean;
|
|
peekInt16Le(val: number): boolean;
|
|
peekInt24Be(val: number): boolean;
|
|
peekInt24Le(val: number): boolean;
|
|
peekInt32Be(val: number): boolean;
|
|
peekInt32Le(val: number): boolean;
|
|
peekInt64Be(val: number | bigint): boolean;
|
|
peekInt64Le(val: number | bigint): boolean;
|
|
peekInt8(val: number): boolean;
|
|
peekStringUtf8(str: string[]): boolean;
|
|
peekUint16Be(val: number): boolean;
|
|
peekUint16Le(val: number): boolean;
|
|
peekUint24Be(val: number): boolean;
|
|
peekUint24Le(val: number): boolean;
|
|
peekUint32Be(val: number): boolean;
|
|
peekUint32Le(val: number): boolean;
|
|
peekUint64Be(val: number | bigint): boolean;
|
|
peekUint64Le(val: number | bigint): boolean;
|
|
peekUint8(val: number): boolean;
|
|
setPos(pos: number): boolean;
|
|
skip(nbytes: number): boolean;
|
|
skipStringUtf16(): boolean;
|
|
skipStringUtf32(): boolean;
|
|
skipStringUtf8(): boolean;
|
|
}
|
|
|
|
class ByteWriter {
|
|
parent : GstBase.ByteReader;
|
|
allocSize : number;
|
|
fixed : boolean;
|
|
owned : boolean;
|
|
|
|
ensureFreeSpace(size: number): boolean;
|
|
fill(value: number, size: number): boolean;
|
|
free(): void;
|
|
freeAndGetBuffer(): Gst.Buffer;
|
|
freeAndGetData(): number;
|
|
getRemaining(): number;
|
|
init(): void;
|
|
initWithData(data: number[], size: number, initialized: boolean): void;
|
|
initWithSize(size: number, fixed: boolean): void;
|
|
putBuffer(buffer: Gst.Buffer, offset: number | bigint, size: number | bigint): boolean;
|
|
putData(data: number[], size: number): boolean;
|
|
putFloat32Be(val: number): boolean;
|
|
putFloat32Le(val: number): boolean;
|
|
putFloat64Be(val: number): boolean;
|
|
putFloat64Le(val: number): boolean;
|
|
putInt16Be(val: number): boolean;
|
|
putInt16Le(val: number): boolean;
|
|
putInt24Be(val: number): boolean;
|
|
putInt24Le(val: number): boolean;
|
|
putInt32Be(val: number): boolean;
|
|
putInt32Le(val: number): boolean;
|
|
putInt64Be(val: number | bigint): boolean;
|
|
putInt64Le(val: number | bigint): boolean;
|
|
putInt8(val: number): boolean;
|
|
putStringUtf16(data: number[]): boolean;
|
|
putStringUtf32(data: number[]): boolean;
|
|
putStringUtf8(data: string): boolean;
|
|
putUint16Be(val: number): boolean;
|
|
putUint16Le(val: number): boolean;
|
|
putUint24Be(val: number): boolean;
|
|
putUint24Le(val: number): boolean;
|
|
putUint32Be(val: number): boolean;
|
|
putUint32Le(val: number): boolean;
|
|
putUint64Be(val: number | bigint): boolean;
|
|
putUint64Le(val: number | bigint): boolean;
|
|
putUint8(val: number): boolean;
|
|
reset(): void;
|
|
resetAndGetBuffer(): Gst.Buffer;
|
|
resetAndGetData(): number[];
|
|
}
|
|
|
|
class CollectData {
|
|
collect : GstBase.CollectPads;
|
|
pad : Gst.Pad;
|
|
buffer : Gst.Buffer;
|
|
pos : number;
|
|
segment : Gst.Segment;
|
|
state : GstBase.CollectPadsStateFlags;
|
|
priv : GstBase.CollectDataPrivate;
|
|
|
|
}
|
|
|
|
class CollectDataPrivate {
|
|
}
|
|
|
|
class CollectPadsClass {
|
|
parentClass : Gst.ObjectClass;
|
|
|
|
}
|
|
|
|
class CollectPadsPrivate {
|
|
}
|
|
|
|
class DataQueueClass {
|
|
parentClass : GObject.ObjectClass;
|
|
empty : (queue: GstBase.DataQueue) => void;
|
|
full : (queue: GstBase.DataQueue) => void;
|
|
|
|
}
|
|
|
|
class DataQueuePrivate {
|
|
}
|
|
|
|
class FlowCombiner {
|
|
static New(): GstBase.FlowCombiner;
|
|
addPad(pad: Gst.Pad): void;
|
|
clear(): void;
|
|
free(): void;
|
|
ref(): GstBase.FlowCombiner;
|
|
removePad(pad: Gst.Pad): void;
|
|
reset(): void;
|
|
unref(): void;
|
|
updateFlow(fret: Gst.FlowReturn): Gst.FlowReturn;
|
|
updatePadFlow(pad: Gst.Pad, fret: Gst.FlowReturn): Gst.FlowReturn;
|
|
}
|
|
|
|
class PushSrcClass {
|
|
parentClass : GstBase.BaseSrcClass;
|
|
create : (src: GstBase.PushSrc, buf: Gst.Buffer) => Gst.FlowReturn;
|
|
alloc : (src: GstBase.PushSrc, buf: Gst.Buffer) => Gst.FlowReturn;
|
|
fill : (src: GstBase.PushSrc, buf: Gst.Buffer) => Gst.FlowReturn;
|
|
|
|
}
|
|
|
|
|
|
class Adapter extends GObject.Object {
|
|
constructor(initializerList ?: AdapterCtor);
|
|
|
|
static New(): GstBase.Adapter;
|
|
available(): number | bigint;
|
|
availableFast(): number | bigint;
|
|
clear(): void;
|
|
copy(offset: number | bigint, size: number | bigint): AuGlibEx.Bytes;
|
|
distanceFromDiscont(): number | bigint;
|
|
dtsAtDiscont(): number | bigint;
|
|
flush(flush: number | bigint): void;
|
|
getBuffer(nbytes: number | bigint): Gst.Buffer;
|
|
getBufferFast(nbytes: number | bigint): Gst.Buffer;
|
|
getBufferList(nbytes: number | bigint): Gst.BufferList;
|
|
getList(nbytes: number | bigint): Gst.Buffer[];
|
|
map(size: number | bigint): number[];
|
|
maskedScanUint32(mask: number, pattern: number, offset: number | bigint, size: number | bigint): number | bigint;
|
|
maskedScanUint32Peek(mask: number, pattern: number, offset: number | bigint, size: number | bigint, value ?: number): number | bigint;
|
|
offsetAtDiscont(): number | bigint;
|
|
prevDts(distance ?: number | bigint): number | bigint;
|
|
prevDtsAtOffset(offset: number | bigint, distance ?: number | bigint): number | bigint;
|
|
prevOffset(distance ?: number | bigint): number | bigint;
|
|
prevPts(distance ?: number | bigint): number | bigint;
|
|
prevPtsAtOffset(offset: number | bigint, distance ?: number | bigint): number | bigint;
|
|
ptsAtDiscont(): number | bigint;
|
|
push(buf: Gst.Buffer): void;
|
|
take(nbytes: number | bigint): number[];
|
|
takeBuffer(nbytes: number | bigint): Gst.Buffer;
|
|
takeBufferFast(nbytes: number | bigint): Gst.Buffer;
|
|
takeBufferList(nbytes: number | bigint): Gst.BufferList;
|
|
takeList(nbytes: number | bigint): Gst.Buffer[];
|
|
unmap(): void;
|
|
//TypeScript is complete garbage:
|
|
}
|
|
|
|
class AdapterCtor {
|
|
}
|
|
|
|
class Aggregator extends Gst.Element {
|
|
constructor(initializerList ?: AggregatorCtor);
|
|
|
|
parent : Gst.Element;
|
|
srcpad : Gst.Pad;
|
|
priv : GstBase.AggregatorPrivate;
|
|
|
|
emitSignals : boolean;
|
|
latency : number | bigint;
|
|
minUpstreamLatency : number | bigint;
|
|
startTime : number | bigint;
|
|
startTimeSelection : GstBase.AggregatorStartTimeSelection;
|
|
|
|
finishBuffer(buffer: Gst.Buffer): Gst.FlowReturn;
|
|
finishBufferList(bufferlist: Gst.BufferList): Gst.FlowReturn;
|
|
getAllocator(allocator ?: Gst.Allocator | undefined | null, params ?: Gst.AllocationParams): void;
|
|
getBufferPool(): Gst.BufferPool;
|
|
getIgnoreInactivePads(): boolean;
|
|
getLatency(): number | bigint;
|
|
negotiate(): boolean;
|
|
peekNextSample(pad: GstBase.AggregatorPad): Gst.Sample;
|
|
selectedSamples(pts: number | bigint, dts: number | bigint, duration: number | bigint, info: Gst.Structure | undefined | null): void;
|
|
setIgnoreInactivePads(ignore: boolean): void;
|
|
setLatency(minLatency: number | bigint, maxLatency: number | bigint): void;
|
|
setSrcCaps(caps: Gst.Caps): void;
|
|
simpleGetNextTime(): number | bigint;
|
|
updateSegment(segment: Gst.Segment): void;
|
|
//TypeScript is complete garbage:
|
|
}
|
|
|
|
class AggregatorCtor {
|
|
name ?: string;
|
|
parent ?: Gst.Object;
|
|
latency ?: number;
|
|
minUpstreamLatency ?: number;
|
|
startTimeSelection ?: GstBase.AggregatorStartTimeSelection;
|
|
startTime ?: number;
|
|
emitSignals ?: boolean;
|
|
}
|
|
|
|
class AggregatorEventListener extends AuGlibEx.IEventListener {
|
|
samplesSelected(segment: Gst.Segment, pts: number | bigint, dts: number | bigint, duration: number | bigint, info: Gst.Structure | undefined | null): void;
|
|
}
|
|
|
|
class AggregatorPad extends Gst.Pad {
|
|
constructor(initializerList ?: AggregatorPadCtor);
|
|
|
|
parent : Gst.Pad;
|
|
segment : Gst.Segment;
|
|
priv : GstBase.AggregatorPadPrivate;
|
|
|
|
emitSignals : boolean;
|
|
|
|
dropBuffer(): boolean;
|
|
hasBuffer(): boolean;
|
|
isEos(): boolean;
|
|
isInactive(): boolean;
|
|
peekBuffer(): Gst.Buffer;
|
|
popBuffer(): Gst.Buffer;
|
|
//TypeScript is complete garbage:
|
|
}
|
|
|
|
class AggregatorPadCtor {
|
|
name ?: string;
|
|
parent ?: Gst.Object;
|
|
direction ?: Gst.PadDirection;
|
|
template ?: Gst.PadTemplate;
|
|
offset ?: number | bigint;
|
|
emitSignals ?: boolean;
|
|
}
|
|
|
|
class AggregatorPadEventListener extends AuGlibEx.IEventListener {
|
|
bufferConsumed(object: Gst.Buffer): void;
|
|
}
|
|
|
|
class BaseParse extends Gst.Element {
|
|
constructor(initializerList ?: BaseParseCtor);
|
|
|
|
element : Gst.Element;
|
|
sinkpad : Gst.Pad;
|
|
srcpad : Gst.Pad;
|
|
flags : number;
|
|
segment : Gst.Segment;
|
|
priv : GstBase.BaseParsePrivate;
|
|
|
|
disablePassthrough : boolean;
|
|
|
|
addIndexEntry(offset: number | bigint, ts: number | bigint, key: boolean, force: boolean): boolean;
|
|
convertDefault(srcFormat: Gst.Format, srcValue: number | bigint, destFormat: Gst.Format, destValue: number | bigint): boolean;
|
|
drain(): void;
|
|
finishFrame(frame: GstBase.BaseParseFrame, size: number): Gst.FlowReturn;
|
|
mergeTags(tags: Gst.TagList | undefined | null, mode: Gst.TagMergeMode): void;
|
|
pushFrame(frame: GstBase.BaseParseFrame): Gst.FlowReturn;
|
|
setAverageBitrate(bitrate: number): void;
|
|
setDuration(fmt: Gst.Format, duration: number | bigint, interval: number): void;
|
|
setFrameRate(fpsNum: number, fpsDen: number, leadIn: number, leadOut: number): void;
|
|
setHasTimingInfo(hasTiming: boolean): void;
|
|
setInferTs(inferTs: boolean): void;
|
|
setLatency(minLatency: number | bigint, maxLatency: number | bigint): void;
|
|
setMinFrameSize(minSize: number): void;
|
|
setPassthrough(passthrough: boolean): void;
|
|
setPtsInterpolation(ptsInterpolate: boolean): void;
|
|
setSyncable(syncable: boolean): void;
|
|
setTsAtOffset(offset: number | bigint): void;
|
|
//TypeScript is complete garbage:
|
|
}
|
|
|
|
class BaseParseCtor {
|
|
name ?: string;
|
|
parent ?: Gst.Object;
|
|
disablePassthrough ?: boolean;
|
|
}
|
|
|
|
class BaseSink extends Gst.Element {
|
|
constructor(initializerList ?: BaseSinkCtor);
|
|
|
|
element : Gst.Element;
|
|
sinkpad : Gst.Pad;
|
|
padMode : Gst.PadMode;
|
|
offset : number | bigint;
|
|
canActivatePull : boolean;
|
|
canActivatePush : boolean;
|
|
prerollCond : AuGlibEx.Cond;
|
|
eos : boolean;
|
|
needPreroll : boolean;
|
|
havePreroll : boolean;
|
|
playingAsync : boolean;
|
|
haveNewsegment : boolean;
|
|
segment : Gst.Segment;
|
|
clockId : void;
|
|
sync : boolean;
|
|
flushing : boolean;
|
|
running : boolean;
|
|
maxLateness : number | bigint;
|
|
priv : GstBase.BaseSinkPrivate;
|
|
|
|
_async : boolean;
|
|
blocksize : number;
|
|
enableLastSample : boolean;
|
|
lastSample : Gst.Sample;
|
|
maxBitrate : number | bigint;
|
|
processingDeadline : number | bigint;
|
|
qos : boolean;
|
|
renderDelay : number | bigint;
|
|
stats : Gst.Structure;
|
|
throttleTime : number | bigint;
|
|
tsOffset : number | bigint;
|
|
|
|
doPreroll(obj: Gst.MiniObject): Gst.FlowReturn;
|
|
getBlocksize(): number;
|
|
getDropOutOfSegment(): boolean;
|
|
getLastSample(): Gst.Sample;
|
|
getLatency(): number | bigint;
|
|
getMaxBitrate(): number | bigint;
|
|
getMaxLateness(): number | bigint;
|
|
getProcessingDeadline(): number | bigint;
|
|
getRenderDelay(): number | bigint;
|
|
getStats(): Gst.Structure;
|
|
getSync(): boolean;
|
|
getThrottleTime(): number | bigint;
|
|
getTsOffset(): number | bigint;
|
|
isAsyncEnabled(): boolean;
|
|
isLastSampleEnabled(): boolean;
|
|
isQosEnabled(): boolean;
|
|
queryLatency(live ?: boolean, upstreamLive ?: boolean, minLatency ?: number | bigint, maxLatency ?: number | bigint): boolean;
|
|
setAsyncEnabled(enabled: boolean): void;
|
|
setBlocksize(blocksize: number): void;
|
|
setDropOutOfSegment(dropOutOfSegment: boolean): void;
|
|
setLastSampleEnabled(enabled: boolean): void;
|
|
setMaxBitrate(maxBitrate: number | bigint): void;
|
|
setMaxLateness(maxLateness: number | bigint): void;
|
|
setProcessingDeadline(processingDeadline: number | bigint): void;
|
|
setQosEnabled(enabled: boolean): void;
|
|
setRenderDelay(delay: number | bigint): void;
|
|
setSync(sync: boolean): void;
|
|
setThrottleTime(throttle: number | bigint): void;
|
|
setTsOffset(offset: number | bigint): void;
|
|
wait(time: number | bigint, jitter ?: number | bigint): Gst.FlowReturn;
|
|
waitClock(time: number | bigint, jitter ?: number | bigint): Gst.ClockReturn;
|
|
waitPreroll(): Gst.FlowReturn;
|
|
//TypeScript is complete garbage:
|
|
}
|
|
|
|
class BaseSinkCtor {
|
|
name ?: string;
|
|
parent ?: Gst.Object;
|
|
sync ?: boolean;
|
|
maxLateness ?: number | bigint;
|
|
qos ?: boolean;
|
|
async ?: boolean;
|
|
tsOffset ?: number | bigint;
|
|
enableLastSample ?: boolean;
|
|
blocksize ?: number;
|
|
renderDelay ?: number;
|
|
throttleTime ?: number;
|
|
maxBitrate ?: number;
|
|
processingDeadline ?: number;
|
|
}
|
|
|
|
class BaseSrc extends Gst.Element {
|
|
constructor(initializerList ?: BaseSrcCtor);
|
|
|
|
element : Gst.Element;
|
|
srcpad : Gst.Pad;
|
|
liveCond : AuGlibEx.Cond;
|
|
isLive : boolean;
|
|
liveRunning : boolean;
|
|
blocksize : number;
|
|
canActivatePush : boolean;
|
|
randomAccess : boolean;
|
|
clockId : void;
|
|
segment : Gst.Segment;
|
|
needNewsegment : boolean;
|
|
numBuffers : number;
|
|
numBuffersLeft : number;
|
|
typefind : boolean;
|
|
running : boolean;
|
|
pendingSeek : Gst.Event;
|
|
priv : GstBase.BaseSrcPrivate;
|
|
|
|
doTimestamp : boolean;
|
|
|
|
getAllocator(allocator ?: Gst.Allocator | undefined | null, params ?: Gst.AllocationParams): void;
|
|
getBlocksize(): number;
|
|
getBufferPool(): Gst.BufferPool;
|
|
getDoTimestamp(): boolean;
|
|
isAsync(): boolean;
|
|
negotiate(): boolean;
|
|
newSeamlessSegment(start: number | bigint, stop: number | bigint, time: number | bigint): boolean;
|
|
newSegment(segment: Gst.Segment): boolean;
|
|
queryLatency(live ?: boolean, minLatency ?: number | bigint, maxLatency ?: number | bigint): boolean;
|
|
setAsync(_async: boolean): void;
|
|
setAutomaticEos(automaticEos: boolean): void;
|
|
setBlocksize(blocksize: number): void;
|
|
setCaps(caps: Gst.Caps): boolean;
|
|
setDoTimestamp(timestamp: boolean): void;
|
|
setDynamicSize(dynamic: boolean): void;
|
|
setFormat(format: Gst.Format): void;
|
|
setLive(live: boolean): void;
|
|
startComplete(ret: Gst.FlowReturn): void;
|
|
startWait(): Gst.FlowReturn;
|
|
submitBufferList(bufferList: Gst.BufferList): void;
|
|
waitPlaying(): Gst.FlowReturn;
|
|
//TypeScript is complete garbage:
|
|
}
|
|
|
|
class BaseSrcCtor {
|
|
name ?: string;
|
|
parent ?: Gst.Object;
|
|
blocksize ?: number;
|
|
numBuffers ?: number;
|
|
typefind ?: boolean;
|
|
doTimestamp ?: boolean;
|
|
}
|
|
|
|
class BaseTransform extends Gst.Element {
|
|
constructor(initializerList ?: BaseTransformCtor);
|
|
|
|
element : Gst.Element;
|
|
sinkpad : Gst.Pad;
|
|
srcpad : Gst.Pad;
|
|
haveSegment : boolean;
|
|
segment : Gst.Segment;
|
|
queuedBuf : Gst.Buffer;
|
|
priv : GstBase.BaseTransformPrivate;
|
|
|
|
qos : boolean;
|
|
|
|
getAllocator(allocator ?: Gst.Allocator | undefined | null, params ?: Gst.AllocationParams): void;
|
|
getBufferPool(): Gst.BufferPool;
|
|
isInPlace(): boolean;
|
|
isPassthrough(): boolean;
|
|
isQosEnabled(): boolean;
|
|
reconfigure(): boolean;
|
|
reconfigureSink(): void;
|
|
reconfigureSrc(): void;
|
|
setGapAware(gapAware: boolean): void;
|
|
setInPlace(inPlace: boolean): void;
|
|
setPassthrough(passthrough: boolean): void;
|
|
setPreferPassthrough(preferPassthrough: boolean): void;
|
|
setQosEnabled(enabled: boolean): void;
|
|
updateQos(proportion: number, diff: number | bigint, timestamp: number | bigint): void;
|
|
updateSrcCaps(updatedCaps: Gst.Caps): boolean;
|
|
//TypeScript is complete garbage:
|
|
}
|
|
|
|
class BaseTransformCtor {
|
|
name ?: string;
|
|
parent ?: Gst.Object;
|
|
qos ?: boolean;
|
|
}
|
|
|
|
class CollectPads extends Gst.Object {
|
|
constructor(initializerList ?: CollectPadsCtor);
|
|
|
|
object : Gst.Object;
|
|
data : GstBase.CollectData[];
|
|
streamLock : AuGlibEx.RecMutex;
|
|
priv : GstBase.CollectPadsPrivate;
|
|
|
|
static New(): GstBase.CollectPads;
|
|
addPad(pad: Gst.Pad, size: number, destroyNotify: (data: GstBase.CollectData) => void, lock: boolean): GstBase.CollectData;
|
|
available(): number;
|
|
clipRunningTime(cdata: GstBase.CollectData, buf: Gst.Buffer, outbuf ?: Gst.Buffer): Gst.FlowReturn;
|
|
eventDefault(data: GstBase.CollectData, event: Gst.Event, discard: boolean): boolean;
|
|
flush(data: GstBase.CollectData, size: number): number;
|
|
peek(data: GstBase.CollectData): Gst.Buffer;
|
|
pop(data: GstBase.CollectData): Gst.Buffer;
|
|
queryDefault(data: GstBase.CollectData, query: Gst.Query, discard: boolean): boolean;
|
|
readBuffer(data: GstBase.CollectData, size: number): Gst.Buffer;
|
|
removePad(pad: Gst.Pad): boolean;
|
|
setBufferFunction(func: (pads: GstBase.CollectPads, data: GstBase.CollectData, buffer: Gst.Buffer) => Gst.FlowReturn): void;
|
|
setClipFunction(clipfunc: (pads: GstBase.CollectPads, data: GstBase.CollectData, inbuffer: Gst.Buffer, outbuffer: Gst.Buffer) => Gst.FlowReturn): void;
|
|
setCompareFunction(func: (pads: GstBase.CollectPads, data1: GstBase.CollectData, timestamp1: number | bigint, data2: GstBase.CollectData, timestamp2: number | bigint) => number): void;
|
|
setEventFunction(func: (pads: GstBase.CollectPads, pad: GstBase.CollectData, event: Gst.Event) => boolean): void;
|
|
setFlushFunction(func: (pads: GstBase.CollectPads) => void): void;
|
|
setFlushing(flushing: boolean): void;
|
|
setFunction(func: (pads: GstBase.CollectPads) => Gst.FlowReturn): void;
|
|
setQueryFunction(func: (pads: GstBase.CollectPads, pad: GstBase.CollectData, query: Gst.Query) => boolean): void;
|
|
setWaiting(data: GstBase.CollectData, waiting: boolean): void;
|
|
srcEventDefault(pad: Gst.Pad, event: Gst.Event): boolean;
|
|
start(): void;
|
|
stop(): void;
|
|
takeBuffer(data: GstBase.CollectData, size: number): Gst.Buffer;
|
|
//TypeScript is complete garbage:
|
|
}
|
|
|
|
class CollectPadsCtor {
|
|
name ?: string;
|
|
parent ?: Gst.Object;
|
|
}
|
|
|
|
class DataQueue extends GObject.Object {
|
|
constructor(initializerList ?: DataQueueCtor);
|
|
|
|
object : GObject.Object;
|
|
priv : GstBase.DataQueuePrivate;
|
|
|
|
currentLevelBytes : number;
|
|
currentLevelTime : number | bigint;
|
|
currentLevelVisible : number;
|
|
|
|
//TypeScript is complete garbage:
|
|
}
|
|
|
|
class DataQueueCtor {
|
|
currentLevelVisible ?: number;
|
|
currentLevelBytes ?: number;
|
|
currentLevelTime ?: number;
|
|
}
|
|
|
|
class PushSrc extends GstBase.BaseSrc {
|
|
constructor(initializerList ?: PushSrcCtor);
|
|
|
|
parent : GstBase.BaseSrc;
|
|
|
|
//TypeScript is complete garbage:
|
|
}
|
|
|
|
class PushSrcCtor {
|
|
name ?: string;
|
|
parent ?: Gst.Object;
|
|
blocksize ?: number;
|
|
numBuffers ?: number;
|
|
typefind ?: boolean;
|
|
doTimestamp ?: boolean;
|
|
}
|
|
} |