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