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