From 1804b4eb3242afab66ede4db37fe5a0c8e6227cc Mon Sep 17 00:00:00 2001 From: Daniel Stankewitz Date: Fri, 25 Nov 2022 14:25:46 +0100 Subject: [PATCH] Create amd-av1-amf.patch --- amd-av1-amf.patch | 466 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 466 insertions(+) create mode 100644 amd-av1-amf.patch diff --git a/amd-av1-amf.patch b/amd-av1-amf.patch new file mode 100644 index 0000000..fd0c40d --- /dev/null +++ b/amd-av1-amf.patch @@ -0,0 +1,466 @@ +diff --git a/configure b/configure +index ba5793b2ff..a7f5642a74 100755 +--- a/configure ++++ b/configure +@@ -3250,6 +3250,7 @@ vp9_qsv_encoder_select="qsvenc" + vp9_v4l2m2m_decoder_deps="v4l2_m2m vp9_v4l2_m2m" + wmv3_crystalhd_decoder_select="crystalhd" + av1_qsv_decoder_select="qsvdec" ++av1_amf_encoder_deps="amf" + + # parsers + aac_parser_select="adts_header mpeg4audio" +diff --git a/libavcodec/Makefile b/libavcodec/Makefile +index 457ec58377..4228851b9c 100644 +--- a/libavcodec/Makefile ++++ b/libavcodec/Makefile +@@ -959,6 +959,7 @@ OBJS-$(CONFIG_AV1_DXVA2_HWACCEL) += dxva2_av1.o + OBJS-$(CONFIG_AV1_NVDEC_HWACCEL) += nvdec_av1.o + OBJS-$(CONFIG_AV1_VAAPI_HWACCEL) += vaapi_av1.o + OBJS-$(CONFIG_AV1_VDPAU_HWACCEL) += vdpau_av1.o ++OBJS-$(CONFIG_AV1_AMF_ENCODER) += amfenc_av1.o + OBJS-$(CONFIG_H263_VAAPI_HWACCEL) += vaapi_mpeg4.o + OBJS-$(CONFIG_H263_VIDEOTOOLBOX_HWACCEL) += videotoolbox.o + OBJS-$(CONFIG_H264_D3D11VA_HWACCEL) += dxva2_h264.o +diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c +index bdfc2f6f45..f2b44a8d18 100644 +--- a/libavcodec/allcodecs.c ++++ b/libavcodec/allcodecs.c +@@ -816,6 +816,7 @@ extern const FFCodec ff_libaom_av1_decoder; + extern const FFCodec ff_av1_decoder; + extern const FFCodec ff_av1_cuvid_decoder; + extern const FFCodec ff_av1_qsv_decoder; ++extern const FFCodec ff_av1_amf_encoder; + extern const FFCodec ff_libopenh264_encoder; + extern const FFCodec ff_libopenh264_decoder; + extern const FFCodec ff_h264_amf_encoder; +diff --git a/libavcodec/amfenc.c b/libavcodec/amfenc.c +index a033e1220e..ab75556b6a 100644 +--- a/libavcodec/amfenc.c ++++ b/libavcodec/amfenc.c +@@ -349,6 +349,9 @@ static int amf_init_encoder(AVCodecContext *avctx) + case AV_CODEC_ID_HEVC: + codec_id = AMFVideoEncoder_HEVC; + break; ++ case AV_CODEC_ID_AV1: ++ codec_id = AMFVideoEncoder_AV1; ++ break; + default: + break; + } +@@ -460,6 +463,12 @@ static int amf_copy_buffer(AVCodecContext *avctx, AVPacket *pkt, AMFBuffer *buff + pkt->flags = AV_PKT_FLAG_KEY; + } + break; ++ case AV_CODEC_ID_AV1: ++ buffer->pVtbl->GetProperty(buffer, AMF_VIDEO_ENCODER_AV1_OUTPUT_FRAME_TYPE, &var); ++ if (var.int64Value == AMF_VIDEO_ENCODER_AV1_OUTPUT_FRAME_TYPE_KEY) { ++ pkt->flags = AV_PKT_FLAG_KEY; ++ } ++ break; + default: + break; + } +@@ -681,6 +690,7 @@ int ff_amf_receive_packet(AVCodecContext *avctx, AVPacket *avpkt) + case AV_CODEC_ID_HEVC: + AMF_ASSIGN_PROPERTY_INT64(res, surface, AMF_VIDEO_ENCODER_HEVC_INSERT_AUD, !!ctx->aud); + break; ++ //case AV_CODEC_ID_AV1 not supported + default: + break; + } +diff --git a/libavcodec/amfenc.h b/libavcodec/amfenc.h +index 1ab98d2f78..96abb58226 100644 +--- a/libavcodec/amfenc.h ++++ b/libavcodec/amfenc.h +@@ -23,6 +23,7 @@ + + #include + #include ++#include + + #include "libavutil/fifo.h" + +@@ -116,6 +117,10 @@ typedef struct AmfContext { + int min_qp_p; + int max_qp_p; + int tier; ++ ++ // AV1 - specific options ++ ++ enum AMF_VIDEO_ENCODER_AV1_ALIGNMENT_MODE_ENUM align; + } AmfContext; + + extern const AVCodecHWConfigInternal *const ff_amfenc_hw_configs[]; +diff --git a/libavcodec/amfenc_av1.c b/libavcodec/amfenc_av1.c +new file mode 100644 +index 0000000000..a4e536ece8 +--- /dev/null ++++ b/libavcodec/amfenc_av1.c +@@ -0,0 +1,365 @@ ++/* ++ * This file is part of FFmpeg. ++ * ++ * FFmpeg is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * FFmpeg is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with FFmpeg; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ */ ++ ++#include "libavutil/internal.h" ++#include "libavutil/opt.h" ++#include "amfenc.h" ++#include "codec_internal.h" ++#include "internal.h" ++ ++#define OFFSET(x) offsetof(AmfContext, x) ++#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM ++static const AVOption options[] = { ++ { "usage", "Set the encoding usage", OFFSET(usage), AV_OPT_TYPE_INT, {.i64 = AMF_VIDEO_ENCODER_AV1_USAGE_TRANSCODING }, AMF_VIDEO_ENCODER_AV1_USAGE_TRANSCODING, AMF_VIDEO_ENCODER_AV1_USAGE_LOW_LATENCY, VE, "usage" }, ++ { "transcoding", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_USAGE_TRANSCODING }, 0, 0, VE, "usage" }, ++ { "lowlatency", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_USAGE_LOW_LATENCY }, 0, 0, VE, "usage" }, ++ ++ { "profile", "Set the profile (default main)", OFFSET(profile), AV_OPT_TYPE_INT,{.i64 = AMF_VIDEO_ENCODER_AV1_PROFILE_MAIN }, AMF_VIDEO_ENCODER_AV1_PROFILE_MAIN, AMF_VIDEO_ENCODER_AV1_PROFILE_MAIN, VE, "profile" }, ++ { "main", "", 0, AV_OPT_TYPE_CONST,{.i64 = AMF_VIDEO_ENCODER_AV1_PROFILE_MAIN }, 0, 0, VE, "profile" }, ++ ++ { "level", "Set the encoding level (default auto)", OFFSET(level), AV_OPT_TYPE_INT,{.i64 = 0 }, 0, AMF_VIDEO_ENCODER_AV1_LEVEL_7_3, VE, "level" }, ++ { "auto", "", 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, VE, "level" }, ++ { "2.0", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_2_0 }, 0, 0, VE, "level" }, ++ { "2.1", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_2_1 }, 0, 0, VE, "level" }, ++ { "2.2", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_2_2 }, 0, 0, VE, "level" }, ++ { "2.3", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_2_3 }, 0, 0, VE, "level" }, ++ { "3.0", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_3_0 }, 0, 0, VE, "level" }, ++ { "3.1", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_3_1 }, 0, 0, VE, "level" }, ++ { "3.2", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_3_2 }, 0, 0, VE, "level" }, ++ { "3.3", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_3_3 }, 0, 0, VE, "level" }, ++ { "4.0", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_4_0 }, 0, 0, VE, "level" }, ++ { "4.1", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_4_1 }, 0, 0, VE, "level" }, ++ { "4.2", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_4_2 }, 0, 0, VE, "level" }, ++ { "4.3", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_4_3 }, 0, 0, VE, "level" }, ++ { "5.0", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_5_0 }, 0, 0, VE, "level" }, ++ { "5.1", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_5_1 }, 0, 0, VE, "level" }, ++ { "5.2", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_5_2 }, 0, 0, VE, "level" }, ++ { "5.3", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_5_3 }, 0, 0, VE, "level" }, ++ { "6.0", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_6_0 }, 0, 0, VE, "level" }, ++ { "6.1", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_6_1 }, 0, 0, VE, "level" }, ++ { "6.2", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_6_2 }, 0, 0, VE, "level" }, ++ { "6.3", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_6_3 }, 0, 0, VE, "level" }, ++ { "7.0", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_7_0 }, 0, 0, VE, "level" }, ++ { "7.1", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_7_1 }, 0, 0, VE, "level" }, ++ { "7.2", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_7_2 }, 0, 0, VE, "level" }, ++ { "7.3", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_LEVEL_7_3 }, 0, 0, VE, "level" }, ++ ++ { "quality", "Set the encoding quality", OFFSET(quality), AV_OPT_TYPE_INT, {.i64 = AMF_VIDEO_ENCODER_AV1_QUALITY_PRESET_SPEED }, AMF_VIDEO_ENCODER_AV1_QUALITY_PRESET_HIGH_QUALITY, AMF_VIDEO_ENCODER_AV1_QUALITY_PRESET_SPEED, VE, "quality" }, ++ { "balanced", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_QUALITY_PRESET_BALANCED }, 0, 0, VE, "quality" }, ++ { "speed", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_QUALITY_PRESET_SPEED }, 0, 0, VE, "quality" }, ++ { "quality", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_QUALITY_PRESET_QUALITY }, 0, 0, VE, "quality" }, ++ { "high_quality", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_QUALITY_PRESET_HIGH_QUALITY }, 0, 0, VE, "quality" }, ++ ++ { "rc", "Set the rate control mode", OFFSET(rate_control_mode), AV_OPT_TYPE_INT, {.i64 = AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_UNKNOWN }, AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_UNKNOWN, AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_CBR, VE, "rc" }, ++ { "cqp", "Constant Quantization Parameter", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_CONSTANT_QP }, 0, 0, VE, "rc" }, ++ { "vbr_latency", "Latency Constrained Variable Bitrate", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_LATENCY_CONSTRAINED_VBR }, 0, 0, VE, "rc" }, ++ { "vbr_peak", "Peak Contrained Variable Bitrate", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_PEAK_CONSTRAINED_VBR }, 0, 0, VE, "rc" }, ++ { "cbr", "Constant Bitrate", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_CBR }, 0, 0, VE, "rc" }, ++ { "vbr_quality", "Quality Variable Bitrate", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_QUALITY_VBR }, 0, 0, VE, "rc" }, ++ { "vbr_high_quality", "High Quality Variable Bitrate", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_HIGH_QUALITY_VBR }, 0, 0, VE, "rc" }, ++ { "cbr_high_quality", "High Quality Constant Bitrate", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_HIGH_QUALITY_CBR }, 0, 0, VE, "rc" }, ++ ++ ++ { "header_insertion_mode", "Set header insertion mode", OFFSET(header_insertion_mode), AV_OPT_TYPE_INT,{.i64 = AMF_VIDEO_ENCODER_AV1_HEADER_INSERTION_MODE_NONE }, AMF_VIDEO_ENCODER_AV1_HEADER_INSERTION_MODE_NONE, AMF_VIDEO_ENCODER_AV1_HEADER_INSERTION_MODE_KEY_FRAME_ALIGNED, VE, "hdrmode" }, ++ { "none", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_HEADER_INSERTION_MODE_NONE }, 0, 0, VE, "hdrmode" }, ++ { "gop", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_HEADER_INSERTION_MODE_GOP_ALIGNED }, 0, 0, VE, "hdrmode" }, ++ { "frame", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_HEADER_INSERTION_MODE_KEY_FRAME_ALIGNED }, 0, 0, VE, "hdrmode" }, ++ ++ { "preanalysis", "Enable preanalysis", OFFSET(preanalysis), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, VE}, ++ { "enforce_hrd", "Enforce HRD", OFFSET(enforce_hrd), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, VE}, ++ { "filler_data", "Filler Data Enable", OFFSET(filler_data), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, VE}, ++ ++ // min_qp_i -> min_qp_intra, min_qp_p -> min_qp_inter ++ { "min_qp_i", "min quantization parameter for I-frame", OFFSET(min_qp_i), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 255, VE }, ++ { "max_qp_i", "max quantization parameter for I-frame", OFFSET(max_qp_i), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 255, VE }, ++ { "min_qp_p", "min quantization parameter for P-frame", OFFSET(min_qp_p), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 255, VE }, ++ { "max_qp_p", "max quantization parameter for P-frame", OFFSET(max_qp_p), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 255, VE }, ++ { "qp_p", "quantization parameter for P-frame", OFFSET(qp_p), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 255, VE }, ++ { "qp_i", "quantization parameter for I-frame", OFFSET(qp_i), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 255, VE }, ++ { "skip_frame", "Rate Control Based Frame Skip", OFFSET(skip_frame), AV_OPT_TYPE_BOOL,{.i64 = 0 }, 0, 1, VE }, ++ ++ { "align", "alignment mode", OFFSET(align), AV_OPT_TYPE_INT, {.i64 = AMF_VIDEO_ENCODER_AV1_ALIGNMENT_MODE_NO_RESTRICTIONS }, AMF_VIDEO_ENCODER_AV1_ALIGNMENT_MODE_64X16_ONLY, AMF_VIDEO_ENCODER_AV1_ALIGNMENT_MODE_NO_RESTRICTIONS, VE, "align" }, ++ { "64x16", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_ALIGNMENT_MODE_64X16_ONLY }, 0, 0, VE, "align" }, ++ { "1080p", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_ALIGNMENT_MODE_64X16_1080P_CODED_1082 }, 0, 0, VE, "align" }, ++ { "none", "", 0, AV_OPT_TYPE_CONST, {.i64 = AMF_VIDEO_ENCODER_AV1_ALIGNMENT_MODE_NO_RESTRICTIONS }, 0, 0, VE, "align" }, ++ ++ { NULL } ++ ++}; ++ ++static av_cold int amf_encode_init_av1(AVCodecContext* avctx) ++{ ++ int ret = 0; ++ AMF_RESULT res = AMF_OK; ++ AmfContext* ctx = avctx->priv_data; ++ AMFVariantStruct var = { 0 }; ++ amf_int64 profile = 0; ++ amf_int64 profile_level = 0; ++ AMFBuffer* buffer; ++ AMFGuid guid; ++ AMFRate framerate; ++ AMFSize framesize = AMFConstructSize(avctx->width, avctx->height); ++ ++ ++ ++ if (avctx->framerate.num > 0 && avctx->framerate.den > 0) { ++ framerate = AMFConstructRate(avctx->framerate.num, avctx->framerate.den); ++ } ++ else { ++ framerate = AMFConstructRate(avctx->time_base.den, avctx->time_base.num * avctx->ticks_per_frame); ++ } ++ ++ if ((ret = ff_amf_encode_init(avctx)) < 0) ++ return ret; ++ ++ // init static parameters ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_USAGE, ctx->usage); ++ ++ AMF_ASSIGN_PROPERTY_SIZE(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_FRAMESIZE, framesize); ++ ++ AMF_ASSIGN_PROPERTY_RATE(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_FRAMERATE, framerate); ++ ++ switch (avctx->profile) { ++ case FF_PROFILE_AV1_MAIN: ++ profile = AMF_VIDEO_ENCODER_AV1_PROFILE_MAIN; ++ break; ++ default: ++ break; ++ } ++ if (profile == 0) { ++ profile = ctx->profile; ++ } ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_PROFILE, profile); ++ ++ profile_level = avctx->level; ++ if (profile_level == FF_LEVEL_UNKNOWN) { ++ profile_level = ctx->level; ++ } ++ if (profile_level != 0) { ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_LEVEL, profile_level); ++ } ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_QUALITY_PRESET, ctx->quality); ++ ++ // Maximum Reference Frames ++ if (avctx->refs != -1) { ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_MAX_NUM_REFRAMES, avctx->refs); ++ } ++ ++ // Picture control properties ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_GOP_SIZE, avctx->gop_size); ++ ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_HEADER_INSERTION_MODE, ctx->header_insertion_mode); ++ ++ // Rate control ++ // autodetect rate control method ++ if (ctx->rate_control_mode == AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_UNKNOWN) { ++ if (ctx->min_qp_i != -1 || ctx->max_qp_i != -1 || ++ ctx->min_qp_p != -1 || ctx->max_qp_p != -1 || ++ ctx->qp_i != -1 || ctx->qp_p != -1) { ++ ctx->rate_control_mode = AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_CONSTANT_QP; ++ av_log(ctx, AV_LOG_DEBUG, "Rate control turned to CQP\n"); ++ } ++ else if (avctx->rc_max_rate > 0) { ++ ctx->rate_control_mode = AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_PEAK_CONSTRAINED_VBR; ++ av_log(ctx, AV_LOG_DEBUG, "Rate control turned to Peak VBR\n"); ++ } ++ else { ++ ctx->rate_control_mode = AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_CBR; ++ av_log(ctx, AV_LOG_DEBUG, "Rate control turned to CBR\n"); ++ } ++ } ++ ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD, ctx->rate_control_mode); ++ if (avctx->rc_buffer_size) { ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_VBV_BUFFER_SIZE, avctx->rc_buffer_size); ++ ++ if (avctx->rc_initial_buffer_occupancy != 0) { ++ int amf_buffer_fullness = avctx->rc_initial_buffer_occupancy * 64 / avctx->rc_buffer_size; ++ if (amf_buffer_fullness > 64) ++ amf_buffer_fullness = 64; ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_INITIAL_VBV_BUFFER_FULLNESS, amf_buffer_fullness); ++ } ++ } ++ ++ // Pre-Pass, Pre-Analysis, Two-Pass ++ AMF_ASSIGN_PROPERTY_BOOL(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_PRE_ANALYSIS_ENABLE, ctx->preanalysis); ++ ++ // init dynamic rate control params ++ if (ctx->max_au_size) ++ ctx->enforce_hrd = 1; ++ AMF_ASSIGN_PROPERTY_BOOL(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_ENFORCE_HRD, ctx->enforce_hrd); ++ AMF_ASSIGN_PROPERTY_BOOL(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_FILLER_DATA, ctx->filler_data); ++ ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_TARGET_BITRATE, avctx->bit_rate); ++ ++ if (ctx->rate_control_mode == AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_CBR) { ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_PEAK_BITRATE, avctx->bit_rate); ++ } ++ if (avctx->rc_max_rate) { ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_PEAK_BITRATE, avctx->rc_max_rate); ++ } ++ else if (ctx->rate_control_mode == AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_PEAK_CONSTRAINED_VBR) { ++ av_log(ctx, AV_LOG_WARNING, "rate control mode is PEAK_CONSTRAINED_VBR but rc_max_rate is not set\n"); ++ } ++ if (avctx->bit_rate > 0) { ++ ctx->rate_control_mode = AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_METHOD_CBR; ++ av_log(ctx, AV_LOG_DEBUG, "Rate control turned to CBR\n"); ++ } ++ ++ switch (ctx->align) ++ { ++ case AMF_VIDEO_ENCODER_AV1_ALIGNMENT_MODE_64X16_ONLY: ++ if (avctx->width / 64 * 64 != avctx->width || avctx->height / 16 * 16 != avctx->height) ++ { ++ res = AMF_NOT_SUPPORTED; ++ av_log(ctx, AV_LOG_ERROR, "Resolution incorrect for alignment mode\n"); ++ return AVERROR_EXIT; ++ } ++ break; ++ case AMF_VIDEO_ENCODER_AV1_ALIGNMENT_MODE_64X16_1080P_CODED_1082: ++ if ((avctx->width / 64 * 64 == avctx->width && avctx->height / 16 * 16 == avctx->height) || (avctx->width == 1920 && avctx->height == 1080)) ++ { ++ res = AMF_OK; ++ } ++ else ++ { ++ res = AMF_NOT_SUPPORTED; ++ av_log(ctx, AV_LOG_ERROR, "Resolution incorrect for alignment mode\n"); ++ return AVERROR_EXIT; ++ } ++ break; ++ case AMF_VIDEO_ENCODER_AV1_ALIGNMENT_MODE_NO_RESTRICTIONS: ++ res = AMF_OK; ++ break; ++ default: ++ res = AMF_NOT_SUPPORTED; ++ av_log(ctx, AV_LOG_ERROR, "Invalid alignment mode\n"); ++ return AVERROR_EXIT; ++ } ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_ALIGNMENT_MODE, ctx->align); ++ ++ ++ // init encoder ++ res = ctx->encoder->pVtbl->Init(ctx->encoder, ctx->format, avctx->width, avctx->height); ++ AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR_BUG, "encoder->Init() failed with error %d\n", res); ++ ++ // init dynamic picture control params ++ if (ctx->min_qp_i != -1) { ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_MIN_Q_INDEX_INTRA, ctx->min_qp_i); ++ } ++ else if (avctx->qmin != -1) { ++ int qval = avctx->qmin > 255 ? 255 : avctx->qmin; ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_MIN_Q_INDEX_INTRA, qval); ++ } ++ if (ctx->max_qp_i != -1) { ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_MAX_Q_INDEX_INTRA, ctx->max_qp_i); ++ } ++ else if (avctx->qmax != -1) { ++ int qval = avctx->qmax > 255 ? 255 : avctx->qmax; ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_MAX_Q_INDEX_INTRA, qval); ++ } ++ if (ctx->min_qp_p != -1) { ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_MIN_Q_INDEX_INTER, ctx->min_qp_p); ++ } ++ else if (avctx->qmin != -1) { ++ int qval = avctx->qmin > 255 ? 255 : avctx->qmin; ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_MIN_Q_INDEX_INTER, qval); ++ } ++ if (ctx->max_qp_p != -1) { ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_MAX_Q_INDEX_INTER, ctx->max_qp_p); ++ } ++ else if (avctx->qmax != -1) { ++ int qval = avctx->qmax > 255 ? 255 : avctx->qmax; ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_MAX_Q_INDEX_INTER, qval); ++ } ++ ++ if (ctx->qp_p != -1) { ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_Q_INDEX_INTER, ctx->qp_p); ++ } ++ if (ctx->qp_i != -1) { ++ AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_Q_INDEX_INTRA, ctx->qp_i); ++ } ++ AMF_ASSIGN_PROPERTY_BOOL(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_RATE_CONTROL_SKIP_FRAME, ctx->skip_frame); ++ ++ ++ // fill extradata ++ res = AMFVariantInit(&var); ++ AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR_BUG, "AMFVariantInit() failed with error %d\n", res); ++ ++ res = ctx->encoder->pVtbl->GetProperty(ctx->encoder, AMF_VIDEO_ENCODER_AV1_EXTRA_DATA, &var); ++ AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR_BUG, "GetProperty(AMF_VIDEO_ENCODER_EXTRADATA) failed with error %d\n", res); ++ AMF_RETURN_IF_FALSE(ctx, var.pInterface != NULL, AVERROR_BUG, "GetProperty(AMF_VIDEO_ENCODER_EXTRADATA) returned NULL\n"); ++ ++ guid = IID_AMFBuffer(); ++ ++ res = var.pInterface->pVtbl->QueryInterface(var.pInterface, &guid, (void**)&buffer); // query for buffer interface ++ if (res != AMF_OK) { ++ var.pInterface->pVtbl->Release(var.pInterface); ++ } ++ AMF_RETURN_IF_FALSE(ctx, res == AMF_OK, AVERROR_BUG, "QueryInterface(IID_AMFBuffer) failed with error %d\n", res); ++ ++ avctx->extradata_size = (int)buffer->pVtbl->GetSize(buffer); ++ avctx->extradata = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE); ++ if (!avctx->extradata) { ++ buffer->pVtbl->Release(buffer); ++ var.pInterface->pVtbl->Release(var.pInterface); ++ return AVERROR(ENOMEM); ++ } ++ memcpy(avctx->extradata, buffer->pVtbl->GetNative(buffer), avctx->extradata_size); ++ ++ buffer->pVtbl->Release(buffer); ++ var.pInterface->pVtbl->Release(var.pInterface); ++ ++ return 0; ++} ++ ++static const FFCodecDefault defaults[] = { ++ { "refs", "-1" }, ++ { "aspect", "0" }, ++ { "b", "2M" }, ++ { "g", "250" }, ++ { "qmin", "-1" }, ++ { "qmax", "-1" }, ++ { NULL }, ++}; ++ ++static const AVClass av1_amf_class = { ++ .class_name = "av1_amf", ++ .item_name = av_default_item_name, ++ .option = options, ++ .version = LIBAVUTIL_VERSION_INT, ++}; ++ ++const FFCodec ff_av1_amf_encoder = { ++ .p.name = "av1_amf", ++ .p.long_name = NULL_IF_CONFIG_SMALL("AMD AMF AV1 encoder"), ++ .p.type = AVMEDIA_TYPE_VIDEO, ++ .p.id = AV_CODEC_ID_AV1, ++ .init = amf_encode_init_av1, ++ FF_CODEC_RECEIVE_PACKET_CB(ff_amf_receive_packet), ++ .close = ff_amf_encode_close, ++ .priv_data_size = sizeof(AmfContext), ++ .p.priv_class = &av1_amf_class, ++ .defaults = defaults, ++ .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE | ++ AV_CODEC_CAP_DR1, ++ .caps_internal = FF_CODEC_CAP_INIT_CLEANUP, ++ .p.pix_fmts = ff_amf_pix_fmts, ++ .p.wrapper_name = "amf", ++ .hw_configs = ff_amfenc_hw_configs, ++}; +\ No newline at end of file