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)
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))
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;
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:
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;
742 q->extco2.ExtBRC = q->
extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
744 #if QSV_VERSION_ATLEAST(1, 9) 746 av_log(avctx,
AV_LOG_ERROR,
"qmin and or qmax are set but invalid, please make sure min <= max\n");
749 if (avctx->
qmin >= 0) {
750 q->extco2.MinQPI = avctx->
qmin > 51 ? 51 : avctx->
qmin;
751 q->extco2.MinQPP = q->extco2.MinQPB = q->extco2.MinQPI;
753 if (avctx->
qmax >= 0) {
754 q->extco2.MaxQPI = avctx->
qmax > 51 ? 51 : avctx->
qmax;
755 q->extco2.MaxQPP = q->extco2.MaxQPB = q->extco2.MaxQPI;
758 q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
759 q->extco2.Header.BufferSz =
sizeof(q->extco2);
768 q->extmfp.Header.BufferId = MFX_EXTBUFF_MULTI_FRAME_PARAM;
769 q->extmfp.Header.BufferSz =
sizeof(q->extmfp);
771 q->extmfp.MFMode = q->mfmode;
778 q->extco3.Header.BufferId = MFX_EXTBUFF_CODING_OPTION3;
779 q->extco3.Header.BufferSz =
sizeof(q->extco3);
782 q->extco3.GPB = q->
gpb ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
788 #if QSV_HAVE_EXT_VP9_PARAM 790 q->extvp9param.Header.BufferId = MFX_EXTBUFF_VP9_PARAM;
791 q->extvp9param.Header.BufferSz =
sizeof(q->extvp9param);
792 q->extvp9param.WriteIVFHeaders = MFX_CODINGOPTION_OFF;
797 #if QSV_HAVE_EXT_HEVC_TILES 799 q->exthevctiles.Header.BufferId = MFX_EXTBUFF_HEVC_TILES;
800 q->exthevctiles.Header.BufferSz =
sizeof(q->exthevctiles);
801 q->exthevctiles.NumTileColumns = q->
tile_cols;
802 q->exthevctiles.NumTileRows = q->
tile_rows;
809 "some encoding parameters are not supported by the QSV " 810 "runtime. Please double check the input parameters.\n");
821 ret = MFXVideoENCODE_GetVideoParam(q->
session, &q->
param);
824 "Error calling GetVideoParam");
838 #if QSV_HAVE_EXT_VP9_PARAM 839 mfxExtVP9Param vp9_extend_buf = {
840 .Header.BufferId = MFX_EXTBUFF_VP9_PARAM,
841 .Header.BufferSz =
sizeof(vp9_extend_buf),
846 mfxExtCodingOption2 co2 = {
847 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
848 .Header.BufferSz =
sizeof(co2),
853 mfxExtCodingOption3 co3 = {
854 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
855 .Header.BufferSz =
sizeof(co3),
859 mfxExtBuffer *ext_buffers[] = {
860 #if QSV_HAVE_EXT_VP9_PARAM 861 (mfxExtBuffer*)&vp9_extend_buf,
871 q->
param.ExtParam = ext_buffers;
874 ret = MFXVideoENCODE_GetVideoParam(q->
session, &q->
param);
877 "Error calling GetVideoParam");
891 mfxExtCodingOptionSPSPPS extradata = {
892 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
893 .Header.BufferSz =
sizeof(extradata),
894 .SPSBuffer = sps_buf, .SPSBufSize =
sizeof(sps_buf),
895 .PPSBuffer = pps_buf, .PPSBufSize =
sizeof(pps_buf)
898 mfxExtCodingOption co = {
899 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
900 .Header.BufferSz =
sizeof(co),
903 mfxExtCodingOption2 co2 = {
904 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
905 .Header.BufferSz =
sizeof(co2),
909 mfxExtCodingOption3 co3 = {
910 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
911 .Header.BufferSz =
sizeof(co3),
917 mfxExtCodingOptionVPS extradata_vps = {
918 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_VPS,
919 .Header.BufferSz =
sizeof(extradata_vps),
920 .VPSBuffer = vps_buf,
921 .VPSBufSize =
sizeof(vps_buf),
925 #if QSV_HAVE_EXT_HEVC_TILES 926 mfxExtHEVCTiles hevc_tile_buf = {
927 .Header.BufferId = MFX_EXTBUFF_HEVC_TILES,
928 .Header.BufferSz =
sizeof(hevc_tile_buf),
935 int ret, ext_buf_num = 0, extradata_offset = 0;
937 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata;
938 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co;
940 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;
943 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;
948 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata_vps;
950 #if QSV_HAVE_EXT_HEVC_TILES 952 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&hevc_tile_buf;
955 q->
param.ExtParam = ext_buffers;
956 q->
param.NumExtParam = ext_buf_num;
958 ret = MFXVideoENCODE_GetVideoParam(q->
session, &q->
param);
961 "Error calling GetVideoParam");
965 if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)
967 || (q->
hevc_vps && !extradata_vps.VPSBufSize)
974 avctx->
extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
985 memcpy(avctx->
extradata, vps_buf, extradata_vps.VPSBufSize);
986 extradata_offset += extradata_vps.VPSBufSize;
990 memcpy(avctx->
extradata + extradata_offset, sps_buf, extradata.SPSBufSize);
991 extradata_offset += extradata.SPSBufSize;
993 memcpy(avctx->
extradata + extradata_offset, pps_buf, extradata.PPSBufSize);
994 extradata_offset += extradata.PPSBufSize;
1014 mfxFrameSurface1 *surfaces;
1028 for (i = 0; i < nb_surfaces; i++) {
1029 surfaces[
i].Info = q->
req.Info;
1033 q->
opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
1062 q->
param.IOPattern == MFX_IOPATTERN_IN_OPAQUE_MEMORY,
1092 return sizeof(
AVPacket) +
sizeof(mfxSyncPoint*) +
sizeof(mfxBitstream*);
1103 int opaque_alloc = 0;
1124 if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)
1125 iopattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
1126 else if (frames_hwctx->frame_type &
1127 (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
1128 iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
1133 iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
1134 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)
#define FF_ARRAY_ELEMS(a)
int ff_qsv_init_session_device(AVCodecContext *avctx, mfxSession *psession, AVBufferRef *device_ref, const char *load_plugins, int gpu_copy)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
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)
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 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.
static __device__ float fabs(float a)
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)
int ff_qsv_print_iopattern(void *log_ctx, int mfx_iopattern, const char *extra_string)
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
static const struct @118 rc_names[]
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 int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q)
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define MFX_LOOKAHEAD_DS_OFF
static const struct @117 profile_names[]
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
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.
const AVCodecHWConfigInternal *const ff_qsv_enc_hw_configs[]
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
#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
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
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)
SetEncodeCtrlCB * set_encode_ctrl_cb
static void clear_unused_frames(QSVEncContext *q)