34 int type,
char *
data,
size_t bit_len)
38 VABufferID param_buffer, data_buffer;
39 VAEncPackedHeaderParameterBuffer params = {
41 .bit_length = bit_len,
42 .has_emulation_bytes = 1,
48 VAEncPackedHeaderParameterBufferType,
49 sizeof(params), 1, ¶ms, ¶m_buffer);
50 if (vas != VA_STATUS_SUCCESS) {
52 "for packed header (type %d): %d (%s).\n",
53 type, vas, vaErrorStr(vas));
59 VAEncPackedHeaderDataBufferType,
60 (bit_len + 7) / 8, 1, data, &data_buffer);
61 if (vas != VA_STATUS_SUCCESS) {
63 "for packed header (type %d): %d (%s).\n",
64 type, vas, vaErrorStr(vas));
70 "(%zu bits).\n", type, param_buffer, data_buffer, bit_len);
76 int type,
char *
data,
size_t len)
85 type, len, 1, data, &buffer);
86 if (vas != VA_STATUS_SUCCESS) {
88 "(type %d): %d (%s).\n", type, vas, vaErrorStr(vas));
116 if (vas != VA_STATUS_SUCCESS) {
118 "%d (%s).\n", vas, vaErrorStr(vas));
146 for (i = 0; i < pic->
nb_refs; i++) {
154 for (i = 0; i < pic->
nb_refs; i++) {
207 VAEncMiscParameterBufferType,
217 VAEncSequenceParameterBufferType,
228 "parameters: %d.\n", err);
232 VAEncPictureParameterBufferType,
241 bit_len = 8 *
sizeof(
data);
245 "header: %d.\n", err);
257 bit_len = 8 *
sizeof(
data);
261 "header: %d.\n", err);
281 "buffer %d: %d.\n", i, err);
295 bit_len = 8 *
sizeof(
data);
302 "header %d: %d.\n", i, err);
334 "parameters: %d.\n", err);
340 bit_len = 8 *
sizeof(
data);
345 "header: %d.\n", err);
357 VAEncSliceParameterBufferType,
367 if (vas != VA_STATUS_SUCCESS) {
369 "%d (%s).\n", vas, vaErrorStr(vas));
371 goto fail_with_picture;
376 if (vas != VA_STATUS_SUCCESS) {
378 "%d (%s).\n", vas, vaErrorStr(vas));
380 goto fail_with_picture;
384 if (vas != VA_STATUS_SUCCESS) {
386 "%d (%s).\n", vas, vaErrorStr(vas));
402 if (vas != VA_STATUS_SUCCESS) {
404 "param buffer %#x: %d (%s).\n",
433 VACodedBufferSegment *buf_list, *buf;
444 if (vas != VA_STATUS_SUCCESS) {
446 "%d (%s).\n", vas, vaErrorStr(vas));
451 for (buf = buf_list; buf; buf = buf->next) {
453 "(status %08x).\n", buf->size, buf->status);
459 memcpy(pkt->
data, buf->buf, buf->size);
468 if (vas != VA_STATUS_SUCCESS) {
470 "%d (%s).\n", vas, vaErrorStr(vas));
497 "%"PRId64
"/%"PRId64
".\n",
574 for (i = 0; i < pic->
nb_refs; i++) {
594 for (i = 0; i < pic->
nb_refs; i++) {
598 if (i < pic->nb_refs)
677 for (i = 0; i < ctx->
b_per_p; i++) {
694 for (i = 0, pic = start; pic; i++, pic = pic->
next) {
714 pic->display_order, pic->encode_order);
752 for (pic = ctx->
pic_start; pic != last_pic; pic = pic->
next) {
755 pic->
refs[1] = last_pic;
766 for (pic = last_pic->
next; pic; pic = next) {
801 for (pic = old->
next; pic; pic = pic->
next) {
804 for (i = 0; i < pic->
nb_refs; i++) {
805 if (pic->
refs[i] == old) {
823 const AVFrame *input_image,
int *got_packet)
848 pic->
pts = input_image->
pts;
899 pkt->
dts = INT64_MIN;
931 VAEntrypoint *entrypoints =
NULL;
932 VAConfigAttrib attr[] = {
933 { VAConfigAttribRateControl },
934 { VAConfigAttribEncMaxRefFrames },
943 vas = vaQueryConfigProfiles(ctx->
hwctx->
display, profiles, &n);
944 if (vas != VA_STATUS_SUCCESS) {
946 vas, vaErrorStr(vas));
950 for (i = 0; i < n; i++) {
969 if (vas != VA_STATUS_SUCCESS) {
972 vas, vaErrorStr(vas));
976 for (i = 0; i < n; i++) {
990 if (vas != VA_STATUS_SUCCESS) {
992 "attributes: %d (%s).\n", vas, vaErrorStr(vas));
997 if (attr[i].value == VA_ATTRIB_NOT_SUPPORTED) {
1003 switch (attr[i].type) {
1004 case VAConfigAttribRateControl:
1007 "supported: %x\n", attr[i].value);
1012 case VAConfigAttribEncMaxRefFrames:
1014 unsigned int ref_l0 = attr[i].value & 0xffff;
1015 unsigned int ref_l1 = (attr[i].value >> 16) & 0xffff;
1017 if (avctx->
gop_size > 1 && ref_l0 < 1) {
1019 "supported (%x).\n", attr[i].value);
1025 "supported (%x).\n", attr[i].value);
1046 VABufferID buffer_id;
1048 buffer_id = (VABufferID)(uintptr_t)
data;
1060 VABufferID buffer_id;
1069 VAEncCodedBufferType,
1071 (1 << 16), 1, 0, &buffer_id);
1072 if (vas != VA_STATUS_SUCCESS) {
1074 "output buffer: %d (%s).\n", vas, vaErrorStr(vas));
1105 "required to associate the encoding device.\n");
1148 if (vas != VA_STATUS_SUCCESS) {
1150 "configuration: %d (%s).\n", vas, vaErrorStr(vas));
1198 "size %dx%d (constraints: width %d-%d height %d-%d).\n",
1225 "frame context: %d.\n", err);
1236 if (vas != VA_STATUS_SUCCESS) {
1238 "context: %d (%s).\n", vas, vaErrorStr(vas));
1269 "failed: %d.\n", err);
1306 for (pic = ctx->
pic_start; pic; pic = next) {
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
VASurfaceID input_surface
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.
This structure describes decoded (raw) audio or video data.
VAAPIEncodeSlice * slices[MAX_PICTURE_SLICES]
VAEntrypoint va_entrypoint
static const char * picture_type_name[]
static int vaapi_encode_free(AVCodecContext *avctx, VAAPIEncodePicture *pic)
char codec_options_data[0]
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...
av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
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.
int(* close)(AVCodecContext *avctx)
static void vaapi_encode_free_output_buffer(void *opaque, uint8_t *data)
#define FF_ARRAY_ELEMS(a)
void * codec_sequence_params
AVBufferRef * input_frames_ref
size_t picture_params_size
AVHWDeviceContext * device
int(* init_picture_params)(AVCodecContext *avctx, VAAPIEncodePicture *pic)
int max_width
The maximum size of frames in this hw_frames_ctx.
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
void av_hwframe_constraints_free(AVHWFramesConstraints **constraints)
Free an AVHWFrameConstraints structure.
static int vaapi_encode_mangle_end(AVCodecContext *avctx)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
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.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
AVBufferRef * output_buffer_ref
av_cold int ff_vaapi_encode_init(AVCodecContext *avctx, const VAAPIEncodeType *type)
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
#define AVERROR_EOF
End of file.
VASurfaceID recon_surface
#define AV_BUFFER_FLAG_READONLY
Always treat the buffer as read-only, even when it has only one reference.
#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
int width
width and height of the video frame
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
VAAPI hardware pipeline configuration details.
static int vaapi_encode_step(AVCodecContext *avctx, VAAPIEncodePicture *target)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
int ff_vaapi_encode2(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *input_image, int *got_packet)
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.
VAEncMiscParameterBuffer * global_params[MAX_GLOBAL_PARAMS]
simple assert() macros that are a bit more flexible than ISO C assert().
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.
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
int flags
A combination of AV_PKT_FLAG values.
int initial_pool_size
Initial size of the frame pool.
The driver does not destroy parameter buffers when they are used by vaRenderPicture().
static int vaapi_encode_get_next(AVCodecContext *avctx, VAAPIEncodePicture **pic_out)
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
static int vaapi_encode_make_param_buffer(AVCodecContext *avctx, VAAPIEncodePicture *pic, int type, char *data, size_t len)
struct VAAPIEncodePicture * next
static int vaapi_encode_discard(AVCodecContext *avctx, VAAPIEncodePicture *pic)
int(* write_extra_buffer)(AVCodecContext *avctx, VAAPIEncodePicture *pic, int index, int *type, char *data, size_t *data_len)
void * codec_picture_params
int64_t ts_ring[MAX_REORDER_DELAY *3]
AVBufferPool * output_buffer_pool
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.
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
Libavcodec external API header.
This struct describes the constraints on hardware frames attached to a given device with a hardware-s...
VAAPIEncodePicture * pic_start
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.
static VAAPIEncodePicture * vaapi_encode_alloc(void)
VABufferID param_buffers[MAX_PARAM_BUFFERS]
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...
static const AVProfile profiles[]
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
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_check_config(AVCodecContext *avctx)
VAAPIEncodePicture * pic_end
static void * av_malloc_array(size_t nmemb, size_t size)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
AVBufferRef * device_ref
A reference to the parent AVHWDeviceContext.
size_t global_params_size[MAX_GLOBAL_PARAMS]
static int vaapi_encode_issue(AVCodecContext *avctx, VAAPIEncodePicture *pic)
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
static int vaapi_encode_clear_old(AVCodecContext *avctx)
common internal and external API header
static int vaapi_encode_output(AVCodecContext *avctx, VAAPIEncodePicture *pic, AVPacket *pkt)
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.
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 AVBufferRef * vaapi_encode_alloc_output_buffer(void *opaque, int size)
static int vaapi_encode_wait(AVCodecContext *avctx, VAAPIEncodePicture *pic)
VAConfigID config_id
ID of a VAAPI pipeline configuration.
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
static int vaapi_encode_make_packed_header(AVCodecContext *avctx, VAAPIEncodePicture *pic, int type, char *data, size_t bit_len)
VASurfaceID * surface_ids
The surfaces IDs of all surfaces in the pool after creation.
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
int(* init)(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.
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
AVPixelFormat
Pixel format.
This structure stores compressed data.
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
AVVAAPIDeviceContext * hwctx
int(* write_slice_header)(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice, char *data, size_t *data_len)