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