#include "libavutil/log.h"
#include "libavutil/time.h"
#include "libavutil/imgutils.h"
+#include "libavcodec/bytestream.h"
#include "avcodec.h"
#include "internal.h"
#include "qsv_internal.h"
#include "qsvenc.h"
-static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
+static const struct {
+ mfxU16 profile;
+ const char *name;
+} profile_names[] = {
+ { MFX_PROFILE_AVC_BASELINE, "baseline" },
+ { MFX_PROFILE_AVC_MAIN, "main" },
+ { MFX_PROFILE_AVC_EXTENDED, "extended" },
+ { MFX_PROFILE_AVC_HIGH, "high" },
+#if QSV_VERSION_ATLEAST(1, 15)
+ { MFX_PROFILE_AVC_HIGH_422, "high 422" },
+#endif
+#if QSV_VERSION_ATLEAST(1, 4)
+ { MFX_PROFILE_AVC_CONSTRAINED_BASELINE, "constrained baseline" },
+ { MFX_PROFILE_AVC_CONSTRAINED_HIGH, "constrained high" },
+ { MFX_PROFILE_AVC_PROGRESSIVE_HIGH, "progressive high" },
+#endif
+ { MFX_PROFILE_MPEG2_SIMPLE, "simple" },
+ { MFX_PROFILE_MPEG2_MAIN, "main" },
+ { MFX_PROFILE_MPEG2_HIGH, "high" },
+ { MFX_PROFILE_VC1_SIMPLE, "simple" },
+ { MFX_PROFILE_VC1_MAIN, "main" },
+ { MFX_PROFILE_VC1_ADVANCED, "advanced" },
+#if QSV_VERSION_ATLEAST(1, 8)
+ { MFX_PROFILE_HEVC_MAIN, "main" },
+ { MFX_PROFILE_HEVC_MAIN10, "main10" },
+ { MFX_PROFILE_HEVC_MAINSP, "mainsp" },
+#endif
+};
+
+static const char *print_profile(mfxU16 profile)
+{
+ int i;
+ for (i = 0; i < FF_ARRAY_ELEMS(profile_names); i++)
+ if (profile == profile_names[i].profile)
+ return profile_names[i].name;
+ return "unknown";
+}
+
+static const struct {
+ mfxU16 rc_mode;
+ const char *name;
+} rc_names[] = {
+ { MFX_RATECONTROL_CBR, "CBR" },
+ { MFX_RATECONTROL_VBR, "VBR" },
+ { MFX_RATECONTROL_CQP, "CQP" },
+ { MFX_RATECONTROL_AVBR, "AVBR" },
+#if QSV_HAVE_LA
+ { MFX_RATECONTROL_LA, "LA" },
+#endif
+#if QSV_HAVE_ICQ
+ { MFX_RATECONTROL_ICQ, "ICQ" },
+ { MFX_RATECONTROL_LA_ICQ, "LA_ICQ" },
+#endif
+#if QSV_HAVE_VCM
+ { MFX_RATECONTROL_VCM, "VCM" },
+#endif
+#if QSV_VERSION_ATLEAST(1, 10)
+ { MFX_RATECONTROL_LA_EXT, "LA_EXT" },
+#endif
+#if QSV_HAVE_LA_HRD
+ { MFX_RATECONTROL_LA_HRD, "LA_HRD" },
+#endif
+#if QSV_HAVE_QVBR
+ { MFX_RATECONTROL_QVBR, "QVBR" },
+#endif
+};
+
+static const char *print_ratecontrol(mfxU16 rc_mode)
+{
+ int i;
+ for (i = 0; i < FF_ARRAY_ELEMS(rc_names); i++)
+ if (rc_mode == rc_names[i].rc_mode)
+ return rc_names[i].name;
+ return "unknown";
+}
+
+static const char *print_threestate(mfxU16 val)
+{
+ if (val == MFX_CODINGOPTION_ON)
+ return "ON";
+ else if (val == MFX_CODINGOPTION_OFF)
+ return "OFF";
+ return "unknown";
+}
+
+static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q,
+ mfxExtBuffer **coding_opts)
+{
+ mfxInfoMFX *info = &q->param.mfx;
+
+ mfxExtCodingOption *co = (mfxExtCodingOption*)coding_opts[0];
+#if QSV_HAVE_CO2
+ mfxExtCodingOption2 *co2 = (mfxExtCodingOption2*)coding_opts[1];
+#endif
+#if QSV_HAVE_CO3
+ mfxExtCodingOption3 *co3 = (mfxExtCodingOption3*)coding_opts[2];
+#endif
+
+ av_log(avctx, AV_LOG_VERBOSE, "profile: %s; level: %"PRIu16"\n",
+ print_profile(info->CodecProfile), info->CodecLevel);
+
+ av_log(avctx, AV_LOG_VERBOSE, "GopPicSize: %"PRIu16"; GopRefDist: %"PRIu16"; GopOptFlag: ",
+ info->GopPicSize, info->GopRefDist);
+ if (info->GopOptFlag & MFX_GOP_CLOSED)
+ av_log(avctx, AV_LOG_VERBOSE, "closed ");
+ if (info->GopOptFlag & MFX_GOP_STRICT)
+ av_log(avctx, AV_LOG_VERBOSE, "strict ");
+ av_log(avctx, AV_LOG_VERBOSE, "; IdrInterval: %"PRIu16"\n", info->IdrInterval);
+
+ av_log(avctx, AV_LOG_VERBOSE, "TargetUsage: %"PRIu16"; RateControlMethod: %s\n",
+ info->TargetUsage, print_ratecontrol(info->RateControlMethod));
+
+ if (info->RateControlMethod == MFX_RATECONTROL_CBR ||
+ info->RateControlMethod == MFX_RATECONTROL_VBR
+#if QSV_HAVE_VCM
+ || info->RateControlMethod == MFX_RATECONTROL_VCM
+#endif
+ ) {
+ av_log(avctx, AV_LOG_VERBOSE,
+ "InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"\n",
+ info->InitialDelayInKB, info->TargetKbps, info->MaxKbps);
+ } else if (info->RateControlMethod == MFX_RATECONTROL_CQP) {
+ av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",
+ info->QPI, info->QPP, info->QPB);
+ } else if (info->RateControlMethod == MFX_RATECONTROL_AVBR) {
+ av_log(avctx, AV_LOG_VERBOSE,
+ "TargetKbps: %"PRIu16"; Accuracy: %"PRIu16"; Convergence: %"PRIu16"\n",
+ info->TargetKbps, info->Accuracy, info->Convergence);
+ }
+#if QSV_HAVE_LA
+ else if (info->RateControlMethod == MFX_RATECONTROL_LA
+#if QSV_HAVE_LA_HRD
+ || info->RateControlMethod == MFX_RATECONTROL_LA_HRD
+#endif
+ ) {
+ av_log(avctx, AV_LOG_VERBOSE,
+ "TargetKbps: %"PRIu16"; LookAheadDepth: %"PRIu16"\n",
+ info->TargetKbps, co2->LookAheadDepth);
+ }
+#endif
+#if QSV_HAVE_ICQ
+ else if (info->RateControlMethod == MFX_RATECONTROL_ICQ) {
+ av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);
+ } else if (info->RateControlMethod == MFX_RATECONTROL_LA_ICQ) {
+ av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"; LookAheadDepth: %"PRIu16"\n",
+ info->ICQQuality, co2->LookAheadDepth);
+ }
+#endif
+#if QSV_HAVE_QVBR
+ else if (info->RateControlMethod == MFX_RATECONTROL_QVBR) {
+ av_log(avctx, AV_LOG_VERBOSE, "QVBRQuality: %"PRIu16"\n",
+ co3->QVBRQuality);
+ }
+#endif
+
+ av_log(avctx, AV_LOG_VERBOSE, "NumSlice: %"PRIu16"; NumRefFrame: %"PRIu16"\n",
+ info->NumSlice, info->NumRefFrame);
+ av_log(avctx, AV_LOG_VERBOSE, "RateDistortionOpt: %s\n",
+ print_threestate(co->RateDistortionOpt));
+
+#if QSV_HAVE_CO2
+ av_log(avctx, AV_LOG_VERBOSE,
+ "RecoveryPointSEI: %s IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16"; IntRefQPDelta: %"PRId16"\n",
+ print_threestate(co->RecoveryPointSEI), co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);
+
+ av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %"PRIu16"; ", co2->MaxFrameSize);
+#if QSV_HAVE_MAX_SLICE_SIZE
+ av_log(avctx, AV_LOG_VERBOSE, "MaxSliceSize: %"PRIu16"; ", co2->MaxSliceSize);
+#endif
+ av_log(avctx, AV_LOG_VERBOSE, "\n");
+
+ av_log(avctx, AV_LOG_VERBOSE,
+ "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
+ print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),
+ print_threestate(co2->ExtBRC));
+
+#if QSV_HAVE_TRELLIS
+ av_log(avctx, AV_LOG_VERBOSE, "Trellis: ");
+ if (co2->Trellis & MFX_TRELLIS_OFF) {
+ av_log(avctx, AV_LOG_VERBOSE, "off");
+ } else if (!co2->Trellis) {
+ av_log(avctx, AV_LOG_VERBOSE, "auto");
+ } else {
+ if (co2->Trellis & MFX_TRELLIS_I) av_log(avctx, AV_LOG_VERBOSE, "I");
+ if (co2->Trellis & MFX_TRELLIS_P) av_log(avctx, AV_LOG_VERBOSE, "P");
+ if (co2->Trellis & MFX_TRELLIS_B) av_log(avctx, AV_LOG_VERBOSE, "B");
+ }
+ av_log(avctx, AV_LOG_VERBOSE, "\n");
+#endif
+
+#if QSV_VERSION_ATLEAST(1, 8)
+ av_log(avctx, AV_LOG_VERBOSE,
+ "RepeatPPS: %s; NumMbPerSlice: %"PRIu16"; LookAheadDS: ",
+ print_threestate(co2->RepeatPPS), co2->NumMbPerSlice);
+ switch (co2->LookAheadDS) {
+ case MFX_LOOKAHEAD_DS_OFF: av_log(avctx, AV_LOG_VERBOSE, "off"); break;
+ case MFX_LOOKAHEAD_DS_2x: av_log(avctx, AV_LOG_VERBOSE, "2x"); break;
+ case MFX_LOOKAHEAD_DS_4x: av_log(avctx, AV_LOG_VERBOSE, "4x"); break;
+ default: av_log(avctx, AV_LOG_VERBOSE, "unknown"); break;
+ }
+ av_log(avctx, AV_LOG_VERBOSE, "\n");
+
+ av_log(avctx, AV_LOG_VERBOSE, "AdaptiveI: %s; AdaptiveB: %s; BRefType: ",
+ print_threestate(co2->AdaptiveI), print_threestate(co2->AdaptiveB));
+ switch (co2->BRefType) {
+ case MFX_B_REF_OFF: av_log(avctx, AV_LOG_VERBOSE, "off"); break;
+ case MFX_B_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "pyramid"); break;
+ default: av_log(avctx, AV_LOG_VERBOSE, "auto"); break;
+ }
+ av_log(avctx, AV_LOG_VERBOSE, "\n");
+#endif
+
+#if QSV_VERSION_ATLEAST(1, 9)
+ av_log(avctx, AV_LOG_VERBOSE,
+ "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",
+ co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
+#endif
+#endif
+
+ if (avctx->codec_id == AV_CODEC_ID_H264) {
+ av_log(avctx, AV_LOG_VERBOSE, "Entropy coding: %s; MaxDecFrameBuffering: %"PRIu16"\n",
+ co->CAVLC == MFX_CODINGOPTION_ON ? "CAVLC" : "CABAC", co->MaxDecFrameBuffering);
+ av_log(avctx, AV_LOG_VERBOSE,
+ "NalHrdConformance: %s; SingleSeiNalUnit: %s; VuiVclHrdParameters: %s VuiNalHrdParameters: %s\n",
+ print_threestate(co->NalHrdConformance), print_threestate(co->SingleSeiNalUnit),
+ print_threestate(co->VuiVclHrdParameters), print_threestate(co->VuiNalHrdParameters));
+ }
+}
+
+static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q)
+{
+ const char *rc_desc;
+ mfxU16 rc_mode;
+
+ int want_la = q->look_ahead;
+ int want_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
+ int want_vcm = q->vcm;
+
+ if (want_la && !QSV_HAVE_LA) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Lookahead ratecontrol mode requested, but is not supported by this SDK version\n");
+ return AVERROR(ENOSYS);
+ }
+ if (want_vcm && !QSV_HAVE_VCM) {
+ av_log(avctx, AV_LOG_ERROR,
+ "VCM ratecontrol mode requested, but is not supported by this SDK version\n");
+ return AVERROR(ENOSYS);
+ }
+
+ if (want_la + want_qscale + want_vcm > 1) {
+ av_log(avctx, AV_LOG_ERROR,
+ "More than one of: { constant qscale, lookahead, VCM } requested, "
+ "only one of them can be used at a time.\n");
+ return AVERROR(EINVAL);
+ }
+
+ if (want_qscale) {
+ rc_mode = MFX_RATECONTROL_CQP;
+ rc_desc = "constant quantization parameter (CQP)";
+ }
+#if QSV_HAVE_VCM
+ else if (want_vcm) {
+ rc_mode = MFX_RATECONTROL_VCM;
+ rc_desc = "video conferencing mode (VCM)";
+ }
+#endif
+#if QSV_HAVE_LA
+ else if (want_la) {
+ rc_mode = MFX_RATECONTROL_LA;
+ rc_desc = "VBR with lookahead (LA)";
+
+#if QSV_HAVE_ICQ
+ if (avctx->global_quality > 0) {
+ rc_mode = MFX_RATECONTROL_LA_ICQ;
+ rc_desc = "intelligent constant quality with lookahead (LA_ICQ)";
+ }
+#endif
+ }
+#endif
+#if QSV_HAVE_ICQ
+ else if (avctx->global_quality > 0) {
+ rc_mode = MFX_RATECONTROL_ICQ;
+ rc_desc = "intelligent constant quality (ICQ)";
+ }
+#endif
+ else if (avctx->rc_max_rate == avctx->bit_rate) {
+ rc_mode = MFX_RATECONTROL_CBR;
+ rc_desc = "constant bitrate (CBR)";
+ } else if (!avctx->rc_max_rate) {
+ rc_mode = MFX_RATECONTROL_AVBR;
+ rc_desc = "average variable bitrate (AVBR)";
+ } else {
+ rc_mode = MFX_RATECONTROL_VBR;
+ rc_desc = "variable bitrate (VBR)";
+ }
+
+ q->param.mfx.RateControlMethod = rc_mode;
+ av_log(avctx, AV_LOG_VERBOSE, "Using the %s ratecontrol method\n", rc_desc);
+
+ return 0;
+}
+
+static int rc_supported(QSVEncContext *q)
{
- const char *ratecontrol_desc;
+ mfxVideoParam param_out = { .mfx.CodecId = q->param.mfx.CodecId };
+ mfxStatus ret;
+
+ ret = MFXVideoENCODE_Query(q->session, &q->param, ¶m_out);
+ if (ret < 0 ||
+ param_out.mfx.RateControlMethod != q->param.mfx.RateControlMethod)
+ return 0;
+ return 1;
+}
+static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
+{
float quant;
int ret;
q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
}
- if (avctx->flags & AV_CODEC_FLAG_QSCALE) {
- q->param.mfx.RateControlMethod = MFX_RATECONTROL_CQP;
- ratecontrol_desc = "constant quantization parameter (CQP)";
- } else if (avctx->rc_max_rate == avctx->bit_rate) {
- q->param.mfx.RateControlMethod = MFX_RATECONTROL_CBR;
- ratecontrol_desc = "constant bitrate (CBR)";
- } else if (!avctx->rc_max_rate) {
-#if QSV_VERSION_ATLEAST(1,7)
- if (q->look_ahead) {
- q->param.mfx.RateControlMethod = MFX_RATECONTROL_LA;
- ratecontrol_desc = "lookahead (LA)";
- } else
-#endif
- {
- q->param.mfx.RateControlMethod = MFX_RATECONTROL_AVBR;
- ratecontrol_desc = "average variable bitrate (AVBR)";
- }
- } else {
- q->param.mfx.RateControlMethod = MFX_RATECONTROL_VBR;
- ratecontrol_desc = "variable bitrate (VBR)";
- }
-
- av_log(avctx, AV_LOG_VERBOSE, "Using the %s ratecontrol method\n", ratecontrol_desc);
+ ret = select_rc_mode(avctx, q);
+ if (ret < 0)
+ return ret;
switch (q->param.mfx.RateControlMethod) {
case MFX_RATECONTROL_CBR:
case MFX_RATECONTROL_VBR:
+#if QSV_HAVE_VCM
+ case MFX_RATECONTROL_VCM:
+#endif
q->param.mfx.InitialDelayInKB = avctx->rc_initial_buffer_occupancy / 1000;
q->param.mfx.TargetKbps = avctx->bit_rate / 1000;
q->param.mfx.MaxKbps = avctx->rc_max_rate / 1000;
break;
case MFX_RATECONTROL_AVBR:
-#if QSV_VERSION_ATLEAST(1,7)
- case MFX_RATECONTROL_LA:
-#endif
q->param.mfx.TargetKbps = avctx->bit_rate / 1000;
q->param.mfx.Convergence = q->avbr_convergence;
q->param.mfx.Accuracy = q->avbr_accuracy;
break;
+#if QSV_HAVE_LA
+ case MFX_RATECONTROL_LA:
+ q->param.mfx.TargetKbps = avctx->bit_rate / 1000;
+ q->extco2.LookAheadDepth = q->look_ahead_depth;
+ break;
+#if QSV_HAVE_ICQ
+ case MFX_RATECONTROL_LA_ICQ:
+ q->extco2.LookAheadDepth = q->look_ahead_depth;
+ case MFX_RATECONTROL_ICQ:
+ q->param.mfx.ICQQuality = avctx->global_quality;
+ break;
+#endif
+#endif
}
// the HEVC encoder plugin currently fails if coding options
q->extco.PicTimingSEI = q->pic_timing_sei ?
MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;
+ if (q->rdo >= 0)
+ q->extco.RateDistortionOpt = q->rdo > 0 ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
+
+ if (avctx->codec_id == AV_CODEC_ID_H264) {
+ if (avctx->strict_std_compliance != FF_COMPLIANCE_NORMAL)
+ q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?
+ MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
+
+ if (q->single_sei_nal_unit >= 0)
+ q->extco.SingleSeiNalUnit = q->single_sei_nal_unit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
+ if (q->recovery_point_sei >= 0)
+ q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
+ q->extco.MaxDecFrameBuffering = q->max_dec_frame_buffering;
+ }
+
q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco;
-#if QSV_VERSION_ATLEAST(1,6)
- q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
- q->extco2.Header.BufferSz = sizeof(q->extco2);
+#if QSV_HAVE_CO2
+ if (avctx->codec_id == AV_CODEC_ID_H264) {
+ q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
+ q->extco2.Header.BufferSz = sizeof(q->extco2);
+
+ if (q->int_ref_type >= 0)
+ q->extco2.IntRefType = q->int_ref_type;
+ if (q->int_ref_cycle_size >= 0)
+ q->extco2.IntRefCycleSize = q->int_ref_cycle_size;
+ if (q->int_ref_qp_delta != INT16_MIN)
+ q->extco2.IntRefQPDelta = q->int_ref_qp_delta;
+
+ if (q->bitrate_limit >= 0)
+ q->extco2.BitrateLimit = q->bitrate_limit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
+ if (q->mbbrc >= 0)
+ q->extco2.MBBRC = q->mbbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
+ if (q->extbrc >= 0)
+ q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
+
+ if (q->max_frame_size >= 0)
+ q->extco2.MaxFrameSize = q->max_frame_size;
+#if QSV_HAVE_MAX_SLICE_SIZE
+ if (q->max_slice_size >= 0)
+ q->extco2.MaxSliceSize = q->max_slice_size;
+#endif
-#if QSV_VERSION_ATLEAST(1,7)
- // valid value range is from 10 to 100 inclusive
- // to instruct the encoder to use the default value this should be set to zero
- q->extco2.LookAheadDepth = q->look_ahead_depth != 0 ? FFMAX(10, q->look_ahead_depth) : 0;
+#if QSV_HAVE_TRELLIS
+ q->extco2.Trellis = q->trellis;
#endif
-#if QSV_VERSION_ATLEAST(1,8)
- q->extco2.LookAheadDS = q->look_ahead_downsampling;
+
+#if QSV_HAVE_BREF_TYPE
+ if (avctx->b_frame_strategy >= 0)
+ q->extco2.BRefType = avctx->b_frame_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
+ if (q->adaptive_i >= 0)
+ q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
+ if (q->adaptive_b >= 0)
+ q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
#endif
- q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
+ q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
+#if QSV_VERSION_ATLEAST(1,8)
+ q->extco2.LookAheadDS = q->look_ahead_downsampling;
#endif
+ }
+#endif
+ }
+
+ if (!rc_supported(q)) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Selected ratecontrol mode is not supported by the QSV "
+ "runtime. Choose a different mode.\n");
+ return AVERROR(ENOSYS);
}
return 0;
.PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
};
+ mfxExtCodingOption co = {
+ .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
+ .Header.BufferSz = sizeof(co),
+ };
+#if QSV_HAVE_CO2
+ mfxExtCodingOption2 co2 = {
+ .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
+ .Header.BufferSz = sizeof(co2),
+ };
+#endif
+#if QSV_HAVE_CO3
+ mfxExtCodingOption3 co3 = {
+ .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
+ .Header.BufferSz = sizeof(co3),
+ };
+#endif
+
mfxExtBuffer *ext_buffers[] = {
(mfxExtBuffer*)&extradata,
+ (mfxExtBuffer*)&co,
+#if QSV_HAVE_CO2
+ (mfxExtBuffer*)&co2,
+#endif
+#if QSV_HAVE_CO3
+ (mfxExtBuffer*)&co3,
+#endif
};
int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
+ dump_video_param(avctx, q, ext_buffers + 1);
+
return 0;
}
return 0;
}
+static void free_encoder_ctrl_payloads(mfxEncodeCtrl* enc_ctrl)
+{
+ if (enc_ctrl) {
+ int i;
+ for (i = 0; i < enc_ctrl->NumPayload && i < QSV_MAX_ENC_PAYLOAD; i++) {
+ mfxPayload* pay = enc_ctrl->Payload[i];
+ av_free(enc_ctrl->Payload[i]->Data);
+ av_free(pay);
+ }
+ enc_ctrl->NumPayload = 0;
+ }
+}
+
static void clear_unused_frames(QSVEncContext *q)
{
QSVFrame *cur = q->work_frames;
while (cur) {
if (cur->surface && !cur->surface->Data.Locked) {
cur->surface = NULL;
+ free_encoder_ctrl_payloads(&cur->enc_ctrl);
av_frame_unref(cur->frame);
}
cur = cur->next;
av_freep(&frame);
return AVERROR(ENOMEM);
}
+ frame->enc_ctrl.Payload = av_mallocz(sizeof(mfxPayload*) * QSV_MAX_ENC_PAYLOAD);
+ if (!frame->enc_ctrl.Payload) {
+ av_freep(&frame);
+ return AVERROR(ENOMEM);
+ }
*last = frame;
*f = frame;
}
static int submit_frame(QSVEncContext *q, const AVFrame *frame,
- mfxFrameSurface1 **surface)
+ QSVFrame **new_frame)
{
QSVFrame *qf;
int ret;
qf->surface->Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
- *surface = qf->surface;
+ *new_frame = qf;
return 0;
}
mfxFrameSurface1 *surf = NULL;
mfxSyncPoint sync = NULL;
+ QSVFrame *qsv_frame = NULL;
+ mfxEncodeCtrl* enc_ctrl = NULL;
int ret;
if (frame) {
- ret = submit_frame(q, frame, &surf);
+ ret = submit_frame(q, frame, &qsv_frame);
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
return ret;
}
}
+ if (qsv_frame) {
+ surf = qsv_frame->surface;
+ enc_ctrl = &qsv_frame->enc_ctrl;
+ }
ret = av_new_packet(&new_pkt, q->packet_size);
if (ret < 0) {
bs->Data = new_pkt.data;
bs->MaxLength = new_pkt.size;
+ if (q->set_encode_ctrl_cb) {
+ q->set_encode_ctrl_cb(avctx, frame, &qsv_frame->enc_ctrl);
+ }
+
do {
- ret = MFXVideoENCODE_EncodeFrameAsync(q->session, NULL, surf, bs, &sync);
+ ret = MFXVideoENCODE_EncodeFrameAsync(q->session, enc_ctrl, surf, bs, &sync);
if (ret == MFX_WRN_DEVICE_BUSY) {
av_usleep(500);
continue;
while (cur) {
q->work_frames = cur->next;
av_frame_free(&cur->frame);
+ av_free(cur->enc_ctrl.Payload);
av_freep(&cur);
cur = q->work_frames;
}
projects / ffmpeg / blobdiff