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 <mfxvideo.h>
27 
28 #include "libavutil/avassert.h"
29 #include "libavutil/common.h"
30 #include "libavutil/hwcontext.h"
32 #include "libavutil/mem.h"
33 #include "libavutil/log.h"
34 #include "libavutil/time.h"
35 #include "libavutil/imgutils.h"
36 
37 #include "avcodec.h"
38 #include "encode.h"
39 #include "internal.h"
40 #include "packet_internal.h"
41 #include "qsv.h"
42 #include "qsv_internal.h"
43 #include "qsvenc.h"
44 
45 struct profile_names {
46  mfxU16 profile;
47  const char *name;
48 };
49 
50 static const struct profile_names avc_profiles[] = {
51  { MFX_PROFILE_AVC_BASELINE, "avc baseline" },
52  { MFX_PROFILE_AVC_MAIN, "avc main" },
53  { MFX_PROFILE_AVC_EXTENDED, "avc extended" },
54  { MFX_PROFILE_AVC_HIGH, "avc high" },
55  { MFX_PROFILE_AVC_HIGH_422, "avc high 422" },
56  { MFX_PROFILE_AVC_CONSTRAINED_BASELINE, "avc constrained baseline" },
57  { MFX_PROFILE_AVC_CONSTRAINED_HIGH, "avc constrained high" },
58  { MFX_PROFILE_AVC_PROGRESSIVE_HIGH, "avc progressive high" },
59 };
60 
61 static const struct profile_names mpeg2_profiles[] = {
62  { MFX_PROFILE_MPEG2_SIMPLE, "mpeg2 simple" },
63  { MFX_PROFILE_MPEG2_MAIN, "mpeg2 main" },
64  { MFX_PROFILE_MPEG2_HIGH, "mpeg2 high" },
65 };
66 
67 static const struct profile_names hevc_profiles[] = {
68  { MFX_PROFILE_HEVC_MAIN, "hevc main" },
69  { MFX_PROFILE_HEVC_MAIN10, "hevc main10" },
70  { MFX_PROFILE_HEVC_MAINSP, "hevc mainsp" },
71  { MFX_PROFILE_HEVC_REXT, "hevc rext" },
72 #if QSV_VERSION_ATLEAST(1, 32)
73  { MFX_PROFILE_HEVC_SCC, "hevc scc" },
74 #endif
75 };
76 
77 static const struct profile_names vp9_profiles[] = {
78  { MFX_PROFILE_VP9_0, "vp9 0" },
79  { MFX_PROFILE_VP9_1, "vp9 1" },
80  { MFX_PROFILE_VP9_2, "vp9 2" },
81  { MFX_PROFILE_VP9_3, "vp9 3" },
82 };
83 
84 static const struct profile_names av1_profiles[] = {
85 #if QSV_VERSION_ATLEAST(1, 34)
86  { MFX_PROFILE_AV1_MAIN, "av1 main" },
87  { MFX_PROFILE_AV1_HIGH, "av1 high" },
88  { MFX_PROFILE_AV1_PRO, "av1 professional" },
89 #endif
90 };
91 
92 typedef struct QSVPacket {
94  mfxSyncPoint *sync;
95  mfxBitstream *bs;
96 } QSVPacket;
97 
98 static const char *print_profile(enum AVCodecID codec_id, mfxU16 profile)
99 {
100  const struct profile_names *profiles;
101  int i, num_profiles;
102 
103  switch (codec_id) {
104  case AV_CODEC_ID_H264:
106  num_profiles = FF_ARRAY_ELEMS(avc_profiles);
107  break;
108 
111  num_profiles = FF_ARRAY_ELEMS(mpeg2_profiles);
112  break;
113 
114  case AV_CODEC_ID_HEVC:
116  num_profiles = FF_ARRAY_ELEMS(hevc_profiles);
117  break;
118 
119  case AV_CODEC_ID_VP9:
121  num_profiles = FF_ARRAY_ELEMS(vp9_profiles);
122  break;
123 
124  case AV_CODEC_ID_AV1:
126  num_profiles = FF_ARRAY_ELEMS(av1_profiles);
127  break;
128 
129  default:
130  return "unknown";
131  }
132 
133  for (i = 0; i < num_profiles; i++)
134  if (profile == profiles[i].profile)
135  return profiles[i].name;
136 
137  return "unknown";
138 }
139 
140 static const struct {
141  mfxU16 rc_mode;
142  const char *name;
143 } rc_names[] = {
144  { MFX_RATECONTROL_CBR, "CBR" },
145  { MFX_RATECONTROL_VBR, "VBR" },
146  { MFX_RATECONTROL_CQP, "CQP" },
147 #if QSV_HAVE_AVBR
148  { MFX_RATECONTROL_AVBR, "AVBR" },
149 #endif
150  { MFX_RATECONTROL_LA, "LA" },
151  { MFX_RATECONTROL_ICQ, "ICQ" },
152  { MFX_RATECONTROL_LA_ICQ, "LA_ICQ" },
153 #if QSV_HAVE_VCM
154  { MFX_RATECONTROL_VCM, "VCM" },
155 #endif
156 #if !QSV_ONEVPL
157  { MFX_RATECONTROL_LA_EXT, "LA_EXT" },
158 #endif
159  { MFX_RATECONTROL_LA_HRD, "LA_HRD" },
160  { MFX_RATECONTROL_QVBR, "QVBR" },
161 };
162 
163 #define UPDATE_PARAM(a, b) \
164 do { \
165  if ((a) != (b)) { \
166  a = b; \
167  updated = 1; \
168  } \
169 } while (0) \
170 
171 #define MFX_IMPL_VIA_MASK(impl) (0x0f00 & (impl))
172 
173 static const char *print_ratecontrol(mfxU16 rc_mode)
174 {
175  int i;
176  for (i = 0; i < FF_ARRAY_ELEMS(rc_names); i++)
177  if (rc_mode == rc_names[i].rc_mode)
178  return rc_names[i].name;
179  return "unknown";
180 }
181 
182 static const char *print_threestate(mfxU16 val)
183 {
184  if (val == MFX_CODINGOPTION_ON)
185  return "ON";
186  else if (val == MFX_CODINGOPTION_OFF)
187  return "OFF";
188  return "unknown";
189 }
190 
192  mfxExtBuffer **coding_opts)
193 {
194  mfxInfoMFX *info = &q->param.mfx;
195 
196  // co is always at index 1
197  mfxExtCodingOption *co = (mfxExtCodingOption*)coding_opts[1];
198  mfxExtCodingOption2 *co2 = NULL;
199  mfxExtCodingOption3 *co3 = NULL;
200  mfxExtHEVCTiles *exthevctiles = NULL;
201 #if QSV_HAVE_HE
202  mfxExtHyperModeParam *exthypermodeparam = NULL;
203 #endif
204 
205  const char *tmp_str = NULL;
206 
207  if (q->co2_idx > 0)
208  co2 = (mfxExtCodingOption2*)coding_opts[q->co2_idx];
209 
210  if (q->co3_idx > 0)
211  co3 = (mfxExtCodingOption3*)coding_opts[q->co3_idx];
212 
213  if (q->exthevctiles_idx > 0)
214  exthevctiles = (mfxExtHEVCTiles *)coding_opts[q->exthevctiles_idx];
215 
216 #if QSV_HAVE_HE
217  if (q->exthypermodeparam_idx > 0)
218  exthypermodeparam = (mfxExtHyperModeParam *)coding_opts[q->exthypermodeparam_idx];
219 #endif
220 
221  av_log(avctx, AV_LOG_VERBOSE, "profile: %s; level: %"PRIu16"\n",
222  print_profile(avctx->codec_id, info->CodecProfile), info->CodecLevel);
223 
224  av_log(avctx, AV_LOG_VERBOSE,
225  "GopPicSize: %"PRIu16"; GopRefDist: %"PRIu16"; GopOptFlag:%s%s; IdrInterval: %"PRIu16"\n",
226  info->GopPicSize, info->GopRefDist,
227  info->GopOptFlag & MFX_GOP_CLOSED ? " closed" : "",
228  info->GopOptFlag & MFX_GOP_STRICT ? " strict" : "",
229  info->IdrInterval);
230 
231  av_log(avctx, AV_LOG_VERBOSE, "TargetUsage: %"PRIu16"; RateControlMethod: %s\n",
232  info->TargetUsage, print_ratecontrol(info->RateControlMethod));
233 
234  if (info->RateControlMethod == MFX_RATECONTROL_CBR ||
235  info->RateControlMethod == MFX_RATECONTROL_VBR
236 #if QSV_HAVE_VCM
237  || info->RateControlMethod == MFX_RATECONTROL_VCM
238 #endif
239  ) {
240  av_log(avctx, AV_LOG_VERBOSE,
241  "BufferSizeInKB: %"PRIu16"; InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
242  info->BufferSizeInKB, info->InitialDelayInKB, info->TargetKbps, info->MaxKbps, info->BRCParamMultiplier);
243  } else if (info->RateControlMethod == MFX_RATECONTROL_CQP) {
244  av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",
245  info->QPI, info->QPP, info->QPB);
246  }
247 #if QSV_HAVE_AVBR
248  else if (info->RateControlMethod == MFX_RATECONTROL_AVBR) {
249  av_log(avctx, AV_LOG_VERBOSE,
250  "TargetKbps: %"PRIu16"; Accuracy: %"PRIu16"; Convergence: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
251  info->TargetKbps, info->Accuracy, info->Convergence, info->BRCParamMultiplier);
252  }
253 #endif
254  else if (info->RateControlMethod == MFX_RATECONTROL_LA
255  || info->RateControlMethod == MFX_RATECONTROL_LA_HRD
256  ) {
257  av_log(avctx, AV_LOG_VERBOSE,
258  "TargetKbps: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
259  info->TargetKbps, info->BRCParamMultiplier);
260  } else if (info->RateControlMethod == MFX_RATECONTROL_ICQ ||
261  info->RateControlMethod == MFX_RATECONTROL_LA_ICQ)
262  av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);
263  av_log(avctx, AV_LOG_VERBOSE, "NumSlice: %"PRIu16"; NumRefFrame: %"PRIu16"\n",
264  info->NumSlice, info->NumRefFrame);
265  av_log(avctx, AV_LOG_VERBOSE, "RateDistortionOpt: %s\n",
266  print_threestate(co->RateDistortionOpt));
267 
268  av_log(avctx, AV_LOG_VERBOSE, "RecoveryPointSEI: %s\n", print_threestate(co->RecoveryPointSEI));
269  av_log(avctx, AV_LOG_VERBOSE, "VDENC: %s\n", print_threestate(info->LowPower));
270 
271  if (avctx->codec_id == AV_CODEC_ID_H264) {
272  av_log(avctx, AV_LOG_VERBOSE, "Entropy coding: %s; MaxDecFrameBuffering: %"PRIu16"\n",
273  co->CAVLC == MFX_CODINGOPTION_ON ? "CAVLC" : "CABAC", co->MaxDecFrameBuffering);
274  av_log(avctx, AV_LOG_VERBOSE,
275  "NalHrdConformance: %s; SingleSeiNalUnit: %s; VuiVclHrdParameters: %s VuiNalHrdParameters: %s\n",
276  print_threestate(co->NalHrdConformance), print_threestate(co->SingleSeiNalUnit),
277  print_threestate(co->VuiVclHrdParameters), print_threestate(co->VuiNalHrdParameters));
278  } else if ((avctx->codec_id == AV_CODEC_ID_HEVC) && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 28)) {
279  av_log(avctx, AV_LOG_VERBOSE,
280  "NalHrdConformance: %s; VuiNalHrdParameters: %s\n",
281  print_threestate(co->NalHrdConformance), 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  if (co2) {
288  if ((info->RateControlMethod == MFX_RATECONTROL_VBR && q->extbrc && q->look_ahead_depth > 0) ||
289  (info->RateControlMethod == MFX_RATECONTROL_LA) ||
290  (info->RateControlMethod == MFX_RATECONTROL_LA_HRD) ||
291  (info->RateControlMethod == MFX_RATECONTROL_LA_ICQ))
292  av_log(avctx, AV_LOG_VERBOSE, "LookAheadDepth: %"PRIu16"\n", co2->LookAheadDepth);
293 
294  av_log(avctx, AV_LOG_VERBOSE, "IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16"; IntRefQPDelta: %"PRId16"\n",
295  co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);
296 
297  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %d; MaxSliceSize: %d\n",
298  co2->MaxFrameSize, co2->MaxSliceSize);
299 
300  av_log(avctx, AV_LOG_VERBOSE,
301  "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
302  print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),
303  print_threestate(co2->ExtBRC));
304 
305  if (co2->Trellis & MFX_TRELLIS_OFF) {
306  av_log(avctx, AV_LOG_VERBOSE, "Trellis: off\n");
307  } else if (!co2->Trellis) {
308  av_log(avctx, AV_LOG_VERBOSE, "Trellis: auto\n");
309  } else {
310  char trellis_type[4];
311  int i = 0;
312  if (co2->Trellis & MFX_TRELLIS_I) trellis_type[i++] = 'I';
313  if (co2->Trellis & MFX_TRELLIS_P) trellis_type[i++] = 'P';
314  if (co2->Trellis & MFX_TRELLIS_B) trellis_type[i++] = 'B';
315  trellis_type[i] = 0;
316  av_log(avctx, AV_LOG_VERBOSE, "Trellis: %s\n", trellis_type);
317  }
318 
319  switch (co2->LookAheadDS) {
320  case MFX_LOOKAHEAD_DS_OFF: tmp_str = "off"; break;
321  case MFX_LOOKAHEAD_DS_2x: tmp_str = "2x"; break;
322  case MFX_LOOKAHEAD_DS_4x: tmp_str = "4x"; break;
323  default: tmp_str = "unknown"; break;
324  }
325  av_log(avctx, AV_LOG_VERBOSE,
326  "RepeatPPS: %s; NumMbPerSlice: %"PRIu16"; LookAheadDS: %s\n",
327  print_threestate(co2->RepeatPPS), co2->NumMbPerSlice, tmp_str);
328 
329  switch (co2->BRefType) {
330  case MFX_B_REF_OFF: tmp_str = "off"; break;
331  case MFX_B_REF_PYRAMID: tmp_str = "pyramid"; break;
332  default: tmp_str = "auto"; break;
333  }
334  av_log(avctx, AV_LOG_VERBOSE,
335  "AdaptiveI: %s; AdaptiveB: %s; BRefType:%s\n",
336  print_threestate(co2->AdaptiveI), print_threestate(co2->AdaptiveB), tmp_str);
337 
338  av_log(avctx, AV_LOG_VERBOSE,
339  "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",
340  co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
341  av_log(avctx, AV_LOG_VERBOSE, "DisableDeblockingIdc: %"PRIu32" \n", co2->DisableDeblockingIdc);
342 
343  switch (co2->SkipFrame) {
344  case MFX_SKIPFRAME_NO_SKIP:
345  av_log(avctx, AV_LOG_VERBOSE, "SkipFrame: no_skip\n");
346  break;
347  case MFX_SKIPFRAME_INSERT_DUMMY:
348  av_log(avctx, AV_LOG_VERBOSE, "SkipFrame: insert_dummy\n");
349  break;
350  case MFX_SKIPFRAME_INSERT_NOTHING:
351  av_log(avctx, AV_LOG_VERBOSE, "SkipFrame: insert_nothing\n");
352  break;
353  case MFX_SKIPFRAME_BRC_ONLY:
354  av_log(avctx, AV_LOG_VERBOSE, "SkipFrame: brc_only\n");
355  break;
356  default: break;
357  }
358  }
359 
360  if (co3) {
361  if (info->RateControlMethod == MFX_RATECONTROL_QVBR)
362  av_log(avctx, AV_LOG_VERBOSE, "QVBRQuality: %"PRIu16"\n", co3->QVBRQuality);
363 
364  switch (co3->PRefType) {
365  case MFX_P_REF_DEFAULT: av_log(avctx, AV_LOG_VERBOSE, "PRefType: default\n"); break;
366  case MFX_P_REF_SIMPLE: av_log(avctx, AV_LOG_VERBOSE, "PRefType: simple\n"); break;
367  case MFX_P_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "PRefType: pyramid\n"); break;
368  default: av_log(avctx, AV_LOG_VERBOSE, "PRefType: unknown\n"); break;
369  }
370 
371  if (avctx->codec_id == AV_CODEC_ID_HEVC)
372  av_log(avctx, AV_LOG_VERBOSE,"GPB: %s\n", print_threestate(co3->GPB));
373 
374  av_log(avctx, AV_LOG_VERBOSE, "TransformSkip: %s \n", print_threestate(co3->TransformSkip));
375  av_log(avctx, AV_LOG_VERBOSE, "IntRefCycleDist: %"PRId16"\n", co3->IntRefCycleDist);
376  av_log(avctx, AV_LOG_VERBOSE, "LowDelayBRC: %s\n", print_threestate(co3->LowDelayBRC));
377  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSizeI: %d; ", co3->MaxFrameSizeI);
378  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSizeP: %d\n", co3->MaxFrameSizeP);
379  av_log(avctx, AV_LOG_VERBOSE, "ScenarioInfo: %"PRId16"\n", co3->ScenarioInfo);
380  }
381 
382  if (exthevctiles) {
383  av_log(avctx, AV_LOG_VERBOSE, "NumTileColumns: %"PRIu16"; NumTileRows: %"PRIu16"\n",
384  exthevctiles->NumTileColumns, exthevctiles->NumTileRows);
385  }
386 
387 #if QSV_HAVE_HE
388  if (exthypermodeparam) {
389  av_log(avctx, AV_LOG_VERBOSE, "HyperEncode: ");
390 
391  if (exthypermodeparam->Mode == MFX_HYPERMODE_OFF)
392  av_log(avctx, AV_LOG_VERBOSE, "OFF");
393  if (exthypermodeparam->Mode == MFX_HYPERMODE_ON)
394  av_log(avctx, AV_LOG_VERBOSE, "ON");
395  if (exthypermodeparam->Mode == MFX_HYPERMODE_ADAPTIVE)
396  av_log(avctx, AV_LOG_VERBOSE, "Adaptive");
397 
398  av_log(avctx, AV_LOG_VERBOSE, "\n");
399  }
400 #endif
401 }
402 
404  mfxExtBuffer **coding_opts)
405 {
406  mfxInfoMFX *info = &q->param.mfx;
407  mfxExtVP9Param *vp9_param = NULL;
408  mfxExtCodingOption2 *co2 = NULL;
409 
410  if (q->vp9_idx >= 0)
411  vp9_param = (mfxExtVP9Param *)coding_opts[q->vp9_idx];
412 
413  if (q->co2_idx >= 0)
414  co2 = (mfxExtCodingOption2*)coding_opts[q->co2_idx];
415 
416  av_log(avctx, AV_LOG_VERBOSE, "profile: %s \n",
417  print_profile(avctx->codec_id, info->CodecProfile));
418 
419  av_log(avctx, AV_LOG_VERBOSE,
420  "GopPicSize: %"PRIu16"; GopRefDist: %"PRIu16"; GopOptFlag:%s%s; IdrInterval: %"PRIu16"\n",
421  info->GopPicSize, info->GopRefDist,
422  info->GopOptFlag & MFX_GOP_CLOSED ? " closed" : "",
423  info->GopOptFlag & MFX_GOP_STRICT ? " strict" : "",
424  info->IdrInterval);
425 
426  av_log(avctx, AV_LOG_VERBOSE, "TargetUsage: %"PRIu16"; RateControlMethod: %s\n",
427  info->TargetUsage, print_ratecontrol(info->RateControlMethod));
428 
429  if (info->RateControlMethod == MFX_RATECONTROL_CBR ||
430  info->RateControlMethod == MFX_RATECONTROL_VBR) {
431  av_log(avctx, AV_LOG_VERBOSE,
432  "BufferSizeInKB: %"PRIu16"; InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
433  info->BufferSizeInKB, info->InitialDelayInKB, info->TargetKbps, info->MaxKbps, info->BRCParamMultiplier);
434  } else if (info->RateControlMethod == MFX_RATECONTROL_CQP) {
435  av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",
436  info->QPI, info->QPP, info->QPB);
437  }
438  else if (info->RateControlMethod == MFX_RATECONTROL_ICQ) {
439  av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);
440  }
441  else {
442  av_log(avctx, AV_LOG_VERBOSE, "Unsupported ratecontrol method: %d \n", info->RateControlMethod);
443  }
444 
445  av_log(avctx, AV_LOG_VERBOSE, "NumRefFrame: %"PRIu16"\n", info->NumRefFrame);
446  av_log(avctx, AV_LOG_VERBOSE, "FrameRateExtD: %"PRIu32"; FrameRateExtN: %"PRIu32" \n",
447  info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);
448 
449  if (co2) {
450  av_log(avctx, AV_LOG_VERBOSE,
451  "IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16"; IntRefQPDelta: %"PRId16"\n",
452  co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);
453 
454  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %d\n", co2->MaxFrameSize);
455 
456  av_log(avctx, AV_LOG_VERBOSE,
457  "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
458  print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),
459  print_threestate(co2->ExtBRC));
460 
461  av_log(avctx, AV_LOG_VERBOSE, "VDENC: %s\n", print_threestate(info->LowPower));
462 
463  av_log(avctx, AV_LOG_VERBOSE,
464  "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",
465  co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
466  }
467 
468  if (vp9_param) {
469  av_log(avctx, AV_LOG_VERBOSE, "WriteIVFHeaders: %s \n",
470  print_threestate(vp9_param->WriteIVFHeaders));
471  }
472 }
473 
475 {
476  mfxInfoMFX *info = &q->param.mfx;
477 
478  av_log(avctx, AV_LOG_VERBOSE, "Interleaved: %"PRIu16" \n", info->Interleaved);
479  av_log(avctx, AV_LOG_VERBOSE, "Quality: %"PRIu16" \n", info->Quality);
480  av_log(avctx, AV_LOG_VERBOSE, "RestartInterval: %"PRIu16" \n", info->RestartInterval);
481 
482  av_log(avctx, AV_LOG_VERBOSE, "FrameRateExtD: %"PRIu32"; FrameRateExtN: %"PRIu32" \n",
483  info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);
484 }
485 
486 #if QSV_HAVE_EXT_AV1_PARAM
487 static void dump_video_av1_param(AVCodecContext *avctx, QSVEncContext *q,
488  mfxExtBuffer **coding_opts)
489 {
490  mfxInfoMFX *info = &q->param.mfx;
491  mfxExtAV1TileParam *av1_tile_param = (mfxExtAV1TileParam *)coding_opts[0];
492  mfxExtAV1BitstreamParam *av1_bs_param = (mfxExtAV1BitstreamParam *)coding_opts[1];
493  mfxExtCodingOption2 *co2 = (mfxExtCodingOption2*)coding_opts[2];
494  mfxExtCodingOption3 *co3 = (mfxExtCodingOption3*)coding_opts[3];
495 
496  av_log(avctx, AV_LOG_VERBOSE, "profile: %s; level: %"PRIu16"\n",
497  print_profile(avctx->codec_id, info->CodecProfile), info->CodecLevel);
498 
499  av_log(avctx, AV_LOG_VERBOSE,
500  "GopPicSize: %"PRIu16"; GopRefDist: %"PRIu16"; GopOptFlag:%s%s; IdrInterval: %"PRIu16"\n",
501  info->GopPicSize, info->GopRefDist,
502  info->GopOptFlag & MFX_GOP_CLOSED ? " closed" : "",
503  info->GopOptFlag & MFX_GOP_STRICT ? " strict" : "",
504  info->IdrInterval);
505 
506  av_log(avctx, AV_LOG_VERBOSE, "TargetUsage: %"PRIu16"; RateControlMethod: %s\n",
507  info->TargetUsage, print_ratecontrol(info->RateControlMethod));
508 
509  if (info->RateControlMethod == MFX_RATECONTROL_CBR ||
510  info->RateControlMethod == MFX_RATECONTROL_VBR)
511  av_log(avctx, AV_LOG_VERBOSE,
512  "BufferSizeInKB: %"PRIu16"; InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
513  info->BufferSizeInKB, info->InitialDelayInKB, info->TargetKbps, info->MaxKbps, info->BRCParamMultiplier);
514  else if (info->RateControlMethod == MFX_RATECONTROL_CQP)
515  av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",
516  info->QPI, info->QPP, info->QPB);
517  else if (info->RateControlMethod == MFX_RATECONTROL_ICQ)
518  av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);
519  else
520  av_log(avctx, AV_LOG_VERBOSE, "Unsupported ratecontrol method: %d \n", info->RateControlMethod);
521 
522  av_log(avctx, AV_LOG_VERBOSE, "NumRefFrame: %"PRIu16"\n", info->NumRefFrame);
523 
524  av_log(avctx, AV_LOG_VERBOSE,
525  "IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16
526  "; IntRefQPDelta: %"PRId16"; IntRefCycleDist: %"PRId16"\n",
527  co2->IntRefType, co2->IntRefCycleSize,
528  co2->IntRefQPDelta, co3->IntRefCycleDist);
529 
530  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %d;\n", co2->MaxFrameSize);
531 
532  av_log(avctx, AV_LOG_VERBOSE,
533  "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
534  print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),
535  print_threestate(co2->ExtBRC));
536 
537  av_log(avctx, AV_LOG_VERBOSE, "VDENC: %s\n", print_threestate(info->LowPower));
538 
539  switch (co2->BRefType) {
540  case MFX_B_REF_OFF: av_log(avctx, AV_LOG_VERBOSE, "BRefType: off\n"); break;
541  case MFX_B_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "BRefType: pyramid\n"); break;
542  default: av_log(avctx, AV_LOG_VERBOSE, "BRefType: auto\n"); break;
543  }
544 
545  switch (co3->PRefType) {
546  case MFX_P_REF_DEFAULT: av_log(avctx, AV_LOG_VERBOSE, "PRefType: default\n"); break;
547  case MFX_P_REF_SIMPLE: av_log(avctx, AV_LOG_VERBOSE, "PRefType: simple\n"); break;
548  case MFX_P_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "PRefType: pyramid\n"); break;
549  default: av_log(avctx, AV_LOG_VERBOSE, "PRefType: unknown\n"); break;
550  }
551 
552  av_log(avctx, AV_LOG_VERBOSE,
553  "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",
554  co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
555 
556  av_log(avctx, AV_LOG_VERBOSE, "FrameRateExtD: %"PRIu32"; FrameRateExtN: %"PRIu32" \n",
557  info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);
558 
559  av_log(avctx, AV_LOG_VERBOSE,
560  "NumTileRows: %"PRIu16"; NumTileColumns: %"PRIu16"; NumTileGroups: %"PRIu16"\n",
561  av1_tile_param->NumTileRows, av1_tile_param->NumTileColumns, av1_tile_param->NumTileGroups);
562 
563  av_log(avctx, AV_LOG_VERBOSE, "WriteIVFHeaders: %s \n",
564  print_threestate(av1_bs_param->WriteIVFHeaders));
565  av_log(avctx, AV_LOG_VERBOSE, "LowDelayBRC: %s\n", print_threestate(co3->LowDelayBRC));
566  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %d;\n", co2->MaxFrameSize);
567 }
568 #endif
569 
571 {
572  const char *rc_desc;
573  mfxU16 rc_mode;
574 
575  int want_la = q->look_ahead;
576  int want_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
577  int want_vcm = q->vcm;
578 
579  if (want_vcm && !QSV_HAVE_VCM) {
580  av_log(avctx, AV_LOG_ERROR,
581  "VCM ratecontrol mode requested, but is not supported by this SDK version\n");
582  return AVERROR(ENOSYS);
583  }
584 
585  if (want_la + want_qscale + want_vcm > 1) {
586  av_log(avctx, AV_LOG_ERROR,
587  "More than one of: { constant qscale, lookahead, VCM } requested, "
588  "only one of them can be used at a time.\n");
589  return AVERROR(EINVAL);
590  }
591 
592  if (want_qscale) {
593  rc_mode = MFX_RATECONTROL_CQP;
594  rc_desc = "constant quantization parameter (CQP)";
595  }
596 #if QSV_HAVE_VCM
597  else if (want_vcm) {
598  rc_mode = MFX_RATECONTROL_VCM;
599  rc_desc = "video conferencing mode (VCM)";
600 
601  if (!avctx->bit_rate) {
602  av_log(avctx, AV_LOG_ERROR, "Using the %s ratecontrol method without "
603  "setting bitrate. Please use the b option to set the desired "
604  "bitrate.\n", rc_desc);
605  return AVERROR(EINVAL);
606  }
607  }
608 #endif
609  else if (want_la) {
610  rc_mode = MFX_RATECONTROL_LA;
611  rc_desc = "VBR with lookahead (LA)";
612 
613  if (avctx->global_quality > 0) {
614  rc_mode = MFX_RATECONTROL_LA_ICQ;
615  rc_desc = "intelligent constant quality with lookahead (LA_ICQ)";
616  } else if (!avctx->bit_rate) {
617  av_log(avctx, AV_LOG_ERROR, "Using the %s ratecontrol method without "
618  "setting bitrate. Please use the b option to set the desired "
619  "bitrate.\n", rc_desc);
620  return AVERROR(EINVAL);
621  }
622  }
623  else if (avctx->global_quality > 0 && !avctx->rc_max_rate) {
624  rc_mode = MFX_RATECONTROL_ICQ;
625  rc_desc = "intelligent constant quality (ICQ)";
626  }
627  else if (avctx->bit_rate) {
628  if (avctx->rc_max_rate == avctx->bit_rate) {
629  rc_mode = MFX_RATECONTROL_CBR;
630  rc_desc = "constant bitrate (CBR)";
631  }
632 #if QSV_HAVE_AVBR
633  else if (!avctx->rc_max_rate &&
634  (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_HEVC) &&
635  q->avbr_accuracy &&
636  q->avbr_convergence) {
637  rc_mode = MFX_RATECONTROL_AVBR;
638  rc_desc = "average variable bitrate (AVBR)";
639  }
640 #endif
641  else if (avctx->global_quality > 0) {
642  rc_mode = MFX_RATECONTROL_QVBR;
643  rc_desc = "constant quality with VBR algorithm (QVBR)";
644  } else {
645  rc_mode = MFX_RATECONTROL_VBR;
646  rc_desc = "variable bitrate (VBR)";
647  }
648  } else {
649  rc_mode = MFX_RATECONTROL_CQP;
650  rc_desc = "constant quantization parameter (CQP)";
651  if (avctx->codec_id == AV_CODEC_ID_AV1)
652  avctx->global_quality = FF_QP2LAMBDA * 128;
653  else
654  avctx->global_quality = FF_QP2LAMBDA * 26;
655  av_log(avctx, AV_LOG_WARNING, "Using the constant quantization "
656  "parameter (CQP) by default. Please use the global_quality "
657  "option and other options for a quality-based mode or the b "
658  "option and other options for a bitrate-based mode if the "
659  "default is not the desired choice.\n");
660  }
661 
662  q->param.mfx.RateControlMethod = rc_mode;
663  av_log(avctx, AV_LOG_VERBOSE, "Using the %s ratecontrol method\n", rc_desc);
664 
665  return 0;
666 }
667 
669 {
670  mfxVideoParam param_out = { .mfx.CodecId = q->param.mfx.CodecId };
671  mfxStatus ret;
672 
673 #define UNMATCH(x) (param_out.mfx.x != q->param.mfx.x)
674 
675  ret = MFXVideoENCODE_Query(q->session, &q->param, &param_out);
676 
677  if (ret < 0) {
678  if (UNMATCH(CodecId))
679  av_log(avctx, AV_LOG_ERROR, "Current codec type is unsupported\n");
680  if (UNMATCH(CodecProfile))
681  av_log(avctx, AV_LOG_ERROR, "Current profile is unsupported\n");
682  if (UNMATCH(RateControlMethod))
683  av_log(avctx, AV_LOG_ERROR, "Selected ratecontrol mode is unsupported\n");
684  if (UNMATCH(LowPower))
685  av_log(avctx, AV_LOG_ERROR, "Low power mode is unsupported\n");
686  if (UNMATCH(FrameInfo.FrameRateExtN) || UNMATCH(FrameInfo.FrameRateExtD))
687  av_log(avctx, AV_LOG_ERROR, "Current frame rate is unsupported\n");
688  if (UNMATCH(FrameInfo.PicStruct))
689  av_log(avctx, AV_LOG_ERROR, "Current picture structure is unsupported\n");
690  if (UNMATCH(FrameInfo.Width) || UNMATCH(FrameInfo.Height))
691  av_log(avctx, AV_LOG_ERROR, "Current resolution is unsupported\n");
692  if (UNMATCH(FrameInfo.FourCC))
693  av_log(avctx, AV_LOG_ERROR, "Current pixel format is unsupported\n");
694  return 0;
695  }
696  return 1;
697 }
698 
699 static int is_strict_gop(QSVEncContext *q) {
700  if (q->adaptive_b == 0 && q->adaptive_i == 0)
701  return 1;
702  return 0;
703 }
704 
706 {
707  enum AVPixelFormat sw_format = avctx->pix_fmt == AV_PIX_FMT_QSV ?
708  avctx->sw_pix_fmt : avctx->pix_fmt;
709  const AVPixFmtDescriptor *desc;
710  int ret;
711 
713  if (ret < 0)
714  return AVERROR_BUG;
715  q->param.mfx.CodecId = ret;
716 
717  if (avctx->level > 0)
718  q->param.mfx.CodecLevel = avctx->level;
719  q->param.mfx.CodecProfile = q->profile;
720 
721  desc = av_pix_fmt_desc_get(sw_format);
722  if (!desc)
723  return AVERROR_BUG;
724 
725  ret = ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC, &q->param.mfx.FrameInfo.Shift);
726  if (ret < 0)
727  return AVERROR_BUG;
728 
729  q->param.mfx.FrameInfo.CropX = 0;
730  q->param.mfx.FrameInfo.CropY = 0;
731  q->param.mfx.FrameInfo.CropW = avctx->width;
732  q->param.mfx.FrameInfo.CropH = avctx->height;
733  q->param.mfx.FrameInfo.AspectRatioW = avctx->sample_aspect_ratio.num;
734  q->param.mfx.FrameInfo.AspectRatioH = avctx->sample_aspect_ratio.den;
735  q->param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420 +
736  !desc->log2_chroma_w + !desc->log2_chroma_h;
737  q->param.mfx.FrameInfo.BitDepthLuma = desc->comp[0].depth;
738  q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
739 
740  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, 16);
741  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, 16);
742 
743  if (avctx->hw_frames_ctx) {
744  AVHWFramesContext *frames_ctx = (AVHWFramesContext *)avctx->hw_frames_ctx->data;
745  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
746  q->param.mfx.FrameInfo.Width = frames_hwctx->surfaces[0].Info.Width;
747  q->param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;
748  }
749 
750  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
751  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
752  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
753  } else {
754  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
755  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
756  }
757 
758  q->param.mfx.Interleaved = 1;
759  q->param.mfx.Quality = av_clip(avctx->global_quality, 1, 100);
760  q->param.mfx.RestartInterval = 0;
761 
762  q->width_align = 16;
763  q->height_align = 16;
764 
765  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, q->width_align);
766  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, q->height_align);
767 
768  return 0;
769 }
770 
772 {
773  enum AVPixelFormat sw_format = avctx->pix_fmt == AV_PIX_FMT_QSV ?
774  avctx->sw_pix_fmt : avctx->pix_fmt;
775  const AVPixFmtDescriptor *desc;
776  float quant;
777  int target_bitrate_kbps, max_bitrate_kbps, brc_param_multiplier;
778  int buffer_size_in_kilobytes, initial_delay_in_kilobytes;
779  int ret;
780 
782  if (ret < 0)
783  return AVERROR_BUG;
784  q->param.mfx.CodecId = ret;
785 
786  if (avctx->level > 0) {
787  q->param.mfx.CodecLevel = avctx->level;
788  if (avctx->codec_id == AV_CODEC_ID_HEVC && avctx->level >= MFX_LEVEL_HEVC_4)
789  q->param.mfx.CodecLevel |= q->tier;
790  }
791 
793  avctx->compression_level = q->preset;
794  } else if (avctx->compression_level >= 0) {
795  if (avctx->compression_level > MFX_TARGETUSAGE_BEST_SPEED) {
796  av_log(avctx, AV_LOG_WARNING, "Invalid compression level: "
797  "valid range is 0-%d, using %d instead\n",
798  MFX_TARGETUSAGE_BEST_SPEED, MFX_TARGETUSAGE_BEST_SPEED);
799  avctx->compression_level = MFX_TARGETUSAGE_BEST_SPEED;
800  }
801  }
802 
803  if (q->low_power == 1) {
804  q->param.mfx.LowPower = MFX_CODINGOPTION_ON;
805  } else if (q->low_power == -1)
806  q->param.mfx.LowPower = MFX_CODINGOPTION_UNKNOWN;
807  else
808  q->param.mfx.LowPower = MFX_CODINGOPTION_OFF;
809 
810  q->param.mfx.CodecProfile = q->profile;
811  q->param.mfx.TargetUsage = avctx->compression_level;
812  q->param.mfx.GopPicSize = FFMAX(0, avctx->gop_size);
813  q->old_gop_size = avctx->gop_size;
814  q->param.mfx.GopRefDist = FFMAX(-1, avctx->max_b_frames) + 1;
815  q->param.mfx.GopOptFlag = avctx->flags & AV_CODEC_FLAG_CLOSED_GOP ?
816  MFX_GOP_CLOSED : is_strict_gop(q) ?
817  MFX_GOP_STRICT : 0;
818  q->param.mfx.IdrInterval = q->idr_interval;
819  q->param.mfx.NumSlice = avctx->slices;
820  q->param.mfx.NumRefFrame = FFMAX(0, avctx->refs);
821  q->param.mfx.EncodedOrder = 0;
822  q->param.mfx.BufferSizeInKB = 0;
823 
824  desc = av_pix_fmt_desc_get(sw_format);
825  if (!desc)
826  return AVERROR_BUG;
827 
828  ret = ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC, &q->param.mfx.FrameInfo.Shift);
829  if (ret < 0)
830  return AVERROR_BUG;
831 
832  q->param.mfx.FrameInfo.CropX = 0;
833  q->param.mfx.FrameInfo.CropY = 0;
834  q->param.mfx.FrameInfo.CropW = avctx->width;
835  q->param.mfx.FrameInfo.CropH = avctx->height;
836  q->param.mfx.FrameInfo.AspectRatioW = avctx->sample_aspect_ratio.num;
837  q->param.mfx.FrameInfo.AspectRatioH = avctx->sample_aspect_ratio.den;
838  q->param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420 +
839  !desc->log2_chroma_w + !desc->log2_chroma_h;
840  q->param.mfx.FrameInfo.BitDepthLuma = desc->comp[0].depth;
841  q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
842 
843  // If the minor version is greater than or equal to 19,
844  // then can use the same alignment settings as H.264 for HEVC
845  q->width_align = (avctx->codec_id != AV_CODEC_ID_HEVC ||
846  QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 19)) ? 16 : 32;
847  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, q->width_align);
848 
849  if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
850  // it is important that PicStruct be setup correctly from the
851  // start--otherwise, encoding doesn't work and results in a bunch
852  // of incompatible video parameter errors
853  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_FIELD_TFF;
854  // height alignment always must be 32 for interlaced video
855  q->height_align = 32;
856  } else {
857  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
858  // for progressive video, the height should be aligned to 16 for
859  // H.264. For HEVC, depending on the version of MFX, it should be
860  // either 32 or 16. The lower number is better if possible.
861  // For AV1, it is 32
862  q->height_align = (avctx->codec_id == AV_CODEC_ID_HEVC ||
863  avctx->codec_id == AV_CODEC_ID_AV1) ? 32 : 16;
864  }
865  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, q->height_align);
866 
867  if (avctx->hw_frames_ctx) {
868  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
869  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
870  q->param.mfx.FrameInfo.Width = frames_hwctx->surfaces[0].Info.Width;
871  q->param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;
872  }
873 
874  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
875  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
876  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
877  } else {
878  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
879  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
880  }
881  q->old_framerate = avctx->framerate;
882 
883  ret = select_rc_mode(avctx, q);
884  if (ret < 0)
885  return ret;
886 
887  //libmfx BRC parameters are 16 bits thus maybe overflow, then BRCParamMultiplier is needed
888  buffer_size_in_kilobytes = avctx->rc_buffer_size / 8000;
889  initial_delay_in_kilobytes = avctx->rc_initial_buffer_occupancy / 8000;
890  target_bitrate_kbps = avctx->bit_rate / 1000;
891  max_bitrate_kbps = avctx->rc_max_rate / 1000;
892  brc_param_multiplier = (FFMAX(FFMAX3(target_bitrate_kbps, max_bitrate_kbps, buffer_size_in_kilobytes),
893  initial_delay_in_kilobytes) + 0x10000) / 0x10000;
896  q->old_bit_rate = avctx->bit_rate;
897  q->old_rc_max_rate = avctx->rc_max_rate;
898 
899  switch (q->param.mfx.RateControlMethod) {
900  case MFX_RATECONTROL_CBR:
901  case MFX_RATECONTROL_VBR:
902  if (q->extbrc) {
903  q->extco2.LookAheadDepth = q->look_ahead_depth;
904  }
905 #if QSV_HAVE_VCM
906  case MFX_RATECONTROL_VCM:
907 #endif
908  case MFX_RATECONTROL_QVBR:
909  q->param.mfx.BufferSizeInKB = buffer_size_in_kilobytes / brc_param_multiplier;
910  q->param.mfx.InitialDelayInKB = initial_delay_in_kilobytes / brc_param_multiplier;
911  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
912  q->param.mfx.MaxKbps = max_bitrate_kbps / brc_param_multiplier;
913  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
914  if (q->param.mfx.RateControlMethod == MFX_RATECONTROL_QVBR)
915  q->extco3.QVBRQuality = av_clip(avctx->global_quality, 0, 51);
916  break;
917  case MFX_RATECONTROL_CQP:
918  quant = avctx->global_quality / FF_QP2LAMBDA;
919  if (avctx->codec_id == AV_CODEC_ID_AV1) {
920  q->param.mfx.QPI = av_clip_uintp2(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 8);
921  q->param.mfx.QPP = av_clip_uintp2(quant, 8);
922  q->param.mfx.QPB = av_clip_uintp2(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 8);
923  } else {
924  q->param.mfx.QPI = av_clip(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 0, 51);
925  q->param.mfx.QPP = av_clip(quant, 0, 51);
926  q->param.mfx.QPB = av_clip(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 0, 51);
927  }
933 
934  break;
935 #if QSV_HAVE_AVBR
936  case MFX_RATECONTROL_AVBR:
937  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
938  q->param.mfx.Convergence = q->avbr_convergence;
939  q->param.mfx.Accuracy = q->avbr_accuracy;
940  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
941  break;
942 #endif
943  case MFX_RATECONTROL_LA:
944  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
945  q->extco2.LookAheadDepth = q->look_ahead_depth;
946  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
947  break;
948  case MFX_RATECONTROL_LA_ICQ:
949  q->extco2.LookAheadDepth = q->look_ahead_depth;
950  case MFX_RATECONTROL_ICQ:
951  q->param.mfx.ICQQuality = av_clip(avctx->global_quality, 1, 51);
952  break;
953  }
954 
955  // The HEVC encoder plugin currently fails with some old libmfx version if coding options
956  // are provided. Can't find the extract libmfx version which fixed it, just enable it from
957  // V1.28 in order to keep compatibility security.
958  if (((avctx->codec_id != AV_CODEC_ID_HEVC) || QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 28))
959  && (avctx->codec_id != AV_CODEC_ID_VP9)) {
960  q->extco.Header.BufferId = MFX_EXTBUFF_CODING_OPTION;
961  q->extco.Header.BufferSz = sizeof(q->extco);
962 
963  q->extco.PicTimingSEI = q->pic_timing_sei ?
964  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;
966 
967  if (q->rdo >= 0)
968  q->extco.RateDistortionOpt = q->rdo > 0 ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
969 
970  if (avctx->codec_id == AV_CODEC_ID_H264) {
971  q->extco.CAVLC = q->cavlc ? MFX_CODINGOPTION_ON
972  : MFX_CODINGOPTION_UNKNOWN;
973 
975  q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?
976  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
977 
978  if (q->single_sei_nal_unit >= 0)
979  q->extco.SingleSeiNalUnit = q->single_sei_nal_unit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
980  if (q->recovery_point_sei >= 0)
981  q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
982  q->extco.MaxDecFrameBuffering = q->max_dec_frame_buffering;
983  q->extco.AUDelimiter = q->aud ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
984  } else if (avctx->codec_id == AV_CODEC_ID_HEVC) {
986  q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?
987  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
988 
989  if (q->recovery_point_sei >= 0)
990  q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
991 
992  q->extco.AUDelimiter = q->aud ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
993  }
994 
995  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco;
996 
997  if (avctx->codec_id == AV_CODEC_ID_H264) {
998  if (q->bitrate_limit >= 0)
999  q->extco2.BitrateLimit = q->bitrate_limit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1000 
1001  if (avctx->trellis >= 0)
1002  q->extco2.Trellis = (avctx->trellis == 0) ? MFX_TRELLIS_OFF : (MFX_TRELLIS_I | MFX_TRELLIS_P | MFX_TRELLIS_B);
1003  else
1004  q->extco2.Trellis = MFX_TRELLIS_UNKNOWN;
1005 
1006  q->extco2.LookAheadDS = q->look_ahead_downsampling;
1007  q->extco2.RepeatPPS = q->repeat_pps ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1008  }
1009 
1010  if (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_HEVC) {
1011  if (q->extbrc >= 0)
1012  q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1013  if (q->max_frame_size >= 0)
1014  q->extco2.MaxFrameSize = q->max_frame_size;
1016  if (q->int_ref_type >= 0)
1017  q->extco2.IntRefType = q->int_ref_type;
1019  if (q->int_ref_cycle_size >= 0)
1020  q->extco2.IntRefCycleSize = q->int_ref_cycle_size;
1022  if (q->int_ref_qp_delta != INT16_MIN)
1023  q->extco2.IntRefQPDelta = q->int_ref_qp_delta;
1025  if (q->max_slice_size >= 0)
1026  q->extco2.MaxSliceSize = q->max_slice_size;
1027  q->extco2.DisableDeblockingIdc = q->dblk_idc;
1028 
1029  if (q->b_strategy >= 0)
1030  q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
1031  if (q->adaptive_i >= 0)
1032  q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1033  if (q->adaptive_b >= 0)
1034  q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1035  if ((avctx->qmin >= 0 && avctx->qmax >= 0 && avctx->qmin > avctx->qmax) ||
1036  (q->max_qp_i >= 0 && q->min_qp_i >= 0 && q->min_qp_i > q->max_qp_i) ||
1037  (q->max_qp_p >= 0 && q->min_qp_p >= 0 && q->min_qp_p > q->max_qp_p) ||
1038  (q->max_qp_b >= 0 && q->min_qp_b >= 0 && q->min_qp_b > q->max_qp_b)) {
1039  av_log(avctx, AV_LOG_ERROR,
1040  "qmin and or qmax are set but invalid,"
1041  " please make sure min <= max\n");
1042  return AVERROR(EINVAL);
1043  }
1044  if (avctx->qmin >= 0) {
1045  q->extco2.MinQPI = avctx->qmin > 51 ? 51 : avctx->qmin;
1046  q->extco2.MinQPP = q->extco2.MinQPB = q->extco2.MinQPI;
1047  }
1048  q->old_qmin = avctx->qmin;
1049  if (avctx->qmax >= 0) {
1050  q->extco2.MaxQPI = avctx->qmax > 51 ? 51 : avctx->qmax;
1051  q->extco2.MaxQPP = q->extco2.MaxQPB = q->extco2.MaxQPI;
1052  }
1053  q->old_qmax = avctx->qmax;
1054  if (q->min_qp_i >= 0)
1055  q->extco2.MinQPI = q->min_qp_i > 51 ? 51 : q->min_qp_i;
1056  q->old_min_qp_i = q->min_qp_i;
1057  if (q->max_qp_i >= 0)
1058  q->extco2.MaxQPI = q->max_qp_i > 51 ? 51 : q->max_qp_i;
1059  q->old_max_qp_i = q->max_qp_i;
1060  if (q->min_qp_p >= 0)
1061  q->extco2.MinQPP = q->min_qp_p > 51 ? 51 : q->min_qp_p;
1062  q->old_min_qp_p = q->min_qp_p;
1063  if (q->max_qp_p >= 0)
1064  q->extco2.MaxQPP = q->max_qp_p > 51 ? 51 : q->max_qp_p;
1065  q->old_max_qp_p = q->max_qp_p;
1066  if (q->min_qp_b >= 0)
1067  q->extco2.MinQPB = q->min_qp_b > 51 ? 51 : q->min_qp_b;
1068  q->old_min_qp_b = q->min_qp_b;
1069  if (q->max_qp_b >= 0)
1070  q->extco2.MaxQPB = q->max_qp_b > 51 ? 51 : q->max_qp_b;
1071  q->old_max_qp_b = q->max_qp_b;
1072  if (q->mbbrc >= 0)
1073  q->extco2.MBBRC = q->mbbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1074  if (q->skip_frame >= 0)
1075  q->extco2.SkipFrame = q->skip_frame;
1076 
1077  q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
1078  q->extco2.Header.BufferSz = sizeof(q->extco2);
1079 
1080  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
1081  } else if (avctx->codec_id == AV_CODEC_ID_AV1) {
1082  if (q->extbrc >= 0)
1083  q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1084  if (q->b_strategy >= 0)
1085  q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
1086  if (q->adaptive_i >= 0)
1087  q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1088  if (q->adaptive_b >= 0)
1089  q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1090  if (q->max_frame_size >= 0)
1091  q->extco2.MaxFrameSize = q->max_frame_size;
1092 
1093  q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
1094  q->extco2.Header.BufferSz = sizeof(q->extco2);
1095 
1096  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
1097  }
1098 
1099  if (avctx->codec_id == AV_CODEC_ID_H264) {
1100 #if QSV_HAVE_MF
1101  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 25)) {
1102  q->extmfp.Header.BufferId = MFX_EXTBUFF_MULTI_FRAME_PARAM;
1103  q->extmfp.Header.BufferSz = sizeof(q->extmfp);
1104 
1105  q->extmfp.MFMode = q->mfmode;
1106  av_log(avctx,AV_LOG_VERBOSE,"MFMode:%d\n", q->extmfp.MFMode);
1107  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extmfp;
1108  }
1109 #endif
1110  }
1111  q->extco3.Header.BufferId = MFX_EXTBUFF_CODING_OPTION3;
1112  q->extco3.Header.BufferSz = sizeof(q->extco3);
1113 
1114  if (avctx->codec_id == AV_CODEC_ID_HEVC ||
1115  avctx->codec_id == AV_CODEC_ID_H264) {
1116  switch (q->p_strategy) {
1117  case 0:
1118  q->extco3.PRefType = MFX_P_REF_DEFAULT;
1119  break;
1120  case 1:
1121  q->extco3.PRefType = MFX_P_REF_SIMPLE;
1122  break;
1123  case 2:
1124  q->extco3.PRefType = MFX_P_REF_PYRAMID;
1125  break;
1126  default:
1127  q->extco3.PRefType = MFX_P_REF_DEFAULT;
1128  av_log(avctx, AV_LOG_WARNING,
1129  "invalid p_strategy, set to default\n");
1130  break;
1131  }
1132  if (q->extco3.PRefType == MFX_P_REF_PYRAMID &&
1133  avctx->max_b_frames != 0) {
1134  av_log(avctx, AV_LOG_WARNING,
1135  "Please set max_b_frames(-bf) to 0 to enable P-pyramid\n");
1136  }
1137  if (q->int_ref_cycle_dist >= 0)
1138  q->extco3.IntRefCycleDist = q->int_ref_cycle_dist;
1140  if (q->low_delay_brc >= 0)
1141  q->extco3.LowDelayBRC = q->low_delay_brc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1143  if (q->max_frame_size_i >= 0)
1144  q->extco3.MaxFrameSizeI = q->max_frame_size_i;
1145  if (q->max_frame_size_p >= 0)
1146  q->extco3.MaxFrameSizeP = q->max_frame_size_p;
1147  if (sw_format == AV_PIX_FMT_BGRA &&
1148  (q->profile == MFX_PROFILE_HEVC_REXT ||
1149  q->profile == MFX_PROFILE_UNKNOWN))
1150  q->extco3.TargetChromaFormatPlus1 = MFX_CHROMAFORMAT_YUV444 + 1;
1151 
1152  q->extco3.ScenarioInfo = q->scenario;
1153  } else if (avctx->codec_id == AV_CODEC_ID_AV1) {
1154  if (q->low_delay_brc >= 0)
1155  q->extco3.LowDelayBRC = q->low_delay_brc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1157  }
1158 
1159  if (avctx->codec_id == AV_CODEC_ID_HEVC) {
1160  if (q->transform_skip >= 0)
1161  q->extco3.TransformSkip = q->transform_skip ? MFX_CODINGOPTION_ON :
1162  MFX_CODINGOPTION_OFF;
1163  else
1164  q->extco3.TransformSkip = MFX_CODINGOPTION_UNKNOWN;
1165  q->extco3.GPB = q->gpb ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1166  }
1167  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco3;
1168  }
1169 
1170  if (avctx->codec_id == AV_CODEC_ID_VP9) {
1171  q->extvp9param.Header.BufferId = MFX_EXTBUFF_VP9_PARAM;
1172  q->extvp9param.Header.BufferSz = sizeof(q->extvp9param);
1173  q->extvp9param.WriteIVFHeaders = MFX_CODINGOPTION_OFF;
1174 #if QSV_HAVE_EXT_VP9_TILES
1175  q->extvp9param.NumTileColumns = q->tile_cols;
1176  q->extvp9param.NumTileRows = q->tile_rows;
1177 #endif
1178  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extvp9param;
1179  }
1180 
1181 #if QSV_HAVE_EXT_AV1_PARAM
1182  if (avctx->codec_id == AV_CODEC_ID_AV1) {
1183  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 2, 5)) {
1184  q->extav1tileparam.Header.BufferId = MFX_EXTBUFF_AV1_TILE_PARAM;
1185  q->extav1tileparam.Header.BufferSz = sizeof(q->extav1tileparam);
1186  q->extav1tileparam.NumTileColumns = q->tile_cols;
1187  q->extav1tileparam.NumTileRows = q->tile_rows;
1188  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extav1tileparam;
1189 
1190  q->extav1bsparam.Header.BufferId = MFX_EXTBUFF_AV1_BITSTREAM_PARAM;
1191  q->extav1bsparam.Header.BufferSz = sizeof(q->extav1bsparam);
1192  q->extav1bsparam.WriteIVFHeaders = MFX_CODINGOPTION_OFF;
1193  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extav1bsparam;
1194  } else {
1195  av_log(avctx, AV_LOG_ERROR,
1196  "This version of runtime doesn't support AV1 encoding\n");
1197  return AVERROR_UNKNOWN;
1198  }
1199  }
1200 #endif
1201 
1202  if (avctx->codec_id == AV_CODEC_ID_HEVC) {
1203  q->exthevctiles.Header.BufferId = MFX_EXTBUFF_HEVC_TILES;
1204  q->exthevctiles.Header.BufferSz = sizeof(q->exthevctiles);
1205  q->exthevctiles.NumTileColumns = q->tile_cols;
1206  q->exthevctiles.NumTileRows = q->tile_rows;
1207  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->exthevctiles;
1208  }
1209 
1210  q->extvsi.VideoFullRange = (avctx->color_range == AVCOL_RANGE_JPEG);
1211  q->extvsi.ColourDescriptionPresent = 0;
1212 
1213  if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
1214  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
1215  avctx->colorspace != AVCOL_SPC_UNSPECIFIED) {
1216  q->extvsi.ColourDescriptionPresent = 1;
1217  q->extvsi.ColourPrimaries = avctx->color_primaries;
1218  q->extvsi.TransferCharacteristics = avctx->color_trc;
1219  if (avctx->colorspace == AVCOL_SPC_RGB)
1220  // RGB will be converted to YUV, so RGB colorspace is not supported
1221  q->extvsi.MatrixCoefficients = AVCOL_SPC_UNSPECIFIED;
1222  else
1223  q->extvsi.MatrixCoefficients = avctx->colorspace;
1224 
1225  }
1226 
1227  if ((avctx->codec_id != AV_CODEC_ID_VP9) && (q->extvsi.VideoFullRange || q->extvsi.ColourDescriptionPresent)) {
1228  q->extvsi.Header.BufferId = MFX_EXTBUFF_VIDEO_SIGNAL_INFO;
1229  q->extvsi.Header.BufferSz = sizeof(q->extvsi);
1230  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extvsi;
1231  }
1232 
1233 #if QSV_HAVE_HE
1234  if (q->dual_gfx) {
1235  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 2, 4)) {
1236  mfxIMPL impl;
1237  MFXQueryIMPL(q->session, &impl);
1238 
1239  if (MFX_IMPL_VIA_MASK(impl) != MFX_IMPL_VIA_D3D11) {
1240  av_log(avctx, AV_LOG_ERROR, "Dual GFX mode requires D3D11VA \n");
1241  return AVERROR_UNKNOWN;
1242  }
1243  if (q->param.mfx.LowPower != MFX_CODINGOPTION_ON) {
1244  av_log(avctx, AV_LOG_ERROR, "Dual GFX mode supports only low-power encoding mode \n");
1245  return AVERROR_UNKNOWN;
1246  }
1247  if (q->param.mfx.CodecId != MFX_CODEC_AVC && q->param.mfx.CodecId != MFX_CODEC_HEVC) {
1248  av_log(avctx, AV_LOG_ERROR, "Not supported encoder for dual GFX mode. "
1249  "Supported: h264_qsv and hevc_qsv \n");
1250  return AVERROR_UNKNOWN;
1251  }
1252  if (q->param.mfx.RateControlMethod != MFX_RATECONTROL_VBR &&
1253  q->param.mfx.RateControlMethod != MFX_RATECONTROL_CQP &&
1254  q->param.mfx.RateControlMethod != MFX_RATECONTROL_ICQ) {
1255  av_log(avctx, AV_LOG_WARNING, "Not supported BRC for dual GFX mode. "
1256  "Supported: VBR, CQP and ICQ \n");
1257  }
1258  if ((q->param.mfx.CodecId == MFX_CODEC_AVC && q->param.mfx.IdrInterval != 0) ||
1259  (q->param.mfx.CodecId == MFX_CODEC_HEVC && q->param.mfx.IdrInterval != 1)) {
1260  av_log(avctx, AV_LOG_WARNING, "Dual GFX mode requires closed GOP for AVC and strict GOP for HEVC, -idr_interval 0 \n");
1261  }
1262  if (q->param.mfx.GopPicSize < 30) {
1263  av_log(avctx, AV_LOG_WARNING, "For better performance in dual GFX mode GopPicSize must be >= 30 \n");
1264  }
1265  if (q->param.AsyncDepth < 30) {
1266  av_log(avctx, AV_LOG_WARNING, "For better performance in dual GFX mode AsyncDepth must be >= 30 \n");
1267  }
1268 
1269  q->exthypermodeparam.Header.BufferId = MFX_EXTBUFF_HYPER_MODE_PARAM;
1270  q->exthypermodeparam.Header.BufferSz = sizeof(q->exthypermodeparam);
1271  q->exthypermodeparam.Mode = q->dual_gfx;
1272  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->exthypermodeparam;
1273  } else {
1274  av_log(avctx, AV_LOG_ERROR,
1275  "This version of runtime doesn't support Hyper Encode\n");
1276  return AVERROR_UNKNOWN;
1277  }
1278  }
1279 #endif
1280 
1281  if (!check_enc_param(avctx,q)) {
1282  av_log(avctx, AV_LOG_ERROR,
1283  "some encoding parameters are not supported by the QSV "
1284  "runtime. Please double check the input parameters.\n");
1285  return AVERROR(ENOSYS);
1286  }
1287 
1288  return 0;
1289 }
1290 
1292 {
1293  int ret = 0;
1294 
1295  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
1296  if (ret < 0)
1297  return ff_qsv_print_error(avctx, ret,
1298  "Error calling GetVideoParam");
1299 
1300  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
1301 
1302  // for qsv mjpeg the return value maybe 0 so alloc the buffer
1303  if (q->packet_size == 0)
1304  q->packet_size = q->param.mfx.FrameInfo.Height * q->param.mfx.FrameInfo.Width * 4;
1305 
1306  dump_video_mjpeg_param(avctx, q);
1307 
1308  return 0;
1309 }
1310 
1312 {
1313  int ret = 0;
1314  mfxExtVP9Param vp9_extend_buf = {
1315  .Header.BufferId = MFX_EXTBUFF_VP9_PARAM,
1316  .Header.BufferSz = sizeof(vp9_extend_buf),
1317  };
1318 
1319  mfxExtCodingOption2 co2 = {
1320  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
1321  .Header.BufferSz = sizeof(co2),
1322  };
1323 
1324  mfxExtCodingOption3 co3 = {
1325  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
1326  .Header.BufferSz = sizeof(co3),
1327  };
1328 
1329  mfxExtBuffer *ext_buffers[3];
1330  int ext_buf_num = 0;
1331 
1332  q->co2_idx = q->co3_idx = q->vp9_idx = -1;
1333 
1334  // It is possible the runtime doesn't support the given ext buffer
1335  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 6)) {
1336  q->co2_idx = ext_buf_num;
1337  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;
1338  }
1339 
1340  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 11)) {
1341  q->co3_idx = ext_buf_num;
1342  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;
1343  }
1344 
1345  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 26)) {
1346  q->vp9_idx = ext_buf_num;
1347  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&vp9_extend_buf;
1348  }
1349 
1350  q->param.ExtParam = ext_buffers;
1351  q->param.NumExtParam = ext_buf_num;
1352 
1353  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
1354  if (ret < 0)
1355  return ff_qsv_print_error(avctx, ret,
1356  "Error calling GetVideoParam");
1357 
1358  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
1359 
1360  dump_video_vp9_param(avctx, q, ext_buffers);
1361 
1362  return 0;
1363 }
1364 
1366 {
1367 #if QSV_HAVE_EXT_AV1_PARAM
1368  int ret = 0;
1369  mfxExtAV1TileParam av1_extend_tile_buf = {
1370  .Header.BufferId = MFX_EXTBUFF_AV1_TILE_PARAM,
1371  .Header.BufferSz = sizeof(av1_extend_tile_buf),
1372  };
1373  mfxExtAV1BitstreamParam av1_bs_param = {
1374  .Header.BufferId = MFX_EXTBUFF_AV1_BITSTREAM_PARAM,
1375  .Header.BufferSz = sizeof(av1_bs_param),
1376  };
1377 
1378  mfxExtCodingOption2 co2 = {
1379  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
1380  .Header.BufferSz = sizeof(co2),
1381  };
1382 
1383  mfxExtCodingOption3 co3 = {
1384  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
1385  .Header.BufferSz = sizeof(co3),
1386  };
1387 
1388  mfxExtBuffer *ext_buffers[] = {
1389  (mfxExtBuffer*)&av1_extend_tile_buf,
1390  (mfxExtBuffer*)&av1_bs_param,
1391  (mfxExtBuffer*)&co2,
1392  (mfxExtBuffer*)&co3,
1393  };
1394 
1395  if (!QSV_RUNTIME_VERSION_ATLEAST(q->ver, 2, 5)) {
1396  av_log(avctx, AV_LOG_ERROR,
1397  "This version of runtime doesn't support AV1 encoding\n");
1398  return AVERROR_UNKNOWN;
1399  }
1400 
1401  q->param.ExtParam = ext_buffers;
1402  q->param.NumExtParam = FF_ARRAY_ELEMS(ext_buffers);
1403 
1404  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
1405  if (ret < 0)
1406  return ff_qsv_print_error(avctx, ret,
1407  "Error calling GetVideoParam");
1408 
1409  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
1410  dump_video_av1_param(avctx, q, ext_buffers);
1411 #endif
1412  return 0;
1413 }
1414 
1416 {
1417  AVCPBProperties *cpb_props;
1418 
1419  uint8_t sps_buf[512];
1420  uint8_t pps_buf[128];
1421 
1422  mfxExtCodingOptionSPSPPS extradata = {
1423  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
1424  .Header.BufferSz = sizeof(extradata),
1425  .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),
1426  .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
1427  };
1428 
1429  mfxExtCodingOption co = {
1430  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
1431  .Header.BufferSz = sizeof(co),
1432  };
1433  mfxExtCodingOption2 co2 = {
1434  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
1435  .Header.BufferSz = sizeof(co2),
1436  };
1437  mfxExtCodingOption3 co3 = {
1438  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
1439  .Header.BufferSz = sizeof(co3),
1440  };
1441 
1442  uint8_t vps_buf[128];
1443  mfxExtCodingOptionVPS extradata_vps = {
1444  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_VPS,
1445  .Header.BufferSz = sizeof(extradata_vps),
1446  .VPSBuffer = vps_buf,
1447  .VPSBufSize = sizeof(vps_buf),
1448  };
1449 
1450  mfxExtHEVCTiles hevc_tile_buf = {
1451  .Header.BufferId = MFX_EXTBUFF_HEVC_TILES,
1452  .Header.BufferSz = sizeof(hevc_tile_buf),
1453  };
1454 
1455 #if QSV_HAVE_HE
1456  mfxExtHyperModeParam hyper_mode_param_buf = {
1457  .Header.BufferId = MFX_EXTBUFF_HYPER_MODE_PARAM,
1458  .Header.BufferSz = sizeof(hyper_mode_param_buf),
1459  };
1460 #endif
1461 
1462  mfxExtBuffer *ext_buffers[6 + QSV_HAVE_HE];
1463 
1464  int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
1465  int ret, ext_buf_num = 0, extradata_offset = 0;
1466 
1467  q->co2_idx = q->co3_idx = q->exthevctiles_idx = q->exthypermodeparam_idx = -1;
1468  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata;
1469  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co;
1470 
1471  // It is possible the runtime doesn't support the given ext buffer
1472  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 6)) {
1473  q->co2_idx = ext_buf_num;
1474  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;
1475  }
1476 
1477  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 11)) {
1478  q->co3_idx = ext_buf_num;
1479  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;
1480  }
1481 
1482  q->hevc_vps = ((avctx->codec_id == AV_CODEC_ID_HEVC) && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 17));
1483  if (q->hevc_vps)
1484  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata_vps;
1485  if (avctx->codec_id == AV_CODEC_ID_HEVC && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 13)) {
1486  q->exthevctiles_idx = ext_buf_num;
1487  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&hevc_tile_buf;
1488  }
1489 #if QSV_HAVE_HE
1490  if (q->dual_gfx && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 2, 4)) {
1491  q->exthypermodeparam_idx = ext_buf_num;
1492  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&hyper_mode_param_buf;
1493  }
1494 #endif
1495 
1496  q->param.ExtParam = ext_buffers;
1497  q->param.NumExtParam = ext_buf_num;
1498 
1499  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
1500  if (ret < 0)
1501  return ff_qsv_print_error(avctx, ret,
1502  "Error calling GetVideoParam");
1503 
1504  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
1505 
1506  if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)
1507  || (q->hevc_vps && !extradata_vps.VPSBufSize)
1508  ) {
1509  av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
1510  return AVERROR_UNKNOWN;
1511  }
1512 
1513  avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
1514  avctx->extradata_size += q->hevc_vps * extradata_vps.VPSBufSize;
1515 
1517  if (!avctx->extradata)
1518  return AVERROR(ENOMEM);
1519 
1520  if (q->hevc_vps) {
1521  memcpy(avctx->extradata, vps_buf, extradata_vps.VPSBufSize);
1522  extradata_offset += extradata_vps.VPSBufSize;
1523  }
1524 
1525  memcpy(avctx->extradata + extradata_offset, sps_buf, extradata.SPSBufSize);
1526  extradata_offset += extradata.SPSBufSize;
1527  if (need_pps) {
1528  memcpy(avctx->extradata + extradata_offset, pps_buf, extradata.PPSBufSize);
1529  extradata_offset += extradata.PPSBufSize;
1530  }
1531  memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1532 
1533  cpb_props = ff_encode_add_cpb_side_data(avctx);
1534  if (!cpb_props)
1535  return AVERROR(ENOMEM);
1536  cpb_props->max_bitrate = avctx->rc_max_rate;
1537  cpb_props->min_bitrate = avctx->rc_min_rate;
1538  cpb_props->avg_bitrate = avctx->bit_rate;
1539  cpb_props->buffer_size = avctx->rc_buffer_size;
1540 
1541  dump_video_param(avctx, q, ext_buffers);
1542 
1543  return 0;
1544 }
1545 
1546 #if QSV_HAVE_OPAQUE
1548 {
1549  AVQSVContext *qsv = avctx->hwaccel_context;
1550  mfxFrameSurface1 *surfaces;
1551  int nb_surfaces, i;
1552 
1553  nb_surfaces = qsv->nb_opaque_surfaces + q->req.NumFrameSuggested;
1554 
1555  q->opaque_alloc_buf = av_buffer_allocz(sizeof(*surfaces) * nb_surfaces);
1556  if (!q->opaque_alloc_buf)
1557  return AVERROR(ENOMEM);
1558 
1559  q->opaque_surfaces = av_malloc_array(nb_surfaces, sizeof(*q->opaque_surfaces));
1560  if (!q->opaque_surfaces)
1561  return AVERROR(ENOMEM);
1562 
1563  surfaces = (mfxFrameSurface1*)q->opaque_alloc_buf->data;
1564  for (i = 0; i < nb_surfaces; i++) {
1565  surfaces[i].Info = q->req.Info;
1566  q->opaque_surfaces[i] = surfaces + i;
1567  }
1568 
1569  q->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
1570  q->opaque_alloc.Header.BufferSz = sizeof(q->opaque_alloc);
1571  q->opaque_alloc.In.Surfaces = q->opaque_surfaces;
1572  q->opaque_alloc.In.NumSurface = nb_surfaces;
1573  q->opaque_alloc.In.Type = q->req.Type;
1574 
1575  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->opaque_alloc;
1576 
1577  qsv->nb_opaque_surfaces = nb_surfaces;
1579  qsv->opaque_alloc_type = q->req.Type;
1580 
1581  return 0;
1582 }
1583 #endif
1584 
1586 {
1587  int ret;
1588 
1589  if (avctx->hwaccel_context) {
1590  AVQSVContext *qsv = avctx->hwaccel_context;
1591  q->session = qsv->session;
1592  } else if (avctx->hw_frames_ctx) {
1594  if (!q->frames_ctx.hw_frames_ctx)
1595  return AVERROR(ENOMEM);
1596 
1598  &q->frames_ctx, q->load_plugins,
1599 #if QSV_HAVE_OPAQUE
1600  q->param.IOPattern == MFX_IOPATTERN_IN_OPAQUE_MEMORY,
1601 #else
1602  0,
1603 #endif
1604  MFX_GPUCOPY_OFF);
1605  if (ret < 0) {
1607  return ret;
1608  }
1609 
1610  q->session = q->internal_qs.session;
1611  } else if (avctx->hw_device_ctx) {
1613  avctx->hw_device_ctx, q->load_plugins,
1614  MFX_GPUCOPY_OFF);
1615  if (ret < 0)
1616  return ret;
1617 
1618  q->session = q->internal_qs.session;
1619  } else {
1621  q->load_plugins, MFX_GPUCOPY_OFF);
1622  if (ret < 0)
1623  return ret;
1624 
1625  q->session = q->internal_qs.session;
1626  }
1627 
1628  return 0;
1629 }
1630 
1632 {
1633  int iopattern = 0;
1634  int opaque_alloc = 0;
1635  int ret;
1636 
1637  q->param.AsyncDepth = q->async_depth;
1638 
1640  if (!q->async_fifo)
1641  return AVERROR(ENOMEM);
1642 
1643  if (avctx->hwaccel_context) {
1644  AVQSVContext *qsv = avctx->hwaccel_context;
1645 
1646  iopattern = qsv->iopattern;
1647  opaque_alloc = qsv->opaque_alloc;
1648  }
1649 
1650  if (avctx->hw_frames_ctx) {
1651  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1652  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
1653 
1654  if (!iopattern) {
1655 #if QSV_HAVE_OPAQUE
1656  if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)
1657  iopattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
1658  else if (frames_hwctx->frame_type &
1659  (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
1660  iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
1661 #else
1662  if (frames_hwctx->frame_type &
1663  (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
1664  iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
1665 #endif
1666  }
1667  }
1668 
1669  if (!iopattern)
1670  iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
1671  q->param.IOPattern = iopattern;
1672  ff_qsv_print_iopattern(avctx, iopattern, "Encoder");
1673 
1674  ret = qsvenc_init_session(avctx, q);
1675  if (ret < 0)
1676  return ret;
1677 
1678  ret = MFXQueryVersion(q->session,&q->ver);
1679  if (ret < 0) {
1680  return ff_qsv_print_error(avctx, ret,
1681  "Error querying mfx version");
1682  }
1683 
1684  // in the mfxInfoMFX struct, JPEG is different from other codecs
1685  switch (avctx->codec_id) {
1686  case AV_CODEC_ID_MJPEG:
1687  ret = init_video_param_jpeg(avctx, q);
1688  break;
1689  default:
1690  ret = init_video_param(avctx, q);
1691  break;
1692  }
1693  if (ret < 0)
1694  return ret;
1695 
1696  if (avctx->hwaccel_context) {
1697  AVQSVContext *qsv = avctx->hwaccel_context;
1698  int i, j;
1699 
1701  sizeof(*q->extparam));
1702  if (!q->extparam)
1703  return AVERROR(ENOMEM);
1704 
1705  q->param.ExtParam = q->extparam;
1706  for (i = 0; i < qsv->nb_ext_buffers; i++)
1707  q->param.ExtParam[i] = qsv->ext_buffers[i];
1708  q->param.NumExtParam = qsv->nb_ext_buffers;
1709 
1710  for (i = 0; i < q->nb_extparam_internal; i++) {
1711  for (j = 0; j < qsv->nb_ext_buffers; j++) {
1712  if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)
1713  break;
1714  }
1715  if (j < qsv->nb_ext_buffers)
1716  continue;
1717 
1718  q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];
1719  }
1720  } else {
1721  q->param.ExtParam = q->extparam_internal;
1722  q->param.NumExtParam = q->nb_extparam_internal;
1723  }
1724 
1725  ret = MFXVideoENCODE_Query(q->session, &q->param, &q->param);
1726  if (ret == MFX_WRN_PARTIAL_ACCELERATION) {
1727  av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
1728  } else if (ret < 0) {
1729  return ff_qsv_print_error(avctx, ret,
1730  "Error querying encoder params");
1731  }
1732 
1733  ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
1734  if (ret < 0)
1735  return ff_qsv_print_error(avctx, ret,
1736  "Error querying (IOSurf) the encoding parameters");
1737 
1738  if (opaque_alloc) {
1739 #if QSV_HAVE_OPAQUE
1740  ret = qsv_init_opaque_alloc(avctx, q);
1741  if (ret < 0)
1742  return ret;
1743 #else
1744  av_log(avctx, AV_LOG_ERROR, "User is requesting to allocate OPAQUE surface, "
1745  "however libmfx %d.%d doesn't support OPAQUE memory.\n",
1746  q->ver.Major, q->ver.Minor);
1747  return AVERROR_UNKNOWN;
1748 #endif
1749  }
1750 
1751  ret = MFXVideoENCODE_Init(q->session, &q->param);
1752  if (ret < 0)
1753  return ff_qsv_print_error(avctx, ret,
1754  "Error initializing the encoder");
1755  else if (ret > 0)
1756  ff_qsv_print_warning(avctx, ret,
1757  "Warning in encoder initialization");
1758 
1759  switch (avctx->codec_id) {
1760  case AV_CODEC_ID_MJPEG:
1761  ret = qsv_retrieve_enc_jpeg_params(avctx, q);
1762  break;
1763  case AV_CODEC_ID_VP9:
1764  ret = qsv_retrieve_enc_vp9_params(avctx, q);
1765  break;
1766  case AV_CODEC_ID_AV1:
1767  ret = qsv_retrieve_enc_av1_params(avctx, q);
1768  break;
1769  default:
1770  ret = qsv_retrieve_enc_params(avctx, q);
1771  break;
1772  }
1773  if (ret < 0) {
1774  av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
1775  return ret;
1776  }
1777 
1778  q->avctx = avctx;
1779 
1780  return 0;
1781 }
1782 
1783 static void free_encoder_ctrl(mfxEncodeCtrl* enc_ctrl)
1784 {
1785  if (enc_ctrl) {
1786  for (int i = 0; i < enc_ctrl->NumPayload && i < QSV_MAX_ENC_PAYLOAD; i++)
1787  av_freep(&enc_ctrl->Payload[i]);
1788 
1789  for (int i = 0; i < enc_ctrl->NumExtParam && i < QSV_MAX_ENC_EXTPARAM; i++)
1790  av_freep(&enc_ctrl->ExtParam[i]);
1791 
1792  enc_ctrl->NumPayload = 0;
1793  enc_ctrl->NumExtParam = 0;
1794  }
1795 }
1796 
1798 {
1799  QSVFrame *cur = q->work_frames;
1800  while (cur) {
1801  if (cur->used && !cur->surface.Data.Locked) {
1802  free_encoder_ctrl(&cur->enc_ctrl);
1803  //do not reuse enc_ctrl from previous frame
1804  memset(&cur->enc_ctrl, 0, sizeof(cur->enc_ctrl));
1805  cur->enc_ctrl.Payload = cur->payloads;
1806  cur->enc_ctrl.ExtParam = cur->extparam;
1807  if (cur->frame->format == AV_PIX_FMT_QSV) {
1808  av_frame_unref(cur->frame);
1809  }
1810  cur->used = 0;
1811  }
1812  cur = cur->next;
1813  }
1814 }
1815 
1817 {
1818  QSVFrame *frame, **last;
1819 
1821 
1822  frame = q->work_frames;
1823  last = &q->work_frames;
1824  while (frame) {
1825  if (!frame->used) {
1826  *f = frame;
1827  frame->used = 1;
1828  return 0;
1829  }
1830 
1831  last = &frame->next;
1832  frame = frame->next;
1833  }
1834 
1835  frame = av_mallocz(sizeof(*frame));
1836  if (!frame)
1837  return AVERROR(ENOMEM);
1838  frame->frame = av_frame_alloc();
1839  if (!frame->frame) {
1840  av_freep(&frame);
1841  return AVERROR(ENOMEM);
1842  }
1843  frame->enc_ctrl.Payload = frame->payloads;
1844  frame->enc_ctrl.ExtParam = frame->extparam;
1845  *last = frame;
1846 
1847  *f = frame;
1848  frame->used = 1;
1849 
1850  return 0;
1851 }
1852 
1853 static int qsvenc_fill_padding_area(AVFrame *frame, int new_w, int new_h)
1854 {
1855  const AVPixFmtDescriptor *desc;
1856  int max_step[4], filled[4] = { 0 };
1857 
1858  desc = av_pix_fmt_desc_get(frame->format);
1859  av_assert0(desc);
1860  av_image_fill_max_pixsteps(max_step, NULL, desc);
1861 
1862  for (int i = 0; i < desc->nb_components; i++) {
1863  const AVComponentDescriptor *comp = &desc->comp[i];
1864  int sheight, dheight, plane = comp->plane;
1865  ptrdiff_t swidth = av_image_get_linesize(frame->format,
1866  frame->width,
1867  plane);
1868  ptrdiff_t dwidth = av_image_get_linesize(frame->format,
1869  new_w,
1870  plane);
1871 
1872  if (swidth < 0 || dwidth < 0) {
1873  av_log(NULL, AV_LOG_ERROR, "av_image_get_linesize failed\n");
1874  return AVERROR(EINVAL);
1875  }
1876 
1877  if (filled[plane])
1878  continue;
1879 
1880  sheight = frame->height;
1881  dheight = new_h;
1882 
1883  if (plane) {
1884  sheight = AV_CEIL_RSHIFT(frame->height, desc->log2_chroma_h);
1885  dheight = AV_CEIL_RSHIFT(new_h, desc->log2_chroma_h);
1886  }
1887 
1888  // Fill right padding
1889  if (new_w > frame->width) {
1890  for (int j = 0; j < sheight; j++) {
1891  void *line_ptr = frame->data[plane] + j * frame->linesize[plane] + swidth;
1892 
1893  av_memcpy_backptr(line_ptr,
1894  max_step[plane],
1895  new_w - frame->width);
1896  }
1897  }
1898 
1899  // Fill bottom padding
1900  for (int j = sheight; j < dheight; j++)
1901  memcpy(frame->data[plane] + j * frame->linesize[plane],
1902  frame->data[plane] + (sheight - 1) * frame->linesize[plane],
1903  dwidth);
1904 
1905  filled[plane] = 1;
1906  }
1907 
1908  return 0;
1909 }
1910 
1911 /* frame width / height have been aligned with the alignment */
1913 {
1914  int total_size;
1915 
1916  switch (frame->format) {
1917  case AV_PIX_FMT_NV12:
1918  frame->linesize[0] = frame->width;
1919  frame->linesize[1] = frame->linesize[0];
1920  total_size = frame->linesize[0] * frame->height + frame->linesize[1] * frame->height / 2;
1921  break;
1922 
1923  case AV_PIX_FMT_P010:
1924  case AV_PIX_FMT_P012:
1925  frame->linesize[0] = 2 * frame->width;
1926  frame->linesize[1] = frame->linesize[0];
1927  total_size = frame->linesize[0] * frame->height + frame->linesize[1] * frame->height / 2;
1928  break;
1929 
1930  case AV_PIX_FMT_YUYV422:
1931  frame->linesize[0] = 2 * frame->width;
1932  frame->linesize[1] = 0;
1933  total_size = frame->linesize[0] * frame->height;
1934  break;
1935 
1936  case AV_PIX_FMT_Y210:
1937  case AV_PIX_FMT_VUYX:
1938  case AV_PIX_FMT_XV30:
1939  case AV_PIX_FMT_BGRA:
1940  case AV_PIX_FMT_X2RGB10:
1941  frame->linesize[0] = 4 * frame->width;
1942  frame->linesize[1] = 0;
1943  total_size = frame->linesize[0] * frame->height;
1944  break;
1945 
1946  default:
1947  // This should never be reached
1948  av_assert0(0);
1949  return AVERROR(EINVAL);
1950  }
1951 
1952  frame->buf[0] = av_buffer_alloc(total_size);
1953  if (!frame->buf[0])
1954  return AVERROR(ENOMEM);
1955 
1956  frame->data[0] = frame->buf[0]->data;
1957  frame->extended_data = frame->data;
1958 
1959  if (frame->format == AV_PIX_FMT_NV12 ||
1960  frame->format == AV_PIX_FMT_P010 ||
1961  frame->format == AV_PIX_FMT_P012)
1962  frame->data[1] = frame->data[0] + frame->linesize[0] * frame->height;
1963 
1964  return 0;
1965 }
1966 
1967 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
1968  QSVFrame **new_frame)
1969 {
1970  QSVFrame *qf;
1971  int ret;
1972 
1973  ret = get_free_frame(q, &qf);
1974  if (ret < 0)
1975  return ret;
1976 
1977  if (frame->format == AV_PIX_FMT_QSV) {
1978  ret = av_frame_ref(qf->frame, frame);
1979  if (ret < 0)
1980  return ret;
1981 
1982  qf->surface = *(mfxFrameSurface1*)qf->frame->data[3];
1983 
1984  if (q->frames_ctx.mids) {
1986  if (ret < 0)
1987  return ret;
1988 
1989  qf->surface.Data.MemId = &q->frames_ctx.mids[ret];
1990  }
1991  } else {
1992  /* make a copy if the input is not padded as libmfx requires */
1993  /* and to make allocation continious for data[0]/data[1] */
1994  if ((frame->height & (q->height_align - 1) || frame->linesize[0] & (q->width_align - 1)) ||
1995  ((frame->format == AV_PIX_FMT_NV12 || frame->format == AV_PIX_FMT_P010 || frame->format == AV_PIX_FMT_P012) &&
1996  (frame->data[1] - frame->data[0] != frame->linesize[0] * FFALIGN(qf->frame->height, q->height_align)))) {
1997  int tmp_w, tmp_h;
1998  qf->frame->height = tmp_h = FFALIGN(frame->height, q->height_align);
1999  qf->frame->width = tmp_w = FFALIGN(frame->width, q->width_align);
2000 
2001  qf->frame->format = frame->format;
2002 
2003  if (!qf->frame->data[0]) {
2005  if (ret < 0)
2006  return ret;
2007  }
2008 
2009  qf->frame->height = frame->height;
2010  qf->frame->width = frame->width;
2011 
2012  ret = av_frame_copy(qf->frame, frame);
2013  if (ret < 0) {
2014  av_frame_unref(qf->frame);
2015  return ret;
2016  }
2017 
2018  ret = qsvenc_fill_padding_area(qf->frame, tmp_w, tmp_h);
2019  if (ret < 0) {
2020  av_frame_unref(qf->frame);
2021  return ret;
2022  }
2023  } else {
2024  ret = av_frame_replace(qf->frame, frame);
2025  if (ret < 0)
2026  return ret;
2027  }
2028 
2029  qf->surface.Info = q->param.mfx.FrameInfo;
2030 
2031  qf->surface.Info.PicStruct =
2032  !(frame->flags & AV_FRAME_FLAG_INTERLACED) ? MFX_PICSTRUCT_PROGRESSIVE :
2033  (frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) ? MFX_PICSTRUCT_FIELD_TFF :
2034  MFX_PICSTRUCT_FIELD_BFF;
2035  if (frame->repeat_pict == 1)
2036  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
2037  else if (frame->repeat_pict == 2)
2038  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
2039  else if (frame->repeat_pict == 4)
2040  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
2041 
2043  if (ret < 0) {
2044  av_log(q->avctx, AV_LOG_ERROR, "map frame to surface failed.\n");
2045  return ret;
2046  }
2047  }
2048  qf->surface.Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
2049 
2050  *new_frame = qf;
2051 
2052  return 0;
2053 }
2054 
2056 {
2057  if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
2058  if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
2059  q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
2060  q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
2061  av_log(avctx, AV_LOG_WARNING,
2062  "Interlaced coding is supported"
2063  " at Main/High Profile Level 2.2-4.0\n");
2064  }
2065 }
2066 
2068  mfxEncodeCtrl *enc_ctrl)
2069 {
2070  AVFrameSideData *sd = NULL;
2071  int mb_size;
2072 
2073  if (avctx->codec_id == AV_CODEC_ID_H264)
2074  mb_size = 16;
2075  else if (avctx->codec_id == AV_CODEC_ID_H265)
2076  mb_size = 32;
2077  else
2078  return 0;
2079 
2080  if (frame)
2082 
2083  if (sd) {
2084  mfxExtEncoderROI *enc_roi = NULL;
2085  AVRegionOfInterest *roi;
2086  uint32_t roi_size;
2087  int nb_roi, i;
2088 
2089  roi = (AVRegionOfInterest *)sd->data;
2090  roi_size = roi->self_size;
2091  if (!roi_size || sd->size % roi_size) {
2092  av_log(avctx, AV_LOG_ERROR, "Invalid ROI Data.\n");
2093  return AVERROR(EINVAL);
2094  }
2095  nb_roi = sd->size / roi_size;
2096  if (nb_roi > QSV_MAX_ROI_NUM) {
2097  av_log(avctx, AV_LOG_WARNING, "More ROIs set than "
2098  "supported by driver (%d > %d).\n",
2099  nb_roi, QSV_MAX_ROI_NUM);
2100  nb_roi = QSV_MAX_ROI_NUM;
2101  }
2102 
2103  enc_roi = av_mallocz(sizeof(*enc_roi));
2104  if (!enc_roi)
2105  return AVERROR(ENOMEM);
2106  enc_roi->Header.BufferId = MFX_EXTBUFF_ENCODER_ROI;
2107  enc_roi->Header.BufferSz = sizeof(*enc_roi);
2108  enc_roi->NumROI = nb_roi;
2109  enc_roi->ROIMode = MFX_ROI_MODE_QP_DELTA;
2110  for (i = 0; i < nb_roi; i++) {
2111  roi = (AVRegionOfInterest *)(sd->data + roi_size * i);
2112  enc_roi->ROI[i].Top = FFALIGN(roi->top, mb_size);
2113  enc_roi->ROI[i].Bottom = FFALIGN(roi->bottom, mb_size);
2114  enc_roi->ROI[i].Left = FFALIGN(roi->left, mb_size);
2115  enc_roi->ROI[i].Right = FFALIGN(roi->right, mb_size);
2116  enc_roi->ROI[i].DeltaQP =
2117  roi->qoffset.num * 51 / roi->qoffset.den;
2118  av_log(avctx, AV_LOG_DEBUG, "ROI: (%d,%d)-(%d,%d) -> %+d.\n",
2119  roi->top, roi->left, roi->bottom, roi->right,
2120  enc_roi->ROI[i].DeltaQP);
2121  }
2122  enc_ctrl->ExtParam[enc_ctrl->NumExtParam] = (mfxExtBuffer *)enc_roi;
2123  enc_ctrl->NumExtParam++;
2124  }
2125  return 0;
2126 }
2127 
2129  mfxEncodeCtrl *enc_ctrl)
2130 {
2131  AVDictionaryEntry* skip_frame_dict = NULL;
2132  if (!frame->metadata)
2133  return;
2134  skip_frame_dict = av_dict_get(frame->metadata, "qsv_skip_frame", NULL, 0);
2135  if (!skip_frame_dict)
2136  return;
2137  enc_ctrl->SkipFrame = strtol(skip_frame_dict->value, NULL, 10);
2138  return;
2139 }
2140 
2142 {
2143  int updated = 0, new_qp = 0;
2144 
2145  if (avctx->codec_id != AV_CODEC_ID_H264 && avctx->codec_id != AV_CODEC_ID_HEVC)
2146  return 0;
2147 
2148  if (q->param.mfx.RateControlMethod == MFX_RATECONTROL_CQP) {
2154  if (!updated)
2155  return 0;
2156 
2157  new_qp = avctx->global_quality / FF_QP2LAMBDA;
2158  q->param.mfx.QPI = av_clip(new_qp * fabs(avctx->i_quant_factor) +
2159  avctx->i_quant_offset, 0, 51);
2160  q->param.mfx.QPP = av_clip(new_qp, 0, 51);
2161  q->param.mfx.QPB = av_clip(new_qp * fabs(avctx->b_quant_factor) +
2162  avctx->b_quant_offset, 0, 51);
2163  av_log(avctx, AV_LOG_DEBUG,
2164  "Reset qp = %d/%d/%d for idr/p/b frames\n",
2165  q->param.mfx.QPI, q->param.mfx.QPP, q->param.mfx.QPB);
2166  }
2167  return updated;
2168 }
2169 
2171 {
2172  int updated = 0;
2173 
2174  if (avctx->codec_id != AV_CODEC_ID_H264 && avctx->codec_id != AV_CODEC_ID_HEVC)
2175  return 0;
2176 
2178  if (!updated)
2179  return 0;
2180 
2181  q->extco2.MaxFrameSize = FFMAX(0, q->max_frame_size);
2182  av_log(avctx, AV_LOG_DEBUG,
2183  "Reset MaxFrameSize: %d;\n", q->extco2.MaxFrameSize);
2184 
2185  return updated;
2186 }
2187 
2189 {
2190  int updated = 0;
2191  UPDATE_PARAM(q->old_gop_size, avctx->gop_size);
2192  if (!updated)
2193  return 0;
2194 
2195  q->param.mfx.GopPicSize = FFMAX(0, avctx->gop_size);
2196  av_log(avctx, AV_LOG_DEBUG, "reset GopPicSize to %d\n",
2197  q->param.mfx.GopPicSize);
2198 
2199  return updated;
2200 }
2201 
2203 {
2204  int updated = 0;
2205 
2206  if (avctx->codec_id != AV_CODEC_ID_H264 && avctx->codec_id != AV_CODEC_ID_HEVC)
2207  return 0;
2208 
2213  if (!updated)
2214  return 0;
2215 
2216  q->extco2.IntRefType = FFMAX(0, q->int_ref_type);
2217  q->extco2.IntRefCycleSize = FFMAX(0, q->int_ref_cycle_size);
2218  q->extco2.IntRefQPDelta =
2219  q->int_ref_qp_delta != INT16_MIN ? q->int_ref_qp_delta : 0;
2220  q->extco3.IntRefCycleDist = FFMAX(0, q->int_ref_cycle_dist);
2221  av_log(avctx, AV_LOG_DEBUG,
2222  "Reset IntRefType: %d; IntRefCycleSize: %d; "
2223  "IntRefQPDelta: %d; IntRefCycleDist: %d\n",
2224  q->extco2.IntRefType, q->extco2.IntRefCycleSize,
2225  q->extco2.IntRefQPDelta, q->extco3.IntRefCycleDist);
2226 
2227  return updated;
2228 }
2229 
2231 {
2232  int updated = 0;
2233 
2234  if (avctx->codec_id != AV_CODEC_ID_H264)
2235  return 0;
2236 
2237  UPDATE_PARAM(q->old_qmin, avctx->qmin);
2238  UPDATE_PARAM(q->old_qmax, avctx->qmax);
2245  if (!updated)
2246  return 0;
2247 
2248  if ((avctx->qmin >= 0 && avctx->qmax >= 0 && avctx->qmin > avctx->qmax) ||
2249  (q->max_qp_i >= 0 && q->min_qp_i >= 0 && q->min_qp_i > q->max_qp_i) ||
2250  (q->max_qp_p >= 0 && q->min_qp_p >= 0 && q->min_qp_p > q->max_qp_p) ||
2251  (q->max_qp_b >= 0 && q->min_qp_b >= 0 && q->min_qp_b > q->max_qp_b)) {
2252  av_log(avctx, AV_LOG_ERROR,
2253  "qmin and or qmax are set but invalid,"
2254  " please make sure min <= max\n");
2255  return AVERROR(EINVAL);
2256  }
2257 
2258  q->extco2.MinQPI = 0;
2259  q->extco2.MaxQPI = 0;
2260  q->extco2.MinQPP = 0;
2261  q->extco2.MaxQPP = 0;
2262  q->extco2.MinQPB = 0;
2263  q->extco2.MaxQPB = 0;
2264  if (avctx->qmin >= 0) {
2265  q->extco2.MinQPI = avctx->qmin > 51 ? 51 : avctx->qmin;
2266  q->extco2.MinQPB = q->extco2.MinQPP = q->extco2.MinQPI;
2267  }
2268  if (avctx->qmax >= 0) {
2269  q->extco2.MaxQPI = avctx->qmax > 51 ? 51 : avctx->qmax;
2270  q->extco2.MaxQPB = q->extco2.MaxQPP = q->extco2.MaxQPI;
2271  }
2272  if (q->min_qp_i >= 0)
2273  q->extco2.MinQPI = q->min_qp_i > 51 ? 51 : q->min_qp_i;
2274  if (q->max_qp_i >= 0)
2275  q->extco2.MaxQPI = q->max_qp_i > 51 ? 51 : q->max_qp_i;
2276  if (q->min_qp_p >= 0)
2277  q->extco2.MinQPP = q->min_qp_p > 51 ? 51 : q->min_qp_p;
2278  if (q->max_qp_p >= 0)
2279  q->extco2.MaxQPP = q->max_qp_p > 51 ? 51 : q->max_qp_p;
2280  if (q->min_qp_b >= 0)
2281  q->extco2.MinQPB = q->min_qp_b > 51 ? 51 : q->min_qp_b;
2282  if (q->max_qp_b >= 0)
2283  q->extco2.MaxQPB = q->max_qp_b > 51 ? 51 : q->max_qp_b;
2284 
2285  av_log(avctx, AV_LOG_VERBOSE, "Reset MinQPI: %d; MaxQPI: %d; "
2286  "MinQPP: %d; MaxQPP: %d; "
2287  "MinQPB: %d; MaxQPB: %d\n",
2288  q->extco2.MinQPI, q->extco2.MaxQPI,
2289  q->extco2.MinQPP, q->extco2.MaxQPP,
2290  q->extco2.MinQPB, q->extco2.MaxQPB);
2291 
2292  return updated;
2293 }
2294 
2296 {
2297  int updated = 0;
2298 
2299  if (avctx->codec_id != AV_CODEC_ID_H264 &&
2300  avctx->codec_id != AV_CODEC_ID_HEVC &&
2301  avctx->codec_id != AV_CODEC_ID_AV1)
2302  return 0;
2303 
2305  if (!updated)
2306  return 0;
2307 
2308  q->extco3.LowDelayBRC = MFX_CODINGOPTION_UNKNOWN;
2309  if (q->low_delay_brc >= 0)
2310  q->extco3.LowDelayBRC = q->low_delay_brc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
2311  av_log(avctx, AV_LOG_DEBUG, "Reset LowDelayBRC: %s\n",
2312  print_threestate(q->extco3.LowDelayBRC));
2313 
2314  return updated;
2315 }
2316 
2318 {
2319  int updated = 0;
2320 
2323  if (!updated)
2324  return 0;
2325 
2326  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
2327  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
2328  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
2329  } else {
2330  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
2331  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
2332  }
2333  av_log(avctx, AV_LOG_DEBUG, "Reset framerate: %d/%d (%.2f fps).\n",
2334  q->param.mfx.FrameInfo.FrameRateExtN,
2335  q->param.mfx.FrameInfo.FrameRateExtD,
2336  (double)q->param.mfx.FrameInfo.FrameRateExtN / q->param.mfx.FrameInfo.FrameRateExtD);
2337 
2338  return updated;
2339 }
2340 
2342 {
2343  int updated = 0;
2344  int target_bitrate_kbps, max_bitrate_kbps, brc_param_multiplier;
2345  int buffer_size_in_kilobytes, initial_delay_in_kilobytes;
2346 
2349  UPDATE_PARAM(q->old_bit_rate, avctx->bit_rate);
2351  if (!updated)
2352  return 0;
2353 
2354  buffer_size_in_kilobytes = avctx->rc_buffer_size / 8000;
2355  initial_delay_in_kilobytes = avctx->rc_initial_buffer_occupancy / 8000;
2356  target_bitrate_kbps = avctx->bit_rate / 1000;
2357  max_bitrate_kbps = avctx->rc_max_rate / 1000;
2358  brc_param_multiplier = (FFMAX(FFMAX3(target_bitrate_kbps, max_bitrate_kbps, buffer_size_in_kilobytes),
2359  initial_delay_in_kilobytes) + 0x10000) / 0x10000;
2360 
2361  q->param.mfx.BufferSizeInKB = buffer_size_in_kilobytes / brc_param_multiplier;
2362  q->param.mfx.InitialDelayInKB = initial_delay_in_kilobytes / brc_param_multiplier;
2363  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
2364  q->param.mfx.MaxKbps = max_bitrate_kbps / brc_param_multiplier;
2365  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
2366  av_log(avctx, AV_LOG_VERBOSE,
2367  "Reset BufferSizeInKB: %d; InitialDelayInKB: %d; "
2368  "TargetKbps: %d; MaxKbps: %d; BRCParamMultiplier: %d\n",
2369  q->param.mfx.BufferSizeInKB, q->param.mfx.InitialDelayInKB,
2370  q->param.mfx.TargetKbps, q->param.mfx.MaxKbps, q->param.mfx.BRCParamMultiplier);
2371  return updated;
2372 }
2373 
2375 {
2376  int updated = 0;
2377 
2378  if (avctx->codec_id != AV_CODEC_ID_H264 && avctx->codec_id != AV_CODEC_ID_HEVC)
2379  return 0;
2380 
2382  if (!updated)
2383  return 0;
2384 
2385  q->extco.PicTimingSEI = q->pic_timing_sei ?
2386  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;
2387  av_log(avctx, AV_LOG_DEBUG, "Reset PicTimingSEI: %s\n",
2388  print_threestate(q->extco.PicTimingSEI));
2389 
2390  return updated;
2391 }
2392 
2394  const AVFrame *frame)
2395 {
2396  QSVPacket pkt = { { 0 } };
2397  mfxExtAVCEncodedFrameInfo *enc_info = NULL;
2398  mfxExtBuffer **enc_buf = NULL;
2399 
2400  mfxFrameSurface1 *surf = NULL;
2401  QSVFrame *qsv_frame = NULL;
2402  mfxEncodeCtrl* enc_ctrl = NULL;
2403  int ret;
2404 
2405  if (frame) {
2406  ret = submit_frame(q, frame, &qsv_frame);
2407  if (ret < 0) {
2408  av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
2409  return ret;
2410  }
2411  }
2412  if (qsv_frame) {
2413  surf = &qsv_frame->surface;
2414  enc_ctrl = &qsv_frame->enc_ctrl;
2415 
2416  if (frame->pict_type == AV_PICTURE_TYPE_I) {
2417  enc_ctrl->FrameType = MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF;
2418  if (q->forced_idr)
2419  enc_ctrl->FrameType |= MFX_FRAMETYPE_IDR;
2420  }
2421  }
2422 
2423  ret = av_new_packet(&pkt.pkt, q->packet_size);
2424  if (ret < 0) {
2425  av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
2426  return ret;
2427  }
2428 
2429  pkt.bs = av_mallocz(sizeof(*pkt.bs));
2430  if (!pkt.bs)
2431  goto nomem;
2432  pkt.bs->Data = pkt.pkt.data;
2433  pkt.bs->MaxLength = pkt.pkt.size;
2434 
2435  if (avctx->codec_id == AV_CODEC_ID_H264) {
2436  enc_info = av_mallocz(sizeof(*enc_info));
2437  if (!enc_info)
2438  goto nomem;
2439 
2440  enc_info->Header.BufferId = MFX_EXTBUFF_ENCODED_FRAME_INFO;
2441  enc_info->Header.BufferSz = sizeof (*enc_info);
2442  pkt.bs->NumExtParam = 1;
2443  enc_buf = av_mallocz(sizeof(mfxExtBuffer *));
2444  if (!enc_buf)
2445  goto nomem;
2446  enc_buf[0] = (mfxExtBuffer *)enc_info;
2447 
2448  pkt.bs->ExtParam = enc_buf;
2449  }
2450 
2451  if (q->set_encode_ctrl_cb && enc_ctrl) {
2452  q->set_encode_ctrl_cb(avctx, frame, enc_ctrl);
2453  }
2454 
2455  if ((avctx->codec_id == AV_CODEC_ID_H264 ||
2456  avctx->codec_id == AV_CODEC_ID_H265) &&
2457  enc_ctrl && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 8)) {
2458  ret = set_roi_encode_ctrl(avctx, frame, enc_ctrl);
2459  if (ret < 0)
2460  goto free;
2461  }
2462  if ((avctx->codec_id == AV_CODEC_ID_H264 ||
2463  avctx->codec_id == AV_CODEC_ID_H265) &&
2464  q->skip_frame != MFX_SKIPFRAME_NO_SKIP &&
2465  enc_ctrl && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 13))
2466  set_skip_frame_encode_ctrl(avctx, frame, enc_ctrl);
2467 
2468  pkt.sync = av_mallocz(sizeof(*pkt.sync));
2469  if (!pkt.sync)
2470  goto nomem;
2471 
2472  do {
2473  ret = MFXVideoENCODE_EncodeFrameAsync(q->session, enc_ctrl, surf, pkt.bs, pkt.sync);
2474  if (ret == MFX_WRN_DEVICE_BUSY)
2475  av_usleep(500);
2476  } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_WRN_IN_EXECUTION);
2477 
2478  if (ret > 0)
2479  ff_qsv_print_warning(avctx, ret, "Warning during encoding");
2480 
2481  if (ret < 0) {
2482  ret = (ret == MFX_ERR_MORE_DATA) ?
2483  AVERROR(EAGAIN) : ff_qsv_print_error(avctx, ret, "Error during encoding");
2484  goto free;
2485  }
2486 
2487  if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM && frame && (frame->flags & AV_FRAME_FLAG_INTERLACED))
2488  print_interlace_msg(avctx, q);
2489 
2490  ret = 0;
2491 
2492  if (*pkt.sync) {
2493  ret = av_fifo_write(q->async_fifo, &pkt, 1);
2494  if (ret < 0)
2495  goto free;
2496  } else {
2497 free:
2498  av_freep(&pkt.sync);
2499  av_packet_unref(&pkt.pkt);
2500  av_freep(&pkt.bs);
2501  if (avctx->codec_id == AV_CODEC_ID_H264) {
2502  av_freep(&enc_info);
2503  av_freep(&enc_buf);
2504  }
2505  }
2506 
2507  return ret;
2508 nomem:
2509  ret = AVERROR(ENOMEM);
2510  goto free;
2511 }
2512 
2514  const AVFrame *frame)
2515 {
2516  int needReset = 0, ret = 0;
2517 
2518  if (!frame || avctx->codec_id == AV_CODEC_ID_MJPEG)
2519  return 0;
2520 
2521  needReset = update_qp(avctx, q);
2522  needReset |= update_max_frame_size(avctx, q);
2523  needReset |= update_gop_size(avctx, q);
2524  needReset |= update_rir(avctx, q);
2525  needReset |= update_low_delay_brc(avctx, q);
2526  needReset |= update_frame_rate(avctx, q);
2527  needReset |= update_bitrate(avctx, q);
2528  needReset |= update_pic_timing_sei(avctx, q);
2529  ret = update_min_max_qp(avctx, q);
2530  if (ret < 0)
2531  return ret;
2532  needReset |= ret;
2533  if (!needReset)
2534  return 0;
2535 
2536  if (avctx->hwaccel_context) {
2537  AVQSVContext *qsv = avctx->hwaccel_context;
2538  int i, j;
2539  q->param.ExtParam = q->extparam;
2540  for (i = 0; i < qsv->nb_ext_buffers; i++)
2541  q->param.ExtParam[i] = qsv->ext_buffers[i];
2542  q->param.NumExtParam = qsv->nb_ext_buffers;
2543 
2544  for (i = 0; i < q->nb_extparam_internal; i++) {
2545  for (j = 0; j < qsv->nb_ext_buffers; j++) {
2546  if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)
2547  break;
2548  }
2549  if (j < qsv->nb_ext_buffers)
2550  continue;
2551  q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];
2552  }
2553  } else {
2554  q->param.ExtParam = q->extparam_internal;
2555  q->param.NumExtParam = q->nb_extparam_internal;
2556  }
2557 
2558  // Flush codec before reset configuration.
2559  while (ret != AVERROR(EAGAIN)) {
2560  ret = encode_frame(avctx, q, NULL);
2561  if (ret < 0 && ret != AVERROR(EAGAIN))
2562  return ret;
2563  }
2564 
2565  av_log(avctx, AV_LOG_DEBUG, "Parameter change, call msdk reset.\n");
2566  ret = MFXVideoENCODE_Reset(q->session, &q->param);
2567  if (ret < 0)
2568  return ff_qsv_print_error(avctx, ret, "Error during resetting");
2569 
2570  return 0;
2571 }
2572 
2574  AVPacket *pkt, const AVFrame *frame, int *got_packet)
2575 {
2576  int ret;
2577 
2578  ret = update_parameters(avctx, q, frame);
2579  if (ret < 0)
2580  return ret;
2581 
2582  ret = encode_frame(avctx, q, frame);
2583  if (ret < 0 && ret != AVERROR(EAGAIN))
2584  return ret;
2585 
2586  if ((av_fifo_can_read(q->async_fifo) >= q->async_depth) ||
2587  (!frame && av_fifo_can_read(q->async_fifo))) {
2588  QSVPacket qpkt;
2589  mfxExtAVCEncodedFrameInfo *enc_info;
2590  mfxExtBuffer **enc_buf;
2591  enum AVPictureType pict_type;
2592 
2593  av_fifo_read(q->async_fifo, &qpkt, 1);
2594 
2595  do {
2596  ret = MFXVideoCORE_SyncOperation(q->session, *qpkt.sync, 1000);
2597  } while (ret == MFX_WRN_IN_EXECUTION);
2598 
2599  qpkt.pkt.dts = av_rescale_q(qpkt.bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
2600  qpkt.pkt.pts = av_rescale_q(qpkt.bs->TimeStamp, (AVRational){1, 90000}, avctx->time_base);
2601  qpkt.pkt.size = qpkt.bs->DataLength;
2602 
2603  if (qpkt.bs->FrameType & MFX_FRAMETYPE_IDR || qpkt.bs->FrameType & MFX_FRAMETYPE_xIDR) {
2604  qpkt.pkt.flags |= AV_PKT_FLAG_KEY;
2605  pict_type = AV_PICTURE_TYPE_I;
2606  } else if (qpkt.bs->FrameType & MFX_FRAMETYPE_I || qpkt.bs->FrameType & MFX_FRAMETYPE_xI) {
2607  if (avctx->codec_id == AV_CODEC_ID_VP9)
2608  qpkt.pkt.flags |= AV_PKT_FLAG_KEY;
2609  pict_type = AV_PICTURE_TYPE_I;
2610  } else if (qpkt.bs->FrameType & MFX_FRAMETYPE_P || qpkt.bs->FrameType & MFX_FRAMETYPE_xP)
2611  pict_type = AV_PICTURE_TYPE_P;
2612  else if (qpkt.bs->FrameType & MFX_FRAMETYPE_B || qpkt.bs->FrameType & MFX_FRAMETYPE_xB)
2613  pict_type = AV_PICTURE_TYPE_B;
2614  else if (qpkt.bs->FrameType == MFX_FRAMETYPE_UNKNOWN && qpkt.bs->DataLength) {
2615  pict_type = AV_PICTURE_TYPE_NONE;
2616  av_log(avctx, AV_LOG_WARNING, "Unknown FrameType, set pict_type to AV_PICTURE_TYPE_NONE.\n");
2617  } else {
2618  av_log(avctx, AV_LOG_ERROR, "Invalid FrameType:%d.\n", qpkt.bs->FrameType);
2619  return AVERROR_INVALIDDATA;
2620  }
2621 
2622  if (avctx->codec_id == AV_CODEC_ID_H264) {
2623  enc_buf = qpkt.bs->ExtParam;
2624  enc_info = (mfxExtAVCEncodedFrameInfo *)(*enc_buf);
2626  enc_info->QP * FF_QP2LAMBDA, NULL, 0, pict_type);
2627  av_freep(&enc_info);
2628  av_freep(&enc_buf);
2629  }
2630  av_freep(&qpkt.bs);
2631  av_freep(&qpkt.sync);
2632 
2633  av_packet_move_ref(pkt, &qpkt.pkt);
2634 
2635  *got_packet = 1;
2636  }
2637 
2638  return 0;
2639 }
2640 
2642 {
2643  QSVFrame *cur;
2644 
2645  if (q->session)
2646  MFXVideoENCODE_Close(q->session);
2647 
2648  q->session = NULL;
2650 
2653 
2654  cur = q->work_frames;
2655  while (cur) {
2656  q->work_frames = cur->next;
2657  av_frame_free(&cur->frame);
2658  free_encoder_ctrl(&cur->enc_ctrl);
2659  av_freep(&cur);
2660  cur = q->work_frames;
2661  }
2662 
2663  if (q->async_fifo) {
2664  QSVPacket pkt;
2665  while (av_fifo_read(q->async_fifo, &pkt, 1) >= 0) {
2666  if (avctx->codec_id == AV_CODEC_ID_H264) {
2667  mfxExtBuffer **enc_buf = pkt.bs->ExtParam;
2668  mfxExtAVCEncodedFrameInfo *enc_info = (mfxExtAVCEncodedFrameInfo *)(*enc_buf);
2669  av_freep(&enc_info);
2670  av_freep(&enc_buf);
2671  }
2672  av_freep(&pkt.sync);
2673  av_freep(&pkt.bs);
2674  av_packet_unref(&pkt.pkt);
2675  }
2677  }
2678 
2679 #if QSV_HAVE_OPAQUE
2682 #endif
2683 
2684  av_freep(&q->extparam);
2685 
2686  return 0;
2687 }
2688 
2690  HW_CONFIG_ENCODER_FRAMES(QSV, QSV),
2691  HW_CONFIG_ENCODER_DEVICE(NV12, QSV),
2692  HW_CONFIG_ENCODER_DEVICE(P010, QSV),
2693  NULL,
2694 };
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:427
update_gop_size
static int update_gop_size(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2188
AVCodecContext::hwaccel_context
void * hwaccel_context
Legacy hardware accelerator context.
Definition: avcodec.h:1451
QSVEncContext::look_ahead_depth
int look_ahead_depth
Definition: qsvenc.h:218
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
QSVEncContext::old_max_qp_i
int old_max_qp_i
Definition: qsvenc.h:297
dump_video_vp9_param
static void dump_video_vp9_param(AVCodecContext *avctx, QSVEncContext *q, mfxExtBuffer **coding_opts)
Definition: qsvenc.c:403
av_clip
#define av_clip
Definition: common.h:99
QSVEncContext::repeat_pps
int repeat_pps
Definition: qsvenc.h:252
set_roi_encode_ctrl
static int set_roi_encode_ctrl(AVCodecContext *avctx, const AVFrame *frame, mfxEncodeCtrl *enc_ctrl)
Definition: qsvenc.c:2067
AVERROR
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
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:685
qsv_retrieve_enc_vp9_params
static int qsv_retrieve_enc_vp9_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1311
QSVFramesContext::hw_frames_ctx
AVBufferRef * hw_frames_ctx
Definition: qsv_internal.h:115
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:947
QSVEncContext::max_qp_i
int max_qp_i
Definition: qsvenc.h:273
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:81
AVCodecContext::rc_min_rate
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:1299
QSVEncContext::p_strategy
int p_strategy
Definition: qsvenc.h:243
QSVEncContext::old_rc_buffer_size
int old_rc_buffer_size
Definition: qsvenc.h:309
AVProfile::name
const char * name
short name for the profile
Definition: codec.h:181
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:123
AVPictureType
AVPictureType
Definition: avutil.h:277
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:224
QSVEncContext::avbr_accuracy
int avbr_accuracy
Definition: qsvenc.h:214
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
QSVEncContext::extco
mfxExtCodingOption extco
Definition: qsvenc.h:171
QSVEncContext::old_int_ref_type
int old_int_ref_type
Definition: qsvenc.h:290
QSVFrame::extparam
mfxExtBuffer * extparam[QSV_MAX_ENC_EXTPARAM]
used for enc_ctrl.ExtParam
Definition: qsv_internal.h:97
ff_qsv_close_internal_session
int ff_qsv_close_internal_session(QSVSession *qs)
Definition: qsv.c:1124
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:375
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:678
AVFrame::width
int width
Definition: frame.h:447
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:686
internal.h
QSVEncContext::adaptive_b
int adaptive_b
Definition: qsvenc.h:241
AVPacket::data
uint8_t * data
Definition: packet.h:524
QSVEncContext::max_frame_size
int max_frame_size
Definition: qsvenc.h:222
QSVEncContext::tile_cols
int tile_cols
Definition: qsvenc.h:229
encode.h
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:583
QSVEncContext::packet_size
int packet_size
Definition: qsvenc.h:164
ff_qsv_find_surface_idx
int ff_qsv_find_surface_idx(QSVFramesContext *ctx, QSVFrame *frame)
Definition: qsv.c:343
AVCodecContext::b_quant_offset
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:811
dump_video_mjpeg_param
static void dump_video_mjpeg_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:474
AV_PIX_FMT_XV30
#define AV_PIX_FMT_XV30
Definition: pixfmt.h:534
QSVEncContext::adaptive_i
int adaptive_i
Definition: qsvenc.h:240
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AVCOL_SPC_RGB
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
Definition: pixfmt.h:610
QSVEncContext::int_ref_qp_delta
int int_ref_qp_delta
Definition: qsvenc.h:248
print_threestate
static const char * print_threestate(mfxU16 val)
Definition: qsvenc.c:182
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
QSVEncContext::old_int_ref_cycle_size
int old_int_ref_cycle_size
Definition: qsvenc.h:291
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
QSVEncContext::frames_ctx
QSVFramesContext frames_ctx
Definition: qsvenc.h:202
QSVEncContext::old_gop_size
int old_gop_size
Definition: qsvenc.h:288
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1263
AVQSVContext::opaque_alloc_type
int opaque_alloc_type
Encoding only, and only if opaque_alloc is set to non-zero.
Definition: qsv.h:99
FF_COMPRESSION_DEFAULT
#define FF_COMPRESSION_DEFAULT
Definition: avcodec.h:1246
QSVEncContext::load_plugins
char * load_plugins
Definition: qsvenc.h:262
QSVFrame::frame
AVFrame * frame
Definition: qsv_internal.h:80
AVQSVContext::iopattern
int iopattern
The IO pattern to use.
Definition: qsv.h:46
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:579
QSVFrame::used
int used
Definition: qsv_internal.h:100
select_rc_mode
static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:570
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:396
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
QSVFrame::enc_ctrl
mfxEncodeCtrl enc_ctrl
Definition: qsv_internal.h:82
ff_qsv_init_session_device
int ff_qsv_init_session_device(AVCodecContext *avctx, mfxSession *psession, AVBufferRef *device_ref, const char *load_plugins, int gpu_copy)
Definition: qsv.c:1000
QSVEncContext::exthevctiles_idx
int exthevctiles_idx
Definition: qsvenc.h:269
QSVEncContext::extvsi
mfxExtVideoSignalInfo extvsi
Definition: qsvenc.h:193
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:639
update_min_max_qp
static int update_min_max_qp(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2230
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:560
QSVEncContext::recovery_point_sei
int recovery_point_sei
Definition: qsvenc.h:250
QSVEncContext::hevc_vps
int hevc_vps
Definition: qsvenc.h:206
ff_qsv_map_frame_to_surface
int ff_qsv_map_frame_to_surface(const AVFrame *frame, mfxFrameSurface1 *surface)
Definition: qsv.c:282
AVCodecContext::i_quant_factor
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:820
QSVEncContext::param
mfxVideoParam param
Definition: qsvenc.h:168
QSVEncContext::height_align
int height_align
Definition: qsvenc.h:166
av_fifo_write
int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems)
Write data into a FIFO.
Definition: fifo.c:188
QSVEncContext::profile
int profile
Definition: qsvenc.h:211
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:715
QSVEncContext::old_global_quality
int old_global_quality
Definition: qsvenc.h:280
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
val
static double val(void *priv, double ch)
Definition: aeval.c:78
update_pic_timing_sei
static int update_pic_timing_sei(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2374
update_parameters
static int update_parameters(AVCodecContext *avctx, QSVEncContext *q, const AVFrame *frame)
Definition: qsvenc.c:2513
qsv_retrieve_enc_params
static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1415
AVRational::num
int num
Numerator.
Definition: rational.h:59
qsv_internal.h
AV_CODEC_FLAG_INTERLACED_DCT
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:330
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:148
quant
static const uint8_t quant[64]
Definition: vmixdec.c:71
QSVEncContext::extbrc
int extbrc
Definition: qsvenc.h:239
AV_PIX_FMT_Y210
#define AV_PIX_FMT_Y210
Definition: pixfmt.h:532
avassert.h
ff_qsv_enc_hw_configs
const AVCodecHWConfigInternal *const ff_qsv_enc_hw_configs[]
Definition: qsvenc.c:2689
QSVEncContext::min_qp_i
int min_qp_i
Definition: qsvenc.h:274
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:671
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
ff_qsv_print_warning
int ff_qsv_print_warning(void *log_ctx, mfxStatus err, const char *warning_string)
Definition: qsv.c:193
AVFrameSideData::size
size_t size
Definition: frame.h:253
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
profile_names::name
const char * name
Definition: qsvenc.c:47
AVRegionOfInterest
Structure describing a single Region Of Interest.
Definition: frame.h:300
av_fifo_read
int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)
Read data from a FIFO.
Definition: fifo.c:240
AVCodecContext::rc_initial_buffer_occupancy
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:1320
QSVEncContext
Definition: qsvenc.h:156
QSV_HAVE_VCM
#define QSV_HAVE_VCM
Definition: qsvenc.h:51
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:62
av_memcpy_backptr
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:447
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
QSVEncContext::old_pic_timing_sei
int old_pic_timing_sei
Definition: qsvenc.h:313
QSVEncContext::old_int_ref_qp_delta
int old_int_ref_qp_delta
Definition: qsvenc.h:292
qsvenc.h
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: packet.c:98
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1239
QSVEncContext::skip_frame
int skip_frame
Definition: qsvenc.h:314
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:59
AVRegionOfInterest::bottom
int bottom
Definition: frame.h:316
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:220
QSV_RUNTIME_VERSION_ATLEAST
#define QSV_RUNTIME_VERSION_ATLEAST(MFX_VERSION, MAJOR, MINOR)
Definition: qsv_internal.h:63
info
MIPS optimizations info
Definition: mips.txt:2
update_rir
static int update_rir(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2202
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
QSVEncContext::old_framerate
AVRational old_framerate
Definition: qsvenc.h:306
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
QSVEncContext::max_frame_size_p
int max_frame_size_p
Definition: qsvenc.h:224
QSVEncContext::nb_extparam_internal
int nb_extparam_internal
Definition: qsvenc.h:196
QSVEncContext::pic_timing_sei
int pic_timing_sei
Definition: qsvenc.h:216
av_rescale_q
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
AVQSVContext::nb_opaque_surfaces
int nb_opaque_surfaces
Encoding only, and only if opaque_alloc is set to non-zero.
Definition: qsv.h:78
init_video_param_jpeg
static int init_video_param_jpeg(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:705
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:387
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1292
av_usleep
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:84
QSVEncContext::forced_idr
int forced_idr
Definition: qsvenc.h:264
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:558
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:269
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
AVQSVContext::nb_ext_buffers
int nb_ext_buffers
Definition: qsv.h:52
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:455
print_interlace_msg
static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2055
QSVEncContext::exthevctiles
mfxExtHEVCTiles exthevctiles
Definition: qsvenc.h:178
if
if(ret)
Definition: filter_design.txt:179
ff_qsv_init_session_frames
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:1077
check_enc_param
static int check_enc_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:668
update_max_frame_size
static int update_max_frame_size(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2170
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1277
QSVFrame
Definition: qsv_internal.h:79
QSVEncContext::int_ref_cycle_size
int int_ref_cycle_size
Definition: qsvenc.h:247
QSVEncContext::opaque_surfaces
mfxFrameSurface1 ** opaque_surfaces
Definition: qsvenc.h:189
QSVEncContext::dual_gfx
int dual_gfx
Definition: qsvenc.h:316
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:695
av_buffer_unref
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:139
AVComponentDescriptor
Definition: pixdesc.h:30
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:280
QSVEncContext::req
mfxFrameAllocRequest req
Definition: qsvenc.h:169
qsv.h
AV_PIX_FMT_YUYV422
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:74
QSV_HAVE_OPAQUE
#define QSV_HAVE_OPAQUE
Definition: qsv_internal.h:68
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
QSVEncContext::look_ahead_downsampling
int look_ahead_downsampling
Definition: qsvenc.h:219
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:495
init_video_param
static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:771
QSVEncContext::max_dec_frame_buffering
int max_dec_frame_buffering
Definition: qsvenc.h:235
AVRegionOfInterest::self_size
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
Definition: frame.h:305
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
QSVFrame::payloads
mfxPayload * payloads[QSV_MAX_ENC_PAYLOAD]
used for enc_ctrl.Payload
Definition: qsv_internal.h:96
QSVEncContext::old_max_frame_size
int old_max_frame_size
Definition: qsvenc.h:286
get_free_frame
static int get_free_frame(QSVEncContext *q, QSVFrame **f)
Definition: qsvenc.c:1816
ff_qsv_print_iopattern
int ff_qsv_print_iopattern(void *log_ctx, int mfx_iopattern, const char *extra_string)
Definition: qsv.c:99
av_fifo_can_read
size_t av_fifo_can_read(const AVFifo *f)
Definition: fifo.c:87
update_frame_rate
static int update_frame_rate(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2317
QSVFrame::surface
mfxFrameSurface1 surface
Definition: qsv_internal.h:81
print_profile
static const char * print_profile(enum AVCodecID codec_id, mfxU16 profile)
Definition: qsvenc.c:98
time.h
QSVFramesContext::mids_buf
AVBufferRef * mids_buf
Definition: qsv_internal.h:122
AVCodecContext::trellis
int trellis
trellis RD quantization
Definition: avcodec.h:1327
update_low_delay_brc
static int update_low_delay_brc(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2295
AV_PIX_FMT_QSV
@ AV_PIX_FMT_QSV
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
Definition: pixfmt.h:247
free_encoder_ctrl
static void free_encoder_ctrl(mfxEncodeCtrl *enc_ctrl)
Definition: qsvenc.c:1783
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: packet.c:484
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1783
QSVEncContext::mbbrc
int mbbrc
Definition: qsvenc.h:238
qsv_retrieve_enc_av1_params
static int qsv_retrieve_enc_av1_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1365
FrameInfo
Definition: af_amix.c:57
QSVPacket::pkt
AVPacket pkt
Definition: qsvenc.c:93
QSVEncContext::preset
int preset
Definition: qsvenc.h:213
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
QSVPacket::sync
mfxSyncPoint * sync
Definition: qsvenc.c:94
QSV_MAX_ENC_EXTPARAM
#define QSV_MAX_ENC_EXTPARAM
Definition: qsv_internal.h:53
AVQSVContext::opaque_surfaces
AVBufferRef * opaque_surfaces
Encoding only, and only if opaque_alloc is set to non-zero.
Definition: qsv.h:92
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:544
QSVEncContext::min_qp_p
int min_qp_p
Definition: qsvenc.h:276
f
f
Definition: af_crystalizer.c:121
HW_CONFIG_ENCODER_DEVICE
#define HW_CONFIG_ENCODER_DEVICE(format, device_type_)
Definition: hwconfig.h:95
QSVEncContext::extmfp
mfxExtMultiFrameParam extmfp
Definition: qsvenc.h:175
AVPacket::size
int size
Definition: packet.h:525
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1031
av_frame_ref
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:384
profile_names
Definition: qsvenc.c:45
AV_PIX_FMT_P012
#define AV_PIX_FMT_P012
Definition: pixfmt.h:529
set_skip_frame_encode_ctrl
static void set_skip_frame_encode_ctrl(AVCodecContext *avctx, const AVFrame *frame, mfxEncodeCtrl *enc_ctrl)
Definition: qsvenc.c:2128
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:999
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
QSVEncContext::avbr_convergence
int avbr_convergence
Definition: qsvenc.h:215
AVQSVContext::session
mfxSession session
If non-NULL, the session to use for encoding or decoding.
Definition: qsv.h:41
QSVEncContext::old_rc_initial_buffer_occupancy
int old_rc_initial_buffer_occupancy
Definition: qsvenc.h:310
QSVEncContext::opaque_alloc_buf
AVBufferRef * opaque_alloc_buf
Definition: qsvenc.h:190
QSVEncContext::min_qp_b
int min_qp_b
Definition: qsvenc.h:278
QSVEncContext::old_min_qp_b
int old_min_qp_b
Definition: qsvenc.h:302
QSVEncContext::extco2
mfxExtCodingOption2 extco2
Definition: qsvenc.h:172
QSVEncContext::max_qp_b
int max_qp_b
Definition: qsvenc.h:277
AVFrameSideData::data
uint8_t * data
Definition: frame.h:252
QSVEncContext::old_low_delay_brc
int old_low_delay_brc
Definition: qsvenc.h:304
QSVEncContext::co2_idx
int co2_idx
Definition: qsvenc.h:267
qsv_init_opaque_alloc
static int qsv_init_opaque_alloc(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1547
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:462
AVCodecHWConfigInternal
Definition: hwconfig.h:25
AV_PICTURE_TYPE_NONE
@ AV_PICTURE_TYPE_NONE
Undefined.
Definition: avutil.h:278
AVCPBProperties::min_bitrate
int64_t min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: defs.h:279
AVQSVContext::ext_buffers
mfxExtBuffer ** ext_buffers
Extra buffers to pass to encoder or decoder initialization.
Definition: qsv.h:51
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:523
FF_COMPLIANCE_NORMAL
#define FF_COMPLIANCE_NORMAL
Definition: defs.h:60
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:530
QSVEncContext::max_slice_size
int max_slice_size
Definition: qsvenc.h:225
QSVEncContext::max_frame_size_i
int max_frame_size_i
Definition: qsvenc.h:223
av_buffer_alloc
AVBufferRef * av_buffer_alloc(size_t size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:77
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: defs.h:284
AVRegionOfInterest::right
int right
Definition: frame.h:318
QSVEncContext::mfmode
int mfmode
Definition: qsvenc.h:260
QSVEncContext::exthypermodeparam_idx
int exthypermodeparam_idx
Definition: qsvenc.h:270
QSVEncContext::work_frames
QSVFrame * work_frames
Definition: qsvenc.h:159
AVCodecContext::b_quant_factor
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:804
QSVFramesContext::mids
QSVMid * mids
Definition: qsv_internal.h:123
QSVEncContext::old_i_quant_offset
float old_i_quant_offset
Definition: qsvenc.h:282
QSVEncContext::bitrate_limit
int bitrate_limit
Definition: qsvenc.h:237
QSVEncContext::rdo
int rdo
Definition: qsvenc.h:221
av_image_get_linesize
int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane)
Compute the size of an image line with format pix_fmt and width width for the plane plane.
Definition: imgutils.c:76
QSVEncContext::tier
int tier
Definition: qsvenc.h:212
QSVEncContext::opaque_alloc
mfxExtOpaqueSurfaceAlloc opaque_alloc
Definition: qsvenc.h:188
HW_CONFIG_ENCODER_FRAMES
#define HW_CONFIG_ENCODER_FRAMES(format, device_type_)
Definition: hwconfig.h:98
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:59
QSVEncContext::single_sei_nal_unit
int single_sei_nal_unit
Definition: qsvenc.h:234
QSVEncContext::dblk_idc
int dblk_idc
Definition: qsvenc.h:226
AVRegionOfInterest::left
int left
Definition: frame.h:317
hwcontext_qsv.h
ff_qsv_map_pixfmt
int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc, uint16_t *shift)
Definition: qsv.c:223
ff_qsv_enc_close
int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2641
QSVEncContext::set_encode_ctrl_cb
SetEncodeCtrlCB * set_encode_ctrl_cb
Definition: qsvenc.h:263
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:517
UPDATE_PARAM
#define UPDATE_PARAM(a, b)
Definition: qsvenc.c:163
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
QSVEncContext::internal_qs
QSVSession internal_qs
Definition: qsvenc.h:162
AVRegionOfInterest::top
int top
Distance in pixels from the top edge of the frame to the top and bottom edges and from the left edge ...
Definition: frame.h:315
is_strict_gop
static int is_strict_gop(QSVEncContext *q)
Definition: qsvenc.c:699
QSVEncContext::old_bit_rate
int old_bit_rate
Definition: qsvenc.h:308
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
common.h
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:274
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
QSVEncContext::extco3
mfxExtCodingOption3 extco3
Definition: qsvenc.h:173
QSVEncContext::extparam
mfxExtBuffer ** extparam
Definition: qsvenc.h:198
QSVEncContext::async_depth
int async_depth
Definition: qsvenc.h:209
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:606
QSV_HAVE_HE
#define QSV_HAVE_HE
Definition: qsvenc.h:53
AV_PIX_FMT_X2RGB10
#define AV_PIX_FMT_X2RGB10
Definition: pixfmt.h:536
submit_frame
static int submit_frame(QSVEncContext *q, const AVFrame *frame, QSVFrame **new_frame)
Definition: qsvenc.c:1967
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
QSVEncContext::cavlc
int cavlc
Definition: qsvenc.h:244
AVCodecContext::hw_device_ctx
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
Definition: avcodec.h:1497
profile
int profile
Definition: mxfenc.c:2227
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:612
clear_unused_frames
static void clear_unused_frames(QSVEncContext *q)
Definition: qsvenc.c:1797
dump_video_param
static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q, mfxExtBuffer **coding_opts)
Definition: qsvenc.c:191
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:634
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
update_qp
static int update_qp(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2141
QSVEncContext::old_qmax
int old_qmax
Definition: qsvenc.h:295
QSVEncContext::aud
int aud
Definition: qsvenc.h:232
AVCodecContext::hw_frames_ctx
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.
Definition: avcodec.h:1475
avcodec.h
QSVEncContext::int_ref_type
int int_ref_type
Definition: qsvenc.h:246
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:115
QSVEncContext::old_min_qp_i
int old_min_qp_i
Definition: qsvenc.h:298
profile_names::profile
mfxU16 profile
Definition: qsvenc.c:46
av_buffer_allocz
AVBufferRef * av_buffer_allocz(size_t size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:93
AV_CODEC_FLAG_CLOSED_GOP
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:352
ret
ret
Definition: filter_design.txt:187
print_ratecontrol
static const char * print_ratecontrol(mfxU16 rc_mode)
Definition: qsvenc.c:173
QSVEncContext::max_qp_p
int max_qp_p
Definition: qsvenc.h:275
QSVEncContext::look_ahead
int look_ahead
Definition: qsvenc.h:217
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:96
frame
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
Definition: filter_design.txt:264
AVCPBProperties::buffer_size
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: defs.h:290
UNMATCH
#define UNMATCH(x)
AVHWFramesContext::hwctx
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:150
ff_qsv_codec_id_to_mfx
int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)
Definition: qsv.c:53
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1379
av_fifo_alloc2
AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)
Allocate and initialize an AVFifo with a given element size.
Definition: fifo.c:47
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
QSVPacket
Definition: qsvenc.c:92
QSVEncContext::async_fifo
AVFifo * async_fifo
Definition: qsvenc.h:200
update_bitrate
static int update_bitrate(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2341
QSVEncContext::co3_idx
int co3_idx
Definition: qsvenc.h:268
QSVEncContext::extparam_internal
mfxExtBuffer * extparam_internal[5+(QSV_HAVE_MF *2)+(QSV_HAVE_EXT_AV1_PARAM *2)+QSV_HAVE_HE]
Definition: qsvenc.h:195
QSVEncContext::int_ref_cycle_dist
int int_ref_cycle_dist
Definition: qsvenc.h:249
av_frame_replace
int av_frame_replace(AVFrame *dst, const AVFrame *src)
Ensure the destination frame refers to the same data described by the source frame,...
Definition: frame.c:483
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVFrame::height
int height
Definition: frame.h:447
QSVEncContext::b_strategy
int b_strategy
Definition: qsvenc.h:242
QSVEncContext::old_b_quant_factor
float old_b_quant_factor
Definition: qsvenc.h:283
encode_frame
static int encode_frame(AVCodecContext *avctx, QSVEncContext *q, const AVFrame *frame)
Definition: qsvenc.c:2393
QSVEncContext::gpb
int gpb
Definition: qsvenc.h:254
QSVEncContext::vcm
int vcm
Definition: qsvenc.h:220
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1256
AVRational::den
int den
Denominator.
Definition: rational.h:60
QSVEncContext::idr_interval
int idr_interval
Definition: qsvenc.h:210
QSVEncContext::old_rc_max_rate
int old_rc_max_rate
Definition: qsvenc.h:311
AVQSVContext
This struct is used for communicating QSV parameters between libavcodec and the caller.
Definition: qsv.h:36
QSVSession::session
mfxSession session
Definition: qsv_internal.h:106
AVCodecContext::i_quant_offset
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:827
AV_CODEC_ID_H265
#define AV_CODEC_ID_H265
Definition: codec_id.h:227
profiles
static const AVProfile profiles[]
Definition: libfdk-aacenc.c:547
qsvenc_get_continuous_buffer
static int qsvenc_get_continuous_buffer(AVFrame *frame)
Definition: qsvenc.c:1912
QSVEncContext::ver
mfxVersion ver
Definition: qsvenc.h:204
QSVEncContext::session
mfxSession session
Definition: qsvenc.h:161
av_image_fill_max_pixsteps
void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4], const AVPixFmtDescriptor *pixdesc)
Compute the max pixel step for each plane of an image with a format described by pixdesc.
Definition: imgutils.c:35
AV_PIX_FMT_P010
#define AV_PIX_FMT_P010
Definition: pixfmt.h:528
AVQSVFramesContext
This struct is allocated as AVHWFramesContext.hwctx.
Definition: hwcontext_qsv.h:53
desc
const char * desc
Definition: libsvtav1.c:75
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
QSV_MAX_ENC_PAYLOAD
#define QSV_MAX_ENC_PAYLOAD
Definition: qsv_internal.h:52
mem.h
AVCodecContext::max_b_frames
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:795
ff_qsv_enc_init
int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1631
packet_internal.h
QSVEncContext::old_qmin
int old_qmin
Definition: qsvenc.h:296
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:250
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
QSVEncContext::old_min_qp_p
int old_min_qp_p
Definition: qsvenc.h:300
rc_names
static const struct @147 rc_names[]
AVQSVContext::opaque_alloc
int opaque_alloc
Encoding only.
Definition: qsv.h:67
AVDictionaryEntry
Definition: dict.h:89
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecContext::slices
int slices
Number of slices.
Definition: avcodec.h:1047
AVPacket
This structure stores compressed data.
Definition: packet.h:501
QSVEncContext::extvp9param
mfxExtVP9Param extvp9param
Definition: qsvenc.h:179
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
QSVEncContext::low_delay_brc
int low_delay_brc
Definition: qsvenc.h:265
QSVEncContext::transform_skip
int transform_skip
Definition: qsvenc.h:255
FFMAX3
#define FFMAX3(a, b, c)
Definition: macros.h:48
QSVEncContext::width_align
int width_align
Definition: qsvenc.h:165
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
AV_FRAME_DATA_REGIONS_OF_INTEREST
@ AV_FRAME_DATA_REGIONS_OF_INTEREST
Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of array element is ...
Definition: frame.h:165
imgutils.h
vp9_profiles
static const struct profile_names vp9_profiles[]
Definition: qsvenc.c:77
QSVEncContext::scenario
int scenario
Definition: qsvenc.h:227
hwcontext.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
QSV_MAX_ROI_NUM
#define QSV_MAX_ROI_NUM
Definition: qsv_internal.h:55
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
av_fifo_freep2
void av_fifo_freep2(AVFifo **f)
Free an AVFifo and reset pointer to NULL.
Definition: fifo.c:286
mpeg2_profiles
static const struct profile_names mpeg2_profiles[]
Definition: qsvenc.c:61
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ff_side_data_set_encoder_stats
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: packet.c:607
ff_encode_add_cpb_side_data
AVCPBProperties * ff_encode_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: encode.c:880
MFX_IMPL_VIA_MASK
#define MFX_IMPL_VIA_MASK(impl)
Definition: qsvenc.c:171
qsv_retrieve_enc_jpeg_params
static int qsv_retrieve_enc_jpeg_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1291
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:664
AVDictionaryEntry::value
char * value
Definition: dict.h:91
avc_profiles
static const struct profile_names avc_profiles[]
Definition: qsvenc.c:50
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
rc_mode
mfxU16 rc_mode
Definition: qsvenc.c:141
QSVEncContext::avctx
AVCodecContext * avctx
Definition: qsvenc.h:157
AV_PIX_FMT_VUYX
@ AV_PIX_FMT_VUYX
packed VUYX 4:4:4, 32bpp, Variant of VUYA where alpha channel is left undefined
Definition: pixfmt.h:406
QSVEncContext::old_i_quant_factor
float old_i_quant_factor
Definition: qsvenc.h:281
QSVFrame::next
struct QSVFrame * next
Definition: qsv_internal.h:102
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
ff_qsv_print_error
int ff_qsv_print_error(void *log_ctx, mfxStatus err, const char *error_string)
Definition: qsv.c:184
AVRegionOfInterest::qoffset
AVRational qoffset
Quantisation offset.
Definition: frame.h:342
ff_qsv_init_internal_session
int ff_qsv_init_internal_session(AVCodecContext *avctx, QSVSession *qs, const char *load_plugins, int gpu_copy)
Definition: qsv.c:676
QSVEncContext::tile_rows
int tile_rows
Definition: qsvenc.h:230
ff_qsv_encode
int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: qsvenc.c:2573
QSVEncContext::vp9_idx
int vp9_idx
Definition: qsvenc.h:271
AVCodecContext::sample_aspect_ratio
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:642
QSVEncContext::old_max_qp_b
int old_max_qp_b
Definition: qsvenc.h:301
AV_FIFO_FLAG_AUTO_GROW
#define AV_FIFO_FLAG_AUTO_GROW
Automatically resize the FIFO on writes, so that the data fits.
Definition: fifo.h:63
QSVEncContext::old_b_quant_offset
float old_b_quant_offset
Definition: qsvenc.h:284
hevc_profiles
static const struct profile_names hevc_profiles[]
Definition: qsvenc.c:67
qsvenc_fill_padding_area
static int qsvenc_fill_padding_area(AVFrame *frame, int new_w, int new_h)
Definition: qsvenc.c:1853
AVCodecContext::compression_level
int compression_level
Definition: avcodec.h:1245
qsvenc_init_session
static int qsvenc_init_session(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1585
QSVEncContext::old_int_ref_cycle_dist
int old_int_ref_cycle_dist
Definition: qsvenc.h:293
QSVEncContext::low_power
int low_power
Definition: qsvenc.h:253
av1_profiles
static const struct profile_names av1_profiles[]
Definition: qsvenc.c:84
QSVEncContext::old_max_qp_p
int old_max_qp_p
Definition: qsvenc.h:299
QSVPacket::bs
mfxBitstream * bs
Definition: qsvenc.c:95