History

libavcodec/qsvenc_av1: add av1_qsv encoder

It is available only when libvpl is enabled. MSDK doesn't support av1 encoding. sample command: ffmpeg -f rawvideo -pix_fmt nv12 -s 1920x1080 -i input.yuv \ -c:v av1_qsv output.ivf

Wenbin Chen committed 4 years ago

Commit dc9e4781 parent 874a6f26 files · +358 −5Browse files

Unified · Split

6 files
  1. configure +2 −0
  2. libavcodec/Makefile +1 −0
  3. libavcodec/allcodecs.c +1 −0
  4. libavcodec/qsvenc.c +192 −4
  5. libavcodec/qsvenc.h +6 −1
  6. libavcodec/qsvenc_av1.c +156 −0
configure+2−0
@@ -3271,6 +3271,8 @@ vp9_qsv_encoder_select="qsvenc" · 3270 unmodified lines
3271vp9_v4l2m2m_decoder_deps="v4l2_m2m vp9_v4l2_m2m"3271vp9_v4l2m2m_decoder_deps="v4l2_m2m vp9_v4l2_m2m"
3272wmv3_crystalhd_decoder_select="crystalhd"3272wmv3_crystalhd_decoder_select="crystalhd"
3273av1_qsv_decoder_select="qsvdec"3273av1_qsv_decoder_select="qsvdec"
3274av1_qsv_encoder_select="qsvenc"
3275av1_qsv_encoder_deps="libvpl"
3274 3276
3275# parsers3277# parsers
3276aac_parser_select="adts_header mpeg4audio"3278aac_parser_select="adts_header mpeg4audio"
libavcodec/Makefile+1−0
@@ -244,6 +244,7 @@ OBJS-$(CONFIG_AURA_DECODER) += cyuv.o · 243 unmodified lines
244OBJS-$(CONFIG_AURA2_DECODER) += aura.o244OBJS-$(CONFIG_AURA2_DECODER) += aura.o
245OBJS-$(CONFIG_AV1_DECODER) += av1dec.o245OBJS-$(CONFIG_AV1_DECODER) += av1dec.o
246OBJS-$(CONFIG_AV1_CUVID_DECODER) += cuviddec.o246OBJS-$(CONFIG_AV1_CUVID_DECODER) += cuviddec.o
247OBJS-$(CONFIG_AV1_QSV_ENCODER) += qsvenc_av1.o
247OBJS-$(CONFIG_AVRN_DECODER) += avrndec.o248OBJS-$(CONFIG_AVRN_DECODER) += avrndec.o
248OBJS-$(CONFIG_AVRP_DECODER) += r210dec.o249OBJS-$(CONFIG_AVRP_DECODER) += r210dec.o
249OBJS-$(CONFIG_AVRP_ENCODER) += r210enc.o250OBJS-$(CONFIG_AVRP_ENCODER) += r210enc.o
libavcodec/allcodecs.c+1−0
@@ -828,6 +828,7 @@ extern const FFCodec ff_libaom_av1_decoder; · 827 unmodified lines
828extern const FFCodec ff_av1_decoder;828extern const FFCodec ff_av1_decoder;
829extern const FFCodec ff_av1_cuvid_decoder;829extern const FFCodec ff_av1_cuvid_decoder;
830extern const FFCodec ff_av1_qsv_decoder;830extern const FFCodec ff_av1_qsv_decoder;
831extern const FFCodec ff_av1_qsv_encoder;
831extern const FFCodec ff_libopenh264_encoder;832extern const FFCodec ff_libopenh264_encoder;
832extern const FFCodec ff_libopenh264_decoder;833extern const FFCodec ff_libopenh264_decoder;
833extern const FFCodec ff_h264_amf_encoder;834extern const FFCodec ff_h264_amf_encoder;
libavcodec/qsvenc.c+192−4
@@ -82,6 +82,14 @@ static const struct profile_names vp9_profiles[] = { · 81 unmodified lines
82 { MFX_PROFILE_VP9_3, "vp9 3" },82 { MFX_PROFILE_VP9_3, "vp9 3" },
83};83};
84 84
85static const struct profile_names av1_profiles[] = {
86#if QSV_VERSION_ATLEAST(1, 34)
87 { MFX_PROFILE_AV1_MAIN, "av1 main" },
88 { MFX_PROFILE_AV1_HIGH, "av1 high" },
89 { MFX_PROFILE_AV1_PRO, "av1 professional" },
90#endif
91};
92
85typedef struct QSVPacket {93typedef struct QSVPacket {
86 AVPacket pkt;94 AVPacket pkt;
87 mfxSyncPoint *sync;95 mfxSyncPoint *sync;
@@ -114,6 +122,11 @@ static const char *print_profile(enum AVCodecID codec_id, mfxU16 profile) · 26 unmodified lines
114 num_profiles = FF_ARRAY_ELEMS(vp9_profiles);122 num_profiles = FF_ARRAY_ELEMS(vp9_profiles);
115 break;123 break;
116 124
125 case AV_CODEC_ID_AV1:
126 profiles = av1_profiles;
127 num_profiles = FF_ARRAY_ELEMS(av1_profiles);
128 break;
129
117 default:130 default:
118 return "unknown";131 return "unknown";
119 }132 }
@@ -429,6 +442,88 @@ static void dump_video_mjpeg_param(AVCodecContext *avctx, QSVEncContext *q) · 309 unmodified lines
429 info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);442 info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);
430}443}
431 444
445#if QSV_HAVE_EXT_AV1_PARAM
446static void dump_video_av1_param(AVCodecContext *avctx, QSVEncContext *q,
447 mfxExtBuffer **coding_opts)
448{
449 mfxInfoMFX *info = &q->param.mfx;
450 mfxExtAV1TileParam *av1_tile_param = (mfxExtAV1TileParam *)coding_opts[0];
451 mfxExtAV1BitstreamParam *av1_bs_param = (mfxExtAV1BitstreamParam *)coding_opts[1];
452 mfxExtCodingOption2 *co2 = (mfxExtCodingOption2*)coding_opts[2];
453 mfxExtCodingOption3 *co3 = (mfxExtCodingOption3*)coding_opts[3];
454
455 av_log(avctx, AV_LOG_VERBOSE, "profile: %s; level: %"PRIu16"\n",
456 print_profile(avctx->codec_id, info->CodecProfile), info->CodecLevel);
457
458 av_log(avctx, AV_LOG_VERBOSE,
459 "GopPicSize: %"PRIu16"; GopRefDist: %"PRIu16"; GopOptFlag:%s%s; IdrInterval: %"PRIu16"\n",
460 info->GopPicSize, info->GopRefDist,
461 info->GopOptFlag & MFX_GOP_CLOSED ? " closed" : "",
462 info->GopOptFlag & MFX_GOP_STRICT ? " strict" : "",
463 info->IdrInterval);
464
465 av_log(avctx, AV_LOG_VERBOSE, "TargetUsage: %"PRIu16"; RateControlMethod: %s\n",
466 info->TargetUsage, print_ratecontrol(info->RateControlMethod));
467
468 if (info->RateControlMethod == MFX_RATECONTROL_CBR ||
469 info->RateControlMethod == MFX_RATECONTROL_VBR)
470 av_log(avctx, AV_LOG_VERBOSE,
471 "BufferSizeInKB: %"PRIu16"; InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
472 info->BufferSizeInKB, info->InitialDelayInKB, info->TargetKbps, info->MaxKbps, info->BRCParamMultiplier);
473 else if (info->RateControlMethod == MFX_RATECONTROL_CQP)
474 av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",
475 info->QPI, info->QPP, info->QPB);
476 else if (info->RateControlMethod == MFX_RATECONTROL_ICQ)
477 av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);
478 else
479 av_log(avctx, AV_LOG_VERBOSE, "Unsupported ratecontrol method: %d \n", info->RateControlMethod);
480
481 av_log(avctx, AV_LOG_VERBOSE, "NumRefFrame: %"PRIu16"\n", info->NumRefFrame);
482
483 av_log(avctx, AV_LOG_VERBOSE,
484 "IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16
485 "; IntRefQPDelta: %"PRId16"; IntRefCycleDist: %"PRId16"\n",
486 co2->IntRefType, co2->IntRefCycleSize,
487 co2->IntRefQPDelta, co3->IntRefCycleDist);
488
489 av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %d;\n", co2->MaxFrameSize);
490
491 av_log(avctx, AV_LOG_VERBOSE,
492 "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
493 print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),
494 print_threestate(co2->ExtBRC));
495
496 av_log(avctx, AV_LOG_VERBOSE, "VDENC: %s\n", print_threestate(info->LowPower));
497
498 switch (co2->BRefType) {
499 case MFX_B_REF_OFF: av_log(avctx, AV_LOG_VERBOSE, "BRefType: off\n"); break;
500 case MFX_B_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "BRefType: pyramid\n"); break;
501 default: av_log(avctx, AV_LOG_VERBOSE, "BRefType: auto\n"); break;
502 }
503
504 switch (co3->PRefType) {
505 case MFX_P_REF_DEFAULT: av_log(avctx, AV_LOG_VERBOSE, "PRefType: default\n"); break;
506 case MFX_P_REF_SIMPLE: av_log(avctx, AV_LOG_VERBOSE, "PRefType: simple\n"); break;
507 case MFX_P_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "PRefType: pyramid\n"); break;
508 default: av_log(avctx, AV_LOG_VERBOSE, "PRefType: unknown\n"); break;
509 }
510
511 av_log(avctx, AV_LOG_VERBOSE,
512 "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",
513 co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
514
515 av_log(avctx, AV_LOG_VERBOSE, "FrameRateExtD: %"PRIu32"; FrameRateExtN: %"PRIu32" \n",
516 info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);
517
518 av_log(avctx, AV_LOG_VERBOSE,
519 "NumTileRows: %"PRIu16"; NumTileColumns: %"PRIu16"; NumTileGroups: %"PRIu16"\n",
520 av1_tile_param->NumTileRows, av1_tile_param->NumTileColumns, av1_tile_param->NumTileGroups);
521
522 av_log(avctx, AV_LOG_VERBOSE, "WriteIVFHeaders: %s \n",
523 print_threestate(av1_bs_param->WriteIVFHeaders));
524}
525#endif
526
432static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q)527static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q)
433{528{
434 const char *rc_desc;529 const char *rc_desc;
@@ -741,10 +836,15 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q) · 306 unmodified lines
741 break;836 break;
742 case MFX_RATECONTROL_CQP:837 case MFX_RATECONTROL_CQP:
743 quant = avctx->global_quality / FF_QP2LAMBDA;838 quant = avctx->global_quality / FF_QP2LAMBDA;
744 839 if (avctx->codec_id == AV_CODEC_ID_AV1) {
745 q->param.mfx.QPI = av_clip(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 0, 51);840 q->param.mfx.QPI = av_clip_uintp2(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 8);
746 q->param.mfx.QPP = av_clip(quant, 0, 51);841 q->param.mfx.QPP = av_clip_uintp2(quant, 8);
747 q->param.mfx.QPB = av_clip(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 0, 51);842 q->param.mfx.QPB = av_clip_uintp2(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 8);
843 } else {
844 q->param.mfx.QPI = av_clip(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 0, 51);
845 q->param.mfx.QPP = av_clip(quant, 0, 51);
846 q->param.mfx.QPB = av_clip(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 0, 51);
847 }
748 q->old_global_quality = avctx->global_quality;848 q->old_global_quality = avctx->global_quality;
749 q->old_i_quant_factor = avctx->i_quant_factor;849 q->old_i_quant_factor = avctx->i_quant_factor;
750 q->old_i_quant_offset = avctx->i_quant_offset;850 q->old_i_quant_offset = avctx->i_quant_offset;
@@ -895,6 +995,20 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q) · 144 unmodified lines
895 q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;995 q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
896 q->extco2.Header.BufferSz = sizeof(q->extco2);996 q->extco2.Header.BufferSz = sizeof(q->extco2);
897 997
998 q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
999 } else if (avctx->codec_id == AV_CODEC_ID_AV1) {
1000 if (q->extbrc >= 0)
1001 q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1002 if (q->b_strategy >= 0)
1003 q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
1004 if (q->adaptive_i >= 0)
1005 q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1006 if (q->adaptive_b >= 0)
1007 q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1008
1009 q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
1010 q->extco2.Header.BufferSz = sizeof(q->extco2);
1011
898 q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;1012 q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
899 }1013 }
900 1014
@@ -972,6 +1086,27 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q) · 71 unmodified lines
972 q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extvp9param;1086 q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extvp9param;
973 }1087 }
974 1088
1089#if QSV_HAVE_EXT_AV1_PARAM
1090 if (avctx->codec_id == AV_CODEC_ID_AV1) {
1091 if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 2, 5)) {
1092 q->extav1tileparam.Header.BufferId = MFX_EXTBUFF_AV1_TILE_PARAM;
1093 q->extav1tileparam.Header.BufferSz = sizeof(q->extav1tileparam);
1094 q->extav1tileparam.NumTileColumns = q->tile_cols;
1095 q->extav1tileparam.NumTileRows = q->tile_rows;
1096 q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extav1tileparam;
1097
1098 q->extav1bsparam.Header.BufferId = MFX_EXTBUFF_AV1_BITSTREAM_PARAM;
1099 q->extav1bsparam.Header.BufferSz = sizeof(q->extav1bsparam);
1100 q->extav1bsparam.WriteIVFHeaders = MFX_CODINGOPTION_OFF;
1101 q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extav1bsparam;
1102 } else {
1103 av_log(avctx, AV_LOG_ERROR,
1104 "This version of runtime doesn't support AV1 encoding\n");
1105 return AVERROR_UNKNOWN;
1106 }
1107 }
1108#endif
1109
975 if (avctx->codec_id == AV_CODEC_ID_HEVC) {1110 if (avctx->codec_id == AV_CODEC_ID_HEVC) {
976 q->exthevctiles.Header.BufferId = MFX_EXTBUFF_HEVC_TILES;1111 q->exthevctiles.Header.BufferId = MFX_EXTBUFF_HEVC_TILES;
977 q->exthevctiles.Header.BufferSz = sizeof(q->exthevctiles);1112 q->exthevctiles.Header.BufferSz = sizeof(q->exthevctiles);
@@ -1082,6 +1217,56 @@ static int qsv_retrieve_enc_vp9_params(AVCodecContext *avctx, QSVEncContext *q) · 104 unmodified lines
1082 return 0;1217 return 0;
1083}1218}
1084 1219
1220static int qsv_retrieve_enc_av1_params(AVCodecContext *avctx, QSVEncContext *q)
1221{
1222#if QSV_HAVE_EXT_AV1_PARAM
1223 int ret = 0;
1224 mfxExtAV1TileParam av1_extend_tile_buf = {
1225 .Header.BufferId = MFX_EXTBUFF_AV1_TILE_PARAM,
1226 .Header.BufferSz = sizeof(av1_extend_tile_buf),
1227 };
1228 mfxExtAV1BitstreamParam av1_bs_param = {
1229 .Header.BufferId = MFX_EXTBUFF_AV1_BITSTREAM_PARAM,
1230 .Header.BufferSz = sizeof(av1_bs_param),
1231 };
1232
1233 mfxExtCodingOption2 co2 = {
1234 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
1235 .Header.BufferSz = sizeof(co2),
1236 };
1237
1238 mfxExtCodingOption3 co3 = {
1239 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
1240 .Header.BufferSz = sizeof(co3),
1241 };
1242
1243 mfxExtBuffer *ext_buffers[] = {
1244 (mfxExtBuffer*)&av1_extend_tile_buf,
1245 (mfxExtBuffer*)&av1_bs_param,
1246 (mfxExtBuffer*)&co2,
1247 (mfxExtBuffer*)&co3,
1248 };
1249
1250 if (!QSV_RUNTIME_VERSION_ATLEAST(q->ver, 2, 5)) {
1251 av_log(avctx, AV_LOG_ERROR,
1252 "This version of runtime doesn't support AV1 encoding\n");
1253 return AVERROR_UNKNOWN;
1254 }
1255
1256 q->param.ExtParam = ext_buffers;
1257 q->param.NumExtParam = FF_ARRAY_ELEMS(ext_buffers);
1258
1259 ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
1260 if (ret < 0)
1261 return ff_qsv_print_error(avctx, ret,
1262 "Error calling GetVideoParam");
1263
1264 q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
1265 dump_video_av1_param(avctx, q, ext_buffers);
1266#endif
1267 return 0;
1268}
1269
1085static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)1270static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
1086{1271{
1087 AVCPBProperties *cpb_props;1272 AVCPBProperties *cpb_props;
@@ -1420,6 +1605,9 @@ int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q) · 332 unmodified lines
1420 case AV_CODEC_ID_VP9:1605 case AV_CODEC_ID_VP9:
1421 ret = qsv_retrieve_enc_vp9_params(avctx, q);1606 ret = qsv_retrieve_enc_vp9_params(avctx, q);
1422 break;1607 break;
1608 case AV_CODEC_ID_AV1:
1609 ret = qsv_retrieve_enc_av1_params(avctx, q);
1610 break;
1423 default:1611 default:
1424 ret = qsv_retrieve_enc_params(avctx, q);1612 ret = qsv_retrieve_enc_params(avctx, q);
1425 break;1613 break;
libavcodec/qsvenc.h+6−1
@@ -39,6 +39,7 @@ · 38 unmodified lines
39#include "qsv_internal.h"39#include "qsv_internal.h"
40 40
41#define QSV_HAVE_EXT_VP9_TILES QSV_VERSION_ATLEAST(1, 29)41#define QSV_HAVE_EXT_VP9_TILES QSV_VERSION_ATLEAST(1, 29)
42#define QSV_HAVE_EXT_AV1_PARAM QSV_VERSION_ATLEAST(2, 5)
42 43
43#if defined(_WIN32) || defined(__CYGWIN__)44#if defined(_WIN32) || defined(__CYGWIN__)
44#define QSV_HAVE_AVBR 145#define QSV_HAVE_AVBR 1
@@ -154,6 +155,10 @@ typedef struct QSVEncContext { · 109 unmodified lines
154#endif155#endif
155 mfxExtHEVCTiles exthevctiles;156 mfxExtHEVCTiles exthevctiles;
156 mfxExtVP9Param extvp9param;157 mfxExtVP9Param extvp9param;
158#if QSV_HAVE_EXT_AV1_PARAM
159 mfxExtAV1TileParam extav1tileparam;
160 mfxExtAV1BitstreamParam extav1bsparam;
161#endif
157 162
158#if QSV_HAVE_OPAQUE163#if QSV_HAVE_OPAQUE
159 mfxExtOpaqueSurfaceAlloc opaque_alloc;164 mfxExtOpaqueSurfaceAlloc opaque_alloc;
@@ -163,7 +168,7 @@ typedef struct QSVEncContext { · 3 unmodified lines
163 168
164 mfxExtVideoSignalInfo extvsi;169 mfxExtVideoSignalInfo extvsi;
165 170
166 mfxExtBuffer *extparam_internal[5 + (QSV_HAVE_MF * 2)];171 mfxExtBuffer *extparam_internal[5 + (QSV_HAVE_MF * 2) + QSV_HAVE_EXT_AV1_PARAM * 2];
167 int nb_extparam_internal;172 int nb_extparam_internal;
168 173
169 mfxExtBuffer **extparam;174 mfxExtBuffer **extparam;
libavcodec/qsvenc_av1.c+156−0
@@ -0,0 +1,156 @@
1/*
2 * Intel MediaSDK QSV based AV1 encoder
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21
22#include <stdint.h>
23#include <sys/types.h>
24
25#include <mfxvideo.h>
26
27#include "libavutil/common.h"
28#include "libavutil/opt.h"
29
30#include "avcodec.h"
31#include "codec_internal.h"
32#include "bsf.h"
33#include "qsv.h"
34#include "qsvenc.h"
35
36typedef struct QSVAV1EncContext {
37 AVClass *class;
38 AVBSFContext *extra_data_bsf;
39 QSVEncContext qsv;
40} QSVAV1EncContext;
41
42static av_cold int qsv_enc_init(AVCodecContext *avctx)
43{
44 QSVAV1EncContext *q = avctx->priv_data;
45 int ret;
46
47 if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
48 const AVBitStreamFilter *filter = av_bsf_get_by_name("extract_extradata");
49 if (!filter) {
50 av_log(avctx, AV_LOG_ERROR, "Cannot get extract_extradata bitstream filter\n");
51 return AVERROR_BUG;
52 }
53 ret = av_bsf_alloc(filter, &q->extra_data_bsf);
54 if (ret < 0)
55 return ret;
56 ret = avcodec_parameters_from_context(q->extra_data_bsf->par_in, avctx);
57 if (ret < 0)
58 return ret;
59 ret = av_bsf_init(q->extra_data_bsf);
60 if (ret < 0)
61 return ret;
62 }
63
64 return ff_qsv_enc_init(avctx, &q->qsv);
65}
66
67static int qsv_enc_frame(AVCodecContext *avctx, AVPacket *pkt,
68 const AVFrame *frame, int *got_packet)
69{
70 QSVAV1EncContext *q = avctx->priv_data;
71 int ret;
72
73 ret = ff_qsv_encode(avctx, &q->qsv, pkt, frame, got_packet);
74 if (ret < 0)
75 return ret;
76
77 if (*got_packet && avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
78 ret = av_bsf_send_packet(q->extra_data_bsf, pkt);
79 if (ret < 0) {
80 av_log(avctx, AV_LOG_ERROR, "extract_extradata filter "
81 "failed to send input packet\n");
82 return ret;
83 }
84
85 ret = av_bsf_receive_packet(q->extra_data_bsf, pkt);
86 if (ret < 0) {
87 av_log(avctx, AV_LOG_ERROR, "extract_extradata filter "
88 "failed to receive output packet\n");
89 return ret;
90 }
91 }
92
93 return ret;
94}
95
96static av_cold int qsv_enc_close(AVCodecContext *avctx)
97{
98 QSVAV1EncContext *q = avctx->priv_data;
99
100 av_bsf_free(&q->extra_data_bsf);
101
102 return ff_qsv_enc_close(avctx, &q->qsv);
103}
104
105#define OFFSET(x) offsetof(QSVAV1EncContext, x)
106#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
107static const AVOption options[] = {
108 QSV_COMMON_OPTS
109 QSV_OPTION_B_STRATEGY
110 QSV_OPTION_ADAPTIVE_I
111 QSV_OPTION_ADAPTIVE_B
112 QSV_OPTION_EXTBRC
113 { "profile", NULL, OFFSET(qsv.profile), AV_OPT_TYPE_INT, { .i64 = MFX_PROFILE_UNKNOWN }, 0, INT_MAX, VE, "profile" },
114 { "unknown" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, VE, "profile" },
115 { "main" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_AV1_MAIN }, INT_MIN, INT_MAX, VE, "profile" },
116 { "tile_cols", "Number of columns for tiled encoding", OFFSET(qsv.tile_cols), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, UINT16_MAX, VE },
117 { "tile_rows", "Number of rows for tiled encoding", OFFSET(qsv.tile_rows), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, UINT16_MAX, VE },
118 { "look_ahead_depth", "Depth of look ahead in number frames, available when extbrc option is enabled", OFFSET(qsv.look_ahead_depth), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 100, VE },
119 { NULL },
120};
121
122static const AVClass class = {
123 .class_name = "av1_qsv encoder",
124 .item_name = av_default_item_name,
125 .option = options,
126 .version = LIBAVUTIL_VERSION_INT,
127};
128
129static const FFCodecDefault qsv_enc_defaults[] = {
130 { "b", "1M" },
131 { "g", "-1" },
132 { "bf", "-1" },
133 { "refs", "0" },
134 { NULL },
135};
136
137FFCodec ff_av1_qsv_encoder = {
138 .p.name = "av1_qsv",
139 .p.long_name = NULL_IF_CONFIG_SMALL("AV1 (Intel Quick Sync Video acceleration)"),
140 .priv_data_size = sizeof(QSVAV1EncContext),
141 .p.type = AVMEDIA_TYPE_VIDEO,
142 .p.id = AV_CODEC_ID_AV1,
143 .init = qsv_enc_init,
144 FF_CODEC_ENCODE_CB(qsv_enc_frame),
145 .close = qsv_enc_close,
146 .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HYBRID,
147 .p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_NV12,
148 AV_PIX_FMT_P010,
149 AV_PIX_FMT_QSV,
150 AV_PIX_FMT_NONE },
151 .p.priv_class = &class,
152 .defaults = qsv_enc_defaults,
153 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
154 .p.wrapper_name = "qsv",
155 .hw_configs = ff_qsv_enc_hw_configs,
156};

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t