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