FFmpeg  4.2.3
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
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:190
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
static AVFrame * frame
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:692
#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:237
static const struct @133 profile_names[]
#define AVERROR(e)
Definition: error.h:43
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
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 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:200
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:220
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
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
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
if(ret< 0)
Definition: vf_mcdeint.c:279
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
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:328
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: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: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
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:622
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)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:191
SetEncodeCtrlCB * set_encode_ctrl_cb
Definition: qsvenc.h:186
static void clear_unused_frames(QSVEncContext *q)
Definition: qsvenc.c:1138