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.
99882 Commits
32 Branches
283MB
Tree: cd322794ee
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cd322794ee'
${ noResults }
FFmpeg/libavcodec/qsvenc.c

1664 lines
58KB
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 FFmpeg.

  8.  *

  9.  * FFmpeg 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.  * FFmpeg 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 FFmpeg; 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/hwcontext.h"

  30. #include "libavutil/hwcontext_qsv.h"

  31. #include "libavutil/mem.h"

  32. #include "libavutil/log.h"

  33. #include "libavutil/time.h"

  34. #include "libavutil/imgutils.h"

  35. #include "libavcodec/bytestream.h"

  36. 

  37. #include "avcodec.h"

  38. #include "internal.h"

  39. #include "packet_internal.h"

  40. #include "qsv.h"

  41. #include "qsv_internal.h"

  42. #include "qsvenc.h"

  43. 

  44. static const struct {

  45.     mfxU16 profile;

  46.     const char *name;

  47. } profile_names[] = {

  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"              },

  54. #endif

  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"      },

  59. #endif

  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"                  },

  71. #endif

  72. };

  73. 

  74. static const char *print_profile(mfxU16 profile)

  75. {

  76.     int i;

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

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

  79.             return profile_names[i].name;

  80.     return "unknown";

  81. }

  82. 

  83. static const struct {

  84.     mfxU16      rc_mode;

  85.     const char *name;

  86. } rc_names[] = {

  87.     { MFX_RATECONTROL_CBR,     "CBR" },

  88.     { MFX_RATECONTROL_VBR,     "VBR" },

  89.     { MFX_RATECONTROL_CQP,     "CQP" },

  90. #if QSV_HAVE_AVBR

  91.     { MFX_RATECONTROL_AVBR,    "AVBR" },

  92. #endif

  93. #if QSV_HAVE_LA

  94.     { MFX_RATECONTROL_LA,      "LA" },

  95. #endif

  96. #if QSV_HAVE_ICQ

  97.     { MFX_RATECONTROL_ICQ,     "ICQ" },

  98.     { MFX_RATECONTROL_LA_ICQ,  "LA_ICQ" },

  99. #endif

  100. #if QSV_HAVE_VCM

  101.     { MFX_RATECONTROL_VCM,     "VCM" },

  102. #endif

  103. #if QSV_VERSION_ATLEAST(1, 10)

  104.     { MFX_RATECONTROL_LA_EXT,  "LA_EXT" },

  105. #endif

  106. #if QSV_HAVE_LA_HRD

  107.     { MFX_RATECONTROL_LA_HRD,  "LA_HRD" },

  108. #endif

  109. #if QSV_HAVE_QVBR

  110.     { MFX_RATECONTROL_QVBR,    "QVBR" },

  111. #endif

  112. };

  113. 

  114. static const char *print_ratecontrol(mfxU16 rc_mode)

  115. {

  116.     int i;

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

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

  119.             return rc_names[i].name;

  120.     return "unknown";

  121. }

  122. 

  123. static const char *print_threestate(mfxU16 val)

  124. {

  125.     if (val == MFX_CODINGOPTION_ON)

  126.         return "ON";

  127.     else if (val == MFX_CODINGOPTION_OFF)

  128.         return "OFF";

  129.     return "unknown";

  130. }

  131. 

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

  133.                              mfxExtBuffer **coding_opts)

  134. {

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

  136. 

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

  138. #if QSV_HAVE_CO2

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

  140. #endif

  141. #if QSV_HAVE_CO3

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

  143. #endif

  144. #if QSV_HAVE_EXT_HEVC_TILES

  145.     mfxExtHEVCTiles *exthevctiles = (mfxExtHEVCTiles *)coding_opts[3 + QSV_HAVE_CO_VPS];

  146. #endif

  147. 

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

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

  150. 

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

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

  153.     if (info->GopOptFlag & MFX_GOP_CLOSED)

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

  155.     if (info->GopOptFlag & MFX_GOP_STRICT)

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

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

  158. 

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

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

  161. 

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

  163.         info->RateControlMethod == MFX_RATECONTROL_VBR

  164. #if QSV_HAVE_VCM

  165.         || info->RateControlMethod == MFX_RATECONTROL_VCM

  166. #endif

  167.         ) {

  168.         av_log(avctx, AV_LOG_VERBOSE,

  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) {

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

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

  174.     }

  175. #if QSV_HAVE_AVBR

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

  177.         av_log(avctx, AV_LOG_VERBOSE,

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

  179.                info->TargetKbps, info->Accuracy, info->Convergence, info->BRCParamMultiplier);

  180.     }

  181. #endif

  182. #if QSV_HAVE_LA

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

  184. #if QSV_HAVE_LA_HRD

  185.              || info->RateControlMethod == MFX_RATECONTROL_LA_HRD

  186. #endif

  187.              ) {

  188.         av_log(avctx, AV_LOG_VERBOSE,

  189.                "TargetKbps: %"PRIu16"; LookAheadDepth: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",

  190.                info->TargetKbps, co2->LookAheadDepth, info->BRCParamMultiplier);

  191.     }

  192. #endif

  193. #if QSV_HAVE_ICQ

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

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

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

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

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

  199.     }

  200. #endif

  201. #if QSV_HAVE_QVBR

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

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

  204.                co3->QVBRQuality);

  205.     }

  206. #endif

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

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

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

  210.            print_threestate(co->RateDistortionOpt));

  211. 

  212. #if QSV_HAVE_EXT_HEVC_TILES

  213.     if (avctx->codec_id == AV_CODEC_ID_HEVC)

  214.         av_log(avctx, AV_LOG_VERBOSE, "NumTileColumns: %"PRIu16"; NumTileRows: %"PRIu16"\n",

  215.                exthevctiles->NumTileColumns, exthevctiles->NumTileRows);

  216. #endif

  217. 

  218. #if QSV_HAVE_CO2

  219.     av_log(avctx, AV_LOG_VERBOSE,

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

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

  222. 

  223.     av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %d; ", co2->MaxFrameSize);

  224. #if QSV_HAVE_MAX_SLICE_SIZE

  225.     av_log(avctx, AV_LOG_VERBOSE, "MaxSliceSize: %d; ", co2->MaxSliceSize);

  226. #endif

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

  228. 

  229.     av_log(avctx, AV_LOG_VERBOSE,

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

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

  232.            print_threestate(co2->ExtBRC));

  233. 

  234. #if QSV_HAVE_TRELLIS

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

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

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

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

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

  240.     } else {

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

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

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

  244.     }

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

  246. #endif

  247. 

  248. #if QSV_HAVE_VDENC

  249.     av_log(avctx, AV_LOG_VERBOSE, "VDENC: %s\n", print_threestate(info->LowPower));

  250. #endif

  251. 

  252. #if QSV_VERSION_ATLEAST(1, 8)

  253.     av_log(avctx, AV_LOG_VERBOSE,

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

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

  256.     switch (co2->LookAheadDS) {

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

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

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

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

  261.     }

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

  263. 

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

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

  266.     switch (co2->BRefType) {

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

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

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

  270.     }

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

  272. #endif

  273. 

  274. #if QSV_VERSION_ATLEAST(1, 9)

  275.     av_log(avctx, AV_LOG_VERBOSE,

  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);

  278. #endif

  279. #endif

  280. 

  281. #if QSV_HAVE_GPB

  282.     if (avctx->codec_id == AV_CODEC_ID_HEVC)

  283.         av_log(avctx, AV_LOG_VERBOSE,"GPB: %s\n", print_threestate(co3->GPB));

  284. #endif

  285. 

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

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

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

  289.         av_log(avctx, AV_LOG_VERBOSE,

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

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

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

  293.     }

  294. 

  295.     av_log(avctx, AV_LOG_VERBOSE, "FrameRateExtD: %"PRIu32"; FrameRateExtN: %"PRIu32" \n",

  296.            info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);

  297. 

  298. }

  299. 

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

  301. {

  302.     const char *rc_desc;

  303.     mfxU16      rc_mode;

  304. 

  305.     int want_la     = q->look_ahead;

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

  307.     int want_vcm    = q->vcm;

  308. 

  309.     if (want_la && !QSV_HAVE_LA) {

  310.         av_log(avctx, AV_LOG_ERROR,

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

  312.         return AVERROR(ENOSYS);

  313.     }

  314.     if (want_vcm && !QSV_HAVE_VCM) {

  315.         av_log(avctx, AV_LOG_ERROR,

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

  317.         return AVERROR(ENOSYS);

  318.     }

  319. 

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

  321.         av_log(avctx, AV_LOG_ERROR,

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

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

  324.         return AVERROR(EINVAL);

  325.     }

  326. 

  327.     if (!want_qscale && avctx->global_quality > 0 && !QSV_HAVE_ICQ){

  328.         av_log(avctx, AV_LOG_ERROR,

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

  330.         return AVERROR(ENOSYS);

  331.     }

  332. 

  333.     if (want_qscale) {

  334.         rc_mode = MFX_RATECONTROL_CQP;

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

  336.     }

  337. #if QSV_HAVE_VCM

  338.     else if (want_vcm) {

  339.         rc_mode = MFX_RATECONTROL_VCM;

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

  341.     }

  342. #endif

  343. #if QSV_HAVE_LA

  344.     else if (want_la) {

  345.         rc_mode = MFX_RATECONTROL_LA;

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

  347. 

  348. #if QSV_HAVE_ICQ

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

  350.             rc_mode = MFX_RATECONTROL_LA_ICQ;

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

  352.         }

  353. #endif

  354.     }

  355. #endif

  356. #if QSV_HAVE_ICQ

  357.     else if (avctx->global_quality > 0 && !avctx->rc_max_rate) {

  358.         rc_mode = MFX_RATECONTROL_ICQ;

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

  360.     }

  361. #endif

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

  363.         rc_mode = MFX_RATECONTROL_CBR;

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

  365.     }

  366. #if QSV_HAVE_AVBR

  367.     else if (!avctx->rc_max_rate) {

  368.         rc_mode = MFX_RATECONTROL_AVBR;

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

  370.     }

  371. #endif

  372. #if QSV_HAVE_QVBR

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

  374.         rc_mode = MFX_RATECONTROL_QVBR;

  375.         rc_desc = "constant quality with VBR algorithm (QVBR)";

  376.     }

  377. #endif

  378.     else {

  379.         rc_mode = MFX_RATECONTROL_VBR;

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

  381.     }

  382. 

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

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

  385. 

  386.     return 0;

  387. }

  388. 

  389. static int check_enc_param(AVCodecContext *avctx, QSVEncContext *q)

  390. {

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

  392.     mfxStatus ret;

  393. 

  394. #define UNMATCH(x) (param_out.mfx.x != q->param.mfx.x)

  395. 

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

  397. 

  398.     if (ret < 0) {

  399.         if (UNMATCH(CodecId))

  400.             av_log(avctx, AV_LOG_ERROR, "Current codec type is unsupported\n");

  401.         if (UNMATCH(CodecProfile))

  402.             av_log(avctx, AV_LOG_ERROR, "Current profile is unsupported\n");

  403.         if (UNMATCH(RateControlMethod))

  404.             av_log(avctx, AV_LOG_ERROR, "Selected ratecontrol mode is unsupported\n");

  405.         if (UNMATCH(LowPower))

  406.               av_log(avctx, AV_LOG_ERROR, "Low power mode is unsupported\n");

  407.         if (UNMATCH(FrameInfo.FrameRateExtN) || UNMATCH(FrameInfo.FrameRateExtD))

  408.               av_log(avctx, AV_LOG_ERROR, "Current frame rate is unsupported\n");

  409.         if (UNMATCH(FrameInfo.PicStruct))

  410.               av_log(avctx, AV_LOG_ERROR, "Current picture structure is unsupported\n");

  411.         if (UNMATCH(FrameInfo.Width) || UNMATCH(FrameInfo.Height))

  412.               av_log(avctx, AV_LOG_ERROR, "Current resolution is unsupported\n");

  413.         if (UNMATCH(FrameInfo.FourCC))

  414.               av_log(avctx, AV_LOG_ERROR, "Current pixel format is unsupported\n");

  415.         return 0;

  416.     }

  417.     return 1;

  418. }

  419. 

  420. static int init_video_param_jpeg(AVCodecContext *avctx, QSVEncContext *q)

  421. {

  422.     enum AVPixelFormat sw_format = avctx->pix_fmt == AV_PIX_FMT_QSV ?

  423.                                    avctx->sw_pix_fmt : avctx->pix_fmt;

  424.     const AVPixFmtDescriptor *desc;

  425.     int ret;

  426. 

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

  428.     if (ret < 0)

  429.         return AVERROR_BUG;

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

  431. 

  432.     if (avctx->level > 0)

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

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

  435. 

  436.     desc = av_pix_fmt_desc_get(sw_format);

  437.     if (!desc)

  438.         return AVERROR_BUG;

  439. 

  440.     ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC);

  441. 

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

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

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

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

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

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

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

  449.     q->param.mfx.FrameInfo.BitDepthLuma   = desc->comp[0].depth;

  450.     q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;

  451.     q->param.mfx.FrameInfo.Shift          = desc->comp[0].depth > 8;

  452. 

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

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

  455. 

  456.     if (avctx->hw_frames_ctx) {

  457.         AVHWFramesContext *frames_ctx    = (AVHWFramesContext *)avctx->hw_frames_ctx->data;

  458.         AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;

  459.         q->param.mfx.FrameInfo.Width  = frames_hwctx->surfaces[0].Info.Width;

  460.         q->param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;

  461.     }

  462. 

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

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

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

  466.     } else {

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

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

  469.     }

  470. 

  471.     q->param.mfx.Interleaved          = 1;

  472.     q->param.mfx.Quality              = av_clip(avctx->global_quality, 1, 100);

  473.     q->param.mfx.RestartInterval      = 0;

  474. 

  475.     q->width_align = 16;

  476.     q->height_align = 16;

  477. 

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

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

  480. 

  481.     return 0;

  482. }

  483. 

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

  485. {

  486.     enum AVPixelFormat sw_format = avctx->pix_fmt == AV_PIX_FMT_QSV ?

  487.                                    avctx->sw_pix_fmt : avctx->pix_fmt;

  488.     const AVPixFmtDescriptor *desc;

  489.     float quant;

  490.     int target_bitrate_kbps, max_bitrate_kbps, brc_param_multiplier;

  491.     int buffer_size_in_kilobytes, initial_delay_in_kilobytes;

  492.     int ret;

  493. 

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

  495.     if (ret < 0)

  496.         return AVERROR_BUG;

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

  498. 

  499.     if (avctx->level > 0)

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

  501. 

  502.     if (avctx->compression_level == FF_COMPRESSION_DEFAULT) {

  503.         avctx->compression_level = q->preset;

  504.     } else if (avctx->compression_level >= 0) {

  505.         if (avctx->compression_level > MFX_TARGETUSAGE_BEST_SPEED) {

  506.             av_log(avctx, AV_LOG_WARNING, "Invalid compression level: "

  507.                     "valid range is 0-%d, using %d instead\n",

  508.                     MFX_TARGETUSAGE_BEST_SPEED, MFX_TARGETUSAGE_BEST_SPEED);

  509.             avctx->compression_level = MFX_TARGETUSAGE_BEST_SPEED;

  510.         }

  511.     }

  512. 

  513.     if (q->low_power) {

  514. #if QSV_HAVE_VDENC

  515.         q->param.mfx.LowPower = MFX_CODINGOPTION_ON;

  516. #else

  517.         av_log(avctx, AV_LOG_WARNING, "The low_power option is "

  518.                             "not supported with this MSDK version.\n");

  519.         q->low_power = 0;

  520.         q->param.mfx.LowPower = MFX_CODINGOPTION_OFF;

  521. #endif

  522.     } else

  523.         q->param.mfx.LowPower = MFX_CODINGOPTION_OFF;

  524. 

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

  526.     q->param.mfx.TargetUsage        = avctx->compression_level;

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

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

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

  530.                                       MFX_GOP_CLOSED : 0;

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

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

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

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

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

  536. 

  537.     desc = av_pix_fmt_desc_get(sw_format);

  538.     if (!desc)

  539.         return AVERROR_BUG;

  540. 

  541.     ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC);

  542. 

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

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

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

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

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

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

  549.     q->param.mfx.FrameInfo.ChromaFormat   = MFX_CHROMAFORMAT_YUV420 +

  550.                                             !desc->log2_chroma_w + !desc->log2_chroma_h;

  551.     q->param.mfx.FrameInfo.BitDepthLuma   = desc->comp[0].depth;

  552.     q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;

  553.     q->param.mfx.FrameInfo.Shift          = desc->comp[0].depth > 8;

  554. 

  555.     // If the minor version is greater than or equal to 19,

  556.     // then can use the same alignment settings as H.264 for HEVC

  557.     q->width_align = (avctx->codec_id != AV_CODEC_ID_HEVC ||

  558.                       QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 19)) ? 16 : 32;

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

  560. 

  561.     if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {

  562.         // it is important that PicStruct be setup correctly from the

  563.         // start--otherwise, encoding doesn't work and results in a bunch

  564.         // of incompatible video parameter errors

  565.         q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_FIELD_TFF;

  566.         // height alignment always must be 32 for interlaced video

  567.         q->height_align = 32;

  568.     } else {

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

  570.         // for progressive video, the height should be aligned to 16 for

  571.         // H.264.  For HEVC, depending on the version of MFX, it should be

  572.         // either 32 or 16.  The lower number is better if possible.

  573.         q->height_align = avctx->codec_id == AV_CODEC_ID_HEVC ? 32 : 16;

  574.     }

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

  576. 

  577.     if (avctx->hw_frames_ctx) {

  578.         AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;

  579.         AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;

  580.         q->param.mfx.FrameInfo.Width  = frames_hwctx->surfaces[0].Info.Width;

  581.         q->param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;

  582.     }

  583. 

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

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

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

  587.     } else {

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

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

  590.     }

  591. 

  592.     ret = select_rc_mode(avctx, q);

  593.     if (ret < 0)

  594.         return ret;

  595. 

  596.     //libmfx BRC parameters are 16 bits thus maybe overflow, then BRCParamMultiplier is needed

  597.     buffer_size_in_kilobytes   = avctx->rc_buffer_size / 8000;

  598.     initial_delay_in_kilobytes = avctx->rc_initial_buffer_occupancy / 8000;

  599.     target_bitrate_kbps        = avctx->bit_rate / 1000;

  600.     max_bitrate_kbps           = avctx->rc_max_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;

  603. 

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

  605.     case MFX_RATECONTROL_CBR:

  606.     case MFX_RATECONTROL_VBR:

  607. #if QSV_HAVE_VCM

  608.     case MFX_RATECONTROL_VCM:

  609. #endif

  610. #if QSV_HAVE_QVBR

  611.     case MFX_RATECONTROL_QVBR:

  612. #endif

  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;

  618. #if QSV_HAVE_QVBR

  619.         if (q->param.mfx.RateControlMethod == MFX_RATECONTROL_QVBR)

  620.             q->extco3.QVBRQuality = av_clip(avctx->global_quality, 0, 51);

  621. #endif

  622.         break;

  623.     case MFX_RATECONTROL_CQP:

  624.         quant = avctx->global_quality / FF_QP2LAMBDA;

  625. 

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

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

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

  629. 

  630.         break;

  631. #if QSV_HAVE_AVBR

  632.     case MFX_RATECONTROL_AVBR:

  633.         q->param.mfx.TargetKbps  = target_bitrate_kbps / brc_param_multiplier;

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

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

  636.         q->param.mfx.BRCParamMultiplier = brc_param_multiplier;

  637.         break;

  638. #endif

  639. #if QSV_HAVE_LA

  640.     case MFX_RATECONTROL_LA:

  641.         q->param.mfx.TargetKbps  = target_bitrate_kbps / brc_param_multiplier;

  642.         q->extco2.LookAheadDepth = q->look_ahead_depth;

  643.         q->param.mfx.BRCParamMultiplier = brc_param_multiplier;

  644.         break;

  645. #if QSV_HAVE_ICQ

  646.     case MFX_RATECONTROL_LA_ICQ:

  647.         q->extco2.LookAheadDepth = q->look_ahead_depth;

  648.     case MFX_RATECONTROL_ICQ:

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

  650.         break;

  651. #endif

  652. #endif

  653.     }

  654. 

  655.     // The HEVC encoder plugin currently fails with some old libmfx version if coding options

  656.     // are provided. Can't find the extract libmfx version which fixed it, just enable it from

  657.     // V1.28 in order to keep compatibility security.

  658.     if (((avctx->codec_id != AV_CODEC_ID_HEVC) || QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 28))

  659.         && (avctx->codec_id != AV_CODEC_ID_VP9)) {

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

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

  662. 

  663.         q->extco.PicTimingSEI         = q->pic_timing_sei ?

  664.                                         MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;

  665. 

  666.         if (q->rdo >= 0)

  667.             q->extco.RateDistortionOpt = q->rdo > 0 ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;

  668. 

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

  670. #if FF_API_CODER_TYPE

  671. FF_DISABLE_DEPRECATION_WARNINGS

  672.             if (avctx->coder_type >= 0)

  673.                 q->cavlc = avctx->coder_type == FF_CODER_TYPE_VLC;

  674. FF_ENABLE_DEPRECATION_WARNINGS

  675. #endif

  676.             q->extco.CAVLC = q->cavlc ? MFX_CODINGOPTION_ON

  677.                                       : MFX_CODINGOPTION_UNKNOWN;

  678. 

  679.             if (avctx->strict_std_compliance != FF_COMPLIANCE_NORMAL)

  680.                 q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?

  681.                                              MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;

  682. 

  683.             if (q->single_sei_nal_unit >= 0)

  684.                 q->extco.SingleSeiNalUnit = q->single_sei_nal_unit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;

  685.             if (q->recovery_point_sei >= 0)

  686.                 q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;

  687.             q->extco.MaxDecFrameBuffering = q->max_dec_frame_buffering;

  688.             q->extco.AUDelimiter          = q->aud ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;

  689.         }

  690. 

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

  692. 

  693. #if QSV_HAVE_CO2

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

  695.             if (q->int_ref_type >= 0)

  696.                 q->extco2.IntRefType = q->int_ref_type;

  697.             if (q->int_ref_cycle_size >= 0)

  698.                 q->extco2.IntRefCycleSize = q->int_ref_cycle_size;

  699.             if (q->int_ref_qp_delta != INT16_MIN)

  700.                 q->extco2.IntRefQPDelta = q->int_ref_qp_delta;

  701. 

  702.             if (q->bitrate_limit >= 0)

  703.                 q->extco2.BitrateLimit = q->bitrate_limit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;

  704.             if (q->mbbrc >= 0)

  705.                 q->extco2.MBBRC = q->mbbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;

  706. 

  707.             if (q->max_frame_size >= 0)

  708.                 q->extco2.MaxFrameSize = q->max_frame_size;

  709. #if QSV_HAVE_MAX_SLICE_SIZE

  710.             if (q->max_slice_size >= 0)

  711.                 q->extco2.MaxSliceSize = q->max_slice_size;

  712. #endif

  713. 

  714. #if QSV_HAVE_TRELLIS

  715.             if (avctx->trellis >= 0)

  716.                 q->extco2.Trellis = (avctx->trellis == 0) ? MFX_TRELLIS_OFF : (MFX_TRELLIS_I | MFX_TRELLIS_P | MFX_TRELLIS_B);

  717.             else

  718.                 q->extco2.Trellis = MFX_TRELLIS_UNKNOWN;

  719. #endif

  720. 

  721. #if QSV_VERSION_ATLEAST(1, 8)

  722.             q->extco2.LookAheadDS = q->look_ahead_downsampling;

  723.             q->extco2.RepeatPPS   = q->repeat_pps ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;

  724. 

  725. #if FF_API_PRIVATE_OPT

  726. FF_DISABLE_DEPRECATION_WARNINGS

  727.             if (avctx->b_frame_strategy >= 0)

  728.                 q->b_strategy = avctx->b_frame_strategy;

  729. FF_ENABLE_DEPRECATION_WARNINGS

  730. #endif

  731.             if (q->b_strategy >= 0)

  732.                 q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;

  733.             if (q->adaptive_i >= 0)

  734.                 q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;

  735.             if (q->adaptive_b >= 0)

  736.                 q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;

  737. #endif

  738.         }

  739. 

  740.         if (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_HEVC) {

  741.             if (q->extbrc >= 0)

  742.                 q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;

  743. 

  744. #if QSV_VERSION_ATLEAST(1, 9)

  745.             if (avctx->qmin >= 0 && avctx->qmax >= 0 && avctx->qmin > avctx->qmax) {

  746.                 av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are set but invalid, please make sure min <= max\n");

  747.                 return AVERROR(EINVAL);

  748.             }

  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;

  752.             }

  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;

  756.             }

  757. #endif

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

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

  760. 

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

  762.         }

  763. #endif

  764. 

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

  766. #if QSV_HAVE_MF

  767.             if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 25)) {

  768.                 q->extmfp.Header.BufferId     = MFX_EXTBUFF_MULTI_FRAME_PARAM;

  769.                 q->extmfp.Header.BufferSz     = sizeof(q->extmfp);

  770. 

  771.                 q->extmfp.MFMode = q->mfmode;

  772.                 av_log(avctx,AV_LOG_VERBOSE,"MFMode:%d\n", q->extmfp.MFMode);

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

  774.             }

  775. #endif

  776.         }

  777. #if QSV_HAVE_CO3

  778.         q->extco3.Header.BufferId      = MFX_EXTBUFF_CODING_OPTION3;

  779.         q->extco3.Header.BufferSz      = sizeof(q->extco3);

  780. #if QSV_HAVE_GPB

  781.         if (avctx->codec_id == AV_CODEC_ID_HEVC)

  782.             q->extco3.GPB              = q->gpb ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;

  783. #endif

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

  785. #endif

  786.     }

  787. 

  788. #if QSV_HAVE_EXT_VP9_PARAM

  789.     if (avctx->codec_id == AV_CODEC_ID_VP9) {

  790.         q->extvp9param.Header.BufferId = MFX_EXTBUFF_VP9_PARAM;

  791.         q->extvp9param.Header.BufferSz = sizeof(q->extvp9param);

  792.         q->extvp9param.WriteIVFHeaders = MFX_CODINGOPTION_OFF;

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

  794.     }

  795. #endif

  796. 

  797. #if QSV_HAVE_EXT_HEVC_TILES

  798.     if (avctx->codec_id == AV_CODEC_ID_HEVC) {

  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;

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

  804.     }

  805. #endif

  806. 

  807.     if (!check_enc_param(avctx,q)) {

  808.         av_log(avctx, AV_LOG_ERROR,

  809.                "some encoding parameters are not supported by the QSV "

  810.                "runtime. Please double check the input parameters.\n");

  811.         return AVERROR(ENOSYS);

  812.     }

  813. 

  814.     return 0;

  815. }

  816. 

  817. static int qsv_retrieve_enc_jpeg_params(AVCodecContext *avctx, QSVEncContext *q)

  818. {

  819.     int ret = 0;

  820. 

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

  822.     if (ret < 0)

  823.         return ff_qsv_print_error(avctx, ret,

  824.                                   "Error calling GetVideoParam");

  825. 

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

  827. 

  828.     // for qsv mjpeg the return value maybe 0 so alloc the buffer

  829.     if (q->packet_size == 0)

  830.         q->packet_size = q->param.mfx.FrameInfo.Height * q->param.mfx.FrameInfo.Width * 4;

  831. 

  832.     return 0;

  833. }

  834. 

  835. static int qsv_retrieve_enc_vp9_params(AVCodecContext *avctx, QSVEncContext *q)

  836. {

  837.     int ret = 0;

  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),

  842.     };

  843. #endif

  844. 

  845. #if QSV_HAVE_CO2

  846.     mfxExtCodingOption2 co2 = {

  847.         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,

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

  849.     };

  850. #endif

  851. 

  852. #if QSV_HAVE_CO3

  853.     mfxExtCodingOption3 co3 = {

  854.         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,

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

  856.     };

  857. #endif

  858. 

  859.     mfxExtBuffer *ext_buffers[] = {

  860. #if QSV_HAVE_EXT_VP9_PARAM

  861.         (mfxExtBuffer*)&vp9_extend_buf,

  862. #endif

  863. #if QSV_HAVE_CO2

  864.         (mfxExtBuffer*)&co2,

  865. #endif

  866. #if QSV_HAVE_CO3

  867.         (mfxExtBuffer*)&co3,

  868. #endif

  869.     };

  870. 

  871.     q->param.ExtParam    = ext_buffers;

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

  873. 

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

  875.     if (ret < 0)

  876.         return ff_qsv_print_error(avctx, ret,

  877.                                   "Error calling GetVideoParam");

  878. 

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

  880. 

  881.     return 0;

  882. }

  883. 

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

  885. {

  886.     AVCPBProperties *cpb_props;

  887. 

  888.     uint8_t sps_buf[128];

  889.     uint8_t pps_buf[128];

  890. 

  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)

  896.     };

  897. 

  898.     mfxExtCodingOption co = {

  899.         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,

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

  901.     };

  902. #if QSV_HAVE_CO2

  903.     mfxExtCodingOption2 co2 = {

  904.         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,

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

  906.     };

  907. #endif

  908. #if QSV_HAVE_CO3

  909.     mfxExtCodingOption3 co3 = {

  910.         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,

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

  912.     };

  913. #endif

  914. 

  915. #if QSV_HAVE_CO_VPS

  916.     uint8_t vps_buf[128];

  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),

  922.     };

  923. #endif

  924. 

  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),

  929.     };

  930. #endif

  931. 

  932.     mfxExtBuffer *ext_buffers[2 + QSV_HAVE_CO2 + QSV_HAVE_CO3 + QSV_HAVE_CO_VPS + QSV_HAVE_EXT_HEVC_TILES];

  933. 

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

  935.     int ret, ext_buf_num = 0, extradata_offset = 0;

  936. 

  937.     ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata;

  938.     ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co;

  939. #if QSV_HAVE_CO2

  940.     ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;

  941. #endif

  942. #if QSV_HAVE_CO3

  943.     ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;

  944. #endif

  945. #if QSV_HAVE_CO_VPS

  946.     q->hevc_vps = ((avctx->codec_id == AV_CODEC_ID_HEVC) && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 17));

  947.     if (q->hevc_vps)

  948.         ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata_vps;

  949. #endif

  950. #if QSV_HAVE_EXT_HEVC_TILES

  951.     if (avctx->codec_id == AV_CODEC_ID_HEVC)

  952.         ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&hevc_tile_buf;

  953. #endif

  954. 

  955.     q->param.ExtParam    = ext_buffers;

  956.     q->param.NumExtParam = ext_buf_num;

  957. 

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

  959.     if (ret < 0)

  960.         return ff_qsv_print_error(avctx, ret,

  961.                                   "Error calling GetVideoParam");

  962. 

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

  964. 

  965.     if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)

  966. #if QSV_HAVE_CO_VPS

  967.         || (q->hevc_vps && !extradata_vps.VPSBufSize)

  968. #endif

  969.     ) {

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

  971.         return AVERROR_UNKNOWN;

  972.     }

  973. 

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

  975. #if QSV_HAVE_CO_VPS

  976.     avctx->extradata_size += q->hevc_vps * extradata_vps.VPSBufSize;

  977. #endif

  978. 

  979.     avctx->extradata = av_malloc(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);

  980.     if (!avctx->extradata)

  981.         return AVERROR(ENOMEM);

  982. 

  983. #if QSV_HAVE_CO_VPS

  984.     if (q->hevc_vps) {

  985.         memcpy(avctx->extradata, vps_buf, extradata_vps.VPSBufSize);

  986.         extradata_offset += extradata_vps.VPSBufSize;

  987.     }

  988. #endif

  989. 

  990.     memcpy(avctx->extradata + extradata_offset, sps_buf, extradata.SPSBufSize);

  991.     extradata_offset += extradata.SPSBufSize;

  992.     if (need_pps) {

  993.         memcpy(avctx->extradata + extradata_offset, pps_buf, extradata.PPSBufSize);

  994.         extradata_offset += extradata.PPSBufSize;

  995.     }

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

  997. 

  998.     cpb_props = ff_add_cpb_side_data(avctx);

  999.     if (!cpb_props)

  1000.         return AVERROR(ENOMEM);

  1001.     cpb_props->max_bitrate = avctx->rc_max_rate;

  1002.     cpb_props->min_bitrate = avctx->rc_min_rate;

  1003.     cpb_props->avg_bitrate = avctx->bit_rate;

  1004.     cpb_props->buffer_size = avctx->rc_buffer_size;

  1005. 

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

  1007. 

  1008.     return 0;

  1009. }

  1010. 

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

  1012. {

  1013.     AVQSVContext *qsv = avctx->hwaccel_context;

  1014.     mfxFrameSurface1 *surfaces;

  1015.     int nb_surfaces, i;

  1016. 

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

  1018. 

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

  1020.     if (!q->opaque_alloc_buf)

  1021.         return AVERROR(ENOMEM);

  1022. 

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

  1024.     if (!q->opaque_surfaces)

  1025.         return AVERROR(ENOMEM);

  1026. 

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

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

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

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

  1031.     }

  1032. 

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

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

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

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

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

  1038. 

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

  1040. 

  1041.     qsv->nb_opaque_surfaces = nb_surfaces;

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

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

  1044. 

  1045.     return 0;

  1046. }

  1047. 

  1048. static int qsvenc_init_session(AVCodecContext *avctx, QSVEncContext *q)

  1049. {

  1050.     int ret;

  1051. 

  1052.     if (avctx->hwaccel_context) {

  1053.         AVQSVContext *qsv = avctx->hwaccel_context;

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

  1055.     } else if (avctx->hw_frames_ctx) {

  1056.         q->frames_ctx.hw_frames_ctx = av_buffer_ref(avctx->hw_frames_ctx);

  1057.         if (!q->frames_ctx.hw_frames_ctx)

  1058.             return AVERROR(ENOMEM);

  1059. 

  1060.         ret = ff_qsv_init_session_frames(avctx, &q->internal_qs.session,

  1061.                                          &q->frames_ctx, q->load_plugins,

  1062.                                          q->param.IOPattern == MFX_IOPATTERN_IN_OPAQUE_MEMORY,

  1063.                                          MFX_GPUCOPY_OFF);

  1064.         if (ret < 0) {

  1065.             av_buffer_unref(&q->frames_ctx.hw_frames_ctx);

  1066.             return ret;

  1067.         }

  1068. 

  1069.         q->session = q->internal_qs.session;

  1070.     } else if (avctx->hw_device_ctx) {

  1071.         ret = ff_qsv_init_session_device(avctx, &q->internal_qs.session,

  1072.                                          avctx->hw_device_ctx, q->load_plugins,

  1073.                                          MFX_GPUCOPY_OFF);

  1074.         if (ret < 0)

  1075.             return ret;

  1076. 

  1077.         q->session = q->internal_qs.session;

  1078.     } else {

  1079.         ret = ff_qsv_init_internal_session(avctx, &q->internal_qs,

  1080.                                            q->load_plugins, MFX_GPUCOPY_OFF);

  1081.         if (ret < 0)

  1082.             return ret;

  1083. 

  1084.         q->session = q->internal_qs.session;

  1085.     }

  1086. 

  1087.     return 0;

  1088. }

  1089. 

  1090. static inline unsigned int qsv_fifo_item_size(void)

  1091. {

  1092.     return sizeof(AVPacket) + sizeof(mfxSyncPoint*) + sizeof(mfxBitstream*);

  1093. }

  1094. 

  1095. static inline unsigned int qsv_fifo_size(const AVFifoBuffer* fifo)

  1096. {

  1097.     return av_fifo_size(fifo)/qsv_fifo_item_size();

  1098. }

  1099. 

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

  1101. {

  1102.     int iopattern = 0;

  1103.     int opaque_alloc = 0;

  1104.     int ret;

  1105. 

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

  1107. 

  1108.     q->async_fifo = av_fifo_alloc(q->async_depth * qsv_fifo_item_size());

  1109.     if (!q->async_fifo)

  1110.         return AVERROR(ENOMEM);

  1111. 

  1112.     if (avctx->hwaccel_context) {

  1113.         AVQSVContext *qsv = avctx->hwaccel_context;

  1114. 

  1115.         iopattern    = qsv->iopattern;

  1116.         opaque_alloc = qsv->opaque_alloc;

  1117.     }

  1118. 

  1119.     if (avctx->hw_frames_ctx) {

  1120.         AVHWFramesContext    *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;

  1121.         AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;

  1122. 

  1123.         if (!iopattern) {

  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;

  1129.         }

  1130.     }

  1131. 

  1132.     if (!iopattern)

  1133.         iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;

  1134.     q->param.IOPattern = iopattern;

  1135. 

  1136.     ret = qsvenc_init_session(avctx, q);

  1137.     if (ret < 0)

  1138.         return ret;

  1139. 

  1140.     ret = MFXQueryVersion(q->session,&q->ver);

  1141.     if (ret < 0) {

  1142.         return ff_qsv_print_error(avctx, ret,

  1143.                                   "Error querying mfx version");

  1144.     }

  1145. 

  1146.     // in the mfxInfoMFX struct, JPEG is different from other codecs

  1147.     switch (avctx->codec_id) {

  1148.     case AV_CODEC_ID_MJPEG:

  1149.         ret = init_video_param_jpeg(avctx, q);

  1150.         break;

  1151.     default:

  1152.         ret = init_video_param(avctx, q);

  1153.         break;

  1154.     }

  1155.     if (ret < 0)

  1156.         return ret;

  1157. 

  1158.     if (avctx->hwaccel_context) {

  1159.         AVQSVContext *qsv = avctx->hwaccel_context;

  1160.         int i, j;

  1161. 

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

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

  1164.         if (!q->extparam)

  1165.             return AVERROR(ENOMEM);

  1166. 

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

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

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

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

  1171. 

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

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

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

  1175.                     break;

  1176.             }

  1177.             if (j < qsv->nb_ext_buffers)

  1178.                 continue;

  1179. 

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

  1181.         }

  1182.     } else {

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

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

  1185.     }

  1186. 

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

  1188.     if (ret == MFX_WRN_PARTIAL_ACCELERATION) {

  1189.         av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");

  1190.     } else if (ret < 0) {

  1191.         return ff_qsv_print_error(avctx, ret,

  1192.                                   "Error querying encoder params");

  1193.     }

  1194. 

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

  1196.     if (ret < 0)

  1197.         return ff_qsv_print_error(avctx, ret,

  1198.                                   "Error querying (IOSurf) the encoding parameters");

  1199. 

  1200.     if (opaque_alloc) {

  1201.         ret = qsv_init_opaque_alloc(avctx, q);

  1202.         if (ret < 0)

  1203.             return ret;

  1204.     }

  1205. 

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

  1207.     if (ret < 0)

  1208.         return ff_qsv_print_error(avctx, ret,

  1209.                                   "Error initializing the encoder");

  1210.     else if (ret > 0)

  1211.         ff_qsv_print_warning(avctx, ret,

  1212.                              "Warning in encoder initialization");

  1213. 

  1214.     switch (avctx->codec_id) {

  1215.     case AV_CODEC_ID_MJPEG:

  1216.         ret = qsv_retrieve_enc_jpeg_params(avctx, q);

  1217.         break;

  1218.     case AV_CODEC_ID_VP9:

  1219.         ret = qsv_retrieve_enc_vp9_params(avctx, q);

  1220.         break;

  1221.     default:

  1222.         ret = qsv_retrieve_enc_params(avctx, q);

  1223.         break;

  1224.     }

  1225.     if (ret < 0) {

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

  1227.         return ret;

  1228.     }

  1229. 

  1230.     q->avctx = avctx;

  1231. 

  1232.     return 0;

  1233. }

  1234. 

  1235. static void free_encoder_ctrl_payloads(mfxEncodeCtrl* enc_ctrl)

  1236. {

  1237.     if (enc_ctrl) {

  1238.         int i;

  1239.         for (i = 0; i < enc_ctrl->NumPayload && i < QSV_MAX_ENC_PAYLOAD; i++) {

  1240.             av_free(enc_ctrl->Payload[i]);

  1241.         }

  1242.         enc_ctrl->NumPayload = 0;

  1243.     }

  1244. }

  1245. 

  1246. static void clear_unused_frames(QSVEncContext *q)

  1247. {

  1248.     QSVFrame *cur = q->work_frames;

  1249.     while (cur) {

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

  1251.             free_encoder_ctrl_payloads(&cur->enc_ctrl);

  1252.             if (cur->frame->format == AV_PIX_FMT_QSV) {

  1253.                 av_frame_unref(cur->frame);

  1254.             }

  1255.             cur->used = 0;

  1256.         }

  1257.         cur = cur->next;

  1258.     }

  1259. }

  1260. 

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

  1262. {

  1263.     QSVFrame *frame, **last;

  1264. 

  1265.     clear_unused_frames(q);

  1266. 

  1267.     frame = q->work_frames;

  1268.     last  = &q->work_frames;

  1269.     while (frame) {

  1270.         if (!frame->used) {

  1271.             *f = frame;

  1272.             frame->used = 1;

  1273.             return 0;

  1274.         }

  1275. 

  1276.         last  = &frame->next;

  1277.         frame = frame->next;

  1278.     }

  1279. 

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

  1281.     if (!frame)

  1282.         return AVERROR(ENOMEM);

  1283.     frame->frame = av_frame_alloc();

  1284.     if (!frame->frame) {

  1285.         av_freep(&frame);

  1286.         return AVERROR(ENOMEM);

  1287.     }

  1288.     frame->enc_ctrl.Payload = av_mallocz(sizeof(mfxPayload*) * QSV_MAX_ENC_PAYLOAD);

  1289.     if (!frame->enc_ctrl.Payload) {

  1290.         av_freep(&frame);

  1291.         return AVERROR(ENOMEM);

  1292.     }

  1293.     *last = frame;

  1294. 

  1295.     *f = frame;

  1296.     frame->used = 1;

  1297. 

  1298.     return 0;

  1299. }

  1300. 

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

  1302.                         QSVFrame **new_frame)

  1303. {

  1304.     QSVFrame *qf;

  1305.     int ret;

  1306. 

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

  1308.     if (ret < 0)

  1309.         return ret;

  1310. 

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

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

  1313.         if (ret < 0)

  1314.             return ret;

  1315. 

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

  1317. 

  1318.         if (q->frames_ctx.mids) {

  1319.             ret = ff_qsv_find_surface_idx(&q->frames_ctx, qf);

  1320.             if (ret < 0)

  1321.                 return ret;

  1322. 

  1323.             qf->surface.Data.MemId = &q->frames_ctx.mids[ret];

  1324.         }

  1325.     } else {

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

  1327.         /* and to make allocation continious for data[0]/data[1] */

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

  1329.             (frame->data[1] - frame->data[0] != frame->linesize[0] * FFALIGN(qf->frame->height, q->height_align))) {

  1330.             qf->frame->height = FFALIGN(frame->height, q->height_align);

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

  1332. 

  1333.             qf->frame->format = frame->format;

  1334. 

  1335.             if (!qf->frame->data[0]) {

  1336.                 ret = av_frame_get_buffer(qf->frame, q->width_align);

  1337.                 if (ret < 0)

  1338.                     return ret;

  1339.             }

  1340. 

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

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

  1343. 

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

  1345.             if (ret < 0) {

  1346.                 av_frame_unref(qf->frame);

  1347.                 return ret;

  1348.             }

  1349.         } else {

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

  1351.             if (ret < 0)

  1352.                 return ret;

  1353.         }

  1354. 

  1355.         qf->surface.Info = q->param.mfx.FrameInfo;

  1356. 

  1357.         qf->surface.Info.PicStruct =

  1358.             !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :

  1359.             frame->top_field_first   ? MFX_PICSTRUCT_FIELD_TFF :

  1360.                                        MFX_PICSTRUCT_FIELD_BFF;

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

  1362.             qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;

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

  1364.             qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;

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

  1366.             qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;

  1367. 

  1368.         qf->surface.Data.PitchLow  = qf->frame->linesize[0];

  1369.         qf->surface.Data.Y         = qf->frame->data[0];

  1370.         qf->surface.Data.UV        = qf->frame->data[1];

  1371.     }

  1372. 

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

  1374. 

  1375.     *new_frame = qf;

  1376. 

  1377.     return 0;

  1378. }

  1379. 

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

  1381. {

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

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

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

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

  1386.             av_log(avctx, AV_LOG_WARNING,

  1387.                    "Interlaced coding is supported"

  1388.                    " at Main/High Profile Level 2.2-4.0\n");

  1389.     }

  1390. }

  1391. 

  1392. static int encode_frame(AVCodecContext *avctx, QSVEncContext *q,

  1393.                         const AVFrame *frame)

  1394. {

  1395.     AVPacket new_pkt = { 0 };

  1396.     mfxBitstream *bs;

  1397. #if QSV_VERSION_ATLEAST(1, 26)

  1398.     mfxExtAVCEncodedFrameInfo *enc_info;

  1399.     mfxExtBuffer **enc_buf;

  1400. #endif

  1401. 

  1402.     mfxFrameSurface1 *surf = NULL;

  1403.     mfxSyncPoint *sync     = NULL;

  1404.     QSVFrame *qsv_frame = NULL;

  1405.     mfxEncodeCtrl* enc_ctrl = NULL;

  1406.     int ret;

  1407. 

  1408.     if (frame) {

  1409.         ret = submit_frame(q, frame, &qsv_frame);

  1410.         if (ret < 0) {

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

  1412.             return ret;

  1413.         }

  1414.     }

  1415.     if (qsv_frame) {

  1416.         surf = &qsv_frame->surface;

  1417.         enc_ctrl = &qsv_frame->enc_ctrl;

  1418. 

  1419.         if (frame->pict_type == AV_PICTURE_TYPE_I) {

  1420.             enc_ctrl->FrameType = MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF;

  1421.             if (q->forced_idr)

  1422.                 enc_ctrl->FrameType |= MFX_FRAMETYPE_IDR;

  1423.         }

  1424.     }

  1425. 

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

  1427.     if (ret < 0) {

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

  1429.         return ret;

  1430.     }

  1431. 

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

  1433.     if (!bs) {

  1434.         av_packet_unref(&new_pkt);

  1435.         return AVERROR(ENOMEM);

  1436.     }

  1437.     bs->Data      = new_pkt.data;

  1438.     bs->MaxLength = new_pkt.size;

  1439. 

  1440. #if QSV_VERSION_ATLEAST(1, 26)

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

  1442.         enc_info = av_mallocz(sizeof(*enc_info));

  1443.         if (!enc_info)

  1444.             return AVERROR(ENOMEM);

  1445. 

  1446.         enc_info->Header.BufferId = MFX_EXTBUFF_ENCODED_FRAME_INFO;

  1447.         enc_info->Header.BufferSz = sizeof (*enc_info);

  1448.         bs->NumExtParam = 1;

  1449.         enc_buf = av_mallocz(sizeof(mfxExtBuffer *));

  1450.         if (!enc_buf)

  1451.             return AVERROR(ENOMEM);

  1452.         enc_buf[0] = (mfxExtBuffer *)enc_info;

  1453. 

  1454.         bs->ExtParam = enc_buf;

  1455.     }

  1456. #endif

  1457. 

  1458.     if (q->set_encode_ctrl_cb) {

  1459.         q->set_encode_ctrl_cb(avctx, frame, &qsv_frame->enc_ctrl);

  1460.     }

  1461. 

  1462.     sync = av_mallocz(sizeof(*sync));

  1463.     if (!sync) {

  1464.         av_freep(&bs);

  1465.  #if QSV_VERSION_ATLEAST(1, 26)

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

  1467.             av_freep(&enc_info);

  1468.             av_freep(&enc_buf);

  1469.         }

  1470.  #endif

  1471.         av_packet_unref(&new_pkt);

  1472.         return AVERROR(ENOMEM);

  1473.     }

  1474. 

  1475.     do {

  1476.         ret = MFXVideoENCODE_EncodeFrameAsync(q->session, enc_ctrl, surf, bs, sync);

  1477.         if (ret == MFX_WRN_DEVICE_BUSY)

  1478.             av_usleep(500);

  1479.     } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_WRN_IN_EXECUTION);

  1480. 

  1481.     if (ret > 0)

  1482.         ff_qsv_print_warning(avctx, ret, "Warning during encoding");

  1483. 

  1484.     if (ret < 0) {

  1485.         av_packet_unref(&new_pkt);

  1486.         av_freep(&bs);

  1487. #if QSV_VERSION_ATLEAST(1, 26)

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

  1489.             av_freep(&enc_info);

  1490.             av_freep(&enc_buf);

  1491.         }

  1492. #endif

  1493.         av_freep(&sync);

  1494.         return (ret == MFX_ERR_MORE_DATA) ?

  1495.                0 : ff_qsv_print_error(avctx, ret, "Error during encoding");

  1496.     }

  1497. 

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

  1499.         print_interlace_msg(avctx, q);

  1500. 

  1501.     if (*sync) {

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

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

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

  1505.     } else {

  1506.         av_freep(&sync);

  1507.         av_packet_unref(&new_pkt);

  1508.         av_freep(&bs);

  1509. #if QSV_VERSION_ATLEAST(1, 26)

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

  1511.             av_freep(&enc_info);

  1512.             av_freep(&enc_buf);

  1513.         }

  1514. #endif

  1515.     }

  1516. 

  1517.     return 0;

  1518. }

  1519. 

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

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

  1522. {

  1523.     int ret;

  1524. 

  1525.     ret = encode_frame(avctx, q, frame);

  1526.     if (ret < 0)

  1527.         return ret;

  1528. 

  1529.     if ((qsv_fifo_size(q->async_fifo) >= q->async_depth) ||

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

  1531.         AVPacket new_pkt;

  1532.         mfxBitstream *bs;

  1533.         mfxSyncPoint *sync;

  1534. #if QSV_VERSION_ATLEAST(1, 26)

  1535.         mfxExtAVCEncodedFrameInfo *enc_info;

  1536.         mfxExtBuffer **enc_buf;

  1537. #endif

  1538.         enum AVPictureType pict_type;

  1539. 

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

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

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

  1543. 

  1544.         do {

  1545.             ret = MFXVideoCORE_SyncOperation(q->session, *sync, 1000);

  1546.         } while (ret == MFX_WRN_IN_EXECUTION);

  1547. 

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

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

  1550.         new_pkt.size = bs->DataLength;

  1551. 

  1552.         if (bs->FrameType & MFX_FRAMETYPE_IDR || bs->FrameType & MFX_FRAMETYPE_xIDR) {

  1553.             new_pkt.flags |= AV_PKT_FLAG_KEY;

  1554.             pict_type = AV_PICTURE_TYPE_I;

  1555.         } else if (bs->FrameType & MFX_FRAMETYPE_I || bs->FrameType & MFX_FRAMETYPE_xI)

  1556.             pict_type = AV_PICTURE_TYPE_I;

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

  1558.             pict_type = AV_PICTURE_TYPE_P;

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

  1560.             pict_type = AV_PICTURE_TYPE_B;

  1561.         else if (bs->FrameType == MFX_FRAMETYPE_UNKNOWN) {

  1562.             pict_type = AV_PICTURE_TYPE_NONE;

  1563.             av_log(avctx, AV_LOG_WARNING, "Unknown FrameType, set pict_type to AV_PICTURE_TYPE_NONE.\n");

  1564.         } else {

  1565.             av_log(avctx, AV_LOG_ERROR, "Invalid FrameType:%d.\n", bs->FrameType);

  1566.             return AVERROR_INVALIDDATA;

  1567.         }

  1568. 

  1569. #if FF_API_CODED_FRAME

  1570. FF_DISABLE_DEPRECATION_WARNINGS

  1571.         avctx->coded_frame->pict_type = pict_type;

  1572. FF_ENABLE_DEPRECATION_WARNINGS

  1573. #endif

  1574. 

  1575. #if QSV_VERSION_ATLEAST(1, 26)

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

  1577.             enc_buf = bs->ExtParam;

  1578.             enc_info = (mfxExtAVCEncodedFrameInfo *)(*bs->ExtParam);

  1579.             ff_side_data_set_encoder_stats(&new_pkt,

  1580.                 enc_info->QP * FF_QP2LAMBDA, NULL, 0, pict_type);

  1581.             av_freep(&enc_info);

  1582.             av_freep(&enc_buf);

  1583.         }

  1584. #endif

  1585.         av_freep(&bs);

  1586.         av_freep(&sync);

  1587. 

  1588.         if (pkt->data) {

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

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

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

  1592.                 av_packet_unref(&new_pkt);

  1593.                 return AVERROR(EINVAL);

  1594.             }

  1595. 

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

  1597.             pkt->size = new_pkt.size;

  1598. 

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

  1600.             av_packet_unref(&new_pkt);

  1601.             if (ret < 0)

  1602.                 return ret;

  1603.         } else

  1604.             *pkt = new_pkt;

  1605. 

  1606.         *got_packet = 1;

  1607.     }

  1608. 

  1609.     return 0;

  1610. }

  1611. 

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

  1613. {

  1614.     QSVFrame *cur;

  1615. 

  1616.     if (q->session)

  1617.         MFXVideoENCODE_Close(q->session);

  1618. 

  1619.     q->session          = NULL;

  1620.     ff_qsv_close_internal_session(&q->internal_qs);

  1621. 

  1622.     av_buffer_unref(&q->frames_ctx.hw_frames_ctx);

  1623.     av_buffer_unref(&q->frames_ctx.mids_buf);

  1624. 

  1625.     cur = q->work_frames;

  1626.     while (cur) {

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

  1628.         av_frame_free(&cur->frame);

  1629.         av_free(cur->enc_ctrl.Payload);

  1630.         av_freep(&cur);

  1631.         cur = q->work_frames;

  1632.     }

  1633. 

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

  1635.         AVPacket pkt;

  1636.         mfxSyncPoint *sync;

  1637.         mfxBitstream *bs;

  1638. 

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

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

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

  1642. 

  1643.         av_freep(&sync);

  1644.         av_freep(&bs);

  1645.         av_packet_unref(&pkt);

  1646.     }

  1647.     av_fifo_free(q->async_fifo);

  1648.     q->async_fifo = NULL;

  1649. 

  1650.     av_freep(&q->opaque_surfaces);

  1651.     av_buffer_unref(&q->opaque_alloc_buf);

  1652. 

  1653.     av_freep(&q->extparam);

  1654. 

  1655.     return 0;

  1656. }

  1657. 

  1658. const AVCodecHWConfigInternal *const ff_qsv_enc_hw_configs[] = {

  1659.     HW_CONFIG_ENCODER_FRAMES(QSV,  QSV),

  1660.     HW_CONFIG_ENCODER_DEVICE(NV12, QSV),

  1661.     HW_CONFIG_ENCODER_DEVICE(P010, QSV),

  1662.     NULL,

  1663. };