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  (mfxExtBuffer*)&vp9_extend_buf,
828 #if QSV_HAVE_CO2
829  (mfxExtBuffer*)&co2,
830 #endif
831 #if QSV_HAVE_CO3
832  (mfxExtBuffer*)&co3,
833 #endif
834  };
835 
836  q->param.ExtParam = ext_buffers;
837  q->param.NumExtParam = FF_ARRAY_ELEMS(ext_buffers);
838 
839  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
840  if (ret < 0)
841  return ff_qsv_print_error(avctx, ret,
842  "Error calling GetVideoParam");
843 
844  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
845 
846  return 0;
847 }
848 
850 {
851  AVCPBProperties *cpb_props;
852 
853  uint8_t sps_buf[128];
854  uint8_t pps_buf[128];
855 
856  mfxExtCodingOptionSPSPPS extradata = {
857  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
858  .Header.BufferSz = sizeof(extradata),
859  .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),
860  .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
861  };
862 
863  mfxExtCodingOption co = {
864  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
865  .Header.BufferSz = sizeof(co),
866  };
867 #if QSV_HAVE_CO2
868  mfxExtCodingOption2 co2 = {
869  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
870  .Header.BufferSz = sizeof(co2),
871  };
872 #endif
873 #if QSV_HAVE_CO3
874  mfxExtCodingOption3 co3 = {
875  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
876  .Header.BufferSz = sizeof(co3),
877  };
878 #endif
879 
880 #if QSV_HAVE_CO_VPS
881  uint8_t vps_buf[128];
882  mfxExtCodingOptionVPS extradata_vps = {
883  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_VPS,
884  .Header.BufferSz = sizeof(extradata_vps),
885  .VPSBuffer = vps_buf,
886  .VPSBufSize = sizeof(vps_buf),
887  };
888 #endif
889 
890  mfxExtBuffer *ext_buffers[2 + QSV_HAVE_CO2 + QSV_HAVE_CO3 + QSV_HAVE_CO_VPS];
891 
892  int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
893  int ret, ext_buf_num = 0, extradata_offset = 0;
894 
895  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata;
896  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co;
897 #if QSV_HAVE_CO2
898  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;
899 #endif
900 #if QSV_HAVE_CO3
901  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;
902 #endif
903 #if QSV_HAVE_CO_VPS
904  q->hevc_vps = ((avctx->codec_id == AV_CODEC_ID_HEVC) && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 17));
905  if (q->hevc_vps)
906  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata_vps;
907 #endif
908 
909  q->param.ExtParam = ext_buffers;
910  q->param.NumExtParam = ext_buf_num;
911 
912  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
913  if (ret < 0)
914  return ff_qsv_print_error(avctx, ret,
915  "Error calling GetVideoParam");
916 
917  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
918 
919  if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)
920 #if QSV_HAVE_CO_VPS
921  || (q->hevc_vps && !extradata_vps.VPSBufSize)
922 #endif
923  ) {
924  av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
925  return AVERROR_UNKNOWN;
926  }
927 
928  avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
929 #if QSV_HAVE_CO_VPS
930  avctx->extradata_size += q->hevc_vps * extradata_vps.VPSBufSize;
931 #endif
932 
934  if (!avctx->extradata)
935  return AVERROR(ENOMEM);
936 
937 #if QSV_HAVE_CO_VPS
938  if (q->hevc_vps) {
939  memcpy(avctx->extradata, vps_buf, extradata_vps.VPSBufSize);
940  extradata_offset += extradata_vps.VPSBufSize;
941  }
942 #endif
943 
944  memcpy(avctx->extradata + extradata_offset, sps_buf, extradata.SPSBufSize);
945  extradata_offset += extradata.SPSBufSize;
946  if (need_pps) {
947  memcpy(avctx->extradata + extradata_offset, pps_buf, extradata.PPSBufSize);
948  extradata_offset += extradata.PPSBufSize;
949  }
950  memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
951 
952  cpb_props = ff_add_cpb_side_data(avctx);
953  if (!cpb_props)
954  return AVERROR(ENOMEM);
955  cpb_props->max_bitrate = avctx->rc_max_rate;
956  cpb_props->min_bitrate = avctx->rc_min_rate;
957  cpb_props->avg_bitrate = avctx->bit_rate;
958  cpb_props->buffer_size = avctx->rc_buffer_size;
959 
960  dump_video_param(avctx, q, ext_buffers + 1);
961 
962  return 0;
963 }
964 
966 {
967  AVQSVContext *qsv = avctx->hwaccel_context;
968  mfxFrameSurface1 *surfaces;
969  int nb_surfaces, i;
970 
971  nb_surfaces = qsv->nb_opaque_surfaces + q->req.NumFrameSuggested;
972 
973  q->opaque_alloc_buf = av_buffer_allocz(sizeof(*surfaces) * nb_surfaces);
974  if (!q->opaque_alloc_buf)
975  return AVERROR(ENOMEM);
976 
977  q->opaque_surfaces = av_malloc_array(nb_surfaces, sizeof(*q->opaque_surfaces));
978  if (!q->opaque_surfaces)
979  return AVERROR(ENOMEM);
980 
981  surfaces = (mfxFrameSurface1*)q->opaque_alloc_buf->data;
982  for (i = 0; i < nb_surfaces; i++) {
983  surfaces[i].Info = q->req.Info;
984  q->opaque_surfaces[i] = surfaces + i;
985  }
986 
987  q->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
988  q->opaque_alloc.Header.BufferSz = sizeof(q->opaque_alloc);
989  q->opaque_alloc.In.Surfaces = q->opaque_surfaces;
990  q->opaque_alloc.In.NumSurface = nb_surfaces;
991  q->opaque_alloc.In.Type = q->req.Type;
992 
993  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->opaque_alloc;
994 
995  qsv->nb_opaque_surfaces = nb_surfaces;
997  qsv->opaque_alloc_type = q->req.Type;
998 
999  return 0;
1000 }
1001 
1003 {
1004  int ret;
1005 
1006  if (avctx->hwaccel_context) {
1007  AVQSVContext *qsv = avctx->hwaccel_context;
1008  q->session = qsv->session;
1009  } else if (avctx->hw_frames_ctx) {
1011  if (!q->frames_ctx.hw_frames_ctx)
1012  return AVERROR(ENOMEM);
1013 
1015  &q->frames_ctx, q->load_plugins,
1016  q->param.IOPattern == MFX_IOPATTERN_IN_OPAQUE_MEMORY,
1017  MFX_GPUCOPY_OFF);
1018  if (ret < 0) {
1020  return ret;
1021  }
1022 
1023  q->session = q->internal_qs.session;
1024  } else if (avctx->hw_device_ctx) {
1026  avctx->hw_device_ctx, q->load_plugins,
1027  MFX_GPUCOPY_OFF);
1028  if (ret < 0)
1029  return ret;
1030 
1031  q->session = q->internal_qs.session;
1032  } else {
1033  ret = ff_qsv_init_internal_session(avctx, &q->internal_qs,
1034  q->load_plugins, MFX_GPUCOPY_OFF);
1035  if (ret < 0)
1036  return ret;
1037 
1038  q->session = q->internal_qs.session;
1039  }
1040 
1041  return 0;
1042 }
1043 
1044 static inline unsigned int qsv_fifo_item_size(void)
1045 {
1046  return sizeof(AVPacket) + sizeof(mfxSyncPoint*) + sizeof(mfxBitstream*);
1047 }
1048 
1049 static inline unsigned int qsv_fifo_size(const AVFifoBuffer* fifo)
1050 {
1051  return av_fifo_size(fifo)/qsv_fifo_item_size();
1052 }
1053 
1055 {
1056  int iopattern = 0;
1057  int opaque_alloc = 0;
1058  int ret;
1059 
1060  q->param.AsyncDepth = q->async_depth;
1061 
1063  if (!q->async_fifo)
1064  return AVERROR(ENOMEM);
1065 
1066  if (avctx->hwaccel_context) {
1067  AVQSVContext *qsv = avctx->hwaccel_context;
1068 
1069  iopattern = qsv->iopattern;
1070  opaque_alloc = qsv->opaque_alloc;
1071  }
1072 
1073  if (avctx->hw_frames_ctx) {
1074  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1075  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
1076 
1077  if (!iopattern) {
1078  if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)
1079  iopattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
1080  else if (frames_hwctx->frame_type &
1081  (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
1082  iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
1083  }
1084  }
1085 
1086  if (!iopattern)
1087  iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
1088  q->param.IOPattern = iopattern;
1089 
1090  ret = qsvenc_init_session(avctx, q);
1091  if (ret < 0)
1092  return ret;
1093 
1094  ret = MFXQueryVersion(q->session,&q->ver);
1095  if (ret < 0) {
1096  return ff_qsv_print_error(avctx, ret,
1097  "Error querying mfx version");
1098  }
1099 
1100  // in the mfxInfoMFX struct, JPEG is different from other codecs
1101  switch (avctx->codec_id) {
1102  case AV_CODEC_ID_MJPEG:
1103  ret = init_video_param_jpeg(avctx, q);
1104  break;
1105  default:
1106  ret = init_video_param(avctx, q);
1107  break;
1108  }
1109  if (ret < 0)
1110  return ret;
1111 
1112  if (avctx->hwaccel_context) {
1113  AVQSVContext *qsv = avctx->hwaccel_context;
1114  int i, j;
1115 
1117  sizeof(*q->extparam));
1118  if (!q->extparam)
1119  return AVERROR(ENOMEM);
1120 
1121  q->param.ExtParam = q->extparam;
1122  for (i = 0; i < qsv->nb_ext_buffers; i++)
1123  q->param.ExtParam[i] = qsv->ext_buffers[i];
1124  q->param.NumExtParam = qsv->nb_ext_buffers;
1125 
1126  for (i = 0; i < q->nb_extparam_internal; i++) {
1127  for (j = 0; j < qsv->nb_ext_buffers; j++) {
1128  if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)
1129  break;
1130  }
1131  if (j < qsv->nb_ext_buffers)
1132  continue;
1133 
1134  q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];
1135  }
1136  } else {
1137  q->param.ExtParam = q->extparam_internal;
1138  q->param.NumExtParam = q->nb_extparam_internal;
1139  }
1140 
1141  ret = MFXVideoENCODE_Query(q->session, &q->param, &q->param);
1142  if (ret == MFX_WRN_PARTIAL_ACCELERATION) {
1143  av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
1144  } else if (ret < 0) {
1145  return ff_qsv_print_error(avctx, ret,
1146  "Error querying encoder params");
1147  }
1148 
1149  ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
1150  if (ret < 0)
1151  return ff_qsv_print_error(avctx, ret,
1152  "Error querying (IOSurf) the encoding parameters");
1153 
1154  if (opaque_alloc) {
1155  ret = qsv_init_opaque_alloc(avctx, q);
1156  if (ret < 0)
1157  return ret;
1158  }
1159 
1160  ret = MFXVideoENCODE_Init(q->session, &q->param);
1161  if (ret < 0)
1162  return ff_qsv_print_error(avctx, ret,
1163  "Error initializing the encoder");
1164  else if (ret > 0)
1165  ff_qsv_print_warning(avctx, ret,
1166  "Warning in encoder initialization");
1167 
1168  switch (avctx->codec_id) {
1169  case AV_CODEC_ID_MJPEG:
1170  ret = qsv_retrieve_enc_jpeg_params(avctx, q);
1171  break;
1172  case AV_CODEC_ID_VP9:
1173  ret = qsv_retrieve_enc_vp9_params(avctx, q);
1174  break;
1175  default:
1176  ret = qsv_retrieve_enc_params(avctx, q);
1177  break;
1178  }
1179  if (ret < 0) {
1180  av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
1181  return ret;
1182  }
1183 
1184  q->avctx = avctx;
1185 
1186  return 0;
1187 }
1188 
1189 static void free_encoder_ctrl_payloads(mfxEncodeCtrl* enc_ctrl)
1190 {
1191  if (enc_ctrl) {
1192  int i;
1193  for (i = 0; i < enc_ctrl->NumPayload && i < QSV_MAX_ENC_PAYLOAD; i++) {
1194  av_free(enc_ctrl->Payload[i]);
1195  }
1196  enc_ctrl->NumPayload = 0;
1197  }
1198 }
1199 
1201 {
1202  QSVFrame *cur = q->work_frames;
1203  while (cur) {
1204  if (cur->used && !cur->surface.Data.Locked) {
1206  if (cur->frame->format == AV_PIX_FMT_QSV) {
1207  av_frame_unref(cur->frame);
1208  }
1209  cur->used = 0;
1210  }
1211  cur = cur->next;
1212  }
1213 }
1214 
1216 {
1217  QSVFrame *frame, **last;
1218 
1220 
1221  frame = q->work_frames;
1222  last = &q->work_frames;
1223  while (frame) {
1224  if (!frame->used) {
1225  *f = frame;
1226  frame->used = 1;
1227  return 0;
1228  }
1229 
1230  last = &frame->next;
1231  frame = frame->next;
1232  }
1233 
1234  frame = av_mallocz(sizeof(*frame));
1235  if (!frame)
1236  return AVERROR(ENOMEM);
1237  frame->frame = av_frame_alloc();
1238  if (!frame->frame) {
1239  av_freep(&frame);
1240  return AVERROR(ENOMEM);
1241  }
1242  frame->enc_ctrl.Payload = av_mallocz(sizeof(mfxPayload*) * QSV_MAX_ENC_PAYLOAD);
1243  if (!frame->enc_ctrl.Payload) {
1244  av_freep(&frame);
1245  return AVERROR(ENOMEM);
1246  }
1247  *last = frame;
1248 
1249  *f = frame;
1250  frame->used = 1;
1251 
1252  return 0;
1253 }
1254 
1255 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
1256  QSVFrame **new_frame)
1257 {
1258  QSVFrame *qf;
1259  int ret;
1260 
1261  ret = get_free_frame(q, &qf);
1262  if (ret < 0)
1263  return ret;
1264 
1265  if (frame->format == AV_PIX_FMT_QSV) {
1266  ret = av_frame_ref(qf->frame, frame);
1267  if (ret < 0)
1268  return ret;
1269 
1270  qf->surface = *(mfxFrameSurface1*)qf->frame->data[3];
1271 
1272  if (q->frames_ctx.mids) {
1273  ret = ff_qsv_find_surface_idx(&q->frames_ctx, qf);
1274  if (ret < 0)
1275  return ret;
1276 
1277  qf->surface.Data.MemId = &q->frames_ctx.mids[ret];
1278  }
1279  } else {
1280  /* make a copy if the input is not padded as libmfx requires */
1281  /* and to make allocation continious for data[0]/data[1] */
1282  if ((frame->height & 31 || frame->linesize[0] & (q->width_align - 1)) ||
1283  (frame->data[1] - frame->data[0] != frame->linesize[0] * FFALIGN(qf->frame->height, q->height_align))) {
1284  qf->frame->height = FFALIGN(frame->height, q->height_align);
1285  qf->frame->width = FFALIGN(frame->width, q->width_align);
1286 
1287  qf->frame->format = frame->format;
1288 
1289  if (!qf->frame->data[0]) {
1290  ret = av_frame_get_buffer(qf->frame, q->width_align);
1291  if (ret < 0)
1292  return ret;
1293  }
1294 
1295  qf->frame->height = frame->height;
1296  qf->frame->width = frame->width;
1297 
1298  ret = av_frame_copy(qf->frame, frame);
1299  if (ret < 0) {
1300  av_frame_unref(qf->frame);
1301  return ret;
1302  }
1303  } else {
1304  ret = av_frame_ref(qf->frame, frame);
1305  if (ret < 0)
1306  return ret;
1307  }
1308 
1309  qf->surface.Info = q->param.mfx.FrameInfo;
1310 
1311  qf->surface.Info.PicStruct =
1312  !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
1313  frame->top_field_first ? MFX_PICSTRUCT_FIELD_TFF :
1314  MFX_PICSTRUCT_FIELD_BFF;
1315  if (frame->repeat_pict == 1)
1316  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
1317  else if (frame->repeat_pict == 2)
1318  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
1319  else if (frame->repeat_pict == 4)
1320  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
1321 
1322  qf->surface.Data.PitchLow = qf->frame->linesize[0];
1323  qf->surface.Data.Y = qf->frame->data[0];
1324  qf->surface.Data.UV = qf->frame->data[1];
1325  }
1326 
1327  qf->surface.Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
1328 
1329  *new_frame = qf;
1330 
1331  return 0;
1332 }
1333 
1335 {
1336  if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
1337  if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
1338  q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
1339  q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
1340  av_log(avctx, AV_LOG_WARNING,
1341  "Interlaced coding is supported"
1342  " at Main/High Profile Level 2.2-4.0\n");
1343  }
1344 }
1345 
1347  const AVFrame *frame)
1348 {
1349  AVPacket new_pkt = { 0 };
1350  mfxBitstream *bs;
1351 #if QSV_VERSION_ATLEAST(1, 26)
1352  mfxExtAVCEncodedFrameInfo *enc_info;
1353  mfxExtBuffer **enc_buf;
1354 #endif
1355 
1356  mfxFrameSurface1 *surf = NULL;
1357  mfxSyncPoint *sync = NULL;
1358  QSVFrame *qsv_frame = NULL;
1359  mfxEncodeCtrl* enc_ctrl = NULL;
1360  int ret;
1361 
1362  if (frame) {
1363  ret = submit_frame(q, frame, &qsv_frame);
1364  if (ret < 0) {
1365  av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
1366  return ret;
1367  }
1368  }
1369  if (qsv_frame) {
1370  surf = &qsv_frame->surface;
1371  enc_ctrl = &qsv_frame->enc_ctrl;
1372 
1373  if (frame->pict_type == AV_PICTURE_TYPE_I) {
1374  enc_ctrl->FrameType = MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF;
1375  if (q->forced_idr)
1376  enc_ctrl->FrameType |= MFX_FRAMETYPE_IDR;
1377  }
1378  }
1379 
1380  ret = av_new_packet(&new_pkt, q->packet_size);
1381  if (ret < 0) {
1382  av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
1383  return ret;
1384  }
1385 
1386  bs = av_mallocz(sizeof(*bs));
1387  if (!bs) {
1388  av_packet_unref(&new_pkt);
1389  return AVERROR(ENOMEM);
1390  }
1391  bs->Data = new_pkt.data;
1392  bs->MaxLength = new_pkt.size;
1393 
1394 #if QSV_VERSION_ATLEAST(1, 26)
1395  if (avctx->codec_id == AV_CODEC_ID_H264) {
1396  enc_info = av_mallocz(sizeof(*enc_info));
1397  if (!enc_info)
1398  return AVERROR(ENOMEM);
1399 
1400  enc_info->Header.BufferId = MFX_EXTBUFF_ENCODED_FRAME_INFO;
1401  enc_info->Header.BufferSz = sizeof (*enc_info);
1402  bs->NumExtParam = 1;
1403  enc_buf = av_mallocz(sizeof(mfxExtBuffer *));
1404  if (!enc_buf)
1405  return AVERROR(ENOMEM);
1406  enc_buf[0] = (mfxExtBuffer *)enc_info;
1407 
1408  bs->ExtParam = enc_buf;
1409  }
1410 #endif
1411 
1412  if (q->set_encode_ctrl_cb) {
1413  q->set_encode_ctrl_cb(avctx, frame, &qsv_frame->enc_ctrl);
1414  }
1415 
1416  sync = av_mallocz(sizeof(*sync));
1417  if (!sync) {
1418  av_freep(&bs);
1419  #if QSV_VERSION_ATLEAST(1, 26)
1420  if (avctx->codec_id == AV_CODEC_ID_H264) {
1421  av_freep(&enc_info);
1422  av_freep(&enc_buf);
1423  }
1424  #endif
1425  av_packet_unref(&new_pkt);
1426  return AVERROR(ENOMEM);
1427  }
1428 
1429  do {
1430  ret = MFXVideoENCODE_EncodeFrameAsync(q->session, enc_ctrl, surf, bs, sync);
1431  if (ret == MFX_WRN_DEVICE_BUSY)
1432  av_usleep(500);
1433  } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_WRN_IN_EXECUTION);
1434 
1435  if (ret > 0)
1436  ff_qsv_print_warning(avctx, ret, "Warning during encoding");
1437 
1438  if (ret < 0) {
1439  av_packet_unref(&new_pkt);
1440  av_freep(&bs);
1441 #if QSV_VERSION_ATLEAST(1, 26)
1442  if (avctx->codec_id == AV_CODEC_ID_H264) {
1443  av_freep(&enc_info);
1444  av_freep(&enc_buf);
1445  }
1446 #endif
1447  av_freep(&sync);
1448  return (ret == MFX_ERR_MORE_DATA) ?
1449  0 : ff_qsv_print_error(avctx, ret, "Error during encoding");
1450  }
1451 
1452  if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM && frame->interlaced_frame)
1453  print_interlace_msg(avctx, q);
1454 
1455  if (*sync) {
1456  av_fifo_generic_write(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1457  av_fifo_generic_write(q->async_fifo, &sync, sizeof(sync), NULL);
1458  av_fifo_generic_write(q->async_fifo, &bs, sizeof(bs), NULL);
1459  } else {
1460  av_freep(&sync);
1461  av_packet_unref(&new_pkt);
1462  av_freep(&bs);
1463 #if QSV_VERSION_ATLEAST(1, 26)
1464  if (avctx->codec_id == AV_CODEC_ID_H264) {
1465  av_freep(&enc_info);
1466  av_freep(&enc_buf);
1467  }
1468 #endif
1469  }
1470 
1471  return 0;
1472 }
1473 
1475  AVPacket *pkt, const AVFrame *frame, int *got_packet)
1476 {
1477  int ret;
1478 
1479  ret = encode_frame(avctx, q, frame);
1480  if (ret < 0)
1481  return ret;
1482 
1483  if ((qsv_fifo_size(q->async_fifo) >= q->async_depth) ||
1484  (!frame && av_fifo_size(q->async_fifo))) {
1485  AVPacket new_pkt;
1486  mfxBitstream *bs;
1487  mfxSyncPoint *sync;
1488 #if QSV_VERSION_ATLEAST(1, 26)
1489  mfxExtAVCEncodedFrameInfo *enc_info;
1490  mfxExtBuffer **enc_buf;
1491 #endif
1492  enum AVPictureType pict_type;
1493 
1494  av_fifo_generic_read(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1495  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1496  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1497 
1498  do {
1499  ret = MFXVideoCORE_SyncOperation(q->session, *sync, 1000);
1500  } while (ret == MFX_WRN_IN_EXECUTION);
1501 
1502  new_pkt.dts = av_rescale_q(bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
1503  new_pkt.pts = av_rescale_q(bs->TimeStamp, (AVRational){1, 90000}, avctx->time_base);
1504  new_pkt.size = bs->DataLength;
1505 
1506  if (bs->FrameType & MFX_FRAMETYPE_IDR || bs->FrameType & MFX_FRAMETYPE_xIDR) {
1507  new_pkt.flags |= AV_PKT_FLAG_KEY;
1508  pict_type = AV_PICTURE_TYPE_I;
1509  } else if (bs->FrameType & MFX_FRAMETYPE_I || bs->FrameType & MFX_FRAMETYPE_xI)
1510  pict_type = AV_PICTURE_TYPE_I;
1511  else if (bs->FrameType & MFX_FRAMETYPE_P || bs->FrameType & MFX_FRAMETYPE_xP)
1512  pict_type = AV_PICTURE_TYPE_P;
1513  else if (bs->FrameType & MFX_FRAMETYPE_B || bs->FrameType & MFX_FRAMETYPE_xB)
1514  pict_type = AV_PICTURE_TYPE_B;
1515  else if (bs->FrameType == MFX_FRAMETYPE_UNKNOWN) {
1516  pict_type = AV_PICTURE_TYPE_NONE;
1517  av_log(avctx, AV_LOG_WARNING, "Unknown FrameType, set pict_type to AV_PICTURE_TYPE_NONE.\n");
1518  } else {
1519  av_log(avctx, AV_LOG_ERROR, "Invalid FrameType:%d.\n", bs->FrameType);
1520  return AVERROR_INVALIDDATA;
1521  }
1522 
1523 #if FF_API_CODED_FRAME
1525  avctx->coded_frame->pict_type = pict_type;
1527 #endif
1528 
1529 #if QSV_VERSION_ATLEAST(1, 26)
1530  if (avctx->codec_id == AV_CODEC_ID_H264) {
1531  enc_buf = bs->ExtParam;
1532  enc_info = (mfxExtAVCEncodedFrameInfo *)(*bs->ExtParam);
1534  enc_info->QP * FF_QP2LAMBDA, NULL, 0, pict_type);
1535  av_freep(&enc_info);
1536  av_freep(&enc_buf);
1537  }
1538 #endif
1539  av_freep(&bs);
1540  av_freep(&sync);
1541 
1542  if (pkt->data) {
1543  if (pkt->size < new_pkt.size) {
1544  av_log(avctx, AV_LOG_ERROR, "Submitted buffer not large enough: %d < %d\n",
1545  pkt->size, new_pkt.size);
1546  av_packet_unref(&new_pkt);
1547  return AVERROR(EINVAL);
1548  }
1549 
1550  memcpy(pkt->data, new_pkt.data, new_pkt.size);
1551  pkt->size = new_pkt.size;
1552 
1553  ret = av_packet_copy_props(pkt, &new_pkt);
1554  av_packet_unref(&new_pkt);
1555  if (ret < 0)
1556  return ret;
1557  } else
1558  *pkt = new_pkt;
1559 
1560  *got_packet = 1;
1561  }
1562 
1563  return 0;
1564 }
1565 
1567 {
1568  QSVFrame *cur;
1569 
1570  if (q->session)
1571  MFXVideoENCODE_Close(q->session);
1572 
1573  q->session = NULL;
1575 
1578 
1579  cur = q->work_frames;
1580  while (cur) {
1581  q->work_frames = cur->next;
1582  av_frame_free(&cur->frame);
1583  av_free(cur->enc_ctrl.Payload);
1584  av_freep(&cur);
1585  cur = q->work_frames;
1586  }
1587 
1588  while (q->async_fifo && av_fifo_size(q->async_fifo)) {
1589  AVPacket pkt;
1590  mfxSyncPoint *sync;
1591  mfxBitstream *bs;
1592 
1593  av_fifo_generic_read(q->async_fifo, &pkt, sizeof(pkt), NULL);
1594  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1595  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1596 
1597  av_freep(&sync);
1598  av_freep(&bs);
1599  av_packet_unref(&pkt);
1600  }
1602  q->async_fifo = NULL;
1603 
1606 
1607  av_freep(&q->extparam);
1608 
1609  return 0;
1610 }
int single_sei_nal_unit
Definition: qsvenc.h:166
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:3108
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:1641
#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:899
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:1618
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:1137
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:1828
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2474
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:1215
int size
Definition: avcodec.h:1481
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:1947
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1778
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:1334
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:1880
int min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: avcodec.h:1146
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:1691
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:1474
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:2744
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:1837
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:1669
int opaque_alloc
Encoding only.
Definition: qsv.h:65
mfxFrameSurface1 ** opaque_surfaces
Definition: qsvenc.h:132
uint8_t * data
Definition: avcodec.h:1480
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:1164
int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1566
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:1512
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:2417
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:1648
static unsigned int qsv_fifo_item_size(void)
Definition: qsvenc.c:1044
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:1873
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:1049
#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:849
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:1486
int adaptive_i
Definition: qsvenc.h:172
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2431
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:2453
int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc)
Definition: qsv.c:254
int refs
number of reference frames
Definition: avcodec.h:2156
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:853
int idr_interval
Definition: qsvenc.h:150
mfxVersion ver
Definition: qsvenc.h:144
int width
picture width / height.
Definition: avcodec.h:1741
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:3265
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:3021
#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:2485
#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:1131
static int qsvenc_init_session(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1002
#define QSV_HAVE_CO3
Definition: qsvenc.h:38
Libavcodec external API header.
enum AVCodecID codec_id
Definition: avcodec.h:1578
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:1640
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:1842
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:1568
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:2410
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:1189
int extradata_size
Definition: avcodec.h:1670
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:2477
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2634
int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1054
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:1850
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:1634
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:1763
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:2818
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:2517
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:793
int slices
Number of slices.
Definition: avcodec.h:2219
#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:1155
#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:1479
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:921
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:3317
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1457
mfxSession session
Definition: qsvenc.h:106
static int qsv_init_opaque_alloc(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:965
#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:2631
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:1473
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:3115
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:1346
Predicted.
Definition: avutil.h:275
static int submit_frame(QSVEncContext *q, const AVFrame *frame, QSVFrame **new_frame)
Definition: qsvenc.c:1255
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2446
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:1200