janishutz/dotfiles
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity

[Notes] Some changes

Browse Source
This commit is contained in:
Janis Hutz
2025-04-25 06:51:13 +02:00
parent 10136ab9de
commit b5ad7e3034
198 changed files with 1916125 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

733
config/ags/quickactions/@girs/gstbadaudio-1.0.d.ts vendored Normal file
View File

@@ -0,0 +1,733 @@
/// <reference path="./gstbase-1.0.d.ts" />
/// <reference path="./gst-1.0.d.ts" />
/// <reference path="./gobject-2.0.d.ts" />
/// <reference path="./glib-2.0.d.ts" />
/// <reference path="./gmodule-2.0.d.ts" />
/// <reference path="./gstaudio-1.0.d.ts" />
/**
* Type Definitions for Gjs (https://gjs.guide/)
*
* These type definitions are automatically generated, do not edit them by hand.
* If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
*
* The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
*/
declare module 'gi://GstBadAudio?version=1.0' {
// Module dependencies
import type GstBase from 'gi://GstBase?version=1.0';
import type Gst from 'gi://Gst?version=1.0';
import type GObject from 'gi://GObject?version=2.0';
import type GLib from 'gi://GLib?version=2.0';
import type GModule from 'gi://GModule?version=2.0';
import type GstAudio from 'gi://GstAudio?version=1.0';
export namespace GstBadAudio {
/**
* GstBadAudio-1.0
*/
/**
* The output mode defines how the output behaves with regards to looping. Either the playback position is
* moved back to the beginning of the loop, acting like a backwards seek, or it increases steadily, as if
* loop were "unrolled".
*/
/**
* The output mode defines how the output behaves with regards to looping. Either the playback position is
* moved back to the beginning of the loop, acting like a backwards seek, or it increases steadily, as if
* loop were "unrolled".
*/
export namespace NonstreamAudioOutputMode {
export const $gtype: GObject.GType<NonstreamAudioOutputMode>;
}
enum NonstreamAudioOutputMode {
/**
* Playback position is moved back to the beginning of the loop
*/
LOOPING,
/**
* Playback position increases steadily, even when looping
*/
STEADY,
}
/**
* The subsong mode defines how the decoder shall handle subsongs.
*/
/**
* The subsong mode defines how the decoder shall handle subsongs.
*/
export namespace NonstreamAudioSubsongMode {
export const $gtype: GObject.GType<NonstreamAudioSubsongMode>;
}
enum NonstreamAudioSubsongMode {
/**
* Only the current subsong is played
*/
SINGLE,
/**
* All subsongs are played (current subsong index is ignored)
*/
ALL,
/**
* Use decoder specific default behavior
*/
DECODER_DEFAULT,
}
/**
* The name of the template for the sink pad.
*/
const NONSTREAM_AUDIO_DECODER_SINK_NAME: string;
/**
* The name of the template for the source pad.
*/
const NONSTREAM_AUDIO_DECODER_SRC_NAME: string;
namespace NonstreamAudioDecoder {
// Constructor properties interface
interface ConstructorProps extends Gst.Element.ConstructorProps {
current_subsong: number;
currentSubsong: number;
num_loops: number;
numLoops: number;
}
}
/**
* This base class is for decoders which do not operate on a streaming model.
* That is: they load the encoded media at once, as part of an initialization,
* and afterwards can decode samples (sometimes referred to as "rendering the
* samples").
*
* This sets it apart from GstAudioDecoder, which is a base class for
* streaming audio decoders.
*
* The base class is conceptually a mix between decoder and parser. This is
* unavoidable, since virtually no format that isn't streaming based has a
* clear distinction between parsing and decoding. As a result, this class
* also handles seeking.
*
* Non-streaming audio formats tend to have some characteristics unknown to
* more "regular" bitstreams. These include subsongs and looping.
*
* Subsongs are a set of songs-within-a-song. An analogy would be a multitrack
* recording, where each track is its own song. The first subsong is typically
* the "main" one. Subsongs were popular for video games to enable context-
* aware music; for example, subsong `#0` would be the "main" song, `#1` would be
* an alternate song playing when a fight started, `#2` would be heard during
* conversations etc. The base class is designed to always have at least one
* subsong. If the subclass doesn't provide any, the base class creates a
* "pseudo" subsong, which is actually the whole song.
* Downstream is informed about the subsong using a table of contents (TOC),
* but only if there are at least 2 subsongs.
*
* Looping refers to jumps within the song, typically backwards to the loop
* start (although bi-directional looping is possible). The loop is defined
* by a chronological start and end; once the playback position reaches the
* loop end, it jumps back to the loop start.
* Depending on the subclass, looping may not be possible at all, or it
* may only be possible to enable/disable it (that is, either no looping, or
* an infinite amount of loops), or it may allow for defining a finite number
* of times the loop is repeated.
* Looping can affect output in two ways. Either, the playback position is
* reset to the start of the loop, similar to what happens after a seek event.
* Or, it is not reset, so the pipeline sees playback steadily moving forwards,
* the playback position monotonically increasing. However, seeking must
* always happen within the confines of the defined subsong duration; for
* example, if a subsong is 2 minutes long, steady playback is at 5 minutes
* (because infinite looping is enabled), then seeking will still place the
* position within the 2 minute period.
* Loop count 0 means no looping. Loop count -1 means infinite looping.
* Nonzero positive values indicate how often a loop shall occur.
*
* If the initial subsong and loop count are set to values the subclass does
* not support, the subclass has a chance to correct these values.
* `get_property` then reports the corrected versions.
*
* The base class operates as follows:
* * Unloaded mode
* - Initial values are set. If a current subsong has already been
* defined (for example over the command line with gst-launch), then
* the subsong index is copied over to current_subsong .
* Same goes for the num-loops and output-mode properties.
* Media is NOT loaded yet.
* - Once the sinkpad is activated, the process continues. The sinkpad is
* activated in push mode, and the class accumulates the incoming media
* data in an adapter inside the sinkpad's chain function until either an
* EOS event is received from upstream, or the number of bytes reported
* by upstream is reached. Then it loads the media, and starts the decoder
* output task.
* - If upstream cannot respond to the size query (in bytes) of `load_from_buffer`
* fails, an error is reported, and the pipeline stops.
* - If there are no errors, `load_from_buffer` is called to load the media. The
* subclass must at least call gst_nonstream_audio_decoder_set_output_format()
* there, and is free to make use of the initial subsong, output mode, and
* position. If the actual output mode or position differs from the initial
* value,it must set the initial value to the actual one (for example, if
* the actual starting position is always 0, set *initial_position to 0).
* If loading is unsuccessful, an error is reported, and the pipeline
* stops. Otherwise, the base class calls `get_current_subsong` to retrieve
* the actual current subsong, `get_subsong_duration` to report the current
* subsong's duration in a duration event and message, and `get_subsong_tags`
* to send tags downstream in an event (these functions are optional; if
* set to NULL, the associated operation is skipped). Afterwards, the base
* class switches to loaded mode, and starts the decoder output task.
*
* * Loaded mode</title>
* - Inside the decoder output task, the base class repeatedly calls `decode,`
* which returns a buffer with decoded, ready-to-play samples. If the
* subclass reached the end of playback, `decode` returns FALSE, otherwise
* TRUE.
* - Upon reaching a loop end, subclass either ignores that, or loops back
* to the beginning of the loop. In the latter case, if the output mode is set
* to LOOPING, the subclass must call gst_nonstream_audio_decoder_handle_loop()
* *after* the playback position moved to the start of the loop. In
* STEADY mode, the subclass must *not* call this function.
* Since many decoders only provide a callback for when the looping occurs,
* and that looping occurs inside the decoding operation itself, the following
* mechanism for subclass is suggested: set a flag inside such a callback.
* Then, in the next `decode` call, before doing the decoding, check this flag.
* If it is set, gst_nonstream_audio_decoder_handle_loop() is called, and the
* flag is cleared.
* (This function call is necessary in LOOPING mode because it updates the
* current segment and makes sure the next buffer that is sent downstream
* has its DISCONT flag set.)
* - When the current subsong is switched, `set_current_subsong` is called.
* If it fails, a warning is reported, and nothing else is done. Otherwise,
* it calls `get_subsong_duration` to get the new current subsongs's
* duration, `get_subsong_tags` to get its tags, reports a new duration
* (i.e. it sends a duration event downstream and generates a duration
* message), updates the current segment, and sends the subsong's tags in
* an event downstream. (If `set_current_subsong` has been set to NULL by
* the subclass, attempts to set a current subsong are ignored; likewise,
* if `get_subsong_duration` is NULL, no duration is reported, and if
* `get_subsong_tags` is NULL, no tags are sent downstream.)
* - When an attempt is made to switch the output mode, it is checked against
* the bitmask returned by `get_supported_output_modes`. If the proposed
* new output mode is supported, the current segment is updated
* (it is open-ended in STEADY mode, and covers the (sub)song length in
* LOOPING mode), and the subclass' `set_output_mode` function is called
* unless it is set to NULL. Subclasses should reset internal loop counters
* in this function.
*
* The relationship between (sub)song duration, output mode, and number of loops
* is defined this way (this is all done by the base class automatically):
*
* * Segments have their duration and stop values set to GST_CLOCK_TIME_NONE in
* STEADY mode, and to the duration of the (sub)song in LOOPING mode.
*
* * The duration that is returned to a DURATION query is always the duration
* of the (sub)song, regardless of number of loops or output mode. The same
* goes for DURATION messages and tags.
*
* * If the number of loops is >0 or -1, durations of TOC entries are set to
* the duration of the respective subsong in LOOPING mode and to G_MAXINT64 in
* STEADY mode. If the number of loops is 0, entry durations are set to the
* subsong duration regardless of the output mode.
*/
abstract class NonstreamAudioDecoder extends Gst.Element {
static $gtype: GObject.GType<NonstreamAudioDecoder>;
// Properties
get current_subsong(): number;
set current_subsong(val: number);
get currentSubsong(): number;
set currentSubsong(val: number);
get num_loops(): number;
set num_loops(val: number);
get numLoops(): number;
set numLoops(val: number);
// Fields
element: Gst.Element;
sinkpad: Gst.Pad;
srcpad: Gst.Pad;
upstream_size: number;
loaded_mode: boolean;
input_data_adapter: GstBase.Adapter;
subsong_duration: Gst.ClockTime;
output_format_changed: boolean;
cur_pos_in_samples: number;
num_decoded_samples: number;
discont: boolean;
allocator: Gst.Allocator;
// Constructors
constructor(properties?: Partial<NonstreamAudioDecoder.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
// Virtual methods
/**
* Optional.
* Sets up the allocation parameters for allocating output
* buffers. The passed in query contains the result of the
* downstream allocation query.
* Subclasses should chain up to the parent implementation to
* invoke the default handler.
* @param query
*/
vfunc_decide_allocation(query: Gst.Query): boolean;
/**
* Always required.
* Allocates an output buffer, fills it with decoded audio samples, and must be passed on to
* *buffer . The number of decoded samples must be passed on to *num_samples.
* If decoding finishes or the decoding is no longer possible (for example, due to an
* unrecoverable error), this function returns FALSE, otherwise TRUE.
* @param buffer
* @param num_samples
*/
vfunc_decode(buffer: Gst.Buffer, num_samples: number): boolean;
/**
* Optional.
* Returns the current subsong.
* If the current subsong mode is not GST_NONSTREAM_AUDIO_SUBSONG_MODE_SINGLE, this
* function's return value is undefined.
* If this function is implemented by the subclass,
* `get_num_subsongs` should be implemented as well.
*/
vfunc_get_current_subsong(): number;
/**
* Optional.
* Returns a tag list containing the main song tags, or NULL if there are
* no such tags. Returned tags will be unref'd. Use this vfunc instead of
* manually pushing a tag event downstream to avoid edge cases where not yet
* pushed sticky tag events get overwritten before they are pushed (can for
* example happen with decodebin if tags are pushed downstream before the
* decodebin pads are linked).
*/
vfunc_get_main_tags(): Gst.TagList;
/**
* Optional.
* Returns the number of loops for playback.
*/
vfunc_get_num_loops(): number;
/**
* Optional.
* Returns the number of subsongs available.
* The return values 0 and 1 have a similar, but distinct, meaning.
* If this function returns 0, then this decoder does not support subsongs at all.
* `get_current_subsong` must then also always return 0. In other words, this function
* either never returns 0, or never returns anything else than 0.
* A return value of 1 means that the media contains either only one or no subsongs
* (the entire song is then considered to be one single subsong). 1 also means that only
* this very media has no or just one subsong, and the decoder itself can
* support multiple subsongs.
*/
vfunc_get_num_subsongs(): number;
/**
* Optional.
* Returns the duration of a subsong. Returns GST_CLOCK_TIME_NONE if duration is unknown.
* @param subsong
*/
vfunc_get_subsong_duration(subsong: number): Gst.ClockTime;
/**
* Optional.
* Returns tags for a subsong, or NULL if there are no tags.
* Returned tags will be unref'd.
* @param subsong
*/
vfunc_get_subsong_tags(subsong: number): Gst.TagList;
/**
* Always required.
* Returns a bitmask containing the output modes the subclass supports.
* The mask is formed by a bitwise OR combination of integers, which can be calculated
* this way: 1 << GST_NONSTREAM_AUDIO_OUTPUT_MODE_<mode> , where mode is either STEADY or LOOPING
*/
vfunc_get_supported_output_modes(): number;
/**
* Required if loads_from_sinkpad is set to TRUE (the default value).
* Loads the media from the given buffer. The entire media is supplied at once,
* so after this call, loading should be finished. This function
* can also make use of a suggested initial subsong & subsong mode and initial
* playback position (but isn't required to). In case it chooses a different starting
* position, the function must pass this position to *initial_position.
* The subclass does not have to unref the input buffer; the base class does that
* already.
* @param source_data
* @param initial_subsong
* @param initial_subsong_mode
* @param initial_position
* @param initial_output_mode
* @param initial_num_loops
*/
vfunc_load_from_buffer(
source_data: Gst.Buffer,
initial_subsong: number,
initial_subsong_mode: NonstreamAudioSubsongMode,
initial_position: Gst.ClockTime,
initial_output_mode: NonstreamAudioOutputMode,
initial_num_loops: number,
): boolean;
/**
* Required if loads_from_sinkpad is set to FALSE.
* Loads the media in a way defined by the custom sink. Data is not supplied;
* the derived class has to handle this on its own. Otherwise, this function is
* identical to `load_from_buffer`.
* @param initial_subsong
* @param initial_subsong_mode
* @param initial_position
* @param initial_output_mode
* @param initial_num_loops
*/
vfunc_load_from_custom(
initial_subsong: number,
initial_subsong_mode: NonstreamAudioSubsongMode,
initial_position: Gst.ClockTime,
initial_output_mode: NonstreamAudioOutputMode,
initial_num_loops: number,
): boolean;
vfunc_negotiate(): boolean;
/**
* Optional.
* Proposes buffer allocation parameters for upstream elements.
* Subclasses should chain up to the parent implementation to
* invoke the default handler.
* @param query
*/
vfunc_propose_allocation(query: Gst.Query): boolean;
/**
* Optional.
* Called when a seek event is received by the parent class.
* new_position is a pointer to a GstClockTime integer which
* contains a position relative to the current subsong.
* Minimum is 0, maximum is the subsong length.
* After this function finishes, new_position is set to the
* actual new position (which may differ from the request
* position, depending on the decoder).
* @param new_position
*/
vfunc_seek(new_position: Gst.ClockTime): boolean;
/**
* Optional.
* Sets the current subsong. This function is allowed to switch to a different
* subsong than the required one, and can optionally make use of the suggested initial
* position. In case it chooses a different starting position, the function must pass
* this position to *initial_position.
* This function switches the subsong mode to GST_NONSTREAM_AUDIO_SUBSONG_MODE_SINGLE
* automatically.
* If this function is implemented by the subclass, `get_current_subsong` and
* `get_num_subsongs` should be implemented as well.
* @param subsong
* @param initial_position
*/
vfunc_set_current_subsong(subsong: number, initial_position: Gst.ClockTime): boolean;
/**
* Optional.
* Sets the number of loops for playback. If this is called during playback,
* the subclass must set any internal loop counters to zero. A loop value of -1
* means infinite looping; 0 means no looping; and when the num_loops is greater than 0,
* playback should loop exactly num_loops times. If this function is implemented,
* `get_num_loops` should be implemented as well. The function can ignore the given values
* and choose another; however, `get_num_loops` should return this other value afterwards.
* It is up to the subclass to define where the loop starts and ends. It can mean that only
* a subset at the end or in the middle of a song is repeated, for example.
* If the current subsong mode is GST_NONSTREAM_AUDIO_SUBSONG_MODE_SINGLE, then the subsong
* is repeated this many times. If it is GST_NONSTREAM_AUDIO_SUBSONG_MODE_ALL, then all
* subsongs are repeated this many times. With GST_NONSTREAM_AUDIO_SUBSONG_MODE_DECODER_DEFAULT,
* the behavior is decoder specific.
* @param num_loops
*/
vfunc_set_num_loops(num_loops: number): boolean;
/**
* Optional.
* Sets the output mode the subclass has to use. Unlike with most other functions, the subclass
* cannot choose a different mode; it must use the requested one.
* If the output mode is set to LOOPING, `gst_nonstream_audio_decoder_handle_loop`
* must be called after playback moved back to the start of a loop.
* @param mode
* @param current_position
*/
vfunc_set_output_mode(mode: NonstreamAudioOutputMode, current_position: Gst.ClockTime): boolean;
/**
* Optional.
* Sets the current subsong mode. Since this might influence the current playback position,
* this function must set the initial_position integer argument to a defined value.
* If the playback position is not affected at all, it must be set to GST_CLOCK_TIME_NONE.
* If the subsong is restarted after the mode switch, it is recommended to set the value
* to the position in the playback right after the switch (or 0 if the subsongs are always
* reset back to the beginning).
* @param mode
* @param initial_position
*/
vfunc_set_subsong_mode(mode: NonstreamAudioSubsongMode, initial_position: Gst.ClockTime): boolean;
/**
* Optional.
* Called when a position query is received by the parent class.
* The position that this function returns must be relative to
* the current subsong. Thus, the minimum is 0, and the maximum
* is the subsong length.
*/
vfunc_tell(): Gst.ClockTime;
// Methods
/**
* Allocates an output buffer with the internally configured buffer pool.
*
* This function may only be called from within `load_from_buffer,`
* `load_from_custom,` and `decode`.
* @param size Size of the output buffer, in bytes
* @returns Newly allocated output buffer, or NULL if allocation failed
*/
allocate_output_buffer(size: number): Gst.Buffer | null;
/**
* Gets sample format, sample rate, channel count from the allowed srcpad caps.
*
* This is useful for when the subclass wishes to adjust one or more output
* parameters to whatever downstream is supporting. For example, the output
* sample rate is often a freely adjustable value in module players.
*
* This function tries to find a value inside the srcpad peer's caps for
* `format,` `sample_rate,` `num_chnanels` . Any of these can be NULL; they
* (and the corresponding downstream caps) are then skipped while retrieving
* information. Non-fixated caps are fixated first; the value closest to
* their present value is then chosen. For example, if the variables pointed
* to by the arguments are GST_AUDIO_FORMAT_16, 48000 Hz, and 2 channels,
* and the downstream caps are:
*
* "audio/x-raw, format={S16LE,S32LE}, rate=[1,32000], channels=[1,MAX]"
*
* Then `format` and `channels` stay the same, while `sample_rate` is set to 32000 Hz.
* This way, the initial values the the variables pointed to by the arguments
* are set to can be used as default output values. Note that if no downstream
* caps can be retrieved, then this function does nothing, therefore it is
* necessary to ensure that `format,` `sample_rate,` and `channels` have valid
* initial values.
*
* Decoder lock is not held by this function, so it can be called from within
* any of the class vfuncs.
* @param format #GstAudioFormat value to fill with a sample format
* @param sample_rate Integer to fill with a sample rate
* @param num_channels Integer to fill with a channel count
*/
get_downstream_info(format: GstAudio.AudioFormat | null, sample_rate: number, num_channels: number): void;
/**
* Reports that a loop has been completed and creates a new appropriate
* segment for the next loop.
*
* `new_position` exists because a loop may not start at the beginning.
*
* This function is only useful for subclasses which can be in the
* GST_NONSTREAM_AUDIO_OUTPUT_MODE_LOOPING output mode, since in the
* GST_NONSTREAM_AUDIO_OUTPUT_MODE_STEADY output mode, this function
* does nothing. See #GstNonstreamAudioOutputMode for more details.
*
* The subclass calls this during playback when it loops. It produces
* a new segment with updated base time and internal time values, to allow
* for seamless looping. It does *not* check the number of elapsed loops;
* this is up the subclass.
*
* Note that if this function is called, then it must be done after the
* last samples of the loop have been decoded and pushed downstream.
*
* This function must be called with the decoder mutex lock held, since it
* is typically called from within `decode` (which in turn are called with
* the lock already held).
* @param new_position
*/
handle_loop(new_position: Gst.ClockTime): void;
/**
* Sets the output caps by means of a GstAudioInfo structure.
*
* This must be called latest in the first `decode` call, to ensure src caps are
* set before decoded samples are sent downstream. Typically, this is called
* from inside `load_from_buffer` or `load_from_custom`.
*
* This function must be called with the decoder mutex lock held, since it
* is typically called from within the aforementioned vfuncs (which in turn
* are called with the lock already held).
* @param audio_info Valid audio info structure containing the output format
* @returns TRUE if setting the output format succeeded, FALSE otherwise
*/
set_output_format(audio_info: GstAudio.AudioInfo): boolean;
/**
* Convenience function; sets the output caps by means of common parameters.
*
* Internally, this fills a GstAudioInfo structure and calls
* gst_nonstream_audio_decoder_set_output_format().
* @param sample_rate Output sample rate to use, in Hz
* @param sample_format Output sample format to use
* @param num_channels Number of output channels to use
* @returns TRUE if setting the output format succeeded, FALSE otherwise
*/
set_output_format_simple(
sample_rate: number,
sample_format: GstAudio.AudioFormat | null,
num_channels: number,
): boolean;
}
namespace PlanarAudioAdapter {
// Constructor properties interface
interface ConstructorProps extends GObject.Object.ConstructorProps {}
}
/**
* This class is similar to GstAdapter, but it is made to work with
* non-interleaved (planar) audio buffers. Before using, an audio format
* must be configured with gst_planar_audio_adapter_configure()
*/
class PlanarAudioAdapter extends GObject.Object {
static $gtype: GObject.GType<PlanarAudioAdapter>;
// Constructors
constructor(properties?: Partial<PlanarAudioAdapter.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): PlanarAudioAdapter;
// Methods
/**
* Gets the maximum amount of samples available, that is it returns the maximum
* value that can be supplied to gst_planar_audio_adapter_get_buffer() without
* that function returning %NULL.
* @returns number of samples available in @adapter
*/
available(): number;
/**
* Removes all buffers from `adapter`.
*/
clear(): void;
/**
* Sets up the `adapter` to handle audio data of the specified audio format.
* Note that this will internally clear the adapter and re-initialize it.
* @param info a #GstAudioInfo describing the format of the audio data
*/
configure(info: GstAudio.AudioInfo): void;
distance_from_discont(): number;
/**
* Get the DTS that was on the last buffer with the GST_BUFFER_FLAG_DISCONT
* flag, or GST_CLOCK_TIME_NONE.
* @returns The DTS at the last discont or GST_CLOCK_TIME_NONE.
*/
dts_at_discont(): Gst.ClockTime;
/**
* Flushes the first `to_flush` samples in the `adapter`. The caller must ensure
* that at least this many samples are available.
* @param to_flush the number of samples to flush
*/
flush(to_flush: number): void;
/**
* Returns a #GstBuffer containing the first `nsamples` of the `adapter,` but
* does not flush them from the adapter.
* Use gst_planar_audio_adapter_take_buffer() for flushing at the same time.
*
* The map `flags` can be used to give an optimization hint to this function.
* When the requested buffer is meant to be mapped only for reading, it might
* be possible to avoid copying memory in some cases.
*
* Caller owns a reference to the returned buffer. gst_buffer_unref() after
* usage.
*
* Free-function: gst_buffer_unref
* @param nsamples the number of samples to get
* @param flags hint the intended use of the returned buffer
* @returns a #GstBuffer containing the first @nsamples of the adapter, or %NULL if @nsamples samples are not available. gst_buffer_unref() when no longer needed.
*/
get_buffer(nsamples: number, flags: Gst.MapFlags | null): Gst.Buffer | null;
/**
* Get the offset that was on the last buffer with the GST_BUFFER_FLAG_DISCONT
* flag, or GST_BUFFER_OFFSET_NONE.
* @returns The offset at the last discont or GST_BUFFER_OFFSET_NONE.
*/
offset_at_discont(): number;
/**
* Get the dts that was before the current sample in the adapter. When
* `distance` is given, the amount of bytes between the dts and the current
* position is returned.
*
* The dts is reset to GST_CLOCK_TIME_NONE and the distance is set to 0 when
* the adapter is first created or when it is cleared. This also means that
* before the first sample with a dts is removed from the adapter, the dts
* and distance returned are GST_CLOCK_TIME_NONE and 0 respectively.
* @returns The previously seen dts.
*/
prev_dts(): [Gst.ClockTime, number];
/**
* Get the offset that was before the current sample in the adapter. When
* `distance` is given, the amount of samples between the offset and the current
* position is returned.
*
* The offset is reset to GST_BUFFER_OFFSET_NONE and the distance is set to 0
* when the adapter is first created or when it is cleared. This also means that
* before the first sample with an offset is removed from the adapter, the
* offset and distance returned are GST_BUFFER_OFFSET_NONE and 0 respectively.
* @returns The previous seen offset.
*/
prev_offset(): [number, number];
/**
* Get the pts that was before the current sample in the adapter. When
* `distance` is given, the amount of samples between the pts and the current
* position is returned.
*
* The pts is reset to GST_CLOCK_TIME_NONE and the distance is set to 0 when
* the adapter is first created or when it is cleared. This also means that before
* the first sample with a pts is removed from the adapter, the pts
* and distance returned are GST_CLOCK_TIME_NONE and 0 respectively.
* @returns The previously seen pts.
*/
prev_pts(): [Gst.ClockTime, number];
/**
* Get the PTS that was on the last buffer with the GST_BUFFER_FLAG_DISCONT
* flag, or GST_CLOCK_TIME_NONE.
* @returns The PTS at the last discont or GST_CLOCK_TIME_NONE.
*/
pts_at_discont(): Gst.ClockTime;
/**
* Adds the data from `buf` to the data stored inside `adapter` and takes
* ownership of the buffer.
* @param buf a #GstBuffer to queue in the adapter
*/
push(buf: Gst.Buffer): void;
/**
* Returns a #GstBuffer containing the first `nsamples` bytes of the
* `adapter`. The returned bytes will be flushed from the adapter.
*
* See gst_planar_audio_adapter_get_buffer() for more details.
*
* Caller owns a reference to the returned buffer. gst_buffer_unref() after
* usage.
*
* Free-function: gst_buffer_unref
* @param nsamples the number of samples to take
* @param flags hint the intended use of the returned buffer
* @returns a #GstBuffer containing the first @nsamples of the adapter, or %NULL if @nsamples samples are not available. gst_buffer_unref() when no longer needed.
*/
take_buffer(nsamples: number, flags: Gst.MapFlags | null): Gst.Buffer | null;
}
type NonstreamAudioDecoderClass = typeof NonstreamAudioDecoder;
type PlanarAudioAdapterClass = typeof PlanarAudioAdapter;
/**
* Name of the imported GIR library
* `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
*/
const __name__: string;
/**
* Version of the imported GIR library
* `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
*/
const __version__: string;
}
export default GstBadAudio;
}
declare module 'gi://GstBadAudio' {
import GstBadAudio10 from 'gi://GstBadAudio?version=1.0';
export default GstBadAudio10;
}
// END