RepoMirrors/ffmpeg
1
0
Fork 0
mirror of https://git.ffmpeg.org/ffmpeg.git synced 2025-04-09 18:53:12 +00:00
Code Issues Projects Releases Wiki Activity

hw_base_encode: refactor picture allocation/freeing

Browse Source 
This commit cleans up and refactors the mess of private state upon
private state that used to be.

Now, FFHWBaseEncodePicture is fully initialized upon call-time,
and, most importantly, this lets APIs which require initialization
data for frames (VkImageViews) to initialize this for both the
input image, and the reconstruction (DPB) image.

Signed-off-by: Tong Wu <wutong1208@outlook.com>
This commit is contained in:
Lynne 2024-08-21 23:27:15 +08:00
parent fdf8025eb6
commit 9db68ed042
No known key found for this signature in database
GPG Key ID: A2FEA5F03F034464
14 changed files with 201 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
libavcodec/d3d12va_encode.c
View File

@ -107,10 +107,10 @@ static int d3d12va_discard_command_allocator(AVCodecContext *avctx, ID3D12Comman
} }
static int d3d12va_encode_wait(AVCodecContext *avctx, static int d3d12va_encode_wait(AVCodecContext *avctx,
D3D12VAEncodePicture *pic) FFHWBaseEncodePicture *base_pic)
{ {
D3D12VAEncodeContext *ctx = avctx->priv_data; D3D12VAEncodeContext *ctx = avctx->priv_data;
FFHWBaseEncodePicture *base_pic = &pic->base; D3D12VAEncodePicture *pic = base_pic->priv;
uint64_t completion; uint64_t completion;
av_assert0(base_pic->encode_issued); av_assert0(base_pic->encode_issued);
@ -186,12 +186,12 @@ static int d3d12va_encode_create_metadata_buffers(AVCodecContext *avctx,
} }
static int d3d12va_encode_issue(AVCodecContext *avctx, static int d3d12va_encode_issue(AVCodecContext *avctx,
const FFHWBaseEncodePicture *base_pic) FFHWBaseEncodePicture *base_pic)
{ {
FFHWBaseEncodeContext *base_ctx = avctx->priv_data; FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
D3D12VAEncodeContext *ctx = avctx->priv_data; D3D12VAEncodeContext *ctx = avctx->priv_data;
D3D12VAEncodePicture *pic = base_pic->priv;
AVD3D12VAFramesContext *frames_hwctx = base_ctx->input_frames->hwctx; AVD3D12VAFramesContext *frames_hwctx = base_ctx->input_frames->hwctx;
D3D12VAEncodePicture *pic = (D3D12VAEncodePicture *)base_pic;
int err, i, j; int err, i, j;
HRESULT hr; HRESULT hr;
char data[MAX_PARAM_BUFFER_SIZE]; char data[MAX_PARAM_BUFFER_SIZE];
@ -288,7 +288,7 @@ static int d3d12va_encode_issue(AVCodecContext *avctx,
goto fail; goto fail;
if (ctx->codec->init_picture_params) { if (ctx->codec->init_picture_params) {
err = ctx->codec->init_picture_params(avctx, pic); err = ctx->codec->init_picture_params(avctx, base_pic);
if (err < 0) { if (err < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to initialise picture " av_log(avctx, AV_LOG_ERROR, "Failed to initialise picture "
"parameters: %d.\n", err); "parameters: %d.\n", err);
@ -333,9 +333,9 @@ static int d3d12va_encode_issue(AVCodecContext *avctx,
i = 0; i = 0;
for (j = 0; j < base_pic->nb_refs[0]; j++) for (j = 0; j < base_pic->nb_refs[0]; j++)
d3d12_refs.ppTexture2Ds[i++] = ((D3D12VAEncodePicture *)base_pic->refs[0][j])->recon_surface->texture; d3d12_refs.ppTexture2Ds[i++] = ((D3D12VAEncodePicture *)base_pic->refs[0][j]->priv)->recon_surface->texture;
for (j = 0; j < base_pic->nb_refs[1]; j++) for (j = 0; j < base_pic->nb_refs[1]; j++)
d3d12_refs.ppTexture2Ds[i++] = ((D3D12VAEncodePicture *)base_pic->refs[1][j])->recon_surface->texture; d3d12_refs.ppTexture2Ds[i++] = ((D3D12VAEncodePicture *)base_pic->refs[1][j]->priv)->recon_surface->texture;
} }
input_args.PictureControlDesc.IntraRefreshFrameIndex = 0; input_args.PictureControlDesc.IntraRefreshFrameIndex = 0;
@ -515,10 +515,11 @@ fail:
} }
static int d3d12va_encode_discard(AVCodecContext *avctx, static int d3d12va_encode_discard(AVCodecContext *avctx,
D3D12VAEncodePicture *pic) FFHWBaseEncodePicture *base_pic)
{ {
FFHWBaseEncodePicture *base_pic = &pic->base; D3D12VAEncodePicture *pic = base_pic->priv;
d3d12va_encode_wait(avctx, pic);
d3d12va_encode_wait(avctx, base_pic);
if (pic->output_buffer_ref) { if (pic->output_buffer_ref) {
av_log(avctx, AV_LOG_DEBUG, "Discard output for pic " av_log(avctx, AV_LOG_DEBUG, "Discard output for pic "
@ -560,44 +561,33 @@ static int d3d12va_encode_free_rc_params(AVCodecContext *avctx)
return 0; return 0;
} }
static FFHWBaseEncodePicture *d3d12va_encode_alloc(AVCodecContext *avctx, static int d3d12va_encode_init(AVCodecContext *avctx, FFHWBaseEncodePicture *pic)
const AVFrame *frame)
{ {
D3D12VAEncodeContext *ctx = avctx->priv_data; D3D12VAEncodeContext *ctx = avctx->priv_data;
D3D12VAEncodePicture *pic; D3D12VAEncodePicture *priv = pic->priv;
AVFrame *frame = pic->input_image;
pic = av_mallocz(sizeof(*pic));
if (!pic)
return NULL;
if (ctx->codec->picture_priv_data_size > 0) { if (ctx->codec->picture_priv_data_size > 0) {
pic->base.priv_data = av_mallocz(ctx->codec->picture_priv_data_size); pic->codec_priv = av_mallocz(ctx->codec->picture_priv_data_size);
if (!pic->base.priv_data) { if (!pic->codec_priv)
av_freep(&pic); return AVERROR(ENOMEM);
return NULL;
}
} }
pic->input_surface = (AVD3D12VAFrame *)frame->data[0]; priv->input_surface = (AVD3D12VAFrame *)frame->data[0];
return &pic->base; return 0;
} }
static int d3d12va_encode_free(AVCodecContext *avctx, static int d3d12va_encode_free(AVCodecContext *avctx, FFHWBaseEncodePicture *pic)
FFHWBaseEncodePicture *base_pic)
{ {
D3D12VAEncodeContext *ctx = avctx->priv_data; D3D12VAEncodeContext *ctx = avctx->priv_data;
D3D12VAEncodePicture *pic = (D3D12VAEncodePicture *)base_pic; D3D12VAEncodePicture *priv = pic->priv;
if (base_pic->encode_issued) if (pic->encode_issued)
d3d12va_encode_discard(avctx, pic); d3d12va_encode_discard(avctx, pic);
if (ctx->codec->free_picture_params) if (ctx->codec->free_picture_params)
ctx->codec->free_picture_params(pic); ctx->codec->free_picture_params(priv);
ff_hw_base_encode_free(base_pic);
av_free(pic);
return 0; return 0;
} }
@ -680,14 +670,14 @@ end:
} }
static int d3d12va_encode_output(AVCodecContext *avctx, static int d3d12va_encode_output(AVCodecContext *avctx,
const FFHWBaseEncodePicture *base_pic, AVPacket *pkt) FFHWBaseEncodePicture *base_pic, AVPacket *pkt)
{ {
FFHWBaseEncodeContext *base_ctx = avctx->priv_data; FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
D3D12VAEncodePicture *pic = (D3D12VAEncodePicture *)base_pic; D3D12VAEncodePicture *pic = base_pic->priv;
AVPacket *pkt_ptr = pkt; AVPacket *pkt_ptr = pkt;
int err; int err;
err = d3d12va_encode_wait(avctx, pic); err = d3d12va_encode_wait(avctx, base_pic);
if (err < 0) if (err < 0)
return err; return err;
@ -1389,7 +1379,9 @@ static int d3d12va_encode_create_recon_frames(AVCodecContext *avctx)
} }
static const FFHWEncodePictureOperation d3d12va_type = { static const FFHWEncodePictureOperation d3d12va_type = {
.alloc = &d3d12va_encode_alloc, .priv_size = sizeof(D3D12VAEncodePicture),
.init = &d3d12va_encode_init,
.issue = &d3d12va_encode_issue, .issue = &d3d12va_encode_issue,

4
libavcodec/d3d12va_encode.h
View File

@ -40,8 +40,6 @@ extern const AVCodecHWConfigInternal *const ff_d3d12va_encode_hw_configs[];
#define D3D12VA_VIDEO_ENC_ASYNC_DEPTH 8 #define D3D12VA_VIDEO_ENC_ASYNC_DEPTH 8
typedef struct D3D12VAEncodePicture { typedef struct D3D12VAEncodePicture {
FFHWBaseEncodePicture base;
int header_size; int header_size;
int aligned_header_size; int aligned_header_size;
@ -303,7 +301,7 @@ typedef struct D3D12VAEncodeType {
int (*init_sequence_params)(AVCodecContext *avctx); int (*init_sequence_params)(AVCodecContext *avctx);
int (*init_picture_params)(AVCodecContext *avctx, int (*init_picture_params)(AVCodecContext *avctx,
D3D12VAEncodePicture *pic); FFHWBaseEncodePicture *base_pic);
void (*free_picture_params)(D3D12VAEncodePicture *pic); void (*free_picture_params)(D3D12VAEncodePicture *pic);

12
libavcodec/d3d12va_encode_hevc.c
View File

@ -748,12 +748,12 @@ static void d3d12va_encode_hevc_free_picture_params(D3D12VAEncodePicture *pic)
} }
static int d3d12va_encode_hevc_init_picture_params(AVCodecContext *avctx, static int d3d12va_encode_hevc_init_picture_params(AVCodecContext *avctx,
D3D12VAEncodePicture *pic) FFHWBaseEncodePicture *base_pic)
{ {
FFHWBaseEncodePicture *base_pic = &pic->base; D3D12VAEncodePicture *pic = base_pic->priv;
D3D12VAEncodeHEVCPicture *hpic = base_pic->priv_data; D3D12VAEncodeHEVCPicture *hpic = base_pic->codec_priv;
FFHWBaseEncodePicture *prev = base_pic->prev; FFHWBaseEncodePicture *prev = base_pic->prev;
D3D12VAEncodeHEVCPicture *hprev = prev ? prev->priv_data : NULL; D3D12VAEncodeHEVCPicture *hprev = prev ? prev->codec_priv : NULL;
D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC *pd = NULL; D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC *pd = NULL;
UINT *ref_list0 = NULL, *ref_list1 = NULL; UINT *ref_list0 = NULL, *ref_list1 = NULL;
int i, idx = 0; int i, idx = 0;
@ -807,7 +807,7 @@ static int d3d12va_encode_hevc_init_picture_params(AVCodecContext *avctx,
D3D12VAEncodeHEVCPicture *href; D3D12VAEncodeHEVCPicture *href;
av_assert0(ref && ref->encode_order < base_pic->encode_order); av_assert0(ref && ref->encode_order < base_pic->encode_order);
href = ref->priv_data; href = ref->codec_priv;
ref_list0[i] = idx; ref_list0[i] = idx;
pd[idx].ReconstructedPictureResourceIndex = idx; pd[idx].ReconstructedPictureResourceIndex = idx;
@ -828,7 +828,7 @@ static int d3d12va_encode_hevc_init_picture_params(AVCodecContext *avctx,
D3D12VAEncodeHEVCPicture *href; D3D12VAEncodeHEVCPicture *href;
av_assert0(ref && ref->encode_order < base_pic->encode_order); av_assert0(ref && ref->encode_order < base_pic->encode_order);
href = ref->priv_data; href = ref->codec_priv;
ref_list1[i] = idx; ref_list1[i] = idx;
pd[idx].ReconstructedPictureResourceIndex = idx; pd[idx].ReconstructedPictureResourceIndex = idx;

39
libavcodec/hw_base_encode.c
View File

@ -27,6 +27,19 @@
#include "avcodec.h" #include "avcodec.h"
#include "hw_base_encode.h" #include "hw_base_encode.h"
static int base_encode_pic_free(FFHWBaseEncodePicture *pic)
{
av_frame_free(&pic->input_image);
av_frame_free(&pic->recon_image);
av_buffer_unref(&pic->opaque_ref);
av_freep(&pic->codec_priv);
av_freep(&pic->priv);
av_free(pic);
return 0;
}
static void hw_base_encode_add_ref(FFHWBaseEncodePicture *pic, static void hw_base_encode_add_ref(FFHWBaseEncodePicture *pic,
FFHWBaseEncodePicture *target, FFHWBaseEncodePicture *target,
int is_ref, int in_dpb, int prev) int is_ref, int in_dpb, int prev)
@ -370,6 +383,7 @@ static int hw_base_encode_clear_old(AVCodecContext *avctx, FFHWBaseEncodeContext
else else
ctx->pic_start = next; ctx->pic_start = next;
ctx->op->free(avctx, pic); ctx->op->free(avctx, pic);
base_encode_pic_free(pic);
} else { } else {
prev = pic; prev = pic;
} }
@ -416,7 +430,7 @@ static int hw_base_encode_send_frame(AVCodecContext *avctx, FFHWBaseEncodeContex
if (err < 0) if (err < 0)
return err; return err;
pic = ctx->op->alloc(avctx, frame); pic = av_mallocz(sizeof(*pic));
if (!pic) if (!pic)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
@ -432,6 +446,12 @@ static int hw_base_encode_send_frame(AVCodecContext *avctx, FFHWBaseEncodeContex
goto fail; goto fail;
} }
pic->priv = av_mallocz(ctx->op->priv_size);
if (!pic->priv) {
err = AVERROR(ENOMEM);
goto fail;
}
if (ctx->input_order == 0 || frame->pict_type == AV_PICTURE_TYPE_I) if (ctx->input_order == 0 || frame->pict_type == AV_PICTURE_TYPE_I)
pic->force_idr = 1; pic->force_idr = 1;
@ -467,6 +487,9 @@ static int hw_base_encode_send_frame(AVCodecContext *avctx, FFHWBaseEncodeContex
ctx->pic_end = pic; ctx->pic_end = pic;
} }
err = ctx->op->init(avctx, pic);
if (err < 0)
goto fail;
} else { } else {
ctx->end_of_stream = 1; ctx->end_of_stream = 1;
@ -480,6 +503,7 @@ static int hw_base_encode_send_frame(AVCodecContext *avctx, FFHWBaseEncodeContex
fail: fail:
ctx->op->free(avctx, pic); ctx->op->free(avctx, pic);
base_encode_pic_free(pic);
return err; return err;
} }
@ -529,7 +553,7 @@ int ff_hw_base_encode_receive_packet(FFHWBaseEncodeContext *ctx,
AVFrame *frame = ctx->frame; AVFrame *frame = ctx->frame;
int err; int err;
av_assert0(ctx->op && ctx->op->alloc && ctx->op->issue && av_assert0(ctx->op && ctx->op->init && ctx->op->issue &&
ctx->op->output && ctx->op->free); ctx->op->output && ctx->op->free);
start: start:
@ -737,17 +761,6 @@ fail:
return err; return err;
} }
int ff_hw_base_encode_free(FFHWBaseEncodePicture *pic)
{
av_frame_free(&pic->input_image);
av_frame_free(&pic->recon_image);
av_buffer_unref(&pic->opaque_ref);
av_freep(&pic->priv_data);
return 0;
}
int ff_hw_base_encode_init(AVCodecContext *avctx, FFHWBaseEncodeContext *ctx) int ff_hw_base_encode_init(AVCodecContext *avctx, FFHWBaseEncodeContext *ctx)
{ {
ctx->log_ctx = (void *)avctx; ctx->log_ctx = (void *)avctx;

22
libavcodec/hw_base_encode.h
View File

@ -59,6 +59,11 @@ enum {
}; };
typedef struct FFHWBaseEncodePicture { typedef struct FFHWBaseEncodePicture {
// API-specific private data
void *priv;
// Codec-specific private data
void *codec_priv;
struct FFHWBaseEncodePicture *next; struct FFHWBaseEncodePicture *next;
int64_t display_order; int64_t display_order;
@ -78,8 +83,6 @@ typedef struct FFHWBaseEncodePicture {
AVFrame *input_image; AVFrame *input_image;
AVFrame *recon_image; AVFrame *recon_image;
void *priv_data;
// Whether this picture is a reference picture. // Whether this picture is a reference picture.
int is_reference; int is_reference;
@ -104,15 +107,16 @@ typedef struct FFHWBaseEncodePicture {
} FFHWBaseEncodePicture; } FFHWBaseEncodePicture;
typedef struct FFHWEncodePictureOperation { typedef struct FFHWEncodePictureOperation {
// Alloc memory for the picture structure and initialize the API-specific internals // Size of API-specific internal picture data
// based of the given frame. size_t priv_size;
FFHWBaseEncodePicture * (*alloc)(AVCodecContext *avctx, const AVFrame *frame); // Initialize API-specific internals
int (*init)(AVCodecContext *avctx, FFHWBaseEncodePicture *pic);
// Issue the picture structure, which will send the frame surface to HW Encode API. // Issue the picture structure, which will send the frame surface to HW Encode API.
int (*issue)(AVCodecContext *avctx, const FFHWBaseEncodePicture *base_pic); int (*issue)(AVCodecContext *avctx, FFHWBaseEncodePicture *pic);
// Get the output AVPacket. // Get the output AVPacket.
int (*output)(AVCodecContext *avctx, const FFHWBaseEncodePicture *base_pic, AVPacket *pkt); int (*output)(AVCodecContext *avctx, FFHWBaseEncodePicture *pic, AVPacket *pkt);
// Free the picture structure. // Free the picture structure.
int (*free)(AVCodecContext *avctx, FFHWBaseEncodePicture *base_pic); int (*free)(AVCodecContext *avctx, FFHWBaseEncodePicture *pic);
} FFHWEncodePictureOperation; } FFHWEncodePictureOperation;
typedef struct FFHWBaseEncodeContext { typedef struct FFHWBaseEncodeContext {
@ -228,8 +232,6 @@ int ff_hw_base_init_gop_structure(FFHWBaseEncodeContext *ctx, AVCodecContext *av
int ff_hw_base_get_recon_format(FFHWBaseEncodeContext *ctx, const void *hwconfig, int ff_hw_base_get_recon_format(FFHWBaseEncodeContext *ctx, const void *hwconfig,
enum AVPixelFormat *fmt); enum AVPixelFormat *fmt);
int ff_hw_base_encode_free(FFHWBaseEncodePicture *pic);
int ff_hw_base_encode_init(AVCodecContext *avctx, FFHWBaseEncodeContext *ctx); int ff_hw_base_encode_init(AVCodecContext *avctx, FFHWBaseEncodeContext *ctx);
int ff_hw_base_encode_close(FFHWBaseEncodeContext *ctx); int ff_hw_base_encode_close(FFHWBaseEncodeContext *ctx);

89
libavcodec/vaapi_encode.c
View File

@ -135,14 +135,13 @@ static int vaapi_encode_make_misc_param_buffer(AVCodecContext *avctx,
buffer, buffer_size); buffer, buffer_size);
} }
static int vaapi_encode_wait(AVCodecContext *avctx, static int vaapi_encode_wait(AVCodecContext *avctx, FFHWBaseEncodePicture *base_pic)
VAAPIEncodePicture *pic)
{ {
#if VA_CHECK_VERSION(1, 9, 0) #if VA_CHECK_VERSION(1, 9, 0)
FFHWBaseEncodeContext *base_ctx = avctx->priv_data; FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
#endif #endif
VAAPIEncodeContext *ctx = avctx->priv_data; VAAPIEncodeContext *ctx = avctx->priv_data;
FFHWBaseEncodePicture *base_pic = &pic->base; VAAPIEncodePicture *pic = base_pic->priv;
VAStatus vas; VAStatus vas;
av_assert0(base_pic->encode_issued); av_assert0(base_pic->encode_issued);
@ -267,11 +266,11 @@ static int vaapi_encode_make_tile_slice(AVCodecContext *avctx,
} }
static int vaapi_encode_issue(AVCodecContext *avctx, static int vaapi_encode_issue(AVCodecContext *avctx,
const FFHWBaseEncodePicture *base_pic) FFHWBaseEncodePicture *base_pic)
{ {
FFHWBaseEncodeContext *base_ctx = avctx->priv_data; FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
VAAPIEncodeContext *ctx = avctx->priv_data; VAAPIEncodeContext *ctx = avctx->priv_data;
VAAPIEncodePicture *pic = (VAAPIEncodePicture*)base_pic; VAAPIEncodePicture *pic = base_pic->priv;
VAAPIEncodeSlice *slice; VAAPIEncodeSlice *slice;
VAStatus vas; VAStatus vas;
int err, i; int err, i;
@ -364,7 +363,7 @@ static int vaapi_encode_issue(AVCodecContext *avctx,
} }
if (ctx->codec->init_picture_params) { if (ctx->codec->init_picture_params) {
err = ctx->codec->init_picture_params(avctx, pic); err = ctx->codec->init_picture_params(avctx, base_pic);
if (err < 0) { if (err < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to initialise picture " av_log(avctx, AV_LOG_ERROR, "Failed to initialise picture "
"parameters: %d.\n", err); "parameters: %d.\n", err);
@ -410,7 +409,7 @@ static int vaapi_encode_issue(AVCodecContext *avctx,
if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_PICTURE && if (ctx->va_packed_headers & VA_ENC_PACKED_HEADER_PICTURE &&
ctx->codec->write_picture_header) { ctx->codec->write_picture_header) {
bit_len = 8 * sizeof(data); bit_len = 8 * sizeof(data);
err = ctx->codec->write_picture_header(avctx, pic, data, &bit_len); err = ctx->codec->write_picture_header(avctx, base_pic, data, &bit_len);
if (err < 0) { if (err < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to write per-picture " av_log(avctx, AV_LOG_ERROR, "Failed to write per-picture "
"header: %d.\n", err); "header: %d.\n", err);
@ -427,7 +426,7 @@ static int vaapi_encode_issue(AVCodecContext *avctx,
for (i = 0;; i++) { for (i = 0;; i++) {
size_t len = sizeof(data); size_t len = sizeof(data);
int type; int type;
err = ctx->codec->write_extra_buffer(avctx, pic, i, &type, err = ctx->codec->write_extra_buffer(avctx, base_pic, i, &type,
data, &len); data, &len);
if (err == AVERROR_EOF) if (err == AVERROR_EOF)
break; break;
@ -449,7 +448,7 @@ static int vaapi_encode_issue(AVCodecContext *avctx,
for (i = 0;; i++) { for (i = 0;; i++) {
int type; int type;
bit_len = 8 * sizeof(data); bit_len = 8 * sizeof(data);
err = ctx->codec->write_extra_header(avctx, pic, i, &type, err = ctx->codec->write_extra_header(avctx, base_pic, i, &type,
data, &bit_len); data, &bit_len);
if (err == AVERROR_EOF) if (err == AVERROR_EOF)
break; break;
@ -493,7 +492,7 @@ static int vaapi_encode_issue(AVCodecContext *avctx,
} }
if (ctx->codec->init_slice_params) { if (ctx->codec->init_slice_params) {
err = ctx->codec->init_slice_params(avctx, pic, slice); err = ctx->codec->init_slice_params(avctx, base_pic, slice);
if (err < 0) { if (err < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to initialise slice " av_log(avctx, AV_LOG_ERROR, "Failed to initialise slice "
"parameters: %d.\n", err); "parameters: %d.\n", err);
@ -773,15 +772,15 @@ end:
} }
static int vaapi_encode_output(AVCodecContext *avctx, static int vaapi_encode_output(AVCodecContext *avctx,
const FFHWBaseEncodePicture *base_pic, AVPacket *pkt) FFHWBaseEncodePicture *base_pic, AVPacket *pkt)
{ {
FFHWBaseEncodeContext *base_ctx = avctx->priv_data; FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
VAAPIEncodeContext *ctx = avctx->priv_data; VAAPIEncodeContext *ctx = avctx->priv_data;
VAAPIEncodePicture *pic = (VAAPIEncodePicture*)base_pic; VAAPIEncodePicture *pic = base_pic->priv;
AVPacket *pkt_ptr = pkt; AVPacket *pkt_ptr = pkt;
int err; int err;
err = vaapi_encode_wait(avctx, pic); err = vaapi_encode_wait(avctx, base_pic);
if (err < 0) if (err < 0)
return err; return err;
@ -820,12 +819,11 @@ end:
return err; return err;
} }
static int vaapi_encode_discard(AVCodecContext *avctx, static int vaapi_encode_discard(AVCodecContext *avctx, FFHWBaseEncodePicture *base_pic)
VAAPIEncodePicture *pic)
{ {
FFHWBaseEncodePicture *base_pic = &pic->base; VAAPIEncodePicture *pic = base_pic->priv;
vaapi_encode_wait(avctx, pic); vaapi_encode_wait(avctx, base_pic);
if (pic->output_buffer_ref) { if (pic->output_buffer_ref) {
av_log(avctx, AV_LOG_DEBUG, "Discard output for pic " av_log(avctx, AV_LOG_DEBUG, "Discard output for pic "
@ -839,56 +837,45 @@ static int vaapi_encode_discard(AVCodecContext *avctx,
return 0; return 0;
} }
static FFHWBaseEncodePicture *vaapi_encode_alloc(AVCodecContext *avctx, static int vaapi_encode_init(AVCodecContext *avctx, FFHWBaseEncodePicture *pic)
const AVFrame *frame)
{ {
VAAPIEncodeContext *ctx = avctx->priv_data; VAAPIEncodeContext *ctx = avctx->priv_data;
VAAPIEncodePicture *pic; VAAPIEncodePicture *priv = pic->priv;
AVFrame *frame = pic->input_image;
pic = av_mallocz(sizeof(*pic));
if (!pic)
return NULL;
if (ctx->codec->picture_priv_data_size > 0) { if (ctx->codec->picture_priv_data_size > 0) {
pic->base.priv_data = av_mallocz(ctx->codec->picture_priv_data_size); pic->codec_priv = av_mallocz(ctx->codec->picture_priv_data_size);
if (!pic->base.priv_data) { if (!pic->codec_priv)
av_freep(&pic); return AVERROR(ENOMEM);
return NULL;
}
} }
pic->input_surface = (VASurfaceID)(uintptr_t)frame->data[3]; priv->input_surface = (VASurfaceID)(uintptr_t)frame->data[3];
pic->recon_surface = VA_INVALID_ID; priv->recon_surface = VA_INVALID_ID;
pic->output_buffer = VA_INVALID_ID; priv->output_buffer = VA_INVALID_ID;
return &pic->base; return 0;
} }
static int vaapi_encode_free(AVCodecContext *avctx, static int vaapi_encode_free(AVCodecContext *avctx, FFHWBaseEncodePicture *pic)
FFHWBaseEncodePicture *base_pic)
{ {
VAAPIEncodePicture *pic = (VAAPIEncodePicture*)base_pic; VAAPIEncodePicture *priv = pic->priv;
int i; int i;
if (base_pic->encode_issued) if (pic->encode_issued)
vaapi_encode_discard(avctx, pic); vaapi_encode_discard(avctx, pic);
if (pic->slices) { if (priv->slices) {
for (i = 0; i < pic->nb_slices; i++) for (i = 0; i < priv->nb_slices; i++)
av_freep(&pic->slices[i].codec_slice_params); av_freep(&priv->slices[i].codec_slice_params);
} }
ff_hw_base_encode_free(base_pic); av_freep(&priv->param_buffers);
av_freep(&priv->slices);
av_freep(&pic->param_buffers);
av_freep(&pic->slices);
// Output buffer should already be destroyed. // Output buffer should already be destroyed.
av_assert0(pic->output_buffer == VA_INVALID_ID); av_assert0(priv->output_buffer == VA_INVALID_ID);
av_freep(&pic->codec_picture_params); av_freep(&priv->codec_picture_params);
av_freep(&pic->roi); av_freep(&priv->roi);
av_free(pic);
return 0; return 0;
} }
@ -2090,7 +2077,9 @@ static av_cold int vaapi_encode_create_recon_frames(AVCodecContext *avctx)
} }
static const FFHWEncodePictureOperation vaapi_op = { static const FFHWEncodePictureOperation vaapi_op = {
.alloc = &vaapi_encode_alloc, .priv_size = sizeof(VAAPIEncodePicture),
.init = &vaapi_encode_init,
.issue = &vaapi_encode_issue, .issue = &vaapi_encode_issue,

12
libavcodec/vaapi_encode.h
View File

@ -63,8 +63,6 @@ typedef struct VAAPIEncodeSlice {
} VAAPIEncodeSlice; } VAAPIEncodeSlice;
typedef struct VAAPIEncodePicture { typedef struct VAAPIEncodePicture {
FFHWBaseEncodePicture base;
#if VA_CHECK_VERSION(1, 0, 0) #if VA_CHECK_VERSION(1, 0, 0)
// ROI regions. // ROI regions.
VAEncROI *roi; VAEncROI *roi;
@ -301,9 +299,9 @@ typedef struct VAAPIEncodeType {
// Fill the parameter structures. // Fill the parameter structures.
int (*init_sequence_params)(AVCodecContext *avctx); int (*init_sequence_params)(AVCodecContext *avctx);
int (*init_picture_params)(AVCodecContext *avctx, int (*init_picture_params)(AVCodecContext *avctx,
VAAPIEncodePicture *pic); FFHWBaseEncodePicture *pic);
int (*init_slice_params)(AVCodecContext *avctx, int (*init_slice_params)(AVCodecContext *avctx,
VAAPIEncodePicture *pic, FFHWBaseEncodePicture *pic,
VAAPIEncodeSlice *slice); VAAPIEncodeSlice *slice);
// The type used by the packed header: this should look like // The type used by the packed header: this should look like
@ -318,7 +316,7 @@ typedef struct VAAPIEncodeType {
int (*write_sequence_header)(AVCodecContext *avctx, int (*write_sequence_header)(AVCodecContext *avctx,
char *data, size_t *data_len); char *data, size_t *data_len);
int (*write_picture_header)(AVCodecContext *avctx, int (*write_picture_header)(AVCodecContext *avctx,
VAAPIEncodePicture *pic, FFHWBaseEncodePicture *pic,
char *data, size_t *data_len); char *data, size_t *data_len);
int (*write_slice_header)(AVCodecContext *avctx, int (*write_slice_header)(AVCodecContext *avctx,
VAAPIEncodePicture *pic, VAAPIEncodePicture *pic,
@ -330,7 +328,7 @@ typedef struct VAAPIEncodeType {
// with increasing index argument until AVERROR_EOF is // with increasing index argument until AVERROR_EOF is
// returned. // returned.
int (*write_extra_buffer)(AVCodecContext *avctx, int (*write_extra_buffer)(AVCodecContext *avctx,
VAAPIEncodePicture *pic, FFHWBaseEncodePicture *pic,
int index, int *type, int index, int *type,
char *data, size_t *data_len); char *data, size_t *data_len);
@ -338,7 +336,7 @@ typedef struct VAAPIEncodeType {
// with increasing index argument until AVERROR_EOF is // with increasing index argument until AVERROR_EOF is
// returned. // returned.
int (*write_extra_header)(AVCodecContext *avctx, int (*write_extra_header)(AVCodecContext *avctx,
VAAPIEncodePicture *pic, FFHWBaseEncodePicture *pic,
int index, int *type, int index, int *type,
char *data, size_t *data_len); char *data, size_t *data_len);
} VAAPIEncodeType; } VAAPIEncodeType;

26
libavcodec/vaapi_encode_av1.c
View File

@ -466,12 +466,12 @@ end:
} }
static int vaapi_encode_av1_init_picture_params(AVCodecContext *avctx, static int vaapi_encode_av1_init_picture_params(AVCodecContext *avctx,
VAAPIEncodePicture *vaapi_pic) FFHWBaseEncodePicture *pic)
{ {
VAAPIEncodeContext *ctx = avctx->priv_data; VAAPIEncodeContext *ctx = avctx->priv_data;
VAAPIEncodeAV1Context *priv = avctx->priv_data; VAAPIEncodeAV1Context *priv = avctx->priv_data;
const FFHWBaseEncodePicture *pic = &vaapi_pic->base; VAAPIEncodePicture *vaapi_pic = pic->priv;
VAAPIEncodeAV1Picture *hpic = pic->priv_data; VAAPIEncodeAV1Picture *hpic = pic->codec_priv;
AV1RawOBU *fh_obu = &priv->fh; AV1RawOBU *fh_obu = &priv->fh;
AV1RawFrameHeader *fh = &fh_obu->obu.frame.header; AV1RawFrameHeader *fh = &fh_obu->obu.frame.header;
VAEncPictureParameterBufferAV1 *vpic = vaapi_pic->codec_picture_params; VAEncPictureParameterBufferAV1 *vpic = vaapi_pic->codec_picture_params;
@ -503,7 +503,7 @@ static int vaapi_encode_av1_init_picture_params(AVCodecContext *avctx,
fh->frame_type = AV1_FRAME_INTER; fh->frame_type = AV1_FRAME_INTER;
fh->base_q_idx = priv->q_idx_p; fh->base_q_idx = priv->q_idx_p;
ref = pic->refs[0][pic->nb_refs[0] - 1]; ref = pic->refs[0][pic->nb_refs[0] - 1];
href = ref->priv_data; href = ref->codec_priv;
hpic->slot = !href->slot; hpic->slot = !href->slot;
hpic->last_idr_frame = href->last_idr_frame; hpic->last_idr_frame = href->last_idr_frame;
fh->refresh_frame_flags = 1 << hpic->slot; fh->refresh_frame_flags = 1 << hpic->slot;
@ -519,7 +519,7 @@ static int vaapi_encode_av1_init_picture_params(AVCodecContext *avctx,
/** set the 2nd nearest frame in L0 as Golden frame. */ /** set the 2nd nearest frame in L0 as Golden frame. */
if (pic->nb_refs[0] > 1) { if (pic->nb_refs[0] > 1) {
ref = pic->refs[0][pic->nb_refs[0] - 2]; ref = pic->refs[0][pic->nb_refs[0] - 2];
href = ref->priv_data; href = ref->codec_priv;
fh->ref_frame_idx[3] = href->slot; fh->ref_frame_idx[3] = href->slot;
fh->ref_order_hint[href->slot] = ref->display_order - href->last_idr_frame; fh->ref_order_hint[href->slot] = ref->display_order - href->last_idr_frame;
vpic->ref_frame_ctrl_l0.fields.search_idx1 = AV1_REF_FRAME_GOLDEN; vpic->ref_frame_ctrl_l0.fields.search_idx1 = AV1_REF_FRAME_GOLDEN;
@ -540,7 +540,7 @@ static int vaapi_encode_av1_init_picture_params(AVCodecContext *avctx,
vpic->ref_frame_ctrl_l1.fields.search_idx0 = AV1_REF_FRAME_BWDREF; vpic->ref_frame_ctrl_l1.fields.search_idx0 = AV1_REF_FRAME_BWDREF;
ref = pic->refs[0][pic->nb_refs[0] - 1]; ref = pic->refs[0][pic->nb_refs[0] - 1];
href = ref->priv_data; href = ref->codec_priv;
hpic->last_idr_frame = href->last_idr_frame; hpic->last_idr_frame = href->last_idr_frame;
fh->primary_ref_frame = href->slot; fh->primary_ref_frame = href->slot;
fh->ref_order_hint[href->slot] = ref->display_order - href->last_idr_frame; fh->ref_order_hint[href->slot] = ref->display_order - href->last_idr_frame;
@ -549,7 +549,7 @@ static int vaapi_encode_av1_init_picture_params(AVCodecContext *avctx,
} }
ref = pic->refs[1][pic->nb_refs[1] - 1]; ref = pic->refs[1][pic->nb_refs[1] - 1];
href = ref->priv_data; href = ref->codec_priv;
fh->ref_order_hint[href->slot] = ref->display_order - href->last_idr_frame; fh->ref_order_hint[href->slot] = ref->display_order - href->last_idr_frame;
for (i = AV1_REF_FRAME_GOLDEN; i < AV1_REFS_PER_FRAME; i++) { for (i = AV1_REF_FRAME_GOLDEN; i < AV1_REFS_PER_FRAME; i++) {
fh->ref_frame_idx[i] = href->slot; fh->ref_frame_idx[i] = href->slot;
@ -634,7 +634,7 @@ static int vaapi_encode_av1_init_picture_params(AVCodecContext *avctx,
for (int j = 0; j < pic->nb_refs[i]; j++) { for (int j = 0; j < pic->nb_refs[i]; j++) {
FFHWBaseEncodePicture *ref_pic = pic->refs[i][j]; FFHWBaseEncodePicture *ref_pic = pic->refs[i][j];
slot = ((VAAPIEncodeAV1Picture*)ref_pic->priv_data)->slot; slot = ((VAAPIEncodeAV1Picture*)ref_pic->codec_priv)->slot;
av_assert0(vpic->reference_frames[slot] == VA_INVALID_SURFACE); av_assert0(vpic->reference_frames[slot] == VA_INVALID_SURFACE);
vpic->reference_frames[slot] = ((VAAPIEncodePicture *)ref_pic)->recon_surface; vpic->reference_frames[slot] = ((VAAPIEncodePicture *)ref_pic)->recon_surface;
@ -732,7 +732,7 @@ end:
} }
static int vaapi_encode_av1_init_slice_params(AVCodecContext *avctx, static int vaapi_encode_av1_init_slice_params(AVCodecContext *avctx,
VAAPIEncodePicture *pic, FFHWBaseEncodePicture *base,
VAAPIEncodeSlice *slice) VAAPIEncodeSlice *slice)
{ {
VAAPIEncodeAV1Context *priv = avctx->priv_data; VAAPIEncodeAV1Context *priv = avctx->priv_data;
@ -754,7 +754,7 @@ static int vaapi_encode_av1_init_slice_params(AVCodecContext *avctx,
} }
static int vaapi_encode_av1_write_picture_header(AVCodecContext *avctx, static int vaapi_encode_av1_write_picture_header(AVCodecContext *avctx,
VAAPIEncodePicture *vaapi_pic, FFHWBaseEncodePicture *pic,
char *data, size_t *data_len) char *data, size_t *data_len)
{ {
VAAPIEncodeAV1Context *priv = avctx->priv_data; VAAPIEncodeAV1Context *priv = avctx->priv_data;
@ -762,7 +762,7 @@ static int vaapi_encode_av1_write_picture_header(AVCodecContext *avctx,
CodedBitstreamAV1Context *cbctx = priv->cbc->priv_data; CodedBitstreamAV1Context *cbctx = priv->cbc->priv_data;
AV1RawOBU *fh_obu = &priv->fh; AV1RawOBU *fh_obu = &priv->fh;
AV1RawFrameHeader *rep_fh = &fh_obu->obu.frame_header; AV1RawFrameHeader *rep_fh = &fh_obu->obu.frame_header;
const FFHWBaseEncodePicture *pic = &vaapi_pic->base; VAAPIEncodePicture *vaapi_pic = pic->priv;
VAAPIEncodeAV1Picture *href; VAAPIEncodeAV1Picture *href;
int ret = 0; int ret = 0;
@ -770,7 +770,7 @@ static int vaapi_encode_av1_write_picture_header(AVCodecContext *avctx,
/** Pack repeat frame header. */ /** Pack repeat frame header. */
if (pic->display_order > pic->encode_order) { if (pic->display_order > pic->encode_order) {
memset(fh_obu, 0, sizeof(*fh_obu)); memset(fh_obu, 0, sizeof(*fh_obu));
href = pic->refs[0][pic->nb_refs[0] - 1]->priv_data; href = pic->refs[0][pic->nb_refs[0] - 1]->codec_priv;
fh_obu->header.obu_type = AV1_OBU_FRAME_HEADER; fh_obu->header.obu_type = AV1_OBU_FRAME_HEADER;
fh_obu->header.obu_has_size_field = 1; fh_obu->header.obu_has_size_field = 1;
@ -804,7 +804,7 @@ end:
} }
static int vaapi_encode_av1_write_extra_header(AVCodecContext *avctx, static int vaapi_encode_av1_write_extra_header(AVCodecContext *avctx,
VAAPIEncodePicture *pic, FFHWBaseEncodePicture *base_pic,
int index, int *type, int index, int *type,
char *data, size_t *data_len) char *data, size_t *data_len)
{ {

67
libavcodec/vaapi_encode_h264.c
View File

@ -209,7 +209,7 @@ fail:
} }
static int vaapi_encode_h264_write_extra_header(AVCodecContext *avctx, static int vaapi_encode_h264_write_extra_header(AVCodecContext *avctx,
VAAPIEncodePicture *pic, FFHWBaseEncodePicture *base,
int index, int *type, int index, int *type,
char *data, size_t *data_len) char *data, size_t *data_len)
{ {
@ -233,7 +233,7 @@ static int vaapi_encode_h264_write_extra_header(AVCodecContext *avctx,
goto fail; goto fail;
} }
if (priv->sei_needed & SEI_TIMING) { if (priv->sei_needed & SEI_TIMING) {
if (pic->base.type == FF_HW_PICTURE_TYPE_IDR) { if (base->type == FF_HW_PICTURE_TYPE_IDR) {
err = ff_cbs_sei_add_message(priv->cbc, au, 1, err = ff_cbs_sei_add_message(priv->cbc, au, 1,
SEI_TYPE_BUFFERING_PERIOD, SEI_TYPE_BUFFERING_PERIOD,
&priv->sei_buffering_period, NULL); &priv->sei_buffering_period, NULL);
@ -620,14 +620,14 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
} }
static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx, static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx,
VAAPIEncodePicture *vaapi_pic) FFHWBaseEncodePicture *pic)
{ {
FFHWBaseEncodeContext *base_ctx = avctx->priv_data; FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
VAAPIEncodeH264Context *priv = avctx->priv_data; VAAPIEncodeH264Context *priv = avctx->priv_data;
const FFHWBaseEncodePicture *pic = &vaapi_pic->base; VAAPIEncodePicture *vaapi_pic = pic->priv;
VAAPIEncodeH264Picture *hpic = pic->priv_data; VAAPIEncodeH264Picture *hpic = pic->codec_priv;
FFHWBaseEncodePicture *prev = pic->prev; FFHWBaseEncodePicture *prev = pic->prev;
VAAPIEncodeH264Picture *hprev = prev ? prev->priv_data : NULL; VAAPIEncodeH264Picture *hprev = prev ? prev->codec_priv : NULL;
VAEncPictureParameterBufferH264 *vpic = vaapi_pic->codec_picture_params; VAEncPictureParameterBufferH264 *vpic = vaapi_pic->codec_picture_params;
int i, j = 0; int i, j = 0;
@ -736,10 +736,10 @@ static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx,
VAAPIEncodeH264Picture *href; VAAPIEncodeH264Picture *href;
av_assert0(ref && ref->encode_order < pic->encode_order); av_assert0(ref && ref->encode_order < pic->encode_order);
href = ref->priv_data; href = ref->codec_priv;
vpic->ReferenceFrames[j++] = (VAPictureH264) { vpic->ReferenceFrames[j++] = (VAPictureH264) {
.picture_id = ((VAAPIEncodePicture *)ref)->recon_surface, .picture_id = ((VAAPIEncodePicture *)ref->priv)->recon_surface,
.frame_idx = href->frame_num, .frame_idx = href->frame_num,
.flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE, .flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE,
.TopFieldOrderCnt = href->pic_order_cnt, .TopFieldOrderCnt = href->pic_order_cnt,
@ -766,37 +766,36 @@ static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx,
} }
static void vaapi_encode_h264_default_ref_pic_list(AVCodecContext *avctx, static void vaapi_encode_h264_default_ref_pic_list(AVCodecContext *avctx,
VAAPIEncodePicture *vaapi_pic, FFHWBaseEncodePicture *pic,
VAAPIEncodePicture **rpl0, FFHWBaseEncodePicture **rpl0,
VAAPIEncodePicture **rpl1, FFHWBaseEncodePicture **rpl1,
int *rpl_size) int *rpl_size)
{ {
FFHWBaseEncodePicture *pic = &vaapi_pic->base;
FFHWBaseEncodePicture *prev; FFHWBaseEncodePicture *prev;
VAAPIEncodeH264Picture *hp, *hn, *hc; VAAPIEncodeH264Picture *hp, *hn, *hc;
int i, j, n = 0; int i, j, n = 0;
prev = pic->prev; prev = pic->prev;
av_assert0(prev); av_assert0(prev);
hp = pic->priv_data; hp = pic->codec_priv;
for (i = 0; i < pic->prev->nb_dpb_pics; i++) { for (i = 0; i < pic->prev->nb_dpb_pics; i++) {
hn = prev->dpb[i]->priv_data; hn = prev->dpb[i]->codec_priv;
av_assert0(hn->frame_num < hp->frame_num); av_assert0(hn->frame_num < hp->frame_num);
if (pic->type == FF_HW_PICTURE_TYPE_P) { if (pic->type == FF_HW_PICTURE_TYPE_P) {
for (j = n; j > 0; j--) { for (j = n; j > 0; j--) {
hc = rpl0[j - 1]->base.priv_data; hc = rpl0[j - 1]->codec_priv;
av_assert0(hc->frame_num != hn->frame_num); av_assert0(hc->frame_num != hn->frame_num);
if (hc->frame_num > hn->frame_num) if (hc->frame_num > hn->frame_num)
break; break;
rpl0[j] = rpl0[j - 1]; rpl0[j] = rpl0[j - 1];
} }
rpl0[j] = (VAAPIEncodePicture *)prev->dpb[i]; rpl0[j] = prev->dpb[i];
} else if (pic->type == FF_HW_PICTURE_TYPE_B) { } else if (pic->type == FF_HW_PICTURE_TYPE_B) {
for (j = n; j > 0; j--) { for (j = n; j > 0; j--) {
hc = rpl0[j - 1]->base.priv_data; hc = rpl0[j - 1]->codec_priv;
av_assert0(hc->pic_order_cnt != hp->pic_order_cnt); av_assert0(hc->pic_order_cnt != hp->pic_order_cnt);
if (hc->pic_order_cnt < hp->pic_order_cnt) { if (hc->pic_order_cnt < hp->pic_order_cnt) {
if (hn->pic_order_cnt > hp->pic_order_cnt || if (hn->pic_order_cnt > hp->pic_order_cnt ||
@ -808,10 +807,10 @@ static void vaapi_encode_h264_default_ref_pic_list(AVCodecContext *avctx,
} }
rpl0[j] = rpl0[j - 1]; rpl0[j] = rpl0[j - 1];
} }
rpl0[j] = (VAAPIEncodePicture *)prev->dpb[i]; rpl0[j] = prev->dpb[i];
for (j = n; j > 0; j--) { for (j = n; j > 0; j--) {
hc = rpl1[j - 1]->base.priv_data; hc = rpl1[j - 1]->codec_priv;
av_assert0(hc->pic_order_cnt != hp->pic_order_cnt); av_assert0(hc->pic_order_cnt != hp->pic_order_cnt);
if (hc->pic_order_cnt > hp->pic_order_cnt) { if (hc->pic_order_cnt > hp->pic_order_cnt) {
if (hn->pic_order_cnt < hp->pic_order_cnt || if (hn->pic_order_cnt < hp->pic_order_cnt ||
@ -823,7 +822,7 @@ static void vaapi_encode_h264_default_ref_pic_list(AVCodecContext *avctx,
} }
rpl1[j] = rpl1[j - 1]; rpl1[j] = rpl1[j - 1];
} }
rpl1[j] = (VAAPIEncodePicture *)prev->dpb[i]; rpl1[j] = prev->dpb[i];
} }
++n; ++n;
@ -835,7 +834,7 @@ static void vaapi_encode_h264_default_ref_pic_list(AVCodecContext *avctx,
break; break;
} }
if (i == n) if (i == n)
FFSWAP(VAAPIEncodePicture*, rpl1[0], rpl1[1]); FFSWAP(FFHWBaseEncodePicture *, rpl1[0], rpl1[1]);
} }
if (pic->type == FF_HW_PICTURE_TYPE_P || if (pic->type == FF_HW_PICTURE_TYPE_P ||
@ -843,7 +842,7 @@ static void vaapi_encode_h264_default_ref_pic_list(AVCodecContext *avctx,
av_log(avctx, AV_LOG_DEBUG, "Default RefPicList0 for fn=%d/poc=%d:", av_log(avctx, AV_LOG_DEBUG, "Default RefPicList0 for fn=%d/poc=%d:",
hp->frame_num, hp->pic_order_cnt); hp->frame_num, hp->pic_order_cnt);
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
hn = rpl0[i]->base.priv_data; hn = rpl0[i]->codec_priv;
av_log(avctx, AV_LOG_DEBUG, " fn=%d/poc=%d", av_log(avctx, AV_LOG_DEBUG, " fn=%d/poc=%d",
hn->frame_num, hn->pic_order_cnt); hn->frame_num, hn->pic_order_cnt);
} }
@ -853,7 +852,7 @@ static void vaapi_encode_h264_default_ref_pic_list(AVCodecContext *avctx,
av_log(avctx, AV_LOG_DEBUG, "Default RefPicList1 for fn=%d/poc=%d:", av_log(avctx, AV_LOG_DEBUG, "Default RefPicList1 for fn=%d/poc=%d:",
hp->frame_num, hp->pic_order_cnt); hp->frame_num, hp->pic_order_cnt);
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
hn = rpl1[i]->base.priv_data; hn = rpl1[i]->codec_priv;
av_log(avctx, AV_LOG_DEBUG, " fn=%d/poc=%d", av_log(avctx, AV_LOG_DEBUG, " fn=%d/poc=%d",
hn->frame_num, hn->pic_order_cnt); hn->frame_num, hn->pic_order_cnt);
} }
@ -864,12 +863,12 @@ static void vaapi_encode_h264_default_ref_pic_list(AVCodecContext *avctx,
} }
static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx, static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx,
VAAPIEncodePicture *vaapi_pic, FFHWBaseEncodePicture *pic,
VAAPIEncodeSlice *slice) VAAPIEncodeSlice *slice)
{ {
VAAPIEncodeH264Context *priv = avctx->priv_data; VAAPIEncodeH264Context *priv = avctx->priv_data;
const FFHWBaseEncodePicture *pic = &vaapi_pic->base; VAAPIEncodePicture *vaapi_pic = pic->priv;
VAAPIEncodeH264Picture *hpic = pic->priv_data; VAAPIEncodeH264Picture *hpic = pic->codec_priv;
FFHWBaseEncodePicture *prev = pic->prev; FFHWBaseEncodePicture *prev = pic->prev;
H264RawSPS *sps = &priv->raw_sps; H264RawSPS *sps = &priv->raw_sps;
H264RawPPS *pps = &priv->raw_pps; H264RawPPS *pps = &priv->raw_pps;
@ -931,7 +930,7 @@ static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx,
} else { } else {
sh->adaptive_ref_pic_marking_mode_flag = 1; sh->adaptive_ref_pic_marking_mode_flag = 1;
for (i = 0; i < discard; i++) { for (i = 0; i < discard; i++) {
VAAPIEncodeH264Picture *old = discard_list[i]->priv_data; VAAPIEncodeH264Picture *old = discard_list[i]->codec_priv;
av_assert0(old->frame_num < hpic->frame_num); av_assert0(old->frame_num < hpic->frame_num);
sh->mmco[i].memory_management_control_operation = 1; sh->mmco[i].memory_management_control_operation = 1;
sh->mmco[i].difference_of_pic_nums_minus1 = sh->mmco[i].difference_of_pic_nums_minus1 =
@ -944,11 +943,11 @@ static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx,
// If the intended references are not the first entries of RefPicListN // If the intended references are not the first entries of RefPicListN
// by default, use ref-pic-list-modification to move them there. // by default, use ref-pic-list-modification to move them there.
if (pic->type == FF_HW_PICTURE_TYPE_P || pic->type == FF_HW_PICTURE_TYPE_B) { if (pic->type == FF_HW_PICTURE_TYPE_P || pic->type == FF_HW_PICTURE_TYPE_B) {
VAAPIEncodePicture *def_l0[MAX_DPB_SIZE], *def_l1[MAX_DPB_SIZE]; FFHWBaseEncodePicture *def_l0[MAX_DPB_SIZE], *def_l1[MAX_DPB_SIZE];
VAAPIEncodeH264Picture *href; VAAPIEncodeH264Picture *href;
int n; int n;
vaapi_encode_h264_default_ref_pic_list(avctx, vaapi_pic, vaapi_encode_h264_default_ref_pic_list(avctx, pic,
def_l0, def_l1, &n); def_l0, def_l1, &n);
if (pic->type == FF_HW_PICTURE_TYPE_P) { if (pic->type == FF_HW_PICTURE_TYPE_P) {
@ -963,7 +962,7 @@ static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx,
if (need_rplm) { if (need_rplm) {
int pic_num = hpic->frame_num; int pic_num = hpic->frame_num;
for (i = 0; i < pic->nb_refs[0]; i++) { for (i = 0; i < pic->nb_refs[0]; i++) {
href = pic->refs[0][i]->priv_data; href = pic->refs[0][i]->codec_priv;
av_assert0(href->frame_num != pic_num); av_assert0(href->frame_num != pic_num);
if (href->frame_num < pic_num) { if (href->frame_num < pic_num) {
sh->rplm_l0[i].modification_of_pic_nums_idc = 0; sh->rplm_l0[i].modification_of_pic_nums_idc = 0;
@ -984,7 +983,7 @@ static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx,
int n0 = 0, n1 = 0; int n0 = 0, n1 = 0;
for (i = 0; i < pic->nb_refs[0]; i++) { for (i = 0; i < pic->nb_refs[0]; i++) {
av_assert0(pic->refs[0][i]); av_assert0(pic->refs[0][i]);
href = pic->refs[0][i]->priv_data; href = pic->refs[0][i]->codec_priv;
av_assert0(href->pic_order_cnt < hpic->pic_order_cnt); av_assert0(href->pic_order_cnt < hpic->pic_order_cnt);
if (pic->refs[0][i] != (FFHWBaseEncodePicture *)def_l0[n0]) if (pic->refs[0][i] != (FFHWBaseEncodePicture *)def_l0[n0])
need_rplm_l0 = 1; need_rplm_l0 = 1;
@ -993,7 +992,7 @@ static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx,
for (i = 0; i < pic->nb_refs[1]; i++) { for (i = 0; i < pic->nb_refs[1]; i++) {
av_assert0(pic->refs[1][i]); av_assert0(pic->refs[1][i]);
href = pic->refs[1][i]->priv_data; href = pic->refs[1][i]->codec_priv;
av_assert0(href->pic_order_cnt > hpic->pic_order_cnt); av_assert0(href->pic_order_cnt > hpic->pic_order_cnt);
if (pic->refs[1][i] != (FFHWBaseEncodePicture *)def_l1[n1]) if (pic->refs[1][i] != (FFHWBaseEncodePicture *)def_l1[n1])
need_rplm_l1 = 1; need_rplm_l1 = 1;
@ -1004,7 +1003,7 @@ static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx,
if (need_rplm_l0) { if (need_rplm_l0) {
int pic_num = hpic->frame_num; int pic_num = hpic->frame_num;
for (i = j = 0; i < pic->nb_refs[0]; i++) { for (i = j = 0; i < pic->nb_refs[0]; i++) {
href = pic->refs[0][i]->priv_data; href = pic->refs[0][i]->codec_priv;
av_assert0(href->frame_num != pic_num); av_assert0(href->frame_num != pic_num);
if (href->frame_num < pic_num) { if (href->frame_num < pic_num) {
sh->rplm_l0[j].modification_of_pic_nums_idc = 0; sh->rplm_l0[j].modification_of_pic_nums_idc = 0;
@ -1026,7 +1025,7 @@ static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx,
if (need_rplm_l1) { if (need_rplm_l1) {
int pic_num = hpic->frame_num; int pic_num = hpic->frame_num;
for (i = j = 0; i < pic->nb_refs[1]; i++) { for (i = j = 0; i < pic->nb_refs[1]; i++) {
href = pic->refs[1][i]->priv_data; href = pic->refs[1][i]->codec_priv;
av_assert0(href->frame_num != pic_num); av_assert0(href->frame_num != pic_num);
if (href->frame_num < pic_num) { if (href->frame_num < pic_num) {
sh->rplm_l1[j].modification_of_pic_nums_idc = 0; sh->rplm_l1[j].modification_of_pic_nums_idc = 0;

24
libavcodec/vaapi_encode_h265.c
View File

@ -200,7 +200,7 @@ fail:
} }
static int vaapi_encode_h265_write_extra_header(AVCodecContext *avctx, static int vaapi_encode_h265_write_extra_header(AVCodecContext *avctx,
VAAPIEncodePicture *pic, FFHWBaseEncodePicture *base,
int index, int *type, int index, int *type,
char *data, size_t *data_len) char *data, size_t *data_len)
{ {
@ -757,14 +757,14 @@ static int vaapi_encode_h265_init_sequence_params(AVCodecContext *avctx)
} }
static int vaapi_encode_h265_init_picture_params(AVCodecContext *avctx, static int vaapi_encode_h265_init_picture_params(AVCodecContext *avctx,
VAAPIEncodePicture *vaapi_pic) FFHWBaseEncodePicture *pic)
{ {
FFHWBaseEncodeContext *base_ctx = avctx->priv_data; FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
VAAPIEncodeH265Context *priv = avctx->priv_data; VAAPIEncodeH265Context *priv = avctx->priv_data;
FFHWBaseEncodePicture *pic = &vaapi_pic->base; VAAPIEncodePicture *vaapi_pic = pic->priv;
VAAPIEncodeH265Picture *hpic = pic->priv_data; VAAPIEncodeH265Picture *hpic = pic->codec_priv;
FFHWBaseEncodePicture *prev = pic->prev; FFHWBaseEncodePicture *prev = pic->prev;
VAAPIEncodeH265Picture *hprev = prev ? prev->priv_data : NULL; VAAPIEncodeH265Picture *hprev = prev ? prev->codec_priv : NULL;
VAEncPictureParameterBufferHEVC *vpic = vaapi_pic->codec_picture_params; VAEncPictureParameterBufferHEVC *vpic = vaapi_pic->codec_picture_params;
int i, j = 0; int i, j = 0;
@ -923,10 +923,10 @@ static int vaapi_encode_h265_init_picture_params(AVCodecContext *avctx,
VAAPIEncodeH265Picture *href; VAAPIEncodeH265Picture *href;
av_assert0(ref && ref->encode_order < pic->encode_order); av_assert0(ref && ref->encode_order < pic->encode_order);
href = ref->priv_data; href = ref->codec_priv;
vpic->reference_frames[j++] = (VAPictureHEVC) { vpic->reference_frames[j++] = (VAPictureHEVC) {
.picture_id = ((VAAPIEncodePicture *)ref)->recon_surface, .picture_id = ((VAAPIEncodePicture *)ref->priv)->recon_surface,
.pic_order_cnt = href->pic_order_cnt, .pic_order_cnt = href->pic_order_cnt,
.flags = (ref->display_order < pic->display_order ? .flags = (ref->display_order < pic->display_order ?
VA_PICTURE_HEVC_RPS_ST_CURR_BEFORE : 0) | VA_PICTURE_HEVC_RPS_ST_CURR_BEFORE : 0) |
@ -973,13 +973,13 @@ static int vaapi_encode_h265_init_picture_params(AVCodecContext *avctx,
} }
static int vaapi_encode_h265_init_slice_params(AVCodecContext *avctx, static int vaapi_encode_h265_init_slice_params(AVCodecContext *avctx,
VAAPIEncodePicture *vaapi_pic, FFHWBaseEncodePicture *pic,
VAAPIEncodeSlice *slice) VAAPIEncodeSlice *slice)
{ {
FFHWBaseEncodeContext *base_ctx = avctx->priv_data; FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
VAAPIEncodeH265Context *priv = avctx->priv_data; VAAPIEncodeH265Context *priv = avctx->priv_data;
const FFHWBaseEncodePicture *pic = &vaapi_pic->base; VAAPIEncodePicture *vaapi_pic = pic->priv;
VAAPIEncodeH265Picture *hpic = pic->priv_data; VAAPIEncodeH265Picture *hpic = pic->codec_priv;
const H265RawSPS *sps = &priv->raw_sps; const H265RawSPS *sps = &priv->raw_sps;
const H265RawPPS *pps = &priv->raw_pps; const H265RawPPS *pps = &priv->raw_pps;
H265RawSliceHeader *sh = &priv->raw_slice.header; H265RawSliceHeader *sh = &priv->raw_slice.header;
@ -1021,7 +1021,7 @@ static int vaapi_encode_h265_init_slice_params(AVCodecContext *avctx,
rps_pics = 0; rps_pics = 0;
for (i = 0; i < MAX_REFERENCE_LIST_NUM; i++) { for (i = 0; i < MAX_REFERENCE_LIST_NUM; i++) {
for (j = 0; j < pic->nb_refs[i]; j++) { for (j = 0; j < pic->nb_refs[i]; j++) {
strp = pic->refs[i][j]->priv_data; strp = pic->refs[i][j]->codec_priv;
rps_poc[rps_pics] = strp->pic_order_cnt; rps_poc[rps_pics] = strp->pic_order_cnt;
rps_used[rps_pics] = 1; rps_used[rps_pics] = 1;
++rps_pics; ++rps_pics;
@ -1046,7 +1046,7 @@ static int vaapi_encode_h265_init_slice_params(AVCodecContext *avctx,
if (j < pic->nb_refs[1]) if (j < pic->nb_refs[1])
continue; continue;
strp = pic->dpb[i]->priv_data; strp = pic->dpb[i]->codec_priv;
rps_poc[rps_pics] = strp->pic_order_cnt; rps_poc[rps_pics] = strp->pic_order_cnt;
rps_used[rps_pics] = 0; rps_used[rps_pics] = 0;
++rps_pics; ++rps_pics;

8
libavcodec/vaapi_encode_mjpeg.c
View File

@ -147,7 +147,7 @@ fail:
} }
static int vaapi_encode_mjpeg_write_extra_buffer(AVCodecContext *avctx, static int vaapi_encode_mjpeg_write_extra_buffer(AVCodecContext *avctx,
VAAPIEncodePicture *pic, FFHWBaseEncodePicture *base,
int index, int *type, int index, int *type,
char *data, size_t *data_len) char *data, size_t *data_len)
{ {
@ -220,11 +220,11 @@ static int vaapi_encode_mjpeg_write_extra_buffer(AVCodecContext *avctx,
} }
static int vaapi_encode_mjpeg_init_picture_params(AVCodecContext *avctx, static int vaapi_encode_mjpeg_init_picture_params(AVCodecContext *avctx,
VAAPIEncodePicture *vaapi_pic) FFHWBaseEncodePicture *pic)
{ {
FFHWBaseEncodeContext *base_ctx = avctx->priv_data; FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
VAAPIEncodeMJPEGContext *priv = avctx->priv_data; VAAPIEncodeMJPEGContext *priv = avctx->priv_data;
const FFHWBaseEncodePicture *pic = &vaapi_pic->base; VAAPIEncodePicture *vaapi_pic = pic->priv;
JPEGRawFrameHeader *fh = &priv->frame_header; JPEGRawFrameHeader *fh = &priv->frame_header;
JPEGRawScanHeader *sh = &priv->scan.header; JPEGRawScanHeader *sh = &priv->scan.header;
VAEncPictureParameterBufferJPEG *vpic = vaapi_pic->codec_picture_params; VAEncPictureParameterBufferJPEG *vpic = vaapi_pic->codec_picture_params;
@ -414,7 +414,7 @@ static int vaapi_encode_mjpeg_init_picture_params(AVCodecContext *avctx,
} }
static int vaapi_encode_mjpeg_init_slice_params(AVCodecContext *avctx, static int vaapi_encode_mjpeg_init_slice_params(AVCodecContext *avctx,
VAAPIEncodePicture *pic, FFHWBaseEncodePicture *base,
VAAPIEncodeSlice *slice) VAAPIEncodeSlice *slice)
{ {
VAAPIEncodeMJPEGContext *priv = avctx->priv_data; VAAPIEncodeMJPEGContext *priv = avctx->priv_data;

15
libavcodec/vaapi_encode_mpeg2.c
View File

@ -141,7 +141,7 @@ fail:
} }
static int vaapi_encode_mpeg2_write_picture_header(AVCodecContext *avctx, static int vaapi_encode_mpeg2_write_picture_header(AVCodecContext *avctx,
VAAPIEncodePicture *pic, FFHWBaseEncodePicture *pic,
char *data, size_t *data_len) char *data, size_t *data_len)
{ {
VAAPIEncodeMPEG2Context *priv = avctx->priv_data; VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
@ -418,10 +418,10 @@ static int vaapi_encode_mpeg2_init_sequence_params(AVCodecContext *avctx)
} }
static int vaapi_encode_mpeg2_init_picture_params(AVCodecContext *avctx, static int vaapi_encode_mpeg2_init_picture_params(AVCodecContext *avctx,
VAAPIEncodePicture *vaapi_pic) FFHWBaseEncodePicture *pic)
{ {
VAAPIEncodeMPEG2Context *priv = avctx->priv_data; VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
const FFHWBaseEncodePicture *pic = &vaapi_pic->base; VAAPIEncodePicture *vaapi_pic = pic->priv;
MPEG2RawPictureHeader *ph = &priv->picture_header; MPEG2RawPictureHeader *ph = &priv->picture_header;
MPEG2RawPictureCodingExtension *pce = &priv->picture_coding_extension.data.picture_coding; MPEG2RawPictureCodingExtension *pce = &priv->picture_coding_extension.data.picture_coding;
VAEncPictureParameterBufferMPEG2 *vpic = vaapi_pic->codec_picture_params; VAEncPictureParameterBufferMPEG2 *vpic = vaapi_pic->codec_picture_params;
@ -460,12 +460,12 @@ static int vaapi_encode_mpeg2_init_picture_params(AVCodecContext *avctx,
break; break;
case FF_HW_PICTURE_TYPE_P: case FF_HW_PICTURE_TYPE_P:
vpic->picture_type = VAEncPictureTypePredictive; vpic->picture_type = VAEncPictureTypePredictive;
vpic->forward_reference_picture = ((VAAPIEncodePicture *)pic->refs[0][0])->recon_surface; vpic->forward_reference_picture = ((VAAPIEncodePicture *)pic->refs[0][0]->priv)->recon_surface;
break; break;
case FF_HW_PICTURE_TYPE_B: case FF_HW_PICTURE_TYPE_B:
vpic->picture_type = VAEncPictureTypeBidirectional; vpic->picture_type = VAEncPictureTypeBidirectional;
vpic->forward_reference_picture = ((VAAPIEncodePicture *)pic->refs[0][0])->recon_surface; vpic->forward_reference_picture = ((VAAPIEncodePicture *)pic->refs[0][0]->priv)->recon_surface;
vpic->backward_reference_picture = ((VAAPIEncodePicture *)pic->refs[1][0])->recon_surface; vpic->backward_reference_picture = ((VAAPIEncodePicture *)pic->refs[1][0]->priv)->recon_surface;
break; break;
default: default:
av_assert0(0 && "invalid picture type"); av_assert0(0 && "invalid picture type");
@ -481,10 +481,9 @@ static int vaapi_encode_mpeg2_init_picture_params(AVCodecContext *avctx,
} }
static int vaapi_encode_mpeg2_init_slice_params(AVCodecContext *avctx, static int vaapi_encode_mpeg2_init_slice_params(AVCodecContext *avctx,
VAAPIEncodePicture *vaapi_pic, FFHWBaseEncodePicture *pic,
VAAPIEncodeSlice *slice) VAAPIEncodeSlice *slice)
{ {
const FFHWBaseEncodePicture *pic = &vaapi_pic->base;
VAAPIEncodeMPEG2Context *priv = avctx->priv_data; VAAPIEncodeMPEG2Context *priv = avctx->priv_data;
VAEncSliceParameterBufferMPEG2 *vslice = slice->codec_slice_params; VAEncSliceParameterBufferMPEG2 *vslice = slice->codec_slice_params;
int qp; int qp;

10
libavcodec/vaapi_encode_vp8.c
View File

@ -74,9 +74,9 @@ static int vaapi_encode_vp8_init_sequence_params(AVCodecContext *avctx)
} }
static int vaapi_encode_vp8_init_picture_params(AVCodecContext *avctx, static int vaapi_encode_vp8_init_picture_params(AVCodecContext *avctx,
VAAPIEncodePicture *vaapi_pic) FFHWBaseEncodePicture *pic)
{ {
const FFHWBaseEncodePicture *pic = &vaapi_pic->base; VAAPIEncodePicture *vaapi_pic = pic->priv;
VAAPIEncodeVP8Context *priv = avctx->priv_data; VAAPIEncodeVP8Context *priv = avctx->priv_data;
VAEncPictureParameterBufferVP8 *vpic = vaapi_pic->codec_picture_params; VAEncPictureParameterBufferVP8 *vpic = vaapi_pic->codec_picture_params;
int i; int i;
@ -103,7 +103,7 @@ static int vaapi_encode_vp8_init_picture_params(AVCodecContext *avctx,
vpic->ref_last_frame = vpic->ref_last_frame =
vpic->ref_gf_frame = vpic->ref_gf_frame =
vpic->ref_arf_frame = vpic->ref_arf_frame =
((VAAPIEncodePicture *)pic->refs[0][0])->recon_surface; ((VAAPIEncodePicture *)pic->refs[0][0]->priv)->recon_surface;
break; break;
default: default:
av_assert0(0 && "invalid picture type"); av_assert0(0 && "invalid picture type");
@ -129,7 +129,7 @@ static int vaapi_encode_vp8_init_picture_params(AVCodecContext *avctx,
} }
static int vaapi_encode_vp8_write_quant_table(AVCodecContext *avctx, static int vaapi_encode_vp8_write_quant_table(AVCodecContext *avctx,
VAAPIEncodePicture *pic, FFHWBaseEncodePicture *base_pic,
int index, int *type, int index, int *type,
char *data, size_t *data_len) char *data, size_t *data_len)
{ {
@ -147,7 +147,7 @@ static int vaapi_encode_vp8_write_quant_table(AVCodecContext *avctx,
memset(&quant, 0, sizeof(quant)); memset(&quant, 0, sizeof(quant));
if (pic->base.type == FF_HW_PICTURE_TYPE_P) if (base_pic->type == FF_HW_PICTURE_TYPE_P)
q = priv->q_index_p; q = priv->q_index_p;
else else
q = priv->q_index_i; q = priv->q_index_i;

16
libavcodec/vaapi_encode_vp9.c
View File

@ -77,12 +77,12 @@ static int vaapi_encode_vp9_init_sequence_params(AVCodecContext *avctx)
} }
static int vaapi_encode_vp9_init_picture_params(AVCodecContext *avctx, static int vaapi_encode_vp9_init_picture_params(AVCodecContext *avctx,
VAAPIEncodePicture *vaapi_pic) FFHWBaseEncodePicture *pic)
{ {
FFHWBaseEncodeContext *base_ctx = avctx->priv_data; FFHWBaseEncodeContext *base_ctx = avctx->priv_data;
VAAPIEncodeVP9Context *priv = avctx->priv_data; VAAPIEncodeVP9Context *priv = avctx->priv_data;
const FFHWBaseEncodePicture *pic = &vaapi_pic->base; VAAPIEncodePicture *vaapi_pic = pic->priv;
VAAPIEncodeVP9Picture *hpic = pic->priv_data; VAAPIEncodeVP9Picture *hpic = pic->codec_priv;
VAEncPictureParameterBufferVP9 *vpic = vaapi_pic->codec_picture_params; VAEncPictureParameterBufferVP9 *vpic = vaapi_pic->codec_picture_params;
int i; int i;
int num_tile_columns; int num_tile_columns;
@ -106,7 +106,7 @@ static int vaapi_encode_vp9_init_picture_params(AVCodecContext *avctx,
case FF_HW_PICTURE_TYPE_P: case FF_HW_PICTURE_TYPE_P:
av_assert0(!pic->nb_refs[1]); av_assert0(!pic->nb_refs[1]);
{ {
VAAPIEncodeVP9Picture *href = pic->refs[0][0]->priv_data; VAAPIEncodeVP9Picture *href = pic->refs[0][0]->codec_priv;
av_assert0(href->slot == 0 || href->slot == 1); av_assert0(href->slot == 0 || href->slot == 1);
if (base_ctx->max_b_depth > 0) { if (base_ctx->max_b_depth > 0) {
@ -124,8 +124,8 @@ static int vaapi_encode_vp9_init_picture_params(AVCodecContext *avctx,
case FF_HW_PICTURE_TYPE_B: case FF_HW_PICTURE_TYPE_B:
av_assert0(pic->nb_refs[0] && pic->nb_refs[1]); av_assert0(pic->nb_refs[0] && pic->nb_refs[1]);
{ {
VAAPIEncodeVP9Picture *href0 = pic->refs[0][0]->priv_data, VAAPIEncodeVP9Picture *href0 = pic->refs[0][0]->codec_priv,
*href1 = pic->refs[1][0]->priv_data; *href1 = pic->refs[1][0]->codec_priv;
av_assert0(href0->slot < pic->b_depth + 1 && av_assert0(href0->slot < pic->b_depth + 1 &&
href1->slot < pic->b_depth + 1); href1->slot < pic->b_depth + 1);
@ -163,9 +163,9 @@ static int vaapi_encode_vp9_init_picture_params(AVCodecContext *avctx,
for (int j = 0; j < pic->nb_refs[i]; j++) { for (int j = 0; j < pic->nb_refs[i]; j++) {
FFHWBaseEncodePicture *ref_pic = pic->refs[i][j]; FFHWBaseEncodePicture *ref_pic = pic->refs[i][j];
int slot; int slot;
slot = ((VAAPIEncodeVP9Picture*)ref_pic->priv_data)->slot; slot = ((VAAPIEncodeVP9Picture*)ref_pic->codec_priv)->slot;
av_assert0(vpic->reference_frames[slot] == VA_INVALID_SURFACE); av_assert0(vpic->reference_frames[slot] == VA_INVALID_SURFACE);
vpic->reference_frames[slot] = ((VAAPIEncodePicture *)ref_pic)->recon_surface; vpic->reference_frames[slot] = ((VAAPIEncodePicture *)ref_pic->priv)->recon_surface;
} }
} }