25 #include <sys/types.h> 26 #include <mfx/mfxvideo.h> 48 { MFX_PROFILE_AVC_BASELINE,
"baseline" },
49 { MFX_PROFILE_AVC_MAIN,
"main" },
50 { MFX_PROFILE_AVC_EXTENDED,
"extended" },
51 { MFX_PROFILE_AVC_HIGH,
"high" },
52 #if QSV_VERSION_ATLEAST(1, 15) 53 { MFX_PROFILE_AVC_HIGH_422,
"high 422" },
55 #if QSV_VERSION_ATLEAST(1, 4) 56 { MFX_PROFILE_AVC_CONSTRAINED_BASELINE,
"constrained baseline" },
57 { MFX_PROFILE_AVC_CONSTRAINED_HIGH,
"constrained high" },
58 { MFX_PROFILE_AVC_PROGRESSIVE_HIGH,
"progressive high" },
60 { MFX_PROFILE_MPEG2_SIMPLE,
"simple" },
61 { MFX_PROFILE_MPEG2_MAIN,
"main" },
62 { MFX_PROFILE_MPEG2_HIGH,
"high" },
63 { MFX_PROFILE_VC1_SIMPLE,
"simple" },
64 { MFX_PROFILE_VC1_MAIN,
"main" },
65 { MFX_PROFILE_VC1_ADVANCED,
"advanced" },
66 #if QSV_VERSION_ATLEAST(1, 8) 67 { MFX_PROFILE_HEVC_MAIN,
"main" },
68 { MFX_PROFILE_HEVC_MAIN10,
"main10" },
69 { MFX_PROFILE_HEVC_MAINSP,
"mainsp" },
70 { MFX_PROFILE_HEVC_REXT,
"rext" },
87 { MFX_RATECONTROL_CBR,
"CBR" },
88 { MFX_RATECONTROL_VBR,
"VBR" },
89 { MFX_RATECONTROL_CQP,
"CQP" },
91 { MFX_RATECONTROL_AVBR,
"AVBR" },
94 { MFX_RATECONTROL_LA,
"LA" },
97 { MFX_RATECONTROL_ICQ,
"ICQ" },
98 { MFX_RATECONTROL_LA_ICQ,
"LA_ICQ" },
101 { MFX_RATECONTROL_VCM,
"VCM" },
103 #if QSV_VERSION_ATLEAST(1, 10) 104 { MFX_RATECONTROL_LA_EXT,
"LA_EXT" },
107 { MFX_RATECONTROL_LA_HRD,
"LA_HRD" },
110 { MFX_RATECONTROL_QVBR,
"QVBR" },
125 if (val == MFX_CODINGOPTION_ON)
127 else if (val == MFX_CODINGOPTION_OFF)
133 mfxExtBuffer **coding_opts)
135 mfxInfoMFX *info = &q->
param.mfx;
137 mfxExtCodingOption *co = (mfxExtCodingOption*)coding_opts[0];
139 mfxExtCodingOption2 *co2 = (mfxExtCodingOption2*)coding_opts[1];
142 mfxExtCodingOption3 *co3 = (mfxExtCodingOption3*)coding_opts[2];
144 #if QSV_HAVE_EXT_HEVC_TILES 145 mfxExtHEVCTiles *exthevctiles = (mfxExtHEVCTiles *)coding_opts[3 +
QSV_HAVE_CO_VPS];
152 info->GopPicSize, info->GopRefDist);
153 if (info->GopOptFlag & MFX_GOP_CLOSED)
155 if (info->GopOptFlag & MFX_GOP_STRICT)
162 if (info->RateControlMethod == MFX_RATECONTROL_CBR ||
163 info->RateControlMethod == MFX_RATECONTROL_VBR
165 || info->RateControlMethod == MFX_RATECONTROL_VCM
169 "BufferSizeInKB: %"PRIu16
"; InitialDelayInKB: %"PRIu16
"; TargetKbps: %"PRIu16
"; MaxKbps: %"PRIu16
"; BRCParamMultiplier: %"PRIu16
"\n",
170 info->BufferSizeInKB, info->InitialDelayInKB, info->TargetKbps, info->MaxKbps, info->BRCParamMultiplier);
171 }
else if (info->RateControlMethod == MFX_RATECONTROL_CQP) {
173 info->QPI, info->QPP, info->QPB);
176 else if (info->RateControlMethod == MFX_RATECONTROL_AVBR) {
178 "TargetKbps: %"PRIu16
"; Accuracy: %"PRIu16
"; Convergence: %"PRIu16
"; BRCParamMultiplier: %"PRIu16
"\n",
179 info->TargetKbps, info->Accuracy, info->Convergence, info->BRCParamMultiplier);
183 else if (info->RateControlMethod == MFX_RATECONTROL_LA
185 || info->RateControlMethod == MFX_RATECONTROL_LA_HRD
189 "TargetKbps: %"PRIu16
"; LookAheadDepth: %"PRIu16
"; BRCParamMultiplier: %"PRIu16
"\n",
190 info->TargetKbps, co2->LookAheadDepth, info->BRCParamMultiplier);
194 else if (info->RateControlMethod == MFX_RATECONTROL_ICQ) {
196 }
else if (info->RateControlMethod == MFX_RATECONTROL_LA_ICQ) {
198 info->ICQQuality, co2->LookAheadDepth);
202 else if (info->RateControlMethod == MFX_RATECONTROL_QVBR) {
208 info->NumSlice, info->NumRefFrame);
212 #if QSV_HAVE_EXT_HEVC_TILES 215 exthevctiles->NumTileColumns, exthevctiles->NumTileRows);
220 "RecoveryPointSEI: %s IntRefType: %"PRIu16
"; IntRefCycleSize: %"PRIu16
"; IntRefQPDelta: %"PRId16
"\n",
221 print_threestate(co->RecoveryPointSEI), co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);
224 #if QSV_HAVE_MAX_SLICE_SIZE 230 "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
236 if (co2->Trellis & MFX_TRELLIS_OFF) {
238 }
else if (!co2->Trellis) {
252 #if QSV_VERSION_ATLEAST(1, 8) 254 "RepeatPPS: %s; NumMbPerSlice: %"PRIu16
"; LookAheadDS: ",
256 switch (co2->LookAheadDS) {
266 switch (co2->BRefType) {
274 #if QSV_VERSION_ATLEAST(1, 9) 276 "MinQPI: %"PRIu8
"; MaxQPI: %"PRIu8
"; MinQPP: %"PRIu8
"; MaxQPP: %"PRIu8
"; MinQPB: %"PRIu8
"; MaxQPB: %"PRIu8
"\n",
277 co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
288 co->CAVLC == MFX_CODINGOPTION_ON ?
"CAVLC" :
"CABAC", co->MaxDecFrameBuffering);
290 "NalHrdConformance: %s; SingleSeiNalUnit: %s; VuiVclHrdParameters: %s VuiNalHrdParameters: %s\n",
296 info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);
307 int want_vcm = q->
vcm;
311 "Lookahead ratecontrol mode requested, but is not supported by this SDK version\n");
316 "VCM ratecontrol mode requested, but is not supported by this SDK version\n");
320 if (want_la + want_qscale + want_vcm > 1) {
322 "More than one of: { constant qscale, lookahead, VCM } requested, " 323 "only one of them can be used at a time.\n");
329 "ICQ ratecontrol mode requested, but is not supported by this SDK version\n");
334 rc_mode = MFX_RATECONTROL_CQP;
335 rc_desc =
"constant quantization parameter (CQP)";
339 rc_mode = MFX_RATECONTROL_VCM;
340 rc_desc =
"video conferencing mode (VCM)";
345 rc_mode = MFX_RATECONTROL_LA;
346 rc_desc =
"VBR with lookahead (LA)";
350 rc_mode = MFX_RATECONTROL_LA_ICQ;
351 rc_desc =
"intelligent constant quality with lookahead (LA_ICQ)";
358 rc_mode = MFX_RATECONTROL_ICQ;
359 rc_desc =
"intelligent constant quality (ICQ)";
363 rc_mode = MFX_RATECONTROL_CBR;
364 rc_desc =
"constant bitrate (CBR)";
368 rc_mode = MFX_RATECONTROL_AVBR;
369 rc_desc =
"average variable bitrate (AVBR)";
374 rc_mode = MFX_RATECONTROL_QVBR;
375 rc_desc =
"constant quality with VBR algorithm (QVBR)";
379 rc_mode = MFX_RATECONTROL_VBR;
380 rc_desc =
"variable bitrate (VBR)";
391 mfxVideoParam param_out = { .mfx.CodecId = q->
param.mfx.CodecId };
394 #define UNMATCH(x) (param_out.mfx.x != q->param.mfx.x) 396 ret = MFXVideoENCODE_Query(q->
session, &q->
param, ¶m_out);
403 if (
UNMATCH(RateControlMethod))
430 q->
param.mfx.CodecId = ret;
432 if (avctx->
level > 0)
442 q->
param.mfx.FrameInfo.CropX = 0;
443 q->
param.mfx.FrameInfo.CropY = 0;
448 q->
param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
459 q->
param.mfx.FrameInfo.Width = frames_hwctx->surfaces[0].Info.Width;
460 q->
param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;
471 q->
param.mfx.Interleaved = 1;
473 q->
param.mfx.RestartInterval = 0;
490 int target_bitrate_kbps, max_bitrate_kbps, brc_param_multiplier;
491 int buffer_size_in_kilobytes, initial_delay_in_kilobytes;
497 q->
param.mfx.CodecId = ret;
499 if (avctx->
level > 0)
507 "valid range is 0-%d, using %d instead\n",
508 MFX_TARGETUSAGE_BEST_SPEED, MFX_TARGETUSAGE_BEST_SPEED);
515 q->
param.mfx.LowPower = MFX_CODINGOPTION_ON;
518 "not supported with this MSDK version.\n");
520 q->
param.mfx.LowPower = MFX_CODINGOPTION_OFF;
523 q->
param.mfx.LowPower = MFX_CODINGOPTION_OFF;
534 q->
param.mfx.EncodedOrder = 0;
535 q->
param.mfx.BufferSizeInKB = 0;
543 q->
param.mfx.FrameInfo.CropX = 0;
544 q->
param.mfx.FrameInfo.CropY = 0;
549 q->
param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420 +
565 q->
param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_FIELD_TFF;
569 q->
param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
580 q->
param.mfx.FrameInfo.Width = frames_hwctx->surfaces[0].Info.Width;
581 q->
param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;
599 target_bitrate_kbps = avctx->
bit_rate / 1000;
601 brc_param_multiplier = (
FFMAX(
FFMAX3(target_bitrate_kbps, max_bitrate_kbps, buffer_size_in_kilobytes),
602 initial_delay_in_kilobytes) + 0x10000) / 0x10000;
604 switch (q->
param.mfx.RateControlMethod) {
605 case MFX_RATECONTROL_CBR:
606 case MFX_RATECONTROL_VBR:
608 case MFX_RATECONTROL_VCM:
611 case MFX_RATECONTROL_QVBR:
613 q->
param.mfx.BufferSizeInKB = buffer_size_in_kilobytes / brc_param_multiplier;
614 q->
param.mfx.InitialDelayInKB = initial_delay_in_kilobytes / brc_param_multiplier;
615 q->
param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
616 q->
param.mfx.MaxKbps = max_bitrate_kbps / brc_param_multiplier;
617 q->
param.mfx.BRCParamMultiplier = brc_param_multiplier;
619 if (q->
param.mfx.RateControlMethod == MFX_RATECONTROL_QVBR)
623 case MFX_RATECONTROL_CQP:
627 q->
param.mfx.QPP = av_clip(quant, 0, 51);
632 case MFX_RATECONTROL_AVBR:
633 q->
param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
636 q->
param.mfx.BRCParamMultiplier = brc_param_multiplier;
640 case MFX_RATECONTROL_LA:
641 q->
param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
643 q->
param.mfx.BRCParamMultiplier = brc_param_multiplier;
646 case MFX_RATECONTROL_LA_ICQ:
648 case MFX_RATECONTROL_ICQ:
660 q->
extco.Header.BufferId = MFX_EXTBUFF_CODING_OPTION;
664 MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;
667 q->
extco.RateDistortionOpt = q->
rdo > 0 ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
670 #if FF_API_CODER_TYPE 676 q->
extco.CAVLC = q->
cavlc ? MFX_CODINGOPTION_ON
677 : MFX_CODINGOPTION_UNKNOWN;
681 MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
688 q->
extco.AUDelimiter = q->
aud ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
703 q->extco2.BitrateLimit = q->
bitrate_limit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
705 q->extco2.MBBRC = q->
mbbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
709 #if QSV_HAVE_MAX_SLICE_SIZE 716 q->extco2.Trellis = (avctx->
trellis == 0) ? MFX_TRELLIS_OFF : (MFX_TRELLIS_I | MFX_TRELLIS_P | MFX_TRELLIS_B);
718 q->extco2.Trellis = MFX_TRELLIS_UNKNOWN;
721 #if QSV_VERSION_ATLEAST(1, 8) 723 q->extco2.RepeatPPS = q->
repeat_pps ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
725 #if FF_API_PRIVATE_OPT 732 q->extco2.BRefType = q->
b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
734 q->extco2.AdaptiveI = q->
adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
736 q->extco2.AdaptiveB = q->
adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
739 #if QSV_VERSION_ATLEAST(1, 9) 741 av_log(avctx,
AV_LOG_ERROR,
"qmin and or qmax are set but invalid, please make sure min <= max\n");
744 if (avctx->
qmin >= 0) {
745 q->extco2.MinQPI = avctx->
qmin > 51 ? 51 : avctx->
qmin;
746 q->extco2.MinQPP = q->extco2.MinQPB = q->extco2.MinQPI;
748 if (avctx->
qmax >= 0) {
749 q->extco2.MaxQPI = avctx->
qmax > 51 ? 51 : avctx->
qmax;
750 q->extco2.MaxQPP = q->extco2.MaxQPB = q->extco2.MaxQPI;
757 q->extco2.ExtBRC = q->
extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
759 q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
760 q->extco2.Header.BufferSz =
sizeof(q->extco2);
769 q->extmfp.Header.BufferId = MFX_EXTBUFF_MULTI_FRAME_PARAM;
770 q->extmfp.Header.BufferSz =
sizeof(q->extmfp);
772 q->extmfp.MFMode = q->mfmode;
779 q->extco3.Header.BufferId = MFX_EXTBUFF_CODING_OPTION3;
780 q->extco3.Header.BufferSz =
sizeof(q->extco3);
783 q->extco3.GPB = q->
gpb ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
789 #if QSV_HAVE_EXT_VP9_PARAM 791 q->extvp9param.Header.BufferId = MFX_EXTBUFF_VP9_PARAM;
792 q->extvp9param.Header.BufferSz =
sizeof(q->extvp9param);
793 q->extvp9param.WriteIVFHeaders = MFX_CODINGOPTION_OFF;
798 #if QSV_HAVE_EXT_HEVC_TILES 800 q->exthevctiles.Header.BufferId = MFX_EXTBUFF_HEVC_TILES;
801 q->exthevctiles.Header.BufferSz =
sizeof(q->exthevctiles);
802 q->exthevctiles.NumTileColumns = q->
tile_cols;
803 q->exthevctiles.NumTileRows = q->
tile_rows;
810 "some encoding parameters are not supported by the QSV " 811 "runtime. Please double check the input parameters.\n");
822 ret = MFXVideoENCODE_GetVideoParam(q->
session, &q->
param);
825 "Error calling GetVideoParam");
839 #if QSV_HAVE_EXT_VP9_PARAM 840 mfxExtVP9Param vp9_extend_buf = {
841 .Header.BufferId = MFX_EXTBUFF_VP9_PARAM,
842 .Header.BufferSz =
sizeof(vp9_extend_buf),
847 mfxExtCodingOption2 co2 = {
848 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
849 .Header.BufferSz =
sizeof(co2),
854 mfxExtCodingOption3 co3 = {
855 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
856 .Header.BufferSz =
sizeof(co3),
860 mfxExtBuffer *ext_buffers[] = {
861 #if QSV_HAVE_EXT_VP9_PARAM 862 (mfxExtBuffer*)&vp9_extend_buf,
872 q->
param.ExtParam = ext_buffers;
875 ret = MFXVideoENCODE_GetVideoParam(q->
session, &q->
param);
878 "Error calling GetVideoParam");
892 mfxExtCodingOptionSPSPPS extradata = {
893 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
894 .Header.BufferSz =
sizeof(extradata),
895 .SPSBuffer = sps_buf, .SPSBufSize =
sizeof(sps_buf),
896 .PPSBuffer = pps_buf, .PPSBufSize =
sizeof(pps_buf)
899 mfxExtCodingOption co = {
900 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
901 .Header.BufferSz =
sizeof(co),
904 mfxExtCodingOption2 co2 = {
905 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
906 .Header.BufferSz =
sizeof(co2),
910 mfxExtCodingOption3 co3 = {
911 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
912 .Header.BufferSz =
sizeof(co3),
918 mfxExtCodingOptionVPS extradata_vps = {
919 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_VPS,
920 .Header.BufferSz =
sizeof(extradata_vps),
921 .VPSBuffer = vps_buf,
922 .VPSBufSize =
sizeof(vps_buf),
926 #if QSV_HAVE_EXT_HEVC_TILES 927 mfxExtHEVCTiles hevc_tile_buf = {
928 .Header.BufferId = MFX_EXTBUFF_HEVC_TILES,
929 .Header.BufferSz =
sizeof(hevc_tile_buf),
936 int ret, ext_buf_num = 0, extradata_offset = 0;
938 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata;
939 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co;
941 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;
944 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;
949 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata_vps;
951 #if QSV_HAVE_EXT_HEVC_TILES 953 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&hevc_tile_buf;
956 q->
param.ExtParam = ext_buffers;
957 q->
param.NumExtParam = ext_buf_num;
959 ret = MFXVideoENCODE_GetVideoParam(q->
session, &q->
param);
962 "Error calling GetVideoParam");
966 if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)
968 || (q->
hevc_vps && !extradata_vps.VPSBufSize)
975 avctx->
extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
986 memcpy(avctx->
extradata, vps_buf, extradata_vps.VPSBufSize);
987 extradata_offset += extradata_vps.VPSBufSize;
991 memcpy(avctx->
extradata + extradata_offset, sps_buf, extradata.SPSBufSize);
992 extradata_offset += extradata.SPSBufSize;
994 memcpy(avctx->
extradata + extradata_offset, pps_buf, extradata.PPSBufSize);
995 extradata_offset += extradata.PPSBufSize;
1015 mfxFrameSurface1 *surfaces;
1029 for (i = 0; i < nb_surfaces; i++) {
1030 surfaces[
i].Info = q->
req.Info;
1034 q->
opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
1063 q->
param.IOPattern == MFX_IOPATTERN_IN_OPAQUE_MEMORY,
1093 return sizeof(
AVPacket) +
sizeof(mfxSyncPoint*) +
sizeof(mfxBitstream*);
1104 int opaque_alloc = 0;
1125 if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)
1126 iopattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
1127 else if (frames_hwctx->frame_type &
1128 (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
1129 iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
1134 iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
1135 q->
param.IOPattern = iopattern;
1144 "Error querying mfx version");
1178 if (j < qsv->nb_ext_buffers)
1189 if (ret == MFX_WRN_PARTIAL_ACCELERATION) {
1191 }
else if (ret < 0) {
1193 "Error querying encoder params");
1199 "Error querying (IOSurf) the encoding parameters");
1210 "Error initializing the encoder");
1213 "Warning in encoder initialization");
1241 av_free(enc_ctrl->Payload[i]);
1243 enc_ctrl->NumPayload = 0;
1277 last = &frame->
next;
1278 frame = frame->
next;
1285 if (!frame->
frame) {
1361 MFX_PICSTRUCT_FIELD_BFF;
1363 qf->
surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
1365 qf->
surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
1367 qf->
surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
1383 if (q->
param.mfx.CodecId == MFX_CODEC_AVC) {
1384 if (q->
param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
1385 q->
param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
1386 q->
param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
1388 "Interlaced coding is supported" 1389 " at Main/High Profile Level 2.2-4.0\n");
1398 #if QSV_VERSION_ATLEAST(1, 26) 1399 mfxExtAVCEncodedFrameInfo *enc_info;
1400 mfxExtBuffer **enc_buf;
1403 mfxFrameSurface1 *surf =
NULL;
1404 mfxSyncPoint *sync =
NULL;
1406 mfxEncodeCtrl* enc_ctrl =
NULL;
1421 enc_ctrl->FrameType = MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF;
1423 enc_ctrl->FrameType |= MFX_FRAMETYPE_IDR;
1438 bs->Data = new_pkt.
data;
1439 bs->MaxLength = new_pkt.
size;
1441 #if QSV_VERSION_ATLEAST(1, 26) 1447 enc_info->Header.BufferId = MFX_EXTBUFF_ENCODED_FRAME_INFO;
1448 enc_info->Header.BufferSz =
sizeof (*enc_info);
1449 bs->NumExtParam = 1;
1450 enc_buf =
av_mallocz(
sizeof(mfxExtBuffer *));
1453 enc_buf[0] = (mfxExtBuffer *)enc_info;
1455 bs->ExtParam = enc_buf;
1466 #if QSV_VERSION_ATLEAST(1, 26) 1477 ret = MFXVideoENCODE_EncodeFrameAsync(q->
session, enc_ctrl, surf, bs, sync);
1478 if (ret == MFX_WRN_DEVICE_BUSY)
1480 }
while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_WRN_IN_EXECUTION);
1488 #if QSV_VERSION_ATLEAST(1, 26) 1495 return (ret == MFX_ERR_MORE_DATA) ?
1510 #if QSV_VERSION_ATLEAST(1, 26) 1535 #if QSV_VERSION_ATLEAST(1, 26) 1536 mfxExtAVCEncodedFrameInfo *enc_info;
1537 mfxExtBuffer **enc_buf;
1546 ret = MFXVideoCORE_SyncOperation(q->
session, *sync, 1000);
1547 }
while (ret == MFX_WRN_IN_EXECUTION);
1551 new_pkt.
size = bs->DataLength;
1553 if (bs->FrameType & MFX_FRAMETYPE_IDR || bs->FrameType & MFX_FRAMETYPE_xIDR) {
1556 }
else if (bs->FrameType & MFX_FRAMETYPE_I || bs->FrameType & MFX_FRAMETYPE_xI)
1558 else if (bs->FrameType & MFX_FRAMETYPE_P || bs->FrameType & MFX_FRAMETYPE_xP)
1560 else if (bs->FrameType & MFX_FRAMETYPE_B || bs->FrameType & MFX_FRAMETYPE_xB)
1562 else if (bs->FrameType == MFX_FRAMETYPE_UNKNOWN) {
1570 #if FF_API_CODED_FRAME 1576 #if QSV_VERSION_ATLEAST(1, 26) 1578 enc_buf = bs->ExtParam;
1579 enc_info = (mfxExtAVCEncodedFrameInfo *)(*bs->ExtParam);
1618 MFXVideoENCODE_Close(q->
session);
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define FF_COMPRESSION_DEFAULT
#define QSV_MAX_ENC_PAYLOAD
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
mfxExtBuffer * extparam_internal[2+QSV_HAVE_CO2+QSV_HAVE_CO3+(QSV_HAVE_MF *2)]
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
AVBufferRef * opaque_alloc_buf
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
static int init_video_param_jpeg(AVCodecContext *avctx, QSVEncContext *q)
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
#define AV_LOG_WARNING
Something somehow does not look correct.
mfxExtOpaqueSurfaceAlloc opaque_alloc
int64_t bit_rate
the average bitrate
Memory handling functions.
This struct is allocated as AVHWFramesContext.hwctx.
#define HW_CONFIG_ENCODER_FRAMES(format, device_type_)
int max_bitrate
Maximum bitrate of the stream, in bits per second.
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
int repeat_pict
When decoding, this signals how much the picture must be delayed.
static int get_free_frame(QSVEncContext *q, QSVFrame **f)
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
QSVFramesContext frames_ctx
#define QSV_RUNTIME_VERSION_ATLEAST(MFX_VERSION, MAJOR, MINOR)
int ff_qsv_init_session_device(AVCodecContext *avctx, mfxSession *psession, AVBufferRef *device_ref, const char *load_plugins, int gpu_copy)
int av_usleep(unsigned usec)
Sleep for a period of time.
int nb_opaque_surfaces
Encoding only, and only if opaque_alloc is set to non-zero.
static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
static const struct @118 profile_names[]
float i_quant_offset
qscale offset between P and I-frames
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
int min_bitrate
Minimum bitrate of the stream, in bits per second.
AVBufferRef * hw_frames_ctx
int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int(*func)(void *, void *, int))
Feed data from a user-supplied callback to an AVFifoBuffer.
int ff_qsv_print_error(void *log_ctx, mfxStatus err, const char *error_string)
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, AVPacket *pkt, const AVFrame *frame, int *got_packet)
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
AVFifoBuffer * async_fifo
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
void * hwaccel_context
Hardware accelerator context.
float b_quant_factor
qscale factor between IP and B-frames If > 0 then the last P-frame quantizer will be used (q= lastp_q...
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
int opaque_alloc
Encoding only.
mfxFrameSurface1 ** opaque_surfaces
static int qsv_retrieve_enc_jpeg_params(AVCodecContext *avctx, QSVEncContext *q)
#define AV_LOG_VERBOSE
Detailed information.
void av_fifo_free(AVFifoBuffer *f)
Free an AVFifoBuffer.
int interlaced_frame
The content of the picture is interlaced.
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
#define HW_CONFIG_ENCODER_DEVICE(format, device_type_)
static const char * print_threestate(mfxU16 val)
int opaque_alloc_type
Encoding only, and only if opaque_alloc is set to non-zero.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
int ff_qsv_init_session_frames(AVCodecContext *avctx, mfxSession *psession, QSVFramesContext *qsv_frames_ctx, const char *load_plugins, int opaque, int gpu_copy)
#define i(width, name, range_min, range_max)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int ff_qsv_find_surface_idx(QSVFramesContext *ctx, QSVFrame *frame)
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
int qmax
maximum quantizer
int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void(*func)(void *, void *, int))
Feed data from an AVFifoBuffer to a user-supplied callback.
int flags
AV_CODEC_FLAG_*.
static unsigned int qsv_fifo_item_size(void)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
float i_quant_factor
qscale factor between P- and I-frames If > 0 then the last P-frame quantizer will be used (q = lastp_...
int max_dec_frame_buffering
int iopattern
The IO pattern to use.
static unsigned int qsv_fifo_size(const AVFifoBuffer *fifo)
int ff_qsv_close_internal_session(QSVSession *qs)
static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
int flags
A combination of AV_PKT_FLAG values.
int rc_buffer_size
decoder bitstream buffer size
int ff_qsv_print_warning(void *log_ctx, mfxStatus err, const char *warning_string)
int64_t rc_min_rate
minimum bitrate
int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc)
int refs
number of reference frames
static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q, mfxExtBuffer **coding_opts)
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
enum AVPictureType pict_type
Picture type of the frame.
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
int width
picture width / height.
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)
static const struct @119 rc_names[]
static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q)
#define MFX_LOOKAHEAD_DS_OFF
static const char * print_profile(mfxU16 profile)
#define MFX_LOOKAHEAD_DS_2x
preferred ID for MPEG-1/2 video decoding
attribute_deprecated int coder_type
#define FF_ARRAY_ELEMS(a)
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
This structure describes the bitrate properties of an encoded bitstream.
static int qsvenc_init_session(AVCodecContext *avctx, QSVEncContext *q)
Libavcodec external API header.
int av_fifo_size(const AVFifoBuffer *f)
Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from ...
mfxExtBuffer ** ext_buffers
Extra buffers to pass to encoder or decoder initialization.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
attribute_deprecated int b_frame_strategy
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
main external API structure.
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
uint8_t * data
The data buffer.
int qmin
minimum quantizer
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
static void free_encoder_ctrl_payloads(mfxEncodeCtrl *enc_ctrl)
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
AVBufferRef * opaque_surfaces
Encoding only, and only if opaque_alloc is set to non-zero.
#define FF_CODER_TYPE_VLC
const AVCodecHWConfigInternal * ff_qsv_enc_hw_configs[]
#define FF_COMPLIANCE_NORMAL
int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
Rational number (pair of numerator and denominator).
This struct describes a set or pool of "hardware" frames (i.e.
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
int ff_qsv_init_internal_session(AVCodecContext *avctx, QSVSession *qs, const char *load_plugins, int gpu_copy)
float b_quant_offset
qscale offset between IP and B-frames
This struct is used for communicating QSV parameters between libavcodec and the caller.
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
int global_quality
Global quality for codecs which cannot change it per frame.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
static int check_enc_param(AVCodecContext *avctx, QSVEncContext *q)
#define FF_DISABLE_DEPRECATION_WARNINGS
common internal api header.
common internal and external API header
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
int trellis
trellis RD quantization
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
int slices
Number of slices.
#define MFX_LOOKAHEAD_DS_4x
AVFifoBuffer * av_fifo_alloc(unsigned int size)
Initialize an AVFifoBuffer.
#define FF_ENABLE_DEPRECATION_WARNINGS
int top_field_first
If the content is interlaced, is top field displayed first.
int avg_bitrate
Average bitrate of the stream, in bits per second.
static int qsv_retrieve_enc_vp9_params(AVCodecContext *avctx, QSVEncContext *q)
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
int look_ahead_downsampling
static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
static const char * print_ratecontrol(mfxU16 rc_mode)
An API-specific header for AV_HWDEVICE_TYPE_QSV.
#define av_malloc_array(a, b)
#define AV_CODEC_FLAG_CLOSED_GOP
#define QSV_HAVE_EXT_HEVC_TILES
int depth
Number of bits in the component.
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
AVPixelFormat
Pixel format.
static double val(void *priv, double ch)
This structure stores compressed data.
static int qsv_init_opaque_alloc(AVCodecContext *avctx, QSVEncContext *q)
mfxSession session
If non-NULL, the session to use for encoding or decoding.
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
static int encode_frame(AVCodecContext *avctx, QSVEncContext *q, const AVFrame *frame)
static int submit_frame(QSVEncContext *q, const AVFrame *frame, QSVFrame **new_frame)
int64_t rc_max_rate
maximum bitrate
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
SetEncodeCtrlCB * set_encode_ctrl_cb
static void clear_unused_frames(QSVEncContext *q)