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