FFmpeg
qsvenc.c
Go to the documentation of this file.
1 /*
2  * Intel MediaSDK QSV encoder utility functions
3  *
4  * copyright (c) 2013 Yukinori Yamazoe
5  * copyright (c) 2015 Anton Khirnov
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 #include <string.h>
25 #include <sys/types.h>
26 #include <mfx/mfxvideo.h>
27 
28 #include "libavutil/common.h"
29 #include "libavutil/hwcontext.h"
31 #include "libavutil/mem.h"
32 #include "libavutil/log.h"
33 #include "libavutil/time.h"
34 #include "libavutil/imgutils.h"
35 #include "libavcodec/bytestream.h"
36 
37 #include "avcodec.h"
38 #include "internal.h"
39 #include "qsv.h"
40 #include "qsv_internal.h"
41 #include "qsvenc.h"
42 
43 static const struct {
44  mfxU16 profile;
45  const char *name;
46 } profile_names[] = {
47  { MFX_PROFILE_AVC_BASELINE, "baseline" },
48  { MFX_PROFILE_AVC_MAIN, "main" },
49  { MFX_PROFILE_AVC_EXTENDED, "extended" },
50  { MFX_PROFILE_AVC_HIGH, "high" },
51 #if QSV_VERSION_ATLEAST(1, 15)
52  { MFX_PROFILE_AVC_HIGH_422, "high 422" },
53 #endif
54 #if QSV_VERSION_ATLEAST(1, 4)
55  { MFX_PROFILE_AVC_CONSTRAINED_BASELINE, "constrained baseline" },
56  { MFX_PROFILE_AVC_CONSTRAINED_HIGH, "constrained high" },
57  { MFX_PROFILE_AVC_PROGRESSIVE_HIGH, "progressive high" },
58 #endif
59  { MFX_PROFILE_MPEG2_SIMPLE, "simple" },
60  { MFX_PROFILE_MPEG2_MAIN, "main" },
61  { MFX_PROFILE_MPEG2_HIGH, "high" },
62  { MFX_PROFILE_VC1_SIMPLE, "simple" },
63  { MFX_PROFILE_VC1_MAIN, "main" },
64  { MFX_PROFILE_VC1_ADVANCED, "advanced" },
65 #if QSV_VERSION_ATLEAST(1, 8)
66  { MFX_PROFILE_HEVC_MAIN, "main" },
67  { MFX_PROFILE_HEVC_MAIN10, "main10" },
68  { MFX_PROFILE_HEVC_MAINSP, "mainsp" },
69 #endif
70 };
71 
72 static const char *print_profile(mfxU16 profile)
73 {
74  int i;
75  for (i = 0; i < FF_ARRAY_ELEMS(profile_names); i++)
76  if (profile == profile_names[i].profile)
77  return profile_names[i].name;
78  return "unknown";
79 }
80 
81 static const struct {
82  mfxU16 rc_mode;
83  const char *name;
84 } rc_names[] = {
85  { MFX_RATECONTROL_CBR, "CBR" },
86  { MFX_RATECONTROL_VBR, "VBR" },
87  { MFX_RATECONTROL_CQP, "CQP" },
88 #if QSV_HAVE_AVBR
89  { MFX_RATECONTROL_AVBR, "AVBR" },
90 #endif
91 #if QSV_HAVE_LA
92  { MFX_RATECONTROL_LA, "LA" },
93 #endif
94 #if QSV_HAVE_ICQ
95  { MFX_RATECONTROL_ICQ, "ICQ" },
96  { MFX_RATECONTROL_LA_ICQ, "LA_ICQ" },
97 #endif
98 #if QSV_HAVE_VCM
99  { MFX_RATECONTROL_VCM, "VCM" },
100 #endif
101 #if QSV_VERSION_ATLEAST(1, 10)
102  { MFX_RATECONTROL_LA_EXT, "LA_EXT" },
103 #endif
104 #if QSV_HAVE_LA_HRD
105  { MFX_RATECONTROL_LA_HRD, "LA_HRD" },
106 #endif
107 #if QSV_HAVE_QVBR
108  { MFX_RATECONTROL_QVBR, "QVBR" },
109 #endif
110 };
111 
112 static const char *print_ratecontrol(mfxU16 rc_mode)
113 {
114  int i;
115  for (i = 0; i < FF_ARRAY_ELEMS(rc_names); i++)
116  if (rc_mode == rc_names[i].rc_mode)
117  return rc_names[i].name;
118  return "unknown";
119 }
120 
121 static const char *print_threestate(mfxU16 val)
122 {
123  if (val == MFX_CODINGOPTION_ON)
124  return "ON";
125  else if (val == MFX_CODINGOPTION_OFF)
126  return "OFF";
127  return "unknown";
128 }
129 
131  mfxExtBuffer **coding_opts)
132 {
133  mfxInfoMFX *info = &q->param.mfx;
134 
135  mfxExtCodingOption *co = (mfxExtCodingOption*)coding_opts[0];
136 #if QSV_HAVE_CO2
137  mfxExtCodingOption2 *co2 = (mfxExtCodingOption2*)coding_opts[1];
138 #endif
139 #if QSV_HAVE_CO3
140  mfxExtCodingOption3 *co3 = (mfxExtCodingOption3*)coding_opts[2];
141 #endif
142 
143  av_log(avctx, AV_LOG_VERBOSE, "profile: %s; level: %"PRIu16"\n",
144  print_profile(info->CodecProfile), info->CodecLevel);
145 
146  av_log(avctx, AV_LOG_VERBOSE, "GopPicSize: %"PRIu16"; GopRefDist: %"PRIu16"; GopOptFlag: ",
147  info->GopPicSize, info->GopRefDist);
148  if (info->GopOptFlag & MFX_GOP_CLOSED)
149  av_log(avctx, AV_LOG_VERBOSE, "closed ");
150  if (info->GopOptFlag & MFX_GOP_STRICT)
151  av_log(avctx, AV_LOG_VERBOSE, "strict ");
152  av_log(avctx, AV_LOG_VERBOSE, "; IdrInterval: %"PRIu16"\n", info->IdrInterval);
153 
154  av_log(avctx, AV_LOG_VERBOSE, "TargetUsage: %"PRIu16"; RateControlMethod: %s\n",
155  info->TargetUsage, print_ratecontrol(info->RateControlMethod));
156 
157  if (info->RateControlMethod == MFX_RATECONTROL_CBR ||
158  info->RateControlMethod == MFX_RATECONTROL_VBR
159 #if QSV_HAVE_VCM
160  || info->RateControlMethod == MFX_RATECONTROL_VCM
161 #endif
162  ) {
163  av_log(avctx, AV_LOG_VERBOSE,
164  "BufferSizeInKB: %"PRIu16"; InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
165  info->BufferSizeInKB, info->InitialDelayInKB, info->TargetKbps, info->MaxKbps, info->BRCParamMultiplier);
166  } else if (info->RateControlMethod == MFX_RATECONTROL_CQP) {
167  av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",
168  info->QPI, info->QPP, info->QPB);
169  }
170 #if QSV_HAVE_AVBR
171  else if (info->RateControlMethod == MFX_RATECONTROL_AVBR) {
172  av_log(avctx, AV_LOG_VERBOSE,
173  "TargetKbps: %"PRIu16"; Accuracy: %"PRIu16"; Convergence: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
174  info->TargetKbps, info->Accuracy, info->Convergence, info->BRCParamMultiplier);
175  }
176 #endif
177 #if QSV_HAVE_LA
178  else if (info->RateControlMethod == MFX_RATECONTROL_LA
179 #if QSV_HAVE_LA_HRD
180  || info->RateControlMethod == MFX_RATECONTROL_LA_HRD
181 #endif
182  ) {
183  av_log(avctx, AV_LOG_VERBOSE,
184  "TargetKbps: %"PRIu16"; LookAheadDepth: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
185  info->TargetKbps, co2->LookAheadDepth, info->BRCParamMultiplier);
186  }
187 #endif
188 #if QSV_HAVE_ICQ
189  else if (info->RateControlMethod == MFX_RATECONTROL_ICQ) {
190  av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);
191  } else if (info->RateControlMethod == MFX_RATECONTROL_LA_ICQ) {
192  av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"; LookAheadDepth: %"PRIu16"\n",
193  info->ICQQuality, co2->LookAheadDepth);
194  }
195 #endif
196 #if QSV_HAVE_QVBR
197  else if (info->RateControlMethod == MFX_RATECONTROL_QVBR) {
198  av_log(avctx, AV_LOG_VERBOSE, "QVBRQuality: %"PRIu16"\n",
199  co3->QVBRQuality);
200  }
201 #endif
202  av_log(avctx, AV_LOG_VERBOSE, "NumSlice: %"PRIu16"; NumRefFrame: %"PRIu16"\n",
203  info->NumSlice, info->NumRefFrame);
204  av_log(avctx, AV_LOG_VERBOSE, "RateDistortionOpt: %s\n",
205  print_threestate(co->RateDistortionOpt));
206 
207 #if QSV_HAVE_CO2
208  av_log(avctx, AV_LOG_VERBOSE,
209  "RecoveryPointSEI: %s IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16"; IntRefQPDelta: %"PRId16"\n",
210  print_threestate(co->RecoveryPointSEI), co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);
211 
212  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %"PRIu16"; ", co2->MaxFrameSize);
213 #if QSV_HAVE_MAX_SLICE_SIZE
214  av_log(avctx, AV_LOG_VERBOSE, "MaxSliceSize: %"PRIu16"; ", co2->MaxSliceSize);
215 #endif
216  av_log(avctx, AV_LOG_VERBOSE, "\n");
217 
218  av_log(avctx, AV_LOG_VERBOSE,
219  "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
220  print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),
221  print_threestate(co2->ExtBRC));
222 
223 #if QSV_HAVE_TRELLIS
224  av_log(avctx, AV_LOG_VERBOSE, "Trellis: ");
225  if (co2->Trellis & MFX_TRELLIS_OFF) {
226  av_log(avctx, AV_LOG_VERBOSE, "off");
227  } else if (!co2->Trellis) {
228  av_log(avctx, AV_LOG_VERBOSE, "auto");
229  } else {
230  if (co2->Trellis & MFX_TRELLIS_I) av_log(avctx, AV_LOG_VERBOSE, "I");
231  if (co2->Trellis & MFX_TRELLIS_P) av_log(avctx, AV_LOG_VERBOSE, "P");
232  if (co2->Trellis & MFX_TRELLIS_B) av_log(avctx, AV_LOG_VERBOSE, "B");
233  }
234  av_log(avctx, AV_LOG_VERBOSE, "\n");
235 #endif
236 
237 #if QSV_HAVE_VDENC
238  av_log(avctx, AV_LOG_VERBOSE, "VDENC: %s\n", print_threestate(info->LowPower));
239 #endif
240 
241 #if QSV_VERSION_ATLEAST(1, 8)
242  av_log(avctx, AV_LOG_VERBOSE,
243  "RepeatPPS: %s; NumMbPerSlice: %"PRIu16"; LookAheadDS: ",
244  print_threestate(co2->RepeatPPS), co2->NumMbPerSlice);
245  switch (co2->LookAheadDS) {
246  case MFX_LOOKAHEAD_DS_OFF: av_log(avctx, AV_LOG_VERBOSE, "off"); break;
247  case MFX_LOOKAHEAD_DS_2x: av_log(avctx, AV_LOG_VERBOSE, "2x"); break;
248  case MFX_LOOKAHEAD_DS_4x: av_log(avctx, AV_LOG_VERBOSE, "4x"); break;
249  default: av_log(avctx, AV_LOG_VERBOSE, "unknown"); break;
250  }
251  av_log(avctx, AV_LOG_VERBOSE, "\n");
252 
253  av_log(avctx, AV_LOG_VERBOSE, "AdaptiveI: %s; AdaptiveB: %s; BRefType: ",
254  print_threestate(co2->AdaptiveI), print_threestate(co2->AdaptiveB));
255  switch (co2->BRefType) {
256  case MFX_B_REF_OFF: av_log(avctx, AV_LOG_VERBOSE, "off"); break;
257  case MFX_B_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "pyramid"); break;
258  default: av_log(avctx, AV_LOG_VERBOSE, "auto"); break;
259  }
260  av_log(avctx, AV_LOG_VERBOSE, "\n");
261 #endif
262 
263 #if QSV_VERSION_ATLEAST(1, 9)
264  av_log(avctx, AV_LOG_VERBOSE,
265  "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",
266  co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
267 #endif
268 #endif
269 
270 #if QSV_HAVE_GPB
271  if (avctx->codec_id == AV_CODEC_ID_HEVC)
272  av_log(avctx, AV_LOG_VERBOSE,"GPB: %s\n", print_threestate(co3->GPB));
273 #endif
274 
275  if (avctx->codec_id == AV_CODEC_ID_H264) {
276  av_log(avctx, AV_LOG_VERBOSE, "Entropy coding: %s; MaxDecFrameBuffering: %"PRIu16"\n",
277  co->CAVLC == MFX_CODINGOPTION_ON ? "CAVLC" : "CABAC", co->MaxDecFrameBuffering);
278  av_log(avctx, AV_LOG_VERBOSE,
279  "NalHrdConformance: %s; SingleSeiNalUnit: %s; VuiVclHrdParameters: %s VuiNalHrdParameters: %s\n",
280  print_threestate(co->NalHrdConformance), print_threestate(co->SingleSeiNalUnit),
281  print_threestate(co->VuiVclHrdParameters), print_threestate(co->VuiNalHrdParameters));
282  }
283 
284  av_log(avctx, AV_LOG_VERBOSE, "FrameRateExtD: %"PRIu32"; FrameRateExtN: %"PRIu32" \n",
285  info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);
286 
287 }
288 
290 {
291  const char *rc_desc;
292  mfxU16 rc_mode;
293 
294  int want_la = q->look_ahead;
295  int want_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
296  int want_vcm = q->vcm;
297 
298  if (want_la && !QSV_HAVE_LA) {
299  av_log(avctx, AV_LOG_ERROR,
300  "Lookahead ratecontrol mode requested, but is not supported by this SDK version\n");
301  return AVERROR(ENOSYS);
302  }
303  if (want_vcm && !QSV_HAVE_VCM) {
304  av_log(avctx, AV_LOG_ERROR,
305  "VCM ratecontrol mode requested, but is not supported by this SDK version\n");
306  return AVERROR(ENOSYS);
307  }
308 
309  if (want_la + want_qscale + want_vcm > 1) {
310  av_log(avctx, AV_LOG_ERROR,
311  "More than one of: { constant qscale, lookahead, VCM } requested, "
312  "only one of them can be used at a time.\n");
313  return AVERROR(EINVAL);
314  }
315 
316  if (!want_qscale && avctx->global_quality > 0 && !QSV_HAVE_ICQ){
317  av_log(avctx, AV_LOG_ERROR,
318  "ICQ ratecontrol mode requested, but is not supported by this SDK version\n");
319  return AVERROR(ENOSYS);
320  }
321 
322  if (want_qscale) {
323  rc_mode = MFX_RATECONTROL_CQP;
324  rc_desc = "constant quantization parameter (CQP)";
325  }
326 #if QSV_HAVE_VCM
327  else if (want_vcm) {
328  rc_mode = MFX_RATECONTROL_VCM;
329  rc_desc = "video conferencing mode (VCM)";
330  }
331 #endif
332 #if QSV_HAVE_LA
333  else if (want_la) {
334  rc_mode = MFX_RATECONTROL_LA;
335  rc_desc = "VBR with lookahead (LA)";
336 
337 #if QSV_HAVE_ICQ
338  if (avctx->global_quality > 0) {
339  rc_mode = MFX_RATECONTROL_LA_ICQ;
340  rc_desc = "intelligent constant quality with lookahead (LA_ICQ)";
341  }
342 #endif
343  }
344 #endif
345 #if QSV_HAVE_ICQ
346  else if (avctx->global_quality > 0 && !avctx->rc_max_rate) {
347  rc_mode = MFX_RATECONTROL_ICQ;
348  rc_desc = "intelligent constant quality (ICQ)";
349  }
350 #endif
351  else if (avctx->rc_max_rate == avctx->bit_rate) {
352  rc_mode = MFX_RATECONTROL_CBR;
353  rc_desc = "constant bitrate (CBR)";
354  }
355 #if QSV_HAVE_AVBR
356  else if (!avctx->rc_max_rate) {
357  rc_mode = MFX_RATECONTROL_AVBR;
358  rc_desc = "average variable bitrate (AVBR)";
359  }
360 #endif
361 #if QSV_HAVE_QVBR
362  else if (avctx->global_quality > 0) {
363  rc_mode = MFX_RATECONTROL_QVBR;
364  rc_desc = "constant quality with VBR algorithm (QVBR)";
365  }
366 #endif
367  else {
368  rc_mode = MFX_RATECONTROL_VBR;
369  rc_desc = "variable bitrate (VBR)";
370  }
371 
372  q->param.mfx.RateControlMethod = rc_mode;
373  av_log(avctx, AV_LOG_VERBOSE, "Using the %s ratecontrol method\n", rc_desc);
374 
375  return 0;
376 }
377 
379 {
380  mfxVideoParam param_out = { .mfx.CodecId = q->param.mfx.CodecId };
381  mfxStatus ret;
382 
383 #define UNMATCH(x) (param_out.mfx.x != q->param.mfx.x)
384 
385  ret = MFXVideoENCODE_Query(q->session, &q->param, &param_out);
386 
387  if (ret < 0) {
388  if (UNMATCH(CodecId))
389  av_log(avctx, AV_LOG_ERROR, "Current codec type is unsupported\n");
390  if (UNMATCH(CodecProfile))
391  av_log(avctx, AV_LOG_ERROR, "Current profile is unsupported\n");
392  if (UNMATCH(RateControlMethod))
393  av_log(avctx, AV_LOG_ERROR, "Selected ratecontrol mode is unsupported\n");
394  if (UNMATCH(LowPower))
395  av_log(avctx, AV_LOG_ERROR, "Low power mode is unsupported\n");
396  if (UNMATCH(FrameInfo.FrameRateExtN) || UNMATCH(FrameInfo.FrameRateExtD))
397  av_log(avctx, AV_LOG_ERROR, "Current frame rate is unsupported\n");
398  if (UNMATCH(FrameInfo.PicStruct))
399  av_log(avctx, AV_LOG_ERROR, "Current picture structure is unsupported\n");
400  if (UNMATCH(FrameInfo.Width) || UNMATCH(FrameInfo.Height))
401  av_log(avctx, AV_LOG_ERROR, "Current resolution is unsupported\n");
402  if (UNMATCH(FrameInfo.FourCC))
403  av_log(avctx, AV_LOG_ERROR, "Current pixel format is unsupported\n");
404  return 0;
405  }
406  return 1;
407 }
408 
410 {
411  enum AVPixelFormat sw_format = avctx->pix_fmt == AV_PIX_FMT_QSV ?
412  avctx->sw_pix_fmt : avctx->pix_fmt;
413  const AVPixFmtDescriptor *desc;
414  int ret;
415 
416  ret = ff_qsv_codec_id_to_mfx(avctx->codec_id);
417  if (ret < 0)
418  return AVERROR_BUG;
419  q->param.mfx.CodecId = ret;
420 
421  if (avctx->level > 0)
422  q->param.mfx.CodecLevel = avctx->level;
423  q->param.mfx.CodecProfile = q->profile;
424 
425  desc = av_pix_fmt_desc_get(sw_format);
426  if (!desc)
427  return AVERROR_BUG;
428 
429  ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC);
430 
431  q->param.mfx.FrameInfo.CropX = 0;
432  q->param.mfx.FrameInfo.CropY = 0;
433  q->param.mfx.FrameInfo.CropW = avctx->width;
434  q->param.mfx.FrameInfo.CropH = avctx->height;
435  q->param.mfx.FrameInfo.AspectRatioW = avctx->sample_aspect_ratio.num;
436  q->param.mfx.FrameInfo.AspectRatioH = avctx->sample_aspect_ratio.den;
437  q->param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
438  q->param.mfx.FrameInfo.BitDepthLuma = desc->comp[0].depth;
439  q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
440  q->param.mfx.FrameInfo.Shift = desc->comp[0].depth > 8;
441 
442  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, 16);
443  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, 16);
444 
445  if (avctx->hw_frames_ctx) {
446  AVHWFramesContext *frames_ctx = (AVHWFramesContext *)avctx->hw_frames_ctx->data;
447  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
448  q->param.mfx.FrameInfo.Width = frames_hwctx->surfaces[0].Info.Width;
449  q->param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;
450  }
451 
452  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
453  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
454  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
455  } else {
456  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
457  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
458  }
459 
460  q->param.mfx.Interleaved = 1;
461  q->param.mfx.Quality = av_clip(avctx->global_quality, 1, 100);
462  q->param.mfx.RestartInterval = 0;
463 
464  return 0;
465 }
466 
468 {
469  enum AVPixelFormat sw_format = avctx->pix_fmt == AV_PIX_FMT_QSV ?
470  avctx->sw_pix_fmt : avctx->pix_fmt;
471  const AVPixFmtDescriptor *desc;
472  float quant;
473  int target_bitrate_kbps, max_bitrate_kbps, brc_param_multiplier;
474  int buffer_size_in_kilobytes, initial_delay_in_kilobytes;
475  int ret;
476 
477  ret = ff_qsv_codec_id_to_mfx(avctx->codec_id);
478  if (ret < 0)
479  return AVERROR_BUG;
480  q->param.mfx.CodecId = ret;
481 
482  if (avctx->level > 0)
483  q->param.mfx.CodecLevel = avctx->level;
484 
486  avctx->compression_level = q->preset;
487  } else if (avctx->compression_level >= 0) {
488  if (avctx->compression_level > MFX_TARGETUSAGE_BEST_SPEED) {
489  av_log(avctx, AV_LOG_WARNING, "Invalid compression level: "
490  "valid range is 0-%d, using %d instead\n",
491  MFX_TARGETUSAGE_BEST_SPEED, MFX_TARGETUSAGE_BEST_SPEED);
492  avctx->compression_level = MFX_TARGETUSAGE_BEST_SPEED;
493  }
494  }
495 
496  if (q->low_power) {
497 #if QSV_HAVE_VDENC
498  q->param.mfx.LowPower = MFX_CODINGOPTION_ON;
499 #else
500  av_log(avctx, AV_LOG_WARNING, "The low_power option is "
501  "not supported with this MSDK version.\n");
502  q->low_power = 0;
503  q->param.mfx.LowPower = MFX_CODINGOPTION_OFF;
504 #endif
505  } else
506  q->param.mfx.LowPower = MFX_CODINGOPTION_OFF;
507 
508  q->param.mfx.CodecProfile = q->profile;
509  q->param.mfx.TargetUsage = avctx->compression_level;
510  q->param.mfx.GopPicSize = FFMAX(0, avctx->gop_size);
511  q->param.mfx.GopRefDist = FFMAX(-1, avctx->max_b_frames) + 1;
512  q->param.mfx.GopOptFlag = avctx->flags & AV_CODEC_FLAG_CLOSED_GOP ?
513  MFX_GOP_CLOSED : 0;
514  q->param.mfx.IdrInterval = q->idr_interval;
515  q->param.mfx.NumSlice = avctx->slices;
516  q->param.mfx.NumRefFrame = FFMAX(0, avctx->refs);
517  q->param.mfx.EncodedOrder = 0;
518  q->param.mfx.BufferSizeInKB = 0;
519 
520  desc = av_pix_fmt_desc_get(sw_format);
521  if (!desc)
522  return AVERROR_BUG;
523 
524  ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC);
525 
526  q->param.mfx.FrameInfo.CropX = 0;
527  q->param.mfx.FrameInfo.CropY = 0;
528  q->param.mfx.FrameInfo.CropW = avctx->width;
529  q->param.mfx.FrameInfo.CropH = avctx->height;
530  q->param.mfx.FrameInfo.AspectRatioW = avctx->sample_aspect_ratio.num;
531  q->param.mfx.FrameInfo.AspectRatioH = avctx->sample_aspect_ratio.den;
532  q->param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
533  q->param.mfx.FrameInfo.BitDepthLuma = desc->comp[0].depth;
534  q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
535  q->param.mfx.FrameInfo.Shift = desc->comp[0].depth > 8;
536 
537  // If the minor version is greater than or equal to 19,
538  // then can use the same alignment settings as H.264 for HEVC
539  q->width_align = (avctx->codec_id != AV_CODEC_ID_HEVC ||
540  QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 19)) ? 16 : 32;
541  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, q->width_align);
542 
543  if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
544  // it is important that PicStruct be setup correctly from the
545  // start--otherwise, encoding doesn't work and results in a bunch
546  // of incompatible video parameter errors
547  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_FIELD_TFF;
548  // height alignment always must be 32 for interlaced video
549  q->height_align = 32;
550  } else {
551  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
552  // for progressive video, the height should be aligned to 16 for
553  // H.264. For HEVC, depending on the version of MFX, it should be
554  // either 32 or 16. The lower number is better if possible.
555  q->height_align = avctx->codec_id == AV_CODEC_ID_HEVC ? 32 : 16;
556  }
557  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, q->height_align);
558 
559  if (avctx->hw_frames_ctx) {
560  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
561  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
562  q->param.mfx.FrameInfo.Width = frames_hwctx->surfaces[0].Info.Width;
563  q->param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;
564  }
565 
566  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
567  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
568  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
569  } else {
570  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
571  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
572  }
573 
574  ret = select_rc_mode(avctx, q);
575  if (ret < 0)
576  return ret;
577 
578  //libmfx BRC parameters are 16 bits thus maybe overflow, then BRCParamMultiplier is needed
579  buffer_size_in_kilobytes = avctx->rc_buffer_size / 8000;
580  initial_delay_in_kilobytes = avctx->rc_initial_buffer_occupancy / 8000;
581  target_bitrate_kbps = avctx->bit_rate / 1000;
582  max_bitrate_kbps = avctx->rc_max_rate / 1000;
583  brc_param_multiplier = (FFMAX(FFMAX3(target_bitrate_kbps, max_bitrate_kbps, buffer_size_in_kilobytes),
584  initial_delay_in_kilobytes) + 0x10000) / 0x10000;
585 
586  switch (q->param.mfx.RateControlMethod) {
587  case MFX_RATECONTROL_CBR:
588  case MFX_RATECONTROL_VBR:
589 #if QSV_HAVE_VCM
590  case MFX_RATECONTROL_VCM:
591 #endif
592 #if QSV_HAVE_QVBR
593  case MFX_RATECONTROL_QVBR:
594 #endif
595  q->param.mfx.BufferSizeInKB = buffer_size_in_kilobytes / brc_param_multiplier;
596  q->param.mfx.InitialDelayInKB = initial_delay_in_kilobytes / brc_param_multiplier;
597  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
598  q->param.mfx.MaxKbps = max_bitrate_kbps / brc_param_multiplier;
599  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
600 #if QSV_HAVE_QVBR
601  if (q->param.mfx.RateControlMethod == MFX_RATECONTROL_QVBR)
602  q->extco3.QVBRQuality = av_clip(avctx->global_quality, 0, 51);
603 #endif
604  break;
605  case MFX_RATECONTROL_CQP:
606  quant = avctx->global_quality / FF_QP2LAMBDA;
607 
608  q->param.mfx.QPI = av_clip(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 0, 51);
609  q->param.mfx.QPP = av_clip(quant, 0, 51);
610  q->param.mfx.QPB = av_clip(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 0, 51);
611 
612  break;
613 #if QSV_HAVE_AVBR
614  case MFX_RATECONTROL_AVBR:
615  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
616  q->param.mfx.Convergence = q->avbr_convergence;
617  q->param.mfx.Accuracy = q->avbr_accuracy;
618  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
619  break;
620 #endif
621 #if QSV_HAVE_LA
622  case MFX_RATECONTROL_LA:
623  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
624  q->extco2.LookAheadDepth = q->look_ahead_depth;
625  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
626  break;
627 #if QSV_HAVE_ICQ
628  case MFX_RATECONTROL_LA_ICQ:
629  q->extco2.LookAheadDepth = q->look_ahead_depth;
630  case MFX_RATECONTROL_ICQ:
631  q->param.mfx.ICQQuality = avctx->global_quality;
632  break;
633 #endif
634 #endif
635  }
636 
637  // The HEVC encoder plugin currently fails with some old libmfx version if coding options
638  // are provided. Can't find the extract libmfx version which fixed it, just enable it from
639  // V1.28 in order to keep compatibility security.
640  if (((avctx->codec_id != AV_CODEC_ID_HEVC) || QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 28))
641  && (avctx->codec_id != AV_CODEC_ID_VP9)) {
642  q->extco.Header.BufferId = MFX_EXTBUFF_CODING_OPTION;
643  q->extco.Header.BufferSz = sizeof(q->extco);
644 
645  q->extco.PicTimingSEI = q->pic_timing_sei ?
646  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;
647 
648  if (q->rdo >= 0)
649  q->extco.RateDistortionOpt = q->rdo > 0 ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
650 
651  if (avctx->codec_id == AV_CODEC_ID_H264) {
652 #if FF_API_CODER_TYPE
654  if (avctx->coder_type >= 0)
655  q->cavlc = avctx->coder_type == FF_CODER_TYPE_VLC;
657 #endif
658  q->extco.CAVLC = q->cavlc ? MFX_CODINGOPTION_ON
659  : MFX_CODINGOPTION_UNKNOWN;
660 
662  q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?
663  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
664 
665  if (q->single_sei_nal_unit >= 0)
666  q->extco.SingleSeiNalUnit = q->single_sei_nal_unit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
667  if (q->recovery_point_sei >= 0)
668  q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
669  q->extco.MaxDecFrameBuffering = q->max_dec_frame_buffering;
670  q->extco.AUDelimiter = q->aud ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
671  }
672 
673  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco;
674 
675  if (avctx->codec_id == AV_CODEC_ID_H264) {
676 #if QSV_HAVE_CO2
677  q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
678  q->extco2.Header.BufferSz = sizeof(q->extco2);
679 
680  if (q->int_ref_type >= 0)
681  q->extco2.IntRefType = q->int_ref_type;
682  if (q->int_ref_cycle_size >= 0)
683  q->extco2.IntRefCycleSize = q->int_ref_cycle_size;
684  if (q->int_ref_qp_delta != INT16_MIN)
685  q->extco2.IntRefQPDelta = q->int_ref_qp_delta;
686 
687  if (q->bitrate_limit >= 0)
688  q->extco2.BitrateLimit = q->bitrate_limit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
689  if (q->mbbrc >= 0)
690  q->extco2.MBBRC = q->mbbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
691  if (q->extbrc >= 0)
692  q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
693 
694  if (q->max_frame_size >= 0)
695  q->extco2.MaxFrameSize = q->max_frame_size;
696 #if QSV_HAVE_MAX_SLICE_SIZE
697  if (q->max_slice_size >= 0)
698  q->extco2.MaxSliceSize = q->max_slice_size;
699 #endif
700 
701 #if QSV_HAVE_TRELLIS
702  if (avctx->trellis >= 0)
703  q->extco2.Trellis = (avctx->trellis == 0) ? MFX_TRELLIS_OFF : (MFX_TRELLIS_I | MFX_TRELLIS_P | MFX_TRELLIS_B);
704  else
705  q->extco2.Trellis = MFX_TRELLIS_UNKNOWN;
706 #endif
707 
708 #if QSV_VERSION_ATLEAST(1, 8)
709  q->extco2.LookAheadDS = q->look_ahead_downsampling;
710  q->extco2.RepeatPPS = q->repeat_pps ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
711 
712 #if FF_API_PRIVATE_OPT
714  if (avctx->b_frame_strategy >= 0)
715  q->b_strategy = avctx->b_frame_strategy;
717 #endif
718  if (q->b_strategy >= 0)
719  q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
720  if (q->adaptive_i >= 0)
721  q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
722  if (q->adaptive_b >= 0)
723  q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
724 #endif
725 
726 #if QSV_VERSION_ATLEAST(1, 9)
727  if (avctx->qmin >= 0 && avctx->qmax >= 0 && avctx->qmin > avctx->qmax) {
728  av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are set but invalid, please make sure min <= max\n");
729  return AVERROR(EINVAL);
730  }
731  if (avctx->qmin >= 0) {
732  q->extco2.MinQPI = avctx->qmin > 51 ? 51 : avctx->qmin;
733  q->extco2.MinQPP = q->extco2.MinQPB = q->extco2.MinQPI;
734  }
735  if (avctx->qmax >= 0) {
736  q->extco2.MaxQPI = avctx->qmax > 51 ? 51 : avctx->qmax;
737  q->extco2.MaxQPP = q->extco2.MaxQPB = q->extco2.MaxQPI;
738  }
739 #endif
740  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
741 #endif
742 
743 #if QSV_HAVE_MF
744  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 25)) {
745  q->extmfp.Header.BufferId = MFX_EXTBUFF_MULTI_FRAME_PARAM;
746  q->extmfp.Header.BufferSz = sizeof(q->extmfp);
747 
748  q->extmfp.MFMode = q->mfmode;
749  av_log(avctx,AV_LOG_VERBOSE,"MFMode:%d\n", q->extmfp.MFMode);
750  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extmfp;
751  }
752 #endif
753  }
754 #if QSV_HAVE_CO3
755  q->extco3.Header.BufferId = MFX_EXTBUFF_CODING_OPTION3;
756  q->extco3.Header.BufferSz = sizeof(q->extco3);
757 #if QSV_HAVE_GPB
758  if (avctx->codec_id == AV_CODEC_ID_HEVC)
759  q->extco3.GPB = q->gpb ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
760 #endif
761  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco3;
762 #endif
763  }
764 
765 #if QSV_HAVE_EXT_VP9_PARAM
766  if (avctx->codec_id == AV_CODEC_ID_VP9) {
767  q->extvp9param.Header.BufferId = MFX_EXTBUFF_VP9_PARAM;
768  q->extvp9param.Header.BufferSz = sizeof(q->extvp9param);
769  q->extvp9param.WriteIVFHeaders = MFX_CODINGOPTION_OFF;
770  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extvp9param;
771  }
772 #endif
773 
774  if (!check_enc_param(avctx,q)) {
775  av_log(avctx, AV_LOG_ERROR,
776  "some encoding parameters are not supported by the QSV "
777  "runtime. Please double check the input parameters.\n");
778  return AVERROR(ENOSYS);
779  }
780 
781  return 0;
782 }
783 
785 {
786  int ret = 0;
787 
788  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
789  if (ret < 0)
790  return ff_qsv_print_error(avctx, ret,
791  "Error calling GetVideoParam");
792 
793  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
794 
795  // for qsv mjpeg the return value maybe 0 so alloc the buffer
796  if (q->packet_size == 0)
797  q->packet_size = q->param.mfx.FrameInfo.Height * q->param.mfx.FrameInfo.Width * 4;
798 
799  return 0;
800 }
801 
803 {
804  int ret = 0;
805 #if QSV_HAVE_EXT_VP9_PARAM
806  mfxExtVP9Param vp9_extend_buf = {
807  .Header.BufferId = MFX_EXTBUFF_VP9_PARAM,
808  .Header.BufferSz = sizeof(vp9_extend_buf),
809  };
810 #endif
811 
812 #if QSV_HAVE_CO2
813  mfxExtCodingOption2 co2 = {
814  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
815  .Header.BufferSz = sizeof(co2),
816  };
817 #endif
818 
819 #if QSV_HAVE_CO3
820  mfxExtCodingOption3 co3 = {
821  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
822  .Header.BufferSz = sizeof(co3),
823  };
824 #endif
825 
826  mfxExtBuffer *ext_buffers[] = {
827 #if QSV_HAVE_EXT_VP9_PARAM
828  (mfxExtBuffer*)&vp9_extend_buf,
829 #endif
830 #if QSV_HAVE_CO2
831  (mfxExtBuffer*)&co2,
832 #endif
833 #if QSV_HAVE_CO3
834  (mfxExtBuffer*)&co3,
835 #endif
836  };
837 
838  q->param.ExtParam = ext_buffers;
839  q->param.NumExtParam = FF_ARRAY_ELEMS(ext_buffers);
840 
841  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
842  if (ret < 0)
843  return ff_qsv_print_error(avctx, ret,
844  "Error calling GetVideoParam");
845 
846  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
847 
848  return 0;
849 }
850 
852 {
853  AVCPBProperties *cpb_props;
854 
855  uint8_t sps_buf[128];
856  uint8_t pps_buf[128];
857 
858  mfxExtCodingOptionSPSPPS extradata = {
859  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
860  .Header.BufferSz = sizeof(extradata),
861  .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),
862  .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
863  };
864 
865  mfxExtCodingOption co = {
866  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
867  .Header.BufferSz = sizeof(co),
868  };
869 #if QSV_HAVE_CO2
870  mfxExtCodingOption2 co2 = {
871  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
872  .Header.BufferSz = sizeof(co2),
873  };
874 #endif
875 #if QSV_HAVE_CO3
876  mfxExtCodingOption3 co3 = {
877  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
878  .Header.BufferSz = sizeof(co3),
879  };
880 #endif
881 
882 #if QSV_HAVE_CO_VPS
883  uint8_t vps_buf[128];
884  mfxExtCodingOptionVPS extradata_vps = {
885  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_VPS,
886  .Header.BufferSz = sizeof(extradata_vps),
887  .VPSBuffer = vps_buf,
888  .VPSBufSize = sizeof(vps_buf),
889  };
890 #endif
891 
892  mfxExtBuffer *ext_buffers[2 + QSV_HAVE_CO2 + QSV_HAVE_CO3 + QSV_HAVE_CO_VPS];
893 
894  int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
895  int ret, ext_buf_num = 0, extradata_offset = 0;
896 
897  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata;
898  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co;
899 #if QSV_HAVE_CO2
900  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;
901 #endif
902 #if QSV_HAVE_CO3
903  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;
904 #endif
905 #if QSV_HAVE_CO_VPS
906  q->hevc_vps = ((avctx->codec_id == AV_CODEC_ID_HEVC) && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 17));
907  if (q->hevc_vps)
908  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata_vps;
909 #endif
910 
911  q->param.ExtParam = ext_buffers;
912  q->param.NumExtParam = ext_buf_num;
913 
914  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
915  if (ret < 0)
916  return ff_qsv_print_error(avctx, ret,
917  "Error calling GetVideoParam");
918 
919  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
920 
921  if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)
922 #if QSV_HAVE_CO_VPS
923  || (q->hevc_vps && !extradata_vps.VPSBufSize)
924 #endif
925  ) {
926  av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
927  return AVERROR_UNKNOWN;
928  }
929 
930  avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
931 #if QSV_HAVE_CO_VPS
932  avctx->extradata_size += q->hevc_vps * extradata_vps.VPSBufSize;
933 #endif
934 
936  if (!avctx->extradata)
937  return AVERROR(ENOMEM);
938 
939 #if QSV_HAVE_CO_VPS
940  if (q->hevc_vps) {
941  memcpy(avctx->extradata, vps_buf, extradata_vps.VPSBufSize);
942  extradata_offset += extradata_vps.VPSBufSize;
943  }
944 #endif
945 
946  memcpy(avctx->extradata + extradata_offset, sps_buf, extradata.SPSBufSize);
947  extradata_offset += extradata.SPSBufSize;
948  if (need_pps) {
949  memcpy(avctx->extradata + extradata_offset, pps_buf, extradata.PPSBufSize);
950  extradata_offset += extradata.PPSBufSize;
951  }
952  memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
953 
954  cpb_props = ff_add_cpb_side_data(avctx);
955  if (!cpb_props)
956  return AVERROR(ENOMEM);
957  cpb_props->max_bitrate = avctx->rc_max_rate;
958  cpb_props->min_bitrate = avctx->rc_min_rate;
959  cpb_props->avg_bitrate = avctx->bit_rate;
960  cpb_props->buffer_size = avctx->rc_buffer_size;
961 
962  dump_video_param(avctx, q, ext_buffers + 1);
963 
964  return 0;
965 }
966 
968 {
969  AVQSVContext *qsv = avctx->hwaccel_context;
970  mfxFrameSurface1 *surfaces;
971  int nb_surfaces, i;
972 
973  nb_surfaces = qsv->nb_opaque_surfaces + q->req.NumFrameSuggested;
974 
975  q->opaque_alloc_buf = av_buffer_allocz(sizeof(*surfaces) * nb_surfaces);
976  if (!q->opaque_alloc_buf)
977  return AVERROR(ENOMEM);
978 
979  q->opaque_surfaces = av_malloc_array(nb_surfaces, sizeof(*q->opaque_surfaces));
980  if (!q->opaque_surfaces)
981  return AVERROR(ENOMEM);
982 
983  surfaces = (mfxFrameSurface1*)q->opaque_alloc_buf->data;
984  for (i = 0; i < nb_surfaces; i++) {
985  surfaces[i].Info = q->req.Info;
986  q->opaque_surfaces[i] = surfaces + i;
987  }
988 
989  q->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
990  q->opaque_alloc.Header.BufferSz = sizeof(q->opaque_alloc);
991  q->opaque_alloc.In.Surfaces = q->opaque_surfaces;
992  q->opaque_alloc.In.NumSurface = nb_surfaces;
993  q->opaque_alloc.In.Type = q->req.Type;
994 
995  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->opaque_alloc;
996 
997  qsv->nb_opaque_surfaces = nb_surfaces;
999  qsv->opaque_alloc_type = q->req.Type;
1000 
1001  return 0;
1002 }
1003 
1005 {
1006  int ret;
1007 
1008  if (avctx->hwaccel_context) {
1009  AVQSVContext *qsv = avctx->hwaccel_context;
1010  q->session = qsv->session;
1011  } else if (avctx->hw_frames_ctx) {
1013  if (!q->frames_ctx.hw_frames_ctx)
1014  return AVERROR(ENOMEM);
1015 
1017  &q->frames_ctx, q->load_plugins,
1018  q->param.IOPattern == MFX_IOPATTERN_IN_OPAQUE_MEMORY,
1019  MFX_GPUCOPY_OFF);
1020  if (ret < 0) {
1022  return ret;
1023  }
1024 
1025  q->session = q->internal_qs.session;
1026  } else if (avctx->hw_device_ctx) {
1028  avctx->hw_device_ctx, q->load_plugins,
1029  MFX_GPUCOPY_OFF);
1030  if (ret < 0)
1031  return ret;
1032 
1033  q->session = q->internal_qs.session;
1034  } else {
1035  ret = ff_qsv_init_internal_session(avctx, &q->internal_qs,
1036  q->load_plugins, MFX_GPUCOPY_OFF);
1037  if (ret < 0)
1038  return ret;
1039 
1040  q->session = q->internal_qs.session;
1041  }
1042 
1043  return 0;
1044 }
1045 
1046 static inline unsigned int qsv_fifo_item_size(void)
1047 {
1048  return sizeof(AVPacket) + sizeof(mfxSyncPoint*) + sizeof(mfxBitstream*);
1049 }
1050 
1051 static inline unsigned int qsv_fifo_size(const AVFifoBuffer* fifo)
1052 {
1053  return av_fifo_size(fifo)/qsv_fifo_item_size();
1054 }
1055 
1057 {
1058  int iopattern = 0;
1059  int opaque_alloc = 0;
1060  int ret;
1061 
1062  q->param.AsyncDepth = q->async_depth;
1063 
1065  if (!q->async_fifo)
1066  return AVERROR(ENOMEM);
1067 
1068  if (avctx->hwaccel_context) {
1069  AVQSVContext *qsv = avctx->hwaccel_context;
1070 
1071  iopattern = qsv->iopattern;
1072  opaque_alloc = qsv->opaque_alloc;
1073  }
1074 
1075  if (avctx->hw_frames_ctx) {
1076  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1077  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
1078 
1079  if (!iopattern) {
1080  if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)
1081  iopattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
1082  else if (frames_hwctx->frame_type &
1083  (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
1084  iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
1085  }
1086  }
1087 
1088  if (!iopattern)
1089  iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
1090  q->param.IOPattern = iopattern;
1091 
1092  ret = qsvenc_init_session(avctx, q);
1093  if (ret < 0)
1094  return ret;
1095 
1096  ret = MFXQueryVersion(q->session,&q->ver);
1097  if (ret < 0) {
1098  return ff_qsv_print_error(avctx, ret,
1099  "Error querying mfx version");
1100  }
1101 
1102  // in the mfxInfoMFX struct, JPEG is different from other codecs
1103  switch (avctx->codec_id) {
1104  case AV_CODEC_ID_MJPEG:
1105  ret = init_video_param_jpeg(avctx, q);
1106  break;
1107  default:
1108  ret = init_video_param(avctx, q);
1109  break;
1110  }
1111  if (ret < 0)
1112  return ret;
1113 
1114  if (avctx->hwaccel_context) {
1115  AVQSVContext *qsv = avctx->hwaccel_context;
1116  int i, j;
1117 
1119  sizeof(*q->extparam));
1120  if (!q->extparam)
1121  return AVERROR(ENOMEM);
1122 
1123  q->param.ExtParam = q->extparam;
1124  for (i = 0; i < qsv->nb_ext_buffers; i++)
1125  q->param.ExtParam[i] = qsv->ext_buffers[i];
1126  q->param.NumExtParam = qsv->nb_ext_buffers;
1127 
1128  for (i = 0; i < q->nb_extparam_internal; i++) {
1129  for (j = 0; j < qsv->nb_ext_buffers; j++) {
1130  if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)
1131  break;
1132  }
1133  if (j < qsv->nb_ext_buffers)
1134  continue;
1135 
1136  q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];
1137  }
1138  } else {
1139  q->param.ExtParam = q->extparam_internal;
1140  q->param.NumExtParam = q->nb_extparam_internal;
1141  }
1142 
1143  ret = MFXVideoENCODE_Query(q->session, &q->param, &q->param);
1144  if (ret == MFX_WRN_PARTIAL_ACCELERATION) {
1145  av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
1146  } else if (ret < 0) {
1147  return ff_qsv_print_error(avctx, ret,
1148  "Error querying encoder params");
1149  }
1150 
1151  ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
1152  if (ret < 0)
1153  return ff_qsv_print_error(avctx, ret,
1154  "Error querying (IOSurf) the encoding parameters");
1155 
1156  if (opaque_alloc) {
1157  ret = qsv_init_opaque_alloc(avctx, q);
1158  if (ret < 0)
1159  return ret;
1160  }
1161 
1162  ret = MFXVideoENCODE_Init(q->session, &q->param);
1163  if (ret < 0)
1164  return ff_qsv_print_error(avctx, ret,
1165  "Error initializing the encoder");
1166  else if (ret > 0)
1167  ff_qsv_print_warning(avctx, ret,
1168  "Warning in encoder initialization");
1169 
1170  switch (avctx->codec_id) {
1171  case AV_CODEC_ID_MJPEG:
1172  ret = qsv_retrieve_enc_jpeg_params(avctx, q);
1173  break;
1174  case AV_CODEC_ID_VP9:
1175  ret = qsv_retrieve_enc_vp9_params(avctx, q);
1176  break;
1177  default:
1178  ret = qsv_retrieve_enc_params(avctx, q);
1179  break;
1180  }
1181  if (ret < 0) {
1182  av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
1183  return ret;
1184  }
1185 
1186  q->avctx = avctx;
1187 
1188  return 0;
1189 }
1190 
1191 static void free_encoder_ctrl_payloads(mfxEncodeCtrl* enc_ctrl)
1192 {
1193  if (enc_ctrl) {
1194  int i;
1195  for (i = 0; i < enc_ctrl->NumPayload && i < QSV_MAX_ENC_PAYLOAD; i++) {
1196  av_free(enc_ctrl->Payload[i]);
1197  }
1198  enc_ctrl->NumPayload = 0;
1199  }
1200 }
1201 
1203 {
1204  QSVFrame *cur = q->work_frames;
1205  while (cur) {
1206  if (cur->used && !cur->surface.Data.Locked) {
1208  if (cur->frame->format == AV_PIX_FMT_QSV) {
1209  av_frame_unref(cur->frame);
1210  }
1211  cur->used = 0;
1212  }
1213  cur = cur->next;
1214  }
1215 }
1216 
1218 {
1219  QSVFrame *frame, **last;
1220 
1222 
1223  frame = q->work_frames;
1224  last = &q->work_frames;
1225  while (frame) {
1226  if (!frame->used) {
1227  *f = frame;
1228  frame->used = 1;
1229  return 0;
1230  }
1231 
1232  last = &frame->next;
1233  frame = frame->next;
1234  }
1235 
1236  frame = av_mallocz(sizeof(*frame));
1237  if (!frame)
1238  return AVERROR(ENOMEM);
1239  frame->frame = av_frame_alloc();
1240  if (!frame->frame) {
1241  av_freep(&frame);
1242  return AVERROR(ENOMEM);
1243  }
1244  frame->enc_ctrl.Payload = av_mallocz(sizeof(mfxPayload*) * QSV_MAX_ENC_PAYLOAD);
1245  if (!frame->enc_ctrl.Payload) {
1246  av_freep(&frame);
1247  return AVERROR(ENOMEM);
1248  }
1249  *last = frame;
1250 
1251  *f = frame;
1252  frame->used = 1;
1253 
1254  return 0;
1255 }
1256 
1257 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
1258  QSVFrame **new_frame)
1259 {
1260  QSVFrame *qf;
1261  int ret;
1262 
1263  ret = get_free_frame(q, &qf);
1264  if (ret < 0)
1265  return ret;
1266 
1267  if (frame->format == AV_PIX_FMT_QSV) {
1268  ret = av_frame_ref(qf->frame, frame);
1269  if (ret < 0)
1270  return ret;
1271 
1272  qf->surface = *(mfxFrameSurface1*)qf->frame->data[3];
1273 
1274  if (q->frames_ctx.mids) {
1275  ret = ff_qsv_find_surface_idx(&q->frames_ctx, qf);
1276  if (ret < 0)
1277  return ret;
1278 
1279  qf->surface.Data.MemId = &q->frames_ctx.mids[ret];
1280  }
1281  } else {
1282  /* make a copy if the input is not padded as libmfx requires */
1283  /* and to make allocation continious for data[0]/data[1] */
1284  if ((frame->height & 31 || frame->linesize[0] & (q->width_align - 1)) ||
1285  (frame->data[1] - frame->data[0] != frame->linesize[0] * FFALIGN(qf->frame->height, q->height_align))) {
1286  qf->frame->height = FFALIGN(frame->height, q->height_align);
1287  qf->frame->width = FFALIGN(frame->width, q->width_align);
1288 
1289  qf->frame->format = frame->format;
1290 
1291  if (!qf->frame->data[0]) {
1292  ret = av_frame_get_buffer(qf->frame, q->width_align);
1293  if (ret < 0)
1294  return ret;
1295  }
1296 
1297  qf->frame->height = frame->height;
1298  qf->frame->width = frame->width;
1299 
1300  ret = av_frame_copy(qf->frame, frame);
1301  if (ret < 0) {
1302  av_frame_unref(qf->frame);
1303  return ret;
1304  }
1305  } else {
1306  ret = av_frame_ref(qf->frame, frame);
1307  if (ret < 0)
1308  return ret;
1309  }
1310 
1311  qf->surface.Info = q->param.mfx.FrameInfo;
1312 
1313  qf->surface.Info.PicStruct =
1314  !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
1315  frame->top_field_first ? MFX_PICSTRUCT_FIELD_TFF :
1316  MFX_PICSTRUCT_FIELD_BFF;
1317  if (frame->repeat_pict == 1)
1318  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
1319  else if (frame->repeat_pict == 2)
1320  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
1321  else if (frame->repeat_pict == 4)
1322  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
1323 
1324  qf->surface.Data.PitchLow = qf->frame->linesize[0];
1325  qf->surface.Data.Y = qf->frame->data[0];
1326  qf->surface.Data.UV = qf->frame->data[1];
1327  }
1328 
1329  qf->surface.Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
1330 
1331  *new_frame = qf;
1332 
1333  return 0;
1334 }
1335 
1337 {
1338  if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
1339  if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
1340  q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
1341  q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
1342  av_log(avctx, AV_LOG_WARNING,
1343  "Interlaced coding is supported"
1344  " at Main/High Profile Level 2.2-4.0\n");
1345  }
1346 }
1347 
1349  const AVFrame *frame)
1350 {
1351  AVPacket new_pkt = { 0 };
1352  mfxBitstream *bs;
1353 #if QSV_VERSION_ATLEAST(1, 26)
1354  mfxExtAVCEncodedFrameInfo *enc_info;
1355  mfxExtBuffer **enc_buf;
1356 #endif
1357 
1358  mfxFrameSurface1 *surf = NULL;
1359  mfxSyncPoint *sync = NULL;
1360  QSVFrame *qsv_frame = NULL;
1361  mfxEncodeCtrl* enc_ctrl = NULL;
1362  int ret;
1363 
1364  if (frame) {
1365  ret = submit_frame(q, frame, &qsv_frame);
1366  if (ret < 0) {
1367  av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
1368  return ret;
1369  }
1370  }
1371  if (qsv_frame) {
1372  surf = &qsv_frame->surface;
1373  enc_ctrl = &qsv_frame->enc_ctrl;
1374 
1375  if (frame->pict_type == AV_PICTURE_TYPE_I) {
1376  enc_ctrl->FrameType = MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF;
1377  if (q->forced_idr)
1378  enc_ctrl->FrameType |= MFX_FRAMETYPE_IDR;
1379  }
1380  }
1381 
1382  ret = av_new_packet(&new_pkt, q->packet_size);
1383  if (ret < 0) {
1384  av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
1385  return ret;
1386  }
1387 
1388  bs = av_mallocz(sizeof(*bs));
1389  if (!bs) {
1390  av_packet_unref(&new_pkt);
1391  return AVERROR(ENOMEM);
1392  }
1393  bs->Data = new_pkt.data;
1394  bs->MaxLength = new_pkt.size;
1395 
1396 #if QSV_VERSION_ATLEAST(1, 26)
1397  if (avctx->codec_id == AV_CODEC_ID_H264) {
1398  enc_info = av_mallocz(sizeof(*enc_info));
1399  if (!enc_info)
1400  return AVERROR(ENOMEM);
1401 
1402  enc_info->Header.BufferId = MFX_EXTBUFF_ENCODED_FRAME_INFO;
1403  enc_info->Header.BufferSz = sizeof (*enc_info);
1404  bs->NumExtParam = 1;
1405  enc_buf = av_mallocz(sizeof(mfxExtBuffer *));
1406  if (!enc_buf)
1407  return AVERROR(ENOMEM);
1408  enc_buf[0] = (mfxExtBuffer *)enc_info;
1409 
1410  bs->ExtParam = enc_buf;
1411  }
1412 #endif
1413 
1414  if (q->set_encode_ctrl_cb) {
1415  q->set_encode_ctrl_cb(avctx, frame, &qsv_frame->enc_ctrl);
1416  }
1417 
1418  sync = av_mallocz(sizeof(*sync));
1419  if (!sync) {
1420  av_freep(&bs);
1421  #if QSV_VERSION_ATLEAST(1, 26)
1422  if (avctx->codec_id == AV_CODEC_ID_H264) {
1423  av_freep(&enc_info);
1424  av_freep(&enc_buf);
1425  }
1426  #endif
1427  av_packet_unref(&new_pkt);
1428  return AVERROR(ENOMEM);
1429  }
1430 
1431  do {
1432  ret = MFXVideoENCODE_EncodeFrameAsync(q->session, enc_ctrl, surf, bs, sync);
1433  if (ret == MFX_WRN_DEVICE_BUSY)
1434  av_usleep(500);
1435  } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_WRN_IN_EXECUTION);
1436 
1437  if (ret > 0)
1438  ff_qsv_print_warning(avctx, ret, "Warning during encoding");
1439 
1440  if (ret < 0) {
1441  av_packet_unref(&new_pkt);
1442  av_freep(&bs);
1443 #if QSV_VERSION_ATLEAST(1, 26)
1444  if (avctx->codec_id == AV_CODEC_ID_H264) {
1445  av_freep(&enc_info);
1446  av_freep(&enc_buf);
1447  }
1448 #endif
1449  av_freep(&sync);
1450  return (ret == MFX_ERR_MORE_DATA) ?
1451  0 : ff_qsv_print_error(avctx, ret, "Error during encoding");
1452  }
1453 
1454  if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM && frame->interlaced_frame)
1455  print_interlace_msg(avctx, q);
1456 
1457  if (*sync) {
1458  av_fifo_generic_write(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1459  av_fifo_generic_write(q->async_fifo, &sync, sizeof(sync), NULL);
1460  av_fifo_generic_write(q->async_fifo, &bs, sizeof(bs), NULL);
1461  } else {
1462  av_freep(&sync);
1463  av_packet_unref(&new_pkt);
1464  av_freep(&bs);
1465 #if QSV_VERSION_ATLEAST(1, 26)
1466  if (avctx->codec_id == AV_CODEC_ID_H264) {
1467  av_freep(&enc_info);
1468  av_freep(&enc_buf);
1469  }
1470 #endif
1471  }
1472 
1473  return 0;
1474 }
1475 
1477  AVPacket *pkt, const AVFrame *frame, int *got_packet)
1478 {
1479  int ret;
1480 
1481  ret = encode_frame(avctx, q, frame);
1482  if (ret < 0)
1483  return ret;
1484 
1485  if ((qsv_fifo_size(q->async_fifo) >= q->async_depth) ||
1486  (!frame && av_fifo_size(q->async_fifo))) {
1487  AVPacket new_pkt;
1488  mfxBitstream *bs;
1489  mfxSyncPoint *sync;
1490 #if QSV_VERSION_ATLEAST(1, 26)
1491  mfxExtAVCEncodedFrameInfo *enc_info;
1492  mfxExtBuffer **enc_buf;
1493 #endif
1494  enum AVPictureType pict_type;
1495 
1496  av_fifo_generic_read(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1497  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1498  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1499 
1500  do {
1501  ret = MFXVideoCORE_SyncOperation(q->session, *sync, 1000);
1502  } while (ret == MFX_WRN_IN_EXECUTION);
1503 
1504  new_pkt.dts = av_rescale_q(bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
1505  new_pkt.pts = av_rescale_q(bs->TimeStamp, (AVRational){1, 90000}, avctx->time_base);
1506  new_pkt.size = bs->DataLength;
1507 
1508  if (bs->FrameType & MFX_FRAMETYPE_IDR || bs->FrameType & MFX_FRAMETYPE_xIDR) {
1509  new_pkt.flags |= AV_PKT_FLAG_KEY;
1510  pict_type = AV_PICTURE_TYPE_I;
1511  } else if (bs->FrameType & MFX_FRAMETYPE_I || bs->FrameType & MFX_FRAMETYPE_xI)
1512  pict_type = AV_PICTURE_TYPE_I;
1513  else if (bs->FrameType & MFX_FRAMETYPE_P || bs->FrameType & MFX_FRAMETYPE_xP)
1514  pict_type = AV_PICTURE_TYPE_P;
1515  else if (bs->FrameType & MFX_FRAMETYPE_B || bs->FrameType & MFX_FRAMETYPE_xB)
1516  pict_type = AV_PICTURE_TYPE_B;
1517  else if (bs->FrameType == MFX_FRAMETYPE_UNKNOWN) {
1518  pict_type = AV_PICTURE_TYPE_NONE;
1519  av_log(avctx, AV_LOG_WARNING, "Unknown FrameType, set pict_type to AV_PICTURE_TYPE_NONE.\n");
1520  } else {
1521  av_log(avctx, AV_LOG_ERROR, "Invalid FrameType:%d.\n", bs->FrameType);
1522  return AVERROR_INVALIDDATA;
1523  }
1524 
1525 #if FF_API_CODED_FRAME
1527  avctx->coded_frame->pict_type = pict_type;
1529 #endif
1530 
1531 #if QSV_VERSION_ATLEAST(1, 26)
1532  if (avctx->codec_id == AV_CODEC_ID_H264) {
1533  enc_buf = bs->ExtParam;
1534  enc_info = (mfxExtAVCEncodedFrameInfo *)(*bs->ExtParam);
1536  enc_info->QP * FF_QP2LAMBDA, NULL, 0, pict_type);
1537  av_freep(&enc_info);
1538  av_freep(&enc_buf);
1539  }
1540 #endif
1541  av_freep(&bs);
1542  av_freep(&sync);
1543 
1544  if (pkt->data) {
1545  if (pkt->size < new_pkt.size) {
1546  av_log(avctx, AV_LOG_ERROR, "Submitted buffer not large enough: %d < %d\n",
1547  pkt->size, new_pkt.size);
1548  av_packet_unref(&new_pkt);
1549  return AVERROR(EINVAL);
1550  }
1551 
1552  memcpy(pkt->data, new_pkt.data, new_pkt.size);
1553  pkt->size = new_pkt.size;
1554 
1555  ret = av_packet_copy_props(pkt, &new_pkt);
1556  av_packet_unref(&new_pkt);
1557  if (ret < 0)
1558  return ret;
1559  } else
1560  *pkt = new_pkt;
1561 
1562  *got_packet = 1;
1563  }
1564 
1565  return 0;
1566 }
1567 
1569 {
1570  QSVFrame *cur;
1571 
1572  if (q->session)
1573  MFXVideoENCODE_Close(q->session);
1574 
1575  q->session = NULL;
1577 
1580 
1581  cur = q->work_frames;
1582  while (cur) {
1583  q->work_frames = cur->next;
1584  av_frame_free(&cur->frame);
1585  av_free(cur->enc_ctrl.Payload);
1586  av_freep(&cur);
1587  cur = q->work_frames;
1588  }
1589 
1590  while (q->async_fifo && av_fifo_size(q->async_fifo)) {
1591  AVPacket pkt;
1592  mfxSyncPoint *sync;
1593  mfxBitstream *bs;
1594 
1595  av_fifo_generic_read(q->async_fifo, &pkt, sizeof(pkt), NULL);
1596  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1597  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1598 
1599  av_freep(&sync);
1600  av_freep(&bs);
1601  av_packet_unref(&pkt);
1602  }
1604  q->async_fifo = NULL;
1605 
1608 
1609  av_freep(&q->extparam);
1610 
1611  return 0;
1612 }
int single_sei_nal_unit
Definition: qsvenc.h:166
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:3110
const char const char void * val
Definition: avisynth_c.h:863
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define FF_COMPRESSION_DEFAULT
Definition: avcodec.h:1643
#define QSV_MAX_ENC_PAYLOAD
Definition: qsv_internal.h:51
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
mfxExtBuffer * extparam_internal[2+QSV_HAVE_CO2+QSV_HAVE_CO3+(QSV_HAVE_MF *2)]
Definition: qsvenc.h:135
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
AVBufferRef * opaque_alloc_buf
Definition: qsvenc.h:133
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:720
mfxExtBuffer ** extparam
Definition: qsvenc.h:138
static int init_video_param_jpeg(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:409
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:901
int int_ref_type
Definition: qsvenc.h:177
#define QSV_HAVE_LA
Definition: qsvenc.h:47
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
mfxExtOpaqueSurfaceAlloc opaque_alloc
Definition: qsvenc.h:131
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1620
Memory handling functions.
This struct is allocated as AVHWFramesContext.hwctx.
Definition: hwcontext_qsv.h:42
const char * desc
Definition: nvenc.c:68
int max_frame_size
Definition: qsvenc.h:161
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:1139
int hevc_vps
Definition: qsvenc.h:146
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:1830
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2476
mfxFrameAllocRequest req
Definition: qsvenc.h:114
int avbr_accuracy
Definition: qsvenc.h:153
mfxEncodeCtrl enc_ctrl
Definition: qsv_internal.h:73
QSVFrame * work_frames
Definition: qsvenc.h:104
int num
Numerator.
Definition: rational.h:59
int repeat_pict
When decoding, this signals how much the picture must be delayed.
Definition: frame.h:437
int look_ahead_depth
Definition: qsvenc.h:157
static int get_free_frame(QSVEncContext *q, QSVFrame **f)
Definition: qsvenc.c:1217
int size
Definition: avcodec.h:1483
int int_ref_qp_delta
Definition: qsvenc.h:179
#define UNMATCH(x)
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1949
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1780
QSVFramesContext frames_ctx
Definition: qsvenc.h:142
int packet_size
Definition: qsvenc.h:109
#define QSV_RUNTIME_VERSION_ATLEAST(MFX_VERSION, MAJOR, MINOR)
Definition: qsv_internal.h:57
int ff_qsv_init_session_device(AVCodecContext *avctx, mfxSession *psession, AVBufferRef *device_ref, const char *load_plugins, int gpu_copy)
Definition: qsv.c:720
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:84
static AVPacket pkt
int nb_opaque_surfaces
Encoding only, and only if opaque_alloc is set to non-zero.
Definition: qsv.h:76
static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1336
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:1882
int min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: avcodec.h:1148
AVBufferRef * hw_frames_ctx
Definition: qsv_internal.h:92
int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int(*func)(void *, void *, int))
Feed data from a user-supplied callback to an AVFifoBuffer.
Definition: fifo.c:122
int ff_qsv_print_error(void *log_ctx, mfxStatus err, const char *error_string)
Definition: qsv.c:224
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1693
Undefined.
Definition: avutil.h:273
int bitrate_limit
Definition: qsvenc.h:169
int look_ahead
Definition: qsvenc.h:156
int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: qsvenc.c:1476
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
mfxVideoParam param
Definition: qsvenc.h:113
uint8_t
#define QSV_HAVE_CO2
Definition: qsvenc.h:37
#define QSV_HAVE_LA_HRD
Definition: qsvenc.h:49
AVFifoBuffer * async_fifo
Definition: qsvenc.h:140
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
void * hwaccel_context
Hardware accelerator context.
Definition: avcodec.h:2746
AVBufferRef * mids_buf
Definition: qsv_internal.h:99
mfxExtCodingOption extco
Definition: qsvenc.h:116
#define f(width, name)
Definition: cbs_vp9.c:255
float b_quant_factor
qscale factor between IP and B-frames If > 0 then the last P-frame quantizer will be used (q= lastp_q...
Definition: avcodec.h:1839
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:443
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1671
int opaque_alloc
Encoding only.
Definition: qsv.h:65
mfxFrameSurface1 ** opaque_surfaces
Definition: qsvenc.h:132
uint8_t * data
Definition: avcodec.h:1482
static int qsv_retrieve_enc_jpeg_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:784
mfxU16 rc_mode
Definition: qsvenc.c:82
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
void av_fifo_free(AVFifoBuffer *f)
Free an AVFifoBuffer.
Definition: fifo.c:55
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:442
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: avcodec.h:1166
int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1568
static const char * print_threestate(mfxU16 val)
Definition: qsvenc.c:121
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
int opaque_alloc_type
Encoding only, and only if opaque_alloc is set to non-zero.
Definition: qsv.h:97
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1514
int b_strategy
Definition: qsvenc.h:174
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:86
int ff_qsv_init_session_frames(AVCodecContext *avctx, mfxSession *psession, QSVFramesContext *qsv_frames_ctx, const char *load_plugins, int opaque, int gpu_copy)
Definition: qsv.c:797
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int width
Definition: frame.h:353
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int ff_qsv_find_surface_idx(QSVFramesContext *ctx, QSVFrame *frame)
Definition: qsv.c:271
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
int qmax
maximum quantizer
Definition: avcodec.h:2419
char * load_plugins
Definition: qsvenc.h:191
int low_power
Definition: qsvenc.h:183
int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void(*func)(void *, void *, int))
Feed data from an AVFifoBuffer to a user-supplied callback.
Definition: fifo.c:213
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1650
static unsigned int qsv_fifo_item_size(void)
Definition: qsvenc.c:1046
int nb_extparam_internal
Definition: qsvenc.h:136
float i_quant_factor
qscale factor between P- and I-frames If > 0 then the last P-frame quantizer will be used (q = lastp_...
Definition: avcodec.h:1875
int max_dec_frame_buffering
Definition: qsvenc.h:167
int iopattern
The IO pattern to use.
Definition: qsv.h:46
static unsigned int qsv_fifo_size(const AVFifoBuffer *fifo)
Definition: qsvenc.c:1051
#define FFMAX(a, b)
Definition: common.h:94
int ff_qsv_close_internal_session(QSVSession *qs)
Definition: qsv.c:844
static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:851
int nb_ext_buffers
Definition: qsv.h:52
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:792
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1488
int adaptive_i
Definition: qsvenc.h:172
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2433
int ff_qsv_print_warning(void *log_ctx, mfxStatus err, const char *warning_string)
Definition: qsv.c:234
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:2455
int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc)
Definition: qsv.c:254
int refs
number of reference frames
Definition: avcodec.h:2158
static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q, mfxExtBuffer **coding_opts)
Definition: qsvenc.c:130
MIPS optimizations info
Definition: mips.txt:2
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: avpacket.c:565
const char * name
Definition: qsvenc.c:45
AVCodecContext * avctx
Definition: qsvenc.h:102
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:855
int idr_interval
Definition: qsvenc.h:150
mfxVersion ver
Definition: qsvenc.h:144
int width
picture width / height.
Definition: avcodec.h:1743
int extbrc
Definition: qsvenc.h:171
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:3267
int preset
Definition: qsvenc.h:152
int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)
Definition: qsv.c:43
static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:289
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
int level
level
Definition: avcodec.h:3023
#define MFX_LOOKAHEAD_DS_OFF
Definition: qsvenc.h:70
static const char * print_profile(mfxU16 profile)
Definition: qsvenc.c:72
mfxFrameSurface1 surface
Definition: qsv_internal.h:72
#define MFX_LOOKAHEAD_DS_2x
Definition: qsvenc.h:71
int repeat_pps
Definition: qsvenc.h:182
int async_depth
Definition: qsvenc.h:149
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
attribute_deprecated int coder_type
Definition: avcodec.h:2487
#define FF_ARRAY_ELEMS(a)
int width_align
Definition: qsvenc.h:110
if(ret)
static const struct @137 rc_names[]
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:368
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:1133
static int qsvenc_init_session(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1004
#define QSV_HAVE_CO3
Definition: qsvenc.h:38
Libavcodec external API header.
enum AVCodecID codec_id
Definition: avcodec.h:1580
int av_fifo_size(const AVFifoBuffer *f)
Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from ...
Definition: fifo.c:77
int compression_level
Definition: avcodec.h:1642
mfxExtBuffer ** ext_buffers
Extra buffers to pass to encoder or decoder initialization.
Definition: qsv.h:51
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
attribute_deprecated int b_frame_strategy
Definition: avcodec.h:1844
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
main external API structure.
Definition: avcodec.h:1570
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
uint8_t * data
The data buffer.
Definition: buffer.h:89
struct QSVFrame * next
Definition: qsv_internal.h:80
int qmin
minimum quantizer
Definition: avcodec.h:2412
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:161
#define QSV_HAVE_CO_VPS
Definition: qsvenc.h:39
int profile
Definition: qsvenc.h:151
static void free_encoder_ctrl_payloads(mfxEncodeCtrl *enc_ctrl)
Definition: qsvenc.c:1191
int extradata_size
Definition: avcodec.h:1672
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:83
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
AVBufferRef * opaque_surfaces
Encoding only, and only if opaque_alloc is set to non-zero.
Definition: qsv.h:90
int height_align
Definition: qsvenc.h:111
QSVSession internal_qs
Definition: qsvenc.h:107
#define FF_CODER_TYPE_VLC
Definition: avcodec.h:2479
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2636
int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1056
Rational number (pair of numerator and denominator).
Definition: rational.h:58
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:123
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
Definition: pixfmt.h:222
int ff_qsv_init_internal_session(AVCodecContext *avctx, QSVSession *qs, const char *load_plugins, int gpu_copy)
Definition: qsv.c:414
AVPictureType
Definition: avutil.h:272
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:1852
int max_slice_size
Definition: qsvenc.h:162
This struct is used for communicating QSV parameters between libavcodec and the caller.
Definition: qsv.h:36
mfxU16 profile
Definition: qsvenc.c:44
const uint8_t * quant
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:324
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1636
int int_ref_cycle_size
Definition: qsvenc.h:178
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
static const struct @136 profile_names[]
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1765
static int check_enc_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:378
int adaptive_b
Definition: qsvenc.h:173
#define QSV_HAVE_ICQ
Definition: qsvenc.h:62
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
common internal and external API header
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
Bi-dir predicted.
Definition: avutil.h:276
int avbr_convergence
Definition: qsvenc.h:154
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2820
int den
Denominator.
Definition: rational.h:60
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
int trellis
trellis RD quantization
Definition: avcodec.h:2519
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1973
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:795
int slices
Number of slices.
Definition: avcodec.h:2221
#define MFX_LOOKAHEAD_DS_4x
Definition: qsvenc.h:72
int forced_idr
Definition: qsvenc.h:193
int recovery_point_sei
Definition: qsvenc.h:180
#define av_free(p)
AVFifoBuffer * av_fifo_alloc(unsigned int size)
Initialize an AVFifoBuffer.
Definition: fifo.c:43
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:447
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:1157
#define QSV_HAVE_MF
Definition: qsvenc.h:65
static int qsv_retrieve_enc_vp9_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:802
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1481
int look_ahead_downsampling
Definition: qsvenc.h:158
static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:467
int height
Definition: frame.h:353
static const char * print_ratecontrol(mfxU16 rc_mode)
Definition: qsvenc.c:112
#define av_freep(p)
An API-specific header for AV_HWDEVICE_TYPE_QSV.
AVFrame * frame
Definition: qsv_internal.h:71
#define av_malloc_array(a, b)
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:923
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
int depth
Number of bits in the component.
Definition: pixdesc.h:58
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
Definition: avcodec.h:3319
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1459
mfxSession session
Definition: qsvenc.h:106
static int qsv_init_opaque_alloc(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:967
#define QSV_HAVE_VCM
Definition: qsvenc.h:63
mfxSession session
If non-NULL, the session to use for encoding or decoding.
Definition: qsv.h:41
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:2633
mfxSession session
Definition: qsv_internal.h:84
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1475
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:3117
for(j=16;j >0;--j)
int pic_timing_sei
Definition: qsvenc.h:155
#define FFMAX3(a, b, c)
Definition: common.h:95
static int encode_frame(AVCodecContext *avctx, QSVEncContext *q, const AVFrame *frame)
Definition: qsvenc.c:1348
Predicted.
Definition: avutil.h:275
static int submit_frame(QSVEncContext *q, const AVFrame *frame, QSVFrame **new_frame)
Definition: qsvenc.c:1257
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2448
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
SetEncodeCtrlCB * set_encode_ctrl_cb
Definition: qsvenc.h:192
static void clear_unused_frames(QSVEncContext *q)
Definition: qsvenc.c:1202