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