41 int type,
char *
data,
size_t bit_len)
45 VABufferID param_buffer, data_buffer;
47 VAEncPackedHeaderParameterBuffer
params = {
49 .bit_length = bit_len,
50 .has_emulation_bytes = 1,
59 VAEncPackedHeaderParameterBufferType,
60 sizeof(params), 1, ¶ms, ¶m_buffer);
61 if (vas != VA_STATUS_SUCCESS) {
63 "for packed header (type %d): %d (%s).\n",
64 type, vas, vaErrorStr(vas));
70 VAEncPackedHeaderDataBufferType,
71 (bit_len + 7) / 8, 1, data, &data_buffer);
72 if (vas != VA_STATUS_SUCCESS) {
74 "for packed header (type %d): %d (%s).\n",
75 type, vas, vaErrorStr(vas));
81 "(%zu bits).\n", type, param_buffer, data_buffer, bit_len);
100 type, len, 1, data, &buffer);
101 if (vas != VA_STATUS_SUCCESS) {
103 "(type %d): %d (%s).\n", type, vas, vaErrorStr(vas));
122 VAEncMiscParameterBuffer
header = {
125 size_t buffer_size =
sizeof(
header) + len;
128 memcpy(buffer, &header,
sizeof(header));
129 memcpy(buffer +
sizeof(header), data, len);
132 VAEncMiscParameterBufferType,
133 buffer, buffer_size);
154 if (vas != VA_STATUS_SUCCESS) {
156 "%d (%s).\n", vas, vaErrorStr(vas));
185 for (i = 0; i < rounding; i++)
188 for (i = 0; i < (rounding + 1) / 2; i++)
190 for (i = 0; i < rounding / 2; i++)
193 }
else if (rounding < 0) {
213 "%d-%d (%d blocks).\n", i, slice->
row_start,
240 "width:%2d height:%2d (%d blocks).\n", index, ctx->
col_bd[i],
267 for (i = 0; i < pic->
nb_refs; i++) {
275 for (i = 0; i < pic->
nb_refs; i++) {
319 VAEncSequenceParameterBufferType,
341 "parameters: %d.\n", err);
345 VAEncPictureParameterBufferType,
355 bit_len = 8 *
sizeof(
data);
359 "header: %d.\n", err);
372 bit_len = 8 *
sizeof(
data);
376 "header: %d.\n", err);
396 "buffer %d: %d.\n", i, err);
411 bit_len = 8 *
sizeof(
data);
418 "header %d: %d.\n", i, err);
459 "parameters: %d.\n", err);
466 bit_len = 8 *
sizeof(
data);
471 "header: %d.\n", err);
483 VAEncSliceParameterBufferType,
491 #if VA_CHECK_VERSION(1, 0, 0) 497 VAEncMiscParameterBufferROI param_roi;
502 av_assert0(roi_size && sd->size % roi_size == 0);
503 nb_roi = sd->size / roi_size;
507 "supported by driver (%d > %d).\n",
520 for (i = 0; i < nb_roi; i++) {
528 pic->
roi[
i] = (VAEncROI) {
539 param_roi = (VAEncMiscParameterBufferROI) {
541 .max_delta_qp = INT8_MAX,
542 .min_delta_qp = INT8_MIN,
544 .roi_flags.bits.roi_value_is_qp_delta = 1,
548 VAEncMiscParameterTypeROI,
558 if (vas != VA_STATUS_SUCCESS) {
560 "%d (%s).\n", vas, vaErrorStr(vas));
562 goto fail_with_picture;
567 if (vas != VA_STATUS_SUCCESS) {
569 "%d (%s).\n", vas, vaErrorStr(vas));
571 goto fail_with_picture;
575 if (vas != VA_STATUS_SUCCESS) {
577 "%d (%s).\n", vas, vaErrorStr(vas));
593 if (vas != VA_STATUS_SUCCESS) {
595 "param buffer %#x: %d (%s).\n",
630 VACodedBufferSegment *buf_list, *buf;
643 if (vas != VA_STATUS_SUCCESS) {
645 "%d (%s).\n", vas, vaErrorStr(vas));
650 for (buf = buf_list; buf; buf = buf->next)
651 total_size += buf->size;
659 for (buf = buf_list; buf; buf = buf->next) {
661 "(status %08x).\n", buf->size, buf->status);
663 memcpy(ptr, buf->buf, buf->size);
673 if (vas != VA_STATUS_SUCCESS) {
675 "%d (%s).\n", vas, vaErrorStr(vas));
702 "%"PRId64
"/%"PRId64
".\n",
770 int is_ref,
int in_dpb,
int prev)
806 for (i = 0; i < pic->
nb_refs; i++) {
844 for (pic = start->
next; pic; pic = pic->
next) {
854 for (ref = end->
refs[1]; ref; ref = ref->
refs[1])
863 for (pic = start->
next; pic != end; pic = pic->
next)
865 for (pic = start->
next, i = 1; 2 * i < len; pic = pic->next, i++);
877 for (ref = end->
refs[1]; ref; ref = ref->
refs[1])
882 current_depth + 1, &next);
887 current_depth + 1, last);
896 int i, b_counter, closed_gop_end;
906 for (i = 0; i < pic->
nb_refs; i++) {
916 "encode next.\n", pic->
b_depth);
927 for (pic = ctx->
pic_start; pic; pic = next) {
945 if (next && next->force_idr)
960 "need more input for reference pictures.\n");
965 "need more input for timestamps.\n");
1015 if (b_counter > 0) {
1046 for (pic = ctx->
pic_start; pic; pic = next) {
1071 "frames ignored due to lack of API support.\n");
1081 "frames ignored due to lack of driver support.\n");
1204 pkt->
dts = INT64_MIN;
1245 {
"YUV400", VA_RT_FORMAT_YUV400, 8, 1, },
1246 {
"YUV420", VA_RT_FORMAT_YUV420, 8, 3, 1, 1 },
1247 {
"YUV422", VA_RT_FORMAT_YUV422, 8, 3, 1, 0 },
1248 #if VA_CHECK_VERSION(1, 2, 0) 1249 {
"YUV422_10", VA_RT_FORMAT_YUV422_10, 10, 3, 1, 0 },
1251 {
"YUV444", VA_RT_FORMAT_YUV444, 8, 3, 0, 0 },
1252 {
"YUV411", VA_RT_FORMAT_YUV411, 8, 3, 2, 0 },
1253 #if VA_CHECK_VERSION(0, 38, 1) 1254 {
"YUV420_10", VA_RT_FORMAT_YUV420_10BPP, 10, 3, 1, 1 },
1259 VAEntrypointEncSlice,
1260 VAEntrypointEncPicture,
1261 #if VA_CHECK_VERSION(0, 39, 2) 1262 VAEntrypointEncSliceLP,
1266 #if VA_CHECK_VERSION(0, 39, 2) 1267 static const VAEntrypoint vaapi_encode_entrypoints_low_power[] = {
1268 VAEntrypointEncSliceLP,
1276 VAProfile *va_profiles =
NULL;
1277 VAEntrypoint *va_entrypoints =
NULL;
1279 const VAEntrypoint *usable_entrypoints;
1282 VAConfigAttrib rt_format_attr;
1284 const char *profile_string, *entrypoint_string;
1289 #if VA_CHECK_VERSION(0, 39, 2) 1290 usable_entrypoints = vaapi_encode_entrypoints_low_power;
1293 "supported with this VAAPI version.\n");
1323 vas = vaQueryConfigProfiles(ctx->
hwctx->
display, va_profiles, &n);
1324 if (vas != VA_STATUS_SUCCESS) {
1326 vas, vaErrorStr(vas));
1335 if (depth != profile->
depth ||
1346 #if VA_CHECK_VERSION(1, 0, 0) 1347 profile_string = vaProfileStr(profile->
va_profile);
1349 profile_string =
"(no profile names)";
1352 for (j = 0; j < n; j++) {
1358 "is not supported by driver.\n", profile_string,
1379 if (!va_entrypoints) {
1384 va_entrypoints, &n);
1385 if (vas != VA_STATUS_SUCCESS) {
1387 "profile %s (%d): %d (%s).\n", profile_string,
1393 for (i = 0; i < n; i++) {
1394 for (j = 0; usable_entrypoints[j]; j++) {
1395 if (va_entrypoints[i] == usable_entrypoints[j])
1398 if (usable_entrypoints[j])
1403 "for profile %s (%d).\n", profile_string, ctx->
va_profile);
1409 #if VA_CHECK_VERSION(1, 0, 0) 1412 entrypoint_string =
"(no entrypoint names)";
1418 rt_format = &vaapi_encode_rt_formats[
i];
1419 if (rt_format->
depth == depth &&
1427 "found for profile %s (%d) entrypoint %s (%d).\n",
1434 rt_format_attr = (VAConfigAttrib) { VAConfigAttribRTFormat };
1437 &rt_format_attr, 1);
1438 if (vas != VA_STATUS_SUCCESS) {
1440 "config attribute: %d (%s).\n", vas, vaErrorStr(vas));
1445 if (rt_format_attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1447 "supported by driver: assuming surface RT format %s " 1448 "is valid.\n", rt_format->
name);
1449 }
else if (!(rt_format_attr.value & rt_format->
value)) {
1451 "by driver for encoding profile %s (%d) entrypoint %s (%d).\n",
1458 "format %s (%#x).\n", rt_format->
name, rt_format->
value);
1461 .type = VAConfigAttribRTFormat,
1462 .value = rt_format->
value,
1480 #if VA_CHECK_VERSION(1, 1, 0) 1485 #if VA_CHECK_VERSION(1, 3, 0) 1497 uint32_t supported_va_rc_modes;
1499 int64_t rc_bits_per_second;
1500 int rc_target_percentage;
1503 int64_t hrd_buffer_size;
1504 int64_t hrd_initial_buffer_fullness;
1506 VAConfigAttrib rc_attr = { VAConfigAttribRateControl };
1508 char supported_rc_modes_string[64];
1513 if (vas != VA_STATUS_SUCCESS) {
1515 "config attribute: %d (%s).\n", vas, vaErrorStr(vas));
1518 if (rc_attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1520 "supported rate control modes: assuming CQP only.\n");
1521 supported_va_rc_modes = VA_RC_CQP;
1522 strcpy(supported_rc_modes_string,
"unknown");
1524 char *
str = supported_rc_modes_string;
1525 size_t len =
sizeof(supported_rc_modes_string);
1528 supported_va_rc_modes = rc_attr.value;
1530 rc_mode = &vaapi_encode_rc_modes[
i];
1531 if (supported_va_rc_modes & rc_mode->
va_mode) {
1533 first ?
"" :
", ", rc_mode->
name);
1547 supported_rc_modes_string);
1562 #define TRY_RC_MODE(mode, fail) do { \ 1563 rc_mode = &vaapi_encode_rc_modes[mode]; \ 1564 if (!(rc_mode->va_mode & supported_va_rc_modes)) { \ 1566 av_log(avctx, AV_LOG_ERROR, "Driver does not support %s " \ 1567 "RC mode (supported modes: %s).\n", rc_mode->name, \ 1568 supported_rc_modes_string); \ 1569 return AVERROR(EINVAL); \ 1571 av_log(avctx, AV_LOG_DEBUG, "Driver does not support %s " \ 1572 "RC mode.\n", rc_mode->name); \ 1575 goto rc_mode_found; \ 1612 "RC mode compatible with selected options " 1613 "(supported modes: %s).\n", supported_rc_modes_string);
1620 "RC mode.\n", rc_mode->
name);
1630 rc_bits_per_second = avctx->
bit_rate;
1636 rc_target_percentage = 100;
1643 }
else if (rc_mode->
maxrate) {
1647 "bitrate (%"PRId64
") must not be greater than " 1648 "maxrate (%"PRId64
").\n", avctx->
bit_rate,
1653 rc_target_percentage = (avctx->
bit_rate * 100) /
1660 rc_bits_per_second = 2 * avctx->
bit_rate;
1661 rc_target_percentage = 50;
1666 "in %s RC mode.\n", rc_mode->
name);
1668 rc_bits_per_second = avctx->
bit_rate;
1669 rc_target_percentage = 100;
1672 rc_bits_per_second = 0;
1673 rc_target_percentage = 100;
1684 "using default (%d).\n", rc_quality);
1700 "must have initial buffer size (%d) <= " 1701 "buffer size (%"PRId64
").\n",
1707 hrd_initial_buffer_fullness = hrd_buffer_size * 3 / 4;
1710 rc_window_size = (hrd_buffer_size * 1000) / rc_bits_per_second;
1714 "in %s RC mode.\n", rc_mode->
name);
1717 hrd_buffer_size = 0;
1718 hrd_initial_buffer_fullness = 0;
1722 rc_window_size = 1000;
1726 if (rc_bits_per_second > UINT32_MAX ||
1727 hrd_buffer_size > UINT32_MAX ||
1728 hrd_initial_buffer_fullness > UINT32_MAX) {
1730 "greater are not supported by VAAPI.\n");
1740 if (rc_attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1745 .type = VAConfigAttribRateControl,
1753 if (rc_mode->
va_mode != VA_RC_CQP) {
1756 "converging in %d frames with %d%% accuracy.\n",
1757 rc_bits_per_second, rc_window_size,
1758 rc_target_percentage);
1759 }
else if (rc_mode->
bitrate) {
1761 "%"PRId64
" bps over %d ms.\n", rc_target_percentage,
1762 rc_bits_per_second, rc_window_size);
1765 ctx->
rc_params = (VAEncMiscParameterRateControl) {
1766 .bits_per_second = rc_bits_per_second,
1767 .target_percentage = rc_target_percentage,
1768 .window_size = rc_window_size,
1770 .min_qp = (avctx->
qmin > 0 ? avctx->
qmin : 0),
1771 .basic_unit_size = 0,
1772 #
if VA_CHECK_VERSION(1, 1, 0)
1773 .ICQ_quality_factor =
av_clip(rc_quality, 1, 51),
1774 .max_qp = (avctx->
qmax > 0 ? avctx->
qmax : 0),
1776 #
if VA_CHECK_VERSION(1, 3, 0)
1777 .quality_factor = rc_quality,
1781 VAEncMiscParameterTypeRateControl,
1788 "initial fullness %"PRId64
" bits.\n",
1789 hrd_buffer_size, hrd_initial_buffer_fullness);
1792 .initial_buffer_fullness = hrd_initial_buffer_fullness,
1793 .buffer_size = hrd_buffer_size,
1796 VAEncMiscParameterTypeHRD,
1809 fr_num, fr_den, (
double)fr_num / fr_den);
1811 ctx->
fr_params = (VAEncMiscParameterFrameRate) {
1812 .framerate = (
unsigned int)fr_den << 16 | fr_num,
1814 #if VA_CHECK_VERSION(0, 40, 0) 1816 VAEncMiscParameterTypeFrameRate,
1828 VAConfigAttrib attr = { VAConfigAttribEncMaxRefFrames };
1829 uint32_t ref_l0, ref_l1;
1835 if (vas != VA_STATUS_SUCCESS) {
1837 "attribute: %d (%s).\n", vas, vaErrorStr(vas));
1841 if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1842 ref_l0 = ref_l1 = 0;
1844 ref_l0 = attr.value & 0xffff;
1845 ref_l1 = attr.value >> 16 & 0xffff;
1852 }
else if (ref_l0 < 1) {
1854 "reference frames.\n");
1857 ref_l1 < 1 || avctx->max_b_frames < 1) {
1859 "(supported references: %d / %d).\n", ref_l0, ref_l1);
1865 "(supported references: %d / %d).\n", ref_l0, ref_l1);
1889 uint32_t slice_structure)
1901 "configured number of slices (%d < %d); using " 1905 req_slices = avctx->
slices;
1907 if (slice_structure & VA_ENC_SLICE_STRUCTURE_ARBITRARY_ROWS ||
1908 slice_structure & VA_ENC_SLICE_STRUCTURE_ARBITRARY_MACROBLOCKS) {
1911 }
else if (slice_structure & VA_ENC_SLICE_STRUCTURE_POWER_OF_TWO_ROWS) {
1913 for (k = 1;; k *= 2) {
1919 #if VA_CHECK_VERSION(1, 0, 0) 1920 }
else if (slice_structure & VA_ENC_SLICE_STRUCTURE_EQUAL_ROWS) {
1926 "slice structure modes (%#x).\n", slice_structure);
1934 uint32_t slice_structure)
1939 if (!(slice_structure & VA_ENC_SLICE_STRUCTURE_ARBITRARY_MACROBLOCKS ||
1940 (slice_structure & VA_ENC_SLICE_STRUCTURE_ARBITRARY_ROWS &&
1943 "current tile requirement.\n", slice_structure);
1950 "for configured number of tile (%d x %d); ",
1966 if (avctx->
slices != req_tiles)
1968 "mismatches with configured number of tile (%d != %d); " 1969 "using requested tile number for slice.\n",
1970 avctx->
slices, req_tiles);
1997 VAConfigAttrib attr[3] = { { VAConfigAttribEncMaxSlices },
1998 { VAConfigAttribEncSliceStructure },
1999 #if VA_CHECK_VERSION(1, 1, 0) 2000 { VAConfigAttribEncTileSupport },
2004 uint32_t max_slices, slice_structure;
2010 "but this codec does not support controlling slices.\n");
2030 if (vas != VA_STATUS_SUCCESS) {
2032 "attributes: %d (%s).\n", vas, vaErrorStr(vas));
2035 max_slices = attr[0].value;
2036 slice_structure = attr[1].value;
2037 if (max_slices == VA_ATTRIB_NOT_SUPPORTED ||
2038 slice_structure == VA_ATTRIB_NOT_SUPPORTED) {
2040 "pictures as multiple slices.\n.");
2045 #if VA_CHECK_VERSION(1, 1, 0) 2046 uint32_t tile_support = attr[2].value;
2047 if (tile_support == VA_ATTRIB_NOT_SUPPORTED) {
2049 "pictures as multiple tiles.\n.");
2054 "not supported with this VAAPI version.\n");
2068 "%d (from %d) due to driver constraints on slice " 2073 "encoding with %d slices (max %"PRIu32
").\n",
2087 VAConfigAttrib attr = { VAConfigAttribEncPackedHeaders };
2093 if (vas != VA_STATUS_SUCCESS) {
2095 "attribute: %d (%s).\n", vas, vaErrorStr(vas));
2099 if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
2102 "packed headers (wanted %#x).\n",
2106 "packed headers (none wanted).\n");
2112 "wanted packed headers (wanted %#x, found %#x).\n",
2116 "available (wanted %#x, found %#x).\n",
2125 .type = VAConfigAttribEncPackedHeaders,
2134 "sequence headers, but a global header is requested.\n");
2136 "this may result in a stream which is not usable for some " 2137 "purposes (e.g. not muxable to some containers).\n");
2145 #if VA_CHECK_VERSION(0, 36, 0) 2148 VAConfigAttrib attr = { VAConfigAttribEncQualityRange };
2155 if (vas != VA_STATUS_SUCCESS) {
2157 "config attribute: %d (%s).\n", vas, vaErrorStr(vas));
2161 if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
2164 "supported: will use default quality level.\n");
2167 if (quality > attr.value) {
2169 "valid range is 0-%d, using %d.\n",
2170 attr.value, attr.value);
2171 quality = attr.value;
2174 ctx->quality_params = (VAEncMiscParameterBufferQualityLevel) {
2178 VAEncMiscParameterTypeQualityLevel,
2179 &ctx->quality_params,
2180 sizeof(ctx->quality_params));
2184 "not supported with this VAAPI version.\n");
2192 #if VA_CHECK_VERSION(1, 0, 0) 2195 VAConfigAttrib attr = { VAConfigAttribEncROI };
2201 if (vas != VA_STATUS_SUCCESS) {
2203 "config attribute: %d (%s).\n", vas, vaErrorStr(vas));
2207 if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
2210 VAConfigAttribValEncROI roi = {
2211 .value = attr.value,
2217 roi.bits.roi_rc_qp_delta_support);
2228 VABufferID buffer_id;
2230 buffer_id = (VABufferID)(uintptr_t)
data;
2242 VABufferID buffer_id;
2251 VAEncCodedBufferType,
2253 (1 << 16), 1, 0, &buffer_id);
2254 if (vas != VA_STATUS_SUCCESS) {
2256 "output buffer: %d (%s).\n", vas, vaErrorStr(vas));
2325 "size %dx%d (constraints: width %d-%d height %d-%d).\n",
2351 "frame context: %d.\n", err);
2376 "required to associate the encoding device.\n");
2432 if (vas != VA_STATUS_SUCCESS) {
2434 "configuration: %d (%s).\n", vas, vaErrorStr(vas));
2450 if (vas != VA_STATUS_SUCCESS) {
2452 "context: %d (%s).\n", vas, vaErrorStr(vas));
2495 "failed: %d.\n", err);
2504 size_t bit_len = 8 *
sizeof(
data);
2509 "for extradata: %d.\n", err);
2534 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
ptrdiff_t const GLvoid * data
int col_bd[MAX_TILE_COLS+1]
static int vaapi_encode_make_tile_slice(AVCodecContext *avctx, VAAPIEncodePicture *pic)
static const VAAPIEncodeRTFormat vaapi_encode_rt_formats[]
static AVBufferRef * vaapi_encode_alloc_output_buffer(void *opaque, buffer_size_t size)
#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 int vaapi_encode_send_frame(AVCodecContext *avctx, AVFrame *frame)
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 av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
#define FF_ARRAY_ELEMS(a)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
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.
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)
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
int(* write_sequence_header)(AVCodecContext *avctx, char *data, size_t *data_len)
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)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
VAConfigAttrib config_attributes[MAX_CONFIG_ATTRIBUTES]
AVHWFramesContext * input_frames
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.
int row_height[MAX_TILE_ROWS]
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.
int flags
AV_CODEC_FLAG_*.
simple assert() macros that are a bit more flexible than ISO C assert().
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.
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 row_bd[MAX_TILE_ROWS+1]
int rc_buffer_size
decoder bitstream buffer size
static av_cold int vaapi_encode_init_gop_structure(AVCodecContext *avctx)
common internal API header
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
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
VAAPIEncodePicture * next_prev
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
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(buffer_size_t size, void *opaque, AVBufferRef *(*alloc)(void *opaque, buffer_size_t size), void(*pool_free)(void *opaque))
Allocate and initialize a buffer pool with a more complex allocator.
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 col_width[MAX_TILE_COLS]
static av_cold int vaapi_encode_init_tile_slice_structure(AVCodecContext *avctx, uint32_t slice_structure)
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...
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
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.
The driver does not destroy parameter buffers when they are used by vaRenderPicture().
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
static av_cold int vaapi_encode_init_row_slice_structure(AVCodecContext *avctx, uint32_t slice_structure)
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.
static int vaapi_encode_make_row_slice(AVCodecContext *avctx, VAAPIEncodePicture *pic)
#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.
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
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)
const AVCodecHWConfigInternal *const ff_vaapi_encode_hw_configs[]
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
int ff_encode_get_frame(AVCodecContext *avctx, AVFrame *frame)
Called by encoders to get the next frame for encoding.
void * av_mallocz_array(size_t nmemb, size_t size)
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)