falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
42568 Commits
32 Branches
555MB
Tree: e7d7cf86dc
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e7d7cf86dc'
${ noResults }
FFmpeg/libavcodec/qsvenc.c

950 lines
32KB
Raw Blame History 

  1. /*

  2.  * Intel MediaSDK QSV encoder utility functions

  3.  *

  4.  * copyright (c) 2013 Yukinori Yamazoe

  5.  * copyright (c) 2015 Anton Khirnov

  6.  *

  7.  * This file is part of Libav.

  8.  *

  9.  * Libav is free software; you can redistribute it and/or

  10.  * modify it under the terms of the GNU Lesser General Public

  11.  * License as published by the Free Software Foundation; either

  12.  * version 2.1 of the License, or (at your option) any later version.

  13.  *

  14.  * Libav is distributed in the hope that it will be useful,

  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  17.  * Lesser General Public License for more details.

  18.  *

  19.  * You should have received a copy of the GNU Lesser General Public

  20.  * License along with Libav; if not, write to the Free Software

  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  22.  */

  23. 

  24. #include <string.h>

  25. #include <sys/types.h>

  26. #include <mfx/mfxvideo.h>

  27. 

  28. #include "libavutil/common.h"

  29. #include "libavutil/mem.h"

  30. #include "libavutil/log.h"

  31. #include "libavutil/time.h"

  32. #include "libavutil/imgutils.h"

  33. 

  34. #include "avcodec.h"

  35. #include "internal.h"

  36. #include "qsv.h"

  37. #include "qsv_internal.h"

  38. #include "qsvenc.h"

  39. 

  40. static const struct {

  41.     mfxU16 profile;

  42.     const char *name;

  43. } profile_names[] = {

  44.     { MFX_PROFILE_AVC_BASELINE,                 "baseline"              },

  45.     { MFX_PROFILE_AVC_MAIN,                     "main"                  },

  46.     { MFX_PROFILE_AVC_EXTENDED,                 "extended"              },

  47.     { MFX_PROFILE_AVC_HIGH,                     "high"                  },

  48. #if QSV_VERSION_ATLEAST(1, 15)

  49.     { MFX_PROFILE_AVC_HIGH_422,                 "high 422"              },

  50. #endif

  51. #if QSV_VERSION_ATLEAST(1, 4)

  52.     { MFX_PROFILE_AVC_CONSTRAINED_BASELINE,     "constrained baseline"  },

  53.     { MFX_PROFILE_AVC_CONSTRAINED_HIGH,         "constrained high"      },

  54.     { MFX_PROFILE_AVC_PROGRESSIVE_HIGH,         "progressive high"      },

  55. #endif

  56.     { MFX_PROFILE_MPEG2_SIMPLE,                 "simple"                },

  57.     { MFX_PROFILE_MPEG2_MAIN,                   "main"                  },

  58.     { MFX_PROFILE_MPEG2_HIGH,                   "high"                  },

  59.     { MFX_PROFILE_VC1_SIMPLE,                   "simple"                },

  60.     { MFX_PROFILE_VC1_MAIN,                     "main"                  },

  61.     { MFX_PROFILE_VC1_ADVANCED,                 "advanced"              },

  62. #if QSV_VERSION_ATLEAST(1, 8)

  63.     { MFX_PROFILE_HEVC_MAIN,                    "main"                  },

  64.     { MFX_PROFILE_HEVC_MAIN10,                  "main10"                },

  65.     { MFX_PROFILE_HEVC_MAINSP,                  "mainsp"                },

  66. #endif

  67. };

  68. 

  69. static const char *print_profile(mfxU16 profile)

  70. {

  71.     int i;

  72.     for (i = 0; i < FF_ARRAY_ELEMS(profile_names); i++)

  73.         if (profile == profile_names[i].profile)

  74.             return profile_names[i].name;

  75.     return "unknown";

  76. }

  77. 

  78. static const struct {

  79.     mfxU16      rc_mode;

  80.     const char *name;

  81. } rc_names[] = {

  82.     { MFX_RATECONTROL_CBR,     "CBR" },

  83.     { MFX_RATECONTROL_VBR,     "VBR" },

  84.     { MFX_RATECONTROL_CQP,     "CQP" },

  85.     { MFX_RATECONTROL_AVBR,    "AVBR" },

  86. #if QSV_HAVE_LA

  87.     { MFX_RATECONTROL_LA,      "LA" },

  88. #endif

  89. #if QSV_HAVE_ICQ

  90.     { MFX_RATECONTROL_ICQ,     "ICQ" },

  91.     { MFX_RATECONTROL_LA_ICQ,  "LA_ICQ" },

  92. #endif

  93. #if QSV_HAVE_VCM

  94.     { MFX_RATECONTROL_VCM,     "VCM" },

  95. #endif

  96. #if QSV_VERSION_ATLEAST(1, 10)

  97.     { MFX_RATECONTROL_LA_EXT,  "LA_EXT" },

  98. #endif

  99. #if QSV_HAVE_LA_HRD

  100.     { MFX_RATECONTROL_LA_HRD,  "LA_HRD" },

  101. #endif

  102. #if QSV_HAVE_QVBR

  103.     { MFX_RATECONTROL_QVBR,    "QVBR" },

  104. #endif

  105. };

  106. 

  107. static const char *print_ratecontrol(mfxU16 rc_mode)

  108. {

  109.     int i;

  110.     for (i = 0; i < FF_ARRAY_ELEMS(rc_names); i++)

  111.         if (rc_mode == rc_names[i].rc_mode)

  112.             return rc_names[i].name;

  113.     return "unknown";

  114. }

  115. 

  116. static const char *print_threestate(mfxU16 val)

  117. {

  118.     if (val == MFX_CODINGOPTION_ON)

  119.         return "ON";

  120.     else if (val == MFX_CODINGOPTION_OFF)

  121.         return "OFF";

  122.     return "unknown";

  123. }

  124. 

  125. static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q,

  126.                              mfxExtBuffer **coding_opts)

  127. {

  128.     mfxInfoMFX *info = &q->param.mfx;

  129. 

  130.     mfxExtCodingOption   *co = (mfxExtCodingOption*)coding_opts[0];

  131. #if QSV_HAVE_CO2

  132.     mfxExtCodingOption2 *co2 = (mfxExtCodingOption2*)coding_opts[1];

  133. #endif

  134. #if QSV_HAVE_CO3

  135.     mfxExtCodingOption3 *co3 = (mfxExtCodingOption3*)coding_opts[2];

  136. #endif

  137. 

  138.     av_log(avctx, AV_LOG_VERBOSE, "profile: %s; level: %"PRIu16"\n",

  139.            print_profile(info->CodecProfile), info->CodecLevel);

  140. 

  141.     av_log(avctx, AV_LOG_VERBOSE, "GopPicSize: %"PRIu16"; GopRefDist: %"PRIu16"; GopOptFlag: ",

  142.            info->GopPicSize, info->GopRefDist);

  143.     if (info->GopOptFlag & MFX_GOP_CLOSED)

  144.         av_log(avctx, AV_LOG_VERBOSE, "closed ");

  145.     if (info->GopOptFlag & MFX_GOP_STRICT)

  146.         av_log(avctx, AV_LOG_VERBOSE, "strict ");

  147.     av_log(avctx, AV_LOG_VERBOSE, "; IdrInterval: %"PRIu16"\n", info->IdrInterval);

  148. 

  149.     av_log(avctx, AV_LOG_VERBOSE, "TargetUsage: %"PRIu16"; RateControlMethod: %s\n",

  150.            info->TargetUsage, print_ratecontrol(info->RateControlMethod));

  151. 

  152.     if (info->RateControlMethod == MFX_RATECONTROL_CBR ||

  153.         info->RateControlMethod == MFX_RATECONTROL_VBR

  154. #if QSV_HAVE_VCM

  155.         || info->RateControlMethod == MFX_RATECONTROL_VCM

  156. #endif

  157.         ) {

  158.         av_log(avctx, AV_LOG_VERBOSE,

  159.                "InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"\n",

  160.                info->InitialDelayInKB, info->TargetKbps, info->MaxKbps);

  161.     } else if (info->RateControlMethod == MFX_RATECONTROL_CQP) {

  162.         av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",

  163.                info->QPI, info->QPP, info->QPB);

  164.     } else if (info->RateControlMethod == MFX_RATECONTROL_AVBR) {

  165.         av_log(avctx, AV_LOG_VERBOSE,

  166.                "TargetKbps: %"PRIu16"; Accuracy: %"PRIu16"; Convergence: %"PRIu16"\n",

  167.                info->TargetKbps, info->Accuracy, info->Convergence);

  168.     }

  169. #if QSV_HAVE_LA

  170.     else if (info->RateControlMethod == MFX_RATECONTROL_LA

  171. #if QSV_HAVE_LA_HRD

  172.              || info->RateControlMethod == MFX_RATECONTROL_LA_HRD

  173. #endif

  174.              ) {

  175.         av_log(avctx, AV_LOG_VERBOSE,

  176.                "TargetKbps: %"PRIu16"; LookAheadDepth: %"PRIu16"\n",

  177.                info->TargetKbps, co2->LookAheadDepth);

  178.     }

  179. #endif

  180. #if QSV_HAVE_ICQ

  181.     else if (info->RateControlMethod == MFX_RATECONTROL_ICQ) {

  182.         av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);

  183.     } else if (info->RateControlMethod == MFX_RATECONTROL_LA_ICQ) {

  184.         av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"; LookAheadDepth: %"PRIu16"\n",

  185.                info->ICQQuality, co2->LookAheadDepth);

  186.     }

  187. #endif

  188. #if QSV_HAVE_QVBR

  189.     else if (info->RateControlMethod == MFX_RATECONTROL_QVBR) {

  190.         av_log(avctx, AV_LOG_VERBOSE, "QVBRQuality: %"PRIu16"\n",

  191.                co3->QVBRQuality);

  192.     }

  193. #endif

  194. 

  195.     av_log(avctx, AV_LOG_VERBOSE, "NumSlice: %"PRIu16"; NumRefFrame: %"PRIu16"\n",

  196.            info->NumSlice, info->NumRefFrame);

  197.     av_log(avctx, AV_LOG_VERBOSE, "RateDistortionOpt: %s\n",

  198.            print_threestate(co->RateDistortionOpt));

  199. 

  200. #if QSV_HAVE_CO2

  201.     av_log(avctx, AV_LOG_VERBOSE,

  202.            "RecoveryPointSEI: %s IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16"; IntRefQPDelta: %"PRId16"\n",

  203.            print_threestate(co->RecoveryPointSEI), co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);

  204. 

  205.     av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %"PRIu16"; ", co2->MaxFrameSize);

  206. #if QSV_VERSION_ATLEAST(1, 9)

  207.     av_log(avctx, AV_LOG_VERBOSE, "MaxSliceSize: %"PRIu16"; ", co2->MaxSliceSize);

  208. #endif

  209.     av_log(avctx, AV_LOG_VERBOSE, "\n");

  210. 

  211.     av_log(avctx, AV_LOG_VERBOSE,

  212.            "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",

  213.            print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),

  214.            print_threestate(co2->ExtBRC));

  215. 

  216. #if QSV_HAVE_TRELLIS

  217.     av_log(avctx, AV_LOG_VERBOSE, "Trellis: ");

  218.     if (co2->Trellis & MFX_TRELLIS_OFF) {

  219.         av_log(avctx, AV_LOG_VERBOSE, "off");

  220.     } else if (!co2->Trellis) {

  221.         av_log(avctx, AV_LOG_VERBOSE, "auto");

  222.     } else {

  223.         if (co2->Trellis & MFX_TRELLIS_I) av_log(avctx, AV_LOG_VERBOSE, "I");

  224.         if (co2->Trellis & MFX_TRELLIS_P) av_log(avctx, AV_LOG_VERBOSE, "P");

  225.         if (co2->Trellis & MFX_TRELLIS_B) av_log(avctx, AV_LOG_VERBOSE, "B");

  226.     }

  227.     av_log(avctx, AV_LOG_VERBOSE, "\n");

  228. #endif

  229. 

  230. #if QSV_VERSION_ATLEAST(1, 8)

  231.     av_log(avctx, AV_LOG_VERBOSE,

  232.            "RepeatPPS: %s; NumMbPerSlice: %"PRIu16"; LookAheadDS: ",

  233.            print_threestate(co2->RepeatPPS), co2->NumMbPerSlice);

  234.     switch (co2->LookAheadDS) {

  235.     case MFX_LOOKAHEAD_DS_OFF: av_log(avctx, AV_LOG_VERBOSE, "off");     break;

  236.     case MFX_LOOKAHEAD_DS_2x:  av_log(avctx, AV_LOG_VERBOSE, "2x");      break;

  237.     case MFX_LOOKAHEAD_DS_4x:  av_log(avctx, AV_LOG_VERBOSE, "4x");      break;

  238.     default:                   av_log(avctx, AV_LOG_VERBOSE, "unknown"); break;

  239.     }

  240.     av_log(avctx, AV_LOG_VERBOSE, "\n");

  241. 

  242.     av_log(avctx, AV_LOG_VERBOSE, "AdaptiveI: %s; AdaptiveB: %s; BRefType: ",

  243.            print_threestate(co2->AdaptiveI), print_threestate(co2->AdaptiveB));

  244.     switch (co2->BRefType) {

  245.     case MFX_B_REF_OFF:     av_log(avctx, AV_LOG_VERBOSE, "off");       break;

  246.     case MFX_B_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "pyramid");   break;

  247.     default:                av_log(avctx, AV_LOG_VERBOSE, "auto");      break;

  248.     }

  249.     av_log(avctx, AV_LOG_VERBOSE, "\n");

  250. #endif

  251. 

  252. #if QSV_VERSION_ATLEAST(1, 9)

  253.     av_log(avctx, AV_LOG_VERBOSE,

  254.            "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",

  255.            co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);

  256. #endif

  257. #endif

  258. 

  259.     if (avctx->codec_id == AV_CODEC_ID_H264) {

  260.         av_log(avctx, AV_LOG_VERBOSE, "Entropy coding: %s; MaxDecFrameBuffering: %"PRIu16"\n",

  261.                co->CAVLC == MFX_CODINGOPTION_ON ? "CAVLC" : "CABAC", co->MaxDecFrameBuffering);

  262.         av_log(avctx, AV_LOG_VERBOSE,

  263.                "NalHrdConformance: %s; SingleSeiNalUnit: %s; VuiVclHrdParameters: %s VuiNalHrdParameters: %s\n",

  264.                print_threestate(co->NalHrdConformance), print_threestate(co->SingleSeiNalUnit),

  265.                print_threestate(co->VuiVclHrdParameters), print_threestate(co->VuiNalHrdParameters));

  266.     }

  267. }

  268. 

  269. static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q)

  270. {

  271.     const char *rc_desc;

  272.     mfxU16      rc_mode;

  273. 

  274.     int want_la     = q->la_depth >= 0;

  275.     int want_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);

  276.     int want_vcm    = q->vcm;

  277. 

  278.     if (want_la && !QSV_HAVE_LA) {

  279.         av_log(avctx, AV_LOG_ERROR,

  280.                "Lookahead ratecontrol mode requested, but is not supported by this SDK version\n");

  281.         return AVERROR(ENOSYS);

  282.     }

  283.     if (want_vcm && !QSV_HAVE_VCM) {

  284.         av_log(avctx, AV_LOG_ERROR,

  285.                "VCM ratecontrol mode requested, but is not supported by this SDK version\n");

  286.         return AVERROR(ENOSYS);

  287.     }

  288. 

  289.     if (want_la + want_qscale + want_vcm > 1) {

  290.         av_log(avctx, AV_LOG_ERROR,

  291.                "More than one of: { constant qscale, lookahead, VCM } requested, "

  292.                "only one of them can be used at a time.\n");

  293.         return AVERROR(EINVAL);

  294.     }

  295. 

  296.     if (want_qscale) {

  297.         rc_mode = MFX_RATECONTROL_CQP;

  298.         rc_desc = "constant quantization parameter (CQP)";

  299.     }

  300. #if QSV_HAVE_VCM

  301.     else if (want_vcm) {

  302.         rc_mode = MFX_RATECONTROL_VCM;

  303.         rc_desc = "video conferencing mode (VCM)";

  304.     }

  305. #endif

  306. #if QSV_HAVE_LA

  307.     else if (want_la) {

  308.         rc_mode = MFX_RATECONTROL_LA;

  309.         rc_desc = "VBR with lookahead (LA)";

  310. 

  311. #if QSV_HAVE_ICQ

  312.         if (avctx->global_quality > 0) {

  313.             rc_mode = MFX_RATECONTROL_LA_ICQ;

  314.             rc_desc = "intelligent constant quality with lookahead (LA_ICQ)";

  315.         }

  316. #endif

  317.     }

  318. #endif

  319. #if QSV_HAVE_ICQ

  320.     else if (avctx->global_quality > 0) {

  321.         rc_mode = MFX_RATECONTROL_ICQ;

  322.         rc_desc = "intelligent constant quality (ICQ)";

  323.     }

  324. #endif

  325.     else if (avctx->rc_max_rate == avctx->bit_rate) {

  326.         rc_mode = MFX_RATECONTROL_CBR;

  327.         rc_desc = "constant bitrate (CBR)";

  328.     } else if (!avctx->rc_max_rate) {

  329.         rc_mode = MFX_RATECONTROL_AVBR;

  330.         rc_desc = "average variable bitrate (AVBR)";

  331.     } else {

  332.         rc_mode = MFX_RATECONTROL_VBR;

  333.         rc_desc = "variable bitrate (VBR)";

  334.     }

  335. 

  336.     q->param.mfx.RateControlMethod = rc_mode;

  337.     av_log(avctx, AV_LOG_VERBOSE, "Using the %s ratecontrol method\n", rc_desc);

  338. 

  339.     return 0;

  340. }

  341. 

  342. static int rc_supported(QSVEncContext *q)

  343. {

  344.     mfxVideoParam param_out = { .mfx.CodecId = q->param.mfx.CodecId };

  345.     mfxStatus ret;

  346. 

  347.     ret = MFXVideoENCODE_Query(q->session, &q->param, &param_out);

  348.     if (ret < 0 ||

  349.         param_out.mfx.RateControlMethod != q->param.mfx.RateControlMethod)

  350.         return 0;

  351.     return 1;

  352. }

  353. 

  354. static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)

  355. {

  356.     float quant;

  357.     int ret;

  358. 

  359.     ret = ff_qsv_codec_id_to_mfx(avctx->codec_id);

  360.     if (ret < 0)

  361.         return AVERROR_BUG;

  362.     q->param.mfx.CodecId = ret;

  363. 

  364.     q->width_align = avctx->codec_id == AV_CODEC_ID_HEVC ? 32 : 16;

  365. 

  366.     if (avctx->level > 0)

  367.         q->param.mfx.CodecLevel = avctx->level;

  368. 

  369.     q->param.mfx.CodecProfile       = q->profile;

  370.     q->param.mfx.TargetUsage        = q->preset;

  371.     q->param.mfx.GopPicSize         = FFMAX(0, avctx->gop_size);

  372.     q->param.mfx.GopRefDist         = FFMAX(-1, avctx->max_b_frames) + 1;

  373.     q->param.mfx.GopOptFlag         = avctx->flags & AV_CODEC_FLAG_CLOSED_GOP ?

  374.                                       MFX_GOP_CLOSED : 0;

  375.     q->param.mfx.IdrInterval        = q->idr_interval;

  376.     q->param.mfx.NumSlice           = avctx->slices;

  377.     q->param.mfx.NumRefFrame        = FFMAX(0, avctx->refs);

  378.     q->param.mfx.EncodedOrder       = 0;

  379.     q->param.mfx.BufferSizeInKB     = 0;

  380. 

  381.     q->param.mfx.FrameInfo.FourCC         = MFX_FOURCC_NV12;

  382.     q->param.mfx.FrameInfo.Width          = FFALIGN(avctx->width, q->width_align);

  383.     q->param.mfx.FrameInfo.Height         = FFALIGN(avctx->height, 32);

  384.     q->param.mfx.FrameInfo.CropX          = 0;

  385.     q->param.mfx.FrameInfo.CropY          = 0;

  386.     q->param.mfx.FrameInfo.CropW          = avctx->width;

  387.     q->param.mfx.FrameInfo.CropH          = avctx->height;

  388.     q->param.mfx.FrameInfo.AspectRatioW   = avctx->sample_aspect_ratio.num;

  389.     q->param.mfx.FrameInfo.AspectRatioH   = avctx->sample_aspect_ratio.den;

  390.     q->param.mfx.FrameInfo.PicStruct      = MFX_PICSTRUCT_PROGRESSIVE;

  391.     q->param.mfx.FrameInfo.ChromaFormat   = MFX_CHROMAFORMAT_YUV420;

  392.     q->param.mfx.FrameInfo.BitDepthLuma   = 8;

  393.     q->param.mfx.FrameInfo.BitDepthChroma = 8;

  394. 

  395.     if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {

  396.         q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;

  397.         q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;

  398.     } else {

  399.         q->param.mfx.FrameInfo.FrameRateExtN  = avctx->time_base.den;

  400.         q->param.mfx.FrameInfo.FrameRateExtD  = avctx->time_base.num;

  401.     }

  402. 

  403.     ret = select_rc_mode(avctx, q);

  404.     if (ret < 0)

  405.         return ret;

  406. 

  407.     switch (q->param.mfx.RateControlMethod) {

  408.     case MFX_RATECONTROL_CBR:

  409.     case MFX_RATECONTROL_VBR:

  410. #if QSV_HAVE_VCM

  411.     case MFX_RATECONTROL_VCM:

  412. #endif

  413.         q->param.mfx.InitialDelayInKB = avctx->rc_initial_buffer_occupancy / 1000;

  414.         q->param.mfx.TargetKbps       = avctx->bit_rate / 1000;

  415.         q->param.mfx.MaxKbps          = avctx->rc_max_rate / 1000;

  416.         break;

  417.     case MFX_RATECONTROL_CQP:

  418.         quant = avctx->global_quality / FF_QP2LAMBDA;

  419. 

  420.         q->param.mfx.QPI = av_clip(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 0, 51);

  421.         q->param.mfx.QPP = av_clip(quant, 0, 51);

  422.         q->param.mfx.QPB = av_clip(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 0, 51);

  423. 

  424.         break;

  425.     case MFX_RATECONTROL_AVBR:

  426.         q->param.mfx.TargetKbps  = avctx->bit_rate / 1000;

  427.         q->param.mfx.Convergence = q->avbr_convergence;

  428.         q->param.mfx.Accuracy    = q->avbr_accuracy;

  429.         break;

  430. #if QSV_HAVE_LA

  431.     case MFX_RATECONTROL_LA:

  432.         q->param.mfx.TargetKbps  = avctx->bit_rate / 1000;

  433.         q->extco2.LookAheadDepth = q->la_depth;

  434.         break;

  435. #if QSV_HAVE_ICQ

  436.     case MFX_RATECONTROL_LA_ICQ:

  437.         q->extco2.LookAheadDepth = q->la_depth;

  438.     case MFX_RATECONTROL_ICQ:

  439.         q->param.mfx.ICQQuality  = avctx->global_quality;

  440.         break;

  441. #endif

  442. #endif

  443.     }

  444. 

  445.     // the HEVC encoder plugin currently fails if coding options

  446.     // are provided

  447.     if (avctx->codec_id != AV_CODEC_ID_HEVC) {

  448.         q->extco.Header.BufferId      = MFX_EXTBUFF_CODING_OPTION;

  449.         q->extco.Header.BufferSz      = sizeof(q->extco);

  450.         q->extco.CAVLC                = avctx->coder_type == FF_CODER_TYPE_VLC ?

  451.                                         MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;

  452. 

  453.         q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco;

  454. 

  455. #if QSV_HAVE_CO2

  456.         if (avctx->codec_id == AV_CODEC_ID_H264) {

  457.             q->extco2.Header.BufferId     = MFX_EXTBUFF_CODING_OPTION2;

  458.             q->extco2.Header.BufferSz     = sizeof(q->extco2);

  459.             q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;

  460.         }

  461. #endif

  462.     }

  463. 

  464.     if (!rc_supported(q)) {

  465.         av_log(avctx, AV_LOG_ERROR,

  466.                "Selected ratecontrol mode is not supported by the QSV "

  467.                "runtime. Choose a different mode.\n");

  468.         return AVERROR(ENOSYS);

  469.     }

  470. 

  471.     return 0;

  472. }

  473. 

  474. static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)

  475. {

  476.     uint8_t sps_buf[128];

  477.     uint8_t pps_buf[128];

  478. 

  479.     mfxExtCodingOptionSPSPPS extradata = {

  480.         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,

  481.         .Header.BufferSz = sizeof(extradata),

  482.         .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),

  483.         .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)

  484.     };

  485. 

  486.     mfxExtCodingOption co = {

  487.         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,

  488.         .Header.BufferSz = sizeof(co),

  489.     };

  490. #if QSV_HAVE_CO2

  491.     mfxExtCodingOption2 co2 = {

  492.         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,

  493.         .Header.BufferSz = sizeof(co2),

  494.     };

  495. #endif

  496. #if QSV_HAVE_CO3

  497.     mfxExtCodingOption3 co3 = {

  498.         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,

  499.         .Header.BufferSz = sizeof(co3),

  500.     };

  501. #endif

  502. 

  503.     mfxExtBuffer *ext_buffers[] = {

  504.         (mfxExtBuffer*)&extradata,

  505.         (mfxExtBuffer*)&co,

  506. #if QSV_HAVE_CO2

  507.         (mfxExtBuffer*)&co2,

  508. #endif

  509. #if QSV_HAVE_CO3

  510.         (mfxExtBuffer*)&co3,

  511. #endif

  512.     };

  513. 

  514.     int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;

  515.     int ret;

  516. 

  517.     q->param.ExtParam    = ext_buffers;

  518.     q->param.NumExtParam = FF_ARRAY_ELEMS(ext_buffers);

  519. 

  520.     ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);

  521.     if (ret < 0)

  522.         return ff_qsv_error(ret);

  523. 

  524.     q->packet_size = q->param.mfx.BufferSizeInKB * 1000;

  525. 

  526.     if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)) {

  527.         av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");

  528.         return AVERROR_UNKNOWN;

  529.     }

  530. 

  531.     avctx->extradata = av_malloc(extradata.SPSBufSize + need_pps * extradata.PPSBufSize +

  532.                                  AV_INPUT_BUFFER_PADDING_SIZE);

  533.     if (!avctx->extradata)

  534.         return AVERROR(ENOMEM);

  535. 

  536.     memcpy(avctx->extradata,                        sps_buf, extradata.SPSBufSize);

  537.     if (need_pps)

  538.         memcpy(avctx->extradata + extradata.SPSBufSize, pps_buf, extradata.PPSBufSize);

  539.     avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;

  540.     memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

  541. 

  542.     dump_video_param(avctx, q, ext_buffers + 1);

  543. 

  544.     return 0;

  545. }

  546. 

  547. static int qsv_init_opaque_alloc(AVCodecContext *avctx, QSVEncContext *q)

  548. {

  549.     AVQSVContext *qsv = avctx->hwaccel_context;

  550.     mfxFrameSurface1 *surfaces;

  551.     int nb_surfaces, i;

  552. 

  553.     nb_surfaces = qsv->nb_opaque_surfaces + q->req.NumFrameSuggested + q->async_depth;

  554. 

  555.     q->opaque_alloc_buf = av_buffer_allocz(sizeof(*surfaces) * nb_surfaces);

  556.     if (!q->opaque_alloc_buf)

  557.         return AVERROR(ENOMEM);

  558. 

  559.     q->opaque_surfaces = av_malloc_array(nb_surfaces, sizeof(*q->opaque_surfaces));

  560.     if (!q->opaque_surfaces)

  561.         return AVERROR(ENOMEM);

  562. 

  563.     surfaces = (mfxFrameSurface1*)q->opaque_alloc_buf->data;

  564.     for (i = 0; i < nb_surfaces; i++) {

  565.         surfaces[i].Info      = q->req.Info;

  566.         q->opaque_surfaces[i] = surfaces + i;

  567.     }

  568. 

  569.     q->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;

  570.     q->opaque_alloc.Header.BufferSz = sizeof(q->opaque_alloc);

  571.     q->opaque_alloc.In.Surfaces     = q->opaque_surfaces;

  572.     q->opaque_alloc.In.NumSurface   = nb_surfaces;

  573.     q->opaque_alloc.In.Type         = q->req.Type;

  574. 

  575.     q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->opaque_alloc;

  576. 

  577.     qsv->nb_opaque_surfaces = nb_surfaces;

  578.     qsv->opaque_surfaces    = q->opaque_alloc_buf;

  579.     qsv->opaque_alloc_type  = q->req.Type;

  580. 

  581.     return 0;

  582. }

  583. 

  584. int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)

  585. {

  586.     int opaque_alloc = 0;

  587.     int ret;

  588. 

  589.     q->param.IOPattern  = MFX_IOPATTERN_IN_SYSTEM_MEMORY;

  590.     q->param.AsyncDepth = q->async_depth;

  591. 

  592.     q->async_fifo = av_fifo_alloc((1 + q->async_depth) *

  593.                                   (sizeof(AVPacket) + sizeof(mfxSyncPoint) + sizeof(mfxBitstream*)));

  594.     if (!q->async_fifo)

  595.         return AVERROR(ENOMEM);

  596. 

  597.     if (avctx->hwaccel_context) {

  598.         AVQSVContext *qsv = avctx->hwaccel_context;

  599. 

  600.         q->session         = qsv->session;

  601.         q->param.IOPattern = qsv->iopattern;

  602. 

  603.         opaque_alloc = qsv->opaque_alloc;

  604.     }

  605. 

  606.     if (!q->session) {

  607.         ret = ff_qsv_init_internal_session(avctx, &q->internal_session,

  608.                                            q->load_plugins);

  609.         if (ret < 0)

  610.             return ret;

  611. 

  612.         q->session = q->internal_session;

  613.     }

  614. 

  615.     ret = init_video_param(avctx, q);

  616.     if (ret < 0)

  617.         return ret;

  618. 

  619.     ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);

  620.     if (ret < 0) {

  621.         av_log(avctx, AV_LOG_ERROR, "Error querying the encoding parameters\n");

  622.         return ff_qsv_error(ret);

  623.     }

  624. 

  625.     if (opaque_alloc) {

  626.         ret = qsv_init_opaque_alloc(avctx, q);

  627.         if (ret < 0)

  628.             return ret;

  629.     }

  630. 

  631.     if (avctx->hwaccel_context) {

  632.         AVQSVContext *qsv = avctx->hwaccel_context;

  633.         int i, j;

  634. 

  635.         q->extparam = av_mallocz_array(qsv->nb_ext_buffers + q->nb_extparam_internal,

  636.                                        sizeof(*q->extparam));

  637.         if (!q->extparam)

  638.             return AVERROR(ENOMEM);

  639. 

  640.         q->param.ExtParam = q->extparam;

  641.         for (i = 0; i < qsv->nb_ext_buffers; i++)

  642.             q->param.ExtParam[i] = qsv->ext_buffers[i];

  643.         q->param.NumExtParam = qsv->nb_ext_buffers;

  644. 

  645.         for (i = 0; i < q->nb_extparam_internal; i++) {

  646.             for (j = 0; j < qsv->nb_ext_buffers; j++) {

  647.                 if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)

  648.                     break;

  649.             }

  650.             if (j < qsv->nb_ext_buffers)

  651.                 continue;

  652. 

  653.             q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];

  654.         }

  655.     } else {

  656.         q->param.ExtParam    = q->extparam_internal;

  657.         q->param.NumExtParam = q->nb_extparam_internal;

  658.     }

  659. 

  660.     ret = MFXVideoENCODE_Init(q->session, &q->param);

  661.     if (ret < 0) {

  662.         av_log(avctx, AV_LOG_ERROR, "Error initializing the encoder\n");

  663.         return ff_qsv_error(ret);

  664.     }

  665. 

  666.     ret = qsv_retrieve_enc_params(avctx, q);

  667.     if (ret < 0) {

  668.         av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");

  669.         return ret;

  670.     }

  671. 

  672.     q->avctx = avctx;

  673. 

  674.     return 0;

  675. }

  676. 

  677. static void clear_unused_frames(QSVEncContext *q)

  678. {

  679.     QSVFrame *cur = q->work_frames;

  680.     while (cur) {

  681.         if (cur->surface && !cur->surface->Data.Locked) {

  682.             cur->surface = NULL;

  683.             av_frame_unref(cur->frame);

  684.         }

  685.         cur = cur->next;

  686.     }

  687. }

  688. 

  689. static int get_free_frame(QSVEncContext *q, QSVFrame **f)

  690. {

  691.     QSVFrame *frame, **last;

  692. 

  693.     clear_unused_frames(q);

  694. 

  695.     frame = q->work_frames;

  696.     last  = &q->work_frames;

  697.     while (frame) {

  698.         if (!frame->surface) {

  699.             *f = frame;

  700.             return 0;

  701.         }

  702. 

  703.         last  = &frame->next;

  704.         frame = frame->next;

  705.     }

  706. 

  707.     frame = av_mallocz(sizeof(*frame));

  708.     if (!frame)

  709.         return AVERROR(ENOMEM);

  710.     frame->frame = av_frame_alloc();

  711.     if (!frame->frame) {

  712.         av_freep(&frame);

  713.         return AVERROR(ENOMEM);

  714.     }

  715.     *last = frame;

  716. 

  717.     *f = frame;

  718. 

  719.     return 0;

  720. }

  721. 

  722. static int submit_frame(QSVEncContext *q, const AVFrame *frame,

  723.                         mfxFrameSurface1 **surface)

  724. {

  725.     QSVFrame *qf;

  726.     int ret;

  727. 

  728.     ret = get_free_frame(q, &qf);

  729.     if (ret < 0)

  730.         return ret;

  731. 

  732.     if (frame->format == AV_PIX_FMT_QSV) {

  733.         ret = av_frame_ref(qf->frame, frame);

  734.         if (ret < 0)

  735.             return ret;

  736. 

  737.         qf->surface = (mfxFrameSurface1*)qf->frame->data[3];

  738.     } else {

  739.         /* make a copy if the input is not padded as libmfx requires */

  740.         if (frame->height & 31 || frame->linesize[0] & (q->width_align - 1)) {

  741.             qf->frame->height = FFALIGN(frame->height, 32);

  742.             qf->frame->width  = FFALIGN(frame->width, q->width_align);

  743. 

  744.             ret = ff_get_buffer(q->avctx, qf->frame, AV_GET_BUFFER_FLAG_REF);

  745.             if (ret < 0)

  746.                 return ret;

  747. 

  748.             qf->frame->height = frame->height;

  749.             qf->frame->width  = frame->width;

  750.             ret = av_frame_copy(qf->frame, frame);

  751.             if (ret < 0) {

  752.                 av_frame_unref(qf->frame);

  753.                 return ret;

  754.             }

  755.         } else {

  756.             ret = av_frame_ref(qf->frame, frame);

  757.             if (ret < 0)

  758.                 return ret;

  759.         }

  760. 

  761.         qf->surface_internal.Info = q->param.mfx.FrameInfo;

  762. 

  763.         qf->surface_internal.Info.PicStruct =

  764.             !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :

  765.             frame->top_field_first   ? MFX_PICSTRUCT_FIELD_TFF :

  766.                                        MFX_PICSTRUCT_FIELD_BFF;

  767.         if (frame->repeat_pict == 1)

  768.             qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;

  769.         else if (frame->repeat_pict == 2)

  770.             qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;

  771.         else if (frame->repeat_pict == 4)

  772.             qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;

  773. 

  774.         qf->surface_internal.Data.PitchLow  = qf->frame->linesize[0];

  775.         qf->surface_internal.Data.Y         = qf->frame->data[0];

  776.         qf->surface_internal.Data.UV        = qf->frame->data[1];

  777. 

  778.         qf->surface = &qf->surface_internal;

  779.     }

  780. 

  781.     qf->surface->Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});

  782. 

  783.     *surface = qf->surface;

  784. 

  785.     return 0;

  786. }

  787. 

  788. static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)

  789. {

  790.     if (q->param.mfx.CodecId == MFX_CODEC_AVC) {

  791.         if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||

  792.             q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||

  793.             q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)

  794.             av_log(avctx, AV_LOG_WARNING,

  795.                    "Interlaced coding is supported"

  796.                    " at Main/High Profile Level 2.1-4.1\n");

  797.     }

  798. }

  799. 

  800. int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q,

  801.                   AVPacket *pkt, const AVFrame *frame, int *got_packet)

  802. {

  803.     AVPacket new_pkt = { 0 };

  804.     mfxBitstream *bs;

  805. 

  806.     mfxFrameSurface1 *surf = NULL;

  807.     mfxSyncPoint sync      = NULL;

  808.     int ret;

  809. 

  810.     if (frame) {

  811.         ret = submit_frame(q, frame, &surf);

  812.         if (ret < 0) {

  813.             av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");

  814.             return ret;

  815.         }

  816.     }

  817. 

  818.     ret = av_new_packet(&new_pkt, q->packet_size);

  819.     if (ret < 0) {

  820.         av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");

  821.         return ret;

  822.     }

  823. 

  824.     bs = av_mallocz(sizeof(*bs));

  825.     if (!bs) {

  826.         av_packet_unref(&new_pkt);

  827.         return AVERROR(ENOMEM);

  828.     }

  829.     bs->Data      = new_pkt.data;

  830.     bs->MaxLength = new_pkt.size;

  831. 

  832.     do {

  833.         ret = MFXVideoENCODE_EncodeFrameAsync(q->session, NULL, surf, bs, &sync);

  834.         if (ret == MFX_WRN_DEVICE_BUSY)

  835.             av_usleep(1);

  836.     } while (ret > 0);

  837. 

  838.     if (ret < 0) {

  839.         av_packet_unref(&new_pkt);

  840.         av_freep(&bs);

  841.         return (ret == MFX_ERR_MORE_DATA) ? 0 : ff_qsv_error(ret);

  842.     }

  843. 

  844.     if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM && frame->interlaced_frame)

  845.         print_interlace_msg(avctx, q);

  846. 

  847.     if (sync) {

  848.         av_fifo_generic_write(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);

  849.         av_fifo_generic_write(q->async_fifo, &sync,    sizeof(sync),    NULL);

  850.         av_fifo_generic_write(q->async_fifo, &bs,      sizeof(bs),    NULL);

  851.     } else {

  852.         av_packet_unref(&new_pkt);

  853.         av_freep(&bs);

  854.     }

  855. 

  856.     if (!av_fifo_space(q->async_fifo) ||

  857.         (!frame && av_fifo_size(q->async_fifo))) {

  858.         av_fifo_generic_read(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);

  859.         av_fifo_generic_read(q->async_fifo, &sync,    sizeof(sync),    NULL);

  860.         av_fifo_generic_read(q->async_fifo, &bs,      sizeof(bs),      NULL);

  861. 

  862.         MFXVideoCORE_SyncOperation(q->session, sync, 60000);

  863. 

  864.         new_pkt.dts  = av_rescale_q(bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);

  865.         new_pkt.pts  = av_rescale_q(bs->TimeStamp,       (AVRational){1, 90000}, avctx->time_base);

  866.         new_pkt.size = bs->DataLength;

  867. 

  868.         if (bs->FrameType & MFX_FRAMETYPE_IDR ||

  869.             bs->FrameType & MFX_FRAMETYPE_xIDR)

  870.             new_pkt.flags |= AV_PKT_FLAG_KEY;

  871. 

  872. #if FF_API_CODED_FRAME

  873. FF_DISABLE_DEPRECATION_WARNINGS

  874.         if (bs->FrameType & MFX_FRAMETYPE_I || bs->FrameType & MFX_FRAMETYPE_xI)

  875.             avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;

  876.         else if (bs->FrameType & MFX_FRAMETYPE_P || bs->FrameType & MFX_FRAMETYPE_xP)

  877.             avctx->coded_frame->pict_type = AV_PICTURE_TYPE_P;

  878.         else if (bs->FrameType & MFX_FRAMETYPE_B || bs->FrameType & MFX_FRAMETYPE_xB)

  879.             avctx->coded_frame->pict_type = AV_PICTURE_TYPE_B;

  880. FF_ENABLE_DEPRECATION_WARNINGS

  881. #endif

  882. 

  883.         av_freep(&bs);

  884. 

  885.         if (pkt->data) {

  886.             if (pkt->size < new_pkt.size) {

  887.                 av_log(avctx, AV_LOG_ERROR, "Submitted buffer not large enough: %d < %d\n",

  888.                        pkt->size, new_pkt.size);

  889.                 av_packet_unref(&new_pkt);

  890.                 return AVERROR(EINVAL);

  891.             }

  892. 

  893.             memcpy(pkt->data, new_pkt.data, new_pkt.size);

  894.             pkt->size = new_pkt.size;

  895. 

  896.             ret = av_packet_copy_props(pkt, &new_pkt);

  897.             av_packet_unref(&new_pkt);

  898.             if (ret < 0)

  899.                 return ret;

  900.         } else

  901.             *pkt = new_pkt;

  902. 

  903.         *got_packet = 1;

  904.     }

  905. 

  906.     return 0;

  907. }

  908. 

  909. int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)

  910. {

  911.     QSVFrame *cur;

  912. 

  913.     if (q->session)

  914.         MFXVideoENCODE_Close(q->session);

  915.     if (q->internal_session)

  916.         MFXClose(q->internal_session);

  917.     q->session          = NULL;

  918.     q->internal_session = NULL;

  919. 

  920.     cur = q->work_frames;

  921.     while (cur) {

  922.         q->work_frames = cur->next;

  923.         av_frame_free(&cur->frame);

  924.         av_freep(&cur);

  925.         cur = q->work_frames;

  926.     }

  927. 

  928.     while (q->async_fifo && av_fifo_size(q->async_fifo)) {

  929.         AVPacket pkt;

  930.         mfxSyncPoint sync;

  931.         mfxBitstream *bs;

  932. 

  933.         av_fifo_generic_read(q->async_fifo, &pkt,  sizeof(pkt),  NULL);

  934.         av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);

  935.         av_fifo_generic_read(q->async_fifo, &bs,   sizeof(bs),   NULL);

  936. 

  937.         av_freep(&bs);

  938.         av_packet_unref(&pkt);

  939.     }

  940.     av_fifo_free(q->async_fifo);

  941.     q->async_fifo = NULL;

  942. 

  943.     av_freep(&q->opaque_surfaces);

  944.     av_buffer_unref(&q->opaque_alloc_buf);

  945. 

  946.     av_freep(&q->extparam);

  947. 

  948.     return 0;

  949. }