git.sesse.net Git - ffmpeg/blob - libavcodec/qsvenc.c

   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/mem.h"
  30 #include "libavutil/log.h"
  31 #include "libavutil/time.h"
  32 #include "libavutil/imgutils.h"
  33 #include "libavcodec/bytestream.h"
  34
  35 #include "avcodec.h"
  36 #include "internal.h"
  37 #include "qsv.h"
  38 #include "qsv_internal.h"
  39 #include "qsvenc.h"
  40
  41 static const struct {
  42     mfxU16 profile;
  43     const char *name;
  44 } profile_names[] = {
  45     { MFX_PROFILE_AVC_BASELINE,                 "baseline"              },
  46     { MFX_PROFILE_AVC_MAIN,                     "main"                  },
  47     { MFX_PROFILE_AVC_EXTENDED,                 "extended"              },
  48     { MFX_PROFILE_AVC_HIGH,                     "high"                  },
  49 #if QSV_VERSION_ATLEAST(1, 15)
  50     { MFX_PROFILE_AVC_HIGH_422,                 "high 422"              },
  51 #endif
  52 #if QSV_VERSION_ATLEAST(1, 4)
  53     { MFX_PROFILE_AVC_CONSTRAINED_BASELINE,     "constrained baseline"  },
  54     { MFX_PROFILE_AVC_CONSTRAINED_HIGH,         "constrained high"      },
  55     { MFX_PROFILE_AVC_PROGRESSIVE_HIGH,         "progressive high"      },
  56 #endif
  57     { MFX_PROFILE_MPEG2_SIMPLE,                 "simple"                },
  58     { MFX_PROFILE_MPEG2_MAIN,                   "main"                  },
  59     { MFX_PROFILE_MPEG2_HIGH,                   "high"                  },
  60     { MFX_PROFILE_VC1_SIMPLE,                   "simple"                },
  61     { MFX_PROFILE_VC1_MAIN,                     "main"                  },
  62     { MFX_PROFILE_VC1_ADVANCED,                 "advanced"              },
  63 #if QSV_VERSION_ATLEAST(1, 8)
  64     { MFX_PROFILE_HEVC_MAIN,                    "main"                  },
  65     { MFX_PROFILE_HEVC_MAIN10,                  "main10"                },
  66     { MFX_PROFILE_HEVC_MAINSP,                  "mainsp"                },
  67 #endif
  68 };
  69
  70 static const char *print_profile(mfxU16 profile)
  71 {
  72     int i;
  73     for (i = 0; i < FF_ARRAY_ELEMS(profile_names); i++)
  74         if (profile == profile_names[i].profile)
  75             return profile_names[i].name;
  76     return "unknown";
  77 }
  78
  79 static const struct {
  80     mfxU16      rc_mode;
  81     const char *name;
  82 } rc_names[] = {
  83     { MFX_RATECONTROL_CBR,     "CBR" },
  84     { MFX_RATECONTROL_VBR,     "VBR" },
  85     { MFX_RATECONTROL_CQP,     "CQP" },
  86     { MFX_RATECONTROL_AVBR,    "AVBR" },
  87 #if QSV_HAVE_LA
  88     { MFX_RATECONTROL_LA,      "LA" },
  89 #endif
  90 #if QSV_HAVE_ICQ
  91     { MFX_RATECONTROL_ICQ,     "ICQ" },
  92     { MFX_RATECONTROL_LA_ICQ,  "LA_ICQ" },
  93 #endif
  94 #if QSV_HAVE_VCM
  95     { MFX_RATECONTROL_VCM,     "VCM" },
  96 #endif
  97 #if QSV_VERSION_ATLEAST(1, 10)
  98     { MFX_RATECONTROL_LA_EXT,  "LA_EXT" },
  99 #endif
 100 #if QSV_HAVE_LA_HRD
 101     { MFX_RATECONTROL_LA_HRD,  "LA_HRD" },
 102 #endif
 103 #if QSV_HAVE_QVBR
 104     { MFX_RATECONTROL_QVBR,    "QVBR" },
 105 #endif
 106 };
 107
 108 static const char *print_ratecontrol(mfxU16 rc_mode)
 109 {
 110     int i;
 111     for (i = 0; i < FF_ARRAY_ELEMS(rc_names); i++)
 112         if (rc_mode == rc_names[i].rc_mode)
 113             return rc_names[i].name;
 114     return "unknown";
 115 }
 116
 117 static const char *print_threestate(mfxU16 val)
 118 {
 119     if (val == MFX_CODINGOPTION_ON)
 120         return "ON";
 121     else if (val == MFX_CODINGOPTION_OFF)
 122         return "OFF";
 123     return "unknown";
 124 }
 125
 126 static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q,
 127                              mfxExtBuffer **coding_opts)
 128 {
 129     mfxInfoMFX *info = &q->param.mfx;
 130
 131     mfxExtCodingOption   *co = (mfxExtCodingOption*)coding_opts[0];
 132 #if QSV_HAVE_CO2
 133     mfxExtCodingOption2 *co2 = (mfxExtCodingOption2*)coding_opts[1];
 134 #endif
 135 #if QSV_HAVE_CO3
 136     mfxExtCodingOption3 *co3 = (mfxExtCodingOption3*)coding_opts[2];
 137 #endif
 138
 139     av_log(avctx, AV_LOG_VERBOSE, "profile: %s; level: %"PRIu16"\n",
 140            print_profile(info->CodecProfile), info->CodecLevel);
 141
 142     av_log(avctx, AV_LOG_VERBOSE, "GopPicSize: %"PRIu16"; GopRefDist: %"PRIu16"; GopOptFlag: ",
 143            info->GopPicSize, info->GopRefDist);
 144     if (info->GopOptFlag & MFX_GOP_CLOSED)
 145         av_log(avctx, AV_LOG_VERBOSE, "closed ");
 146     if (info->GopOptFlag & MFX_GOP_STRICT)
 147         av_log(avctx, AV_LOG_VERBOSE, "strict ");
 148     av_log(avctx, AV_LOG_VERBOSE, "; IdrInterval: %"PRIu16"\n", info->IdrInterval);
 149
 150     av_log(avctx, AV_LOG_VERBOSE, "TargetUsage: %"PRIu16"; RateControlMethod: %s\n",
 151            info->TargetUsage, print_ratecontrol(info->RateControlMethod));
 152
 153     if (info->RateControlMethod == MFX_RATECONTROL_CBR ||
 154         info->RateControlMethod == MFX_RATECONTROL_VBR
 155 #if QSV_HAVE_VCM
 156         || info->RateControlMethod == MFX_RATECONTROL_VCM
 157 #endif
 158         ) {
 159         av_log(avctx, AV_LOG_VERBOSE,
 160                "InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"\n",
 161                info->InitialDelayInKB, info->TargetKbps, info->MaxKbps);
 162     } else if (info->RateControlMethod == MFX_RATECONTROL_CQP) {
 163         av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",
 164                info->QPI, info->QPP, info->QPB);
 165     } else if (info->RateControlMethod == MFX_RATECONTROL_AVBR) {
 166         av_log(avctx, AV_LOG_VERBOSE,
 167                "TargetKbps: %"PRIu16"; Accuracy: %"PRIu16"; Convergence: %"PRIu16"\n",
 168                info->TargetKbps, info->Accuracy, info->Convergence);
 169     }
 170 #if QSV_HAVE_LA
 171     else if (info->RateControlMethod == MFX_RATECONTROL_LA
 172 #if QSV_HAVE_LA_HRD
 173              || info->RateControlMethod == MFX_RATECONTROL_LA_HRD
 174 #endif
 175              ) {
 176         av_log(avctx, AV_LOG_VERBOSE,
 177                "TargetKbps: %"PRIu16"; LookAheadDepth: %"PRIu16"\n",
 178                info->TargetKbps, co2->LookAheadDepth);
 179     }
 180 #endif
 181 #if QSV_HAVE_ICQ
 182     else if (info->RateControlMethod == MFX_RATECONTROL_ICQ) {
 183         av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);
 184     } else if (info->RateControlMethod == MFX_RATECONTROL_LA_ICQ) {
 185         av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"; LookAheadDepth: %"PRIu16"\n",
 186                info->ICQQuality, co2->LookAheadDepth);
 187     }
 188 #endif
 189 #if QSV_HAVE_QVBR
 190     else if (info->RateControlMethod == MFX_RATECONTROL_QVBR) {
 191         av_log(avctx, AV_LOG_VERBOSE, "QVBRQuality: %"PRIu16"\n",
 192                co3->QVBRQuality);
 193     }
 194 #endif
 195
 196     av_log(avctx, AV_LOG_VERBOSE, "NumSlice: %"PRIu16"; NumRefFrame: %"PRIu16"\n",
 197            info->NumSlice, info->NumRefFrame);
 198     av_log(avctx, AV_LOG_VERBOSE, "RateDistortionOpt: %s\n",
 199            print_threestate(co->RateDistortionOpt));
 200
 201 #if QSV_HAVE_CO2
 202     av_log(avctx, AV_LOG_VERBOSE,
 203            "RecoveryPointSEI: %s IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16"; IntRefQPDelta: %"PRId16"\n",
 204            print_threestate(co->RecoveryPointSEI), co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);
 205
 206     av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %"PRIu16"; ", co2->MaxFrameSize);
 207 #if QSV_HAVE_MAX_SLICE_SIZE
 208     av_log(avctx, AV_LOG_VERBOSE, "MaxSliceSize: %"PRIu16"; ", co2->MaxSliceSize);
 209 #endif
 210     av_log(avctx, AV_LOG_VERBOSE, "\n");
 211
 212     av_log(avctx, AV_LOG_VERBOSE,
 213            "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
 214            print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),
 215            print_threestate(co2->ExtBRC));
 216
 217 #if QSV_HAVE_TRELLIS
 218     av_log(avctx, AV_LOG_VERBOSE, "Trellis: ");
 219     if (co2->Trellis & MFX_TRELLIS_OFF) {
 220         av_log(avctx, AV_LOG_VERBOSE, "off");
 221     } else if (!co2->Trellis) {
 222         av_log(avctx, AV_LOG_VERBOSE, "auto");
 223     } else {
 224         if (co2->Trellis & MFX_TRELLIS_I) av_log(avctx, AV_LOG_VERBOSE, "I");
 225         if (co2->Trellis & MFX_TRELLIS_P) av_log(avctx, AV_LOG_VERBOSE, "P");
 226         if (co2->Trellis & MFX_TRELLIS_B) av_log(avctx, AV_LOG_VERBOSE, "B");
 227     }
 228     av_log(avctx, AV_LOG_VERBOSE, "\n");
 229 #endif
 230
 231 #if QSV_VERSION_ATLEAST(1, 8)
 232     av_log(avctx, AV_LOG_VERBOSE,
 233            "RepeatPPS: %s; NumMbPerSlice: %"PRIu16"; LookAheadDS: ",
 234            print_threestate(co2->RepeatPPS), co2->NumMbPerSlice);
 235     switch (co2->LookAheadDS) {
 236     case MFX_LOOKAHEAD_DS_OFF: av_log(avctx, AV_LOG_VERBOSE, "off");     break;
 237     case MFX_LOOKAHEAD_DS_2x:  av_log(avctx, AV_LOG_VERBOSE, "2x");      break;
 238     case MFX_LOOKAHEAD_DS_4x:  av_log(avctx, AV_LOG_VERBOSE, "4x");      break;
 239     default:                   av_log(avctx, AV_LOG_VERBOSE, "unknown"); break;
 240     }
 241     av_log(avctx, AV_LOG_VERBOSE, "\n");
 242
 243     av_log(avctx, AV_LOG_VERBOSE, "AdaptiveI: %s; AdaptiveB: %s; BRefType: ",
 244            print_threestate(co2->AdaptiveI), print_threestate(co2->AdaptiveB));
 245     switch (co2->BRefType) {
 246     case MFX_B_REF_OFF:     av_log(avctx, AV_LOG_VERBOSE, "off");       break;
 247     case MFX_B_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "pyramid");   break;
 248     default:                av_log(avctx, AV_LOG_VERBOSE, "auto");      break;
 249     }
 250     av_log(avctx, AV_LOG_VERBOSE, "\n");
 251 #endif
 252
 253 #if QSV_VERSION_ATLEAST(1, 9)
 254     av_log(avctx, AV_LOG_VERBOSE,
 255            "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",
 256            co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
 257 #endif
 258 #endif
 259
 260     if (avctx->codec_id == AV_CODEC_ID_H264) {
 261         av_log(avctx, AV_LOG_VERBOSE, "Entropy coding: %s; MaxDecFrameBuffering: %"PRIu16"\n",
 262                co->CAVLC == MFX_CODINGOPTION_ON ? "CAVLC" : "CABAC", co->MaxDecFrameBuffering);
 263         av_log(avctx, AV_LOG_VERBOSE,
 264                "NalHrdConformance: %s; SingleSeiNalUnit: %s; VuiVclHrdParameters: %s VuiNalHrdParameters: %s\n",
 265                print_threestate(co->NalHrdConformance), print_threestate(co->SingleSeiNalUnit),
 266                print_threestate(co->VuiVclHrdParameters), print_threestate(co->VuiNalHrdParameters));
 267     }
 268 }
 269
 270 static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q)
 271 {
 272     const char *rc_desc;
 273     mfxU16      rc_mode;
 274
 275     int want_la     = q->look_ahead;
 276     int want_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
 277     int want_vcm    = q->vcm;
 278
 279     if (want_la && !QSV_HAVE_LA) {
 280         av_log(avctx, AV_LOG_ERROR,
 281                "Lookahead ratecontrol mode requested, but is not supported by this SDK version\n");
 282         return AVERROR(ENOSYS);
 283     }
 284     if (want_vcm && !QSV_HAVE_VCM) {
 285         av_log(avctx, AV_LOG_ERROR,
 286                "VCM ratecontrol mode requested, but is not supported by this SDK version\n");
 287         return AVERROR(ENOSYS);
 288     }
 289
 290     if (want_la + want_qscale + want_vcm > 1) {
 291         av_log(avctx, AV_LOG_ERROR,
 292                "More than one of: { constant qscale, lookahead, VCM } requested, "
 293                "only one of them can be used at a time.\n");
 294         return AVERROR(EINVAL);
 295     }
 296
 297     if (want_qscale) {
 298         rc_mode = MFX_RATECONTROL_CQP;
 299         rc_desc = "constant quantization parameter (CQP)";
 300     }
 301 #if QSV_HAVE_VCM
 302     else if (want_vcm) {
 303         rc_mode = MFX_RATECONTROL_VCM;
 304         rc_desc = "video conferencing mode (VCM)";
 305     }
 306 #endif
 307 #if QSV_HAVE_LA
 308     else if (want_la) {
 309         rc_mode = MFX_RATECONTROL_LA;
 310         rc_desc = "VBR with lookahead (LA)";
 311
 312 #if QSV_HAVE_ICQ
 313         if (avctx->global_quality > 0) {
 314             rc_mode = MFX_RATECONTROL_LA_ICQ;
 315             rc_desc = "intelligent constant quality with lookahead (LA_ICQ)";
 316         }
 317 #endif
 318     }
 319 #endif
 320 #if QSV_HAVE_ICQ
 321     else if (avctx->global_quality > 0) {
 322         rc_mode = MFX_RATECONTROL_ICQ;
 323         rc_desc = "intelligent constant quality (ICQ)";
 324     }
 325 #endif
 326     else if (avctx->rc_max_rate == avctx->bit_rate) {
 327         rc_mode = MFX_RATECONTROL_CBR;
 328         rc_desc = "constant bitrate (CBR)";
 329     } else if (!avctx->rc_max_rate) {
 330         rc_mode = MFX_RATECONTROL_AVBR;
 331         rc_desc = "average variable bitrate (AVBR)";
 332     } else {
 333         rc_mode = MFX_RATECONTROL_VBR;
 334         rc_desc = "variable bitrate (VBR)";
 335     }
 336
 337     q->param.mfx.RateControlMethod = rc_mode;
 338     av_log(avctx, AV_LOG_VERBOSE, "Using the %s ratecontrol method\n", rc_desc);
 339
 340     return 0;
 341 }
 342
 343 static int rc_supported(QSVEncContext *q)
 344 {
 345     mfxVideoParam param_out = { .mfx.CodecId = q->param.mfx.CodecId };
 346     mfxStatus ret;
 347
 348     ret = MFXVideoENCODE_Query(q->session, &q->param, &param_out);
 349     if (ret < 0 ||
 350         param_out.mfx.RateControlMethod != q->param.mfx.RateControlMethod)
 351         return 0;
 352     return 1;
 353 }
 354
 355 static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
 356 {
 357     float quant;
 358     int ret;
 359
 360     ret = ff_qsv_codec_id_to_mfx(avctx->codec_id);
 361     if (ret < 0)
 362         return AVERROR_BUG;
 363     q->param.mfx.CodecId = ret;
 364
 365     q->width_align = avctx->codec_id == AV_CODEC_ID_HEVC ? 32 : 16;
 366
 367     if (avctx->level > 0)
 368         q->param.mfx.CodecLevel = avctx->level;
 369
 370     q->param.mfx.CodecProfile       = q->profile;
 371     q->param.mfx.TargetUsage        = q->preset;
 372     q->param.mfx.GopPicSize         = FFMAX(0, avctx->gop_size);
 373     q->param.mfx.GopRefDist         = FFMAX(-1, avctx->max_b_frames) + 1;
 374     q->param.mfx.GopOptFlag         = avctx->flags & AV_CODEC_FLAG_CLOSED_GOP ?
 375                                       MFX_GOP_CLOSED : 0;
 376     q->param.mfx.IdrInterval        = q->idr_interval;
 377     q->param.mfx.NumSlice           = avctx->slices;
 378     q->param.mfx.NumRefFrame        = FFMAX(0, avctx->refs);
 379     q->param.mfx.EncodedOrder       = 0;
 380     q->param.mfx.BufferSizeInKB     = 0;
 381
 382     q->param.mfx.FrameInfo.FourCC         = MFX_FOURCC_NV12;
 383     q->param.mfx.FrameInfo.CropX          = 0;
 384     q->param.mfx.FrameInfo.CropY          = 0;
 385     q->param.mfx.FrameInfo.CropW          = avctx->width;
 386     q->param.mfx.FrameInfo.CropH          = avctx->height;
 387     q->param.mfx.FrameInfo.AspectRatioW   = avctx->sample_aspect_ratio.num;
 388     q->param.mfx.FrameInfo.AspectRatioH   = avctx->sample_aspect_ratio.den;
 389     q->param.mfx.FrameInfo.ChromaFormat   = MFX_CHROMAFORMAT_YUV420;
 390     q->param.mfx.FrameInfo.BitDepthLuma   = 8;
 391     q->param.mfx.FrameInfo.BitDepthChroma = 8;
 392     q->param.mfx.FrameInfo.Width          = FFALIGN(avctx->width, q->width_align);
 393
 394     if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
 395        /* A true field layout (TFF or BFF) is not important here,
 396           it will specified later during frame encoding. But it is important
 397           to specify is frame progressive or not because allowed heigh alignment
 398           does depend by this.
 399         */
 400         q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_FIELD_TFF;
 401         q->height_align = 32;
 402     } else {
 403         q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
 404         q->height_align = 16;
 405     }
 406    q->param.mfx.FrameInfo.Height    = FFALIGN(avctx->height, q->height_align);
 407
 408     if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
 409         q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
 410         q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
 411     } else {
 412         q->param.mfx.FrameInfo.FrameRateExtN  = avctx->time_base.den;
 413         q->param.mfx.FrameInfo.FrameRateExtD  = avctx->time_base.num;
 414     }
 415
 416     ret = select_rc_mode(avctx, q);
 417     if (ret < 0)
 418         return ret;
 419
 420     switch (q->param.mfx.RateControlMethod) {
 421     case MFX_RATECONTROL_CBR:
 422     case MFX_RATECONTROL_VBR:
 423 #if QSV_HAVE_VCM
 424     case MFX_RATECONTROL_VCM:
 425 #endif
 426         q->param.mfx.InitialDelayInKB = avctx->rc_initial_buffer_occupancy / 1000;
 427         q->param.mfx.TargetKbps       = avctx->bit_rate / 1000;
 428         q->param.mfx.MaxKbps          = avctx->rc_max_rate / 1000;
 429         break;
 430     case MFX_RATECONTROL_CQP:
 431         quant = avctx->global_quality / FF_QP2LAMBDA;
 432
 433         q->param.mfx.QPI = av_clip(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 0, 51);
 434         q->param.mfx.QPP = av_clip(quant, 0, 51);
 435         q->param.mfx.QPB = av_clip(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 0, 51);
 436
 437         break;
 438     case MFX_RATECONTROL_AVBR:
 439         q->param.mfx.TargetKbps  = avctx->bit_rate / 1000;
 440         q->param.mfx.Convergence = q->avbr_convergence;
 441         q->param.mfx.Accuracy    = q->avbr_accuracy;
 442         break;
 443 #if QSV_HAVE_LA
 444     case MFX_RATECONTROL_LA:
 445         q->param.mfx.TargetKbps  = avctx->bit_rate / 1000;
 446         q->extco2.LookAheadDepth = q->look_ahead_depth;
 447         break;
 448 #if QSV_HAVE_ICQ
 449     case MFX_RATECONTROL_LA_ICQ:
 450         q->extco2.LookAheadDepth = q->look_ahead_depth;
 451     case MFX_RATECONTROL_ICQ:
 452         q->param.mfx.ICQQuality  = avctx->global_quality;
 453         break;
 454 #endif
 455 #endif
 456     }
 457
 458     // the HEVC encoder plugin currently fails if coding options
 459     // are provided
 460     if (avctx->codec_id != AV_CODEC_ID_HEVC) {
 461         q->extco.Header.BufferId      = MFX_EXTBUFF_CODING_OPTION;
 462         q->extco.Header.BufferSz      = sizeof(q->extco);
 463 #if FF_API_CODER_TYPE
 464 FF_DISABLE_DEPRECATION_WARNINGS
 465         if (avctx->coder_type != 0)
 466             q->cavlc = avctx->coder_type == FF_CODER_TYPE_VLC;
 467 FF_ENABLE_DEPRECATION_WARNINGS
 468 #endif
 469         q->extco.CAVLC = q->cavlc ? MFX_CODINGOPTION_ON
 470                                   : MFX_CODINGOPTION_UNKNOWN;
 471
 472         q->extco.PicTimingSEI         = q->pic_timing_sei ?
 473                                         MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;
 474
 475         if (q->rdo >= 0)
 476             q->extco.RateDistortionOpt = q->rdo > 0 ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
 477
 478         if (avctx->codec_id == AV_CODEC_ID_H264) {
 479             if (avctx->strict_std_compliance != FF_COMPLIANCE_NORMAL)
 480                 q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?
 481                                              MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
 482
 483             if (q->single_sei_nal_unit >= 0)
 484                 q->extco.SingleSeiNalUnit = q->single_sei_nal_unit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
 485             if (q->recovery_point_sei >= 0)
 486                 q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
 487             q->extco.MaxDecFrameBuffering = q->max_dec_frame_buffering;
 488         }
 489
 490         q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco;
 491
 492 #if QSV_HAVE_CO2
 493         if (avctx->codec_id == AV_CODEC_ID_H264) {
 494             q->extco2.Header.BufferId     = MFX_EXTBUFF_CODING_OPTION2;
 495             q->extco2.Header.BufferSz     = sizeof(q->extco2);
 496
 497             if (q->int_ref_type >= 0)
 498                 q->extco2.IntRefType = q->int_ref_type;
 499             if (q->int_ref_cycle_size >= 0)
 500                 q->extco2.IntRefCycleSize = q->int_ref_cycle_size;
 501             if (q->int_ref_qp_delta != INT16_MIN)
 502                 q->extco2.IntRefQPDelta = q->int_ref_qp_delta;
 503
 504             if (q->bitrate_limit >= 0)
 505                 q->extco2.BitrateLimit = q->bitrate_limit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
 506             if (q->mbbrc >= 0)
 507                 q->extco2.MBBRC = q->mbbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
 508             if (q->extbrc >= 0)
 509                 q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
 510
 511             if (q->max_frame_size >= 0)
 512                 q->extco2.MaxFrameSize = q->max_frame_size;
 513 #if QSV_HAVE_MAX_SLICE_SIZE
 514             if (q->max_slice_size >= 0)
 515                 q->extco2.MaxSliceSize = q->max_slice_size;
 516 #endif
 517
 518 #if QSV_HAVE_TRELLIS
 519             q->extco2.Trellis = q->trellis;
 520 #endif
 521
 522 #if QSV_HAVE_BREF_TYPE
 523 #if FF_API_PRIVATE_OPT
 524 FF_DISABLE_DEPRECATION_WARNINGS
 525             if (avctx->b_frame_strategy >= 0)
 526                 q->b_strategy = avctx->b_frame_strategy;
 527 FF_ENABLE_DEPRECATION_WARNINGS
 528 #endif
 529             if (q->b_strategy >= 0)
 530                 q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
 531             if (q->adaptive_i >= 0)
 532                 q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
 533             if (q->adaptive_b >= 0)
 534                 q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
 535 #endif
 536
 537             q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
 538
 539 #if QSV_VERSION_ATLEAST(1,8)
 540             q->extco2.LookAheadDS           = q->look_ahead_downsampling;
 541 #endif
 542         }
 543 #endif
 544     }
 545
 546     if (!rc_supported(q)) {
 547         av_log(avctx, AV_LOG_ERROR,
 548                "Selected ratecontrol mode is not supported by the QSV "
 549                "runtime. Choose a different mode.\n");
 550         return AVERROR(ENOSYS);
 551     }
 552
 553     return 0;
 554 }
 555
 556 static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
 557 {
 558     AVCPBProperties *cpb_props;
 559
 560     uint8_t sps_buf[128];
 561     uint8_t pps_buf[128];
 562
 563     mfxExtCodingOptionSPSPPS extradata = {
 564         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
 565         .Header.BufferSz = sizeof(extradata),
 566         .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),
 567         .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
 568     };
 569
 570     mfxExtCodingOption co = {
 571         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
 572         .Header.BufferSz = sizeof(co),
 573     };
 574 #if QSV_HAVE_CO2
 575     mfxExtCodingOption2 co2 = {
 576         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
 577         .Header.BufferSz = sizeof(co2),
 578     };
 579 #endif
 580 #if QSV_HAVE_CO3
 581     mfxExtCodingOption3 co3 = {
 582         .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
 583         .Header.BufferSz = sizeof(co3),
 584     };
 585 #endif
 586
 587     mfxExtBuffer *ext_buffers[] = {
 588         (mfxExtBuffer*)&extradata,
 589         (mfxExtBuffer*)&co,
 590 #if QSV_HAVE_CO2
 591         (mfxExtBuffer*)&co2,
 592 #endif
 593 #if QSV_HAVE_CO3
 594         (mfxExtBuffer*)&co3,
 595 #endif
 596     };
 597
 598     int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
 599     int ret;
 600
 601     q->param.ExtParam    = ext_buffers;
 602     q->param.NumExtParam = FF_ARRAY_ELEMS(ext_buffers);
 603
 604     ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
 605     if (ret < 0)
 606         return ff_qsv_error(ret);
 607
 608     q->packet_size = q->param.mfx.BufferSizeInKB * 1000;
 609
 610     if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)) {
 611         av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
 612         return AVERROR_UNKNOWN;
 613     }
 614
 615     avctx->extradata = av_malloc(extradata.SPSBufSize + need_pps * extradata.PPSBufSize +
 616                                  AV_INPUT_BUFFER_PADDING_SIZE);
 617     if (!avctx->extradata)
 618         return AVERROR(ENOMEM);
 619
 620     memcpy(avctx->extradata,                        sps_buf, extradata.SPSBufSize);
 621     if (need_pps)
 622         memcpy(avctx->extradata + extradata.SPSBufSize, pps_buf, extradata.PPSBufSize);
 623     avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
 624     memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
 625
 626     cpb_props = ff_add_cpb_side_data(avctx);
 627     if (!cpb_props)
 628         return AVERROR(ENOMEM);
 629     cpb_props->max_bitrate = avctx->rc_max_rate;
 630     cpb_props->min_bitrate = avctx->rc_min_rate;
 631     cpb_props->avg_bitrate = avctx->bit_rate;
 632     cpb_props->buffer_size = avctx->rc_buffer_size;
 633
 634     dump_video_param(avctx, q, ext_buffers + 1);
 635
 636     return 0;
 637 }
 638
 639 static int qsv_init_opaque_alloc(AVCodecContext *avctx, QSVEncContext *q)
 640 {
 641     AVQSVContext *qsv = avctx->hwaccel_context;
 642     mfxFrameSurface1 *surfaces;
 643     int nb_surfaces, i;
 644
 645     nb_surfaces = qsv->nb_opaque_surfaces + q->req.NumFrameSuggested + q->async_depth;
 646
 647     q->opaque_alloc_buf = av_buffer_allocz(sizeof(*surfaces) * nb_surfaces);
 648     if (!q->opaque_alloc_buf)
 649         return AVERROR(ENOMEM);
 650
 651     q->opaque_surfaces = av_malloc_array(nb_surfaces, sizeof(*q->opaque_surfaces));
 652     if (!q->opaque_surfaces)
 653         return AVERROR(ENOMEM);
 654
 655     surfaces = (mfxFrameSurface1*)q->opaque_alloc_buf->data;
 656     for (i = 0; i < nb_surfaces; i++) {
 657         surfaces[i].Info      = q->req.Info;
 658         q->opaque_surfaces[i] = surfaces + i;
 659     }
 660
 661     q->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
 662     q->opaque_alloc.Header.BufferSz = sizeof(q->opaque_alloc);
 663     q->opaque_alloc.In.Surfaces     = q->opaque_surfaces;
 664     q->opaque_alloc.In.NumSurface   = nb_surfaces;
 665     q->opaque_alloc.In.Type         = q->req.Type;
 666
 667     q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->opaque_alloc;
 668
 669     qsv->nb_opaque_surfaces = nb_surfaces;
 670     qsv->opaque_surfaces    = q->opaque_alloc_buf;
 671     qsv->opaque_alloc_type  = q->req.Type;
 672
 673     return 0;
 674 }
 675
 676 int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
 677 {
 678     int opaque_alloc = 0;
 679     int ret;
 680
 681     q->param.IOPattern  = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
 682     q->param.AsyncDepth = q->async_depth;
 683
 684     q->async_fifo = av_fifo_alloc((1 + q->async_depth) *
 685                                   (sizeof(AVPacket) + sizeof(mfxSyncPoint*) + sizeof(mfxBitstream*)));
 686     if (!q->async_fifo)
 687         return AVERROR(ENOMEM);
 688
 689     if (avctx->hwaccel_context) {
 690         AVQSVContext *qsv = avctx->hwaccel_context;
 691
 692         q->session         = qsv->session;
 693         q->param.IOPattern = qsv->iopattern;
 694
 695         opaque_alloc = qsv->opaque_alloc;
 696     }
 697
 698     if (!q->session) {
 699         ret = ff_qsv_init_internal_session(avctx, &q->internal_qs,
 700                                            q->load_plugins);
 701         if (ret < 0)
 702             return ret;
 703
 704         q->session = q->internal_qs.session;
 705     }
 706
 707     ret = init_video_param(avctx, q);
 708     if (ret < 0)
 709         return ret;
 710
 711     ret = MFXVideoENCODE_Query(q->session, &q->param,&q->param);
 712     if (MFX_WRN_PARTIAL_ACCELERATION==ret) {
 713         av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
 714     } else if (ret < 0) {
 715         av_log(avctx, AV_LOG_ERROR, "Error %d querying encoder params\n", ret);
 716         return ff_qsv_error(ret);
 717     }
 718
 719     ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
 720     if (ret < 0) {
 721         av_log(avctx, AV_LOG_ERROR, "Error querying the encoding parameters\n");
 722         return ff_qsv_error(ret);
 723     }
 724
 725     if (opaque_alloc) {
 726         ret = qsv_init_opaque_alloc(avctx, q);
 727         if (ret < 0)
 728             return ret;
 729     }
 730
 731     if (avctx->hwaccel_context) {
 732         AVQSVContext *qsv = avctx->hwaccel_context;
 733         int i, j;
 734
 735         q->extparam = av_mallocz_array(qsv->nb_ext_buffers + q->nb_extparam_internal,
 736                                        sizeof(*q->extparam));
 737         if (!q->extparam)
 738             return AVERROR(ENOMEM);
 739
 740         q->param.ExtParam = q->extparam;
 741         for (i = 0; i < qsv->nb_ext_buffers; i++)
 742             q->param.ExtParam[i] = qsv->ext_buffers[i];
 743         q->param.NumExtParam = qsv->nb_ext_buffers;
 744
 745         for (i = 0; i < q->nb_extparam_internal; i++) {
 746             for (j = 0; j < qsv->nb_ext_buffers; j++) {
 747                 if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)
 748                     break;
 749             }
 750             if (j < qsv->nb_ext_buffers)
 751                 continue;
 752
 753             q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];
 754         }
 755     } else {
 756         q->param.ExtParam    = q->extparam_internal;
 757         q->param.NumExtParam = q->nb_extparam_internal;
 758     }
 759
 760     ret = MFXVideoENCODE_Init(q->session, &q->param);
 761     if (MFX_WRN_PARTIAL_ACCELERATION==ret) {
 762         av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
 763     } else if (ret < 0) {
 764         av_log(avctx, AV_LOG_ERROR, "Error initializing the encoder\n");
 765         return ff_qsv_error(ret);
 766     }
 767
 768     ret = qsv_retrieve_enc_params(avctx, q);
 769     if (ret < 0) {
 770         av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
 771         return ret;
 772     }
 773
 774     q->avctx = avctx;
 775
 776     return 0;
 777 }
 778
 779 static void free_encoder_ctrl_payloads(mfxEncodeCtrl* enc_ctrl)
 780 {
 781     if (enc_ctrl) {
 782         int i;
 783         for (i = 0; i < enc_ctrl->NumPayload && i < QSV_MAX_ENC_PAYLOAD; i++) {
 784             av_free(enc_ctrl->Payload[i]);
 785         }
 786         enc_ctrl->NumPayload = 0;
 787     }
 788 }
 789
 790 static void clear_unused_frames(QSVEncContext *q)
 791 {
 792     QSVFrame *cur = q->work_frames;
 793     while (cur) {
 794         if (cur->surface && !cur->surface->Data.Locked) {
 795             cur->surface = NULL;
 796             free_encoder_ctrl_payloads(&cur->enc_ctrl);
 797             av_frame_unref(cur->frame);
 798         }
 799         cur = cur->next;
 800     }
 801 }
 802
 803 static int get_free_frame(QSVEncContext *q, QSVFrame **f)
 804 {
 805     QSVFrame *frame, **last;
 806
 807     clear_unused_frames(q);
 808
 809     frame = q->work_frames;
 810     last  = &q->work_frames;
 811     while (frame) {
 812         if (!frame->surface) {
 813             *f = frame;
 814             return 0;
 815         }
 816
 817         last  = &frame->next;
 818         frame = frame->next;
 819     }
 820
 821     frame = av_mallocz(sizeof(*frame));
 822     if (!frame)
 823         return AVERROR(ENOMEM);
 824     frame->frame = av_frame_alloc();
 825     if (!frame->frame) {
 826         av_freep(&frame);
 827         return AVERROR(ENOMEM);
 828     }
 829     frame->enc_ctrl.Payload = av_mallocz(sizeof(mfxPayload*) * QSV_MAX_ENC_PAYLOAD);
 830     if (!frame->enc_ctrl.Payload) {
 831         av_freep(&frame);
 832         return AVERROR(ENOMEM);
 833     }
 834     *last = frame;
 835
 836     *f = frame;
 837
 838     return 0;
 839 }
 840
 841 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
 842                         QSVFrame **new_frame)
 843 {
 844     QSVFrame *qf;
 845     int ret;
 846
 847     ret = get_free_frame(q, &qf);
 848     if (ret < 0)
 849         return ret;
 850
 851     if (frame->format == AV_PIX_FMT_QSV) {
 852         ret = av_frame_ref(qf->frame, frame);
 853         if (ret < 0)
 854             return ret;
 855
 856         qf->surface = (mfxFrameSurface1*)qf->frame->data[3];
 857     } else {
 858         /* make a copy if the input is not padded as libmfx requires */
 859         if (     frame->height & (q->height_align - 1) ||
 860             frame->linesize[0] & (q->width_align - 1)) {
 861             qf->frame->height = FFALIGN(frame->height, q->height_align);
 862             qf->frame->width  = FFALIGN(frame->width, q->width_align);
 863
 864             ret = ff_get_buffer(q->avctx, qf->frame, AV_GET_BUFFER_FLAG_REF);
 865             if (ret < 0)
 866                 return ret;
 867
 868             qf->frame->height = frame->height;
 869             qf->frame->width  = frame->width;
 870             ret = av_frame_copy(qf->frame, frame);
 871             if (ret < 0) {
 872                 av_frame_unref(qf->frame);
 873                 return ret;
 874             }
 875         } else {
 876             ret = av_frame_ref(qf->frame, frame);
 877             if (ret < 0)
 878                 return ret;
 879         }
 880
 881         qf->surface_internal.Info = q->param.mfx.FrameInfo;
 882
 883         qf->surface_internal.Info.PicStruct =
 884             !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
 885             frame->top_field_first   ? MFX_PICSTRUCT_FIELD_TFF :
 886                                        MFX_PICSTRUCT_FIELD_BFF;
 887         if (frame->repeat_pict == 1)
 888             qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
 889         else if (frame->repeat_pict == 2)
 890             qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
 891         else if (frame->repeat_pict == 4)
 892             qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
 893
 894         qf->surface_internal.Data.PitchLow  = qf->frame->linesize[0];
 895         qf->surface_internal.Data.Y         = qf->frame->data[0];
 896         qf->surface_internal.Data.UV        = qf->frame->data[1];
 897
 898         qf->surface = &qf->surface_internal;
 899     }
 900
 901     qf->surface->Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
 902
 903     *new_frame = qf;
 904
 905     return 0;
 906 }
 907
 908 static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
 909 {
 910     if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
 911         if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
 912             q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
 913             q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
 914             av_log(avctx, AV_LOG_WARNING,
 915                    "Interlaced coding is supported"
 916                    " at Main/High Profile Level 2.1-4.1\n");
 917     }
 918 }
 919
 920 static int encode_frame(AVCodecContext *avctx, QSVEncContext *q,
 921                         const AVFrame *frame)
 922 {
 923     AVPacket new_pkt = { 0 };
 924     mfxBitstream *bs;
 925
 926     mfxFrameSurface1 *surf = NULL;
 927     mfxSyncPoint *sync      = NULL;
 928     QSVFrame *qsv_frame = NULL;
 929     mfxEncodeCtrl* enc_ctrl = NULL;
 930     int ret;
 931
 932     if (frame) {
 933         ret = submit_frame(q, frame, &qsv_frame);
 934         if (ret < 0) {
 935             av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
 936             return ret;
 937         }
 938     }
 939     if (qsv_frame) {
 940         surf = qsv_frame->surface;
 941         enc_ctrl = &qsv_frame->enc_ctrl;
 942     }
 943
 944     ret = av_new_packet(&new_pkt, q->packet_size);
 945     if (ret < 0) {
 946         av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
 947         return ret;
 948     }
 949
 950     bs = av_mallocz(sizeof(*bs));
 951     if (!bs) {
 952         av_packet_unref(&new_pkt);
 953         return AVERROR(ENOMEM);
 954     }
 955     bs->Data      = new_pkt.data;
 956     bs->MaxLength = new_pkt.size;
 957
 958     if (q->set_encode_ctrl_cb) {
 959         q->set_encode_ctrl_cb(avctx, frame, &qsv_frame->enc_ctrl);
 960     }
 961
 962     sync = av_mallocz(sizeof(*sync));
 963     if (!sync) {
 964         av_freep(&bs);
 965         av_packet_unref(&new_pkt);
 966         return AVERROR(ENOMEM);
 967     }
 968
 969     do {
 970         ret = MFXVideoENCODE_EncodeFrameAsync(q->session, enc_ctrl, surf, bs, sync);
 971         if (ret == MFX_WRN_DEVICE_BUSY) {
 972             av_usleep(500);
 973             continue;
 974         }
 975         break;
 976     } while ( 1 );
 977
 978     if (ret < 0) {
 979         av_packet_unref(&new_pkt);
 980         av_freep(&bs);
 981         if (ret == MFX_ERR_MORE_DATA)
 982             return 0;
 983         av_log(avctx, AV_LOG_ERROR, "EncodeFrameAsync returned %d\n", ret);
 984         return ff_qsv_error(ret);
 985     }
 986
 987     if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM) {
 988         if (frame->interlaced_frame)
 989             print_interlace_msg(avctx, q);
 990         else
 991             av_log(avctx, AV_LOG_WARNING,
 992                    "EncodeFrameAsync returned 'incompatible param' code\n");
 993     }
 994     if (sync) {
 995         av_fifo_generic_write(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
 996         av_fifo_generic_write(q->async_fifo, &sync,    sizeof(sync),    NULL);
 997         av_fifo_generic_write(q->async_fifo, &bs,      sizeof(bs),    NULL);
 998     } else {
 999         av_freep(&sync);
1000         av_packet_unref(&new_pkt);
1001         av_freep(&bs);
1002     }
1003
1004     return 0;
1005 }
1006
1007 int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q,
1008                   AVPacket *pkt, const AVFrame *frame, int *got_packet)
1009 {
1010     int ret;
1011
1012     ret = encode_frame(avctx, q, frame);
1013     if (ret < 0)
1014         return ret;
1015
1016     if (!av_fifo_space(q->async_fifo) ||
1017         (!frame && av_fifo_size(q->async_fifo))) {
1018         AVPacket new_pkt;
1019         mfxBitstream *bs;
1020         mfxSyncPoint *sync;
1021
1022         av_fifo_generic_read(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1023         av_fifo_generic_read(q->async_fifo, &sync,    sizeof(sync),    NULL);
1024         av_fifo_generic_read(q->async_fifo, &bs,      sizeof(bs),      NULL);
1025
1026         do {
1027             ret = MFXVideoCORE_SyncOperation(q->session, *sync, 1000);
1028         } while (ret == MFX_WRN_IN_EXECUTION);
1029
1030         new_pkt.dts  = av_rescale_q(bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
1031         new_pkt.pts  = av_rescale_q(bs->TimeStamp,       (AVRational){1, 90000}, avctx->time_base);
1032         new_pkt.size = bs->DataLength;
1033
1034         if (bs->FrameType & MFX_FRAMETYPE_IDR ||
1035             bs->FrameType & MFX_FRAMETYPE_xIDR)
1036             new_pkt.flags |= AV_PKT_FLAG_KEY;
1037
1038 #if FF_API_CODED_FRAME
1039 FF_DISABLE_DEPRECATION_WARNINGS
1040         if (bs->FrameType & MFX_FRAMETYPE_I || bs->FrameType & MFX_FRAMETYPE_xI)
1041             avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1042         else if (bs->FrameType & MFX_FRAMETYPE_P || bs->FrameType & MFX_FRAMETYPE_xP)
1043             avctx->coded_frame->pict_type = AV_PICTURE_TYPE_P;
1044         else if (bs->FrameType & MFX_FRAMETYPE_B || bs->FrameType & MFX_FRAMETYPE_xB)
1045             avctx->coded_frame->pict_type = AV_PICTURE_TYPE_B;
1046 FF_ENABLE_DEPRECATION_WARNINGS
1047 #endif
1048
1049         av_freep(&bs);
1050         av_freep(&sync);
1051
1052         if (pkt->data) {
1053             if (pkt->size < new_pkt.size) {
1054                 av_log(avctx, AV_LOG_ERROR, "Submitted buffer not large enough: %d < %d\n",
1055                        pkt->size, new_pkt.size);
1056                 av_packet_unref(&new_pkt);
1057                 return AVERROR(EINVAL);
1058             }
1059
1060             memcpy(pkt->data, new_pkt.data, new_pkt.size);
1061             pkt->size = new_pkt.size;
1062
1063             ret = av_packet_copy_props(pkt, &new_pkt);
1064             av_packet_unref(&new_pkt);
1065             if (ret < 0)
1066                 return ret;
1067         } else
1068             *pkt = new_pkt;
1069
1070         *got_packet = 1;
1071     }
1072
1073     return 0;
1074 }
1075
1076 int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
1077 {
1078     QSVFrame *cur;
1079
1080     if (q->session)
1081         MFXVideoENCODE_Close(q->session);
1082     q->session = NULL;
1083
1084     ff_qsv_close_internal_session(&q->internal_qs);
1085
1086     cur = q->work_frames;
1087     while (cur) {
1088         q->work_frames = cur->next;
1089         av_frame_free(&cur->frame);
1090         av_free(cur->enc_ctrl.Payload);
1091         av_freep(&cur);
1092         cur = q->work_frames;
1093     }
1094
1095     while (q->async_fifo && av_fifo_size(q->async_fifo)) {
1096         AVPacket pkt;
1097         mfxSyncPoint *sync;
1098         mfxBitstream *bs;
1099
1100         av_fifo_generic_read(q->async_fifo, &pkt,  sizeof(pkt),  NULL);
1101         av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1102         av_fifo_generic_read(q->async_fifo, &bs,   sizeof(bs),   NULL);
1103
1104         av_freep(&sync);
1105         av_freep(&bs);
1106         av_packet_unref(&pkt);
1107     }
1108     av_fifo_free(q->async_fifo);
1109     q->async_fifo = NULL;
1110
1111     av_freep(&q->opaque_surfaces);
1112     av_buffer_unref(&q->opaque_alloc_buf);
1113
1114     av_freep(&q->extparam);
1115
1116     return 0;
1117 }