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