43 type, size, 1, (
void*)data, &buffer);
44 if (vas != VA_STATUS_SUCCESS) {
46 "buffer (type %d): %d (%s).\n",
47 type, vas, vaErrorStr(vas));
54 "is %#x.\n", type, size, buffer);
61 const void *params_data,
63 const void *slice_data,
89 VASliceParameterBufferType,
90 params_size, 1, (
void*)params_data,
92 if (vas != VA_STATUS_SUCCESS) {
94 "parameter buffer: %d (%s).\n", vas, vaErrorStr(vas));
103 VASliceDataBufferType,
104 slice_size, 1, (
void*)slice_data,
106 if (vas != VA_STATUS_SUCCESS) {
108 "data buffer (size %zu): %d (%s).\n",
109 slice_size, vas, vaErrorStr(vas));
133 if (vas != VA_STATUS_SUCCESS) {
135 "parameter buffer %#x: %d (%s).\n",
140 for (i = 0; i < 2 * pic->
nb_slices; i++) {
143 if (vas != VA_STATUS_SUCCESS) {
145 "slice buffer %#x: %d (%s).\n",
163 if (vas != VA_STATUS_SUCCESS) {
165 "issue: %d (%s).\n", vas, vaErrorStr(vas));
167 goto fail_with_picture;
172 if (vas != VA_STATUS_SUCCESS) {
174 "parameters: %d (%s).\n", vas, vaErrorStr(vas));
176 goto fail_with_picture;
181 if (vas != VA_STATUS_SUCCESS) {
183 "%d (%s).\n", vas, vaErrorStr(vas));
185 goto fail_with_picture;
189 if (vas != VA_STATUS_SUCCESS) {
191 "issue: %d (%s).\n", vas, vaErrorStr(vas));
209 if (vas != VA_STATUS_SUCCESS) {
211 "after error: %d (%s).\n", vas, vaErrorStr(vas));
238 static const struct {
242 #define MAP(va, av) { VA_FOURCC_ ## va, AV_PIX_FMT_ ## av } 249 #ifdef VA_FOURCC_I420 257 #ifdef VA_FOURCC_YV16 261 #ifdef VA_FOURCC_Y210 269 #ifdef VA_FOURCC_P010 272 #ifdef VA_FOURCC_I010 273 MAP(I010, YUV420P10),
280 VAConfigID config_id,
285 VASurfaceAttrib *attr;
287 uint32_t best_fourcc,
fourcc;
293 vas = vaQuerySurfaceAttributes(hwctx->
display, config_id,
295 if (vas != VA_STATUS_SUCCESS) {
297 "%d (%s).\n", vas, vaErrorStr(vas));
305 vas = vaQuerySurfaceAttributes(hwctx->
display, config_id,
307 if (vas != VA_STATUS_SUCCESS) {
309 "%d (%s).\n", vas, vaErrorStr(vas));
316 for (i = 0; i < nb_attr; i++) {
317 if (attr[i].
type != VASurfaceAttribPixelFormat)
320 fourcc = attr[
i].value.value.i;
335 source_format, 0,
NULL);
336 if (format == best_format)
357 .type = VASurfaceAttribPixelFormat,
358 .value.value.i = best_fourcc,
368 static const struct {
374 #define MAP(c, p, v, ...) { AV_CODEC_ID_ ## c, FF_PROFILE_ ## p, VAProfile ## v, __VA_ARGS__ } 375 MAP(MPEG2VIDEO, MPEG2_SIMPLE, MPEG2Simple ),
376 MAP(MPEG2VIDEO, MPEG2_MAIN, MPEG2Main ),
378 MAP(MPEG4, MPEG4_SIMPLE, MPEG4Simple ),
379 MAP(MPEG4, MPEG4_ADVANCED_SIMPLE,
380 MPEG4AdvancedSimple),
381 MAP(MPEG4, MPEG4_MAIN, MPEG4Main ),
382 MAP(H264, H264_CONSTRAINED_BASELINE,
383 H264ConstrainedBaseline),
384 MAP(H264, H264_MAIN, H264Main ),
385 MAP(H264, H264_HIGH, H264High ),
386 #if VA_CHECK_VERSION(0, 37, 0) 387 MAP(HEVC, HEVC_MAIN, HEVCMain ),
388 MAP(HEVC, HEVC_MAIN_10, HEVCMain10 ),
389 MAP(HEVC, HEVC_MAIN_STILL_PICTURE,
392 #if VA_CHECK_VERSION(1, 2, 0) && CONFIG_HEVC_VAAPI_HWACCEL 393 MAP(HEVC, HEVC_REXT, None,
396 MAP(MJPEG, MJPEG_HUFFMAN_BASELINE_DCT,
398 MAP(WMV3, VC1_SIMPLE, VC1Simple ),
399 MAP(WMV3, VC1_MAIN, VC1Main ),
400 MAP(WMV3, VC1_COMPLEX, VC1Advanced ),
401 MAP(WMV3, VC1_ADVANCED, VC1Advanced ),
402 MAP(VC1, VC1_SIMPLE, VC1Simple ),
403 MAP(VC1, VC1_MAIN, VC1Main ),
404 MAP(VC1, VC1_COMPLEX, VC1Advanced ),
405 MAP(VC1, VC1_ADVANCED, VC1Advanced ),
407 #if VA_CHECK_VERSION(0, 38, 0) 408 MAP(VP9, VP9_0, VP9Profile0 ),
410 #if VA_CHECK_VERSION(0, 39, 0) 411 MAP(VP9, VP9_2, VP9Profile2 ),
413 #if VA_CHECK_VERSION(1, 8, 0) 414 MAP(AV1, AV1_MAIN, AV1Profile0),
415 MAP(AV1, AV1_HIGH, AV1Profile1),
427 VAConfigID *va_config,
436 int profile_count, exact_match, matched_ff_profile,
codec_profile;
447 profile_count = vaMaxNumProfiles(hwctx->display);
455 vas = vaQueryConfigProfiles(hwctx->display,
456 profile_list, &profile_count);
457 if (vas != VA_STATUS_SUCCESS) {
459 "%d (%s).\n", vas, vaErrorStr(vas));
464 matched_va_profile = VAProfileNone;
468 int profile_match = 0;
480 for (j = 0; j < profile_count; j++) {
481 if (va_profile == profile_list[j]) {
482 exact_match = profile_match;
486 if (j < profile_count) {
495 if (matched_va_profile == VAProfileNone) {
497 "profile %d.\n", codec_desc->
name, avctx->
profile);
505 "supported for hardware decode.\n",
508 "incompatible profile %d instead.\n",
512 "supported for hardware decode.\n",
519 vas = vaCreateConfig(hwctx->display, matched_va_profile,
520 VAEntrypointVLD,
NULL, 0,
522 if (vas != VA_STATUS_SUCCESS) {
524 "configuration: %d (%s).\n", vas, vaErrorStr(vas));
548 "size %dx%d (constraints: width %d-%d height %d-%d).\n",
558 "usable surface formats.\n");
602 if (*va_config != VA_INVALID_ID) {
603 vaDestroyConfig(hwctx->display, *va_config);
604 *va_config = VA_INVALID_ID;
616 VAConfigID va_config = VA_INVALID_ID;
621 hwctx = device_ctx->hwctx;
628 if (va_config != VA_INVALID_ID)
629 vaDestroyConfig(hwctx->display, va_config);
643 #if FF_API_STRUCT_VAAPI_CONTEXT 646 "vaapi_context in decode.\n");
673 #if FF_API_STRUCT_VAAPI_CONTEXT 703 if (vas != VA_STATUS_SUCCESS) {
705 "context: %d (%s).\n", vas, vaErrorStr(vas));
712 #if FF_API_STRUCT_VAAPI_CONTEXT 728 #if FF_API_STRUCT_VAAPI_CONTEXT 736 if (vas != VA_STATUS_SUCCESS) {
738 "context %#x: %d (%s).\n",
744 if (vas != VA_STATUS_SUCCESS) {
746 "configuration %#x: %d (%s).\n",
751 #if FF_API_STRUCT_VAAPI_CONTEXT
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
VAAPI-specific data associated with a frame pool.
ptrdiff_t const GLvoid * data
int coded_width
Bitstream width / height, may be different from width/height e.g.
VAProfile(* profile_parser)(AVCodecContext *avctx)
#define AV_LOG_WARNING
Something somehow does not look correct.
VASurfaceAttrib * attributes
Set by the user to apply surface attributes to all surfaces in the frame pool.
static void ff_vaapi_decode_destroy_buffers(AVCodecContext *avctx, VAAPIDecodePicture *pic)
int ff_vaapi_decode_make_param_buffer(AVCodecContext *avctx, VAAPIDecodePicture *pic, int type, const void *data, size_t size)
static const struct @150 vaapi_format_map[]
VASurfaceAttrib pixel_format_attribute
enum AVPixelFormat pix_fmt
uint32_t context_id
Context ID (video decode pipeline)
FF_ENABLE_DEPRECATION_WARNINGS AVHWDeviceContext * device
int width
The allocated dimensions of the frames in this pool.
void * av_hwdevice_hwconfig_alloc(AVBufferRef *ref)
Allocate a HW-specific configuration structure for a given HW device.
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
#define FF_ARRAY_ELEMS(a)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate.The lists are not just lists
if it could not because there are no more frames
int max_width
The maximum size of frames in this hw_frames_ctx.
int ff_vaapi_common_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
void av_hwframe_constraints_free(AVHWFramesConstraints **constraints)
Free an AVHWFrameConstraints structure.
static int vaapi_decode_find_best_format(AVCodecContext *avctx, AVHWDeviceContext *device, VAConfigID config_id, AVHWFramesContext *frames)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int ff_vaapi_decode_uninit(AVCodecContext *avctx)
void * hwaccel_context
Hardware accelerator context.
int ff_vaapi_decode_issue(AVCodecContext *avctx, VAAPIDecodePicture *pic)
AVHWFramesContext * frames
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
AVVAAPIDeviceContext * hwctx
#define AV_LOG_VERBOSE
Detailed information.
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
AVCodecID
Identify the syntax and semantics of the bitstream.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
AVVAAPIFramesContext * hwfc
VAAPI hardware pipeline configuration details.
static const struct @151 vaapi_profile_map[]
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
simple assert() macros that are a bit more flexible than ISO C assert().
FF_DISABLE_DEPRECATION_WARNINGS int have_old_context
int initial_pool_size
Initial size of the frame pool.
AVHWDeviceContext * device_ctx
The parent AVHWDeviceContext.
int ff_vaapi_decode_init(AVCodecContext *avctx)
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
#define FF_PROFILE_UNKNOWN
VABufferID * slice_buffers
struct vaapi_context * old_context
VABufferID param_buffers[MAX_PARAM_BUFFERS]
VAProfile ff_vaapi_parse_hevc_rext_profile(AVCodecContext *avctx)
VADisplay display
The VADisplay handle, to be filled by the user.
VASurfaceID output_surface
void * display
Window system dependent data.
int min_width
The minimum size of frames in this hw_frames_ctx.
AVBufferRef * av_hwdevice_ctx_alloc(enum AVHWDeviceType type)
Allocate an AVHWDeviceContext for a given hardware type.
Libavcodec external API header.
This struct describes the constraints on hardware frames attached to a given device with a hardware-s...
main external API structure.
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...
uint8_t * data
The data buffer.
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
unsigned int driver_quirks
Driver quirks to apply - this is filled by av_hwdevice_ctx_init(), with reference to a table of known...
This struct describes a set or pool of "hardware" frames (i.e.
The driver does not destroy parameter buffers when they are used by vaRenderPicture().
const char * name
Name of the codec described by this descriptor.
int ff_vaapi_decode_cancel(AVCodecContext *avctx, VAAPIDecodePicture *pic)
This struct describes the properties of a single codec described by an AVCodecID. ...
int ff_decode_get_hw_frames_ctx(AVCodecContext *avctx, enum AVHWDeviceType dev_type)
Make sure avctx.hw_frames_ctx is set.
AVBufferRef * device_ref
A reference to the parent AVHWDeviceContext.
A reference to a data buffer.
common internal api header.
common internal and external API header
void * hwaccel_priv_data
hwaccel-specific private data
enum AVPixelFormat av_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2, enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr)
Compute what kind of losses will occur when converting from one specific pixel format to another...
struct AVCodecInternal * internal
Private context used for internal data.
enum AVPixelFormat * valid_sw_formats
A list of possible values for sw_format in the hw_frames_ctx, terminated by AV_PIX_FMT_NONE.
VAAPI connection details.
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
VAConfigID config_id
ID of a VAAPI pipeline configuration.
static int vaapi_decode_make_config(AVCodecContext *avctx, AVBufferRef *device_ref, VAConfigID *va_config, AVBufferRef *frames_ref)
VASurfaceID * surface_ids
The surfaces IDs of all surfaces in the pool after creation.
#define AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH
Hardware acceleration should still be attempted for decoding when the codec profile does not match th...
int hwaccel_flags
Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated decoding (if active)...
#define av_malloc_array(a, b)
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.
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
AVPixelFormat
Pixel format.
int ff_vaapi_decode_make_slice_buffer(AVCodecContext *avctx, VAAPIDecodePicture *pic, const void *params_data, size_t params_size, const void *slice_data, size_t slice_size)
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
uint32_t config_id
Configuration ID.