39 int type,
char *
data,
size_t bit_len)
43 VABufferID param_buffer, data_buffer;
45 VAEncPackedHeaderParameterBuffer params = {
47 .bit_length = bit_len,
48 .has_emulation_bytes = 1,
57 VAEncPackedHeaderParameterBufferType,
58 sizeof(params), 1, ¶ms, ¶m_buffer);
59 if (vas != VA_STATUS_SUCCESS) {
61 "for packed header (type %d): %d (%s).\n",
62 type, vas, vaErrorStr(vas));
68 VAEncPackedHeaderDataBufferType,
69 (bit_len + 7) / 8, 1, data, &data_buffer);
70 if (vas != VA_STATUS_SUCCESS) {
72 "for packed header (type %d): %d (%s).\n",
73 type, vas, vaErrorStr(vas));
79 "(%zu bits).\n", type, param_buffer, data_buffer, bit_len);
98 type, len, 1, data, &buffer);
99 if (vas != VA_STATUS_SUCCESS) {
101 "(type %d): %d (%s).\n", type, vas, vaErrorStr(vas));
120 VAEncMiscParameterBuffer
header = {
123 size_t buffer_size =
sizeof(
header) + len;
126 memcpy(buffer, &header,
sizeof(header));
127 memcpy(buffer +
sizeof(header), data, len);
130 VAEncMiscParameterBufferType,
131 buffer, buffer_size);
152 if (vas != VA_STATUS_SUCCESS) {
154 "%d (%s).\n", vas, vaErrorStr(vas));
183 for (i = 0; i < pic->
nb_refs; i++) {
191 for (i = 0; i < pic->
nb_refs; i++) {
235 VAEncSequenceParameterBufferType,
257 "parameters: %d.\n", err);
261 VAEncPictureParameterBufferType,
271 bit_len = 8 *
sizeof(
data);
275 "header: %d.\n", err);
288 bit_len = 8 *
sizeof(
data);
292 "header: %d.\n", err);
312 "buffer %d: %d.\n", i, err);
327 bit_len = 8 *
sizeof(
data);
334 "header %d: %d.\n", i, err);
367 for (i = 0; i < rounding; i++)
370 for (i = 0; i < (rounding + 1) / 2; i++)
372 for (i = 0; i < rounding / 2; i++)
375 }
else if (rounding < 0) {
395 "%d-%d (%d blocks).\n", i, slice->
row_start,
412 "parameters: %d.\n", err);
419 bit_len = 8 *
sizeof(
data);
424 "header: %d.\n", err);
436 VAEncSliceParameterBufferType,
444 #if VA_CHECK_VERSION(1, 0, 0) 450 VAEncMiscParameterBufferROI param_roi;
455 av_assert0(roi_size && sd->size % roi_size == 0);
456 nb_roi = sd->size / roi_size;
460 "supported by driver (%d > %d).\n",
473 for (i = 0; i < nb_roi; i++) {
481 pic->
roi[
i] = (VAEncROI) {
488 .roi_value = av_clip_int8(v),
492 param_roi = (VAEncMiscParameterBufferROI) {
494 .max_delta_qp = INT8_MAX,
495 .min_delta_qp = INT8_MIN,
497 .roi_flags.bits.roi_value_is_qp_delta = 1,
501 VAEncMiscParameterTypeROI,
511 if (vas != VA_STATUS_SUCCESS) {
513 "%d (%s).\n", vas, vaErrorStr(vas));
515 goto fail_with_picture;
520 if (vas != VA_STATUS_SUCCESS) {
522 "%d (%s).\n", vas, vaErrorStr(vas));
524 goto fail_with_picture;
528 if (vas != VA_STATUS_SUCCESS) {
530 "%d (%s).\n", vas, vaErrorStr(vas));
546 if (vas != VA_STATUS_SUCCESS) {
548 "param buffer %#x: %d (%s).\n",
585 VACodedBufferSegment *buf_list, *buf;
598 if (vas != VA_STATUS_SUCCESS) {
600 "%d (%s).\n", vas, vaErrorStr(vas));
605 for (buf = buf_list; buf; buf = buf->next)
606 total_size += buf->size;
614 for (buf = buf_list; buf; buf = buf->next) {
616 "(status %08x).\n", buf->size, buf->status);
618 memcpy(ptr, buf->buf, buf->size);
628 if (vas != VA_STATUS_SUCCESS) {
630 "%d (%s).\n", vas, vaErrorStr(vas));
657 "%"PRId64
"/%"PRId64
".\n",
727 int is_ref,
int in_dpb,
int prev)
763 for (i = 0; i < pic->
nb_refs; i++) {
801 for (pic = start->
next; pic; pic = pic->
next) {
811 for (ref = end->
refs[1]; ref; ref = ref->
refs[1])
820 for (pic = start->
next; pic != end; pic = pic->
next)
822 for (pic = start->
next, i = 1; 2 * i < len; pic = pic->next, i++);
834 for (ref = end->
refs[1]; ref; ref = ref->
refs[1])
839 current_depth + 1, &next);
844 current_depth + 1, last);
853 int i, b_counter, closed_gop_end;
863 for (i = 0; i < pic->
nb_refs; i++) {
873 "encode next.\n", pic->
b_depth);
884 for (pic = ctx->
pic_start; pic; pic = next) {
902 if (next && next->force_idr)
917 "need more input for reference pictures.\n");
922 "need more input for timestamps.\n");
1003 for (pic = ctx->
pic_start; pic; pic = next) {
1028 "frames ignored due to lack of API support.\n");
1038 "frames ignored due to lack of driver support.\n");
1150 pkt->
dts = INT64_MIN;
1191 {
"YUV400", VA_RT_FORMAT_YUV400, 8, 1, },
1192 {
"YUV420", VA_RT_FORMAT_YUV420, 8, 3, 1, 1 },
1193 {
"YUV422", VA_RT_FORMAT_YUV422, 8, 3, 1, 0 },
1194 {
"YUV444", VA_RT_FORMAT_YUV444, 8, 3, 0, 0 },
1195 {
"YUV411", VA_RT_FORMAT_YUV411, 8, 3, 2, 0 },
1196 #if VA_CHECK_VERSION(0, 38, 1) 1197 {
"YUV420_10", VA_RT_FORMAT_YUV420_10BPP, 10, 3, 1, 1 },
1202 VAEntrypointEncSlice,
1203 VAEntrypointEncPicture,
1204 #if VA_CHECK_VERSION(0, 39, 2) 1205 VAEntrypointEncSliceLP,
1209 #if VA_CHECK_VERSION(0, 39, 2) 1210 static const VAEntrypoint vaapi_encode_entrypoints_low_power[] = {
1211 VAEntrypointEncSliceLP,
1219 VAProfile *va_profiles =
NULL;
1220 VAEntrypoint *va_entrypoints =
NULL;
1222 const VAEntrypoint *usable_entrypoints;
1225 VAConfigAttrib rt_format_attr;
1227 const char *profile_string, *entrypoint_string;
1232 #if VA_CHECK_VERSION(0, 39, 2) 1233 usable_entrypoints = vaapi_encode_entrypoints_low_power;
1236 "supported with this VAAPI version.\n");
1266 vas = vaQueryConfigProfiles(ctx->
hwctx->
display, va_profiles, &n);
1267 if (vas != VA_STATUS_SUCCESS) {
1269 vas, vaErrorStr(vas));
1278 if (depth != profile->
depth ||
1289 #if VA_CHECK_VERSION(1, 0, 0) 1290 profile_string = vaProfileStr(profile->
va_profile);
1292 profile_string =
"(no profile names)";
1295 for (j = 0; j < n; j++) {
1301 "is not supported by driver.\n", profile_string,
1322 if (!va_entrypoints) {
1327 va_entrypoints, &n);
1328 if (vas != VA_STATUS_SUCCESS) {
1330 "profile %s (%d): %d (%s).\n", profile_string,
1336 for (i = 0; i < n; i++) {
1337 for (j = 0; usable_entrypoints[j]; j++) {
1338 if (va_entrypoints[i] == usable_entrypoints[j])
1341 if (usable_entrypoints[j])
1346 "for profile %s (%d).\n", profile_string, ctx->
va_profile);
1352 #if VA_CHECK_VERSION(1, 0, 0) 1355 entrypoint_string =
"(no entrypoint names)";
1361 rt_format = &vaapi_encode_rt_formats[
i];
1362 if (rt_format->
depth == depth &&
1370 "found for profile %s (%d) entrypoint %s (%d).\n",
1377 rt_format_attr = (VAConfigAttrib) { VAConfigAttribRTFormat };
1380 &rt_format_attr, 1);
1381 if (vas != VA_STATUS_SUCCESS) {
1383 "config attribute: %d (%s).\n", vas, vaErrorStr(vas));
1388 if (rt_format_attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1390 "supported by driver: assuming surface RT format %s " 1391 "is valid.\n", rt_format->
name);
1392 }
else if (!(rt_format_attr.value & rt_format->
value)) {
1394 "by driver for encoding profile %s (%d) entrypoint %s (%d).\n",
1401 "format %s (%#x).\n", rt_format->
name, rt_format->
value);
1404 .type = VAConfigAttribRTFormat,
1405 .value = rt_format->
value,
1423 #if VA_CHECK_VERSION(1, 1, 0) 1428 #if VA_CHECK_VERSION(1, 3, 0) 1440 uint32_t supported_va_rc_modes;
1442 int64_t rc_bits_per_second;
1443 int rc_target_percentage;
1446 int64_t hrd_buffer_size;
1447 int64_t hrd_initial_buffer_fullness;
1449 VAConfigAttrib rc_attr = { VAConfigAttribRateControl };
1451 char supported_rc_modes_string[64];
1456 if (vas != VA_STATUS_SUCCESS) {
1458 "config attribute: %d (%s).\n", vas, vaErrorStr(vas));
1461 if (rc_attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1463 "supported rate control modes: assuming CQP only.\n");
1464 supported_va_rc_modes = VA_RC_CQP;
1465 strcpy(supported_rc_modes_string,
"unknown");
1467 char *
str = supported_rc_modes_string;
1468 size_t len =
sizeof(supported_rc_modes_string);
1469 int i, first = 1, res;
1471 supported_va_rc_modes = rc_attr.value;
1473 rc_mode = &vaapi_encode_rc_modes[
i];
1474 if (supported_va_rc_modes & rc_mode->
va_mode) {
1476 first ?
"" :
", ", rc_mode->
name);
1490 supported_rc_modes_string);
1505 #define TRY_RC_MODE(mode, fail) do { \ 1506 rc_mode = &vaapi_encode_rc_modes[mode]; \ 1507 if (!(rc_mode->va_mode & supported_va_rc_modes)) { \ 1509 av_log(avctx, AV_LOG_ERROR, "Driver does not support %s " \ 1510 "RC mode (supported modes: %s).\n", rc_mode->name, \ 1511 supported_rc_modes_string); \ 1512 return AVERROR(EINVAL); \ 1514 av_log(avctx, AV_LOG_DEBUG, "Driver does not support %s " \ 1515 "RC mode.\n", rc_mode->name); \ 1518 goto rc_mode_found; \ 1555 "RC mode compatible with selected options " 1556 "(supported modes: %s).\n", supported_rc_modes_string);
1563 "RC mode.\n", rc_mode->
name);
1573 rc_bits_per_second = avctx->
bit_rate;
1579 rc_target_percentage = 100;
1586 }
else if (rc_mode->
maxrate) {
1590 "bitrate (%"PRId64
") must not be greater than " 1591 "maxrate (%"PRId64
").\n", avctx->
bit_rate,
1596 rc_target_percentage = (avctx->
bit_rate * 100) /
1603 rc_bits_per_second = 2 * avctx->
bit_rate;
1604 rc_target_percentage = 50;
1609 "in %s RC mode.\n", rc_mode->
name);
1611 rc_bits_per_second = avctx->
bit_rate;
1612 rc_target_percentage = 100;
1615 rc_bits_per_second = 0;
1616 rc_target_percentage = 100;
1627 "using default (%d).\n", rc_quality);
1643 "must have initial buffer size (%d) <= " 1644 "buffer size (%"PRId64
").\n",
1650 hrd_initial_buffer_fullness = hrd_buffer_size * 3 / 4;
1653 rc_window_size = (hrd_buffer_size * 1000) / rc_bits_per_second;
1657 "in %s RC mode.\n", rc_mode->
name);
1660 hrd_buffer_size = 0;
1661 hrd_initial_buffer_fullness = 0;
1665 rc_window_size = 1000;
1669 if (rc_bits_per_second > UINT32_MAX ||
1670 hrd_buffer_size > UINT32_MAX ||
1671 hrd_initial_buffer_fullness > UINT32_MAX) {
1673 "greater are not supported by VAAPI.\n");
1683 if (rc_attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1688 .type = VAConfigAttribRateControl,
1696 if (rc_mode->
va_mode != VA_RC_CQP) {
1699 "converging in %d frames with %d%% accuracy.\n",
1700 rc_bits_per_second, rc_window_size,
1701 rc_target_percentage);
1702 }
else if (rc_mode->
bitrate) {
1704 "%"PRId64
" bps over %d ms.\n", rc_target_percentage,
1705 rc_bits_per_second, rc_window_size);
1708 ctx->
rc_params = (VAEncMiscParameterRateControl) {
1709 .bits_per_second = rc_bits_per_second,
1710 .target_percentage = rc_target_percentage,
1711 .window_size = rc_window_size,
1713 .min_qp = (avctx->
qmin > 0 ? avctx->
qmin : 0),
1714 .basic_unit_size = 0,
1715 #
if VA_CHECK_VERSION(1, 1, 0)
1716 .ICQ_quality_factor = av_clip(rc_quality, 1, 51),
1717 .max_qp = (avctx->
qmax > 0 ? avctx->
qmax : 0),
1719 #
if VA_CHECK_VERSION(1, 3, 0)
1720 .quality_factor = rc_quality,
1724 VAEncMiscParameterTypeRateControl,
1731 "initial fullness %"PRId64
" bits.\n",
1732 hrd_buffer_size, hrd_initial_buffer_fullness);
1735 .initial_buffer_fullness = hrd_initial_buffer_fullness,
1736 .buffer_size = hrd_buffer_size,
1739 VAEncMiscParameterTypeHRD,
1752 fr_num, fr_den, (
double)fr_num / fr_den);
1754 ctx->
fr_params = (VAEncMiscParameterFrameRate) {
1755 .framerate = (
unsigned int)fr_den << 16 | fr_num,
1757 #if VA_CHECK_VERSION(0, 40, 0) 1759 VAEncMiscParameterTypeFrameRate,
1771 VAConfigAttrib attr = { VAConfigAttribEncMaxRefFrames };
1772 uint32_t ref_l0, ref_l1;
1778 if (vas != VA_STATUS_SUCCESS) {
1780 "attribute: %d (%s).\n", vas, vaErrorStr(vas));
1784 if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1785 ref_l0 = ref_l1 = 0;
1787 ref_l0 = attr.value & 0xffff;
1788 ref_l1 = attr.value >> 16 & 0xffff;
1795 }
else if (ref_l0 < 1) {
1797 "reference frames.\n");
1800 ref_l1 < 1 || avctx->max_b_frames < 1) {
1802 "(supported references: %d / %d).\n", ref_l0, ref_l1);
1808 "(supported references: %d / %d).\n", ref_l0, ref_l1);
1834 VAConfigAttrib attr[2] = { { VAConfigAttribEncMaxSlices },
1835 { VAConfigAttribEncSliceStructure } };
1837 uint32_t max_slices, slice_structure;
1843 "but this codec does not support controlling slices.\n");
1853 if (avctx->
slices <= 1) {
1863 if (vas != VA_STATUS_SUCCESS) {
1865 "attributes: %d (%s).\n", vas, vaErrorStr(vas));
1868 max_slices = attr[0].value;
1869 slice_structure = attr[1].value;
1870 if (max_slices == VA_ATTRIB_NOT_SUPPORTED ||
1871 slice_structure == VA_ATTRIB_NOT_SUPPORTED) {
1873 "pictures as multiple slices.\n.");
1884 "configured number of slices (%d < %d); using " 1888 req_slices = avctx->
slices;
1890 if (slice_structure & VA_ENC_SLICE_STRUCTURE_ARBITRARY_ROWS ||
1891 slice_structure & VA_ENC_SLICE_STRUCTURE_ARBITRARY_MACROBLOCKS) {
1894 }
else if (slice_structure & VA_ENC_SLICE_STRUCTURE_POWER_OF_TWO_ROWS) {
1896 for (k = 1;; k *= 2) {
1902 #if VA_CHECK_VERSION(1, 0, 0) 1903 }
else if (slice_structure & VA_ENC_SLICE_STRUCTURE_EQUAL_ROWS) {
1909 "slice structure modes (%#x).\n", slice_structure);
1915 "%d (from %d) due to driver constraints on slice " 1920 "encoding with %d slices (max %"PRIu32
").\n",
1926 "(default size %d block rows).\n",
1935 VAConfigAttrib attr = { VAConfigAttribEncPackedHeaders };
1941 if (vas != VA_STATUS_SUCCESS) {
1943 "attribute: %d (%s).\n", vas, vaErrorStr(vas));
1947 if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1950 "packed headers (wanted %#x).\n",
1954 "packed headers (none wanted).\n");
1960 "wanted packed headers (wanted %#x, found %#x).\n",
1964 "available (wanted %#x, found %#x).\n",
1973 .type = VAConfigAttribEncPackedHeaders,
1982 "sequence headers, but a global header is requested.\n");
1984 "this may result in a stream which is not usable for some " 1985 "purposes (e.g. not muxable to some containers).\n");
1993 #if VA_CHECK_VERSION(0, 36, 0) 1996 VAConfigAttrib attr = { VAConfigAttribEncQualityRange };
2003 if (vas != VA_STATUS_SUCCESS) {
2005 "config attribute: %d (%s).\n", vas, vaErrorStr(vas));
2009 if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
2012 "supported: will use default quality level.\n");
2015 if (quality > attr.value) {
2017 "valid range is 0-%d, using %d.\n",
2018 attr.value, attr.value);
2019 quality = attr.value;
2022 ctx->quality_params = (VAEncMiscParameterBufferQualityLevel) {
2023 .quality_level = quality,
2026 VAEncMiscParameterTypeQualityLevel,
2027 &ctx->quality_params,
2028 sizeof(ctx->quality_params));
2032 "not supported with this VAAPI version.\n");
2040 #if VA_CHECK_VERSION(1, 0, 0) 2043 VAConfigAttrib attr = { VAConfigAttribEncROI };
2049 if (vas != VA_STATUS_SUCCESS) {
2051 "config attribute: %d (%s).\n", vas, vaErrorStr(vas));
2055 if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
2058 VAConfigAttribValEncROI roi = {
2059 .value = attr.value,
2065 roi.bits.roi_rc_qp_delta_support);
2076 VABufferID buffer_id;
2078 buffer_id = (VABufferID)(uintptr_t)
data;
2090 VABufferID buffer_id;
2099 VAEncCodedBufferType,
2101 (1 << 16), 1, 0, &buffer_id);
2102 if (vas != VA_STATUS_SUCCESS) {
2104 "output buffer: %d (%s).\n", vas, vaErrorStr(vas));
2173 "size %dx%d (constraints: width %d-%d height %d-%d).\n",
2199 "frame context: %d.\n", err);
2219 "required to associate the encoding device.\n");
2275 if (vas != VA_STATUS_SUCCESS) {
2277 "configuration: %d (%s).\n", vas, vaErrorStr(vas));
2293 if (vas != VA_STATUS_SUCCESS) {
2295 "context: %d (%s).\n", vas, vaErrorStr(vas));
2338 "failed: %d.\n", err);
2347 size_t bit_len = 8 *
sizeof(
data);
2352 "for extradata: %d.\n", err);
2377 for (pic = ctx->
pic_start; pic; pic = next) {
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
VASurfaceID input_surface
int top
Distance in pixels from the top edge of the frame to the top and bottom edges and from the left edge ...
static int vaapi_encode_pick_next(AVCodecContext *avctx, VAAPIEncodePicture **pic_out)
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
const void * global_params[MAX_GLOBAL_PARAMS]
VAAPI-specific data associated with a frame pool.
This structure describes decoded (raw) audio or video data.
VAEntrypoint va_entrypoint
static const VAAPIEncodeRTFormat vaapi_encode_rt_formats[]
#define AV_LOG_WARNING
Something somehow does not look correct.
int64_t bit_rate
the average bitrate
#define HW_CONFIG_ENCODER_FRAMES(format, device_type_)
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
static av_cold int vaapi_encode_profile_entrypoint(AVCodecContext *avctx)
int width
The allocated dimensions of the frames in this pool.
static int vaapi_encode_make_packed_header(AVCodecContext *avctx, VAAPIEncodePicture *pic, int type, char *data, size_t bit_len)
static const char *const picture_type_name[]
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.
void * codec_sequence_params
AVBufferRef * input_frames_ref
size_t picture_params_size
AVHWDeviceContext * device
static int vaapi_encode_clear_old(AVCodecContext *avctx)
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
static int vaapi_encode_wait(AVCodecContext *avctx, VAAPIEncodePicture *pic)
int(* init_picture_params)(AVCodecContext *avctx, VAAPIEncodePicture *pic)
int max_width
The maximum size of frames in this hw_frames_ctx.
static int vaapi_encode_discard(AVCodecContext *avctx, VAAPIEncodePicture *pic)
static int vaapi_encode_make_param_buffer(AVCodecContext *avctx, VAAPIEncodePicture *pic, int type, char *data, size_t len)
AVRational qoffset
Quantisation offset.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
void av_hwframe_constraints_free(AVHWFramesConstraints **constraints)
Free an AVHWFrameConstraints structure.
unsigned int va_packed_headers
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int ff_vaapi_encode_send_frame(AVCodecContext *avctx, const AVFrame *frame)
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
const VAAPIEncodeRCMode * rc_mode
static int vaapi_encode_issue(AVCodecContext *avctx, VAAPIEncodePicture *pic)
static av_cold int end(AVCodecContext *avctx)
int(* write_sequence_header)(AVCodecContext *avctx, char *data, size_t *data_len)
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
static AVBufferRef * vaapi_encode_alloc_output_buffer(void *opaque, int size)
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
AVBufferRef * output_buffer_ref
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
Structure to hold side data for an AVFrame.
VABufferID * param_buffers
static void vaapi_encode_remove_refs(AVCodecContext *avctx, VAAPIEncodePicture *pic, int level)
struct VAAPIEncodePicture * prev
#define AVERROR_EOF
End of file.
#define AV_LOG_VERBOSE
Detailed information.
VASurfaceID recon_surface
#define AV_BUFFER_FLAG_READONLY
Always treat the buffer as read-only, even when it has only one reference.
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
static const uint8_t header[24]
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
VAConfigAttrib config_attributes[MAX_CONFIG_ATTRIBUTES]
AVHWFramesContext * input_frames
#define i(width, name, range_min, range_max)
int(* configure)(AVCodecContext *avctx)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
VAAPI hardware pipeline configuration details.
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
static int vaapi_encode_make_misc_param_buffer(AVCodecContext *avctx, VAAPIEncodePicture *pic, int type, const void *data, size_t len)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
static av_cold int vaapi_encode_init_packed_headers(AVCodecContext *avctx)
int qmax
maximum quantizer
int(* init_sequence_params)(AVCodecContext *avctx)
int(* write_picture_header)(AVCodecContext *avctx, VAAPIEncodePicture *pic, char *data, size_t *data_len)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
const AVCodecHWConfigInternal * ff_vaapi_encode_hw_configs[]
int flags
AV_CODEC_FLAG_*.
The driver does not destroy parameter buffers when they are used by vaRenderPicture().
simple assert() macros that are a bit more flexible than ISO C assert().
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
static int vaapi_encode_check_frame(AVCodecContext *avctx, const AVFrame *frame)
void * codec_picture_params
int av_hwframe_get_buffer(AVBufferRef *hwframe_ref, AVFrame *frame, int flags)
Allocate a new frame attached to the given AVHWFramesContext.
AVHWFramesContext * recon_frames
#define TRY_RC_MODE(mode, fail)
int flags
A combination of AV_PKT_FLAG values.
int rc_buffer_size
decoder bitstream buffer size
static av_cold int vaapi_encode_init_gop_structure(AVCodecContext *avctx)
VAAPIEncodeSlice * slices
uint8_t nb_components
The number of components each pixel has, (1-4)
enum AVPictureType pict_type
Picture type of the frame.
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
int width
picture width / height.
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
const VAAPIEncodeProfile * profile
#define FF_PROFILE_UNKNOWN
const VAAPIEncodeProfile * profiles
av_cold int ff_vaapi_encode_init(AVCodecContext *avctx)
int global_params_type[MAX_GLOBAL_PARAMS]
VAEncMiscParameterRateControl rc_params
VAAPIEncodePicture * next_prev
struct VAAPIEncodePicture * next
int(* write_extra_buffer)(AVCodecContext *avctx, VAAPIEncodePicture *pic, int index, int *type, char *data, size_t *data_len)
Structure describing a single Region Of Interest.
void * codec_picture_params
int64_t ts_ring[MAX_REORDER_DELAY *3]
AVBufferPool * output_buffer_pool
int ff_vaapi_encode_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
AVBufferPool * av_buffer_pool_init2(int size, void *opaque, AVBufferRef *(*alloc)(void *opaque, int size), void(*pool_free)(void *opaque))
Allocate and initialize a buffer pool with a more complex allocator.
#define FF_ARRAY_ELEMS(a)
static void vaapi_encode_add_ref(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodePicture *target, int is_ref, int in_dpb, int prev)
VADisplay display
The VADisplay handle, to be filled by the user.
struct VAAPIEncodePicture * refs[MAX_PICTURE_REFERENCES]
int min_width
The minimum size of frames in this hw_frames_ctx.
int(* init_slice_params)(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice)
const struct VAAPIEncodeType * codec
static VAAPIEncodePicture * vaapi_encode_alloc(AVCodecContext *avctx)
Libavcodec external API header.
static void vaapi_encode_set_b_pictures(AVCodecContext *avctx, VAAPIEncodePicture *start, VAAPIEncodePicture *end, VAAPIEncodePicture *prev, int current_depth, VAAPIEncodePicture **last)
This struct describes the constraints on hardware frames attached to a given device with a hardware-s...
VAAPIEncodePicture * pic_start
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
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.
int qmin
minimum quantizer
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...
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of array element is ...
This struct describes a set or pool of "hardware" frames (i.e.
int(* write_extra_header)(AVCodecContext *avctx, VAAPIEncodePicture *pic, int index, int *type, char *data, size_t *data_len)
AVBufferRef * recon_frames_ref
static av_cold int vaapi_encode_init_quality(AVCodecContext *avctx)
int global_quality
Global quality for codecs which cannot change it per frame.
VAAPIEncodePicture * pic_end
static const VAAPIEncodeRCMode vaapi_encode_rc_modes[]
size_t picture_priv_data_size
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
AVBufferRef * device_ref
A reference to the parent AVHWDeviceContext.
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
size_t global_params_size[MAX_GLOBAL_PARAMS]
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
A reference to a data buffer.
size_t sequence_params_size
VAEncMiscParameterHRD hrd_params
common internal and external API header
static int ref[MAX_W *MAX_W]
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
static av_cold int vaapi_encode_init_roi(AVCodecContext *avctx)
int slices
Number of slices.
static av_cold int vaapi_encode_create_recon_frames(AVCodecContext *avctx)
static const VAEntrypoint vaapi_encode_entrypoints_normal[]
VAEncMiscParameterFrameRate fr_params
enum AVPixelFormat * valid_sw_formats
A list of possible values for sw_format in the hw_frames_ctx, terminated by AV_PIX_FMT_NONE.
void * codec_slice_params
static int vaapi_encode_free(AVCodecContext *avctx, VAAPIEncodePicture *pic)
VAConfigID config_id
ID of a VAAPI pipeline configuration.
static void vaapi_encode_free_output_buffer(void *opaque, uint8_t *data)
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
unsigned int desired_packed_headers
VASurfaceID * surface_ids
The surfaces IDs of all surfaces in the pool after creation.
static av_cold int vaapi_encode_init_slice_structure(AVCodecContext *avctx)
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
#define av_malloc_array(a, b)
#define AV_CODEC_FLAG_CLOSED_GOP
static av_cold int vaapi_encode_init_rate_control(AVCodecContext *avctx)
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.
int depth
Number of bits in the component.
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
#define AVERROR_EXTERNAL
Generic error in an external library.
AVPixelFormat
Pixel format.
This structure stores compressed data.
struct VAAPIEncodePicture * dpb[MAX_DPB_SIZE]
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)
static av_cold void vaapi_encode_add_global_param(AVCodecContext *avctx, int type, void *buffer, size_t size)
int64_t rc_max_rate
maximum bitrate
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
static int vaapi_encode_output(AVCodecContext *avctx, VAAPIEncodePicture *pic, AVPacket *pkt)
AVVAAPIDeviceContext * hwctx
int(* write_slice_header)(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice, char *data, size_t *data_len)