56 #if CONFIG_VIDEOTOOLBOX
262 if (hw_type->frames_priv_size) {
268 if (hw_type->frames_hwctx_size) {
285 ctx->device_ref = device_ref;
286 ctx->device_ctx = device_ctx;
315 for (
i = 0;
i <
ctx->initial_pool_size;
i++) {
326 for (
i = 0;
i <
ctx->initial_pool_size;
i++)
351 "The hardware pixel format '%s' is not supported by the device type '%s'\n",
372 if (
ctx->initial_pool_size > 0) {
410 frame_tmp->format = dst->
format;
419 frame_tmp->format =
formats[0];
422 frame_tmp->width =
ctx->width;
423 frame_tmp->height =
ctx->height;
433 frame_tmp->width =
src->width;
434 frame_tmp->height =
src->height;
465 "A device with a derived frame context cannot be used as "
466 "the source of a HW -> HW transfer.");
470 if (dst_ctx->internal->source_frames) {
472 "A device with a derived frame context cannot be used as "
473 "the destination of a HW -> HW transfer.");
479 ret = dst_ctx->internal->hw_type->transfer_data_to(dst_ctx, dst,
src);
483 if (
src->hw_frames_ctx) {
532 "frame context: %d.\n", ret);
570 if (hw_type->device_hwconfig_size == 0)
573 return av_mallocz(hw_type->device_hwconfig_size);
577 const void *hwconfig)
583 if (!hw_type->frames_get_constraints)
586 constraints =
av_mallocz(
sizeof(*constraints));
590 constraints->min_width = constraints->min_height = 0;
591 constraints->max_width = constraints->max_height = INT_MAX;
593 if (hw_type->frames_get_constraints(
ctx, hwconfig, constraints) >= 0) {
604 av_freep(&(*constraints)->valid_hw_formats);
605 av_freep(&(*constraints)->valid_sw_formats);
638 *pdevice_ref = device_ref;
705 *dst_ref_ptr = dst_ref;
768 hwmap->
unmap = unmap;
799 if ((src_frames == dst_frames &&
811 "found when attempting unmap.\n");
820 if (
src->hw_frames_ctx) {
858 if (
src->internal->source_frames) {
869 if (!*derived_frame_ctx) {
903 if (
src->internal->hw_type->frames_derive_from)
904 ret =
src->internal->hw_type->frames_derive_from(dst,
src,
flags);
913 *derived_frame_ctx = dst_ref;
static const char *const format[]
refcounted data buffer API
#define flags(name, subs,...)
common internal and external API header
static enum AVPixelFormat pix_fmt
const OptionDef options[]
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
AVBufferRef * av_buffer_create(uint8_t *data, buffer_size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
#define AV_BUFFER_FLAG_READONLY
Always treat the buffer as read-only, even when it has only one reference.
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const char * av_default_item_name(void *ptr)
Return the context name.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
#define LIBAVUTIL_VERSION_INT
enum AVHWDeviceType av_hwdevice_iterate_types(enum AVHWDeviceType prev)
Iterate over supported device types.
int av_hwdevice_ctx_init(AVBufferRef *ref)
Finalize the device context before use.
AVBufferRef * av_hwdevice_ctx_alloc(enum AVHWDeviceType type)
Allocate an AVHWDeviceContext for a given hardware type.
static void ff_hwframe_unmap(void *opaque, uint8_t *data)
int av_hwdevice_ctx_create(AVBufferRef **pdevice_ref, enum AVHWDeviceType type, const char *device, AVDictionary *opts, int flags)
Open a device of the specified type and create an AVHWDeviceContext for it.
int av_hwframe_transfer_get_formats(AVBufferRef *hwframe_ref, enum AVHWFrameTransferDirection dir, enum AVPixelFormat **formats, int flags)
Get a list of possible source or target formats usable in av_hwframe_transfer_data().
static int hwframe_pool_prealloc(AVBufferRef *ref)
void av_hwframe_constraints_free(AVHWFramesConstraints **constraints)
Free an AVHWFrameConstraints structure.
static const char *const hw_type_names[]
int av_hwdevice_ctx_create_derived(AVBufferRef **dst_ref_ptr, enum AVHWDeviceType type, AVBufferRef *src_ref, int flags)
Create a new device of the specified type from an existing device.
int av_hwframe_ctx_create_derived(AVBufferRef **derived_frame_ctx, enum AVPixelFormat format, AVBufferRef *derived_device_ctx, AVBufferRef *source_frame_ctx, int flags)
Create and initialise an AVHWFramesContext as a mapping of another existing AVHWFramesContext on a di...
enum AVHWDeviceType av_hwdevice_find_type_by_name(const char *name)
Look up an AVHWDeviceType by name.
static const HWContextType *const hw_table[]
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
static const AVClass hwframe_ctx_class
static void hwframe_ctx_free(void *opaque, uint8_t *data)
int ff_hwframe_map_create(AVBufferRef *hwframe_ref, AVFrame *dst, const AVFrame *src, void(*unmap)(AVHWFramesContext *ctx, HWMapDescriptor *hwmap), void *priv)
static void hwdevice_ctx_free(void *opaque, uint8_t *data)
AVHWFramesConstraints * av_hwdevice_get_hwframe_constraints(AVBufferRef *ref, const void *hwconfig)
Get the constraints on HW frames given a device and the HW-specific configuration to be used with tha...
static int transfer_data_alloc(AVFrame *dst, const AVFrame *src, int flags)
int av_hwframe_map(AVFrame *dst, const AVFrame *src, int flags)
Map a hardware frame.
static const AVClass hwdevice_ctx_class
void * av_hwdevice_hwconfig_alloc(AVBufferRef *ref)
Allocate a HW-specific configuration structure for a given HW device.
int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags)
Copy data to or from a hw surface.
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
int av_hwframe_get_buffer(AVBufferRef *hwframe_ref, AVFrame *frame, int flags)
Allocate a new frame attached to the given AVHWFramesContext.
int av_hwdevice_ctx_create_derived_opts(AVBufferRef **dst_ref_ptr, enum AVHWDeviceType type, AVBufferRef *src_ref, AVDictionary *options, int flags)
Create a new device of the specified type from an existing device.
int ff_hwframe_map_replace(AVFrame *dst, const AVFrame *src)
Replace the current hwmap of dst with the one from src, used for indirect mappings like VAAPI->(DRM)-...
const char * av_hwdevice_get_type_name(enum AVHWDeviceType type)
Get the string name of an AVHWDeviceType.
AVHWFrameTransferDirection
@ AV_HWFRAME_TRANSFER_DIRECTION_FROM
Transfer the data from the queried hw frame.
@ AV_HWDEVICE_TYPE_D3D11VA
@ AV_HWDEVICE_TYPE_OPENCL
@ AV_HWDEVICE_TYPE_VULKAN
@ AV_HWDEVICE_TYPE_MEDIACODEC
@ AV_HWDEVICE_TYPE_VIDEOTOOLBOX
@ AV_HWFRAME_MAP_READ
The mapping must be readable.
@ AV_HWFRAME_MAP_DIRECT
The mapping must be direct.
@ AV_HWFRAME_MAP_WRITE
The mapping must be writeable.
@ AV_HWFRAME_MAP_OVERWRITE
The mapped frame will be overwritten completely in subsequent operations, so the current frame data n...
const HWContextType ff_hwcontext_type_cuda
const HWContextType ff_hwcontext_type_d3d11va
const HWContextType ff_hwcontext_type_drm
const HWContextType ff_hwcontext_type_dxva2
const HWContextType ff_hwcontext_type_opencl
const HWContextType ff_hwcontext_type_vaapi
const HWContextType ff_hwcontext_type_vdpau
const HWContextType ff_hwcontext_type_qsv
const HWContextType ff_hwcontext_type_videotoolbox
const HWContextType ff_hwcontext_type_vulkan
const HWContextType ff_hwcontext_type_mediacodec
Memory handling functions.
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
AVPixelFormat
Pixel format.
#define FF_ARRAY_ELEMS(a)
A reference to a data buffer.
uint8_t * data
The data buffer.
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
const AVClass * av_class
A class for logging and AVOptions.
AVFormatInternal * internal
An opaque field for libavformat internal usage.
This structure describes decoded (raw) audio or video data.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame.
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
uint8_t ** extended_data
pointers to the data planes/channels.
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
AVHWDeviceInternal * internal
Private data used internally by libavutil.
enum AVHWDeviceType type
This field identifies the underlying API used for hardware access.
const HWContextType * hw_type
AVBufferRef * source_device
For a derived device, a reference to the original device context it was derived from.
This struct describes the constraints on hardware frames attached to a given device with a hardware-s...
This struct describes a set or pool of "hardware" frames (i.e.
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
AVHWFramesInternal * internal
Private data used internally by libavutil.
int width
The allocated dimensions of the frames in this pool.
AVHWDeviceContext * device_ctx
The parent AVHWDeviceContext.
AVBufferRef * source_frames
For a derived context, a reference to the original frames context it was derived from.
const HWContextType * hw_type
int source_allocation_map_flags
Flags to apply to the mapping from the source to the derived frame context when trying to allocate in...
int(* transfer_data_from)(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src)
int(* map_from)(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src, int flags)
int(* device_create)(AVHWDeviceContext *ctx, const char *device, AVDictionary *opts, int flags)
size_t device_priv_size
size of the private data, i.e.
int(* map_to)(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src, int flags)
size_t device_hwctx_size
size of the public hardware-specific context, i.e.
int(* frames_derive_to)(AVHWFramesContext *dst_ctx, AVHWFramesContext *src_ctx, int flags)
int(* device_derive)(AVHWDeviceContext *dst_ctx, AVHWDeviceContext *src_ctx, AVDictionary *opts, int flags)
void * priv
Hardware-specific private data associated with the mapping.
void(* unmap)(AVHWFramesContext *ctx, struct HWMapDescriptor *hwmap)
Unmap function.
AVFrame * source
A reference to the original source of the mapping.
AVBufferRef * hw_frames_ctx
A reference to the hardware frames context in which this mapping was made.
static int ref[MAX_W *MAX_W]
static void set(uint8_t *a[], int ch, int index, int ch_count, enum AVSampleFormat f, double v)