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  q->extco.Header.BufferId = MFX_EXTBUFF_CODING_OPTION;
642  q->extco.Header.BufferSz = sizeof(q->extco);
643 
644  q->extco.PicTimingSEI = q->pic_timing_sei ?
645  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;
646 
647  if (q->rdo >= 0)
648  q->extco.RateDistortionOpt = q->rdo > 0 ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
649 
650  if (avctx->codec_id == AV_CODEC_ID_H264) {
651 #if FF_API_CODER_TYPE
653  if (avctx->coder_type >= 0)
654  q->cavlc = avctx->coder_type == FF_CODER_TYPE_VLC;
656 #endif
657  q->extco.CAVLC = q->cavlc ? MFX_CODINGOPTION_ON
658  : MFX_CODINGOPTION_UNKNOWN;
659 
661  q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?
662  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
663 
664  if (q->single_sei_nal_unit >= 0)
665  q->extco.SingleSeiNalUnit = q->single_sei_nal_unit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
666  if (q->recovery_point_sei >= 0)
667  q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
668  q->extco.MaxDecFrameBuffering = q->max_dec_frame_buffering;
669  q->extco.AUDelimiter = q->aud ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
670  }
671 
672  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco;
673 
674  if (avctx->codec_id == AV_CODEC_ID_H264) {
675 #if QSV_HAVE_CO2
676  q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
677  q->extco2.Header.BufferSz = sizeof(q->extco2);
678 
679  if (q->int_ref_type >= 0)
680  q->extco2.IntRefType = q->int_ref_type;
681  if (q->int_ref_cycle_size >= 0)
682  q->extco2.IntRefCycleSize = q->int_ref_cycle_size;
683  if (q->int_ref_qp_delta != INT16_MIN)
684  q->extco2.IntRefQPDelta = q->int_ref_qp_delta;
685 
686  if (q->bitrate_limit >= 0)
687  q->extco2.BitrateLimit = q->bitrate_limit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
688  if (q->mbbrc >= 0)
689  q->extco2.MBBRC = q->mbbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
690  if (q->extbrc >= 0)
691  q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
692 
693  if (q->max_frame_size >= 0)
694  q->extco2.MaxFrameSize = q->max_frame_size;
695 #if QSV_HAVE_MAX_SLICE_SIZE
696  if (q->max_slice_size >= 0)
697  q->extco2.MaxSliceSize = q->max_slice_size;
698 #endif
699 
700 #if QSV_HAVE_TRELLIS
701  if (avctx->trellis >= 0)
702  q->extco2.Trellis = (avctx->trellis == 0) ? MFX_TRELLIS_OFF : (MFX_TRELLIS_I | MFX_TRELLIS_P | MFX_TRELLIS_B);
703  else
704  q->extco2.Trellis = MFX_TRELLIS_UNKNOWN;
705 #endif
706 
707 #if QSV_VERSION_ATLEAST(1, 8)
708  q->extco2.LookAheadDS = q->look_ahead_downsampling;
709  q->extco2.RepeatPPS = q->repeat_pps ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
710 
711 #if FF_API_PRIVATE_OPT
713  if (avctx->b_frame_strategy >= 0)
714  q->b_strategy = avctx->b_frame_strategy;
716 #endif
717  if (q->b_strategy >= 0)
718  q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
719  if (q->adaptive_i >= 0)
720  q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
721  if (q->adaptive_b >= 0)
722  q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
723 #endif
724 
725 #if QSV_VERSION_ATLEAST(1, 9)
726  if (avctx->qmin >= 0 && avctx->qmax >= 0 && avctx->qmin > avctx->qmax) {
727  av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are set but invalid, please make sure min <= max\n");
728  return AVERROR(EINVAL);
729  }
730  if (avctx->qmin >= 0) {
731  q->extco2.MinQPI = avctx->qmin > 51 ? 51 : avctx->qmin;
732  q->extco2.MinQPP = q->extco2.MinQPB = q->extco2.MinQPI;
733  }
734  if (avctx->qmax >= 0) {
735  q->extco2.MaxQPI = avctx->qmax > 51 ? 51 : avctx->qmax;
736  q->extco2.MaxQPP = q->extco2.MaxQPB = q->extco2.MaxQPI;
737  }
738 #endif
739  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
740 #endif
741 
742 #if QSV_HAVE_MF
743  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 25)) {
744  q->extmfp.Header.BufferId = MFX_EXTBUFF_MULTI_FRAME_PARAM;
745  q->extmfp.Header.BufferSz = sizeof(q->extmfp);
746 
747  q->extmfp.MFMode = q->mfmode;
748  av_log(avctx,AV_LOG_VERBOSE,"MFMode:%d\n", q->extmfp.MFMode);
749  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extmfp;
750  }
751 #endif
752  }
753 #if QSV_HAVE_CO3
754  q->extco3.Header.BufferId = MFX_EXTBUFF_CODING_OPTION3;
755  q->extco3.Header.BufferSz = sizeof(q->extco3);
756 #if QSV_HAVE_GPB
757  if (avctx->codec_id == AV_CODEC_ID_HEVC)
758  q->extco3.GPB = q->gpb ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
759 #endif
760  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco3;
761 #endif
762  }
763 
764  if (!check_enc_param(avctx,q)) {
765  av_log(avctx, AV_LOG_ERROR,
766  "some encoding parameters are not supported by the QSV "
767  "runtime. Please double check the input parameters.\n");
768  return AVERROR(ENOSYS);
769  }
770 
771  return 0;
772 }
773 
775 {
776  int ret = 0;
777 
778  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
779  if (ret < 0)
780  return ff_qsv_print_error(avctx, ret,
781  "Error calling GetVideoParam");
782 
783  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
784 
785  // for qsv mjpeg the return value maybe 0 so alloc the buffer
786  if (q->packet_size == 0)
787  q->packet_size = q->param.mfx.FrameInfo.Height * q->param.mfx.FrameInfo.Width * 4;
788 
789  return 0;
790 }
791 
793 {
794  AVCPBProperties *cpb_props;
795 
796  uint8_t sps_buf[128];
797  uint8_t pps_buf[128];
798 
799  mfxExtCodingOptionSPSPPS extradata = {
800  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
801  .Header.BufferSz = sizeof(extradata),
802  .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),
803  .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
804  };
805 
806  mfxExtCodingOption co = {
807  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
808  .Header.BufferSz = sizeof(co),
809  };
810 #if QSV_HAVE_CO2
811  mfxExtCodingOption2 co2 = {
812  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
813  .Header.BufferSz = sizeof(co2),
814  };
815 #endif
816 #if QSV_HAVE_CO3
817  mfxExtCodingOption3 co3 = {
818  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
819  .Header.BufferSz = sizeof(co3),
820  };
821 #endif
822 
823 #if QSV_HAVE_CO_VPS
824  uint8_t vps_buf[128];
825  mfxExtCodingOptionVPS extradata_vps = {
826  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_VPS,
827  .Header.BufferSz = sizeof(extradata_vps),
828  .VPSBuffer = vps_buf,
829  .VPSBufSize = sizeof(vps_buf),
830  };
831 #endif
832 
833  mfxExtBuffer *ext_buffers[2 + QSV_HAVE_CO2 + QSV_HAVE_CO3 + QSV_HAVE_CO_VPS];
834 
835  int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
836  int ret, ext_buf_num = 0, extradata_offset = 0;
837 
838  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata;
839  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co;
840 #if QSV_HAVE_CO2
841  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;
842 #endif
843 #if QSV_HAVE_CO3
844  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;
845 #endif
846 #if QSV_HAVE_CO_VPS
847  q->hevc_vps = ((avctx->codec_id == AV_CODEC_ID_HEVC) && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 17));
848  if (q->hevc_vps)
849  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata_vps;
850 #endif
851 
852  q->param.ExtParam = ext_buffers;
853  q->param.NumExtParam = ext_buf_num;
854 
855  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
856  if (ret < 0)
857  return ff_qsv_print_error(avctx, ret,
858  "Error calling GetVideoParam");
859 
860  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
861 
862  if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)
863 #if QSV_HAVE_CO_VPS
864  || (q->hevc_vps && !extradata_vps.VPSBufSize)
865 #endif
866  ) {
867  av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
868  return AVERROR_UNKNOWN;
869  }
870 
871  avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
872 #if QSV_HAVE_CO_VPS
873  avctx->extradata_size += q->hevc_vps * extradata_vps.VPSBufSize;
874 #endif
875 
877  if (!avctx->extradata)
878  return AVERROR(ENOMEM);
879 
880 #if QSV_HAVE_CO_VPS
881  if (q->hevc_vps) {
882  memcpy(avctx->extradata, vps_buf, extradata_vps.VPSBufSize);
883  extradata_offset += extradata_vps.VPSBufSize;
884  }
885 #endif
886 
887  memcpy(avctx->extradata + extradata_offset, sps_buf, extradata.SPSBufSize);
888  extradata_offset += extradata.SPSBufSize;
889  if (need_pps) {
890  memcpy(avctx->extradata + extradata_offset, pps_buf, extradata.PPSBufSize);
891  extradata_offset += extradata.PPSBufSize;
892  }
893  memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
894 
895  cpb_props = ff_add_cpb_side_data(avctx);
896  if (!cpb_props)
897  return AVERROR(ENOMEM);
898  cpb_props->max_bitrate = avctx->rc_max_rate;
899  cpb_props->min_bitrate = avctx->rc_min_rate;
900  cpb_props->avg_bitrate = avctx->bit_rate;
901  cpb_props->buffer_size = avctx->rc_buffer_size;
902 
903  dump_video_param(avctx, q, ext_buffers + 1);
904 
905  return 0;
906 }
907 
909 {
910  AVQSVContext *qsv = avctx->hwaccel_context;
911  mfxFrameSurface1 *surfaces;
912  int nb_surfaces, i;
913 
914  nb_surfaces = qsv->nb_opaque_surfaces + q->req.NumFrameSuggested;
915 
916  q->opaque_alloc_buf = av_buffer_allocz(sizeof(*surfaces) * nb_surfaces);
917  if (!q->opaque_alloc_buf)
918  return AVERROR(ENOMEM);
919 
920  q->opaque_surfaces = av_malloc_array(nb_surfaces, sizeof(*q->opaque_surfaces));
921  if (!q->opaque_surfaces)
922  return AVERROR(ENOMEM);
923 
924  surfaces = (mfxFrameSurface1*)q->opaque_alloc_buf->data;
925  for (i = 0; i < nb_surfaces; i++) {
926  surfaces[i].Info = q->req.Info;
927  q->opaque_surfaces[i] = surfaces + i;
928  }
929 
930  q->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
931  q->opaque_alloc.Header.BufferSz = sizeof(q->opaque_alloc);
932  q->opaque_alloc.In.Surfaces = q->opaque_surfaces;
933  q->opaque_alloc.In.NumSurface = nb_surfaces;
934  q->opaque_alloc.In.Type = q->req.Type;
935 
936  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->opaque_alloc;
937 
938  qsv->nb_opaque_surfaces = nb_surfaces;
940  qsv->opaque_alloc_type = q->req.Type;
941 
942  return 0;
943 }
944 
946 {
947  int ret;
948 
949  if (avctx->hwaccel_context) {
950  AVQSVContext *qsv = avctx->hwaccel_context;
951  q->session = qsv->session;
952  } else if (avctx->hw_frames_ctx) {
954  if (!q->frames_ctx.hw_frames_ctx)
955  return AVERROR(ENOMEM);
956 
958  &q->frames_ctx, q->load_plugins,
959  q->param.IOPattern == MFX_IOPATTERN_IN_OPAQUE_MEMORY);
960  if (ret < 0) {
962  return ret;
963  }
964 
965  q->session = q->internal_session;
966  } else if (avctx->hw_device_ctx) {
968  avctx->hw_device_ctx, q->load_plugins);
969  if (ret < 0)
970  return ret;
971 
972  q->session = q->internal_session;
973  } else {
975  q->load_plugins);
976  if (ret < 0)
977  return ret;
978 
979  q->session = q->internal_session;
980  }
981 
982  return 0;
983 }
984 
985 static inline unsigned int qsv_fifo_item_size(void)
986 {
987  return sizeof(AVPacket) + sizeof(mfxSyncPoint*) + sizeof(mfxBitstream*);
988 }
989 
990 static inline unsigned int qsv_fifo_size(const AVFifoBuffer* fifo)
991 {
992  return av_fifo_size(fifo)/qsv_fifo_item_size();
993 }
994 
996 {
997  int iopattern = 0;
998  int opaque_alloc = 0;
999  int ret;
1000 
1001  q->param.AsyncDepth = q->async_depth;
1002 
1004  if (!q->async_fifo)
1005  return AVERROR(ENOMEM);
1006 
1007  if (avctx->hwaccel_context) {
1008  AVQSVContext *qsv = avctx->hwaccel_context;
1009 
1010  iopattern = qsv->iopattern;
1011  opaque_alloc = qsv->opaque_alloc;
1012  }
1013 
1014  if (avctx->hw_frames_ctx) {
1015  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1016  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
1017 
1018  if (!iopattern) {
1019  if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)
1020  iopattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
1021  else if (frames_hwctx->frame_type &
1022  (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
1023  iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
1024  }
1025  }
1026 
1027  if (!iopattern)
1028  iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
1029  q->param.IOPattern = iopattern;
1030 
1031  ret = qsvenc_init_session(avctx, q);
1032  if (ret < 0)
1033  return ret;
1034 
1035  ret = MFXQueryVersion(q->session,&q->ver);
1036  if (ret < 0) {
1037  return ff_qsv_print_error(avctx, ret,
1038  "Error querying mfx version");
1039  }
1040 
1041  // in the mfxInfoMFX struct, JPEG is different from other codecs
1042  switch (avctx->codec_id) {
1043  case AV_CODEC_ID_MJPEG:
1044  ret = init_video_param_jpeg(avctx, q);
1045  break;
1046  default:
1047  ret = init_video_param(avctx, q);
1048  break;
1049  }
1050  if (ret < 0)
1051  return ret;
1052 
1053  ret = MFXVideoENCODE_Query(q->session, &q->param, &q->param);
1054  if (ret == MFX_WRN_PARTIAL_ACCELERATION) {
1055  av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
1056  } else if (ret < 0) {
1057  return ff_qsv_print_error(avctx, ret,
1058  "Error querying encoder params");
1059  }
1060 
1061  ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
1062  if (ret < 0)
1063  return ff_qsv_print_error(avctx, ret,
1064  "Error querying (IOSurf) the encoding parameters");
1065 
1066  if (opaque_alloc) {
1067  ret = qsv_init_opaque_alloc(avctx, q);
1068  if (ret < 0)
1069  return ret;
1070  }
1071 
1072  if (avctx->hwaccel_context) {
1073  AVQSVContext *qsv = avctx->hwaccel_context;
1074  int i, j;
1075 
1077  sizeof(*q->extparam));
1078  if (!q->extparam)
1079  return AVERROR(ENOMEM);
1080 
1081  q->param.ExtParam = q->extparam;
1082  for (i = 0; i < qsv->nb_ext_buffers; i++)
1083  q->param.ExtParam[i] = qsv->ext_buffers[i];
1084  q->param.NumExtParam = qsv->nb_ext_buffers;
1085 
1086  for (i = 0; i < q->nb_extparam_internal; i++) {
1087  for (j = 0; j < qsv->nb_ext_buffers; j++) {
1088  if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)
1089  break;
1090  }
1091  if (j < qsv->nb_ext_buffers)
1092  continue;
1093 
1094  q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];
1095  }
1096  } else {
1097  q->param.ExtParam = q->extparam_internal;
1098  q->param.NumExtParam = q->nb_extparam_internal;
1099  }
1100 
1101  ret = MFXVideoENCODE_Init(q->session, &q->param);
1102  if (ret < 0)
1103  return ff_qsv_print_error(avctx, ret,
1104  "Error initializing the encoder");
1105  else if (ret > 0)
1106  ff_qsv_print_warning(avctx, ret,
1107  "Warning in encoder initialization");
1108 
1109  switch (avctx->codec_id) {
1110  case AV_CODEC_ID_MJPEG:
1111  ret = qsv_retrieve_enc_jpeg_params(avctx, q);
1112  break;
1113  default:
1114  ret = qsv_retrieve_enc_params(avctx, q);
1115  break;
1116  }
1117  if (ret < 0) {
1118  av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
1119  return ret;
1120  }
1121 
1122  q->avctx = avctx;
1123 
1124  return 0;
1125 }
1126 
1127 static void free_encoder_ctrl_payloads(mfxEncodeCtrl* enc_ctrl)
1128 {
1129  if (enc_ctrl) {
1130  int i;
1131  for (i = 0; i < enc_ctrl->NumPayload && i < QSV_MAX_ENC_PAYLOAD; i++) {
1132  av_free(enc_ctrl->Payload[i]);
1133  }
1134  enc_ctrl->NumPayload = 0;
1135  }
1136 }
1137 
1139 {
1140  QSVFrame *cur = q->work_frames;
1141  while (cur) {
1142  if (cur->used && !cur->surface.Data.Locked) {
1144  if (cur->frame->format == AV_PIX_FMT_QSV) {
1145  av_frame_unref(cur->frame);
1146  }
1147  cur->used = 0;
1148  }
1149  cur = cur->next;
1150  }
1151 }
1152 
1154 {
1155  QSVFrame *frame, **last;
1156 
1158 
1159  frame = q->work_frames;
1160  last = &q->work_frames;
1161  while (frame) {
1162  if (!frame->used) {
1163  *f = frame;
1164  frame->used = 1;
1165  return 0;
1166  }
1167 
1168  last = &frame->next;
1169  frame = frame->next;
1170  }
1171 
1172  frame = av_mallocz(sizeof(*frame));
1173  if (!frame)
1174  return AVERROR(ENOMEM);
1175  frame->frame = av_frame_alloc();
1176  if (!frame->frame) {
1177  av_freep(&frame);
1178  return AVERROR(ENOMEM);
1179  }
1180  frame->enc_ctrl.Payload = av_mallocz(sizeof(mfxPayload*) * QSV_MAX_ENC_PAYLOAD);
1181  if (!frame->enc_ctrl.Payload) {
1182  av_freep(&frame);
1183  return AVERROR(ENOMEM);
1184  }
1185  *last = frame;
1186 
1187  *f = frame;
1188  frame->used = 1;
1189 
1190  return 0;
1191 }
1192 
1193 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
1194  QSVFrame **new_frame)
1195 {
1196  QSVFrame *qf;
1197  int ret;
1198 
1199  ret = get_free_frame(q, &qf);
1200  if (ret < 0)
1201  return ret;
1202 
1203  if (frame->format == AV_PIX_FMT_QSV) {
1204  ret = av_frame_ref(qf->frame, frame);
1205  if (ret < 0)
1206  return ret;
1207 
1208  qf->surface = *(mfxFrameSurface1*)qf->frame->data[3];
1209 
1210  if (q->frames_ctx.mids) {
1211  ret = ff_qsv_find_surface_idx(&q->frames_ctx, qf);
1212  if (ret < 0)
1213  return ret;
1214 
1215  qf->surface.Data.MemId = &q->frames_ctx.mids[ret];
1216  }
1217  } else {
1218  /* make a copy if the input is not padded as libmfx requires */
1219  /* and to make allocation continious for data[0]/data[1] */
1220  if ((frame->height & 31 || frame->linesize[0] & (q->width_align - 1)) ||
1221  (frame->data[1] - frame->data[0] != frame->linesize[0] * FFALIGN(qf->frame->height, q->height_align))) {
1222  qf->frame->height = FFALIGN(frame->height, q->height_align);
1223  qf->frame->width = FFALIGN(frame->width, q->width_align);
1224 
1225  qf->frame->format = frame->format;
1226 
1227  if (!qf->frame->data[0]) {
1228  ret = av_frame_get_buffer(qf->frame, q->width_align);
1229  if (ret < 0)
1230  return ret;
1231  }
1232 
1233  qf->frame->height = frame->height;
1234  qf->frame->width = frame->width;
1235 
1236  ret = av_frame_copy(qf->frame, frame);
1237  if (ret < 0) {
1238  av_frame_unref(qf->frame);
1239  return ret;
1240  }
1241  } else {
1242  ret = av_frame_ref(qf->frame, frame);
1243  if (ret < 0)
1244  return ret;
1245  }
1246 
1247  qf->surface.Info = q->param.mfx.FrameInfo;
1248 
1249  qf->surface.Info.PicStruct =
1250  !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
1251  frame->top_field_first ? MFX_PICSTRUCT_FIELD_TFF :
1252  MFX_PICSTRUCT_FIELD_BFF;
1253  if (frame->repeat_pict == 1)
1254  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
1255  else if (frame->repeat_pict == 2)
1256  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
1257  else if (frame->repeat_pict == 4)
1258  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
1259 
1260  qf->surface.Data.PitchLow = qf->frame->linesize[0];
1261  qf->surface.Data.Y = qf->frame->data[0];
1262  qf->surface.Data.UV = qf->frame->data[1];
1263  }
1264 
1265  qf->surface.Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
1266 
1267  *new_frame = qf;
1268 
1269  return 0;
1270 }
1271 
1273 {
1274  if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
1275  if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
1276  q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
1277  q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
1278  av_log(avctx, AV_LOG_WARNING,
1279  "Interlaced coding is supported"
1280  " at Main/High Profile Level 2.2-4.0\n");
1281  }
1282 }
1283 
1285  const AVFrame *frame)
1286 {
1287  AVPacket new_pkt = { 0 };
1288  mfxBitstream *bs;
1289 #if QSV_VERSION_ATLEAST(1, 26)
1290  mfxExtAVCEncodedFrameInfo *enc_info;
1291  mfxExtBuffer **enc_buf;
1292 #endif
1293 
1294  mfxFrameSurface1 *surf = NULL;
1295  mfxSyncPoint *sync = NULL;
1296  QSVFrame *qsv_frame = NULL;
1297  mfxEncodeCtrl* enc_ctrl = NULL;
1298  int ret;
1299 
1300  if (frame) {
1301  ret = submit_frame(q, frame, &qsv_frame);
1302  if (ret < 0) {
1303  av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
1304  return ret;
1305  }
1306  }
1307  if (qsv_frame) {
1308  surf = &qsv_frame->surface;
1309  enc_ctrl = &qsv_frame->enc_ctrl;
1310 
1311  if (frame->pict_type == AV_PICTURE_TYPE_I) {
1312  enc_ctrl->FrameType = MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF;
1313  if (q->forced_idr)
1314  enc_ctrl->FrameType |= MFX_FRAMETYPE_IDR;
1315  }
1316  }
1317 
1318  ret = av_new_packet(&new_pkt, q->packet_size);
1319  if (ret < 0) {
1320  av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
1321  return ret;
1322  }
1323 
1324  bs = av_mallocz(sizeof(*bs));
1325  if (!bs) {
1326  av_packet_unref(&new_pkt);
1327  return AVERROR(ENOMEM);
1328  }
1329  bs->Data = new_pkt.data;
1330  bs->MaxLength = new_pkt.size;
1331 
1332 #if QSV_VERSION_ATLEAST(1, 26)
1333  if (avctx->codec_id == AV_CODEC_ID_H264) {
1334  enc_info = av_mallocz(sizeof(*enc_info));
1335  if (!enc_info)
1336  return AVERROR(ENOMEM);
1337 
1338  enc_info->Header.BufferId = MFX_EXTBUFF_ENCODED_FRAME_INFO;
1339  enc_info->Header.BufferSz = sizeof (*enc_info);
1340  bs->NumExtParam = 1;
1341  enc_buf = av_mallocz(sizeof(mfxExtBuffer *));
1342  if (!enc_buf)
1343  return AVERROR(ENOMEM);
1344  enc_buf[0] = (mfxExtBuffer *)enc_info;
1345 
1346  bs->ExtParam = enc_buf;
1347  }
1348 #endif
1349 
1350  if (q->set_encode_ctrl_cb) {
1351  q->set_encode_ctrl_cb(avctx, frame, &qsv_frame->enc_ctrl);
1352  }
1353 
1354  sync = av_mallocz(sizeof(*sync));
1355  if (!sync) {
1356  av_freep(&bs);
1357  #if QSV_VERSION_ATLEAST(1, 26)
1358  if (avctx->codec_id == AV_CODEC_ID_H264) {
1359  av_freep(&enc_info);
1360  av_freep(&enc_buf);
1361  }
1362  #endif
1363  av_packet_unref(&new_pkt);
1364  return AVERROR(ENOMEM);
1365  }
1366 
1367  do {
1368  ret = MFXVideoENCODE_EncodeFrameAsync(q->session, enc_ctrl, surf, bs, sync);
1369  if (ret == MFX_WRN_DEVICE_BUSY)
1370  av_usleep(500);
1371  } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_WRN_IN_EXECUTION);
1372 
1373  if (ret > 0)
1374  ff_qsv_print_warning(avctx, ret, "Warning during encoding");
1375 
1376  if (ret < 0) {
1377  av_packet_unref(&new_pkt);
1378  av_freep(&bs);
1379 #if QSV_VERSION_ATLEAST(1, 26)
1380  if (avctx->codec_id == AV_CODEC_ID_H264) {
1381  av_freep(&enc_info);
1382  av_freep(&enc_buf);
1383  }
1384 #endif
1385  av_freep(&sync);
1386  return (ret == MFX_ERR_MORE_DATA) ?
1387  0 : ff_qsv_print_error(avctx, ret, "Error during encoding");
1388  }
1389 
1390  if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM && frame->interlaced_frame)
1391  print_interlace_msg(avctx, q);
1392 
1393  if (*sync) {
1394  av_fifo_generic_write(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1395  av_fifo_generic_write(q->async_fifo, &sync, sizeof(sync), NULL);
1396  av_fifo_generic_write(q->async_fifo, &bs, sizeof(bs), NULL);
1397  } else {
1398  av_freep(&sync);
1399  av_packet_unref(&new_pkt);
1400  av_freep(&bs);
1401 #if QSV_VERSION_ATLEAST(1, 26)
1402  if (avctx->codec_id == AV_CODEC_ID_H264) {
1403  av_freep(&enc_info);
1404  av_freep(&enc_buf);
1405  }
1406 #endif
1407  }
1408 
1409  return 0;
1410 }
1411 
1413  AVPacket *pkt, const AVFrame *frame, int *got_packet)
1414 {
1415  int ret;
1416 
1417  ret = encode_frame(avctx, q, frame);
1418  if (ret < 0)
1419  return ret;
1420 
1421  if ((qsv_fifo_size(q->async_fifo) >= q->async_depth) ||
1422  (!frame && av_fifo_size(q->async_fifo))) {
1423  AVPacket new_pkt;
1424  mfxBitstream *bs;
1425  mfxSyncPoint *sync;
1426 #if QSV_VERSION_ATLEAST(1, 26)
1427  mfxExtAVCEncodedFrameInfo *enc_info;
1428  mfxExtBuffer **enc_buf;
1429 #endif
1430  enum AVPictureType pict_type;
1431 
1432  av_fifo_generic_read(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1433  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1434  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1435 
1436  do {
1437  ret = MFXVideoCORE_SyncOperation(q->session, *sync, 1000);
1438  } while (ret == MFX_WRN_IN_EXECUTION);
1439 
1440  new_pkt.dts = av_rescale_q(bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
1441  new_pkt.pts = av_rescale_q(bs->TimeStamp, (AVRational){1, 90000}, avctx->time_base);
1442  new_pkt.size = bs->DataLength;
1443 
1444  if (bs->FrameType & MFX_FRAMETYPE_IDR || bs->FrameType & MFX_FRAMETYPE_xIDR) {
1445  new_pkt.flags |= AV_PKT_FLAG_KEY;
1446  pict_type = AV_PICTURE_TYPE_I;
1447  } else if (bs->FrameType & MFX_FRAMETYPE_I || bs->FrameType & MFX_FRAMETYPE_xI)
1448  pict_type = AV_PICTURE_TYPE_I;
1449  else if (bs->FrameType & MFX_FRAMETYPE_P || bs->FrameType & MFX_FRAMETYPE_xP)
1450  pict_type = AV_PICTURE_TYPE_P;
1451  else if (bs->FrameType & MFX_FRAMETYPE_B || bs->FrameType & MFX_FRAMETYPE_xB)
1452  pict_type = AV_PICTURE_TYPE_B;
1453  else if (bs->FrameType == MFX_FRAMETYPE_UNKNOWN) {
1454  pict_type = AV_PICTURE_TYPE_NONE;
1455  av_log(avctx, AV_LOG_WARNING, "Unknown FrameType, set pict_type to AV_PICTURE_TYPE_NONE.\n");
1456  } else {
1457  av_log(avctx, AV_LOG_ERROR, "Invalid FrameType:%d.\n", bs->FrameType);
1458  return AVERROR_INVALIDDATA;
1459  }
1460 
1461 #if FF_API_CODED_FRAME
1463  avctx->coded_frame->pict_type = pict_type;
1465 #endif
1466 
1467 #if QSV_VERSION_ATLEAST(1, 26)
1468  if (avctx->codec_id == AV_CODEC_ID_H264) {
1469  enc_buf = bs->ExtParam;
1470  enc_info = (mfxExtAVCEncodedFrameInfo *)(*bs->ExtParam);
1472  enc_info->QP * FF_QP2LAMBDA, NULL, 0, pict_type);
1473  av_freep(&enc_info);
1474  av_freep(&enc_buf);
1475  }
1476 #endif
1477  av_freep(&bs);
1478  av_freep(&sync);
1479 
1480  if (pkt->data) {
1481  if (pkt->size < new_pkt.size) {
1482  av_log(avctx, AV_LOG_ERROR, "Submitted buffer not large enough: %d < %d\n",
1483  pkt->size, new_pkt.size);
1484  av_packet_unref(&new_pkt);
1485  return AVERROR(EINVAL);
1486  }
1487 
1488  memcpy(pkt->data, new_pkt.data, new_pkt.size);
1489  pkt->size = new_pkt.size;
1490 
1491  ret = av_packet_copy_props(pkt, &new_pkt);
1492  av_packet_unref(&new_pkt);
1493  if (ret < 0)
1494  return ret;
1495  } else
1496  *pkt = new_pkt;
1497 
1498  *got_packet = 1;
1499  }
1500 
1501  return 0;
1502 }
1503 
1505 {
1506  QSVFrame *cur;
1507 
1508  if (q->session)
1509  MFXVideoENCODE_Close(q->session);
1510  if (q->internal_session)
1511  MFXClose(q->internal_session);
1512  q->session = NULL;
1513  q->internal_session = NULL;
1514 
1517 
1518  cur = q->work_frames;
1519  while (cur) {
1520  q->work_frames = cur->next;
1521  av_frame_free(&cur->frame);
1522  av_free(cur->enc_ctrl.Payload);
1523  av_freep(&cur);
1524  cur = q->work_frames;
1525  }
1526 
1527  while (q->async_fifo && av_fifo_size(q->async_fifo)) {
1528  AVPacket pkt;
1529  mfxSyncPoint *sync;
1530  mfxBitstream *bs;
1531 
1532  av_fifo_generic_read(q->async_fifo, &pkt, sizeof(pkt), NULL);
1533  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1534  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1535 
1536  av_freep(&sync);
1537  av_freep(&bs);
1538  av_packet_unref(&pkt);
1539  }
1541  q->async_fifo = NULL;
1542 
1545 
1546  av_freep(&q->extparam);
1547 
1548  return 0;
1549 }
int single_sei_nal_unit
Definition: qsvenc.h:160
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:3105
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:1638
#define QSV_MAX_ENC_PAYLOAD
Definition: qsv_internal.h:35
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:129
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:127
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:132
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:896
int int_ref_type
Definition: qsvenc.h:171
#define QSV_HAVE_LA
Definition: qsvenc.h:45
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
mfxExtOpaqueSurfaceAlloc opaque_alloc
Definition: qsvenc.h:125
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1615
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:155
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:1134
int hevc_vps
Definition: qsvenc.h:140
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:1825
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2471
mfxFrameAllocRequest req
Definition: qsvenc.h:112
int avbr_accuracy
Definition: qsvenc.h:147
mfxEncodeCtrl enc_ctrl
Definition: qsv_internal.h:57
QSVFrame * work_frames
Definition: qsvenc.h:102
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:151
static int get_free_frame(QSVEncContext *q, QSVFrame **f)
Definition: qsvenc.c:1153
int size
Definition: avcodec.h:1478
int int_ref_qp_delta
Definition: qsvenc.h:173
#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:1944
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
QSVFramesContext frames_ctx
Definition: qsvenc.h:136
int packet_size
Definition: qsvenc.h:107
#define QSV_RUNTIME_VERSION_ATLEAST(MFX_VERSION, MAJOR, MINOR)
Definition: qsv_internal.h:41
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
mfxSession internal_session
Definition: qsvenc.h:105
static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1272
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:1877
int min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: avcodec.h:1143
AVBufferRef * hw_frames_ctx
Definition: qsv_internal.h:68
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:195
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1688
Undefined.
Definition: avutil.h:273
int bitrate_limit
Definition: qsvenc.h:163
int look_ahead
Definition: qsvenc.h:150
int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: qsvenc.c:1412
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
mfxVideoParam param
Definition: qsvenc.h:111
uint8_t
#define QSV_HAVE_CO2
Definition: qsvenc.h:37
#define QSV_HAVE_LA_HRD
Definition: qsvenc.h:47
AVFifoBuffer * async_fifo
Definition: qsvenc.h:134
#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:2741
AVBufferRef * mids_buf
Definition: qsv_internal.h:75
mfxExtCodingOption extco
Definition: qsvenc.h:114
#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:1834
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:1666
int opaque_alloc
Encoding only.
Definition: qsv.h:65
mfxFrameSurface1 ** opaque_surfaces
Definition: qsvenc.h:126
uint8_t * data
Definition: avcodec.h:1477
static int qsv_retrieve_enc_jpeg_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:774
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:1161
int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1504
static const char * print_threestate(mfxU16 val)
Definition: qsvenc.c:121
int ff_qsv_init_session_frames(AVCodecContext *avctx, mfxSession *psession, QSVFramesContext *qsv_frames_ctx, const char *load_plugins, int opaque)
Definition: qsv.c:715
#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:1509
int b_strategy
Definition: qsvenc.h:168
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
#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:242
static const struct @133 profile_names[]
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:2414
char * load_plugins
Definition: qsvenc.h:185
int low_power
Definition: qsvenc.h:177
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:1645
static unsigned int qsv_fifo_item_size(void)
Definition: qsvenc.c:985
int nb_extparam_internal
Definition: qsvenc.h:130
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:1870
int max_dec_frame_buffering
Definition: qsvenc.h:161
int iopattern
The IO pattern to use.
Definition: qsv.h:46
static unsigned int qsv_fifo_size(const AVFifoBuffer *fifo)
Definition: qsvenc.c:990
#define FFMAX(a, b)
Definition: common.h:94
static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:792
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:1483
int adaptive_i
Definition: qsvenc.h:166
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2428
int ff_qsv_print_warning(void *log_ctx, mfxStatus err, const char *warning_string)
Definition: qsv.c:205
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:2450
int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc)
Definition: qsv.c:225
int refs
number of reference frames
Definition: avcodec.h:2153
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:100
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:850
int idr_interval
Definition: qsvenc.h:144
mfxVersion ver
Definition: qsvenc.h:138
int width
picture width / height.
Definition: avcodec.h:1738
int extbrc
Definition: qsvenc.h:165
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:3262
int preset
Definition: qsvenc.h:146
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:3018
#define MFX_LOOKAHEAD_DS_OFF
Definition: qsvenc.h:68
static const char * print_profile(mfxU16 profile)
Definition: qsvenc.c:72
mfxFrameSurface1 surface
Definition: qsv_internal.h:56
#define MFX_LOOKAHEAD_DS_2x
Definition: qsvenc.h:69
int repeat_pps
Definition: qsvenc.h:176
int async_depth
Definition: qsvenc.h:143
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
attribute_deprecated int coder_type
Definition: avcodec.h:2482
#define FF_ARRAY_ELEMS(a)
int width_align
Definition: qsvenc.h:108
if(ret)
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:1128
static int qsvenc_init_session(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:945
#define QSV_HAVE_CO3
Definition: qsvenc.h:38
Libavcodec external API header.
enum AVCodecID codec_id
Definition: avcodec.h:1575
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:1637
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:1839
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:1565
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:64
int qmin
minimum quantizer
Definition: avcodec.h:2407
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:145
static void free_encoder_ctrl_payloads(mfxEncodeCtrl *enc_ctrl)
Definition: qsvenc.c:1127
int extradata_size
Definition: avcodec.h:1667
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:109
#define FF_CODER_TYPE_VLC
Definition: avcodec.h:2474
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2631
int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:995
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
AVPictureType
Definition: avutil.h:272
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:1847
int max_slice_size
Definition: qsvenc.h:156
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:1631
int int_ref_cycle_size
Definition: qsvenc.h:172
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1760
static int check_enc_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:378
int adaptive_b
Definition: qsvenc.h:167
#define QSV_HAVE_ICQ
Definition: qsvenc.h:60
#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:148
int ff_qsv_init_internal_session(AVCodecContext *avctx, mfxSession *session, const char *load_plugins)
Definition: qsv.c:351
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2815
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:2514
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1954
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:790
int slices
Number of slices.
Definition: avcodec.h:2216
#define MFX_LOOKAHEAD_DS_4x
Definition: qsvenc.h:70
int forced_idr
Definition: qsvenc.h:187
int recovery_point_sei
Definition: qsvenc.h:174
#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
static const struct @134 rc_names[]
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:1152
#define QSV_HAVE_MF
Definition: qsvenc.h:63
#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:1476
int look_ahead_downsampling
Definition: qsvenc.h:152
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:55
#define av_malloc_array(a, b)
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:918
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:3314
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1454
mfxSession session
Definition: qsvenc.h:104
static int qsv_init_opaque_alloc(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:908
#define QSV_HAVE_VCM
Definition: qsvenc.h:61
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:2628
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:3112
for(j=16;j >0;--j)
int pic_timing_sei
Definition: qsvenc.h:149
#define FFMAX3(a, b, c)
Definition: common.h:95
static int encode_frame(AVCodecContext *avctx, QSVEncContext *q, const AVFrame *frame)
Definition: qsvenc.c:1284
Predicted.
Definition: avutil.h:275
int ff_qsv_init_session_device(AVCodecContext *avctx, mfxSession *psession, AVBufferRef *device_ref, const char *load_plugins)
Definition: qsv.c:645
static int submit_frame(QSVEncContext *q, const AVFrame *frame, QSVFrame **new_frame)
Definition: qsvenc.c:1193
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2443
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
SetEncodeCtrlCB * set_encode_ctrl_cb
Definition: qsvenc.h:186
static void clear_unused_frames(QSVEncContext *q)
Definition: qsvenc.c:1138