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