77 int index, index_limit = 1000;
78 index_pos = strlen(type_name);
87 if (
index >= index_limit) {
109 const char *errmsg, *p, *q;
112 k = strcspn(
arg,
":=@");
122 errmsg =
"unknown device type";
127 k = strcspn(p + 1,
":@");
135 errmsg =
"named device already exists";
155 }
else if (*p ==
':') {
169 errmsg =
"failed to parse options";
175 q ? device : p[0] ? p :
NULL,
180 }
else if (*p ==
'@') {
185 errmsg =
"invalid source device name";
194 errmsg =
"parse error";
221 "Invalid device specification \"%s\": %s\n",
arg, errmsg);
226 "Device creation failed: %d.\n", err);
249 "Device creation failed: %d.\n", err);
308 int err, auto_device = 0;
329 "specified for decoder: device %s of type %s is not "
330 "usable with hwaccel %s.\n", dev->
name,
360 for (
i = 0; !dev;
i++) {
368 "hwaccel type %s with existing device %s.\n",
372 for (
i = 0; !dev;
i++) {
386 "hwaccel type %s with new device created "
391 "hwaccel type %s with new default device.\n",
399 "disabled: no device found.\n");
407 "for decoder: device type %s needed for codec %s.\n",
430 ost->enc_ctx->pix_fmt) {
447 "frames context (format %s) with %s encoder.\n",
451 if (!
ost->enc_ctx->hw_frames_ctx)
463 "(type %s) with %s encoder.\n", dev->
name,
466 if (!
ost->enc_ctx->hw_device_ctx)
481 if (input->
format == output_format) {
490 output->
format = output_format;
495 "output frame: %d.\n", err);
memory buffer sink API for audio and video
HWDevice * filter_hw_device
const OptionDef options[]
int hw_device_setup_for_encode(OutputStream *ost)
static HWDevice ** hw_devices
static HWDevice * hw_device_add(void)
static char * hw_device_default_name(enum AVHWDeviceType type)
int hw_device_init_from_string(const char *arg, HWDevice **dev_out)
int hwaccel_decode_init(AVCodecContext *avctx)
static int hwaccel_retrieve_data(AVCodecContext *avctx, AVFrame *input)
int hw_device_setup_for_decode(InputStream *ist)
void hw_device_free_all(void)
int hw_device_setup_for_filter(FilterGraph *fg)
static int hw_device_init_from_type(enum AVHWDeviceType type, const char *device, HWDevice **dev_out)
HWDevice * hw_device_get_by_name(const char *name)
static HWDevice * hw_device_get_by_type(enum AVHWDeviceType type)
static HWDevice * hw_device_match_by_codec(const AVCodec *codec)
const AVCodecHWConfig * avcodec_get_hw_config(const AVCodec *codec, int index)
Retrieve supported hardware configurations for a codec.
@ AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX
The codec supports this format via the hw_frames_ctx interface.
@ AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX
The codec supports this format via the hw_device_ctx interface.
AVBufferRef * av_buffersink_get_hw_frames_ctx(const AVFilterContext *ctx)
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_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
int av_dict_parse_string(AVDictionary **pm, const char *str, const char *key_val_sep, const char *pairs_sep, int flags)
Parse the key/value pairs list and add the parsed entries to a dictionary.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define AV_LOG_VERBOSE
Detailed information.
#define AV_LOG_INFO
Standard information.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
char * av_strndup(const char *s, size_t len)
Duplicate a substring of a string.
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_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.
enum AVHWDeviceType av_hwdevice_find_type_by_name(const char *name)
Look up an AVHWDeviceType by name.
int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags)
Copy data to or from a hw surface.
const char * av_hwdevice_get_type_name(enum AVHWDeviceType type)
Get the string name of an AVHWDeviceType.
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.
A reference to a data buffer.
uint8_t * data
The data buffer.
main external API structure.
void * opaque
Private data of the user, can be used to carry app specific stuff.
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
enum AVHWDeviceType device_type
The device type associated with the configuration.
int methods
Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible setup methods which can be used...
enum AVPixelFormat pix_fmt
For decoders, a hardware pixel format which that decoder may be able to decode to if suitable hardwar...
const char * name
Name of the codec implementation.
AVBufferRef * hw_device_ctx
For filters which will create hardware frames, sets the device the filter should create them in.
AVFilterContext ** filters
This structure describes decoded (raw) audio or video data.
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
This struct describes a set or pool of "hardware" frames (i.e.