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