{ MFX_RATECONTROL_CBR, "CBR" },
{ MFX_RATECONTROL_VBR, "VBR" },
{ MFX_RATECONTROL_CQP, "CQP" },
+#if QSV_HAVE_AVBR
{ MFX_RATECONTROL_AVBR, "AVBR" },
+#endif
#if QSV_HAVE_LA
{ MFX_RATECONTROL_LA, "LA" },
#endif
} 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) {
+ }
+#if QSV_HAVE_AVBR
+ 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);
}
+#endif
#if QSV_HAVE_LA
else if (info->RateControlMethod == MFX_RATECONTROL_LA
#if QSV_HAVE_LA_HRD
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) {
+ }
+#if QSV_HAVE_AVBR
+ else if (!avctx->rc_max_rate) {
rc_mode = MFX_RATECONTROL_AVBR;
rc_desc = "average variable bitrate (AVBR)";
- } else {
+ }
+#endif
+ else {
rc_mode = MFX_RATECONTROL_VBR;
rc_desc = "variable bitrate (VBR)";
}
return 0;
}
-static int rc_supported(QSVEncContext *q)
+static int check_enc_param(AVCodecContext *avctx, QSVEncContext *q)
{
mfxVideoParam param_out = { .mfx.CodecId = q->param.mfx.CodecId };
mfxStatus ret;
+#define UNMATCH(x) (param_out.mfx.x != q->param.mfx.x)
+
ret = MFXVideoENCODE_Query(q->session, &q->param, ¶m_out);
- if (ret < 0 ||
- param_out.mfx.RateControlMethod != q->param.mfx.RateControlMethod)
+
+ if (ret < 0) {
+ if (UNMATCH(CodecId))
+ av_log(avctx, AV_LOG_ERROR, "Current codec type is unsupported\n");
+ if (UNMATCH(CodecProfile))
+ av_log(avctx, AV_LOG_ERROR, "Current profile is unsupported\n");
+ if (UNMATCH(RateControlMethod))
+ av_log(avctx, AV_LOG_ERROR, "Selected ratecontrol mode is unsupported\n");
+ if (UNMATCH(LowPower))
+ av_log(avctx, AV_LOG_ERROR, "Low power mode is unsupported\n");
+ if (UNMATCH(FrameInfo.FrameRateExtN) || UNMATCH(FrameInfo.FrameRateExtD))
+ av_log(avctx, AV_LOG_ERROR, "Current frame rate is unsupported\n");
+ if (UNMATCH(FrameInfo.PicStruct))
+ av_log(avctx, AV_LOG_ERROR, "Current picture structure is unsupported\n");
+ if (UNMATCH(FrameInfo.Width) || UNMATCH(FrameInfo.Height))
+ av_log(avctx, AV_LOG_ERROR, "Current resolution is unsupported\n");
+ if (UNMATCH(FrameInfo.FourCC))
+ av_log(avctx, AV_LOG_ERROR, "Current pixel format is unsupported\n");
return 0;
+ }
return 1;
}
q->param.mfx.QPB = av_clip(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 0, 51);
break;
+#if QSV_HAVE_AVBR
case MFX_RATECONTROL_AVBR:
q->param.mfx.TargetKbps = avctx->bit_rate / 1000;
q->param.mfx.Convergence = q->avbr_convergence;
q->param.mfx.Accuracy = q->avbr_accuracy;
break;
+#endif
#if QSV_HAVE_LA
case MFX_RATECONTROL_LA:
q->param.mfx.TargetKbps = avctx->bit_rate / 1000;
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->extco.AUDelimiter = q->aud ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
}
q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco;
q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
}
+#endif
+#if QSV_HAVE_MF
+ if (avctx->codec_id == AV_CODEC_ID_H264) {
+ mfxVersion ver;
+ ret = MFXQueryVersion(q->session,&ver);
+ if (ret >= MFX_ERR_NONE && QSV_RUNTIME_VERSION_ATLEAST(ver, 1, 25)) {
+ q->extmfp.Header.BufferId = MFX_EXTBUFF_MULTI_FRAME_PARAM;
+ q->extmfp.Header.BufferSz = sizeof(q->extmfp);
+
+ q->extmfp.MFMode = q->mfmode;
+ av_log(avctx,AV_LOG_VERBOSE,"MFMode:%d\n", q->extmfp.MFMode);
+ q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extmfp;
+ }
+ }
#endif
}
- if (!rc_supported(q)) {
+ if (!check_enc_param(avctx,q)) {
av_log(avctx, AV_LOG_ERROR,
- "Selected ratecontrol mode is not supported by the QSV "
- "runtime. Choose a different mode.\n");
+ "some encoding parameters are not supported by the QSV "
+ "runtime. Please double check the input parameters.\n");
return AVERROR(ENOSYS);
}
{
AVPacket new_pkt = { 0 };
mfxBitstream *bs;
+#if QSV_VERSION_ATLEAST(1, 26)
+ mfxExtAVCEncodedFrameInfo *enc_info;
+ mfxExtBuffer **enc_buf;
+#endif
mfxFrameSurface1 *surf = NULL;
mfxSyncPoint *sync = NULL;
bs->Data = new_pkt.data;
bs->MaxLength = new_pkt.size;
+#if QSV_VERSION_ATLEAST(1, 26)
+ if (avctx->codec_id == AV_CODEC_ID_H264) {
+ enc_info = av_mallocz(sizeof(*enc_info));
+ if (!enc_info)
+ return AVERROR(ENOMEM);
+
+ enc_info->Header.BufferId = MFX_EXTBUFF_ENCODED_FRAME_INFO;
+ enc_info->Header.BufferSz = sizeof (*enc_info);
+ bs->NumExtParam = 1;
+ enc_buf = av_mallocz(sizeof(mfxExtBuffer *));
+ if (!enc_buf)
+ return AVERROR(ENOMEM);
+ enc_buf[0] = (mfxExtBuffer *)enc_info;
+
+ bs->ExtParam = enc_buf;
+ }
+#endif
+
if (q->set_encode_ctrl_cb) {
q->set_encode_ctrl_cb(avctx, frame, &qsv_frame->enc_ctrl);
}
sync = av_mallocz(sizeof(*sync));
if (!sync) {
av_freep(&bs);
+ #if QSV_VERSION_ATLEAST(1, 26)
+ if (avctx->codec_id == AV_CODEC_ID_H264) {
+ av_freep(&enc_info);
+ av_freep(&enc_buf);
+ }
+ #endif
av_packet_unref(&new_pkt);
return AVERROR(ENOMEM);
}
if (ret < 0) {
av_packet_unref(&new_pkt);
av_freep(&bs);
+#if QSV_VERSION_ATLEAST(1, 26)
+ if (avctx->codec_id == AV_CODEC_ID_H264) {
+ av_freep(&enc_info);
+ av_freep(&enc_buf);
+ }
+#endif
av_freep(&sync);
return (ret == MFX_ERR_MORE_DATA) ?
0 : ff_qsv_print_error(avctx, ret, "Error during encoding");
av_freep(&sync);
av_packet_unref(&new_pkt);
av_freep(&bs);
+#if QSV_VERSION_ATLEAST(1, 26)
+ if (avctx->codec_id == AV_CODEC_ID_H264) {
+ av_freep(&enc_info);
+ av_freep(&enc_buf);
+ }
+#endif
}
return 0;
AVPacket new_pkt;
mfxBitstream *bs;
mfxSyncPoint *sync;
+#if QSV_VERSION_ATLEAST(1, 26)
+ mfxExtAVCEncodedFrameInfo *enc_info;
+ mfxExtBuffer **enc_buf;
+#endif
+ enum AVPictureType pict_type;
av_fifo_generic_read(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
bs->FrameType & MFX_FRAMETYPE_xIDR)
new_pkt.flags |= AV_PKT_FLAG_KEY;
-#if FF_API_CODED_FRAME
-FF_DISABLE_DEPRECATION_WARNINGS
if (bs->FrameType & MFX_FRAMETYPE_I || bs->FrameType & MFX_FRAMETYPE_xI)
- avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
+ pict_type = AV_PICTURE_TYPE_I;
else if (bs->FrameType & MFX_FRAMETYPE_P || bs->FrameType & MFX_FRAMETYPE_xP)
- avctx->coded_frame->pict_type = AV_PICTURE_TYPE_P;
+ pict_type = AV_PICTURE_TYPE_P;
else if (bs->FrameType & MFX_FRAMETYPE_B || bs->FrameType & MFX_FRAMETYPE_xB)
- avctx->coded_frame->pict_type = AV_PICTURE_TYPE_B;
+ pict_type = AV_PICTURE_TYPE_B;
+
+#if FF_API_CODED_FRAME
+FF_DISABLE_DEPRECATION_WARNINGS
+ avctx->coded_frame->pict_type = pict_type;
FF_ENABLE_DEPRECATION_WARNINGS
#endif
+#if QSV_VERSION_ATLEAST(1, 26)
+ if (avctx->codec_id == AV_CODEC_ID_H264) {
+ enc_buf = bs->ExtParam;
+ enc_info = (mfxExtAVCEncodedFrameInfo *)(*bs->ExtParam);
+ ff_side_data_set_encoder_stats(&new_pkt,
+ enc_info->QP * FF_QP2LAMBDA, NULL, 0, pict_type);
+ av_freep(&enc_info);
+ av_freep(&enc_buf);
+ }
+#endif
av_freep(&bs);
av_freep(&sync);
projects / ffmpeg / blobdiff