Merge commit 'a1335149fd610b16459d9281b611282cac51c950'
[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 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             mfxPayload* pay = enc_ctrl->Payload[i];
785             av_free(enc_ctrl->Payload[i]->Data);
786             av_free(pay);
787         }
788         enc_ctrl->NumPayload = 0;
789     }
790 }
791
792 static void clear_unused_frames(QSVEncContext *q)
793 {
794     QSVFrame *cur = q->work_frames;
795     while (cur) {
796         if (cur->surface && !cur->surface->Data.Locked) {
797             cur->surface = NULL;
798             free_encoder_ctrl_payloads(&cur->enc_ctrl);
799             av_frame_unref(cur->frame);
800         }
801         cur = cur->next;
802     }
803 }
804
805 static int get_free_frame(QSVEncContext *q, QSVFrame **f)
806 {
807     QSVFrame *frame, **last;
808
809     clear_unused_frames(q);
810
811     frame = q->work_frames;
812     last  = &q->work_frames;
813     while (frame) {
814         if (!frame->surface) {
815             *f = frame;
816             return 0;
817         }
818
819         last  = &frame->next;
820         frame = frame->next;
821     }
822
823     frame = av_mallocz(sizeof(*frame));
824     if (!frame)
825         return AVERROR(ENOMEM);
826     frame->frame = av_frame_alloc();
827     if (!frame->frame) {
828         av_freep(&frame);
829         return AVERROR(ENOMEM);
830     }
831     frame->enc_ctrl.Payload = av_mallocz(sizeof(mfxPayload*) * QSV_MAX_ENC_PAYLOAD);
832     if (!frame->enc_ctrl.Payload) {
833         av_freep(&frame);
834         return AVERROR(ENOMEM);
835     }
836     *last = frame;
837
838     *f = frame;
839
840     return 0;
841 }
842
843 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
844                         QSVFrame **new_frame)
845 {
846     QSVFrame *qf;
847     int ret;
848
849     ret = get_free_frame(q, &qf);
850     if (ret < 0)
851         return ret;
852
853     if (frame->format == AV_PIX_FMT_QSV) {
854         ret = av_frame_ref(qf->frame, frame);
855         if (ret < 0)
856             return ret;
857
858         qf->surface = (mfxFrameSurface1*)qf->frame->data[3];
859     } else {
860         /* make a copy if the input is not padded as libmfx requires */
861         if (     frame->height & (q->height_align - 1) ||
862             frame->linesize[0] & (q->width_align - 1)) {
863             qf->frame->height = FFALIGN(frame->height, q->height_align);
864             qf->frame->width  = FFALIGN(frame->width, q->width_align);
865
866             ret = ff_get_buffer(q->avctx, qf->frame, AV_GET_BUFFER_FLAG_REF);
867             if (ret < 0)
868                 return ret;
869
870             qf->frame->height = frame->height;
871             qf->frame->width  = frame->width;
872             ret = av_frame_copy(qf->frame, frame);
873             if (ret < 0) {
874                 av_frame_unref(qf->frame);
875                 return ret;
876             }
877         } else {
878             ret = av_frame_ref(qf->frame, frame);
879             if (ret < 0)
880                 return ret;
881         }
882
883         qf->surface_internal.Info = q->param.mfx.FrameInfo;
884
885         qf->surface_internal.Info.PicStruct =
886             !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
887             frame->top_field_first   ? MFX_PICSTRUCT_FIELD_TFF :
888                                        MFX_PICSTRUCT_FIELD_BFF;
889         if (frame->repeat_pict == 1)
890             qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
891         else if (frame->repeat_pict == 2)
892             qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
893         else if (frame->repeat_pict == 4)
894             qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
895
896         qf->surface_internal.Data.PitchLow  = qf->frame->linesize[0];
897         qf->surface_internal.Data.Y         = qf->frame->data[0];
898         qf->surface_internal.Data.UV        = qf->frame->data[1];
899
900         qf->surface = &qf->surface_internal;
901     }
902
903     qf->surface->Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
904
905     *new_frame = qf;
906
907     return 0;
908 }
909
910 static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
911 {
912     if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
913         if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
914             q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
915             q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
916             av_log(avctx, AV_LOG_WARNING,
917                    "Interlaced coding is supported"
918                    " at Main/High Profile Level 2.1-4.1\n");
919     }
920 }
921
922 static int encode_frame(AVCodecContext *avctx, QSVEncContext *q,
923                         const AVFrame *frame)
924 {
925     AVPacket new_pkt = { 0 };
926     mfxBitstream *bs;
927
928     mfxFrameSurface1 *surf = NULL;
929     mfxSyncPoint *sync      = NULL;
930     QSVFrame *qsv_frame = NULL;
931     mfxEncodeCtrl* enc_ctrl = NULL;
932     int ret;
933
934     if (frame) {
935         ret = submit_frame(q, frame, &qsv_frame);
936         if (ret < 0) {
937             av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
938             return ret;
939         }
940     }
941     if (qsv_frame) {
942         surf = qsv_frame->surface;
943         enc_ctrl = &qsv_frame->enc_ctrl;
944     }
945
946     ret = av_new_packet(&new_pkt, q->packet_size);
947     if (ret < 0) {
948         av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
949         return ret;
950     }
951
952     bs = av_mallocz(sizeof(*bs));
953     if (!bs) {
954         av_packet_unref(&new_pkt);
955         return AVERROR(ENOMEM);
956     }
957     bs->Data      = new_pkt.data;
958     bs->MaxLength = new_pkt.size;
959
960     if (q->set_encode_ctrl_cb) {
961         q->set_encode_ctrl_cb(avctx, frame, &qsv_frame->enc_ctrl);
962     }
963
964     sync = av_mallocz(sizeof(*sync));
965     if (!sync) {
966         av_freep(&bs);
967         av_packet_unref(&new_pkt);
968         return AVERROR(ENOMEM);
969     }
970
971     do {
972         ret = MFXVideoENCODE_EncodeFrameAsync(q->session, enc_ctrl, surf, bs, sync);
973         if (ret == MFX_WRN_DEVICE_BUSY) {
974             av_usleep(500);
975             continue;
976         }
977         break;
978     } while ( 1 );
979
980     if (ret < 0) {
981         av_packet_unref(&new_pkt);
982         av_freep(&bs);
983         if (ret == MFX_ERR_MORE_DATA)
984             return 0;
985         av_log(avctx, AV_LOG_ERROR, "EncodeFrameAsync returned %d\n", ret);
986         return ff_qsv_error(ret);
987     }
988
989     if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM) {
990         if (frame->interlaced_frame)
991             print_interlace_msg(avctx, q);
992         else
993             av_log(avctx, AV_LOG_WARNING,
994                    "EncodeFrameAsync returned 'incompatible param' code\n");
995     }
996     if (sync) {
997         av_fifo_generic_write(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
998         av_fifo_generic_write(q->async_fifo, &sync,    sizeof(sync),    NULL);
999         av_fifo_generic_write(q->async_fifo, &bs,      sizeof(bs),    NULL);
1000     } else {
1001         av_freep(&sync);
1002         av_packet_unref(&new_pkt);
1003         av_freep(&bs);
1004     }
1005
1006     return 0;
1007 }
1008
1009 int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q,
1010                   AVPacket *pkt, const AVFrame *frame, int *got_packet)
1011 {
1012     int ret;
1013
1014     ret = encode_frame(avctx, q, frame);
1015     if (ret < 0)
1016         return ret;
1017
1018     if (!av_fifo_space(q->async_fifo) ||
1019         (!frame && av_fifo_size(q->async_fifo))) {
1020         AVPacket new_pkt;
1021         mfxBitstream *bs;
1022         mfxSyncPoint *sync;
1023
1024         av_fifo_generic_read(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1025         av_fifo_generic_read(q->async_fifo, &sync,    sizeof(sync),    NULL);
1026         av_fifo_generic_read(q->async_fifo, &bs,      sizeof(bs),      NULL);
1027
1028         do {
1029             ret = MFXVideoCORE_SyncOperation(q->session, *sync, 1000);
1030         } while (ret == MFX_WRN_IN_EXECUTION);
1031
1032         new_pkt.dts  = av_rescale_q(bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
1033         new_pkt.pts  = av_rescale_q(bs->TimeStamp,       (AVRational){1, 90000}, avctx->time_base);
1034         new_pkt.size = bs->DataLength;
1035
1036         if (bs->FrameType & MFX_FRAMETYPE_IDR ||
1037             bs->FrameType & MFX_FRAMETYPE_xIDR)
1038             new_pkt.flags |= AV_PKT_FLAG_KEY;
1039
1040 #if FF_API_CODED_FRAME
1041 FF_DISABLE_DEPRECATION_WARNINGS
1042         if (bs->FrameType & MFX_FRAMETYPE_I || bs->FrameType & MFX_FRAMETYPE_xI)
1043             avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1044         else if (bs->FrameType & MFX_FRAMETYPE_P || bs->FrameType & MFX_FRAMETYPE_xP)
1045             avctx->coded_frame->pict_type = AV_PICTURE_TYPE_P;
1046         else if (bs->FrameType & MFX_FRAMETYPE_B || bs->FrameType & MFX_FRAMETYPE_xB)
1047             avctx->coded_frame->pict_type = AV_PICTURE_TYPE_B;
1048 FF_ENABLE_DEPRECATION_WARNINGS
1049 #endif
1050
1051         av_freep(&bs);
1052         av_freep(&sync);
1053
1054         if (pkt->data) {
1055             if (pkt->size < new_pkt.size) {
1056                 av_log(avctx, AV_LOG_ERROR, "Submitted buffer not large enough: %d < %d\n",
1057                        pkt->size, new_pkt.size);
1058                 av_packet_unref(&new_pkt);
1059                 return AVERROR(EINVAL);
1060             }
1061
1062             memcpy(pkt->data, new_pkt.data, new_pkt.size);
1063             pkt->size = new_pkt.size;
1064
1065             ret = av_packet_copy_props(pkt, &new_pkt);
1066             av_packet_unref(&new_pkt);
1067             if (ret < 0)
1068                 return ret;
1069         } else
1070             *pkt = new_pkt;
1071
1072         *got_packet = 1;
1073     }
1074
1075     return 0;
1076 }
1077
1078 int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
1079 {
1080     QSVFrame *cur;
1081
1082     if (q->session)
1083         MFXVideoENCODE_Close(q->session);
1084     q->session = NULL;
1085
1086     ff_qsv_close_internal_session(&q->internal_qs);
1087
1088     cur = q->work_frames;
1089     while (cur) {
1090         q->work_frames = cur->next;
1091         av_frame_free(&cur->frame);
1092         av_free(cur->enc_ctrl.Payload);
1093         av_freep(&cur);
1094         cur = q->work_frames;
1095     }
1096
1097     while (q->async_fifo && av_fifo_size(q->async_fifo)) {
1098         AVPacket pkt;
1099         mfxSyncPoint *sync;
1100         mfxBitstream *bs;
1101
1102         av_fifo_generic_read(q->async_fifo, &pkt,  sizeof(pkt),  NULL);
1103         av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1104         av_fifo_generic_read(q->async_fifo, &bs,   sizeof(bs),   NULL);
1105
1106         av_freep(&sync);
1107         av_freep(&bs);
1108         av_packet_unref(&pkt);
1109     }
1110     av_fifo_free(q->async_fifo);
1111     q->async_fifo = NULL;
1112
1113     av_freep(&q->opaque_surfaces);
1114     av_buffer_unref(&q->opaque_alloc_buf);
1115
1116     av_freep(&q->extparam);
1117
1118     return 0;
1119 }