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

1116 lines
37KB
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/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. 

  36. #include "avcodec.h"

  37. #include "internal.h"

  38. #include "qsv.h"

  39. #include "qsv_internal.h"

  40. #include "qsvenc.h"

  41. 

  42. static const struct {

  43.     mfxU16 profile;

  44.     const char *name;

  45. } profile_names[] = {

  46.     { MFX_PROFILE_AVC_BASELINE,                 "baseline"              },

  47.     { MFX_PROFILE_AVC_MAIN,                     "main"                  },

  48.     { MFX_PROFILE_AVC_EXTENDED,                 "extended"              },

  49.     { MFX_PROFILE_AVC_HIGH,                     "high"                  },

  50. #if QSV_VERSION_ATLEAST(1, 15)

  51.     { MFX_PROFILE_AVC_HIGH_422,                 "high 422"              },

  52. #endif

  53. #if QSV_VERSION_ATLEAST(1, 4)

  54.     { MFX_PROFILE_AVC_CONSTRAINED_BASELINE,     "constrained baseline"  },

  55.     { MFX_PROFILE_AVC_CONSTRAINED_HIGH,         "constrained high"      },

  56.     { MFX_PROFILE_AVC_PROGRESSIVE_HIGH,         "progressive high"      },

  57. #endif

  58.     { MFX_PROFILE_MPEG2_SIMPLE,                 "simple"                },

  59.     { MFX_PROFILE_MPEG2_MAIN,                   "main"                  },

  60.     { MFX_PROFILE_MPEG2_HIGH,                   "high"                  },

  61.     { MFX_PROFILE_VC1_SIMPLE,                   "simple"                },

  62.     { MFX_PROFILE_VC1_MAIN,                     "main"                  },

  63.     { MFX_PROFILE_VC1_ADVANCED,                 "advanced"              },

  64. #if QSV_VERSION_ATLEAST(1, 8)

  65.     { MFX_PROFILE_HEVC_MAIN,                    "main"                  },

  66.     { MFX_PROFILE_HEVC_MAIN10,                  "main10"                },

  67.     { MFX_PROFILE_HEVC_MAINSP,                  "mainsp"                },

  68. #endif

  69. };

  70. 

  71. static const char *print_profile(mfxU16 profile)

  72. {

  73.     int i;

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

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

  76.             return profile_names[i].name;

  77.     return "unknown";

  78. }

  79. 

  80. static const struct {

  81.     mfxU16      rc_mode;

  82.     const char *name;

  83. } rc_names[] = {

  84.     { MFX_RATECONTROL_CBR,     "CBR" },

  85.     { MFX_RATECONTROL_VBR,     "VBR" },

  86.     { MFX_RATECONTROL_CQP,     "CQP" },

  87.     { MFX_RATECONTROL_AVBR,    "AVBR" },

  88. #if QSV_HAVE_LA

  89.     { MFX_RATECONTROL_LA,      "LA" },

  90. #endif

  91. #if QSV_HAVE_ICQ

  92.     { MFX_RATECONTROL_ICQ,     "ICQ" },

  93.     { MFX_RATECONTROL_LA_ICQ,  "LA_ICQ" },

  94. #endif

  95. #if QSV_HAVE_VCM

  96.     { MFX_RATECONTROL_VCM,     "VCM" },

  97. #endif

  98. #if QSV_VERSION_ATLEAST(1, 10)

  99.     { MFX_RATECONTROL_LA_EXT,  "LA_EXT" },

  100. #endif

  101. #if QSV_HAVE_LA_HRD

  102.     { MFX_RATECONTROL_LA_HRD,  "LA_HRD" },

  103. #endif

  104. #if QSV_HAVE_QVBR

  105.     { MFX_RATECONTROL_QVBR,    "QVBR" },

  106. #endif

  107. };

  108. 

  109. static const char *print_ratecontrol(mfxU16 rc_mode)

  110. {

  111.     int i;

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

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

  114.             return rc_names[i].name;

  115.     return "unknown";

  116. }

  117. 

  118. static const char *print_threestate(mfxU16 val)

  119. {

  120.     if (val == MFX_CODINGOPTION_ON)

  121.         return "ON";

  122.     else if (val == MFX_CODINGOPTION_OFF)

  123.         return "OFF";

  124.     return "unknown";

  125. }

  126. 

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

  128.                              mfxExtBuffer **coding_opts)

  129. {

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

  131. 

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

  133. #if QSV_HAVE_CO2

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

  135. #endif

  136. #if QSV_HAVE_CO3

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

  138. #endif

  139. 

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

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

  142. 

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

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

  145.     if (info->GopOptFlag & MFX_GOP_CLOSED)

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

  147.     if (info->GopOptFlag & MFX_GOP_STRICT)

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

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

  150. 

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

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

  153. 

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

  155.         info->RateControlMethod == MFX_RATECONTROL_VBR

  156. #if QSV_HAVE_VCM

  157.         || info->RateControlMethod == MFX_RATECONTROL_VCM

  158. #endif

  159.         ) {

  160.         av_log(avctx, AV_LOG_VERBOSE,

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

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

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

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

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

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

  167.         av_log(avctx, AV_LOG_VERBOSE,

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

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

  170.     }

  171. #if QSV_HAVE_LA

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

  173. #if QSV_HAVE_LA_HRD

  174.              || info->RateControlMethod == MFX_RATECONTROL_LA_HRD

  175. #endif

  176.              ) {

  177.         av_log(avctx, AV_LOG_VERBOSE,

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

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

  180.     }

  181. #endif

  182. #if QSV_HAVE_ICQ

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

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

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

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

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

  188.     }

  189. #endif

  190. #if QSV_HAVE_QVBR

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

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

  193.                co3->QVBRQuality);

  194.     }

  195. #endif

  196. 

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

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

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

  200.            print_threestate(co->RateDistortionOpt));

  201. 

  202. #if QSV_HAVE_CO2

  203.     av_log(avctx, AV_LOG_VERBOSE,

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

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

  206. 

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

  208. #if QSV_HAVE_MAX_SLICE_SIZE

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

  210. #endif

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

  212. 

  213.     av_log(avctx, AV_LOG_VERBOSE,

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

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

  216.            print_threestate(co2->ExtBRC));

  217. 

  218. #if QSV_HAVE_TRELLIS

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

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

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

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

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

  224.     } else {

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

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

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

  228.     }

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

  230. #endif

  231. 

  232. #if QSV_VERSION_ATLEAST(1, 8)

  233.     av_log(avctx, AV_LOG_VERBOSE,

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

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

  236.     switch (co2->LookAheadDS) {

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

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

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

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

  241.     }

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

  243. 

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

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

  246.     switch (co2->BRefType) {

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

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

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

  250.     }

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

  252. #endif

  253. 

  254. #if QSV_VERSION_ATLEAST(1, 9)

  255.     av_log(avctx, AV_LOG_VERBOSE,

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

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

  258. #endif

  259. #endif

  260. 

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

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

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

  264.         av_log(avctx, AV_LOG_VERBOSE,

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

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

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

  268.     }

  269. }

  270. 

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

  272. {

  273.     const char *rc_desc;

  274.     mfxU16      rc_mode;

  275. 

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

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

  278.     int want_vcm    = q->vcm;

  279. 

  280.     if (want_la && !QSV_HAVE_LA) {

  281.         av_log(avctx, AV_LOG_ERROR,

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

  283.         return AVERROR(ENOSYS);

  284.     }

  285.     if (want_vcm && !QSV_HAVE_VCM) {

  286.         av_log(avctx, AV_LOG_ERROR,

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

  288.         return AVERROR(ENOSYS);

  289.     }

  290. 

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

  292.         av_log(avctx, AV_LOG_ERROR,

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

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

  295.         return AVERROR(EINVAL);

  296.     }

  297. 

  298.     if (want_qscale) {

  299.         rc_mode = MFX_RATECONTROL_CQP;

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

  301.     }

  302. #if QSV_HAVE_VCM

  303.     else if (want_vcm) {

  304.         rc_mode = MFX_RATECONTROL_VCM;

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

  306.     }

  307. #endif

  308. #if QSV_HAVE_LA

  309.     else if (want_la) {

  310.         rc_mode = MFX_RATECONTROL_LA;

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

  312. 

  313. #if QSV_HAVE_ICQ

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

  315.             rc_mode = MFX_RATECONTROL_LA_ICQ;

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

  317.         }

  318. #endif

  319.     }

  320. #endif

  321. #if QSV_HAVE_ICQ

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

  323.         rc_mode = MFX_RATECONTROL_ICQ;

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

  325.     }

  326. #endif

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

  328.         rc_mode = MFX_RATECONTROL_CBR;

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

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

  331.         rc_mode = MFX_RATECONTROL_AVBR;

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

  333.     } else {

  334.         rc_mode = MFX_RATECONTROL_VBR;

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

  336.     }

  337. 

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

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

  340. 

  341.     return 0;

  342. }

  343. 

  344. static int rc_supported(QSVEncContext *q)

  345. {

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

  347.     mfxStatus ret;

  348. 

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

  350.     if (ret < 0 ||

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

  352.         return 0;

  353.     return 1;

  354. }

  355. 

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

  357. {

  358.     float quant;

  359.     int ret;

  360. 

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

  362.     if (ret < 0)

  363.         return AVERROR_BUG;

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

  365. 

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

  367. 

  368.     if (avctx->level > 0)

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

  370. 

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

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

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

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

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

  376.                                       MFX_GOP_CLOSED : 0;

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

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

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

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

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

  382. 

  383.     if (avctx->hw_frames_ctx) {

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

  385.         AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;

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

  387.     } else {

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

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

  390.         const AVPixFmtDescriptor *desc;

  391. 

  392.         desc = av_pix_fmt_desc_get(sw_format);

  393.         if (!desc)

  394.             return AVERROR_BUG;

  395. 

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

  397. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  411.     }

  412. 

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

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

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

  416.     } else {

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

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

  419.     }

  420. 

  421.     ret = select_rc_mode(avctx, q);

  422.     if (ret < 0)

  423.         return ret;

  424. 

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

  426.     case MFX_RATECONTROL_CBR:

  427.     case MFX_RATECONTROL_VBR:

  428. #if QSV_HAVE_VCM

  429.     case MFX_RATECONTROL_VCM:

  430. #endif

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

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

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

  434.         break;

  435.     case MFX_RATECONTROL_CQP:

  436.         quant = avctx->global_quality / FF_QP2LAMBDA;

  437. 

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

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

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

  441. 

  442.         break;

  443.     case MFX_RATECONTROL_AVBR:

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

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

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

  447.         break;

  448. #if QSV_HAVE_LA

  449.     case MFX_RATECONTROL_LA:

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

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

  452.         break;

  453. #if QSV_HAVE_ICQ

  454.     case MFX_RATECONTROL_LA_ICQ:

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

  456.     case MFX_RATECONTROL_ICQ:

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

  458.         break;

  459. #endif

  460. #endif

  461.     }

  462. 

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

  464.     // are provided

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

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

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

  468. #if FF_API_CODER_TYPE

  469. FF_DISABLE_DEPRECATION_WARNINGS

  470.         if (avctx->coder_type != 0)

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

  472. FF_ENABLE_DEPRECATION_WARNINGS

  473. #endif

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

  475.                                   : MFX_CODINGOPTION_UNKNOWN;

  476. 

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

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

  479. 

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

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

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

  483.                                              MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;

  484. 

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

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

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

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

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

  490.         }

  491. 

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

  493. 

  494. #if QSV_HAVE_CO2

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

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

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

  498. 

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

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

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

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

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

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

  505. 

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

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

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

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

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

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

  512. 

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

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

  515. #if QSV_HAVE_MAX_SLICE_SIZE

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

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

  518. #endif

  519. 

  520. #if QSV_HAVE_TRELLIS

  521.             q->extco2.Trellis = q->trellis;

  522. #endif

  523. 

  524. #if QSV_HAVE_BREF_TYPE

  525. #if FF_API_PRIVATE_OPT

  526. FF_DISABLE_DEPRECATION_WARNINGS

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

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

  529. FF_ENABLE_DEPRECATION_WARNINGS

  530. #endif

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

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

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

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

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

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

  537. #endif

  538. 

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

  540.         }

  541. #endif

  542.     }

  543. 

  544.     if (!rc_supported(q)) {

  545.         av_log(avctx, AV_LOG_ERROR,

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

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

  548.         return AVERROR(ENOSYS);

  549.     }

  550. 

  551.     return 0;

  552. }

  553. 

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

  555. {

  556.     AVCPBProperties *cpb_props;

  557. 

  558.     uint8_t sps_buf[128];

  559.     uint8_t pps_buf[128];

  560. 

  561.     mfxExtCodingOptionSPSPPS extradata = {

  562.         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,

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

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

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

  566.     };

  567. 

  568.     mfxExtCodingOption co = {

  569.         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,

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

  571.     };

  572. #if QSV_HAVE_CO2

  573.     mfxExtCodingOption2 co2 = {

  574.         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,

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

  576.     };

  577. #endif

  578. #if QSV_HAVE_CO3

  579.     mfxExtCodingOption3 co3 = {

  580.         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,

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

  582.     };

  583. #endif

  584. 

  585.     mfxExtBuffer *ext_buffers[] = {

  586.         (mfxExtBuffer*)&extradata,

  587.         (mfxExtBuffer*)&co,

  588. #if QSV_HAVE_CO2

  589.         (mfxExtBuffer*)&co2,

  590. #endif

  591. #if QSV_HAVE_CO3

  592.         (mfxExtBuffer*)&co3,

  593. #endif

  594.     };

  595. 

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

  597.     int ret;

  598. 

  599.     q->param.ExtParam    = ext_buffers;

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

  601. 

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

  603.     if (ret < 0)

  604.         return ff_qsv_error(ret);

  605. 

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

  607. 

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

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

  610.         return AVERROR_UNKNOWN;

  611.     }

  612. 

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

  614.                                  AV_INPUT_BUFFER_PADDING_SIZE);

  615.     if (!avctx->extradata)

  616.         return AVERROR(ENOMEM);

  617. 

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

  619.     if (need_pps)

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

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

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

  623. 

  624.     cpb_props = ff_add_cpb_side_data(avctx);

  625.     if (!cpb_props)

  626.         return AVERROR(ENOMEM);

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

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

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

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

  631. 

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

  633. 

  634.     return 0;

  635. }

  636. 

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

  638. {

  639.     AVQSVContext *qsv = avctx->hwaccel_context;

  640.     mfxFrameSurface1 *surfaces;

  641.     int nb_surfaces, i;

  642. 

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

  644. 

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

  646.     if (!q->opaque_alloc_buf)

  647.         return AVERROR(ENOMEM);

  648. 

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

  650.     if (!q->opaque_surfaces)

  651.         return AVERROR(ENOMEM);

  652. 

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

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

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

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

  657.     }

  658. 

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

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

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

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

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

  664. 

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

  666. 

  667.     qsv->nb_opaque_surfaces = nb_surfaces;

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

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

  670. 

  671.     return 0;

  672. }

  673. 

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

  675. {

  676.     int ret;

  677. 

  678.     if (avctx->hwaccel_context) {

  679.         AVQSVContext *qsv = avctx->hwaccel_context;

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

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

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

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

  684.             return AVERROR(ENOMEM);

  685. 

  686.         ret = ff_qsv_init_session_hwcontext(avctx, &q->internal_session,

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

  688.                                             q->param.IOPattern == MFX_IOPATTERN_IN_OPAQUE_MEMORY);

  689.         if (ret < 0) {

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

  691.             return ret;

  692.         }

  693. 

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

  695.     } else {

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

  697.                                            q->load_plugins);

  698.         if (ret < 0)

  699.             return ret;

  700. 

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

  702.     }

  703. 

  704.     return 0;

  705. }

  706. 

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

  708. {

  709.     int iopattern = 0;

  710.     int opaque_alloc = 0;

  711.     int ret;

  712. 

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

  714. 

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

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

  717.     if (!q->async_fifo)

  718.         return AVERROR(ENOMEM);

  719. 

  720.     if (avctx->hwaccel_context) {

  721.         AVQSVContext *qsv = avctx->hwaccel_context;

  722. 

  723.         iopattern    = qsv->iopattern;

  724.         opaque_alloc = qsv->opaque_alloc;

  725.     }

  726. 

  727.     if (avctx->hw_frames_ctx) {

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

  729.         AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;

  730. 

  731.         if (!iopattern) {

  732.             if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)

  733.                 iopattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY;

  734.             else if (frames_hwctx->frame_type &

  735.                      (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))

  736.                 iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;

  737.         }

  738.     }

  739. 

  740.     if (!iopattern)

  741.         iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;

  742.     q->param.IOPattern = iopattern;

  743. 

  744.     ret = qsvenc_init_session(avctx, q);

  745.     if (ret < 0)

  746.         return ret;

  747. 

  748.     ret = init_video_param(avctx, q);

  749.     if (ret < 0)

  750.         return ret;

  751. 

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

  753.     if (ret < 0) {

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

  755.         return ff_qsv_error(ret);

  756.     }

  757. 

  758.     if (opaque_alloc) {

  759.         ret = qsv_init_opaque_alloc(avctx, q);

  760.         if (ret < 0)

  761.             return ret;

  762.     }

  763. 

  764.     if (avctx->hwaccel_context) {

  765.         AVQSVContext *qsv = avctx->hwaccel_context;

  766.         int i, j;

  767. 

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

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

  770.         if (!q->extparam)

  771.             return AVERROR(ENOMEM);

  772. 

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

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

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

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

  777. 

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

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

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

  781.                     break;

  782.             }

  783.             if (j < qsv->nb_ext_buffers)

  784.                 continue;

  785. 

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

  787.         }

  788.     } else {

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

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

  791.     }

  792. 

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

  794.     if (ret < 0) {

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

  796.         return ff_qsv_error(ret);

  797.     }

  798. 

  799.     ret = qsv_retrieve_enc_params(avctx, q);

  800.     if (ret < 0) {

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

  802.         return ret;

  803.     }

  804. 

  805.     q->avctx = avctx;

  806. 

  807.     return 0;

  808. }

  809. 

  810. static void clear_unused_frames(QSVEncContext *q)

  811. {

  812.     QSVFrame *cur = q->work_frames;

  813.     while (cur) {

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

  815.             cur->surface = NULL;

  816.             av_frame_unref(cur->frame);

  817.         }

  818.         cur = cur->next;

  819.     }

  820. }

  821. 

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

  823. {

  824.     QSVFrame *frame, **last;

  825. 

  826.     clear_unused_frames(q);

  827. 

  828.     frame = q->work_frames;

  829.     last  = &q->work_frames;

  830.     while (frame) {

  831.         if (!frame->surface) {

  832.             *f = frame;

  833.             return 0;

  834.         }

  835. 

  836.         last  = &frame->next;

  837.         frame = frame->next;

  838.     }

  839. 

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

  841.     if (!frame)

  842.         return AVERROR(ENOMEM);

  843.     frame->frame = av_frame_alloc();

  844.     if (!frame->frame) {

  845.         av_freep(&frame);

  846.         return AVERROR(ENOMEM);

  847.     }

  848.     *last = frame;

  849. 

  850.     *f = frame;

  851. 

  852.     return 0;

  853. }

  854. 

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

  856.                         mfxFrameSurface1 **surface)

  857. {

  858.     QSVFrame *qf;

  859.     int ret;

  860. 

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

  862.     if (ret < 0)

  863.         return ret;

  864. 

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

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

  867.         if (ret < 0)

  868.             return ret;

  869. 

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

  871.     } else {

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

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

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

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

  876. 

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

  878.             if (ret < 0)

  879.                 return ret;

  880. 

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

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

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

  884.             if (ret < 0) {

  885.                 av_frame_unref(qf->frame);

  886.                 return ret;

  887.             }

  888.         } else {

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

  890.             if (ret < 0)

  891.                 return ret;

  892.         }

  893. 

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

  895. 

  896.         qf->surface_internal.Info.PicStruct =

  897.             !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :

  898.             frame->top_field_first   ? MFX_PICSTRUCT_FIELD_TFF :

  899.                                        MFX_PICSTRUCT_FIELD_BFF;

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

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

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

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

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

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

  906. 

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

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

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

  910. 

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

  912.     }

  913. 

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

  915. 

  916.     *surface = qf->surface;

  917. 

  918.     return 0;

  919. }

  920. 

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

  922. {

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

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

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

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

  927.             av_log(avctx, AV_LOG_WARNING,

  928.                    "Interlaced coding is supported"

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

  930.     }

  931. }

  932. 

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

  934.                         const AVFrame *frame)

  935. {

  936.     AVPacket new_pkt = { 0 };

  937.     mfxBitstream *bs;

  938. 

  939.     mfxFrameSurface1 *surf = NULL;

  940.     mfxSyncPoint *sync     = NULL;

  941.     int ret;

  942. 

  943.     if (frame) {

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

  945.         if (ret < 0) {

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

  947.             return ret;

  948.         }

  949.     }

  950. 

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

  952.     if (ret < 0) {

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

  954.         return ret;

  955.     }

  956. 

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

  958.     if (!bs) {

  959.         av_packet_unref(&new_pkt);

  960.         return AVERROR(ENOMEM);

  961.     }

  962.     bs->Data      = new_pkt.data;

  963.     bs->MaxLength = new_pkt.size;

  964. 

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

  966.     if (!sync) {

  967.         av_freep(&bs);

  968.         av_packet_unref(&new_pkt);

  969.         return AVERROR(ENOMEM);

  970.     }

  971. 

  972.     do {

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

  974.         if (ret == MFX_WRN_DEVICE_BUSY)

  975.             av_usleep(1);

  976.     } while (ret > 0);

  977. 

  978.     if (ret < 0) {

  979.         av_packet_unref(&new_pkt);

  980.         av_freep(&bs);

  981.         av_freep(&sync);

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

  983.     }

  984. 

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

  986.         print_interlace_msg(avctx, q);

  987. 

  988.     if (*sync) {

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

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

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

  992.     } else {

  993.         av_freep(&sync);

  994.         av_packet_unref(&new_pkt);

  995.         av_freep(&bs);

  996.     }

  997. 

  998.     return 0;

  999. }

  1000. 

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

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

  1003. {

  1004.     int ret;

  1005. 

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

  1007.     if (ret < 0)

  1008.         return ret;

  1009. 

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

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

  1012.         AVPacket new_pkt;

  1013.         mfxBitstream *bs;

  1014.         mfxSyncPoint *sync;

  1015. 

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

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

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

  1019. 

  1020.         do {

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

  1022.         } while (ret == MFX_WRN_IN_EXECUTION);

  1023. 

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

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

  1026.         new_pkt.size = bs->DataLength;

  1027. 

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

  1029.             bs->FrameType & MFX_FRAMETYPE_xIDR)

  1030.             new_pkt.flags |= AV_PKT_FLAG_KEY;

  1031. 

  1032. #if FF_API_CODED_FRAME

  1033. FF_DISABLE_DEPRECATION_WARNINGS

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

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

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

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

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

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

  1040. FF_ENABLE_DEPRECATION_WARNINGS

  1041. #endif

  1042. 

  1043.         av_freep(&bs);

  1044.         av_freep(&sync);

  1045. 

  1046.         if (pkt->data) {

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

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

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

  1050.                 av_packet_unref(&new_pkt);

  1051.                 return AVERROR(EINVAL);

  1052.             }

  1053. 

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

  1055.             pkt->size = new_pkt.size;

  1056. 

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

  1058.             av_packet_unref(&new_pkt);

  1059.             if (ret < 0)

  1060.                 return ret;

  1061.         } else

  1062.             *pkt = new_pkt;

  1063. 

  1064.         *got_packet = 1;

  1065.     }

  1066. 

  1067.     return 0;

  1068. }

  1069. 

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

  1071. {

  1072.     QSVFrame *cur;

  1073. 

  1074.     if (q->session)

  1075.         MFXVideoENCODE_Close(q->session);

  1076.     if (q->internal_session)

  1077.         MFXClose(q->internal_session);

  1078.     q->session          = NULL;

  1079.     q->internal_session = NULL;

  1080. 

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

  1082.     av_freep(&q->frames_ctx.mids);

  1083.     q->frames_ctx.nb_mids = 0;

  1084. 

  1085.     cur = q->work_frames;

  1086.     while (cur) {

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

  1088.         av_frame_free(&cur->frame);

  1089.         av_freep(&cur);

  1090.         cur = q->work_frames;

  1091.     }

  1092. 

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

  1094.         AVPacket pkt;

  1095.         mfxSyncPoint *sync;

  1096.         mfxBitstream *bs;

  1097. 

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

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

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

  1101. 

  1102.         av_freep(&sync);

  1103.         av_freep(&bs);

  1104.         av_packet_unref(&pkt);

  1105.     }

  1106.     av_fifo_free(q->async_fifo);

  1107.     q->async_fifo = NULL;

  1108. 

  1109.     av_freep(&q->opaque_surfaces);

  1110.     av_buffer_unref(&q->opaque_alloc_buf);

  1111. 

  1112.     av_freep(&q->extparam);

  1113. 

  1114.     return 0;

  1115. }