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

1451 lines
50KB
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 "qsv.h"

  40. #include "qsv_internal.h"

  41. #include "qsvenc.h"

  42. 

  43. static const struct {

  44.     mfxU16 profile;

  45.     const char *name;

  46. } profile_names[] = {

  47.     { MFX_PROFILE_AVC_BASELINE,                 "baseline"              },

  48.     { MFX_PROFILE_AVC_MAIN,                     "main"                  },

  49.     { MFX_PROFILE_AVC_EXTENDED,                 "extended"              },

  50.     { MFX_PROFILE_AVC_HIGH,                     "high"                  },

  51. #if QSV_VERSION_ATLEAST(1, 15)

  52.     { MFX_PROFILE_AVC_HIGH_422,                 "high 422"              },

  53. #endif

  54. #if QSV_VERSION_ATLEAST(1, 4)

  55.     { MFX_PROFILE_AVC_CONSTRAINED_BASELINE,     "constrained baseline"  },

  56.     { MFX_PROFILE_AVC_CONSTRAINED_HIGH,         "constrained high"      },

  57.     { MFX_PROFILE_AVC_PROGRESSIVE_HIGH,         "progressive high"      },

  58. #endif

  59.     { MFX_PROFILE_MPEG2_SIMPLE,                 "simple"                },

  60.     { MFX_PROFILE_MPEG2_MAIN,                   "main"                  },

  61.     { MFX_PROFILE_MPEG2_HIGH,                   "high"                  },

  62.     { MFX_PROFILE_VC1_SIMPLE,                   "simple"                },

  63.     { MFX_PROFILE_VC1_MAIN,                     "main"                  },

  64.     { MFX_PROFILE_VC1_ADVANCED,                 "advanced"              },

  65. #if QSV_VERSION_ATLEAST(1, 8)

  66.     { MFX_PROFILE_HEVC_MAIN,                    "main"                  },

  67.     { MFX_PROFILE_HEVC_MAIN10,                  "main10"                },

  68.     { MFX_PROFILE_HEVC_MAINSP,                  "mainsp"                },

  69. #endif

  70. };

  71. 

  72. static const char *print_profile(mfxU16 profile)

  73. {

  74.     int i;

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

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

  77.             return profile_names[i].name;

  78.     return "unknown";

  79. }

  80. 

  81. static const struct {

  82.     mfxU16      rc_mode;

  83.     const char *name;

  84. } rc_names[] = {

  85.     { MFX_RATECONTROL_CBR,     "CBR" },

  86.     { MFX_RATECONTROL_VBR,     "VBR" },

  87.     { MFX_RATECONTROL_CQP,     "CQP" },

  88. #if QSV_HAVE_AVBR

  89.     { MFX_RATECONTROL_AVBR,    "AVBR" },

  90. #endif

  91. #if QSV_HAVE_LA

  92.     { MFX_RATECONTROL_LA,      "LA" },

  93. #endif

  94. #if QSV_HAVE_ICQ

  95.     { MFX_RATECONTROL_ICQ,     "ICQ" },

  96.     { MFX_RATECONTROL_LA_ICQ,  "LA_ICQ" },

  97. #endif

  98. #if QSV_HAVE_VCM

  99.     { MFX_RATECONTROL_VCM,     "VCM" },

  100. #endif

  101. #if QSV_VERSION_ATLEAST(1, 10)

  102.     { MFX_RATECONTROL_LA_EXT,  "LA_EXT" },

  103. #endif

  104. #if QSV_HAVE_LA_HRD

  105.     { MFX_RATECONTROL_LA_HRD,  "LA_HRD" },

  106. #endif

  107. #if QSV_HAVE_QVBR

  108.     { MFX_RATECONTROL_QVBR,    "QVBR" },

  109. #endif

  110. };

  111. 

  112. static const char *print_ratecontrol(mfxU16 rc_mode)

  113. {

  114.     int i;

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

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

  117.             return rc_names[i].name;

  118.     return "unknown";

  119. }

  120. 

  121. static const char *print_threestate(mfxU16 val)

  122. {

  123.     if (val == MFX_CODINGOPTION_ON)

  124.         return "ON";

  125.     else if (val == MFX_CODINGOPTION_OFF)

  126.         return "OFF";

  127.     return "unknown";

  128. }

  129. 

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

  131.                              mfxExtBuffer **coding_opts)

  132. {

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

  134. 

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

  136. #if QSV_HAVE_CO2

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

  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.                "BufferSizeInKB: %"PRIu16"; InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"\n",

  162.                info->BufferSizeInKB, 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.     }

  167. #if QSV_HAVE_AVBR

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

  169.         av_log(avctx, AV_LOG_VERBOSE,

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

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

  172.     }

  173. #endif

  174. #if QSV_HAVE_LA

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

  176. #if QSV_HAVE_LA_HRD

  177.              || info->RateControlMethod == MFX_RATECONTROL_LA_HRD

  178. #endif

  179.              ) {

  180.         av_log(avctx, AV_LOG_VERBOSE,

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

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

  183.     }

  184. #endif

  185. #if QSV_HAVE_ICQ

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

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

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

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

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

  191.     }

  192. #endif

  193. 

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

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

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

  197.            print_threestate(co->RateDistortionOpt));

  198. 

  199. #if QSV_HAVE_CO2

  200.     av_log(avctx, AV_LOG_VERBOSE,

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

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

  203. 

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

  205. #if QSV_HAVE_MAX_SLICE_SIZE

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

  207. #endif

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

  209. 

  210.     av_log(avctx, AV_LOG_VERBOSE,

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

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

  213.            print_threestate(co2->ExtBRC));

  214. 

  215. #if QSV_HAVE_TRELLIS

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

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

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

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

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

  221.     } else {

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

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

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

  225.     }

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

  227. #endif

  228. 

  229. #if QSV_HAVE_VDENC

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

  231. #endif

  232. 

  233. #if QSV_VERSION_ATLEAST(1, 8)

  234.     av_log(avctx, AV_LOG_VERBOSE,

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

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

  237.     switch (co2->LookAheadDS) {

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

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

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

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

  242.     }

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

  244. 

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

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

  247.     switch (co2->BRefType) {

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

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

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

  251.     }

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

  253. #endif

  254. 

  255. #if QSV_VERSION_ATLEAST(1, 9)

  256.     av_log(avctx, AV_LOG_VERBOSE,

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

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

  259. #endif

  260. #endif

  261. 

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

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

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

  265.         av_log(avctx, AV_LOG_VERBOSE,

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

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

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

  269.     }

  270. 

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

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

  273. 

  274. }

  275. 

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

  277. {

  278.     const char *rc_desc;

  279.     mfxU16      rc_mode;

  280. 

  281.     int want_la     = q->look_ahead;

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

  283.     int want_vcm    = q->vcm;

  284. 

  285.     if (want_la && !QSV_HAVE_LA) {

  286.         av_log(avctx, AV_LOG_ERROR,

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

  288.         return AVERROR(ENOSYS);

  289.     }

  290.     if (want_vcm && !QSV_HAVE_VCM) {

  291.         av_log(avctx, AV_LOG_ERROR,

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

  293.         return AVERROR(ENOSYS);

  294.     }

  295. 

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

  297.         av_log(avctx, AV_LOG_ERROR,

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

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

  300.         return AVERROR(EINVAL);

  301.     }

  302. 

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

  304.         av_log(avctx, AV_LOG_ERROR,

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

  306.         return AVERROR(ENOSYS);

  307.     }

  308. 

  309.     if (want_qscale) {

  310.         rc_mode = MFX_RATECONTROL_CQP;

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

  312.     }

  313. #if QSV_HAVE_VCM

  314.     else if (want_vcm) {

  315.         rc_mode = MFX_RATECONTROL_VCM;

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

  317.     }

  318. #endif

  319. #if QSV_HAVE_LA

  320.     else if (want_la) {

  321.         rc_mode = MFX_RATECONTROL_LA;

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

  323. 

  324. #if QSV_HAVE_ICQ

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

  326.             rc_mode = MFX_RATECONTROL_LA_ICQ;

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

  328.         }

  329. #endif

  330.     }

  331. #endif

  332. #if QSV_HAVE_ICQ

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

  334.         rc_mode = MFX_RATECONTROL_ICQ;

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

  336.     }

  337. #endif

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

  339.         rc_mode = MFX_RATECONTROL_CBR;

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

  341.     }

  342. #if QSV_HAVE_AVBR

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

  344.         rc_mode = MFX_RATECONTROL_AVBR;

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

  346.     }

  347. #endif

  348.     else {

  349.         rc_mode = MFX_RATECONTROL_VBR;

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

  351.     }

  352. 

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

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

  355. 

  356.     return 0;

  357. }

  358. 

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

  360. {

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

  362.     mfxStatus ret;

  363. 

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

  365. 

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

  367. 

  368.     if (ret < 0) {

  369.         if (UNMATCH(CodecId))

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

  371.         if (UNMATCH(CodecProfile))

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

  373.         if (UNMATCH(RateControlMethod))

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

  375.         if (UNMATCH(LowPower))

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

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

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

  379.         if (UNMATCH(FrameInfo.PicStruct))

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

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

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

  383.         if (UNMATCH(FrameInfo.FourCC))

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

  385.         return 0;

  386.     }

  387.     return 1;

  388. }

  389. 

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

  391. {

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

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

  394.     const AVPixFmtDescriptor *desc;

  395.     int ret;

  396. 

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

  398.     if (ret < 0)

  399.         return AVERROR_BUG;

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

  401. 

  402.     if (avctx->level > 0)

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

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

  405. 

  406.     desc = av_pix_fmt_desc_get(sw_format);

  407.     if (!desc)

  408.         return AVERROR_BUG;

  409. 

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

  411. 

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

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

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

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

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

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

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

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

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

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

  422. 

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

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

  425. 

  426.     if (avctx->hw_frames_ctx) {

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

  428.         AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;

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

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

  431.     }

  432. 

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

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

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

  436.     } else {

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

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

  439.     }

  440. 

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

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

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

  444. 

  445.     return 0;

  446. }

  447. 

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

  449. {

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

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

  452.     const AVPixFmtDescriptor *desc;

  453.     float quant;

  454.     int ret;

  455.     mfxVersion ver;

  456. 

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

  458.     if (ret != MFX_ERR_NONE) {

  459.         av_log(avctx, AV_LOG_ERROR, "Error getting the session handle\n");

  460.         return AVERROR_UNKNOWN;

  461.     }

  462. 

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

  464.     if (ret < 0)

  465.         return AVERROR_BUG;

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

  467. 

  468.     if (avctx->level > 0)

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

  470. 

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

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

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

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

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

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

  477.                     MFX_TARGETUSAGE_BEST_SPEED, MFX_TARGETUSAGE_BEST_SPEED);

  478.             avctx->compression_level = MFX_TARGETUSAGE_BEST_SPEED;

  479.         }

  480.     }

  481. 

  482. #if QSV_HAVE_VDENC

  483.     q->param.mfx.LowPower           = q->low_power ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;

  484. #endif

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

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

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

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

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

  490.                                       MFX_GOP_CLOSED : 0;

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

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

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

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

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

  496. 

  497.     desc = av_pix_fmt_desc_get(sw_format);

  498.     if (!desc)

  499.         return AVERROR_BUG;

  500. 

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

  502. 

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

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

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

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

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

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

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

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

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

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

  513. 

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

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

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

  517.                       QSV_RUNTIME_VERSION_ATLEAST(ver, 1, 19)) ? 16 : 32;

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

  519. 

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

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

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

  523.         // of incompatible video parameter errors

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

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

  526.         q->height_align = 32;

  527.     } else {

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

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

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

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

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

  533.     }

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

  535. 

  536.     if (avctx->hw_frames_ctx) {

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

  538.         AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;

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

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

  541.     }

  542. 

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

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

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

  546.     } else {

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

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

  549.     }

  550. 

  551.     ret = select_rc_mode(avctx, q);

  552.     if (ret < 0)

  553.         return ret;

  554. 

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

  556.     case MFX_RATECONTROL_CBR:

  557.     case MFX_RATECONTROL_VBR:

  558. #if QSV_HAVE_VCM

  559.     case MFX_RATECONTROL_VCM:

  560. #endif

  561.         q->param.mfx.BufferSizeInKB   = avctx->rc_buffer_size / 8000;

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

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

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

  565.         break;

  566.     case MFX_RATECONTROL_CQP:

  567.         quant = avctx->global_quality / FF_QP2LAMBDA;

  568. 

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

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

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

  572. 

  573.         break;

  574. #if QSV_HAVE_AVBR

  575.     case MFX_RATECONTROL_AVBR:

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

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

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

  579.         break;

  580. #endif

  581. #if QSV_HAVE_LA

  582.     case MFX_RATECONTROL_LA:

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

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

  585.         break;

  586. #if QSV_HAVE_ICQ

  587.     case MFX_RATECONTROL_LA_ICQ:

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

  589.     case MFX_RATECONTROL_ICQ:

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

  591.         break;

  592. #endif

  593. #endif

  594.     }

  595. 

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

  597.     // are provided

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

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

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

  601. 

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

  603.                                         MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;

  604. 

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

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

  607. 

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

  609. #if FF_API_CODER_TYPE

  610. FF_DISABLE_DEPRECATION_WARNINGS

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

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

  613. FF_ENABLE_DEPRECATION_WARNINGS

  614. #endif

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

  616.                                       : MFX_CODINGOPTION_UNKNOWN;

  617. 

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

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

  620.                                              MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;

  621. 

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

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

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

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

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

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

  628.         }

  629. 

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

  631. 

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

  633. #if QSV_HAVE_CO2

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

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

  636. 

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

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

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

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

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

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

  643. 

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

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

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

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

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

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

  650. 

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

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

  653. #if QSV_HAVE_MAX_SLICE_SIZE

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

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

  656. #endif

  657. 

  658. #if QSV_HAVE_TRELLIS

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

  660. #endif

  661. 

  662. #if QSV_VERSION_ATLEAST(1, 8)

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

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

  665. 

  666. #if FF_API_PRIVATE_OPT

  667. FF_DISABLE_DEPRECATION_WARNINGS

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

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

  670. FF_ENABLE_DEPRECATION_WARNINGS

  671. #endif

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

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

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

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

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

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

  678. #endif

  679. 

  680. #if QSV_VERSION_ATLEAST(1, 9)

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

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

  683.                 return AVERROR(EINVAL);

  684.             }

  685.             if (avctx->qmin >= 0) {

  686.                 q->extco2.MinQPI = avctx->qmin > 51 ? 51 : avctx->qmin;

  687.                 q->extco2.MinQPP = q->extco2.MinQPB = q->extco2.MinQPI;

  688.             }

  689.             if (avctx->qmax >= 0) {

  690.                 q->extco2.MaxQPI = avctx->qmax > 51 ? 51 : avctx->qmax;

  691.                 q->extco2.MaxQPP = q->extco2.MaxQPB = q->extco2.MaxQPI;

  692.             }

  693. #endif

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

  695. #endif

  696. 

  697. #if QSV_HAVE_MF

  698.             if (QSV_RUNTIME_VERSION_ATLEAST(ver, 1, 25)) {

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

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

  701. 

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

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

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

  705.             }

  706. #endif

  707.         }

  708.     }

  709. 

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

  711.         av_log(avctx, AV_LOG_ERROR,

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

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

  714.         return AVERROR(ENOSYS);

  715.     }

  716. 

  717.     return 0;

  718. }

  719. 

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

  721. {

  722.     int ret = 0;

  723. 

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

  725.     if (ret < 0)

  726.         return ff_qsv_print_error(avctx, ret,

  727.                                   "Error calling GetVideoParam");

  728. 

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

  730. 

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

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

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

  734. 

  735.     return 0;

  736. }

  737. 

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

  739. {

  740.     AVCPBProperties *cpb_props;

  741. 

  742.     uint8_t sps_buf[128];

  743.     uint8_t pps_buf[128];

  744. 

  745.     mfxExtCodingOptionSPSPPS extradata = {

  746.         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,

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

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

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

  750.     };

  751. 

  752.     mfxExtCodingOption co = {

  753.         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,

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

  755.     };

  756. #if QSV_HAVE_CO2

  757.     mfxExtCodingOption2 co2 = {

  758.         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,

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

  760.     };

  761. #endif

  762. 

  763.     mfxExtBuffer *ext_buffers[] = {

  764.         (mfxExtBuffer*)&extradata,

  765.         (mfxExtBuffer*)&co,

  766. #if QSV_HAVE_CO2

  767.         (mfxExtBuffer*)&co2,

  768. #endif

  769.     };

  770. 

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

  772.     int ret;

  773. 

  774.     q->param.ExtParam    = ext_buffers;

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

  776. 

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

  778.     if (ret < 0)

  779.         return ff_qsv_print_error(avctx, ret,

  780.                                   "Error calling GetVideoParam");

  781. 

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

  783. 

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

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

  786.         return AVERROR_UNKNOWN;

  787.     }

  788. 

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

  790.                                  AV_INPUT_BUFFER_PADDING_SIZE);

  791.     if (!avctx->extradata)

  792.         return AVERROR(ENOMEM);

  793. 

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

  795.     if (need_pps)

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

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

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

  799. 

  800.     cpb_props = ff_add_cpb_side_data(avctx);

  801.     if (!cpb_props)

  802.         return AVERROR(ENOMEM);

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

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

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

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

  807. 

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

  809. 

  810.     return 0;

  811. }

  812. 

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

  814. {

  815.     AVQSVContext *qsv = avctx->hwaccel_context;

  816.     mfxFrameSurface1 *surfaces;

  817.     int nb_surfaces, i;

  818. 

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

  820. 

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

  822.     if (!q->opaque_alloc_buf)

  823.         return AVERROR(ENOMEM);

  824. 

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

  826.     if (!q->opaque_surfaces)

  827.         return AVERROR(ENOMEM);

  828. 

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

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

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

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

  833.     }

  834. 

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

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

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

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

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

  840. 

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

  842. 

  843.     qsv->nb_opaque_surfaces = nb_surfaces;

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

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

  846. 

  847.     return 0;

  848. }

  849. 

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

  851. {

  852.     int ret;

  853. 

  854.     if (avctx->hwaccel_context) {

  855.         AVQSVContext *qsv = avctx->hwaccel_context;

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

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

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

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

  860.             return AVERROR(ENOMEM);

  861. 

  862.         ret = ff_qsv_init_session_frames(avctx, &q->internal_session,

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

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

  865.         if (ret < 0) {

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

  867.             return ret;

  868.         }

  869. 

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

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

  872.         ret = ff_qsv_init_session_device(avctx, &q->internal_session,

  873.                                          avctx->hw_device_ctx, q->load_plugins);

  874.         if (ret < 0)

  875.             return ret;

  876. 

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

  878.     } else {

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

  880.                                            q->load_plugins);

  881.         if (ret < 0)

  882.             return ret;

  883. 

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

  885.     }

  886. 

  887.     return 0;

  888. }

  889. 

  890. static inline unsigned int qsv_fifo_item_size(void)

  891. {

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

  893. }

  894. 

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

  896. {

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

  898. }

  899. 

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

  901. {

  902.     int iopattern = 0;

  903.     int opaque_alloc = 0;

  904.     int ret;

  905. 

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

  907. 

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

  909.     if (!q->async_fifo)

  910.         return AVERROR(ENOMEM);

  911. 

  912.     if (avctx->hwaccel_context) {

  913.         AVQSVContext *qsv = avctx->hwaccel_context;

  914. 

  915.         iopattern    = qsv->iopattern;

  916.         opaque_alloc = qsv->opaque_alloc;

  917.     }

  918. 

  919.     if (avctx->hw_frames_ctx) {

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

  921.         AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;

  922. 

  923.         if (!iopattern) {

  924.             if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)

  925.                 iopattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY;

  926.             else if (frames_hwctx->frame_type &

  927.                      (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))

  928.                 iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;

  929.         }

  930.     }

  931. 

  932.     if (!iopattern)

  933.         iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;

  934.     q->param.IOPattern = iopattern;

  935. 

  936.     ret = qsvenc_init_session(avctx, q);

  937.     if (ret < 0)

  938.         return ret;

  939. 

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

  941.     switch (avctx->codec_id) {

  942.     case AV_CODEC_ID_MJPEG:

  943.         ret = init_video_param_jpeg(avctx, q);

  944.         break;

  945.     default:

  946.         ret = init_video_param(avctx, q);

  947.         break;

  948.     }

  949.     if (ret < 0)

  950.         return ret;

  951. 

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

  953.     if (ret == MFX_WRN_PARTIAL_ACCELERATION) {

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

  955.     } else if (ret < 0) {

  956.         return ff_qsv_print_error(avctx, ret,

  957.                                   "Error querying encoder params");

  958.     }

  959. 

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

  961.     if (ret < 0)

  962.         return ff_qsv_print_error(avctx, ret,

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

  964. 

  965.     if (opaque_alloc) {

  966.         ret = qsv_init_opaque_alloc(avctx, q);

  967.         if (ret < 0)

  968.             return ret;

  969.     }

  970. 

  971.     if (avctx->hwaccel_context) {

  972.         AVQSVContext *qsv = avctx->hwaccel_context;

  973.         int i, j;

  974. 

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

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

  977.         if (!q->extparam)

  978.             return AVERROR(ENOMEM);

  979. 

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

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

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

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

  984. 

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

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

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

  988.                     break;

  989.             }

  990.             if (j < qsv->nb_ext_buffers)

  991.                 continue;

  992. 

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

  994.         }

  995.     } else {

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

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

  998.     }

  999. 

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

  1001.     if (ret < 0)

  1002.         return ff_qsv_print_error(avctx, ret,

  1003.                                   "Error initializing the encoder");

  1004.     else if (ret > 0)

  1005.         ff_qsv_print_warning(avctx, ret,

  1006.                              "Warning in encoder initialization");

  1007. 

  1008.     switch (avctx->codec_id) {

  1009.     case AV_CODEC_ID_MJPEG:

  1010.         ret = qsv_retrieve_enc_jpeg_params(avctx, q);

  1011.         break;

  1012.     default:

  1013.         ret = qsv_retrieve_enc_params(avctx, q);

  1014.         break;

  1015.     }

  1016.     if (ret < 0) {

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

  1018.         return ret;

  1019.     }

  1020. 

  1021.     q->avctx = avctx;

  1022. 

  1023.     return 0;

  1024. }

  1025. 

  1026. static void free_encoder_ctrl_payloads(mfxEncodeCtrl* enc_ctrl)

  1027. {

  1028.     if (enc_ctrl) {

  1029.         int i;

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

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

  1032.         }

  1033.         enc_ctrl->NumPayload = 0;

  1034.     }

  1035. }

  1036. 

  1037. static void clear_unused_frames(QSVEncContext *q)

  1038. {

  1039.     QSVFrame *cur = q->work_frames;

  1040.     while (cur) {

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

  1042.             free_encoder_ctrl_payloads(&cur->enc_ctrl);

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

  1044.                 av_frame_unref(cur->frame);

  1045.             }

  1046.             cur->used = 0;

  1047.         }

  1048.         cur = cur->next;

  1049.     }

  1050. }

  1051. 

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

  1053. {

  1054.     QSVFrame *frame, **last;

  1055. 

  1056.     clear_unused_frames(q);

  1057. 

  1058.     frame = q->work_frames;

  1059.     last  = &q->work_frames;

  1060.     while (frame) {

  1061.         if (!frame->used) {

  1062.             *f = frame;

  1063.             frame->used = 1;

  1064.             return 0;

  1065.         }

  1066. 

  1067.         last  = &frame->next;

  1068.         frame = frame->next;

  1069.     }

  1070. 

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

  1072.     if (!frame)

  1073.         return AVERROR(ENOMEM);

  1074.     frame->frame = av_frame_alloc();

  1075.     if (!frame->frame) {

  1076.         av_freep(&frame);

  1077.         return AVERROR(ENOMEM);

  1078.     }

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

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

  1081.         av_freep(&frame);

  1082.         return AVERROR(ENOMEM);

  1083.     }

  1084.     *last = frame;

  1085. 

  1086.     *f = frame;

  1087.     frame->used = 1;

  1088. 

  1089.     return 0;

  1090. }

  1091. 

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

  1093.                         QSVFrame **new_frame)

  1094. {

  1095.     QSVFrame *qf;

  1096.     int ret;

  1097. 

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

  1099.     if (ret < 0)

  1100.         return ret;

  1101. 

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

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

  1104.         if (ret < 0)

  1105.             return ret;

  1106. 

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

  1108. 

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

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

  1111.             if (ret < 0)

  1112.                 return ret;

  1113. 

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

  1115.         }

  1116.     } else {

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

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

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

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

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

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

  1123. 

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

  1125. 

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

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

  1128.                 if (ret < 0)

  1129.                     return ret;

  1130.             }

  1131. 

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

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

  1134. 

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

  1136.             if (ret < 0) {

  1137.                 av_frame_unref(qf->frame);

  1138.                 return ret;

  1139.             }

  1140.         } else {

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

  1142.             if (ret < 0)

  1143.                 return ret;

  1144.         }

  1145. 

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

  1147. 

  1148.         qf->surface.Info.PicStruct =

  1149.             !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :

  1150.             frame->top_field_first   ? MFX_PICSTRUCT_FIELD_TFF :

  1151.                                        MFX_PICSTRUCT_FIELD_BFF;

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

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

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

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

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

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

  1158. 

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

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

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

  1162.     }

  1163. 

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

  1165. 

  1166.     *new_frame = qf;

  1167. 

  1168.     return 0;

  1169. }

  1170. 

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

  1172. {

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

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

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

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

  1177.             av_log(avctx, AV_LOG_WARNING,

  1178.                    "Interlaced coding is supported"

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

  1180.     }

  1181. }

  1182. 

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

  1184.                         const AVFrame *frame)

  1185. {

  1186.     AVPacket new_pkt = { 0 };

  1187.     mfxBitstream *bs;

  1188. #if QSV_VERSION_ATLEAST(1, 26)

  1189.     mfxExtAVCEncodedFrameInfo *enc_info;

  1190.     mfxExtBuffer **enc_buf;

  1191. #endif

  1192. 

  1193.     mfxFrameSurface1 *surf = NULL;

  1194.     mfxSyncPoint *sync     = NULL;

  1195.     QSVFrame *qsv_frame = NULL;

  1196.     mfxEncodeCtrl* enc_ctrl = NULL;

  1197.     int ret;

  1198. 

  1199.     if (frame) {

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

  1201.         if (ret < 0) {

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

  1203.             return ret;

  1204.         }

  1205.     }

  1206.     if (qsv_frame) {

  1207.         surf = &qsv_frame->surface;

  1208.         enc_ctrl = &qsv_frame->enc_ctrl;

  1209.         memset(enc_ctrl, 0, sizeof(mfxEncodeCtrl));

  1210. 

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

  1212.             enc_ctrl->FrameType = MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF;

  1213.             if (q->forced_idr)

  1214.                 enc_ctrl->FrameType |= MFX_FRAMETYPE_IDR;

  1215.         }

  1216.     }

  1217. 

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

  1219.     if (ret < 0) {

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

  1221.         return ret;

  1222.     }

  1223. 

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

  1225.     if (!bs) {

  1226.         av_packet_unref(&new_pkt);

  1227.         return AVERROR(ENOMEM);

  1228.     }

  1229.     bs->Data      = new_pkt.data;

  1230.     bs->MaxLength = new_pkt.size;

  1231. 

  1232. #if QSV_VERSION_ATLEAST(1, 26)

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

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

  1235.         if (!enc_info)

  1236.             return AVERROR(ENOMEM);

  1237. 

  1238.         enc_info->Header.BufferId = MFX_EXTBUFF_ENCODED_FRAME_INFO;

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

  1240.         bs->NumExtParam = 1;

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

  1242.         if (!enc_buf)

  1243.             return AVERROR(ENOMEM);

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

  1245. 

  1246.         bs->ExtParam = enc_buf;

  1247.     }

  1248. #endif

  1249. 

  1250.     if (q->set_encode_ctrl_cb) {

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

  1252.     }

  1253. 

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

  1255.     if (!sync) {

  1256.         av_freep(&bs);

  1257.  #if QSV_VERSION_ATLEAST(1, 26)

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

  1259.             av_freep(&enc_info);

  1260.             av_freep(&enc_buf);

  1261.         }

  1262.  #endif

  1263.         av_packet_unref(&new_pkt);

  1264.         return AVERROR(ENOMEM);

  1265.     }

  1266. 

  1267.     do {

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

  1269.         if (ret == MFX_WRN_DEVICE_BUSY)

  1270.             av_usleep(500);

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

  1272. 

  1273.     if (ret > 0)

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

  1275. 

  1276.     if (ret < 0) {

  1277.         av_packet_unref(&new_pkt);

  1278.         av_freep(&bs);

  1279. #if QSV_VERSION_ATLEAST(1, 26)

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

  1281.             av_freep(&enc_info);

  1282.             av_freep(&enc_buf);

  1283.         }

  1284. #endif

  1285.         av_freep(&sync);

  1286.         return (ret == MFX_ERR_MORE_DATA) ?

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

  1288.     }

  1289. 

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

  1291.         print_interlace_msg(avctx, q);

  1292. 

  1293.     if (*sync) {

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

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

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

  1297.     } else {

  1298.         av_freep(&sync);

  1299.         av_packet_unref(&new_pkt);

  1300.         av_freep(&bs);

  1301. #if QSV_VERSION_ATLEAST(1, 26)

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

  1303.             av_freep(&enc_info);

  1304.             av_freep(&enc_buf);

  1305.         }

  1306. #endif

  1307.     }

  1308. 

  1309.     return 0;

  1310. }

  1311. 

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

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

  1314. {

  1315.     int ret;

  1316. 

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

  1318.     if (ret < 0)

  1319.         return ret;

  1320. 

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

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

  1323.         AVPacket new_pkt;

  1324.         mfxBitstream *bs;

  1325.         mfxSyncPoint *sync;

  1326. #if QSV_VERSION_ATLEAST(1, 26)

  1327.         mfxExtAVCEncodedFrameInfo *enc_info;

  1328.         mfxExtBuffer **enc_buf;

  1329. #endif

  1330.         enum AVPictureType pict_type;

  1331. 

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

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

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

  1335. 

  1336.         do {

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

  1338.         } while (ret == MFX_WRN_IN_EXECUTION);

  1339. 

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

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

  1342.         new_pkt.size = bs->DataLength;

  1343. 

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

  1345.             bs->FrameType & MFX_FRAMETYPE_xIDR)

  1346.             new_pkt.flags |= AV_PKT_FLAG_KEY;

  1347. 

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

  1349.             pict_type = AV_PICTURE_TYPE_I;

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

  1351.             pict_type = AV_PICTURE_TYPE_P;

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

  1353.             pict_type = AV_PICTURE_TYPE_B;

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

  1355.             pict_type = AV_PICTURE_TYPE_NONE;

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

  1357.         } else {

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

  1359.             return AVERROR_INVALIDDATA;

  1360.         }

  1361. 

  1362. #if FF_API_CODED_FRAME

  1363. FF_DISABLE_DEPRECATION_WARNINGS

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

  1365. FF_ENABLE_DEPRECATION_WARNINGS

  1366. #endif

  1367. 

  1368. #if QSV_VERSION_ATLEAST(1, 26)

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

  1370.             enc_buf = bs->ExtParam;

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

  1372.             ff_side_data_set_encoder_stats(&new_pkt,

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

  1374.             av_freep(&enc_info);

  1375.             av_freep(&enc_buf);

  1376.         }

  1377. #endif

  1378.         av_freep(&bs);

  1379.         av_freep(&sync);

  1380. 

  1381.         if (pkt->data) {

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

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

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

  1385.                 av_packet_unref(&new_pkt);

  1386.                 return AVERROR(EINVAL);

  1387.             }

  1388. 

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

  1390.             pkt->size = new_pkt.size;

  1391. 

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

  1393.             av_packet_unref(&new_pkt);

  1394.             if (ret < 0)

  1395.                 return ret;

  1396.         } else

  1397.             *pkt = new_pkt;

  1398. 

  1399.         *got_packet = 1;

  1400.     }

  1401. 

  1402.     return 0;

  1403. }

  1404. 

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

  1406. {

  1407.     QSVFrame *cur;

  1408. 

  1409.     if (q->session)

  1410.         MFXVideoENCODE_Close(q->session);

  1411.     if (q->internal_session)

  1412.         MFXClose(q->internal_session);

  1413.     q->session          = NULL;

  1414.     q->internal_session = NULL;

  1415. 

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

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

  1418. 

  1419.     cur = q->work_frames;

  1420.     while (cur) {

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

  1422.         av_frame_free(&cur->frame);

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

  1424.         av_freep(&cur);

  1425.         cur = q->work_frames;

  1426.     }

  1427. 

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

  1429.         AVPacket pkt;

  1430.         mfxSyncPoint *sync;

  1431.         mfxBitstream *bs;

  1432. 

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

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

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

  1436. 

  1437.         av_freep(&sync);

  1438.         av_freep(&bs);

  1439.         av_packet_unref(&pkt);

  1440.     }

  1441.     av_fifo_free(q->async_fifo);

  1442.     q->async_fifo = NULL;

  1443. 

  1444.     av_freep(&q->opaque_surfaces);

  1445.     av_buffer_unref(&q->opaque_alloc_buf);

  1446. 

  1447.     av_freep(&q->extparam);

  1448. 

  1449.     return 0;

  1450. }