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