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

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

@@ -0,0 +1,532 @@
/// <reference path="./gstvideo-1.0.d.ts" />
/// <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" />
/**
* 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://GstVa?version=1.0' {
// Module dependencies
import type GstVideo from 'gi://GstVideo?version=1.0';
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';
export namespace GstVa {
/**
* GstVa-1.0
*/
export namespace VaFeature {
export const $gtype: GObject.GType<VaFeature>;
}
enum VaFeature {
/**
* The feature is disabled.
*/
DISABLED,
/**
* The feature is enabled.
*/
ENABLED,
/**
* The feature is enabled automatically.
*/
AUTO,
}
/**
* Types of different VA API implemented drivers. These are the typical and
* the most widely used VA drivers.
*/
/**
* Types of different VA API implemented drivers. These are the typical and
* the most widely used VA drivers.
*/
export namespace VaImplementation {
export const $gtype: GObject.GType<VaImplementation>;
}
enum VaImplementation {
/**
* The mesa gallium implementation.
*/
MESA_GALLIUM,
/**
* The legacy i965 intel implementation.
*/
INTEL_I965,
/**
* The iHD intel implementation.
*/
INTEL_IHD,
/**
* Other implementation.
*/
OTHER,
/**
* Invalid implementation.
*/
INVALID,
}
const ALLOCATOR_VASURFACE: string;
const CAPS_FEATURE_MEMORY_VA: string;
/**
* Flag indicating that we should map the VASurfaceID instead of to
* system memory, so users can use libva primitives to operate with
* that surface.
*/
const MAP_VA: number;
const VA_DISPLAY_HANDLE_CONTEXT_TYPE_STR: string;
/**
* Video alignment is not handled as expected by VA since it uses
* opaque surfaces, not directly mappable memory. Still, decoders
* might need to request bigger surfaces for coded size rather than
* display sizes. This method will set the coded size to bufferpool's
* configuration, out of the typical video aligment.
* @param config the #GstStructure with the pool's configuration.
* @param align a #GstVideoAlignment
*/
function buffer_pool_config_set_va_alignment(config: Gst.Structure, align: GstVideo.VideoAlignment): void;
/**
* Sets the usage hint for the buffers handled by the buffer pool.
* @param config the #GstStructure with the pool's configuration.
* @param usage_hint the VA usage hint for new VASurfaceID.
* @param use_derived a #GstVaFeature for derived mapping (only used when VA allocator).
*/
function buffer_pool_config_set_va_allocation_params(
config: Gst.Structure,
usage_hint: number,
use_derived: VaFeature | null,
): void;
function context_get_va_display(
context: Gst.Context,
type_name: string,
render_device_path: string,
): [boolean, VaDisplay];
/**
* Set the `display` in the `context`
* @param context a #GstContext
* @param display the #GstVaDisplay we want to set
*/
function context_set_va_display(context: Gst.Context, display: VaDisplay): void;
/**
* Creates a new VASurfaceID with `buffer'`s allocator and attached it
* to it.
*
* *This method is used only by plugin's internal VA decoder.*
* @param buffer a #GstBuffer
* @returns %TRUE if the new VASurfaceID is attached to @buffer correctly; %FALSE, otherwise.
*/
function va_buffer_create_aux_surface(buffer: Gst.Buffer): boolean;
function va_buffer_peek_display(buffer: Gst.Buffer): VaDisplay;
/**
* Query the specified context type name.
* @param element a #GstElement
* @param context_type the #gchar string specify the context type name
*/
function va_context_query(element: Gst.Element, context_type: string): void;
/**
* Get the underlying modifier for specified `format` and `usage_hint`.
* @param display a #GstVaDisplay
* @param format a #GstVideoFormat
* @param usage_hint VA usage hint
* @returns the underlying modifier.
*/
function va_dmabuf_get_modifier_for_format(
display: VaDisplay,
format: GstVideo.VideoFormat | null,
usage_hint: number,
): number;
/**
* It imports the array of `mem,` representing a single frame, into a
* VASurfaceID and it's attached into every `mem`.
* @param display a #GstVaDisplay
* @param drm_info a #GstVideoInfoDmaDrm
* @param mem Memories. One per plane.
* @param fds array of DMABuf file descriptors.
* @param offset array of memory offsets.
* @param usage_hint VA usage hint.
* @returns %TRUE if frame is imported correctly into a VASurfaceID; %FALSE otherwise.
*/
function va_dmabuf_memories_setup(
display: VaDisplay,
drm_info: GstVideo.VideoInfoDmaDrm,
mem: Gst.Memory[],
fds: never[],
offset: number[],
usage_hint: number,
): boolean;
/**
* Propagate `display` by posting it as #GstContext in the pipeline's bus.
* @param element a #GstElement
* @param display the #GstVaDisplay to propagate
*/
function va_element_propagate_display_context(element: Gst.Element, display: VaDisplay): void;
/**
* Called by the va element to ensure a valid #GstVaDisplay.
* @param element a #GstElement
* @param render_device_path the #gchar string of render device path
* @returns whether a #GstVaDisplay exists in @display_ptr
*/
function va_ensure_element_data(element: any | null, render_device_path: string): [boolean, VaDisplay];
/**
* Used by elements when processing their pad's queries, propagating
* element's #GstVaDisplay if the processed query requests it.
* @param element a #GstElement
* @param query a #GstQuery to query the context
* @param display a #GstVaDisplay to answer the query
* @returns whether we can handle the context query successfully
*/
function va_handle_context_query(element: Gst.Element, query: Gst.Query, display: VaDisplay): boolean;
/**
* Called by elements in their #GstElementClass::set_context vmethod.
* It gets a valid #GstVaDisplay if `context` has it.
* @param element a #GstElement
* @param context a #GstContext may contain the display
* @param render_device_path the #gchar string of render device path
* @returns whether the @display_ptr could be successfully set to a valid #GstVaDisplay in the @context
*/
function va_handle_set_context(
element: Gst.Element,
context: Gst.Context,
render_device_path: string,
): [boolean, VaDisplay];
function va_memory_peek_display(mem: Gst.Memory): VaDisplay;
namespace VaAllocator {
// Constructor properties interface
interface ConstructorProps extends Gst.Allocator.ConstructorProps {}
}
/**
* There are two types of VA allocators:
*
* * #GstVaAllocator
* * #GstVaDmabufAllocator
*/
class VaAllocator extends Gst.Allocator {
static $gtype: GObject.GType<VaAllocator>;
// Constructors
constructor(properties?: Partial<VaAllocator.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](display: VaDisplay, surface_formats: number[]): VaAllocator;
// Static methods
/**
* Allocate a new VASurfaceID backed #GstMemory.
* @param allocator a #GstAllocator
*/
static alloc(allocator: Gst.Allocator): Gst.Memory;
/**
* Removes all the memories in `allocator'`s pool.
* @param allocator a #GstAllocator
*/
static flush(allocator: Gst.Allocator): void;
/**
* Gets current internal configuration of `allocator`.
* @param allocator a #GstAllocator
*/
static get_format(allocator: Gst.Allocator): [boolean, GstVideo.VideoInfo | null, number, boolean];
static peek_display(allocator: Gst.Allocator): VaDisplay;
/**
* This method will populate `buffer` with pooled VASurfaceID
* memories. It doesn't allocate new VASurfacesID.
* @param allocator a #GstAllocator
* @param buffer an empty #GstBuffer
*/
static prepare_buffer(allocator: Gst.Allocator, buffer: Gst.Buffer): boolean;
/**
* Sets the configuration defined by `info,` `usage_hint` and
* `use_derived` for `allocator,` and it tries the configuration, if
* `allocator` has not allocated memories yet.
*
* If `allocator` has memory allocated already, and frame size and
* format in `info` are the same as currently configured in `allocator,`
* the rest of `info` parameters are updated internally.
* @param allocator a #GstAllocator
* @param info a #GstVideoInfo
* @param usage_hint VA usage hint
* @param feat_use_derived a #GstVaFeature
*/
static set_format(
allocator: Gst.Allocator,
info: GstVideo.VideoInfo,
usage_hint: number,
feat_use_derived: VaFeature,
): [boolean, GstVideo.VideoInfo];
/**
* Populates an empty `buffer` with a VASuface backed #GstMemory.
* @param allocator a #GstAllocator
* @param buffer a #GstBuffer
*/
static setup_buffer(allocator: Gst.Allocator, buffer: Gst.Buffer): boolean;
}
namespace VaDisplay {
// Constructor properties interface
interface ConstructorProps extends Gst.Object.ConstructorProps {
description: string;
va_display: any;
vaDisplay: any;
}
}
/**
* It is a generic wrapper for VADisplay. To create new instances
* subclasses are required, depending on the display type to use
* (v.gr. DRM, X11, Wayland, etc.).
*
* The purpose of this class is to be shared among pipelines via
* #GstContext so all the VA processing elements will use the same
* display entry. Application developers can create their own
* subclass, based on their display, and shared it via the synced bus
* message for the application.
*/
class VaDisplay extends Gst.Object {
static $gtype: GObject.GType<VaDisplay>;
// Properties
get description(): string;
get va_display(): any;
get vaDisplay(): any;
// Constructors
constructor(properties?: Partial<VaDisplay.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
// Virtual methods
/**
* This is called when the subclass has to create the internal
* VADisplay.
*/
vfunc_create_va_display(): any | null;
// Methods
check_version(major: number, minor: number): boolean;
/**
* Get the the #GstVaImplementation type of `self`.
* @returns #GstVaImplementation.
*/
get_implementation(): VaImplementation;
/**
* Get the VA display handle of the `self`.
* @returns the VA display handle.
*/
get_va_dpy(): any | null;
/**
* If the display is set by the user (foreign) it is assumed that the
* driver is already initialized, thus this function is noop.
*
* If the display is opened internally, this function will initialize
* the driver and it will set driver's message callbacks.
*
* NOTE: this function is supposed to be private, only used by
* GstVaDisplay descendants.
* @returns %TRUE if the VA driver can be initialized; %FALSE otherwise
*/
initialize(): boolean;
}
namespace VaDisplayDrm {
// Constructor properties interface
interface ConstructorProps extends VaDisplay.ConstructorProps {
path: string;
}
}
/**
* This is a #GstVaDisplay subclass to instantiate with DRM devices.
*/
class VaDisplayDrm extends VaDisplay {
static $gtype: GObject.GType<VaDisplayDrm>;
// Properties
get path(): string;
// Constructors
constructor(properties?: Partial<VaDisplayDrm.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static new_from_path(path: string): VaDisplayDrm;
}
namespace VaDisplayWrapped {
// Constructor properties interface
interface ConstructorProps extends VaDisplay.ConstructorProps {}
}
/**
* This is a #GstVaDisplay instantiaton subclass for custom created
* VADisplay, such as X11 or Wayland, wrapping it.
*/
class VaDisplayWrapped extends VaDisplay {
static $gtype: GObject.GType<VaDisplayWrapped>;
// Constructors
constructor(properties?: Partial<VaDisplayWrapped.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](handle?: any | null): VaDisplayWrapped;
}
namespace VaDmabufAllocator {
// Constructor properties interface
interface ConstructorProps extends Gst.Allocator.ConstructorProps {}
}
/**
* A pooled memory allocator backed by the DMABufs exported from a
* VASurfaceID. Also it is possible to import DMAbufs into a
* VASurfaceID.
*/
class VaDmabufAllocator extends Gst.Allocator {
static $gtype: GObject.GType<VaDmabufAllocator>;
// Constructors
constructor(properties?: Partial<VaDmabufAllocator.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](display: VaDisplay): VaDmabufAllocator;
// Static methods
/**
* Removes all the memories in `allocator'`s pool.
* @param allocator a #GstAllocator
*/
static flush(allocator: Gst.Allocator): void;
/**
* Gets current internal configuration of `allocator`.
* @param allocator a #GstAllocator
*/
static get_format(allocator: Gst.Allocator): [boolean, GstVideo.VideoInfoDmaDrm | null, number];
/**
* This method will populate `buffer` with pooled VASurfaceID/DMABuf
* memories. It doesn't allocate new VASurfacesID.
* @param allocator a #GstAllocator
* @param buffer an empty #GstBuffer
*/
static prepare_buffer(allocator: Gst.Allocator, buffer: Gst.Buffer): boolean;
/**
* Sets the configuration defined by `info` and `usage_hint` for
* `allocator,` and it tries the configuration, if `allocator` has not
* allocated memories yet.
*
* If `allocator` has memory allocated already, and frame size, format
* and modifier in `info` are the same as currently configured in
* `allocator,` the rest of `info` parameters are updated internally.
* @param allocator a #GstAllocator
* @param usage_hint VA usage hint
*/
static set_format(allocator: Gst.Allocator, usage_hint: number): [boolean, GstVideo.VideoInfoDmaDrm];
/**
* This function creates a new VASurfaceID and exposes its DMABufs,
* later it populates the `buffer` with those DMABufs.
* @param allocator a #GstAllocator
* @param buffer an empty #GstBuffer
*/
static setup_buffer(allocator: Gst.Allocator, buffer: Gst.Buffer): boolean;
}
namespace VaPool {
// Constructor properties interface
interface ConstructorProps extends Gst.BufferPool.ConstructorProps {}
}
/**
* `GstVaPool` is a buffer pool for VA allocators.
*/
class VaPool extends Gst.BufferPool {
static $gtype: GObject.GType<VaPool>;
// Constructors
constructor(properties?: Partial<VaPool.ConstructorProps>, ...args: any[]);
_init(...args: any[]): void;
static ['new'](): VaPool;
static new_with_config(
caps: Gst.Caps,
min_buffers: number,
max_buffers: number,
usage_hint: number,
use_derived: VaFeature,
allocator: Gst.Allocator,
alloc_params: Gst.AllocationParams,
): VaPool;
// Static methods
/**
* Helper function to retrieve the VA surface size provided by `pool`.
* @param pool a #GstBufferPool
*/
static get_buffer_size(pool: Gst.BufferPool): [boolean, number];
/**
* Retuns: %TRUE if `pool` always add #GstVideoMeta to its
* buffers. Otherwise, %FALSE.
* @param pool the #GstBufferPool
*/
static requires_video_meta(pool: Gst.BufferPool): boolean;
}
type VaDisplayClass = typeof VaDisplay;
type VaDisplayDrmClass = typeof VaDisplayDrm;
type VaDisplayWrappedClass = typeof VaDisplayWrapped;
/**
* 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 GstVa;
}
declare module 'gi://GstVa' {
import GstVa10 from 'gi://GstVa?version=1.0';
export default GstVa10;
}
// END