From patchwork Mon Aug 19 15:16:15 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lynne X-Patchwork-Id: 51081 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a59:b6ca:0:b0:48e:c0f8:d0de with SMTP id s10csp2006744vqj; Mon, 19 Aug 2024 08:18:33 -0700 (PDT) X-Forwarded-Encrypted: i=2; AJvYcCULwjZ/YCXwC70DupKzR0nWJ1KeyyOFZul+aHktYlPd+en6s3Ho29/irY3X8iF8U0q3dN/U4FrWp0CunoiXXPtcB9MUicKcpc6bzA== X-Google-Smtp-Source: AGHT+IEuXP0nEaqVdLIYnDeNcqYxeXwUp8vYn7vVQlv6BGzGV3hEGf9Du8VDeYS7hNhVMTZeiJNq X-Received: by 2002:a05:6402:3552:b0:5be:fe37:41cb with SMTP id 4fb4d7f45d1cf-5befe374394mr1635135a12.33.1724080712732; Mon, 19 Aug 2024 08:18:32 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1724080712; cv=none; d=google.com; s=arc-20160816; b=AfzcCcS7AyIZXkLWvLM6WQZEJNgbSzErGgpjm4Bt3mzBh21cJpNI006m0B3Bb4IIxw 8QR+uwYTYyrl7LYtLIWUwLGnSnbJO1EVE5grnh7Z7XJ03nP9HY5oBWv+qonSf4KNDsF7 QgMqseeAVK4EGaake5PkYbnoIHeiuqkOMO7GT5oBZBqshRuz5YAxrQhXeqZINilfmjkS JfSmswDI7SdvMF/CFJDpmBkmjk2pdG5mGTCbtkqLusypgH4BgNy/94rtHe88O07/w2d1 oZWdlz1ir2yJkmC9fqH3G4ceBJyAd2EM7tTKWZGSyly61m+xNjdv5C4H+wNT0DeZcDcb oNww== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:content-transfer-encoding:cc:reply-to:from :list-subscribe:list-help:list-post:list-archive:list-unsubscribe :list-id:precedence:subject:mime-version:references:in-reply-to :message-id:date:to:delivered-to; bh=zrErZGy54hyef2zJ21QFXG7shzGb2Nagz7Ax6V5dZOs=; fh=Cn6T6QwPRwu6aI1sqDwBPFLnTD2RubbJmbVvddlPaPc=; b=Wq11Ql+CuCT2qAvzYgvoITQuFDZ2K6PLNW77Tt4YqVKOakCQ2rFULbQE2GaCPjCvBH ZbE3qxbedTaSyv+Lehp6eiCRjR6ONTPQd4kupxKuDetpXs+GZBq+JSKHG+mDm6xDJf9y OxQ2JasaHp9uV5AEe2kjb8Y1/gc0uRv/3UISXFPBVpih/X8dG3lkOvblCUoVbtHo9UHk 1nY4fB9O+u6RAO65w/cLs6r+t6O9PeWZGW4IOaHUoGwOSb5Dag5zJa3lqresic8KwRbo LGr5eTsQFhnmlq6f3IwClsbl+I/bj6RHM2BP4nRQtrxFVWIXGsgpS4T+Uwk+me/0kVzd 4n/A==; dara=google.com ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org Return-Path: Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org. [79.124.17.100]) by mx.google.com with ESMTP id 4fb4d7f45d1cf-5bec38ed583si5547949a12.354.2024.08.19.08.18.31; Mon, 19 Aug 2024 08:18:32 -0700 (PDT) Received-SPF: pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) client-ip=79.124.17.100; Authentication-Results: mx.google.com; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 9E49568DDDF; Mon, 19 Aug 2024 18:18:29 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from vidala.lynne.ee (vidala.pars.ee [116.203.72.101]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 8AC4F68DC29 for ; Mon, 19 Aug 2024 18:18:22 +0300 (EEST) To: ffmpeg-devel@ffmpeg.org, wutong1208@outlook.com Date: Mon, 19 Aug 2024 17:16:15 +0200 Message-ID: <20240819151754.71524-1-dev@lynne.ee> X-Mailer: git-send-email 2.45.2.753.g447d99e1c3b In-Reply-To: References: MIME-Version: 1.0 Subject: [FFmpeg-devel] [PATCH v2] hw_base_encode: refactor picture allocation/freeing X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Lynne via ffmpeg-devel From: Lynne Reply-To: FFmpeg development discussions and patches Cc: Lynne Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: JKNImCK4/FB0 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. --- libavcodec/d3d12va_encode.c | 29 +++++------ libavcodec/hw_base_encode.c | 39 ++++++++++----- libavcodec/hw_base_encode.h | 21 ++++---- libavcodec/vaapi_encode.c | 89 +++++++++++++++------------------ libavcodec/vaapi_encode.h | 12 ++--- libavcodec/vaapi_encode_av1.c | 26 +++++----- libavcodec/vaapi_encode_h264.c | 65 ++++++++++++------------ libavcodec/vaapi_encode_h265.c | 24 ++++----- libavcodec/vaapi_encode_mjpeg.c | 8 +-- libavcodec/vaapi_encode_mpeg2.c | 9 ++-- libavcodec/vaapi_encode_vp8.c | 8 +-- libavcodec/vaapi_encode_vp9.c | 14 +++--- 12 files changed, 170 insertions(+), 174 deletions(-) diff --git a/libavcodec/d3d12va_encode.c b/libavcodec/d3d12va_encode.c index 9ee9da41e3..1df2d682d3 100644 --- a/libavcodec/d3d12va_encode.c +++ b/libavcodec/d3d12va_encode.c @@ -186,12 +186,12 @@ static int d3d12va_encode_create_metadata_buffers(AVCodecContext *avctx, } static int d3d12va_encode_issue(AVCodecContext *avctx, - const FFHWBaseEncodePicture *base_pic) + FFHWBaseEncodePicture *base_pic) { FFHWBaseEncodeContext *base_ctx = avctx->priv_data; D3D12VAEncodeContext *ctx = avctx->priv_data; + D3D12VAEncodePicture *pic = base_pic->priv; AVD3D12VAFramesContext *frames_hwctx = base_ctx->input_frames->hwctx; - D3D12VAEncodePicture *pic = (D3D12VAEncodePicture *)base_pic; int err, i, j; HRESULT hr; char data[MAX_PARAM_BUFFER_SIZE]; @@ -560,27 +560,20 @@ static int d3d12va_encode_free_rc_params(AVCodecContext *avctx) return 0; } -static FFHWBaseEncodePicture *d3d12va_encode_alloc(AVCodecContext *avctx, - const AVFrame *frame) +static int d3d12va_encode_init(AVCodecContext *avctx, FFHWBaseEncodePicture *base) { D3D12VAEncodeContext *ctx = avctx->priv_data; - D3D12VAEncodePicture *pic; - - pic = av_mallocz(sizeof(*pic)); - if (!pic) - return NULL; + D3D12VAEncodePicture *pic = base->priv; if (ctx->codec->picture_priv_data_size > 0) { - pic->base.priv_data = av_mallocz(ctx->codec->picture_priv_data_size); - if (!pic->base.priv_data) { - av_freep(&pic); - return NULL; - } + pic->base.codec_priv = av_mallocz(ctx->codec->picture_priv_data_size); + if (!pic->base.codec_priv) + return AVERROR(ENOMEM); } pic->input_surface = (AVD3D12VAFrame *)frame->data[0]; - return &pic->base; + return 0; } static int d3d12va_encode_free(AVCodecContext *avctx, @@ -680,10 +673,10 @@ end: } static int d3d12va_encode_output(AVCodecContext *avctx, - const FFHWBaseEncodePicture *base_pic, AVPacket *pkt) + FFHWBaseEncodePicture *base_pic, AVPacket *pkt) { FFHWBaseEncodeContext *base_ctx = avctx->priv_data; - D3D12VAEncodePicture *pic = (D3D12VAEncodePicture *)base_pic; + D3D12VAEncodePicture *pic = base_pic->priv; AVPacket *pkt_ptr = pkt; int err; @@ -1389,6 +1382,8 @@ static int d3d12va_encode_create_recon_frames(AVCodecContext *avctx) } static const FFHWEncodePictureOperation d3d12va_type = { + .priv_size = sizeof(D3D12VAEncodePicture), + .alloc = &d3d12va_encode_alloc, .issue = &d3d12va_encode_issue, diff --git a/libavcodec/hw_base_encode.c b/libavcodec/hw_base_encode.c index c1346e866c..8a1fe6148d 100644 --- a/libavcodec/hw_base_encode.c +++ b/libavcodec/hw_base_encode.c @@ -27,6 +27,19 @@ #include "avcodec.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, FFHWBaseEncodePicture *target, int is_ref, int in_dpb, int prev) @@ -370,6 +383,7 @@ static int hw_base_encode_clear_old(AVCodecContext *avctx, FFHWBaseEncodeContext else ctx->pic_start = next; ctx->op->free(avctx, pic); + base_encode_pic_free(pic); } else { prev = pic; } @@ -416,7 +430,7 @@ static int hw_base_encode_send_frame(AVCodecContext *avctx, FFHWBaseEncodeContex if (err < 0) return err; - pic = ctx->op->alloc(avctx, frame); + pic = av_mallocz(sizeof(*pic)); if (!pic) return AVERROR(ENOMEM); @@ -432,6 +446,12 @@ static int hw_base_encode_send_frame(AVCodecContext *avctx, FFHWBaseEncodeContex goto fail; } + pic->priv = av_mallocz(ctx->op->priv_size); + if (!pic->recon_image) { + err = AVERROR(ENOMEM); + goto fail; + } + if (ctx->input_order == 0 || frame->pict_type == AV_PICTURE_TYPE_I) pic->force_idr = 1; @@ -467,6 +487,9 @@ static int hw_base_encode_send_frame(AVCodecContext *avctx, FFHWBaseEncodeContex ctx->pic_end = pic; } + err = ctx->op->init(avctx, pic); + if (err < 0) + goto fail; } else { ctx->end_of_stream = 1; @@ -480,6 +503,7 @@ static int hw_base_encode_send_frame(AVCodecContext *avctx, FFHWBaseEncodeContex fail: ctx->op->free(avctx, pic); + base_encode_pic_free(pic); return err; } @@ -529,7 +553,7 @@ int ff_hw_base_encode_receive_packet(FFHWBaseEncodeContext *ctx, AVFrame *frame = ctx->frame; 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); start: @@ -737,17 +761,6 @@ fail: 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) { ctx->log_ctx = (void *)avctx; diff --git a/libavcodec/hw_base_encode.h b/libavcodec/hw_base_encode.h index ac0cc7b80c..d6ec5a611a 100644 --- a/libavcodec/hw_base_encode.h +++ b/libavcodec/hw_base_encode.h @@ -59,6 +59,11 @@ enum { }; typedef struct FFHWBaseEncodePicture { + /* API-specific private data */ + void *priv; + /* Codec-specific private data */ + void *codec_priv; + struct FFHWBaseEncodePicture *next; int64_t display_order; @@ -78,8 +83,6 @@ typedef struct FFHWBaseEncodePicture { AVFrame *input_image; AVFrame *recon_image; - void *priv_data; - // Whether this picture is a reference picture. int is_reference; @@ -104,13 +107,15 @@ typedef struct FFHWBaseEncodePicture { } FFHWBaseEncodePicture; typedef struct FFHWEncodePictureOperation { - // Alloc memory for the picture structure and initialize the API-specific internals - // based of the given frame. - FFHWBaseEncodePicture * (*alloc)(AVCodecContext *avctx, const AVFrame *frame); + /* Size of API-specific internal picture data */ + size_t priv_size; + /* Initialize API-specific internals */ + int (*init)(AVCodecContext *avctx, FFHWBaseEncodePicture *pic); + // 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 *base_pic); // Get the output AVPacket. - int (*output)(AVCodecContext *avctx, const FFHWBaseEncodePicture *base_pic, AVPacket *pkt); + int (*output)(AVCodecContext *avctx, FFHWBaseEncodePicture *base_pic, AVPacket *pkt); // Free the picture structure. int (*free)(AVCodecContext *avctx, FFHWBaseEncodePicture *base_pic); } FFHWEncodePictureOperation; @@ -228,8 +233,6 @@ int ff_hw_base_init_gop_structure(FFHWBaseEncodeContext *ctx, AVCodecContext *av int ff_hw_base_get_recon_format(FFHWBaseEncodeContext *ctx, const void *hwconfig, 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_close(FFHWBaseEncodeContext *ctx); diff --git a/libavcodec/vaapi_encode.c b/libavcodec/vaapi_encode.c index afdf3fe3d8..b72e9035cb 100644 --- a/libavcodec/vaapi_encode.c +++ b/libavcodec/vaapi_encode.c @@ -135,14 +135,13 @@ static int vaapi_encode_make_misc_param_buffer(AVCodecContext *avctx, buffer, buffer_size); } -static int vaapi_encode_wait(AVCodecContext *avctx, - VAAPIEncodePicture *pic) +static int vaapi_encode_wait(AVCodecContext *avctx, FFHWBaseEncodePicture *base_pic) { #if VA_CHECK_VERSION(1, 9, 0) FFHWBaseEncodeContext *base_ctx = avctx->priv_data; #endif VAAPIEncodeContext *ctx = avctx->priv_data; - FFHWBaseEncodePicture *base_pic = &pic->base; + VAAPIEncodePicture *pic = base_pic->priv; VAStatus vas; 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, - const FFHWBaseEncodePicture *base_pic) + FFHWBaseEncodePicture *base_pic) { FFHWBaseEncodeContext *base_ctx = avctx->priv_data; VAAPIEncodeContext *ctx = avctx->priv_data; - VAAPIEncodePicture *pic = (VAAPIEncodePicture*)base_pic; + VAAPIEncodePicture *pic = base_pic->priv; VAAPIEncodeSlice *slice; VAStatus vas; int err, i; @@ -364,7 +363,7 @@ static int vaapi_encode_issue(AVCodecContext *avctx, } 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) { av_log(avctx, AV_LOG_ERROR, "Failed to initialise picture " "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 && ctx->codec->write_picture_header) { 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) { av_log(avctx, AV_LOG_ERROR, "Failed to write per-picture " "header: %d.\n", err); @@ -427,7 +426,7 @@ static int vaapi_encode_issue(AVCodecContext *avctx, for (i = 0;; i++) { size_t len = sizeof(data); 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); if (err == AVERROR_EOF) break; @@ -449,7 +448,7 @@ static int vaapi_encode_issue(AVCodecContext *avctx, for (i = 0;; i++) { int type; 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); if (err == AVERROR_EOF) break; @@ -493,7 +492,7 @@ static int vaapi_encode_issue(AVCodecContext *avctx, } 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) { av_log(avctx, AV_LOG_ERROR, "Failed to initialise slice " "parameters: %d.\n", err); @@ -773,15 +772,15 @@ end: } static int vaapi_encode_output(AVCodecContext *avctx, - const FFHWBaseEncodePicture *base_pic, AVPacket *pkt) + FFHWBaseEncodePicture *base_pic, AVPacket *pkt) { FFHWBaseEncodeContext *base_ctx = avctx->priv_data; VAAPIEncodeContext *ctx = avctx->priv_data; - VAAPIEncodePicture *pic = (VAAPIEncodePicture*)base_pic; + VAAPIEncodePicture *pic = base_pic->priv; AVPacket *pkt_ptr = pkt; int err; - err = vaapi_encode_wait(avctx, pic); + err = vaapi_encode_wait(avctx, base_pic); if (err < 0) return err; @@ -820,12 +819,11 @@ end: return err; } -static int vaapi_encode_discard(AVCodecContext *avctx, - VAAPIEncodePicture *pic) +static int vaapi_encode_discard(AVCodecContext *avctx, FFHWBaseEncodePicture *base_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) { av_log(avctx, AV_LOG_DEBUG, "Discard output for pic " @@ -839,56 +837,45 @@ static int vaapi_encode_discard(AVCodecContext *avctx, return 0; } -static FFHWBaseEncodePicture *vaapi_encode_alloc(AVCodecContext *avctx, - const AVFrame *frame) +static int vaapi_encode_init(AVCodecContext *avctx, FFHWBaseEncodePicture *pic) { VAAPIEncodeContext *ctx = avctx->priv_data; - VAAPIEncodePicture *pic; - - pic = av_mallocz(sizeof(*pic)); - if (!pic) - return NULL; + VAAPIEncodePicture *priv = pic->priv; + AVFrame *frame = pic->input_image; if (ctx->codec->picture_priv_data_size > 0) { - pic->base.priv_data = av_mallocz(ctx->codec->picture_priv_data_size); - if (!pic->base.priv_data) { - av_freep(&pic); - return NULL; - } + pic->codec_priv = av_mallocz(ctx->codec->picture_priv_data_size); + if (!pic->codec_priv) + return AVERROR(ENOMEM); } - pic->input_surface = (VASurfaceID)(uintptr_t)frame->data[3]; - pic->recon_surface = VA_INVALID_ID; - pic->output_buffer = VA_INVALID_ID; + priv->input_surface = (VASurfaceID)(uintptr_t)frame->data[3]; + priv->recon_surface = VA_INVALID_ID; + priv->output_buffer = VA_INVALID_ID; - return &pic->base; + return 0; } -static int vaapi_encode_free(AVCodecContext *avctx, - FFHWBaseEncodePicture *base_pic) +static int vaapi_encode_free(AVCodecContext *avctx, FFHWBaseEncodePicture *pic) { - VAAPIEncodePicture *pic = (VAAPIEncodePicture*)base_pic; + VAAPIEncodePicture *priv = pic->priv; int i; - if (base_pic->encode_issued) + if (pic->encode_issued) vaapi_encode_discard(avctx, pic); - if (pic->slices) { - for (i = 0; i < pic->nb_slices; i++) - av_freep(&pic->slices[i].codec_slice_params); + if (priv->slices) { + for (i = 0; i < priv->nb_slices; i++) + av_freep(&priv->slices[i].codec_slice_params); } - ff_hw_base_encode_free(base_pic); - - av_freep(&pic->param_buffers); - av_freep(&pic->slices); + av_freep(&priv->param_buffers); + av_freep(&priv->slices); // 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(&pic->roi); - - av_free(pic); + av_freep(&priv->codec_picture_params); + av_freep(&priv->roi); return 0; } @@ -2090,7 +2077,9 @@ static av_cold int vaapi_encode_create_recon_frames(AVCodecContext *avctx) } static const FFHWEncodePictureOperation vaapi_op = { - .alloc = &vaapi_encode_alloc, + .priv_size = sizeof(VAAPIEncodePicture), + + .init = &vaapi_encode_init, .issue = &vaapi_encode_issue, diff --git a/libavcodec/vaapi_encode.h b/libavcodec/vaapi_encode.h index d76cdb8662..1493c42607 100644 --- a/libavcodec/vaapi_encode.h +++ b/libavcodec/vaapi_encode.h @@ -63,8 +63,6 @@ typedef struct VAAPIEncodeSlice { } VAAPIEncodeSlice; typedef struct VAAPIEncodePicture { - FFHWBaseEncodePicture base; - #if VA_CHECK_VERSION(1, 0, 0) // ROI regions. VAEncROI *roi; @@ -301,9 +299,9 @@ typedef struct VAAPIEncodeType { // Fill the parameter structures. int (*init_sequence_params)(AVCodecContext *avctx); int (*init_picture_params)(AVCodecContext *avctx, - VAAPIEncodePicture *pic); + FFHWBaseEncodePicture *pic); int (*init_slice_params)(AVCodecContext *avctx, - VAAPIEncodePicture *pic, + FFHWBaseEncodePicture *pice, VAAPIEncodeSlice *slice); // The type used by the packed header: this should look like @@ -318,7 +316,7 @@ typedef struct VAAPIEncodeType { int (*write_sequence_header)(AVCodecContext *avctx, char *data, size_t *data_len); int (*write_picture_header)(AVCodecContext *avctx, - VAAPIEncodePicture *pic, + FFHWBaseEncodePicture *pic, char *data, size_t *data_len); int (*write_slice_header)(AVCodecContext *avctx, VAAPIEncodePicture *pic, @@ -330,7 +328,7 @@ typedef struct VAAPIEncodeType { // with increasing index argument until AVERROR_EOF is // returned. int (*write_extra_buffer)(AVCodecContext *avctx, - VAAPIEncodePicture *pic, + FFHWBaseEncodePicture *pic, int index, int *type, char *data, size_t *data_len); @@ -338,7 +336,7 @@ typedef struct VAAPIEncodeType { // with increasing index argument until AVERROR_EOF is // returned. int (*write_extra_header)(AVCodecContext *avctx, - VAAPIEncodePicture *pic, + FFHWBaseEncodePicture *pic, int index, int *type, char *data, size_t *data_len); } VAAPIEncodeType; diff --git a/libavcodec/vaapi_encode_av1.c b/libavcodec/vaapi_encode_av1.c index 26a5707bf5..b7c9ca7917 100644 --- a/libavcodec/vaapi_encode_av1.c +++ b/libavcodec/vaapi_encode_av1.c @@ -466,12 +466,12 @@ end: } static int vaapi_encode_av1_init_picture_params(AVCodecContext *avctx, - VAAPIEncodePicture *vaapi_pic) + FFHWBaseEncodePicture *pic) { VAAPIEncodeContext *ctx = avctx->priv_data; VAAPIEncodeAV1Context *priv = avctx->priv_data; - const FFHWBaseEncodePicture *pic = &vaapi_pic->base; - VAAPIEncodeAV1Picture *hpic = pic->priv_data; + VAAPIEncodePicture *vaapi_pic = pic->priv; + VAAPIEncodeAV1Picture *hpic = pic->codec_priv; AV1RawOBU *fh_obu = &priv->fh; AV1RawFrameHeader *fh = &fh_obu->obu.frame.header; 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->base_q_idx = priv->q_idx_p; ref = pic->refs[0][pic->nb_refs[0] - 1]; - href = ref->priv_data; + href = ref->codec_priv; hpic->slot = !href->slot; hpic->last_idr_frame = href->last_idr_frame; 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. */ if (pic->nb_refs[0] > 1) { 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_order_hint[href->slot] = ref->display_order - href->last_idr_frame; 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; 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; fh->primary_ref_frame = href->slot; 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]; - href = ref->priv_data; + href = ref->codec_priv; 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++) { 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++) { 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); vpic->reference_frames[slot] = ((VAAPIEncodePicture *)ref_pic)->recon_surface; @@ -732,7 +732,7 @@ end: } static int vaapi_encode_av1_init_slice_params(AVCodecContext *avctx, - VAAPIEncodePicture *pic, + FFHWBaseEncodePicture *base, VAAPIEncodeSlice *slice) { 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, - VAAPIEncodePicture *vaapi_pic, + FFHWBaseEncodePicture *pic, char *data, size_t *data_len) { 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; AV1RawOBU *fh_obu = &priv->fh; AV1RawFrameHeader *rep_fh = &fh_obu->obu.frame_header; - const FFHWBaseEncodePicture *pic = &vaapi_pic->base; + VAAPIEncodePicture *vaapi_pic = pic->priv; VAAPIEncodeAV1Picture *href; int ret = 0; @@ -770,7 +770,7 @@ static int vaapi_encode_av1_write_picture_header(AVCodecContext *avctx, /** Pack repeat frame header. */ if (pic->display_order > pic->encode_order) { 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_has_size_field = 1; @@ -804,7 +804,7 @@ end: } static int vaapi_encode_av1_write_extra_header(AVCodecContext *avctx, - VAAPIEncodePicture *pic, + FFHWBaseEncodePicture *base_pic, int index, int *type, char *data, size_t *data_len) { diff --git a/libavcodec/vaapi_encode_h264.c b/libavcodec/vaapi_encode_h264.c index d156719728..132e430fc4 100644 --- a/libavcodec/vaapi_encode_h264.c +++ b/libavcodec/vaapi_encode_h264.c @@ -209,7 +209,7 @@ fail: } static int vaapi_encode_h264_write_extra_header(AVCodecContext *avctx, - VAAPIEncodePicture *pic, + FFHWBaseEncodePicture *base, int index, int *type, char *data, size_t *data_len) { @@ -233,7 +233,7 @@ static int vaapi_encode_h264_write_extra_header(AVCodecContext *avctx, goto fail; } 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, SEI_TYPE_BUFFERING_PERIOD, &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, - VAAPIEncodePicture *vaapi_pic) + FFHWBaseEncodePicture *pic) { FFHWBaseEncodeContext *base_ctx = avctx->priv_data; VAAPIEncodeH264Context *priv = avctx->priv_data; - const FFHWBaseEncodePicture *pic = &vaapi_pic->base; - VAAPIEncodeH264Picture *hpic = pic->priv_data; + VAAPIEncodePicture *vaapi_pic = pic->priv; + VAAPIEncodeH264Picture *hpic = pic->codec_priv; 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; int i, j = 0; @@ -736,7 +736,7 @@ static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx, VAAPIEncodeH264Picture *href; av_assert0(ref && ref->encode_order < pic->encode_order); - href = ref->priv_data; + href = ref->codec_priv; vpic->ReferenceFrames[j++] = (VAPictureH264) { .picture_id = ((VAAPIEncodePicture *)ref)->recon_surface, @@ -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, - VAAPIEncodePicture *vaapi_pic, - VAAPIEncodePicture **rpl0, - VAAPIEncodePicture **rpl1, + FFHWBaseEncodePicture *pic, + FFHWBaseEncodePicture **rpl0, + FFHWBaseEncodePicture **rpl1, int *rpl_size) { - FFHWBaseEncodePicture *pic = &vaapi_pic->base; FFHWBaseEncodePicture *prev; VAAPIEncodeH264Picture *hp, *hn, *hc; int i, j, n = 0; prev = pic->prev; av_assert0(prev); - hp = pic->priv_data; + hp = pic->codec_priv; 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); if (pic->type == FF_HW_PICTURE_TYPE_P) { 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); if (hc->frame_num > hn->frame_num) break; 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) { 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); if (hc->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] = (VAAPIEncodePicture *)prev->dpb[i]; + rpl0[j] = prev->dpb[i]; 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); if (hc->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] = (VAAPIEncodePicture *)prev->dpb[i]; + rpl1[j] = prev->dpb[i]; } ++n; @@ -835,7 +834,7 @@ static void vaapi_encode_h264_default_ref_pic_list(AVCodecContext *avctx, break; } if (i == n) - FFSWAP(VAAPIEncodePicture*, rpl1[0], rpl1[1]); + FFSWAP(FFHWBaseEncodePicture *, rpl1[0], rpl1[1]); } 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:", hp->frame_num, hp->pic_order_cnt); 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", 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:", hp->frame_num, hp->pic_order_cnt); 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", 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, - VAAPIEncodePicture *vaapi_pic, + FFHWBaseEncodePicture *pic, VAAPIEncodeSlice *slice) { VAAPIEncodeH264Context *priv = avctx->priv_data; - const FFHWBaseEncodePicture *pic = &vaapi_pic->base; - VAAPIEncodeH264Picture *hpic = pic->priv_data; + VAAPIEncodePicture *vaapi_pic = pic->priv; + VAAPIEncodeH264Picture *hpic = pic->codec_priv; FFHWBaseEncodePicture *prev = pic->prev; H264RawSPS *sps = &priv->raw_sps; H264RawPPS *pps = &priv->raw_pps; @@ -931,7 +930,7 @@ static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx, } else { sh->adaptive_ref_pic_marking_mode_flag = 1; 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); sh->mmco[i].memory_management_control_operation = 1; 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 // 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) { - VAAPIEncodePicture *def_l0[MAX_DPB_SIZE], *def_l1[MAX_DPB_SIZE]; + FFHWBaseEncodePicture *def_l0[MAX_DPB_SIZE], *def_l1[MAX_DPB_SIZE]; VAAPIEncodeH264Picture *href; 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); 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) { int pic_num = hpic->frame_num; 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); if (href->frame_num < pic_num) { 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; for (i = 0; i < pic->nb_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); if (pic->refs[0][i] != (FFHWBaseEncodePicture *)def_l0[n0]) 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++) { 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); if (pic->refs[1][i] != (FFHWBaseEncodePicture *)def_l1[n1]) need_rplm_l1 = 1; @@ -1004,7 +1003,7 @@ static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx, if (need_rplm_l0) { int pic_num = hpic->frame_num; 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); if (href->frame_num < pic_num) { 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) { int pic_num = hpic->frame_num; 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); if (href->frame_num < pic_num) { sh->rplm_l1[j].modification_of_pic_nums_idc = 0; diff --git a/libavcodec/vaapi_encode_h265.c b/libavcodec/vaapi_encode_h265.c index bbd174f975..ebe64942bc 100644 --- a/libavcodec/vaapi_encode_h265.c +++ b/libavcodec/vaapi_encode_h265.c @@ -200,7 +200,7 @@ fail: } static int vaapi_encode_h265_write_extra_header(AVCodecContext *avctx, - VAAPIEncodePicture *pic, + FFHWBaseEncodePicture *base, int index, int *type, 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, - VAAPIEncodePicture *vaapi_pic) + FFHWBaseEncodePicture *pic) { FFHWBaseEncodeContext *base_ctx = avctx->priv_data; VAAPIEncodeH265Context *priv = avctx->priv_data; - FFHWBaseEncodePicture *pic = &vaapi_pic->base; - VAAPIEncodeH265Picture *hpic = pic->priv_data; + VAAPIEncodePicture *vaapi_pic = pic->priv; + VAAPIEncodeH265Picture *hpic = pic->codec_priv; 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; int i, j = 0; @@ -923,10 +923,10 @@ static int vaapi_encode_h265_init_picture_params(AVCodecContext *avctx, VAAPIEncodeH265Picture *href; av_assert0(ref && ref->encode_order < pic->encode_order); - href = ref->priv_data; + href = ref->codec_priv; 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, .flags = (ref->display_order < pic->display_order ? 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, - VAAPIEncodePicture *vaapi_pic, + FFHWBaseEncodePicture *pic, VAAPIEncodeSlice *slice) { FFHWBaseEncodeContext *base_ctx = avctx->priv_data; VAAPIEncodeH265Context *priv = avctx->priv_data; - const FFHWBaseEncodePicture *pic = &vaapi_pic->base; - VAAPIEncodeH265Picture *hpic = pic->priv_data; + VAAPIEncodePicture *vaapi_pic = pic->priv; + VAAPIEncodeH265Picture *hpic = pic->codec_priv; const H265RawSPS *sps = &priv->raw_sps; const H265RawPPS *pps = &priv->raw_pps; H265RawSliceHeader *sh = &priv->raw_slice.header; @@ -1021,7 +1021,7 @@ static int vaapi_encode_h265_init_slice_params(AVCodecContext *avctx, rps_pics = 0; for (i = 0; i < MAX_REFERENCE_LIST_NUM; i++) { 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_used[rps_pics] = 1; ++rps_pics; @@ -1046,7 +1046,7 @@ static int vaapi_encode_h265_init_slice_params(AVCodecContext *avctx, if (j < pic->nb_refs[1]) continue; - strp = pic->dpb[i]->priv_data; + strp = pic->dpb[i]->codec_priv; rps_poc[rps_pics] = strp->pic_order_cnt; rps_used[rps_pics] = 0; ++rps_pics; diff --git a/libavcodec/vaapi_encode_mjpeg.c b/libavcodec/vaapi_encode_mjpeg.c index 0ca8d676dd..8176177b84 100644 --- a/libavcodec/vaapi_encode_mjpeg.c +++ b/libavcodec/vaapi_encode_mjpeg.c @@ -147,7 +147,7 @@ fail: } static int vaapi_encode_mjpeg_write_extra_buffer(AVCodecContext *avctx, - VAAPIEncodePicture *pic, + FFHWBaseEncodePicture *base, int index, int *type, 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, - VAAPIEncodePicture *vaapi_pic) + FFHWBaseEncodePicture *pic) { FFHWBaseEncodeContext *base_ctx = avctx->priv_data; VAAPIEncodeMJPEGContext *priv = avctx->priv_data; - const FFHWBaseEncodePicture *pic = &vaapi_pic->base; + VAAPIEncodePicture *vaapi_pic = pic->priv; JPEGRawFrameHeader *fh = &priv->frame_header; JPEGRawScanHeader *sh = &priv->scan.header; 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, - VAAPIEncodePicture *pic, + FFHWBaseEncodePicture *base, VAAPIEncodeSlice *slice) { VAAPIEncodeMJPEGContext *priv = avctx->priv_data; diff --git a/libavcodec/vaapi_encode_mpeg2.c b/libavcodec/vaapi_encode_mpeg2.c index be801d21d2..75cd76a90f 100644 --- a/libavcodec/vaapi_encode_mpeg2.c +++ b/libavcodec/vaapi_encode_mpeg2.c @@ -141,7 +141,7 @@ fail: } static int vaapi_encode_mpeg2_write_picture_header(AVCodecContext *avctx, - VAAPIEncodePicture *pic, + FFHWBaseEncodePicture *pic, char *data, size_t *data_len) { 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, - VAAPIEncodePicture *vaapi_pic) + FFHWBaseEncodePicture *pic) { VAAPIEncodeMPEG2Context *priv = avctx->priv_data; - const FFHWBaseEncodePicture *pic = &vaapi_pic->base; + VAAPIEncodePicture *vaapi_pic = pic->priv; MPEG2RawPictureHeader *ph = &priv->picture_header; MPEG2RawPictureCodingExtension *pce = &priv->picture_coding_extension.data.picture_coding; VAEncPictureParameterBufferMPEG2 *vpic = vaapi_pic->codec_picture_params; @@ -481,10 +481,9 @@ static int vaapi_encode_mpeg2_init_picture_params(AVCodecContext *avctx, } static int vaapi_encode_mpeg2_init_slice_params(AVCodecContext *avctx, - VAAPIEncodePicture *vaapi_pic, + FFHWBaseEncodePicture *pic, VAAPIEncodeSlice *slice) { - const FFHWBaseEncodePicture *pic = &vaapi_pic->base; VAAPIEncodeMPEG2Context *priv = avctx->priv_data; VAEncSliceParameterBufferMPEG2 *vslice = slice->codec_slice_params; int qp; diff --git a/libavcodec/vaapi_encode_vp8.c b/libavcodec/vaapi_encode_vp8.c index 634b849cd2..5550a8e3c6 100644 --- a/libavcodec/vaapi_encode_vp8.c +++ b/libavcodec/vaapi_encode_vp8.c @@ -74,9 +74,9 @@ static int vaapi_encode_vp8_init_sequence_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; VAEncPictureParameterBufferVP8 *vpic = vaapi_pic->codec_picture_params; int i; @@ -129,7 +129,7 @@ static int vaapi_encode_vp8_init_picture_params(AVCodecContext *avctx, } static int vaapi_encode_vp8_write_quant_table(AVCodecContext *avctx, - VAAPIEncodePicture *pic, + FFHWBaseEncodePicture *base_pic, int index, int *type, 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)); - if (pic->base.type == FF_HW_PICTURE_TYPE_P) + if (base_pic->type == FF_HW_PICTURE_TYPE_P) q = priv->q_index_p; else q = priv->q_index_i; diff --git a/libavcodec/vaapi_encode_vp9.c b/libavcodec/vaapi_encode_vp9.c index eac9be82b0..b424357757 100644 --- a/libavcodec/vaapi_encode_vp9.c +++ b/libavcodec/vaapi_encode_vp9.c @@ -77,12 +77,12 @@ static int vaapi_encode_vp9_init_sequence_params(AVCodecContext *avctx) } static int vaapi_encode_vp9_init_picture_params(AVCodecContext *avctx, - VAAPIEncodePicture *vaapi_pic) + FFHWBaseEncodePicture *pic) { FFHWBaseEncodeContext *base_ctx = avctx->priv_data; VAAPIEncodeVP9Context *priv = avctx->priv_data; - const FFHWBaseEncodePicture *pic = &vaapi_pic->base; - VAAPIEncodeVP9Picture *hpic = pic->priv_data; + VAAPIEncodePicture *vaapi_pic = pic->priv; + VAAPIEncodeVP9Picture *hpic = pic->codec_priv; VAEncPictureParameterBufferVP9 *vpic = vaapi_pic->codec_picture_params; int i; int num_tile_columns; @@ -106,7 +106,7 @@ static int vaapi_encode_vp9_init_picture_params(AVCodecContext *avctx, case FF_HW_PICTURE_TYPE_P: 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); 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: av_assert0(pic->nb_refs[0] && pic->nb_refs[1]); { - VAAPIEncodeVP9Picture *href0 = pic->refs[0][0]->priv_data, - *href1 = pic->refs[1][0]->priv_data; + VAAPIEncodeVP9Picture *href0 = pic->refs[0][0]->codec_priv, + *href1 = pic->refs[1][0]->codec_priv; av_assert0(href0->slot < pic->b_depth + 1 && href1->slot < pic->b_depth + 1); @@ -163,7 +163,7 @@ static int vaapi_encode_vp9_init_picture_params(AVCodecContext *avctx, for (int j = 0; j < pic->nb_refs[i]; j++) { FFHWBaseEncodePicture *ref_pic = pic->refs[i][j]; 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); vpic->reference_frames[slot] = ((VAAPIEncodePicture *)ref_pic)->recon_surface; }