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"
31 #include "libavutil/hwcontext_qsv.h"
32 #include "libavutil/mem.h"
33 #include "libavutil/log.h"
34 #include "libavutil/dict.h"
35 #include "libavutil/time.h"
36 #include "libavutil/imgutils.h"
37 
38 #include "avcodec.h"
39 #include "encode.h"
40 #include "qsv.h"
41 #include "qsv_internal.h"
42 #include "qsvenc.h"
43 #include "libavutil/refstruct.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 {
93  AVPacket pkt;
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:
105  profiles = avc_profiles;
106  num_profiles = FF_ARRAY_ELEMS(avc_profiles);
107  break;
108 
109  case AV_CODEC_ID_MPEG2VIDEO:
110  profiles = mpeg2_profiles;
111  num_profiles = FF_ARRAY_ELEMS(mpeg2_profiles);
112  break;
113 
114  case AV_CODEC_ID_HEVC:
115  profiles = hevc_profiles;
116  num_profiles = FF_ARRAY_ELEMS(hevc_profiles);
117  break;
118 
119  case AV_CODEC_ID_VP9:
120  profiles = vp9_profiles;
121  num_profiles = FF_ARRAY_ELEMS(vp9_profiles);
122  break;
123 
124  case AV_CODEC_ID_AV1:
125  profiles = av1_profiles;
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 
191 static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q,
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 
403 static void dump_video_vp9_param(AVCodecContext *avctx, QSVEncContext *q,
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 
474 static void dump_video_mjpeg_param(AVCodecContext *avctx, QSVEncContext *q)
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 
570 static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q)
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 
668 static int check_enc_param(AVCodecContext *avctx, QSVEncContext *q)
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(CodecLevel))
687  av_log(avctx, AV_LOG_ERROR, "Current codec level is unsupported\n");
688  if (UNMATCH(FrameInfo.FrameRateExtN) || UNMATCH(FrameInfo.FrameRateExtD))
689  av_log(avctx, AV_LOG_ERROR, "Current frame rate is unsupported\n");
690  if (UNMATCH(FrameInfo.PicStruct))
691  av_log(avctx, AV_LOG_ERROR, "Current picture structure is unsupported\n");
692  if (UNMATCH(FrameInfo.Width) || UNMATCH(FrameInfo.Height))
693  av_log(avctx, AV_LOG_ERROR, "Current resolution is unsupported\n");
694  if (UNMATCH(FrameInfo.FourCC))
695  av_log(avctx, AV_LOG_ERROR, "Current pixel format is unsupported\n");
696  return 0;
697  }
698  return 1;
699 }
700 
701 static int is_strict_gop(QSVEncContext *q) {
702  if (q->adaptive_b == 0 && q->adaptive_i == 0)
703  return 1;
704  return 0;
705 }
706 
707 static int init_video_param_jpeg(AVCodecContext *avctx, QSVEncContext *q)
708 {
709  enum AVPixelFormat sw_format = avctx->pix_fmt == AV_PIX_FMT_QSV ?
710  avctx->sw_pix_fmt : avctx->pix_fmt;
711  const AVPixFmtDescriptor *desc;
712  int ret;
713 
714  ret = ff_qsv_codec_id_to_mfx(avctx->codec_id);
715  if (ret < 0)
716  return AVERROR_BUG;
717  q->param.mfx.CodecId = ret;
718 
719  if (avctx->level > 0)
720  q->param.mfx.CodecLevel = avctx->level;
721  q->param.mfx.CodecProfile = q->profile;
722 
723  desc = av_pix_fmt_desc_get(sw_format);
724  if (!desc)
725  return AVERROR_BUG;
726 
727  ret = ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC, &q->param.mfx.FrameInfo.Shift);
728  if (ret < 0)
729  return AVERROR_BUG;
730 
731  q->param.mfx.FrameInfo.CropX = 0;
732  q->param.mfx.FrameInfo.CropY = 0;
733  q->param.mfx.FrameInfo.CropW = avctx->width;
734  q->param.mfx.FrameInfo.CropH = avctx->height;
735  q->param.mfx.FrameInfo.AspectRatioW = avctx->sample_aspect_ratio.num;
736  q->param.mfx.FrameInfo.AspectRatioH = avctx->sample_aspect_ratio.den;
737  q->param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420 +
738  !desc->log2_chroma_w + !desc->log2_chroma_h;
739  q->param.mfx.FrameInfo.BitDepthLuma = desc->comp[0].depth;
740  q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
741 
742  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, 16);
743  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, 16);
744 
745  if (avctx->hw_frames_ctx) {
746  AVHWFramesContext *frames_ctx = (AVHWFramesContext *)avctx->hw_frames_ctx->data;
747  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
748  mfxFrameInfo *info = frames_hwctx->nb_surfaces ? &frames_hwctx->surfaces[0].Info : frames_hwctx->info;
749  q->param.mfx.FrameInfo.Width = info->Width;
750  q->param.mfx.FrameInfo.Height = info->Height;
751  }
752 
753  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
754  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
755  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
756  } else {
757  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
758  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
759  }
760 
761  q->param.mfx.Interleaved = 1;
762  q->param.mfx.Quality = av_clip(avctx->global_quality, 1, 100);
763  q->param.mfx.RestartInterval = 0;
764 
765  q->width_align = 16;
766  q->height_align = 16;
767 
768  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, q->width_align);
769  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, q->height_align);
770 
771  return 0;
772 }
773 
774 static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
775 {
776  enum AVPixelFormat sw_format = avctx->pix_fmt == AV_PIX_FMT_QSV ?
777  avctx->sw_pix_fmt : avctx->pix_fmt;
778  const AVPixFmtDescriptor *desc;
779  float quant;
780  int target_bitrate_kbps, max_bitrate_kbps, brc_param_multiplier;
781  int buffer_size_in_kilobytes, initial_delay_in_kilobytes;
782  int ret;
783 
784  ret = ff_qsv_codec_id_to_mfx(avctx->codec_id);
785  if (ret < 0)
786  return AVERROR_BUG;
787  q->param.mfx.CodecId = ret;
788 
789  if (avctx->level > 0) {
790  q->param.mfx.CodecLevel = avctx->level;
791  if (avctx->codec_id == AV_CODEC_ID_HEVC && avctx->level >= MFX_LEVEL_HEVC_4)
792  q->param.mfx.CodecLevel |= q->tier;
793  }
794 
795  if (avctx->compression_level == FF_COMPRESSION_DEFAULT) {
796  avctx->compression_level = q->preset;
797  } else if (avctx->compression_level >= 0) {
798  if (avctx->compression_level > MFX_TARGETUSAGE_BEST_SPEED) {
799  av_log(avctx, AV_LOG_WARNING, "Invalid compression level: "
800  "valid range is 0-%d, using %d instead\n",
801  MFX_TARGETUSAGE_BEST_SPEED, MFX_TARGETUSAGE_BEST_SPEED);
802  avctx->compression_level = MFX_TARGETUSAGE_BEST_SPEED;
803  }
804  }
805 
806  if (q->low_power == 1) {
807  q->param.mfx.LowPower = MFX_CODINGOPTION_ON;
808  } else if (q->low_power == -1)
809  q->param.mfx.LowPower = MFX_CODINGOPTION_UNKNOWN;
810  else
811  q->param.mfx.LowPower = MFX_CODINGOPTION_OFF;
812 
813  q->param.mfx.CodecProfile = q->profile;
814  q->param.mfx.TargetUsage = avctx->compression_level;
815  q->param.mfx.GopPicSize = FFMAX(0, avctx->gop_size);
816  q->old_gop_size = avctx->gop_size;
817  q->param.mfx.GopRefDist = FFMAX(-1, avctx->max_b_frames) + 1;
818  q->param.mfx.GopOptFlag = avctx->flags & AV_CODEC_FLAG_CLOSED_GOP ?
819  MFX_GOP_CLOSED : is_strict_gop(q) ?
820  MFX_GOP_STRICT : 0;
821  q->param.mfx.IdrInterval = q->idr_interval;
822  q->param.mfx.NumSlice = avctx->slices;
823  q->param.mfx.NumRefFrame = FFMAX(0, avctx->refs);
824  q->param.mfx.EncodedOrder = 0;
825  q->param.mfx.BufferSizeInKB = 0;
826 
827  desc = av_pix_fmt_desc_get(sw_format);
828  if (!desc)
829  return AVERROR_BUG;
830 
831  ret = ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC, &q->param.mfx.FrameInfo.Shift);
832  if (ret < 0)
833  return AVERROR_BUG;
834 
835  q->param.mfx.FrameInfo.CropX = 0;
836  q->param.mfx.FrameInfo.CropY = 0;
837  q->param.mfx.FrameInfo.CropW = avctx->width;
838  q->param.mfx.FrameInfo.CropH = avctx->height;
839  q->param.mfx.FrameInfo.AspectRatioW = avctx->sample_aspect_ratio.num;
840  q->param.mfx.FrameInfo.AspectRatioH = avctx->sample_aspect_ratio.den;
841  q->param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420 +
842  !desc->log2_chroma_w + !desc->log2_chroma_h;
843  q->param.mfx.FrameInfo.BitDepthLuma = desc->comp[0].depth;
844  q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
845 
846  // If the minor version is greater than or equal to 19,
847  // then can use the same alignment settings as H.264 for HEVC
848  q->width_align = (avctx->codec_id != AV_CODEC_ID_HEVC ||
849  QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 19)) ? 16 : 32;
850  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, q->width_align);
851 
852  if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
853  // it is important that PicStruct be setup correctly from the
854  // start--otherwise, encoding doesn't work and results in a bunch
855  // of incompatible video parameter errors
856  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_FIELD_TFF;
857  // height alignment always must be 32 for interlaced video
858  q->height_align = 32;
859  } else {
860  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
861  // for progressive video, the height should be aligned to 16 for
862  // H.264. For HEVC, depending on the version of MFX, it should be
863  // either 32 or 16. The lower number is better if possible.
864  // For AV1, it is 32
865  q->height_align = (avctx->codec_id == AV_CODEC_ID_HEVC ||
866  avctx->codec_id == AV_CODEC_ID_AV1) ? 32 : 16;
867  }
868  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, q->height_align);
869 
870  if (avctx->hw_frames_ctx) {
871  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
872  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
873  mfxFrameInfo *info = frames_hwctx->nb_surfaces ? &frames_hwctx->surfaces[0].Info : frames_hwctx->info;
874  q->param.mfx.FrameInfo.Width = info->Width;
875  q->param.mfx.FrameInfo.Height = info->Height;
876  }
877 
878  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
879  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
880  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
881  } else {
882  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
883  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
884  }
885  q->old_framerate = avctx->framerate;
886 
887  ret = select_rc_mode(avctx, q);
888  if (ret < 0)
889  return ret;
890 
891  //libmfx BRC parameters are 16 bits thus maybe overflow, then BRCParamMultiplier is needed
892  buffer_size_in_kilobytes = avctx->rc_buffer_size / 8000;
893  initial_delay_in_kilobytes = avctx->rc_initial_buffer_occupancy / 8000;
894  target_bitrate_kbps = avctx->bit_rate / 1000;
895  max_bitrate_kbps = avctx->rc_max_rate / 1000;
896  brc_param_multiplier = (FFMAX(FFMAX3(target_bitrate_kbps, max_bitrate_kbps, buffer_size_in_kilobytes),
897  initial_delay_in_kilobytes) + 0x10000) / 0x10000;
898  q->old_rc_buffer_size = avctx->rc_buffer_size;
899  q->old_rc_initial_buffer_occupancy = avctx->rc_initial_buffer_occupancy;
900  q->old_bit_rate = avctx->bit_rate;
901  q->old_rc_max_rate = avctx->rc_max_rate;
902 
903  switch (q->param.mfx.RateControlMethod) {
904  case MFX_RATECONTROL_CBR:
905  case MFX_RATECONTROL_VBR:
906  if (q->extbrc) {
907  q->extco2.LookAheadDepth = q->look_ahead_depth;
908  }
909  av_fallthrough;
910 #if QSV_HAVE_VCM
911  case MFX_RATECONTROL_VCM:
912 #endif
913  case MFX_RATECONTROL_QVBR:
914  q->param.mfx.BufferSizeInKB = buffer_size_in_kilobytes / brc_param_multiplier;
915  q->param.mfx.InitialDelayInKB = initial_delay_in_kilobytes / brc_param_multiplier;
916  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
917  q->param.mfx.MaxKbps = max_bitrate_kbps / brc_param_multiplier;
918  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
919  if (q->param.mfx.RateControlMethod == MFX_RATECONTROL_QVBR)
920  q->extco3.QVBRQuality = av_clip(avctx->global_quality, 0, 51);
921  break;
922  case MFX_RATECONTROL_CQP:
923  quant = avctx->global_quality / FF_QP2LAMBDA;
924  if (avctx->codec_id == AV_CODEC_ID_AV1) {
925  q->param.mfx.QPI = av_clip_uintp2(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 8);
926  q->param.mfx.QPP = av_clip_uintp2(quant, 8);
927  q->param.mfx.QPB = av_clip_uintp2(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 8);
928  } else {
929  q->param.mfx.QPI = av_clip(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 0, 51);
930  q->param.mfx.QPP = av_clip(quant, 0, 51);
931  q->param.mfx.QPB = av_clip(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 0, 51);
932  }
933  q->old_global_quality = avctx->global_quality;
934  q->old_i_quant_factor = avctx->i_quant_factor;
935  q->old_i_quant_offset = avctx->i_quant_offset;
936  q->old_b_quant_factor = avctx->b_quant_factor;
937  q->old_b_quant_offset = avctx->b_quant_offset;
938 
939  break;
940 #if QSV_HAVE_AVBR
941  case MFX_RATECONTROL_AVBR:
942  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
943  q->param.mfx.Convergence = q->avbr_convergence;
944  q->param.mfx.Accuracy = q->avbr_accuracy;
945  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
946  break;
947 #endif
948  case MFX_RATECONTROL_LA:
949  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
950  q->extco2.LookAheadDepth = q->look_ahead_depth;
951  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
952  break;
953  case MFX_RATECONTROL_LA_ICQ:
954  q->extco2.LookAheadDepth = q->look_ahead_depth;
955  av_fallthrough;
956  case MFX_RATECONTROL_ICQ:
957  q->param.mfx.ICQQuality = av_clip(avctx->global_quality, 1, 51);
958  break;
959  }
960 
961  // The HEVC encoder plugin currently fails with some old libmfx version if coding options
962  // are provided. Can't find the extract libmfx version which fixed it, just enable it from
963  // V1.28 in order to keep compatibility security.
964  if (((avctx->codec_id != AV_CODEC_ID_HEVC) || QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 28))
965  && (avctx->codec_id != AV_CODEC_ID_VP9)) {
966  q->extco.Header.BufferId = MFX_EXTBUFF_CODING_OPTION;
967  q->extco.Header.BufferSz = sizeof(q->extco);
968 
969  q->extco.PicTimingSEI = q->pic_timing_sei ?
970  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;
971  q->old_pic_timing_sei = q->pic_timing_sei;
972 
973  if (q->rdo >= 0)
974  q->extco.RateDistortionOpt = q->rdo > 0 ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
975 
976  if (avctx->codec_id == AV_CODEC_ID_H264) {
977  q->extco.CAVLC = q->cavlc ? MFX_CODINGOPTION_ON
978  : MFX_CODINGOPTION_UNKNOWN;
979 
980  if (avctx->strict_std_compliance != FF_COMPLIANCE_NORMAL)
981  q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?
982  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
983 
984  if (q->single_sei_nal_unit >= 0)
985  q->extco.SingleSeiNalUnit = q->single_sei_nal_unit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
986  if (q->recovery_point_sei >= 0)
987  q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
988  q->extco.MaxDecFrameBuffering = q->max_dec_frame_buffering;
989  q->extco.AUDelimiter = q->aud ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
990  } else if (avctx->codec_id == AV_CODEC_ID_HEVC) {
991  if (avctx->strict_std_compliance != FF_COMPLIANCE_NORMAL)
992  q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?
993  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
994 
995  if (q->recovery_point_sei >= 0)
996  q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
997 
998  q->extco.AUDelimiter = q->aud ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
999  }
1000 
1001  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco;
1002 
1003  if (avctx->codec_id == AV_CODEC_ID_H264) {
1004  if (q->bitrate_limit >= 0)
1005  q->extco2.BitrateLimit = q->bitrate_limit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1006 
1007  if (avctx->trellis >= 0)
1008  q->extco2.Trellis = (avctx->trellis == 0) ? MFX_TRELLIS_OFF : (MFX_TRELLIS_I | MFX_TRELLIS_P | MFX_TRELLIS_B);
1009  else
1010  q->extco2.Trellis = MFX_TRELLIS_UNKNOWN;
1011 
1012  q->extco2.LookAheadDS = q->look_ahead_downsampling;
1013  q->extco2.RepeatPPS = q->repeat_pps ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1014  }
1015 
1016  if (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_HEVC) {
1017  if (q->extbrc >= 0)
1018  q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1019  if (q->max_frame_size >= 0)
1020  q->extco2.MaxFrameSize = q->max_frame_size;
1021  q->old_max_frame_size = q->max_frame_size;
1022  if (q->int_ref_type >= 0)
1023  q->extco2.IntRefType = q->int_ref_type;
1024  q->old_int_ref_type = q->int_ref_type;
1025  if (q->int_ref_cycle_size >= 0)
1026  q->extco2.IntRefCycleSize = q->int_ref_cycle_size;
1027  q->old_int_ref_cycle_size = q->int_ref_cycle_size;
1028  if (q->int_ref_qp_delta != INT16_MIN)
1029  q->extco2.IntRefQPDelta = q->int_ref_qp_delta;
1030  q->old_int_ref_qp_delta = q->int_ref_qp_delta;
1031  if (q->max_slice_size >= 0)
1032  q->extco2.MaxSliceSize = q->max_slice_size;
1033  q->extco2.DisableDeblockingIdc = q->dblk_idc;
1034 
1035  if (q->b_strategy >= 0)
1036  q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
1037  if (q->adaptive_i >= 0)
1038  q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1039  if (q->adaptive_b >= 0)
1040  q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1041  if ((avctx->qmin >= 0 && avctx->qmax >= 0 && avctx->qmin > avctx->qmax) ||
1042  (q->max_qp_i >= 0 && q->min_qp_i >= 0 && q->min_qp_i > q->max_qp_i) ||
1043  (q->max_qp_p >= 0 && q->min_qp_p >= 0 && q->min_qp_p > q->max_qp_p) ||
1044  (q->max_qp_b >= 0 && q->min_qp_b >= 0 && q->min_qp_b > q->max_qp_b)) {
1045  av_log(avctx, AV_LOG_ERROR,
1046  "qmin and or qmax are set but invalid,"
1047  " please make sure min <= max\n");
1048  return AVERROR(EINVAL);
1049  }
1050  if (avctx->qmin >= 0) {
1051  q->extco2.MinQPI = avctx->qmin > 51 ? 51 : avctx->qmin;
1052  q->extco2.MinQPP = q->extco2.MinQPB = q->extco2.MinQPI;
1053  }
1054  q->old_qmin = avctx->qmin;
1055  if (avctx->qmax >= 0) {
1056  q->extco2.MaxQPI = avctx->qmax > 51 ? 51 : avctx->qmax;
1057  q->extco2.MaxQPP = q->extco2.MaxQPB = q->extco2.MaxQPI;
1058  }
1059  q->old_qmax = avctx->qmax;
1060  if (q->min_qp_i >= 0)
1061  q->extco2.MinQPI = q->min_qp_i > 51 ? 51 : q->min_qp_i;
1062  q->old_min_qp_i = q->min_qp_i;
1063  if (q->max_qp_i >= 0)
1064  q->extco2.MaxQPI = q->max_qp_i > 51 ? 51 : q->max_qp_i;
1065  q->old_max_qp_i = q->max_qp_i;
1066  if (q->min_qp_p >= 0)
1067  q->extco2.MinQPP = q->min_qp_p > 51 ? 51 : q->min_qp_p;
1068  q->old_min_qp_p = q->min_qp_p;
1069  if (q->max_qp_p >= 0)
1070  q->extco2.MaxQPP = q->max_qp_p > 51 ? 51 : q->max_qp_p;
1071  q->old_max_qp_p = q->max_qp_p;
1072  if (q->min_qp_b >= 0)
1073  q->extco2.MinQPB = q->min_qp_b > 51 ? 51 : q->min_qp_b;
1074  q->old_min_qp_b = q->min_qp_b;
1075  if (q->max_qp_b >= 0)
1076  q->extco2.MaxQPB = q->max_qp_b > 51 ? 51 : q->max_qp_b;
1077  q->old_max_qp_b = q->max_qp_b;
1078  if (q->mbbrc >= 0)
1079  q->extco2.MBBRC = q->mbbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1080  if (q->skip_frame >= 0)
1081  q->extco2.SkipFrame = q->skip_frame;
1082 
1083  q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
1084  q->extco2.Header.BufferSz = sizeof(q->extco2);
1085 
1086  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
1087  } else if (avctx->codec_id == AV_CODEC_ID_AV1) {
1088  if (q->extbrc >= 0)
1089  q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1090  if (q->b_strategy >= 0)
1091  q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
1092  if (q->adaptive_i >= 0)
1093  q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1094  if (q->adaptive_b >= 0)
1095  q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1096  if (q->max_frame_size >= 0)
1097  q->extco2.MaxFrameSize = q->max_frame_size;
1098 
1099  q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
1100  q->extco2.Header.BufferSz = sizeof(q->extco2);
1101 
1102  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
1103  }
1104 
1105  if (avctx->codec_id == AV_CODEC_ID_H264) {
1106 #if QSV_HAVE_MF
1107  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 25)) {
1108  q->extmfp.Header.BufferId = MFX_EXTBUFF_MULTI_FRAME_PARAM;
1109  q->extmfp.Header.BufferSz = sizeof(q->extmfp);
1110 
1111  q->extmfp.MFMode = q->mfmode;
1112  av_log(avctx,AV_LOG_VERBOSE,"MFMode:%d\n", q->extmfp.MFMode);
1113  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extmfp;
1114  }
1115 #endif
1116  }
1117  q->extco3.Header.BufferId = MFX_EXTBUFF_CODING_OPTION3;
1118  q->extco3.Header.BufferSz = sizeof(q->extco3);
1119 
1120  if (avctx->codec_id == AV_CODEC_ID_HEVC ||
1121  avctx->codec_id == AV_CODEC_ID_H264) {
1122  switch (q->p_strategy) {
1123  case 0:
1124  q->extco3.PRefType = MFX_P_REF_DEFAULT;
1125  break;
1126  case 1:
1127  q->extco3.PRefType = MFX_P_REF_SIMPLE;
1128  break;
1129  case 2:
1130  q->extco3.PRefType = MFX_P_REF_PYRAMID;
1131  break;
1132  default:
1133  q->extco3.PRefType = MFX_P_REF_DEFAULT;
1134  av_log(avctx, AV_LOG_WARNING,
1135  "invalid p_strategy, set to default\n");
1136  break;
1137  }
1138  if (q->extco3.PRefType == MFX_P_REF_PYRAMID &&
1139  avctx->max_b_frames != 0) {
1140  av_log(avctx, AV_LOG_WARNING,
1141  "Please set max_b_frames(-bf) to 0 to enable P-pyramid\n");
1142  }
1143  if (q->int_ref_cycle_dist >= 0)
1144  q->extco3.IntRefCycleDist = q->int_ref_cycle_dist;
1145  q->old_int_ref_cycle_dist = q->int_ref_cycle_dist;
1146  if (q->low_delay_brc >= 0)
1147  q->extco3.LowDelayBRC = q->low_delay_brc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1148  q->old_low_delay_brc = q->low_delay_brc;
1149  if (q->max_frame_size_i >= 0)
1150  q->extco3.MaxFrameSizeI = q->max_frame_size_i;
1151  if (q->max_frame_size_p >= 0)
1152  q->extco3.MaxFrameSizeP = q->max_frame_size_p;
1153  if (sw_format == AV_PIX_FMT_BGRA &&
1154  (q->profile == MFX_PROFILE_HEVC_REXT ||
1155  q->profile == MFX_PROFILE_UNKNOWN))
1156  q->extco3.TargetChromaFormatPlus1 = MFX_CHROMAFORMAT_YUV444 + 1;
1157 
1158  q->extco3.ScenarioInfo = q->scenario;
1159  } else if (avctx->codec_id == AV_CODEC_ID_AV1) {
1160  if (q->low_delay_brc >= 0)
1161  q->extco3.LowDelayBRC = q->low_delay_brc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1162  q->old_low_delay_brc = q->low_delay_brc;
1163  }
1164 
1165  if (avctx->codec_id == AV_CODEC_ID_HEVC) {
1166  if (q->transform_skip >= 0)
1167  q->extco3.TransformSkip = q->transform_skip ? MFX_CODINGOPTION_ON :
1168  MFX_CODINGOPTION_OFF;
1169  else
1170  q->extco3.TransformSkip = MFX_CODINGOPTION_UNKNOWN;
1171  q->extco3.GPB = q->gpb ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1172  }
1173  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco3;
1174  }
1175 
1176  if (avctx->codec_id == AV_CODEC_ID_VP9) {
1177  q->extvp9param.Header.BufferId = MFX_EXTBUFF_VP9_PARAM;
1178  q->extvp9param.Header.BufferSz = sizeof(q->extvp9param);
1179  q->extvp9param.WriteIVFHeaders = MFX_CODINGOPTION_OFF;
1180 #if QSV_HAVE_EXT_VP9_TILES
1181  q->extvp9param.NumTileColumns = q->tile_cols;
1182  q->extvp9param.NumTileRows = q->tile_rows;
1183 #endif
1184  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extvp9param;
1185  }
1186 
1187 #if QSV_HAVE_EXT_AV1_PARAM
1188  if (avctx->codec_id == AV_CODEC_ID_AV1) {
1189  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 2, 5)) {
1190  q->extav1tileparam.Header.BufferId = MFX_EXTBUFF_AV1_TILE_PARAM;
1191  q->extav1tileparam.Header.BufferSz = sizeof(q->extav1tileparam);
1192  q->extav1tileparam.NumTileColumns = q->tile_cols;
1193  q->extav1tileparam.NumTileRows = q->tile_rows;
1194  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extav1tileparam;
1195 
1196  q->extav1bsparam.Header.BufferId = MFX_EXTBUFF_AV1_BITSTREAM_PARAM;
1197  q->extav1bsparam.Header.BufferSz = sizeof(q->extav1bsparam);
1198  q->extav1bsparam.WriteIVFHeaders = MFX_CODINGOPTION_OFF;
1199  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extav1bsparam;
1200  } else {
1201  av_log(avctx, AV_LOG_ERROR,
1202  "This version of runtime doesn't support AV1 encoding\n");
1203  return AVERROR_UNKNOWN;
1204  }
1205  }
1206 #endif
1207 
1208  if (avctx->codec_id == AV_CODEC_ID_HEVC) {
1209  q->exthevctiles.Header.BufferId = MFX_EXTBUFF_HEVC_TILES;
1210  q->exthevctiles.Header.BufferSz = sizeof(q->exthevctiles);
1211  q->exthevctiles.NumTileColumns = q->tile_cols;
1212  q->exthevctiles.NumTileRows = q->tile_rows;
1213  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->exthevctiles;
1214  }
1215 
1216  q->extvsi.VideoFullRange = (avctx->color_range == AVCOL_RANGE_JPEG);
1217  q->extvsi.ColourDescriptionPresent = 0;
1218 
1219  if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
1220  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
1221  avctx->colorspace != AVCOL_SPC_UNSPECIFIED) {
1222  q->extvsi.ColourDescriptionPresent = 1;
1223  q->extvsi.ColourPrimaries = avctx->color_primaries;
1224  q->extvsi.TransferCharacteristics = avctx->color_trc;
1225  if (avctx->colorspace == AVCOL_SPC_RGB)
1226  // RGB will be converted to YUV, so RGB colorspace is not supported
1227  q->extvsi.MatrixCoefficients = AVCOL_SPC_UNSPECIFIED;
1228  else
1229  q->extvsi.MatrixCoefficients = avctx->colorspace;
1230 
1231  }
1232 
1233  if ((avctx->codec_id != AV_CODEC_ID_VP9) && (q->extvsi.VideoFullRange || q->extvsi.ColourDescriptionPresent)) {
1234  q->extvsi.Header.BufferId = MFX_EXTBUFF_VIDEO_SIGNAL_INFO;
1235  q->extvsi.Header.BufferSz = sizeof(q->extvsi);
1236  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extvsi;
1237  }
1238 
1239 #if QSV_HAVE_HE
1240  if (q->dual_gfx) {
1241  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 2, 4)) {
1242  mfxIMPL impl;
1243  MFXQueryIMPL(q->session, &impl);
1244 
1245  if (MFX_IMPL_VIA_MASK(impl) != MFX_IMPL_VIA_D3D11) {
1246  av_log(avctx, AV_LOG_ERROR, "Dual GFX mode requires D3D11VA \n");
1247  return AVERROR_UNKNOWN;
1248  }
1249  if (q->param.mfx.LowPower != MFX_CODINGOPTION_ON) {
1250  av_log(avctx, AV_LOG_ERROR, "Dual GFX mode supports only low-power encoding mode \n");
1251  return AVERROR_UNKNOWN;
1252  }
1253  if (q->param.mfx.CodecId != MFX_CODEC_AVC && q->param.mfx.CodecId != MFX_CODEC_HEVC) {
1254  av_log(avctx, AV_LOG_ERROR, "Not supported encoder for dual GFX mode. "
1255  "Supported: h264_qsv and hevc_qsv \n");
1256  return AVERROR_UNKNOWN;
1257  }
1258  if (q->param.mfx.RateControlMethod != MFX_RATECONTROL_VBR &&
1259  q->param.mfx.RateControlMethod != MFX_RATECONTROL_CQP &&
1260  q->param.mfx.RateControlMethod != MFX_RATECONTROL_ICQ) {
1261  av_log(avctx, AV_LOG_WARNING, "Not supported BRC for dual GFX mode. "
1262  "Supported: VBR, CQP and ICQ \n");
1263  }
1264  if ((q->param.mfx.CodecId == MFX_CODEC_AVC && q->param.mfx.IdrInterval != 0) ||
1265  (q->param.mfx.CodecId == MFX_CODEC_HEVC && q->param.mfx.IdrInterval != 1)) {
1266  av_log(avctx, AV_LOG_WARNING, "Dual GFX mode requires closed GOP for AVC and strict GOP for HEVC, -idr_interval 0 \n");
1267  }
1268  if (q->param.mfx.GopPicSize < 30) {
1269  av_log(avctx, AV_LOG_WARNING, "For better performance in dual GFX mode GopPicSize must be >= 30 \n");
1270  }
1271  if (q->param.AsyncDepth < 30) {
1272  av_log(avctx, AV_LOG_WARNING, "For better performance in dual GFX mode AsyncDepth must be >= 30 \n");
1273  }
1274 
1275  q->exthypermodeparam.Header.BufferId = MFX_EXTBUFF_HYPER_MODE_PARAM;
1276  q->exthypermodeparam.Header.BufferSz = sizeof(q->exthypermodeparam);
1277  q->exthypermodeparam.Mode = q->dual_gfx;
1278  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->exthypermodeparam;
1279  } else {
1280  av_log(avctx, AV_LOG_ERROR,
1281  "This version of runtime doesn't support Hyper Encode\n");
1282  return AVERROR_UNKNOWN;
1283  }
1284  }
1285 #endif
1286 
1287  if (!check_enc_param(avctx,q)) {
1288  av_log(avctx, AV_LOG_ERROR,
1289  "some encoding parameters are not supported by the QSV "
1290  "runtime. Please double check the input parameters.\n");
1291  return AVERROR(ENOSYS);
1292  }
1293 
1294  return 0;
1295 }
1296 
1297 static int qsv_retrieve_enc_jpeg_params(AVCodecContext *avctx, QSVEncContext *q)
1298 {
1299  int ret = 0;
1300 
1301  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
1302  if (ret < 0)
1303  return ff_qsv_print_error(avctx, ret,
1304  "Error calling GetVideoParam");
1305 
1306  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
1307 
1308  // for qsv mjpeg the return value maybe 0 so alloc the buffer
1309  if (q->packet_size == 0)
1310  q->packet_size = q->param.mfx.FrameInfo.Height * q->param.mfx.FrameInfo.Width * 4;
1311 
1312  dump_video_mjpeg_param(avctx, q);
1313 
1314  return 0;
1315 }
1316 
1317 static int qsv_retrieve_enc_vp9_params(AVCodecContext *avctx, QSVEncContext *q)
1318 {
1319  int ret = 0;
1320  mfxExtVP9Param vp9_extend_buf = {
1321  .Header.BufferId = MFX_EXTBUFF_VP9_PARAM,
1322  .Header.BufferSz = sizeof(vp9_extend_buf),
1323  };
1324 
1325  mfxExtCodingOption2 co2 = {
1326  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
1327  .Header.BufferSz = sizeof(co2),
1328  };
1329 
1330  mfxExtCodingOption3 co3 = {
1331  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
1332  .Header.BufferSz = sizeof(co3),
1333  };
1334 
1335  mfxExtBuffer *ext_buffers[3];
1336  int ext_buf_num = 0;
1337 
1338  q->co2_idx = q->co3_idx = q->vp9_idx = -1;
1339 
1340  // It is possible the runtime doesn't support the given ext buffer
1341  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 6)) {
1342  q->co2_idx = ext_buf_num;
1343  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;
1344  }
1345 
1346  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 11)) {
1347  q->co3_idx = ext_buf_num;
1348  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;
1349  }
1350 
1351  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 26)) {
1352  q->vp9_idx = ext_buf_num;
1353  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&vp9_extend_buf;
1354  }
1355 
1356  q->param.ExtParam = ext_buffers;
1357  q->param.NumExtParam = ext_buf_num;
1358 
1359  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
1360  if (ret < 0)
1361  return ff_qsv_print_error(avctx, ret,
1362  "Error calling GetVideoParam");
1363 
1364  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
1365 
1366  dump_video_vp9_param(avctx, q, ext_buffers);
1367 
1368  return 0;
1369 }
1370 
1371 static int qsv_retrieve_enc_av1_params(AVCodecContext *avctx, QSVEncContext *q)
1372 {
1373 #if QSV_HAVE_EXT_AV1_PARAM
1374  int ret = 0;
1375  mfxExtAV1TileParam av1_extend_tile_buf = {
1376  .Header.BufferId = MFX_EXTBUFF_AV1_TILE_PARAM,
1377  .Header.BufferSz = sizeof(av1_extend_tile_buf),
1378  };
1379  mfxExtAV1BitstreamParam av1_bs_param = {
1380  .Header.BufferId = MFX_EXTBUFF_AV1_BITSTREAM_PARAM,
1381  .Header.BufferSz = sizeof(av1_bs_param),
1382  };
1383 
1384  mfxExtCodingOption2 co2 = {
1385  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
1386  .Header.BufferSz = sizeof(co2),
1387  };
1388 
1389  mfxExtCodingOption3 co3 = {
1390  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
1391  .Header.BufferSz = sizeof(co3),
1392  };
1393 
1394  mfxExtBuffer *ext_buffers[] = {
1395  (mfxExtBuffer*)&av1_extend_tile_buf,
1396  (mfxExtBuffer*)&av1_bs_param,
1397  (mfxExtBuffer*)&co2,
1398  (mfxExtBuffer*)&co3,
1399  };
1400 
1401  if (!QSV_RUNTIME_VERSION_ATLEAST(q->ver, 2, 5)) {
1402  av_log(avctx, AV_LOG_ERROR,
1403  "This version of runtime doesn't support AV1 encoding\n");
1404  return AVERROR_UNKNOWN;
1405  }
1406 
1407  q->param.ExtParam = ext_buffers;
1408  q->param.NumExtParam = FF_ARRAY_ELEMS(ext_buffers);
1409 
1410  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
1411  if (ret < 0)
1412  return ff_qsv_print_error(avctx, ret,
1413  "Error calling GetVideoParam");
1414 
1415  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
1416  dump_video_av1_param(avctx, q, ext_buffers);
1417 #endif
1418  return 0;
1419 }
1420 
1421 static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
1422 {
1423  AVCPBProperties *cpb_props;
1424 
1425  uint8_t sps_buf[512];
1426  uint8_t pps_buf[128];
1427 
1428  mfxExtCodingOptionSPSPPS extradata = {
1429  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
1430  .Header.BufferSz = sizeof(extradata),
1431  .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),
1432  .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
1433  };
1434 
1435  mfxExtCodingOption co = {
1436  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
1437  .Header.BufferSz = sizeof(co),
1438  };
1439  mfxExtCodingOption2 co2 = {
1440  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
1441  .Header.BufferSz = sizeof(co2),
1442  };
1443  mfxExtCodingOption3 co3 = {
1444  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
1445  .Header.BufferSz = sizeof(co3),
1446  };
1447 
1448  uint8_t vps_buf[128];
1449  mfxExtCodingOptionVPS extradata_vps = {
1450  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_VPS,
1451  .Header.BufferSz = sizeof(extradata_vps),
1452  .VPSBuffer = vps_buf,
1453  .VPSBufSize = sizeof(vps_buf),
1454  };
1455 
1456  mfxExtHEVCTiles hevc_tile_buf = {
1457  .Header.BufferId = MFX_EXTBUFF_HEVC_TILES,
1458  .Header.BufferSz = sizeof(hevc_tile_buf),
1459  };
1460 
1461 #if QSV_HAVE_HE
1462  mfxExtHyperModeParam hyper_mode_param_buf = {
1463  .Header.BufferId = MFX_EXTBUFF_HYPER_MODE_PARAM,
1464  .Header.BufferSz = sizeof(hyper_mode_param_buf),
1465  };
1466 #endif
1467 
1468  mfxExtBuffer *ext_buffers[6 + QSV_HAVE_HE];
1469 
1470  int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
1471  int ret, ext_buf_num = 0, extradata_offset = 0;
1472 
1473  q->co2_idx = q->co3_idx = q->exthevctiles_idx = q->exthypermodeparam_idx = -1;
1474  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata;
1475  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co;
1476 
1477  // It is possible the runtime doesn't support the given ext buffer
1478  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 6)) {
1479  q->co2_idx = ext_buf_num;
1480  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;
1481  }
1482 
1483  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 11)) {
1484  q->co3_idx = ext_buf_num;
1485  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;
1486  }
1487 
1488  q->hevc_vps = ((avctx->codec_id == AV_CODEC_ID_HEVC) && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 17));
1489  if (q->hevc_vps)
1490  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata_vps;
1491  if (avctx->codec_id == AV_CODEC_ID_HEVC && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 13)) {
1492  q->exthevctiles_idx = ext_buf_num;
1493  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&hevc_tile_buf;
1494  }
1495 #if QSV_HAVE_HE
1496  if (q->dual_gfx && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 2, 4)) {
1497  q->exthypermodeparam_idx = ext_buf_num;
1498  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&hyper_mode_param_buf;
1499  }
1500 #endif
1501 
1502  q->param.ExtParam = ext_buffers;
1503  q->param.NumExtParam = ext_buf_num;
1504 
1505  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
1506  if (ret < 0)
1507  return ff_qsv_print_error(avctx, ret,
1508  "Error calling GetVideoParam");
1509 
1510  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
1511 
1512  if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)
1513  || (q->hevc_vps && !extradata_vps.VPSBufSize)
1514  ) {
1515  av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
1516  return AVERROR_UNKNOWN;
1517  }
1518 
1519  avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
1520  avctx->extradata_size += q->hevc_vps * extradata_vps.VPSBufSize;
1521 
1522  avctx->extradata = av_malloc(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
1523  if (!avctx->extradata)
1524  return AVERROR(ENOMEM);
1525 
1526  if (q->hevc_vps) {
1527  memcpy(avctx->extradata, vps_buf, extradata_vps.VPSBufSize);
1528  extradata_offset += extradata_vps.VPSBufSize;
1529  }
1530 
1531  memcpy(avctx->extradata + extradata_offset, sps_buf, extradata.SPSBufSize);
1532  extradata_offset += extradata.SPSBufSize;
1533  if (need_pps) {
1534  memcpy(avctx->extradata + extradata_offset, pps_buf, extradata.PPSBufSize);
1535  extradata_offset += extradata.PPSBufSize;
1536  }
1537  memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1538 
1539  cpb_props = ff_encode_add_cpb_side_data(avctx);
1540  if (!cpb_props)
1541  return AVERROR(ENOMEM);
1542  cpb_props->max_bitrate = avctx->rc_max_rate;
1543  cpb_props->min_bitrate = avctx->rc_min_rate;
1544  cpb_props->avg_bitrate = avctx->bit_rate;
1545  cpb_props->buffer_size = avctx->rc_buffer_size;
1546 
1547  dump_video_param(avctx, q, ext_buffers);
1548 
1549  return 0;
1550 }
1551 
1552 #if QSV_HAVE_OPAQUE
1553 static int qsv_init_opaque_alloc(AVCodecContext *avctx, QSVEncContext *q)
1554 {
1555  AVQSVContext *qsv = avctx->hwaccel_context;
1556  mfxFrameSurface1 *surfaces;
1557  int nb_surfaces, i;
1558 
1559  nb_surfaces = qsv->nb_opaque_surfaces + q->req.NumFrameSuggested;
1560 
1561  q->opaque_alloc_buf = av_buffer_allocz(sizeof(*surfaces) * nb_surfaces);
1562  if (!q->opaque_alloc_buf)
1563  return AVERROR(ENOMEM);
1564 
1565  q->opaque_surfaces = av_malloc_array(nb_surfaces, sizeof(*q->opaque_surfaces));
1566  if (!q->opaque_surfaces)
1567  return AVERROR(ENOMEM);
1568 
1569  surfaces = (mfxFrameSurface1*)q->opaque_alloc_buf->data;
1570  for (i = 0; i < nb_surfaces; i++) {
1571  surfaces[i].Info = q->req.Info;
1572  q->opaque_surfaces[i] = surfaces + i;
1573  }
1574 
1575  q->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
1576  q->opaque_alloc.Header.BufferSz = sizeof(q->opaque_alloc);
1577  q->opaque_alloc.In.Surfaces = q->opaque_surfaces;
1578  q->opaque_alloc.In.NumSurface = nb_surfaces;
1579  q->opaque_alloc.In.Type = q->req.Type;
1580 
1581  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->opaque_alloc;
1582 
1583  qsv->nb_opaque_surfaces = nb_surfaces;
1584  qsv->opaque_surfaces = q->opaque_alloc_buf;
1585  qsv->opaque_alloc_type = q->req.Type;
1586 
1587  return 0;
1588 }
1589 #endif
1590 
1591 static int qsvenc_init_session(AVCodecContext *avctx, QSVEncContext *q)
1592 {
1593  int ret;
1594 
1595  if (avctx->hwaccel_context) {
1596  AVQSVContext *qsv = avctx->hwaccel_context;
1597  q->session = qsv->session;
1598  } else if (avctx->hw_frames_ctx) {
1599  q->frames_ctx.hw_frames_ctx = av_buffer_ref(avctx->hw_frames_ctx);
1600  if (!q->frames_ctx.hw_frames_ctx)
1601  return AVERROR(ENOMEM);
1602 
1603  ret = ff_qsv_init_session_frames(avctx, &q->internal_qs.session,
1604  &q->frames_ctx, q->load_plugins,
1605 #if QSV_HAVE_OPAQUE
1606  q->param.IOPattern == MFX_IOPATTERN_IN_OPAQUE_MEMORY,
1607 #else
1608  0,
1609 #endif
1610  MFX_GPUCOPY_OFF);
1611  if (ret < 0) {
1612  av_buffer_unref(&q->frames_ctx.hw_frames_ctx);
1613  return ret;
1614  }
1615 
1616  q->session = q->internal_qs.session;
1617  } else if (avctx->hw_device_ctx) {
1618  ret = ff_qsv_init_session_device(avctx, &q->internal_qs.session,
1619  avctx->hw_device_ctx, q->load_plugins,
1620  MFX_GPUCOPY_OFF);
1621  if (ret < 0)
1622  return ret;
1623 
1624  q->session = q->internal_qs.session;
1625  } else {
1626  ret = ff_qsv_init_internal_session(avctx, &q->internal_qs,
1627  q->load_plugins, MFX_GPUCOPY_OFF);
1628  if (ret < 0)
1629  return ret;
1630 
1631  q->session = q->internal_qs.session;
1632  }
1633 
1634  return 0;
1635 }
1636 
1637 int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
1638 {
1639  int iopattern = 0;
1640  int opaque_alloc = 0;
1641  int ret;
1642  void *tmp;
1643 #if HAVE_STRUCT_MFXCONFIGINTERFACE
1644  mfxExtBuffer ext_buf;
1645  mfxConfigInterface *iface = NULL;
1646  const AVDictionaryEntry *param = NULL;
1647 #endif
1648 
1649  q->param.AsyncDepth = q->async_depth;
1650 
1651  q->async_fifo = av_fifo_alloc2(q->async_depth, sizeof(QSVPacket), AV_FIFO_FLAG_AUTO_GROW);
1652  if (!q->async_fifo)
1653  return AVERROR(ENOMEM);
1654 
1655  if (avctx->hwaccel_context) {
1656  AVQSVContext *qsv = avctx->hwaccel_context;
1657 
1658  iopattern = qsv->iopattern;
1659  opaque_alloc = qsv->opaque_alloc;
1660  }
1661 
1662  if (avctx->hw_frames_ctx) {
1663  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1664  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
1665 
1666  if (!iopattern) {
1667 #if QSV_HAVE_OPAQUE
1668  if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)
1669  iopattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
1670  else if (frames_hwctx->frame_type &
1671  (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
1672  iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
1673 #else
1674  if (frames_hwctx->frame_type &
1675  (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
1676  iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
1677 #endif
1678  }
1679  }
1680 
1681  if (!iopattern)
1682  iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
1683  q->param.IOPattern = iopattern;
1684  ff_qsv_print_iopattern(avctx, iopattern, "Encoder");
1685 
1686  ret = qsvenc_init_session(avctx, q);
1687  if (ret < 0)
1688  return ret;
1689 
1690  ret = MFXQueryVersion(q->session,&q->ver);
1691  if (ret < 0) {
1692  return ff_qsv_print_error(avctx, ret,
1693  "Error querying mfx version");
1694  }
1695 
1696  // in the mfxInfoMFX struct, JPEG is different from other codecs
1697  switch (avctx->codec_id) {
1698  case AV_CODEC_ID_MJPEG:
1699  ret = init_video_param_jpeg(avctx, q);
1700  break;
1701  default:
1702  ret = init_video_param(avctx, q);
1703  break;
1704  }
1705  if (ret < 0)
1706  return ret;
1707 
1708  tmp = av_realloc_array(q->extparam, q->nb_extparam_internal, sizeof(*q->extparam));
1709  if (!tmp)
1710  return AVERROR(ENOMEM);
1711 
1712  q->extparam = tmp;
1713  q->nb_extparam = q->nb_extparam_internal;
1714  memcpy(q->extparam, q->extparam_internal, q->nb_extparam * sizeof(*q->extparam));
1715 
1716  if (avctx->hwaccel_context) {
1717  AVQSVContext *qsv = avctx->hwaccel_context;
1718  int i, j;
1719 
1720  for (i = 0; i < qsv->nb_ext_buffers; i++) {
1721  for (j = 0; j < q->nb_extparam_internal; j++) {
1722  if (qsv->ext_buffers[i]->BufferId == q->extparam_internal[j]->BufferId) {
1723  q->extparam[j] = qsv->ext_buffers[i];
1724  break;
1725  }
1726  }
1727 
1728  if (j == q->nb_extparam_internal) {
1729  tmp = av_realloc_array(q->extparam, q->nb_extparam + 1, sizeof(*q->extparam));
1730  if (!tmp)
1731  return AVERROR(ENOMEM);
1732 
1733  q->extparam = tmp;
1734  q->extparam[q->nb_extparam++] = qsv->ext_buffers[i];
1735  }
1736  }
1737  }
1738 
1739  q->param.ExtParam = q->extparam;
1740  q->param.NumExtParam = q->nb_extparam;
1741 
1742 #if HAVE_STRUCT_MFXCONFIGINTERFACE
1743  ret = MFXVideoCORE_GetHandle(q->session, MFX_HANDLE_CONFIG_INTERFACE, (mfxHDL *)(&iface));
1744  if (ret < 0)
1745  return ff_qsv_print_error(avctx, ret,
1746  "Error getting mfx config interface handle");
1747 
1748  while ((param = av_dict_get(q->qsv_params, "", param, AV_DICT_IGNORE_SUFFIX))) {
1749  const char *param_key = param->key;
1750  const char *param_value = param->value;
1751  mfxExtBuffer *new_ext_buf;
1752  void *tmp;
1753 
1754  av_log(avctx, AV_LOG_VERBOSE, "Parameter key: %s, value: %s\n", param_key, param_value);
1755 
1756  // Set encoding parameters using MFXSetParameter
1757  for (int i = 0; i < 2; i++) {
1758  ret = iface->SetParameter(iface, (mfxU8*)param_key, (mfxU8*)param_value, MFX_STRUCTURE_TYPE_VIDEO_PARAM, &q->param, &ext_buf);
1759  if (ret == MFX_ERR_NONE) {
1760  break;
1761  } else if (i == 0 && ret == MFX_ERR_MORE_EXTBUFFER) {
1762  tmp = av_realloc_array(q->extparam_str, q->nb_extparam_str + 1, sizeof(*q->extparam_str));
1763  if (!tmp)
1764  return AVERROR(ENOMEM);
1765  q->extparam_str = tmp;
1766 
1767  tmp = av_realloc_array(q->extparam, q->nb_extparam + 1, sizeof(*q->extparam));
1768  if (!tmp)
1769  return AVERROR(ENOMEM);
1770  q->extparam = tmp;
1771 
1772  new_ext_buf = (mfxExtBuffer*)av_mallocz(ext_buf.BufferSz);
1773  if (!new_ext_buf)
1774  return AVERROR(ENOMEM);
1775 
1776  new_ext_buf->BufferId = ext_buf.BufferId;
1777  new_ext_buf->BufferSz = ext_buf.BufferSz;
1778  q->extparam_str[q->nb_extparam_str++] = new_ext_buf;
1779  q->extparam[q->nb_extparam++] = new_ext_buf;
1780  q->param.ExtParam = q->extparam;
1781  q->param.NumExtParam = q->nb_extparam;
1782  } else {
1783  av_log(avctx, AV_LOG_ERROR, "Failed to set parameter: %s\n", param_key);
1784  return AVERROR_UNKNOWN;
1785  }
1786  }
1787  }
1788 #else
1789  if (q->qsv_params) {
1790  av_log(avctx, AV_LOG_WARNING, "MFX string API is not supported, ignore qsv_params option\n");
1791  }
1792 #endif
1793 
1794  ret = MFXVideoENCODE_Query(q->session, &q->param, &q->param);
1795  if (ret == MFX_WRN_PARTIAL_ACCELERATION) {
1796  av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
1797  } else if (ret < 0) {
1798  return ff_qsv_print_error(avctx, ret,
1799  "Error querying encoder params");
1800  }
1801 
1802  ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
1803  if (ret < 0)
1804  return ff_qsv_print_error(avctx, ret,
1805  "Error querying (IOSurf) the encoding parameters");
1806 
1807  if (opaque_alloc) {
1808 #if QSV_HAVE_OPAQUE
1809  ret = qsv_init_opaque_alloc(avctx, q);
1810  if (ret < 0)
1811  return ret;
1812 #else
1813  av_log(avctx, AV_LOG_ERROR, "User is requesting to allocate OPAQUE surface, "
1814  "however libmfx %d.%d doesn't support OPAQUE memory.\n",
1815  q->ver.Major, q->ver.Minor);
1816  return AVERROR_UNKNOWN;
1817 #endif
1818  }
1819 
1820  ret = MFXVideoENCODE_Init(q->session, &q->param);
1821  if (ret < 0)
1822  return ff_qsv_print_error(avctx, ret,
1823  "Error initializing the encoder");
1824  else if (ret > 0)
1825  ff_qsv_print_warning(avctx, ret,
1826  "Warning in encoder initialization");
1827 
1828  switch (avctx->codec_id) {
1829  case AV_CODEC_ID_MJPEG:
1830  ret = qsv_retrieve_enc_jpeg_params(avctx, q);
1831  break;
1832  case AV_CODEC_ID_VP9:
1833  ret = qsv_retrieve_enc_vp9_params(avctx, q);
1834  break;
1835  case AV_CODEC_ID_AV1:
1836  ret = qsv_retrieve_enc_av1_params(avctx, q);
1837  break;
1838  default:
1839  ret = qsv_retrieve_enc_params(avctx, q);
1840  break;
1841  }
1842  if (ret < 0) {
1843  av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
1844  return ret;
1845  }
1846 
1847  q->avctx = avctx;
1848 
1849  return 0;
1850 }
1851 
1852 static void free_encoder_ctrl(mfxEncodeCtrl* enc_ctrl)
1853 {
1854  if (enc_ctrl) {
1855  for (int i = 0; i < enc_ctrl->NumPayload && i < QSV_MAX_ENC_PAYLOAD; i++)
1856  av_freep(&enc_ctrl->Payload[i]);
1857 
1858  for (int i = 0; i < enc_ctrl->NumExtParam && i < QSV_MAX_ENC_EXTPARAM; i++)
1859  av_freep(&enc_ctrl->ExtParam[i]);
1860 
1861  enc_ctrl->NumPayload = 0;
1862  enc_ctrl->NumExtParam = 0;
1863  }
1864 }
1865 
1866 static void clear_unused_frames(QSVEncContext *q)
1867 {
1868  QSVFrame *cur = q->work_frames;
1869  while (cur) {
1870  if (cur->used && !cur->surface.Data.Locked) {
1871  free_encoder_ctrl(&cur->enc_ctrl);
1872  //do not reuse enc_ctrl from previous frame
1873  memset(&cur->enc_ctrl, 0, sizeof(cur->enc_ctrl));
1874  cur->enc_ctrl.Payload = cur->payloads;
1875  cur->enc_ctrl.ExtParam = cur->extparam;
1876  if (cur->frame->format == AV_PIX_FMT_QSV) {
1877  av_frame_unref(cur->frame);
1878  }
1879  cur->used = 0;
1880  }
1881  cur = cur->next;
1882  }
1883 }
1884 
1885 static int get_free_frame(QSVEncContext *q, QSVFrame **f)
1886 {
1887  QSVFrame *frame, **last;
1888 
1889  clear_unused_frames(q);
1890 
1891  frame = q->work_frames;
1892  last = &q->work_frames;
1893  while (frame) {
1894  if (!frame->used) {
1895  *f = frame;
1896  frame->used = 1;
1897  return 0;
1898  }
1899 
1900  last = &frame->next;
1901  frame = frame->next;
1902  }
1903 
1904  frame = av_mallocz(sizeof(*frame));
1905  if (!frame)
1906  return AVERROR(ENOMEM);
1907  frame->frame = av_frame_alloc();
1908  if (!frame->frame) {
1909  av_freep(&frame);
1910  return AVERROR(ENOMEM);
1911  }
1912  frame->enc_ctrl.Payload = frame->payloads;
1913  frame->enc_ctrl.ExtParam = frame->extparam;
1914  *last = frame;
1915 
1916  *f = frame;
1917  frame->used = 1;
1918 
1919  return 0;
1920 }
1921 
1922 static int qsvenc_fill_padding_area(AVFrame *frame, int new_w, int new_h)
1923 {
1924  const AVPixFmtDescriptor *desc;
1925  int max_step[4], filled[4] = { 0 };
1926 
1927  desc = av_pix_fmt_desc_get(frame->format);
1928  av_assert0(desc);
1929  av_image_fill_max_pixsteps(max_step, NULL, desc);
1930 
1931  for (int i = 0; i < desc->nb_components; i++) {
1932  const AVComponentDescriptor *comp = &desc->comp[i];
1933  int sheight, dheight, plane = comp->plane;
1934  ptrdiff_t swidth = av_image_get_linesize(frame->format,
1935  frame->width,
1936  plane);
1937  ptrdiff_t dwidth = av_image_get_linesize(frame->format,
1938  new_w,
1939  plane);
1940 
1941  if (swidth < 0 || dwidth < 0) {
1942  av_log(NULL, AV_LOG_ERROR, "av_image_get_linesize failed\n");
1943  return AVERROR(EINVAL);
1944  }
1945 
1946  if (filled[plane])
1947  continue;
1948 
1949  sheight = frame->height;
1950  dheight = new_h;
1951 
1952  if (plane) {
1953  sheight = AV_CEIL_RSHIFT(frame->height, desc->log2_chroma_h);
1954  dheight = AV_CEIL_RSHIFT(new_h, desc->log2_chroma_h);
1955  }
1956 
1957  // Fill right padding
1958  if (new_w > frame->width) {
1959  for (int j = 0; j < sheight; j++) {
1960  void *line_ptr = frame->data[plane] + j * frame->linesize[plane] + swidth;
1961 
1962  av_memcpy_backptr(line_ptr,
1963  max_step[plane],
1964  new_w - frame->width);
1965  }
1966  }
1967 
1968  // Fill bottom padding
1969  for (int j = sheight; j < dheight; j++)
1970  memcpy(frame->data[plane] + j * frame->linesize[plane],
1971  frame->data[plane] + (sheight - 1) * frame->linesize[plane],
1972  dwidth);
1973 
1974  filled[plane] = 1;
1975  }
1976 
1977  return 0;
1978 }
1979 
1980 /* frame width / height have been aligned with the alignment */
1981 static int qsvenc_get_continuous_buffer(AVFrame *frame)
1982 {
1983  int total_size;
1984 
1985  switch (frame->format) {
1986  case AV_PIX_FMT_NV12:
1987  frame->linesize[0] = frame->width;
1988  frame->linesize[1] = frame->linesize[0];
1989  total_size = frame->linesize[0] * frame->height + frame->linesize[1] * frame->height / 2;
1990  break;
1991 
1992  case AV_PIX_FMT_P010:
1993  case AV_PIX_FMT_P012:
1994  frame->linesize[0] = 2 * frame->width;
1995  frame->linesize[1] = frame->linesize[0];
1996  total_size = frame->linesize[0] * frame->height + frame->linesize[1] * frame->height / 2;
1997  break;
1998 
1999  case AV_PIX_FMT_YUYV422:
2000  frame->linesize[0] = 2 * frame->width;
2001  frame->linesize[1] = 0;
2002  total_size = frame->linesize[0] * frame->height;
2003  break;
2004 
2005  case AV_PIX_FMT_Y210:
2006  case AV_PIX_FMT_VUYX:
2007  case AV_PIX_FMT_XV30:
2008  case AV_PIX_FMT_BGRA:
2009  case AV_PIX_FMT_X2RGB10:
2010  frame->linesize[0] = 4 * frame->width;
2011  frame->linesize[1] = 0;
2012  total_size = frame->linesize[0] * frame->height;
2013  break;
2014 
2015  default:
2016  // This should never be reached
2017  av_assert0(0);
2018  return AVERROR(EINVAL);
2019  }
2020 
2021  frame->buf[0] = av_buffer_alloc(total_size);
2022  if (!frame->buf[0])
2023  return AVERROR(ENOMEM);
2024 
2025  frame->data[0] = frame->buf[0]->data;
2026  frame->extended_data = frame->data;
2027 
2028  if (frame->format == AV_PIX_FMT_NV12 ||
2029  frame->format == AV_PIX_FMT_P010 ||
2030  frame->format == AV_PIX_FMT_P012)
2031  frame->data[1] = frame->data[0] + frame->linesize[0] * frame->height;
2032 
2033  return 0;
2034 }
2035 
2036 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
2037  QSVFrame **new_frame)
2038 {
2039  QSVFrame *qf;
2040  int ret;
2041 
2042  ret = get_free_frame(q, &qf);
2043  if (ret < 0)
2044  return ret;
2045 
2046  if (frame->format == AV_PIX_FMT_QSV) {
2047  ret = av_frame_ref(qf->frame, frame);
2048  if (ret < 0)
2049  return ret;
2050 
2051  qf->surface = *(mfxFrameSurface1*)qf->frame->data[3];
2052 
2053  if (q->frames_ctx.mids) {
2054  ret = ff_qsv_find_surface_idx(&q->frames_ctx, qf);
2055  if (ret < 0)
2056  return ret;
2057 
2058  qf->surface.Data.MemId = &q->frames_ctx.mids[ret];
2059  }
2060  } else {
2061  /* make a copy if the input is not padded as libmfx requires */
2062  /* and to make allocation continuous for data[0]/data[1] */
2063  if ((frame->height & (q->height_align - 1) || frame->linesize[0] & (q->width_align - 1)) ||
2064  ((frame->format == AV_PIX_FMT_NV12 || frame->format == AV_PIX_FMT_P010 || frame->format == AV_PIX_FMT_P012) &&
2065  (frame->data[1] - frame->data[0] != frame->linesize[0] * FFALIGN(qf->frame->height, q->height_align)))) {
2066  int tmp_w, tmp_h;
2067  qf->frame->height = tmp_h = FFALIGN(frame->height, q->height_align);
2068  qf->frame->width = tmp_w = FFALIGN(frame->width, q->width_align);
2069 
2070  qf->frame->format = frame->format;
2071 
2072  if (!qf->frame->data[0]) {
2073  ret = qsvenc_get_continuous_buffer(qf->frame);
2074  if (ret < 0)
2075  return ret;
2076  }
2077 
2078  qf->frame->height = frame->height;
2079  qf->frame->width = frame->width;
2080 
2081  ret = av_frame_copy(qf->frame, frame);
2082  if (ret < 0) {
2083  av_frame_unref(qf->frame);
2084  return ret;
2085  }
2086 
2087  ret = qsvenc_fill_padding_area(qf->frame, tmp_w, tmp_h);
2088  if (ret < 0) {
2089  av_frame_unref(qf->frame);
2090  return ret;
2091  }
2092  } else {
2093  ret = av_frame_replace(qf->frame, frame);
2094  if (ret < 0)
2095  return ret;
2096  }
2097 
2098  qf->surface.Info = q->param.mfx.FrameInfo;
2099 
2100  qf->surface.Info.PicStruct =
2101  !(frame->flags & AV_FRAME_FLAG_INTERLACED) ? MFX_PICSTRUCT_PROGRESSIVE :
2102  (frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) ? MFX_PICSTRUCT_FIELD_TFF :
2103  MFX_PICSTRUCT_FIELD_BFF;
2104  if (frame->repeat_pict == 1)
2105  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
2106  else if (frame->repeat_pict == 2)
2107  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
2108  else if (frame->repeat_pict == 4)
2109  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
2110 
2111  ret = ff_qsv_map_frame_to_surface(qf->frame, &qf->surface);
2112  if (ret < 0) {
2113  av_log(q->avctx, AV_LOG_ERROR, "map frame to surface failed.\n");
2114  return ret;
2115  }
2116  }
2117  qf->surface.Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
2118 
2119  *new_frame = qf;
2120 
2121  return 0;
2122 }
2123 
2124 static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
2125 {
2126  if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
2127  if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
2128  q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
2129  q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
2130  av_log(avctx, AV_LOG_WARNING,
2131  "Interlaced coding is supported"
2132  " at Main/High Profile Level 2.2-4.0\n");
2133  }
2134 }
2135 
2136 static int set_roi_encode_ctrl(AVCodecContext *avctx, const AVFrame *frame,
2137  mfxEncodeCtrl *enc_ctrl)
2138 {
2139  AVFrameSideData *sd = NULL;
2140  int mb_size;
2141 
2142  if (avctx->codec_id == AV_CODEC_ID_H264)
2143  mb_size = 16;
2144  else if (avctx->codec_id == AV_CODEC_ID_H265)
2145  mb_size = 32;
2146  else
2147  return 0;
2148 
2149  if (frame)
2150  sd = av_frame_get_side_data(frame, AV_FRAME_DATA_REGIONS_OF_INTEREST);
2151 
2152  if (sd) {
2153  mfxExtEncoderROI *enc_roi = NULL;
2154  AVRegionOfInterest *roi;
2155  uint32_t roi_size;
2156  int nb_roi, i;
2157 
2158  roi = (AVRegionOfInterest *)sd->data;
2159  roi_size = roi->self_size;
2160  if (!roi_size || sd->size % roi_size) {
2161  av_log(avctx, AV_LOG_ERROR, "Invalid ROI Data.\n");
2162  return AVERROR(EINVAL);
2163  }
2164  nb_roi = sd->size / roi_size;
2165  if (nb_roi > QSV_MAX_ROI_NUM) {
2166  av_log(avctx, AV_LOG_WARNING, "More ROIs set than "
2167  "supported by driver (%d > %d).\n",
2168  nb_roi, QSV_MAX_ROI_NUM);
2169  nb_roi = QSV_MAX_ROI_NUM;
2170  }
2171 
2172  enc_roi = av_mallocz(sizeof(*enc_roi));
2173  if (!enc_roi)
2174  return AVERROR(ENOMEM);
2175  enc_roi->Header.BufferId = MFX_EXTBUFF_ENCODER_ROI;
2176  enc_roi->Header.BufferSz = sizeof(*enc_roi);
2177  enc_roi->NumROI = nb_roi;
2178  enc_roi->ROIMode = MFX_ROI_MODE_QP_DELTA;
2179  for (i = 0; i < nb_roi; i++) {
2180  roi = (AVRegionOfInterest *)(sd->data + roi_size * i);
2181  enc_roi->ROI[i].Top = FFALIGN(roi->top, mb_size);
2182  enc_roi->ROI[i].Bottom = FFALIGN(roi->bottom, mb_size);
2183  enc_roi->ROI[i].Left = FFALIGN(roi->left, mb_size);
2184  enc_roi->ROI[i].Right = FFALIGN(roi->right, mb_size);
2185  enc_roi->ROI[i].DeltaQP =
2186  roi->qoffset.num * 51 / roi->qoffset.den;
2187  av_log(avctx, AV_LOG_DEBUG, "ROI: (%d,%d)-(%d,%d) -> %+d.\n",
2188  roi->top, roi->left, roi->bottom, roi->right,
2189  enc_roi->ROI[i].DeltaQP);
2190  }
2191  enc_ctrl->ExtParam[enc_ctrl->NumExtParam] = (mfxExtBuffer *)enc_roi;
2192  enc_ctrl->NumExtParam++;
2193  }
2194  return 0;
2195 }
2196 
2197 static void set_skip_frame_encode_ctrl(AVCodecContext *avctx, const AVFrame *frame,
2198  mfxEncodeCtrl *enc_ctrl)
2199 {
2200  AVDictionaryEntry* skip_frame_dict = NULL;
2201  if (!frame->metadata)
2202  return;
2203  skip_frame_dict = av_dict_get(frame->metadata, "qsv_skip_frame", NULL, 0);
2204  if (!skip_frame_dict)
2205  return;
2206  enc_ctrl->SkipFrame = strtol(skip_frame_dict->value, NULL, 10);
2207  return;
2208 }
2209 
2210 static int update_qp(AVCodecContext *avctx, QSVEncContext *q)
2211 {
2212  int updated = 0, new_qp = 0;
2213 
2214  if (avctx->codec_id != AV_CODEC_ID_H264 && avctx->codec_id != AV_CODEC_ID_HEVC)
2215  return 0;
2216 
2217  if (q->param.mfx.RateControlMethod == MFX_RATECONTROL_CQP) {
2218  UPDATE_PARAM(q->old_global_quality, avctx->global_quality);
2219  UPDATE_PARAM(q->old_i_quant_factor, avctx->i_quant_factor);
2220  UPDATE_PARAM(q->old_i_quant_offset, avctx->i_quant_offset);
2221  UPDATE_PARAM(q->old_b_quant_factor, avctx->b_quant_factor);
2222  UPDATE_PARAM(q->old_b_quant_offset, avctx->b_quant_offset);
2223  if (!updated)
2224  return 0;
2225 
2226  new_qp = avctx->global_quality / FF_QP2LAMBDA;
2227  q->param.mfx.QPI = av_clip(new_qp * fabs(avctx->i_quant_factor) +
2228  avctx->i_quant_offset, 0, 51);
2229  q->param.mfx.QPP = av_clip(new_qp, 0, 51);
2230  q->param.mfx.QPB = av_clip(new_qp * fabs(avctx->b_quant_factor) +
2231  avctx->b_quant_offset, 0, 51);
2232  av_log(avctx, AV_LOG_DEBUG,
2233  "Reset qp = %d/%d/%d for idr/p/b frames\n",
2234  q->param.mfx.QPI, q->param.mfx.QPP, q->param.mfx.QPB);
2235  }
2236  return updated;
2237 }
2238 
2239 static int update_max_frame_size(AVCodecContext *avctx, QSVEncContext *q)
2240 {
2241  int updated = 0;
2242 
2243  if (avctx->codec_id != AV_CODEC_ID_H264 && avctx->codec_id != AV_CODEC_ID_HEVC)
2244  return 0;
2245 
2246  UPDATE_PARAM(q->old_max_frame_size, q->max_frame_size);
2247  if (!updated)
2248  return 0;
2249 
2250  q->extco2.MaxFrameSize = FFMAX(0, q->max_frame_size);
2251  av_log(avctx, AV_LOG_DEBUG,
2252  "Reset MaxFrameSize: %d;\n", q->extco2.MaxFrameSize);
2253 
2254  return updated;
2255 }
2256 
2257 static int update_gop_size(AVCodecContext *avctx, QSVEncContext *q)
2258 {
2259  int updated = 0;
2260  UPDATE_PARAM(q->old_gop_size, avctx->gop_size);
2261  if (!updated)
2262  return 0;
2263 
2264  q->param.mfx.GopPicSize = FFMAX(0, avctx->gop_size);
2265  av_log(avctx, AV_LOG_DEBUG, "reset GopPicSize to %d\n",
2266  q->param.mfx.GopPicSize);
2267 
2268  return updated;
2269 }
2270 
2271 static int update_rir(AVCodecContext *avctx, QSVEncContext *q)
2272 {
2273  int updated = 0;
2274 
2275  if (avctx->codec_id != AV_CODEC_ID_H264 && avctx->codec_id != AV_CODEC_ID_HEVC)
2276  return 0;
2277 
2278  UPDATE_PARAM(q->old_int_ref_type, q->int_ref_type);
2279  UPDATE_PARAM(q->old_int_ref_cycle_size, q->int_ref_cycle_size);
2280  UPDATE_PARAM(q->old_int_ref_qp_delta, q->int_ref_qp_delta);
2281  UPDATE_PARAM(q->old_int_ref_cycle_dist, q->int_ref_cycle_dist);
2282  if (!updated)
2283  return 0;
2284 
2285  q->extco2.IntRefType = FFMAX(0, q->int_ref_type);
2286  q->extco2.IntRefCycleSize = FFMAX(0, q->int_ref_cycle_size);
2287  q->extco2.IntRefQPDelta =
2288  q->int_ref_qp_delta != INT16_MIN ? q->int_ref_qp_delta : 0;
2289  q->extco3.IntRefCycleDist = FFMAX(0, q->int_ref_cycle_dist);
2290  av_log(avctx, AV_LOG_DEBUG,
2291  "Reset IntRefType: %d; IntRefCycleSize: %d; "
2292  "IntRefQPDelta: %d; IntRefCycleDist: %d\n",
2293  q->extco2.IntRefType, q->extco2.IntRefCycleSize,
2294  q->extco2.IntRefQPDelta, q->extco3.IntRefCycleDist);
2295 
2296  return updated;
2297 }
2298 
2299 static int update_min_max_qp(AVCodecContext *avctx, QSVEncContext *q)
2300 {
2301  int updated = 0;
2302 
2303  if (avctx->codec_id != AV_CODEC_ID_H264)
2304  return 0;
2305 
2306  UPDATE_PARAM(q->old_qmin, avctx->qmin);
2307  UPDATE_PARAM(q->old_qmax, avctx->qmax);
2308  UPDATE_PARAM(q->old_min_qp_i, q->min_qp_i);
2309  UPDATE_PARAM(q->old_max_qp_i, q->max_qp_i);
2310  UPDATE_PARAM(q->old_min_qp_p, q->min_qp_p);
2311  UPDATE_PARAM(q->old_max_qp_p, q->max_qp_p);
2312  UPDATE_PARAM(q->old_min_qp_b, q->min_qp_b);
2313  UPDATE_PARAM(q->old_max_qp_b, q->max_qp_b);
2314  if (!updated)
2315  return 0;
2316 
2317  if ((avctx->qmin >= 0 && avctx->qmax >= 0 && avctx->qmin > avctx->qmax) ||
2318  (q->max_qp_i >= 0 && q->min_qp_i >= 0 && q->min_qp_i > q->max_qp_i) ||
2319  (q->max_qp_p >= 0 && q->min_qp_p >= 0 && q->min_qp_p > q->max_qp_p) ||
2320  (q->max_qp_b >= 0 && q->min_qp_b >= 0 && q->min_qp_b > q->max_qp_b)) {
2321  av_log(avctx, AV_LOG_ERROR,
2322  "qmin and or qmax are set but invalid,"
2323  " please make sure min <= max\n");
2324  return AVERROR(EINVAL);
2325  }
2326 
2327  q->extco2.MinQPI = 0;
2328  q->extco2.MaxQPI = 0;
2329  q->extco2.MinQPP = 0;
2330  q->extco2.MaxQPP = 0;
2331  q->extco2.MinQPB = 0;
2332  q->extco2.MaxQPB = 0;
2333  if (avctx->qmin >= 0) {
2334  q->extco2.MinQPI = avctx->qmin > 51 ? 51 : avctx->qmin;
2335  q->extco2.MinQPB = q->extco2.MinQPP = q->extco2.MinQPI;
2336  }
2337  if (avctx->qmax >= 0) {
2338  q->extco2.MaxQPI = avctx->qmax > 51 ? 51 : avctx->qmax;
2339  q->extco2.MaxQPB = q->extco2.MaxQPP = q->extco2.MaxQPI;
2340  }
2341  if (q->min_qp_i >= 0)
2342  q->extco2.MinQPI = q->min_qp_i > 51 ? 51 : q->min_qp_i;
2343  if (q->max_qp_i >= 0)
2344  q->extco2.MaxQPI = q->max_qp_i > 51 ? 51 : q->max_qp_i;
2345  if (q->min_qp_p >= 0)
2346  q->extco2.MinQPP = q->min_qp_p > 51 ? 51 : q->min_qp_p;
2347  if (q->max_qp_p >= 0)
2348  q->extco2.MaxQPP = q->max_qp_p > 51 ? 51 : q->max_qp_p;
2349  if (q->min_qp_b >= 0)
2350  q->extco2.MinQPB = q->min_qp_b > 51 ? 51 : q->min_qp_b;
2351  if (q->max_qp_b >= 0)
2352  q->extco2.MaxQPB = q->max_qp_b > 51 ? 51 : q->max_qp_b;
2353 
2354  av_log(avctx, AV_LOG_VERBOSE, "Reset MinQPI: %d; MaxQPI: %d; "
2355  "MinQPP: %d; MaxQPP: %d; "
2356  "MinQPB: %d; MaxQPB: %d\n",
2357  q->extco2.MinQPI, q->extco2.MaxQPI,
2358  q->extco2.MinQPP, q->extco2.MaxQPP,
2359  q->extco2.MinQPB, q->extco2.MaxQPB);
2360 
2361  return updated;
2362 }
2363 
2364 static int update_low_delay_brc(AVCodecContext *avctx, QSVEncContext *q)
2365 {
2366  int updated = 0;
2367 
2368  if (avctx->codec_id != AV_CODEC_ID_H264 &&
2369  avctx->codec_id != AV_CODEC_ID_HEVC &&
2370  avctx->codec_id != AV_CODEC_ID_AV1)
2371  return 0;
2372 
2373  UPDATE_PARAM(q->old_low_delay_brc, q->low_delay_brc);
2374  if (!updated)
2375  return 0;
2376 
2377  q->extco3.LowDelayBRC = MFX_CODINGOPTION_UNKNOWN;
2378  if (q->low_delay_brc >= 0)
2379  q->extco3.LowDelayBRC = q->low_delay_brc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
2380  av_log(avctx, AV_LOG_DEBUG, "Reset LowDelayBRC: %s\n",
2381  print_threestate(q->extco3.LowDelayBRC));
2382 
2383  return updated;
2384 }
2385 
2386 static int update_frame_rate(AVCodecContext *avctx, QSVEncContext *q)
2387 {
2388  int updated = 0;
2389 
2390  UPDATE_PARAM(q->old_framerate.num, avctx->framerate.num);
2391  UPDATE_PARAM(q->old_framerate.den, avctx->framerate.den);
2392  if (!updated)
2393  return 0;
2394 
2395  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
2396  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
2397  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
2398  } else {
2399  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
2400  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
2401  }
2402  av_log(avctx, AV_LOG_DEBUG, "Reset framerate: %d/%d (%.2f fps).\n",
2403  q->param.mfx.FrameInfo.FrameRateExtN,
2404  q->param.mfx.FrameInfo.FrameRateExtD,
2405  (double)q->param.mfx.FrameInfo.FrameRateExtN / q->param.mfx.FrameInfo.FrameRateExtD);
2406 
2407  return updated;
2408 }
2409 
2410 static int update_bitrate(AVCodecContext *avctx, QSVEncContext *q)
2411 {
2412  int updated = 0;
2413  int target_bitrate_kbps, max_bitrate_kbps, brc_param_multiplier;
2414  int buffer_size_in_kilobytes, initial_delay_in_kilobytes;
2415 
2416  UPDATE_PARAM(q->old_rc_buffer_size, avctx->rc_buffer_size);
2417  UPDATE_PARAM(q->old_rc_initial_buffer_occupancy, avctx->rc_initial_buffer_occupancy);
2418  UPDATE_PARAM(q->old_bit_rate, avctx->bit_rate);
2419  UPDATE_PARAM(q->old_rc_max_rate, avctx->rc_max_rate);
2420  if (!updated)
2421  return 0;
2422 
2423  buffer_size_in_kilobytes = avctx->rc_buffer_size / 8000;
2424  initial_delay_in_kilobytes = avctx->rc_initial_buffer_occupancy / 8000;
2425  target_bitrate_kbps = avctx->bit_rate / 1000;
2426  max_bitrate_kbps = avctx->rc_max_rate / 1000;
2427  brc_param_multiplier = (FFMAX(FFMAX3(target_bitrate_kbps, max_bitrate_kbps, buffer_size_in_kilobytes),
2428  initial_delay_in_kilobytes) + 0x10000) / 0x10000;
2429 
2430  q->param.mfx.BufferSizeInKB = buffer_size_in_kilobytes / brc_param_multiplier;
2431  q->param.mfx.InitialDelayInKB = initial_delay_in_kilobytes / brc_param_multiplier;
2432  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
2433  q->param.mfx.MaxKbps = max_bitrate_kbps / brc_param_multiplier;
2434  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
2435  av_log(avctx, AV_LOG_VERBOSE,
2436  "Reset BufferSizeInKB: %d; InitialDelayInKB: %d; "
2437  "TargetKbps: %d; MaxKbps: %d; BRCParamMultiplier: %d\n",
2438  q->param.mfx.BufferSizeInKB, q->param.mfx.InitialDelayInKB,
2439  q->param.mfx.TargetKbps, q->param.mfx.MaxKbps, q->param.mfx.BRCParamMultiplier);
2440  return updated;
2441 }
2442 
2443 static int update_pic_timing_sei(AVCodecContext *avctx, QSVEncContext *q)
2444 {
2445  int updated = 0;
2446 
2447  if (avctx->codec_id != AV_CODEC_ID_H264 && avctx->codec_id != AV_CODEC_ID_HEVC)
2448  return 0;
2449 
2450  UPDATE_PARAM(q->old_pic_timing_sei, q->pic_timing_sei);
2451  if (!updated)
2452  return 0;
2453 
2454  q->extco.PicTimingSEI = q->pic_timing_sei ?
2455  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;
2456  av_log(avctx, AV_LOG_DEBUG, "Reset PicTimingSEI: %s\n",
2457  print_threestate(q->extco.PicTimingSEI));
2458 
2459  return updated;
2460 }
2461 
2462 static int encode_frame(AVCodecContext *avctx, QSVEncContext *q,
2463  const AVFrame *frame)
2464 {
2465  QSVPacket pkt = { { 0 } };
2466  mfxExtAVCEncodedFrameInfo *enc_info = NULL;
2467  mfxExtBuffer **enc_buf = NULL;
2468 
2469  mfxFrameSurface1 *surf = NULL;
2470  QSVFrame *qsv_frame = NULL;
2471  mfxEncodeCtrl* enc_ctrl = NULL;
2472  int ret;
2473 
2474  if (frame) {
2475  ret = submit_frame(q, frame, &qsv_frame);
2476  if (ret < 0) {
2477  av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
2478  return ret;
2479  }
2480  }
2481  if (qsv_frame) {
2482  surf = &qsv_frame->surface;
2483  enc_ctrl = &qsv_frame->enc_ctrl;
2484 
2485  if (frame->pict_type == AV_PICTURE_TYPE_I) {
2486  enc_ctrl->FrameType = MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF;
2487  if ((frame->flags & AV_FRAME_FLAG_KEY) || q->forced_idr)
2488  enc_ctrl->FrameType |= MFX_FRAMETYPE_IDR;
2489  }
2490  }
2491 
2492  ret = av_new_packet(&pkt.pkt, q->packet_size);
2493  if (ret < 0) {
2494  av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
2495  return ret;
2496  }
2497 
2498  pkt.bs = av_mallocz(sizeof(*pkt.bs));
2499  if (!pkt.bs)
2500  goto nomem;
2501  pkt.bs->Data = pkt.pkt.data;
2502  pkt.bs->MaxLength = pkt.pkt.size;
2503 
2504  if (avctx->codec_id == AV_CODEC_ID_H264) {
2505  enc_info = av_mallocz(sizeof(*enc_info));
2506  if (!enc_info)
2507  goto nomem;
2508 
2509  enc_info->Header.BufferId = MFX_EXTBUFF_ENCODED_FRAME_INFO;
2510  enc_info->Header.BufferSz = sizeof (*enc_info);
2511  pkt.bs->NumExtParam = 1;
2512  enc_buf = av_mallocz(sizeof(mfxExtBuffer *));
2513  if (!enc_buf)
2514  goto nomem;
2515  enc_buf[0] = (mfxExtBuffer *)enc_info;
2516 
2517  pkt.bs->ExtParam = enc_buf;
2518  }
2519 
2520  if (q->set_encode_ctrl_cb && enc_ctrl) {
2521  q->set_encode_ctrl_cb(avctx, frame, enc_ctrl);
2522  }
2523 
2524  if ((avctx->codec_id == AV_CODEC_ID_H264 ||
2525  avctx->codec_id == AV_CODEC_ID_H265) &&
2526  enc_ctrl && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 8)) {
2527  ret = set_roi_encode_ctrl(avctx, frame, enc_ctrl);
2528  if (ret < 0)
2529  goto free;
2530  }
2531  if ((avctx->codec_id == AV_CODEC_ID_H264 ||
2532  avctx->codec_id == AV_CODEC_ID_H265) &&
2533  q->skip_frame != MFX_SKIPFRAME_NO_SKIP &&
2534  enc_ctrl && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 13))
2535  set_skip_frame_encode_ctrl(avctx, frame, enc_ctrl);
2536 
2537  pkt.sync = av_mallocz(sizeof(*pkt.sync));
2538  if (!pkt.sync)
2539  goto nomem;
2540 
2541  do {
2542  ret = MFXVideoENCODE_EncodeFrameAsync(q->session, enc_ctrl, surf, pkt.bs, pkt.sync);
2543  if (ret == MFX_WRN_DEVICE_BUSY)
2544  av_usleep(500);
2545  } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_WRN_IN_EXECUTION);
2546 
2547  if (ret > 0)
2548  ff_qsv_print_warning(avctx, ret, "Warning during encoding");
2549 
2550  if (ret < 0) {
2551  ret = (ret == MFX_ERR_MORE_DATA) ?
2552  AVERROR(EAGAIN) : ff_qsv_print_error(avctx, ret, "Error during encoding");
2553  goto free;
2554  }
2555 
2556  if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM && frame && (frame->flags & AV_FRAME_FLAG_INTERLACED))
2557  print_interlace_msg(avctx, q);
2558 
2559  ret = 0;
2560 
2561  if (*pkt.sync) {
2562  ret = av_fifo_write(q->async_fifo, &pkt, 1);
2563  if (ret < 0)
2564  goto free;
2565  } else {
2566 free:
2567  av_freep(&pkt.sync);
2568  av_packet_unref(&pkt.pkt);
2569  av_freep(&pkt.bs);
2570  if (avctx->codec_id == AV_CODEC_ID_H264) {
2571  av_freep(&enc_info);
2572  av_freep(&enc_buf);
2573  }
2574  }
2575 
2576  return ret;
2577 nomem:
2578  ret = AVERROR(ENOMEM);
2579  goto free;
2580 }
2581 
2582 static int update_parameters(AVCodecContext *avctx, QSVEncContext *q,
2583  const AVFrame *frame)
2584 {
2585  int needReset = 0, ret = 0;
2586 
2587  if (!frame || avctx->codec_id == AV_CODEC_ID_MJPEG)
2588  return 0;
2589 
2590  needReset = update_qp(avctx, q);
2591  needReset |= update_max_frame_size(avctx, q);
2592  needReset |= update_gop_size(avctx, q);
2593  needReset |= update_rir(avctx, q);
2594  needReset |= update_low_delay_brc(avctx, q);
2595  needReset |= update_frame_rate(avctx, q);
2596  needReset |= update_bitrate(avctx, q);
2597  needReset |= update_pic_timing_sei(avctx, q);
2598  ret = update_min_max_qp(avctx, q);
2599  if (ret < 0)
2600  return ret;
2601  needReset |= ret;
2602  if (!needReset)
2603  return 0;
2604 
2605  if (avctx->hwaccel_context) {
2606  AVQSVContext *qsv = avctx->hwaccel_context;
2607  int i, j;
2608  q->param.ExtParam = q->extparam;
2609  for (i = 0; i < qsv->nb_ext_buffers; i++)
2610  q->param.ExtParam[i] = qsv->ext_buffers[i];
2611  q->param.NumExtParam = qsv->nb_ext_buffers;
2612 
2613  for (i = 0; i < q->nb_extparam_internal; i++) {
2614  for (j = 0; j < qsv->nb_ext_buffers; j++) {
2615  if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)
2616  break;
2617  }
2618  if (j < qsv->nb_ext_buffers)
2619  continue;
2620  q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];
2621  }
2622  } else {
2623  q->param.ExtParam = q->extparam_internal;
2624  q->param.NumExtParam = q->nb_extparam_internal;
2625  }
2626 
2627  // Flush codec before reset configuration.
2628  while (ret != AVERROR(EAGAIN)) {
2629  ret = encode_frame(avctx, q, NULL);
2630  if (ret < 0 && ret != AVERROR(EAGAIN))
2631  return ret;
2632  }
2633 
2634  av_log(avctx, AV_LOG_DEBUG, "Parameter change, call msdk reset.\n");
2635  ret = MFXVideoENCODE_Reset(q->session, &q->param);
2636  if (ret < 0)
2637  return ff_qsv_print_error(avctx, ret, "Error during resetting");
2638 
2639  return 0;
2640 }
2641 
2642 int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q,
2643  AVPacket *pkt, const AVFrame *frame, int *got_packet)
2644 {
2645  int ret;
2646 
2647  ret = update_parameters(avctx, q, frame);
2648  if (ret < 0)
2649  return ret;
2650 
2651  ret = encode_frame(avctx, q, frame);
2652  if (ret < 0 && ret != AVERROR(EAGAIN))
2653  return ret;
2654 
2655  if ((av_fifo_can_read(q->async_fifo) >= q->async_depth) ||
2656  (!frame && av_fifo_can_read(q->async_fifo))) {
2657  QSVPacket qpkt;
2658  mfxExtAVCEncodedFrameInfo *enc_info;
2659  mfxExtBuffer **enc_buf;
2660  enum AVPictureType pict_type;
2661 
2662  av_fifo_read(q->async_fifo, &qpkt, 1);
2663 
2664  do {
2665  ret = MFXVideoCORE_SyncOperation(q->session, *qpkt.sync, 1000);
2666  } while (ret == MFX_WRN_IN_EXECUTION);
2667 
2668  qpkt.pkt.dts = av_rescale_q(qpkt.bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
2669  qpkt.pkt.pts = av_rescale_q(qpkt.bs->TimeStamp, (AVRational){1, 90000}, avctx->time_base);
2670  qpkt.pkt.size = qpkt.bs->DataLength;
2671 
2672  if (qpkt.bs->FrameType & MFX_FRAMETYPE_IDR || qpkt.bs->FrameType & MFX_FRAMETYPE_xIDR) {
2673  qpkt.pkt.flags |= AV_PKT_FLAG_KEY;
2674  pict_type = AV_PICTURE_TYPE_I;
2675  } else if (qpkt.bs->FrameType & MFX_FRAMETYPE_I || qpkt.bs->FrameType & MFX_FRAMETYPE_xI) {
2676  if (avctx->codec_id == AV_CODEC_ID_VP9)
2677  qpkt.pkt.flags |= AV_PKT_FLAG_KEY;
2678  pict_type = AV_PICTURE_TYPE_I;
2679  } else if (qpkt.bs->FrameType & MFX_FRAMETYPE_P || qpkt.bs->FrameType & MFX_FRAMETYPE_xP)
2680  pict_type = AV_PICTURE_TYPE_P;
2681  else if (qpkt.bs->FrameType & MFX_FRAMETYPE_B || qpkt.bs->FrameType & MFX_FRAMETYPE_xB)
2682  pict_type = AV_PICTURE_TYPE_B;
2683  else if (qpkt.bs->FrameType == MFX_FRAMETYPE_UNKNOWN && qpkt.bs->DataLength) {
2684  pict_type = AV_PICTURE_TYPE_NONE;
2685  av_log(avctx, AV_LOG_WARNING, "Unknown FrameType, set pict_type to AV_PICTURE_TYPE_NONE.\n");
2686  } else {
2687  av_log(avctx, AV_LOG_ERROR, "Invalid FrameType:%d.\n", qpkt.bs->FrameType);
2688  return AVERROR_INVALIDDATA;
2689  }
2690 
2691  if (avctx->codec_id == AV_CODEC_ID_H264) {
2692  enc_buf = qpkt.bs->ExtParam;
2693  enc_info = (mfxExtAVCEncodedFrameInfo *)(*enc_buf);
2694  ff_encode_add_stats_side_data(&qpkt.pkt,
2695  enc_info->QP * FF_QP2LAMBDA, NULL, 0, pict_type);
2696  av_freep(&enc_info);
2697  av_freep(&enc_buf);
2698  }
2699  av_freep(&qpkt.bs);
2700  av_freep(&qpkt.sync);
2701 
2702  av_packet_move_ref(pkt, &qpkt.pkt);
2703 
2704  *got_packet = 1;
2705  }
2706 
2707  return 0;
2708 }
2709 
2710 int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
2711 {
2712  QSVFrame *cur;
2713 
2714  if (q->session)
2715  MFXVideoENCODE_Close(q->session);
2716 
2717  q->session = NULL;
2718  ff_qsv_close_internal_session(&q->internal_qs);
2719 
2720  av_buffer_unref(&q->frames_ctx.hw_frames_ctx);
2721  av_refstruct_unref(&q->frames_ctx.mids);
2722 
2723  cur = q->work_frames;
2724  while (cur) {
2725  q->work_frames = cur->next;
2726  av_frame_free(&cur->frame);
2727  free_encoder_ctrl(&cur->enc_ctrl);
2728  av_freep(&cur);
2729  cur = q->work_frames;
2730  }
2731 
2732  if (q->async_fifo) {
2733  QSVPacket pkt;
2734  while (av_fifo_read(q->async_fifo, &pkt, 1) >= 0) {
2735  if (avctx->codec_id == AV_CODEC_ID_H264) {
2736  mfxExtBuffer **enc_buf = pkt.bs->ExtParam;
2737  mfxExtAVCEncodedFrameInfo *enc_info = (mfxExtAVCEncodedFrameInfo *)(*enc_buf);
2738  av_freep(&enc_info);
2739  av_freep(&enc_buf);
2740  }
2741  av_freep(&pkt.sync);
2742  av_freep(&pkt.bs);
2743  av_packet_unref(&pkt.pkt);
2744  }
2745  av_fifo_freep2(&q->async_fifo);
2746  }
2747 
2748 #if QSV_HAVE_OPAQUE
2749  av_freep(&q->opaque_surfaces);
2750  av_buffer_unref(&q->opaque_alloc_buf);
2751 #endif
2752 
2753  for (int i = 0; i < q->nb_extparam_str; i++)
2754  av_free(q->extparam_str[i]);
2755 
2756  av_freep(&q->extparam_str);
2757  av_freep(&q->extparam);
2758 
2759  return 0;
2760 }
2761 
2762 const AVCodecHWConfigInternal *const ff_qsv_enc_hw_configs[] = {
2763  HW_CONFIG_ENCODER_FRAMES(QSV, QSV),
2764  HW_CONFIG_ENCODER_DEVICE(NV12, QSV),
2765  HW_CONFIG_ENCODER_DEVICE(P010, QSV),
2766  NULL,
2767 };
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:434
update_gop_size
static int update_gop_size(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2257
AVCodecContext::hwaccel_context
void * hwaccel_context
Legacy hardware accelerator context.
Definition: avcodec.h:1447
QSVEncContext::look_ahead_depth
int look_ahead_depth
Definition: qsvenc.h:221
QSVEncContext::nb_extparam
int nb_extparam
Definition: qsvenc.h:201
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
QSVEncContext::old_max_qp_i
int old_max_qp_i
Definition: qsvenc.h:300
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:100
QSVEncContext::repeat_pps
int repeat_pps
Definition: qsvenc.h:255
set_roi_encode_ctrl
static int set_roi_encode_ctrl(AVCodecContext *avctx, const AVFrame *frame, mfxEncodeCtrl *enc_ctrl)
Definition: qsvenc.c:2136
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:671
qsv_retrieve_enc_vp9_params
static int qsv_retrieve_enc_vp9_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1317
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:659
QSVEncContext::max_qp_i
int max_qp_i
Definition: qsvenc.h:276
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:79
AVCodecContext::rc_min_rate
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:1295
QSVEncContext::p_strategy
int p_strategy
Definition: qsvenc.h:246
QSVEncContext::old_rc_buffer_size
int old_rc_buffer_size
Definition: qsvenc.h:312
AVProfile::name
const char * name
short name for the profile
Definition: codec.h:163
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3456
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:124
AVPictureType
AVPictureType
Definition: avutil.h:276
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:213
QSVEncContext::avbr_accuracy
int avbr_accuracy
Definition: qsvenc.h:217
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:64
QSVEncContext::extco
mfxExtCodingOption extco
Definition: qsvenc.h:170
QSVEncContext::old_int_ref_type
int old_int_ref_type
Definition: qsvenc.h:293
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:1159
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:466
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:664
AVFrame::width
int width
Definition: frame.h:538
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:777
QSVEncContext::adaptive_b
int adaptive_b
Definition: qsvenc.h:244
AVPacket::data
uint8_t * data
Definition: packet.h:603
QSVEncContext::max_frame_size
int max_frame_size
Definition: qsvenc.h:225
QSVEncContext::tile_cols
int tile_cols
Definition: qsvenc.h:232
encode.h
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:669
QSVEncContext::packet_size
int packet_size
Definition: qsvenc.h:163
ff_qsv_find_surface_idx
int ff_qsv_find_surface_idx(QSVFramesContext *ctx, QSVFrame *frame)
Definition: qsv.c:348
AVCodecContext::b_quant_offset
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:797
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:75
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:609
QSVEncContext::adaptive_i
int adaptive_i
Definition: qsvenc.h:243
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
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:701
QSVEncContext::int_ref_qp_delta
int int_ref_qp_delta
Definition: qsvenc.h:251
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::extparam_str
mfxExtBuffer ** extparam_str
Definition: qsvenc.h:197
QSVEncContext::old_int_ref_cycle_size
int old_int_ref_cycle_size
Definition: qsvenc.h:294
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:205
QSVEncContext::old_gop_size
int old_gop_size
Definition: qsvenc.h:291
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:1259
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:1242
QSVEncContext::load_plugins
char * load_plugins
Definition: qsvenc.h:265
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:650
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:487
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:1032
QSVEncContext::exthevctiles_idx
int exthevctiles_idx
Definition: qsvenc.h:272
QSVEncContext::extvsi
mfxExtVideoSignalInfo extvsi
Definition: qsvenc.h:192
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:694
update_min_max_qp
static int update_min_max_qp(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2299
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:563
QSVEncContext::recovery_point_sei
int recovery_point_sei
Definition: qsvenc.h:253
QSVEncContext::hevc_vps
int hevc_vps
Definition: qsvenc.h:209
ff_qsv_map_frame_to_surface
int ff_qsv_map_frame_to_surface(const AVFrame *frame, mfxFrameSurface1 *surface)
Definition: qsv.c:287
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:806
QSVEncContext::param
mfxVideoParam param
Definition: qsvenc.h:167
QSVEncContext::height_align
int height_align
Definition: qsvenc.h:165
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:214
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:701
QSVEncContext::old_global_quality
int old_global_quality
Definition: qsvenc.h:283
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:500
val
static double val(void *priv, double ch)
Definition: aeval.c:77
update_pic_timing_sei
static int update_pic_timing_sei(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2443
update_parameters
static int update_parameters(AVCodecContext *avctx, QSVEncContext *q, const AVFrame *frame)
Definition: qsvenc.c:2582
ff_encode_add_stats_side_data
int ff_encode_add_stats_side_data(AVPacket *pkt, int quality, const int64_t error[], int error_count, enum AVPictureType pict_type)
Definition: encode.c:972
qsv_retrieve_enc_params
static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1421
AVRational::num
int num
Numerator.
Definition: rational.h:59
refstruct.h
qsv_internal.h
AV_CODEC_FLAG_INTERLACED_DCT
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:310
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:52
quant
static const uint8_t quant[64]
Definition: vmixdec.c:71
QSVEncContext::extbrc
int extbrc
Definition: qsvenc.h:242
AV_PIX_FMT_Y210
#define AV_PIX_FMT_Y210
Definition: pixfmt.h:606
avassert.h
ff_qsv_enc_hw_configs
const AVCodecHWConfigInternal *const ff_qsv_enc_hw_configs[]
Definition: qsvenc.c:2762
QSVEncContext::min_qp_i
int min_qp_i
Definition: qsvenc.h:277
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:657
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
ff_qsv_print_warning
int ff_qsv_print_warning(void *log_ctx, mfxStatus err, const char *warning_string)
Definition: qsv.c:198
AVFrameSideData::size
size_t size
Definition: frame.h:324
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:392
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:1316
QSVEncContext
Definition: qsvenc.h:155
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:681
QSV_HAVE_VCM
#define QSV_HAVE_VCM
Definition: qsvenc.h:49
av_memcpy_backptr
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:447
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:60
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:527
QSVEncContext::old_pic_timing_sei
int old_pic_timing_sei
Definition: qsvenc.h:316
QSVEncContext::old_int_ref_qp_delta
int old_int_ref_qp_delta
Definition: qsvenc.h:295
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:1235
QSVEncContext::skip_frame
int skip_frame
Definition: qsvenc.h:317
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
AVRegionOfInterest::bottom
int bottom
Definition: frame.h:408
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
AVDictionaryEntry::key
char * key
Definition: dict.h:91
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:217
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:2271
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:42
QSVEncContext::old_framerate
AVRational old_framerate
Definition: qsvenc.h:309
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
QSVEncContext::max_frame_size_p
int max_frame_size_p
Definition: qsvenc.h:227
QSVEncContext::nb_extparam_str
int nb_extparam_str
Definition: qsvenc.h:198
QSVEncContext::nb_extparam_internal
int nb_extparam_internal
Definition: qsvenc.h:195
QSVEncContext::pic_timing_sei
int pic_timing_sei
Definition: qsvenc.h:219
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:707
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:410
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1288
av_usleep
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:84
av_mallocz
#define av_mallocz(s)
Definition: tableprint_vlc.h:31
QSVEncContext::forced_idr
int forced_idr
Definition: qsvenc.h:267
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:639
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:282
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:77
tmp
static uint8_t tmp[40]
Definition: aes_ctr.c:52
AVQSVContext::nb_ext_buffers
int nb_ext_buffers
Definition: qsv.h:52
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:453
print_interlace_msg
static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2124
QSVEncContext::exthevctiles
mfxExtHEVCTiles exthevctiles
Definition: qsvenc.h:177
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:1109
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:2239
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1273
QSVFrame
Definition: qsv_internal.h:79
QSVEncContext::int_ref_cycle_size
int int_ref_cycle_size
Definition: qsvenc.h:250
QSVEncContext::opaque_surfaces
mfxFrameSurface1 ** opaque_surfaces
Definition: qsvenc.h:188
QSVEncContext::dual_gfx
int dual_gfx
Definition: qsvenc.h:319
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:681
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:275
QSVEncContext::req
mfxFrameAllocRequest req
Definition: qsvenc.h:168
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:222
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:493
init_video_param
static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:774
av_fallthrough
#define av_fallthrough
Definition: attributes.h:67
QSVEncContext::max_dec_frame_buffering
int max_dec_frame_buffering
Definition: qsvenc.h:238
AVRegionOfInterest::self_size
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
Definition: frame.h:397
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:278
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:289
get_free_frame
static int get_free_frame(QSVEncContext *q, QSVFrame **f)
Definition: qsvenc.c:1885
ff_qsv_print_iopattern
int ff_qsv_print_iopattern(void *log_ctx, int mfx_iopattern, const char *extra_string)
Definition: qsv.c:104
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:2386
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
AVCodecContext::trellis
int trellis
trellis RD quantization
Definition: avcodec.h:1323
update_low_delay_brc
static int update_low_delay_brc(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2364
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:1852
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:491
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1646
QSVEncContext::mbbrc
int mbbrc
Definition: qsvenc.h:241
qsv_retrieve_enc_av1_params
static int qsv_retrieve_enc_av1_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1371
FrameInfo
Definition: af_amix.c:56
QSVPacket::pkt
AVPacket pkt
Definition: qsvenc.c:93
QSVEncContext::preset
int preset
Definition: qsvenc.h:216
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:47
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:547
QSVEncContext::min_qp_p
int min_qp_p
Definition: qsvenc.h:279
f
f
Definition: af_crystalizer.c:122
HW_CONFIG_ENCODER_DEVICE
#define HW_CONFIG_ENCODER_DEVICE(format, device_type_)
Definition: hwconfig.h:95
QSVEncContext::extmfp
mfxExtMultiFrameParam extmfp
Definition: qsvenc.h:174
AVPacket::size
int size
Definition: packet.h:604
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1021
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:278
profile_names
Definition: qsvenc.c:45
AV_PIX_FMT_P012
#define AV_PIX_FMT_P012
Definition: pixfmt.h:603
set_skip_frame_encode_ctrl
static void set_skip_frame_encode_ctrl(AVCodecContext *avctx, const AVFrame *frame, mfxEncodeCtrl *enc_ctrl)
Definition: qsvenc.c:2197
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:711
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
QSVEncContext::avbr_convergence
int avbr_convergence
Definition: qsvenc.h:218
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:313
QSVEncContext::opaque_alloc_buf
AVBufferRef * opaque_alloc_buf
Definition: qsvenc.h:189
QSVEncContext::min_qp_b
int min_qp_b
Definition: qsvenc.h:281
QSVEncContext::old_min_qp_b
int old_min_qp_b
Definition: qsvenc.h:305
QSVEncContext::extco2
mfxExtCodingOption2 extco2
Definition: qsvenc.h:171
rc_names
static const struct @251 rc_names[]
QSVEncContext::max_qp_b
int max_qp_b
Definition: qsvenc.h:280
AVFrameSideData::data
uint8_t * data
Definition: frame.h:323
QSVEncContext::old_low_delay_brc
int old_low_delay_brc
Definition: qsvenc.h:307
QSVEncContext::co2_idx
int co2_idx
Definition: qsvenc.h:270
qsv_init_opaque_alloc
static int qsv_init_opaque_alloc(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1553
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:553
AVCodecHWConfigInternal
Definition: hwconfig.h:25
AV_PICTURE_TYPE_NONE
@ AV_PICTURE_TYPE_NONE
Undefined.
Definition: avutil.h:277
AVCPBProperties::min_bitrate
int64_t min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: defs.h:292
QSVEncContext::qsv_params
AVDictionary * qsv_params
Definition: qsvenc.h:321
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:602
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:609
QSVEncContext::max_slice_size
int max_slice_size
Definition: qsvenc.h:228
QSVEncContext::max_frame_size_i
int max_frame_size_i
Definition: qsvenc.h:226
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:297
AVRegionOfInterest::right
int right
Definition: frame.h:410
QSVEncContext::mfmode
int mfmode
Definition: qsvenc.h:263
QSVEncContext::exthypermodeparam_idx
int exthypermodeparam_idx
Definition: qsvenc.h:273
QSVEncContext::work_frames
QSVFrame * work_frames
Definition: qsvenc.h:158
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:790
QSVFramesContext::mids
QSVMid * mids
The memory ids for the external frames.
Definition: qsv_internal.h:124
QSVEncContext::old_i_quant_offset
float old_i_quant_offset
Definition: qsvenc.h:285
av_refstruct_unref
void av_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
QSVEncContext::bitrate_limit
int bitrate_limit
Definition: qsvenc.h:240
QSVEncContext::rdo
int rdo
Definition: qsvenc.h:224
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:215
QSVEncContext::opaque_alloc
mfxExtOpaqueSurfaceAlloc opaque_alloc
Definition: qsvenc.h:187
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:57
QSVEncContext::single_sei_nal_unit
int single_sei_nal_unit
Definition: qsvenc.h:237
QSVEncContext::dblk_idc
int dblk_idc
Definition: qsvenc.h:229
AVRegionOfInterest::left
int left
Definition: frame.h:409
hwcontext_qsv.h
ff_qsv_map_pixfmt
int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc, uint16_t *shift)
Definition: qsv.c:228
ff_qsv_enc_close
int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2710
QSVEncContext::set_encode_ctrl_cb
SetEncodeCtrlCB * set_encode_ctrl_cb
Definition: qsvenc.h:266
log.h
av_malloc
#define av_malloc(s)
Definition: ops_asmgen.c:44
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:596
UPDATE_PARAM
#define UPDATE_PARAM(a, b)
Definition: qsvenc.c:163
AVCodecContext::extradata
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition: avcodec.h:526
QSVEncContext::internal_qs
QSVSession internal_qs
Definition: qsvenc.h:161
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:407
is_strict_gop
static int is_strict_gop(QSVEncContext *q)
Definition: qsvenc.c:701
QSVEncContext::old_bit_rate
int old_bit_rate
Definition: qsvenc.h:311
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
common.h
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:287
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:223
QSVEncContext::extco3
mfxExtCodingOption3 extco3
Definition: qsvenc.h:172
QSVEncContext::extparam
mfxExtBuffer ** extparam
Definition: qsvenc.h:200
QSVEncContext::async_depth
int async_depth
Definition: qsvenc.h:212
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:496
QSV_HAVE_HE
#define QSV_HAVE_HE
Definition: qsvenc.h:51
AV_PIX_FMT_X2RGB10
#define AV_PIX_FMT_X2RGB10
Definition: pixfmt.h:613
submit_frame
static int submit_frame(QSVEncContext *q, const AVFrame *frame, QSVFrame **new_frame)
Definition: qsvenc.c:2036
QSVEncContext::cavlc
int cavlc
Definition: qsvenc.h:247
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:1493
profile
int profile
Definition: mxfenc.c:2299
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:703
clear_unused_frames
static void clear_unused_frames(QSVEncContext *q)
Definition: qsvenc.c:1866
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:604
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:643
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:689
update_qp
static int update_qp(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2210
QSVEncContext::old_qmax
int old_qmax
Definition: qsvenc.h:298
QSVEncContext::aud
int aud
Definition: qsvenc.h:235
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:1471
avcodec.h
QSVEncContext::int_ref_type
int int_ref_type
Definition: qsvenc.h:249
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:118
QSVEncContext::old_min_qp_i
int old_min_qp_i
Definition: qsvenc.h:301
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:332
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:278
QSVEncContext::look_ahead
int look_ahead
Definition: qsvenc.h:220
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:265
AVCPBProperties::buffer_size
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: defs.h:303
UNMATCH
#define UNMATCH(x)
AVHWFramesContext::hwctx
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:153
ff_qsv_codec_id_to_mfx
int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)
Definition: qsv.c:54
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1375
dict.h
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:203
update_bitrate
static int update_bitrate(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2410
QSVEncContext::co3_idx
int co3_idx
Definition: qsvenc.h:271
QSVEncContext::extparam_internal
mfxExtBuffer * extparam_internal[5+(QSV_HAVE_MF *2)+(QSV_HAVE_EXT_AV1_PARAM *2)+QSV_HAVE_HE]
Definition: qsvenc.h:194
QSVEncContext::int_ref_cycle_dist
int int_ref_cycle_dist
Definition: qsvenc.h:252
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:376
AVCodecContext
main external API structure.
Definition: avcodec.h:443
AVFrame::height
int height
Definition: frame.h:538
QSVEncContext::b_strategy
int b_strategy
Definition: qsvenc.h:245
QSVEncContext::old_b_quant_factor
float old_b_quant_factor
Definition: qsvenc.h:286
encode_frame
static int encode_frame(AVCodecContext *avctx, QSVEncContext *q, const AVFrame *frame)
Definition: qsvenc.c:2462
QSVEncContext::gpb
int gpb
Definition: qsvenc.h:257
QSVEncContext::vcm
int vcm
Definition: qsvenc.h:223
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:280
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1252
AVRational::den
int den
Denominator.
Definition: rational.h:60
QSVEncContext::idr_interval
int idr_interval
Definition: qsvenc.h:213
QSVEncContext::old_rc_max_rate
int old_rc_max_rate
Definition: qsvenc.h:314
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:813
AV_CODEC_ID_H265
#define AV_CODEC_ID_H265
Definition: codec_id.h:224
profiles
static const AVProfile profiles[]
Definition: libfdk-aacenc.c:557
qsvenc_get_continuous_buffer
static int qsvenc_get_continuous_buffer(AVFrame *frame)
Definition: qsvenc.c:1981
QSVEncContext::ver
mfxVersion ver
Definition: qsvenc.h:207
QSVEncContext::session
mfxSession session
Definition: qsvenc.h:160
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:602
AVQSVFramesContext
This struct is allocated as AVHWFramesContext.hwctx.
Definition: hwcontext_qsv.h:53
desc
const char * desc
Definition: libsvtav1.c:83
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:279
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:781
ff_qsv_enc_init
int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1637
QSVEncContext::old_qmin
int old_qmin
Definition: qsvenc.h:299
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:321
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:303
AVQSVContext::opaque_alloc
int opaque_alloc
Encoding only.
Definition: qsv.h:67
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:90
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecContext::slices
int slices
Number of slices.
Definition: avcodec.h:1037
AVPacket
This structure stores compressed data.
Definition: packet.h:580
QSVEncContext::extvp9param
mfxExtVP9Param extvp9param
Definition: qsvenc.h:178
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
QSVEncContext::low_delay_brc
int low_delay_brc
Definition: qsvenc.h:268
QSVEncContext::transform_skip
int transform_skip
Definition: qsvenc.h:258
FFMAX3
#define FFMAX3(a, b, c)
Definition: macros.h:48
QSVEncContext::width_align
int width_align
Definition: qsvenc.h:164
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:604
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:230
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_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:941
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:1297
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:650
AVDictionaryEntry::value
char * value
Definition: dict.h:92
avc_profiles
static const struct profile_names avc_profiles[]
Definition: qsvenc.c:50
pkt
static AVPacket * pkt
Definition: demux_decode.c:55
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:226
rc_mode
mfxU16 rc_mode
Definition: qsvenc.c:141
QSVEncContext::avctx
AVCodecContext * avctx
Definition: qsvenc.h:156
AV_PIX_FMT_VUYX
@ AV_PIX_FMT_VUYX
packed VUYX 4: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:284
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:52
ff_qsv_print_error
int ff_qsv_print_error(void *log_ctx, mfxStatus err, const char *error_string)
Definition: qsv.c:189
AVRegionOfInterest::qoffset
AVRational qoffset
Quantisation offset.
Definition: frame.h:434
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:681
QSVEncContext::tile_rows
int tile_rows
Definition: qsvenc.h:233
ff_qsv_encode
int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: qsvenc.c:2642
QSVEncContext::vp9_idx
int vp9_idx
Definition: qsvenc.h:274
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:628
QSVEncContext::old_max_qp_b
int old_max_qp_b
Definition: qsvenc.h:304
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:287
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:1922
AVCodecContext::compression_level
int compression_level
Definition: avcodec.h:1241
qsvenc_init_session
static int qsvenc_init_session(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1591
QSVEncContext::old_int_ref_cycle_dist
int old_int_ref_cycle_dist
Definition: qsvenc.h:296
QSVEncContext::low_power
int low_power
Definition: qsvenc.h:256
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:302
QSVPacket::bs
mfxBitstream * bs
Definition: qsvenc.c:95
Generated on Wed Jun 24 2026 19:22:53 for FFmpeg by   doxygen 1.8.17