FFmpeg
qsvenc.c
Go to the documentation of this file.
1 /*
2  * Intel MediaSDK QSV encoder utility functions
3  *
4  * copyright (c) 2013 Yukinori Yamazoe
5  * copyright (c) 2015 Anton Khirnov
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 #include "config_components.h"
25 
26 #include <string.h>
27 #include <sys/types.h>
28 #include <mfx/mfxvideo.h>
29 
30 #include "libavutil/common.h"
31 #include "libavutil/hwcontext.h"
33 #include "libavutil/mem.h"
34 #include "libavutil/log.h"
35 #include "libavutil/time.h"
36 #include "libavutil/imgutils.h"
37 #include "libavcodec/bytestream.h"
38 
39 #include "avcodec.h"
40 #include "internal.h"
41 #include "packet_internal.h"
42 #include "qsv.h"
43 #include "qsv_internal.h"
44 #include "qsvenc.h"
45 
46 struct profile_names {
47  mfxU16 profile;
48  const char *name;
49 };
50 
51 static const struct profile_names avc_profiles[] = {
52  { MFX_PROFILE_AVC_BASELINE, "avc baseline" },
53  { MFX_PROFILE_AVC_MAIN, "avc main" },
54  { MFX_PROFILE_AVC_EXTENDED, "avc extended" },
55  { MFX_PROFILE_AVC_HIGH, "avc high" },
56  { MFX_PROFILE_AVC_HIGH_422, "avc high 422" },
57  { MFX_PROFILE_AVC_CONSTRAINED_BASELINE, "avc constrained baseline" },
58  { MFX_PROFILE_AVC_CONSTRAINED_HIGH, "avc constrained high" },
59  { MFX_PROFILE_AVC_PROGRESSIVE_HIGH, "avc progressive high" },
60 };
61 
62 static const struct profile_names mpeg2_profiles[] = {
63  { MFX_PROFILE_MPEG2_SIMPLE, "mpeg2 simple" },
64  { MFX_PROFILE_MPEG2_MAIN, "mpeg2 main" },
65  { MFX_PROFILE_MPEG2_HIGH, "mpeg2 high" },
66 };
67 
68 static const struct profile_names hevc_profiles[] = {
69  { MFX_PROFILE_HEVC_MAIN, "hevc main" },
70  { MFX_PROFILE_HEVC_MAIN10, "hevc main10" },
71  { MFX_PROFILE_HEVC_MAINSP, "hevc mainsp" },
72  { MFX_PROFILE_HEVC_REXT, "hevc rext" },
73 #if QSV_VERSION_ATLEAST(1, 32)
74  { MFX_PROFILE_HEVC_SCC, "hevc scc" },
75 #endif
76 };
77 
78 static const struct profile_names vp9_profiles[] = {
79  { MFX_PROFILE_VP9_0, "vp9 0" },
80  { MFX_PROFILE_VP9_1, "vp9 1" },
81  { MFX_PROFILE_VP9_2, "vp9 2" },
82  { MFX_PROFILE_VP9_3, "vp9 3" },
83 };
84 
85 typedef struct QSVPacket {
87  mfxSyncPoint *sync;
88  mfxBitstream *bs;
89 } QSVPacket;
90 
91 static const char *print_profile(enum AVCodecID codec_id, mfxU16 profile)
92 {
93  const struct profile_names *profiles;
94  int i, num_profiles;
95 
96  switch (codec_id) {
97  case AV_CODEC_ID_H264:
99  num_profiles = FF_ARRAY_ELEMS(avc_profiles);
100  break;
101 
104  num_profiles = FF_ARRAY_ELEMS(mpeg2_profiles);
105  break;
106 
107  case AV_CODEC_ID_HEVC:
109  num_profiles = FF_ARRAY_ELEMS(hevc_profiles);
110  break;
111 
112  case AV_CODEC_ID_VP9:
114  num_profiles = FF_ARRAY_ELEMS(vp9_profiles);
115  break;
116 
117  default:
118  return "unknown";
119  }
120 
121  for (i = 0; i < num_profiles; i++)
122  if (profile == profiles[i].profile)
123  return profiles[i].name;
124 
125  return "unknown";
126 }
127 
128 static const struct {
129  mfxU16 rc_mode;
130  const char *name;
131 } rc_names[] = {
132  { MFX_RATECONTROL_CBR, "CBR" },
133  { MFX_RATECONTROL_VBR, "VBR" },
134  { MFX_RATECONTROL_CQP, "CQP" },
135 #if QSV_HAVE_AVBR
136  { MFX_RATECONTROL_AVBR, "AVBR" },
137 #endif
138  { MFX_RATECONTROL_LA, "LA" },
139  { MFX_RATECONTROL_ICQ, "ICQ" },
140  { MFX_RATECONTROL_LA_ICQ, "LA_ICQ" },
141 #if QSV_HAVE_VCM
142  { MFX_RATECONTROL_VCM, "VCM" },
143 #endif
144  { MFX_RATECONTROL_LA_EXT, "LA_EXT" },
145  { MFX_RATECONTROL_LA_HRD, "LA_HRD" },
146  { MFX_RATECONTROL_QVBR, "QVBR" },
147 };
148 
149 static const char *print_ratecontrol(mfxU16 rc_mode)
150 {
151  int i;
152  for (i = 0; i < FF_ARRAY_ELEMS(rc_names); i++)
153  if (rc_mode == rc_names[i].rc_mode)
154  return rc_names[i].name;
155  return "unknown";
156 }
157 
158 static const char *print_threestate(mfxU16 val)
159 {
160  if (val == MFX_CODINGOPTION_ON)
161  return "ON";
162  else if (val == MFX_CODINGOPTION_OFF)
163  return "OFF";
164  return "unknown";
165 }
166 
168  mfxExtBuffer **coding_opts)
169 {
170  mfxInfoMFX *info = &q->param.mfx;
171 
172  // co is always at index 1
173  mfxExtCodingOption *co = (mfxExtCodingOption*)coding_opts[1];
174  mfxExtCodingOption2 *co2 = NULL;
175  mfxExtCodingOption3 *co3 = NULL;
176  mfxExtHEVCTiles *exthevctiles = NULL;
177 
178  if (q->co2_idx > 0)
179  co2 = (mfxExtCodingOption2*)coding_opts[q->co2_idx];
180 
181  if (q->co3_idx > 0)
182  co3 = (mfxExtCodingOption3*)coding_opts[q->co3_idx];
183 
184  if (q->exthevctiles_idx > 0)
185  exthevctiles = (mfxExtHEVCTiles *)coding_opts[q->exthevctiles_idx];
186 
187  av_log(avctx, AV_LOG_VERBOSE, "profile: %s; level: %"PRIu16"\n",
188  print_profile(avctx->codec_id, info->CodecProfile), info->CodecLevel);
189 
190  av_log(avctx, AV_LOG_VERBOSE, "GopPicSize: %"PRIu16"; GopRefDist: %"PRIu16"; GopOptFlag: ",
191  info->GopPicSize, info->GopRefDist);
192  if (info->GopOptFlag & MFX_GOP_CLOSED)
193  av_log(avctx, AV_LOG_VERBOSE, "closed ");
194  if (info->GopOptFlag & MFX_GOP_STRICT)
195  av_log(avctx, AV_LOG_VERBOSE, "strict ");
196  av_log(avctx, AV_LOG_VERBOSE, "; IdrInterval: %"PRIu16"\n", info->IdrInterval);
197 
198  av_log(avctx, AV_LOG_VERBOSE, "TargetUsage: %"PRIu16"; RateControlMethod: %s\n",
199  info->TargetUsage, print_ratecontrol(info->RateControlMethod));
200 
201  if (info->RateControlMethod == MFX_RATECONTROL_CBR ||
202  info->RateControlMethod == MFX_RATECONTROL_VBR
203 #if QSV_HAVE_VCM
204  || info->RateControlMethod == MFX_RATECONTROL_VCM
205 #endif
206  ) {
207  av_log(avctx, AV_LOG_VERBOSE,
208  "BufferSizeInKB: %"PRIu16"; InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
209  info->BufferSizeInKB, info->InitialDelayInKB, info->TargetKbps, info->MaxKbps, info->BRCParamMultiplier);
210  } else if (info->RateControlMethod == MFX_RATECONTROL_CQP) {
211  av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",
212  info->QPI, info->QPP, info->QPB);
213  }
214 #if QSV_HAVE_AVBR
215  else if (info->RateControlMethod == MFX_RATECONTROL_AVBR) {
216  av_log(avctx, AV_LOG_VERBOSE,
217  "TargetKbps: %"PRIu16"; Accuracy: %"PRIu16"; Convergence: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
218  info->TargetKbps, info->Accuracy, info->Convergence, info->BRCParamMultiplier);
219  }
220 #endif
221  else if (info->RateControlMethod == MFX_RATECONTROL_LA
222  || info->RateControlMethod == MFX_RATECONTROL_LA_HRD
223  ) {
224  av_log(avctx, AV_LOG_VERBOSE,
225  "TargetKbps: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
226  info->TargetKbps, info->BRCParamMultiplier);
227  } else if (info->RateControlMethod == MFX_RATECONTROL_ICQ ||
228  info->RateControlMethod == MFX_RATECONTROL_LA_ICQ)
229  av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);
230  av_log(avctx, AV_LOG_VERBOSE, "NumSlice: %"PRIu16"; NumRefFrame: %"PRIu16"\n",
231  info->NumSlice, info->NumRefFrame);
232  av_log(avctx, AV_LOG_VERBOSE, "RateDistortionOpt: %s\n",
233  print_threestate(co->RateDistortionOpt));
234 
235  av_log(avctx, AV_LOG_VERBOSE, "RecoveryPointSEI: %s\n", print_threestate(co->RecoveryPointSEI));
236  av_log(avctx, AV_LOG_VERBOSE, "VDENC: %s\n", print_threestate(info->LowPower));
237 
238  if (avctx->codec_id == AV_CODEC_ID_H264) {
239  av_log(avctx, AV_LOG_VERBOSE, "Entropy coding: %s; MaxDecFrameBuffering: %"PRIu16"\n",
240  co->CAVLC == MFX_CODINGOPTION_ON ? "CAVLC" : "CABAC", co->MaxDecFrameBuffering);
241  av_log(avctx, AV_LOG_VERBOSE,
242  "NalHrdConformance: %s; SingleSeiNalUnit: %s; VuiVclHrdParameters: %s VuiNalHrdParameters: %s\n",
243  print_threestate(co->NalHrdConformance), print_threestate(co->SingleSeiNalUnit),
244  print_threestate(co->VuiVclHrdParameters), print_threestate(co->VuiNalHrdParameters));
245  } else if ((avctx->codec_id == AV_CODEC_ID_HEVC) && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 28)) {
246  av_log(avctx, AV_LOG_VERBOSE,
247  "NalHrdConformance: %s; VuiNalHrdParameters: %s\n",
248  print_threestate(co->NalHrdConformance), print_threestate(co->VuiNalHrdParameters));
249  }
250 
251  av_log(avctx, AV_LOG_VERBOSE, "FrameRateExtD: %"PRIu32"; FrameRateExtN: %"PRIu32" \n",
252  info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);
253 
254  if (co2) {
255  if ((info->RateControlMethod == MFX_RATECONTROL_VBR && q->extbrc && q->look_ahead_depth > 0) ||
256  (info->RateControlMethod == MFX_RATECONTROL_LA) ||
257  (info->RateControlMethod == MFX_RATECONTROL_LA_HRD) ||
258  (info->RateControlMethod == MFX_RATECONTROL_LA_ICQ))
259  av_log(avctx, AV_LOG_VERBOSE, "LookAheadDepth: %"PRIu16"\n", co2->LookAheadDepth);
260 
261  av_log(avctx, AV_LOG_VERBOSE, "IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16"; IntRefQPDelta: %"PRId16"\n",
262  co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);
263 
264  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %d; ", co2->MaxFrameSize);
265  av_log(avctx, AV_LOG_VERBOSE, "MaxSliceSize: %d; ", co2->MaxSliceSize);
266  av_log(avctx, AV_LOG_VERBOSE, "\n");
267 
268  av_log(avctx, AV_LOG_VERBOSE,
269  "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
270  print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),
271  print_threestate(co2->ExtBRC));
272 
273  av_log(avctx, AV_LOG_VERBOSE, "Trellis: ");
274  if (co2->Trellis & MFX_TRELLIS_OFF) {
275  av_log(avctx, AV_LOG_VERBOSE, "off");
276  } else if (!co2->Trellis) {
277  av_log(avctx, AV_LOG_VERBOSE, "auto");
278  } else {
279  if (co2->Trellis & MFX_TRELLIS_I) av_log(avctx, AV_LOG_VERBOSE, "I");
280  if (co2->Trellis & MFX_TRELLIS_P) av_log(avctx, AV_LOG_VERBOSE, "P");
281  if (co2->Trellis & MFX_TRELLIS_B) av_log(avctx, AV_LOG_VERBOSE, "B");
282  }
283  av_log(avctx, AV_LOG_VERBOSE, "\n");
284 
285  av_log(avctx, AV_LOG_VERBOSE,
286  "RepeatPPS: %s; NumMbPerSlice: %"PRIu16"; LookAheadDS: ",
287  print_threestate(co2->RepeatPPS), co2->NumMbPerSlice);
288  switch (co2->LookAheadDS) {
289  case MFX_LOOKAHEAD_DS_OFF: av_log(avctx, AV_LOG_VERBOSE, "off"); break;
290  case MFX_LOOKAHEAD_DS_2x: av_log(avctx, AV_LOG_VERBOSE, "2x"); break;
291  case MFX_LOOKAHEAD_DS_4x: av_log(avctx, AV_LOG_VERBOSE, "4x"); break;
292  default: av_log(avctx, AV_LOG_VERBOSE, "unknown"); break;
293  }
294  av_log(avctx, AV_LOG_VERBOSE, "\n");
295 
296  av_log(avctx, AV_LOG_VERBOSE, "AdaptiveI: %s; AdaptiveB: %s; BRefType: ",
297  print_threestate(co2->AdaptiveI), print_threestate(co2->AdaptiveB));
298  switch (co2->BRefType) {
299  case MFX_B_REF_OFF: av_log(avctx, AV_LOG_VERBOSE, "off"); break;
300  case MFX_B_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "pyramid"); break;
301  default: av_log(avctx, AV_LOG_VERBOSE, "auto"); break;
302  }
303 
304  av_log(avctx, AV_LOG_VERBOSE,
305  "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",
306  co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
307  av_log(avctx, AV_LOG_VERBOSE, "DisableDeblockingIdc: %"PRIu32" \n", co2->DisableDeblockingIdc);
308  }
309 
310  if (co3) {
311  if (info->RateControlMethod == MFX_RATECONTROL_QVBR)
312  av_log(avctx, AV_LOG_VERBOSE, "QVBRQuality: %"PRIu16"\n", co3->QVBRQuality);
313 
314  av_log(avctx, AV_LOG_VERBOSE, "PRefType: ");
315  switch (co3->PRefType) {
316  case MFX_P_REF_DEFAULT: av_log(avctx, AV_LOG_VERBOSE, "default"); break;
317  case MFX_P_REF_SIMPLE: av_log(avctx, AV_LOG_VERBOSE, "simple"); break;
318  case MFX_P_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "pyramid"); break;
319  default: av_log(avctx, AV_LOG_VERBOSE, "unknown"); break;
320  }
321  av_log(avctx, AV_LOG_VERBOSE, "\n");
322 
323  if (avctx->codec_id == AV_CODEC_ID_HEVC)
324  av_log(avctx, AV_LOG_VERBOSE,"GPB: %s\n", print_threestate(co3->GPB));
325 
326  av_log(avctx, AV_LOG_VERBOSE, "TransformSkip: %s \n", print_threestate(co3->TransformSkip));
327  av_log(avctx, AV_LOG_VERBOSE, "IntRefCycleDist: %"PRId16"\n", co3->IntRefCycleDist);
328  av_log(avctx, AV_LOG_VERBOSE, "LowDelayBRC: %s\n", print_threestate(co3->LowDelayBRC));
329  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSizeI: %d; ", co3->MaxFrameSizeI);
330  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSizeP: %d\n", co3->MaxFrameSizeP);
331  }
332 
333  if (exthevctiles) {
334  av_log(avctx, AV_LOG_VERBOSE, "NumTileColumns: %"PRIu16"; NumTileRows: %"PRIu16"\n",
335  exthevctiles->NumTileColumns, exthevctiles->NumTileRows);
336  }
337 }
338 
340  mfxExtBuffer **coding_opts)
341 {
342  mfxInfoMFX *info = &q->param.mfx;
343  mfxExtVP9Param *vp9_param = NULL;
344  mfxExtCodingOption2 *co2 = NULL;
345 
346  if (q->vp9_idx >= 0)
347  vp9_param = (mfxExtVP9Param *)coding_opts[q->vp9_idx];
348 
349  if (q->co2_idx >= 0)
350  co2 = (mfxExtCodingOption2*)coding_opts[q->co2_idx];
351 
352  av_log(avctx, AV_LOG_VERBOSE, "profile: %s \n",
353  print_profile(avctx->codec_id, info->CodecProfile));
354 
355  av_log(avctx, AV_LOG_VERBOSE, "GopPicSize: %"PRIu16"; GopRefDist: %"PRIu16"; GopOptFlag: ",
356  info->GopPicSize, info->GopRefDist);
357  if (info->GopOptFlag & MFX_GOP_CLOSED)
358  av_log(avctx, AV_LOG_VERBOSE, "closed ");
359  if (info->GopOptFlag & MFX_GOP_STRICT)
360  av_log(avctx, AV_LOG_VERBOSE, "strict ");
361  av_log(avctx, AV_LOG_VERBOSE, "; IdrInterval: %"PRIu16"\n", info->IdrInterval);
362 
363  av_log(avctx, AV_LOG_VERBOSE, "TargetUsage: %"PRIu16"; RateControlMethod: %s\n",
364  info->TargetUsage, print_ratecontrol(info->RateControlMethod));
365 
366  if (info->RateControlMethod == MFX_RATECONTROL_CBR ||
367  info->RateControlMethod == MFX_RATECONTROL_VBR) {
368  av_log(avctx, AV_LOG_VERBOSE,
369  "BufferSizeInKB: %"PRIu16"; InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
370  info->BufferSizeInKB, info->InitialDelayInKB, info->TargetKbps, info->MaxKbps, info->BRCParamMultiplier);
371  } else if (info->RateControlMethod == MFX_RATECONTROL_CQP) {
372  av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",
373  info->QPI, info->QPP, info->QPB);
374  }
375  else if (info->RateControlMethod == MFX_RATECONTROL_ICQ) {
376  av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);
377  }
378  else {
379  av_log(avctx, AV_LOG_VERBOSE, "Unsupported ratecontrol method: %d \n", info->RateControlMethod);
380  }
381 
382  av_log(avctx, AV_LOG_VERBOSE, "NumRefFrame: %"PRIu16"\n", info->NumRefFrame);
383  av_log(avctx, AV_LOG_VERBOSE, "FrameRateExtD: %"PRIu32"; FrameRateExtN: %"PRIu32" \n",
384  info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);
385 
386  if (co2) {
387  av_log(avctx, AV_LOG_VERBOSE,
388  "IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16"; IntRefQPDelta: %"PRId16"\n",
389  co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);
390 
391  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %d; ", co2->MaxFrameSize);
392  av_log(avctx, AV_LOG_VERBOSE, "\n");
393 
394  av_log(avctx, AV_LOG_VERBOSE,
395  "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
396  print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),
397  print_threestate(co2->ExtBRC));
398 
399  av_log(avctx, AV_LOG_VERBOSE, "VDENC: %s\n", print_threestate(info->LowPower));
400 
401  av_log(avctx, AV_LOG_VERBOSE,
402  "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",
403  co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
404  }
405 
406  if (vp9_param) {
407  av_log(avctx, AV_LOG_VERBOSE, "WriteIVFHeaders: %s \n",
408  print_threestate(vp9_param->WriteIVFHeaders));
409  }
410 }
411 
413 {
414  mfxInfoMFX *info = &q->param.mfx;
415 
416  av_log(avctx, AV_LOG_VERBOSE, "Interleaved: %"PRIu16" \n", info->Interleaved);
417  av_log(avctx, AV_LOG_VERBOSE, "Quality: %"PRIu16" \n", info->Quality);
418  av_log(avctx, AV_LOG_VERBOSE, "RestartInterval: %"PRIu16" \n", info->RestartInterval);
419 
420  av_log(avctx, AV_LOG_VERBOSE, "FrameRateExtD: %"PRIu32"; FrameRateExtN: %"PRIu32" \n",
421  info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);
422 }
423 
425 {
426  const char *rc_desc;
427  mfxU16 rc_mode;
428 
429  int want_la = q->look_ahead;
430  int want_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
431  int want_vcm = q->vcm;
432 
433  if (want_vcm && !QSV_HAVE_VCM) {
434  av_log(avctx, AV_LOG_ERROR,
435  "VCM ratecontrol mode requested, but is not supported by this SDK version\n");
436  return AVERROR(ENOSYS);
437  }
438 
439  if (want_la + want_qscale + want_vcm > 1) {
440  av_log(avctx, AV_LOG_ERROR,
441  "More than one of: { constant qscale, lookahead, VCM } requested, "
442  "only one of them can be used at a time.\n");
443  return AVERROR(EINVAL);
444  }
445 
446  if (want_qscale) {
447  rc_mode = MFX_RATECONTROL_CQP;
448  rc_desc = "constant quantization parameter (CQP)";
449  }
450 #if QSV_HAVE_VCM
451  else if (want_vcm) {
452  rc_mode = MFX_RATECONTROL_VCM;
453  rc_desc = "video conferencing mode (VCM)";
454  }
455 #endif
456  else if (want_la) {
457  rc_mode = MFX_RATECONTROL_LA;
458  rc_desc = "VBR with lookahead (LA)";
459 
460  if (avctx->global_quality > 0) {
461  rc_mode = MFX_RATECONTROL_LA_ICQ;
462  rc_desc = "intelligent constant quality with lookahead (LA_ICQ)";
463  }
464  }
465  else if (avctx->global_quality > 0 && !avctx->rc_max_rate) {
466  rc_mode = MFX_RATECONTROL_ICQ;
467  rc_desc = "intelligent constant quality (ICQ)";
468  }
469  else if (avctx->rc_max_rate == avctx->bit_rate) {
470  rc_mode = MFX_RATECONTROL_CBR;
471  rc_desc = "constant bitrate (CBR)";
472  }
473 #if QSV_HAVE_AVBR
474  else if (!avctx->rc_max_rate) {
475  rc_mode = MFX_RATECONTROL_AVBR;
476  rc_desc = "average variable bitrate (AVBR)";
477  }
478 #endif
479  else if (avctx->global_quality > 0) {
480  rc_mode = MFX_RATECONTROL_QVBR;
481  rc_desc = "constant quality with VBR algorithm (QVBR)";
482  }
483  else {
484  rc_mode = MFX_RATECONTROL_VBR;
485  rc_desc = "variable bitrate (VBR)";
486  }
487 
488  q->param.mfx.RateControlMethod = rc_mode;
489  av_log(avctx, AV_LOG_VERBOSE, "Using the %s ratecontrol method\n", rc_desc);
490 
491  return 0;
492 }
493 
495 {
496  mfxVideoParam param_out = { .mfx.CodecId = q->param.mfx.CodecId };
497  mfxStatus ret;
498 
499 #define UNMATCH(x) (param_out.mfx.x != q->param.mfx.x)
500 
501  ret = MFXVideoENCODE_Query(q->session, &q->param, &param_out);
502 
503  if (ret < 0) {
504  if (UNMATCH(CodecId))
505  av_log(avctx, AV_LOG_ERROR, "Current codec type is unsupported\n");
506  if (UNMATCH(CodecProfile))
507  av_log(avctx, AV_LOG_ERROR, "Current profile is unsupported\n");
508  if (UNMATCH(RateControlMethod))
509  av_log(avctx, AV_LOG_ERROR, "Selected ratecontrol mode is unsupported\n");
510  if (UNMATCH(LowPower))
511  av_log(avctx, AV_LOG_ERROR, "Low power mode is unsupported\n");
512  if (UNMATCH(FrameInfo.FrameRateExtN) || UNMATCH(FrameInfo.FrameRateExtD))
513  av_log(avctx, AV_LOG_ERROR, "Current frame rate is unsupported\n");
514  if (UNMATCH(FrameInfo.PicStruct))
515  av_log(avctx, AV_LOG_ERROR, "Current picture structure is unsupported\n");
516  if (UNMATCH(FrameInfo.Width) || UNMATCH(FrameInfo.Height))
517  av_log(avctx, AV_LOG_ERROR, "Current resolution is unsupported\n");
518  if (UNMATCH(FrameInfo.FourCC))
519  av_log(avctx, AV_LOG_ERROR, "Current pixel format is unsupported\n");
520  return 0;
521  }
522  return 1;
523 }
524 
526 {
527  enum AVPixelFormat sw_format = avctx->pix_fmt == AV_PIX_FMT_QSV ?
528  avctx->sw_pix_fmt : avctx->pix_fmt;
529  const AVPixFmtDescriptor *desc;
530  int ret;
531 
533  if (ret < 0)
534  return AVERROR_BUG;
535  q->param.mfx.CodecId = ret;
536 
537  if (avctx->level > 0)
538  q->param.mfx.CodecLevel = avctx->level;
539  q->param.mfx.CodecProfile = q->profile;
540 
541  desc = av_pix_fmt_desc_get(sw_format);
542  if (!desc)
543  return AVERROR_BUG;
544 
545  ret = ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC);
546  if (ret < 0)
547  return AVERROR_BUG;
548 
549  q->param.mfx.FrameInfo.CropX = 0;
550  q->param.mfx.FrameInfo.CropY = 0;
551  q->param.mfx.FrameInfo.CropW = avctx->width;
552  q->param.mfx.FrameInfo.CropH = avctx->height;
553  q->param.mfx.FrameInfo.AspectRatioW = avctx->sample_aspect_ratio.num;
554  q->param.mfx.FrameInfo.AspectRatioH = avctx->sample_aspect_ratio.den;
555  q->param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420 +
556  !desc->log2_chroma_w + !desc->log2_chroma_h;
557  q->param.mfx.FrameInfo.BitDepthLuma = desc->comp[0].depth;
558  q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
559  q->param.mfx.FrameInfo.Shift = desc->comp[0].depth > 8;
560 
561  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, 16);
562  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, 16);
563 
564  if (avctx->hw_frames_ctx) {
565  AVHWFramesContext *frames_ctx = (AVHWFramesContext *)avctx->hw_frames_ctx->data;
566  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
567  q->param.mfx.FrameInfo.Width = frames_hwctx->surfaces[0].Info.Width;
568  q->param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;
569  }
570 
571  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
572  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
573  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
574  } else {
575  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
576  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
577  }
578 
579  q->param.mfx.Interleaved = 1;
580  q->param.mfx.Quality = av_clip(avctx->global_quality, 1, 100);
581  q->param.mfx.RestartInterval = 0;
582 
583  q->width_align = 16;
584  q->height_align = 16;
585 
586  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, q->width_align);
587  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, q->height_align);
588 
589  return 0;
590 }
591 
593 {
594  enum AVPixelFormat sw_format = avctx->pix_fmt == AV_PIX_FMT_QSV ?
595  avctx->sw_pix_fmt : avctx->pix_fmt;
596  const AVPixFmtDescriptor *desc;
597  float quant;
598  int target_bitrate_kbps, max_bitrate_kbps, brc_param_multiplier;
599  int buffer_size_in_kilobytes, initial_delay_in_kilobytes;
600  int ret;
601 
603  if (ret < 0)
604  return AVERROR_BUG;
605  q->param.mfx.CodecId = ret;
606 
607  if (avctx->level > 0)
608  q->param.mfx.CodecLevel = avctx->level;
609 
611  avctx->compression_level = q->preset;
612  } else if (avctx->compression_level >= 0) {
613  if (avctx->compression_level > MFX_TARGETUSAGE_BEST_SPEED) {
614  av_log(avctx, AV_LOG_WARNING, "Invalid compression level: "
615  "valid range is 0-%d, using %d instead\n",
616  MFX_TARGETUSAGE_BEST_SPEED, MFX_TARGETUSAGE_BEST_SPEED);
617  avctx->compression_level = MFX_TARGETUSAGE_BEST_SPEED;
618  }
619  }
620 
621  if (q->low_power == 1) {
622  q->param.mfx.LowPower = MFX_CODINGOPTION_ON;
623  } else if (q->low_power == -1)
624  q->param.mfx.LowPower = MFX_CODINGOPTION_UNKNOWN;
625  else
626  q->param.mfx.LowPower = MFX_CODINGOPTION_OFF;
627 
628  q->param.mfx.CodecProfile = q->profile;
629  q->param.mfx.TargetUsage = avctx->compression_level;
630  q->param.mfx.GopPicSize = FFMAX(0, avctx->gop_size);
631  q->param.mfx.GopRefDist = FFMAX(-1, avctx->max_b_frames) + 1;
632  q->param.mfx.GopOptFlag = avctx->flags & AV_CODEC_FLAG_CLOSED_GOP ?
633  MFX_GOP_CLOSED : MFX_GOP_STRICT;
634  q->param.mfx.IdrInterval = q->idr_interval;
635  q->param.mfx.NumSlice = avctx->slices;
636  q->param.mfx.NumRefFrame = FFMAX(0, avctx->refs);
637  q->param.mfx.EncodedOrder = 0;
638  q->param.mfx.BufferSizeInKB = 0;
639 
640  desc = av_pix_fmt_desc_get(sw_format);
641  if (!desc)
642  return AVERROR_BUG;
643 
644  ret = ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC);
645  if (ret < 0)
646  return AVERROR_BUG;
647 
648  q->param.mfx.FrameInfo.CropX = 0;
649  q->param.mfx.FrameInfo.CropY = 0;
650  q->param.mfx.FrameInfo.CropW = avctx->width;
651  q->param.mfx.FrameInfo.CropH = avctx->height;
652  q->param.mfx.FrameInfo.AspectRatioW = avctx->sample_aspect_ratio.num;
653  q->param.mfx.FrameInfo.AspectRatioH = avctx->sample_aspect_ratio.den;
654  q->param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420 +
655  !desc->log2_chroma_w + !desc->log2_chroma_h;
656  q->param.mfx.FrameInfo.BitDepthLuma = desc->comp[0].depth;
657  q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
658  q->param.mfx.FrameInfo.Shift = desc->comp[0].depth > 8;
659 
660  // If the minor version is greater than or equal to 19,
661  // then can use the same alignment settings as H.264 for HEVC
662  q->width_align = (avctx->codec_id != AV_CODEC_ID_HEVC ||
663  QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 19)) ? 16 : 32;
664  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, q->width_align);
665 
666  if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
667  // it is important that PicStruct be setup correctly from the
668  // start--otherwise, encoding doesn't work and results in a bunch
669  // of incompatible video parameter errors
670  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_FIELD_TFF;
671  // height alignment always must be 32 for interlaced video
672  q->height_align = 32;
673  } else {
674  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
675  // for progressive video, the height should be aligned to 16 for
676  // H.264. For HEVC, depending on the version of MFX, it should be
677  // either 32 or 16. The lower number is better if possible.
678  q->height_align = avctx->codec_id == AV_CODEC_ID_HEVC ? 32 : 16;
679  }
680  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, q->height_align);
681 
682  if (avctx->hw_frames_ctx) {
683  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
684  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
685  q->param.mfx.FrameInfo.Width = frames_hwctx->surfaces[0].Info.Width;
686  q->param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;
687  }
688 
689  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
690  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
691  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
692  } else {
693  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
694  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
695  }
696 
697  ret = select_rc_mode(avctx, q);
698  if (ret < 0)
699  return ret;
700 
701  //libmfx BRC parameters are 16 bits thus maybe overflow, then BRCParamMultiplier is needed
702  buffer_size_in_kilobytes = avctx->rc_buffer_size / 8000;
703  initial_delay_in_kilobytes = avctx->rc_initial_buffer_occupancy / 8000;
704  target_bitrate_kbps = avctx->bit_rate / 1000;
705  max_bitrate_kbps = avctx->rc_max_rate / 1000;
706  brc_param_multiplier = (FFMAX(FFMAX3(target_bitrate_kbps, max_bitrate_kbps, buffer_size_in_kilobytes),
707  initial_delay_in_kilobytes) + 0x10000) / 0x10000;
708 
709  switch (q->param.mfx.RateControlMethod) {
710  case MFX_RATECONTROL_CBR:
711  case MFX_RATECONTROL_VBR:
712  if (q->extbrc) {
713  q->extco2.LookAheadDepth = q->look_ahead_depth;
714  }
715 #if QSV_HAVE_VCM
716  case MFX_RATECONTROL_VCM:
717 #endif
718  case MFX_RATECONTROL_QVBR:
719  q->param.mfx.BufferSizeInKB = buffer_size_in_kilobytes / brc_param_multiplier;
720  q->param.mfx.InitialDelayInKB = initial_delay_in_kilobytes / brc_param_multiplier;
721  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
722  q->param.mfx.MaxKbps = max_bitrate_kbps / brc_param_multiplier;
723  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
724  if (q->param.mfx.RateControlMethod == MFX_RATECONTROL_QVBR)
725  q->extco3.QVBRQuality = av_clip(avctx->global_quality, 0, 51);
726  break;
727  case MFX_RATECONTROL_CQP:
728  quant = avctx->global_quality / FF_QP2LAMBDA;
729 
730  q->param.mfx.QPI = av_clip(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 0, 51);
731  q->param.mfx.QPP = av_clip(quant, 0, 51);
732  q->param.mfx.QPB = av_clip(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 0, 51);
733 
734  break;
735 #if QSV_HAVE_AVBR
736  case MFX_RATECONTROL_AVBR:
737  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
738  q->param.mfx.Convergence = q->avbr_convergence;
739  q->param.mfx.Accuracy = q->avbr_accuracy;
740  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
741  break;
742 #endif
743  case MFX_RATECONTROL_LA:
744  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
745  q->extco2.LookAheadDepth = q->look_ahead_depth;
746  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
747  break;
748  case MFX_RATECONTROL_LA_ICQ:
749  q->extco2.LookAheadDepth = q->look_ahead_depth;
750  case MFX_RATECONTROL_ICQ:
751  q->param.mfx.ICQQuality = av_clip(avctx->global_quality, 1, 51);
752  break;
753  }
754 
755  // The HEVC encoder plugin currently fails with some old libmfx version if coding options
756  // are provided. Can't find the extract libmfx version which fixed it, just enable it from
757  // V1.28 in order to keep compatibility security.
758  if (((avctx->codec_id != AV_CODEC_ID_HEVC) || QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 28))
759  && (avctx->codec_id != AV_CODEC_ID_VP9)) {
760  q->extco.Header.BufferId = MFX_EXTBUFF_CODING_OPTION;
761  q->extco.Header.BufferSz = sizeof(q->extco);
762 
763  q->extco.PicTimingSEI = q->pic_timing_sei ?
764  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;
765 
766  if (q->rdo >= 0)
767  q->extco.RateDistortionOpt = q->rdo > 0 ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
768 
769  if (avctx->codec_id == AV_CODEC_ID_H264) {
770  q->extco.CAVLC = q->cavlc ? MFX_CODINGOPTION_ON
771  : MFX_CODINGOPTION_UNKNOWN;
772 
774  q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?
775  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
776 
777  if (q->single_sei_nal_unit >= 0)
778  q->extco.SingleSeiNalUnit = q->single_sei_nal_unit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
779  if (q->recovery_point_sei >= 0)
780  q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
781  q->extco.MaxDecFrameBuffering = q->max_dec_frame_buffering;
782  q->extco.AUDelimiter = q->aud ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
783  } else if (avctx->codec_id == AV_CODEC_ID_HEVC) {
785  q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?
786  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
787 
788  if (q->recovery_point_sei >= 0)
789  q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
790 
791  q->extco.AUDelimiter = q->aud ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
792  }
793 
794  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco;
795 
796  if (avctx->codec_id == AV_CODEC_ID_H264) {
797  if (q->bitrate_limit >= 0)
798  q->extco2.BitrateLimit = q->bitrate_limit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
799 
800  if (avctx->trellis >= 0)
801  q->extco2.Trellis = (avctx->trellis == 0) ? MFX_TRELLIS_OFF : (MFX_TRELLIS_I | MFX_TRELLIS_P | MFX_TRELLIS_B);
802  else
803  q->extco2.Trellis = MFX_TRELLIS_UNKNOWN;
804 
805  q->extco2.LookAheadDS = q->look_ahead_downsampling;
806  q->extco2.RepeatPPS = q->repeat_pps ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
807 
808  if (q->adaptive_i >= 0)
809  q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
810  if (q->adaptive_b >= 0)
811  q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
812  }
813 
814  if (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_HEVC) {
815  if (q->extbrc >= 0)
816  q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
817  if (q->max_frame_size >= 0)
818  q->extco2.MaxFrameSize = q->max_frame_size;
819  if (q->int_ref_type >= 0)
820  q->extco2.IntRefType = q->int_ref_type;
821  if (q->int_ref_cycle_size >= 0)
822  q->extco2.IntRefCycleSize = q->int_ref_cycle_size;
823  if (q->int_ref_qp_delta != INT16_MIN)
824  q->extco2.IntRefQPDelta = q->int_ref_qp_delta;
825  if (q->max_slice_size >= 0)
826  q->extco2.MaxSliceSize = q->max_slice_size;
827  q->extco2.DisableDeblockingIdc = q->dblk_idc;
828 
829  if (q->b_strategy >= 0)
830  q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
831  if (avctx->qmin >= 0 && avctx->qmax >= 0 && avctx->qmin > avctx->qmax) {
832  av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are set but invalid, please make sure min <= max\n");
833  return AVERROR(EINVAL);
834  }
835  if (avctx->qmin >= 0) {
836  q->extco2.MinQPI = avctx->qmin > 51 ? 51 : avctx->qmin;
837  q->extco2.MinQPP = q->extco2.MinQPB = q->extco2.MinQPI;
838  }
839  if (avctx->qmax >= 0) {
840  q->extco2.MaxQPI = avctx->qmax > 51 ? 51 : avctx->qmax;
841  q->extco2.MaxQPP = q->extco2.MaxQPB = q->extco2.MaxQPI;
842  }
843  if (q->mbbrc >= 0)
844  q->extco2.MBBRC = q->mbbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
845 
846  q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
847  q->extco2.Header.BufferSz = sizeof(q->extco2);
848 
849  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
850  }
851 
852  if (avctx->codec_id == AV_CODEC_ID_H264) {
853 #if QSV_HAVE_MF
854  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 25)) {
855  q->extmfp.Header.BufferId = MFX_EXTBUFF_MULTI_FRAME_PARAM;
856  q->extmfp.Header.BufferSz = sizeof(q->extmfp);
857 
858  q->extmfp.MFMode = q->mfmode;
859  av_log(avctx,AV_LOG_VERBOSE,"MFMode:%d\n", q->extmfp.MFMode);
860  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extmfp;
861  }
862 #endif
863  }
864  q->extco3.Header.BufferId = MFX_EXTBUFF_CODING_OPTION3;
865  q->extco3.Header.BufferSz = sizeof(q->extco3);
866 
867  if (avctx->codec_id == AV_CODEC_ID_HEVC ||
868  avctx->codec_id == AV_CODEC_ID_H264) {
869  switch (q->p_strategy) {
870  case 0:
871  q->extco3.PRefType = MFX_P_REF_DEFAULT;
872  break;
873  case 1:
874  q->extco3.PRefType = MFX_P_REF_SIMPLE;
875  break;
876  case 2:
877  q->extco3.PRefType = MFX_P_REF_PYRAMID;
878  break;
879  default:
880  q->extco3.PRefType = MFX_P_REF_DEFAULT;
881  av_log(avctx, AV_LOG_WARNING,
882  "invalid p_strategy, set to default\n");
883  break;
884  }
885  if (q->extco3.PRefType == MFX_P_REF_PYRAMID &&
886  avctx->max_b_frames != 0) {
887  av_log(avctx, AV_LOG_WARNING,
888  "Please set max_b_frames(-bf) to 0 to enable P-pyramid\n");
889  }
890  if (q->int_ref_cycle_dist >= 0)
891  q->extco3.IntRefCycleDist = q->int_ref_cycle_dist;
892  if (q->low_delay_brc >= 0)
893  q->extco3.LowDelayBRC = q->low_delay_brc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
894  if (q->max_frame_size_i >= 0)
895  q->extco3.MaxFrameSizeI = q->max_frame_size_i;
896  if (q->max_frame_size_p >= 0)
897  q->extco3.MaxFrameSizeP = q->max_frame_size_p;
898  }
899 
900  if (avctx->codec_id == AV_CODEC_ID_HEVC) {
901  if (q->transform_skip >= 0)
902  q->extco3.TransformSkip = q->transform_skip ? MFX_CODINGOPTION_ON :
903  MFX_CODINGOPTION_OFF;
904  else
905  q->extco3.TransformSkip = MFX_CODINGOPTION_UNKNOWN;
906  q->extco3.GPB = q->gpb ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
907  }
908  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco3;
909  }
910 
911  if (avctx->codec_id == AV_CODEC_ID_VP9) {
912  q->extvp9param.Header.BufferId = MFX_EXTBUFF_VP9_PARAM;
913  q->extvp9param.Header.BufferSz = sizeof(q->extvp9param);
914  q->extvp9param.WriteIVFHeaders = MFX_CODINGOPTION_OFF;
915 #if QSV_HAVE_EXT_VP9_TILES
916  q->extvp9param.NumTileColumns = q->tile_cols;
917  q->extvp9param.NumTileRows = q->tile_rows;
918 #endif
919  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extvp9param;
920  }
921 
922  if (avctx->codec_id == AV_CODEC_ID_HEVC) {
923  q->exthevctiles.Header.BufferId = MFX_EXTBUFF_HEVC_TILES;
924  q->exthevctiles.Header.BufferSz = sizeof(q->exthevctiles);
925  q->exthevctiles.NumTileColumns = q->tile_cols;
926  q->exthevctiles.NumTileRows = q->tile_rows;
927  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->exthevctiles;
928  }
929 
930  q->extvsi.VideoFullRange = (avctx->color_range == AVCOL_RANGE_JPEG);
931  q->extvsi.ColourDescriptionPresent = 0;
932 
933  if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
934  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
935  avctx->colorspace != AVCOL_SPC_UNSPECIFIED) {
936  q->extvsi.ColourDescriptionPresent = 1;
937  q->extvsi.ColourPrimaries = avctx->color_primaries;
938  q->extvsi.TransferCharacteristics = avctx->color_trc;
939  q->extvsi.MatrixCoefficients = avctx->colorspace;
940  }
941 
942  if (q->extvsi.VideoFullRange || q->extvsi.ColourDescriptionPresent) {
943  q->extvsi.Header.BufferId = MFX_EXTBUFF_VIDEO_SIGNAL_INFO;
944  q->extvsi.Header.BufferSz = sizeof(q->extvsi);
945  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extvsi;
946  }
947 
948  if (!check_enc_param(avctx,q)) {
949  av_log(avctx, AV_LOG_ERROR,
950  "some encoding parameters are not supported by the QSV "
951  "runtime. Please double check the input parameters.\n");
952  return AVERROR(ENOSYS);
953  }
954 
955  return 0;
956 }
957 
959 {
960  int ret = 0;
961 
962  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
963  if (ret < 0)
964  return ff_qsv_print_error(avctx, ret,
965  "Error calling GetVideoParam");
966 
967  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
968 
969  // for qsv mjpeg the return value maybe 0 so alloc the buffer
970  if (q->packet_size == 0)
971  q->packet_size = q->param.mfx.FrameInfo.Height * q->param.mfx.FrameInfo.Width * 4;
972 
973  dump_video_mjpeg_param(avctx, q);
974 
975  return 0;
976 }
977 
979 {
980  int ret = 0;
981  mfxExtVP9Param vp9_extend_buf = {
982  .Header.BufferId = MFX_EXTBUFF_VP9_PARAM,
983  .Header.BufferSz = sizeof(vp9_extend_buf),
984  };
985 
986  mfxExtCodingOption2 co2 = {
987  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
988  .Header.BufferSz = sizeof(co2),
989  };
990 
991  mfxExtCodingOption3 co3 = {
992  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
993  .Header.BufferSz = sizeof(co3),
994  };
995 
996  mfxExtBuffer *ext_buffers[3];
997  int ext_buf_num = 0;
998 
999  q->co2_idx = q->co3_idx = q->vp9_idx = -1;
1000 
1001  // It is possible the runtime doesn't support the given ext buffer
1002  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 6)) {
1003  q->co2_idx = ext_buf_num;
1004  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;
1005  }
1006 
1007  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 11)) {
1008  q->co3_idx = ext_buf_num;
1009  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;
1010  }
1011 
1012  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 26)) {
1013  q->vp9_idx = ext_buf_num;
1014  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&vp9_extend_buf;
1015  }
1016 
1017  q->param.ExtParam = ext_buffers;
1018  q->param.NumExtParam = ext_buf_num;
1019 
1020  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
1021  if (ret < 0)
1022  return ff_qsv_print_error(avctx, ret,
1023  "Error calling GetVideoParam");
1024 
1025  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
1026 
1027  dump_video_vp9_param(avctx, q, ext_buffers);
1028 
1029  return 0;
1030 }
1031 
1033 {
1034  AVCPBProperties *cpb_props;
1035 
1036  uint8_t sps_buf[128];
1037  uint8_t pps_buf[128];
1038 
1039  mfxExtCodingOptionSPSPPS extradata = {
1040  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
1041  .Header.BufferSz = sizeof(extradata),
1042  .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),
1043  .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
1044  };
1045 
1046  mfxExtCodingOption co = {
1047  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
1048  .Header.BufferSz = sizeof(co),
1049  };
1050  mfxExtCodingOption2 co2 = {
1051  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
1052  .Header.BufferSz = sizeof(co2),
1053  };
1054  mfxExtCodingOption3 co3 = {
1055  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
1056  .Header.BufferSz = sizeof(co3),
1057  };
1058 
1059  uint8_t vps_buf[128];
1060  mfxExtCodingOptionVPS extradata_vps = {
1061  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_VPS,
1062  .Header.BufferSz = sizeof(extradata_vps),
1063  .VPSBuffer = vps_buf,
1064  .VPSBufSize = sizeof(vps_buf),
1065  };
1066 
1067  mfxExtHEVCTiles hevc_tile_buf = {
1068  .Header.BufferId = MFX_EXTBUFF_HEVC_TILES,
1069  .Header.BufferSz = sizeof(hevc_tile_buf),
1070  };
1071 
1072  mfxExtBuffer *ext_buffers[6];
1073 
1074  int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
1075  int ret, ext_buf_num = 0, extradata_offset = 0;
1076 
1077  q->co2_idx = q->co3_idx = q->exthevctiles_idx = -1;
1078  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata;
1079  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co;
1080 
1081  // It is possible the runtime doesn't support the given ext buffer
1082  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 6)) {
1083  q->co2_idx = ext_buf_num;
1084  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;
1085  }
1086 
1087  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 11)) {
1088  q->co3_idx = ext_buf_num;
1089  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;
1090  }
1091 
1092  q->hevc_vps = ((avctx->codec_id == AV_CODEC_ID_HEVC) && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 17));
1093  if (q->hevc_vps)
1094  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata_vps;
1095  if (avctx->codec_id == AV_CODEC_ID_HEVC && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 13)) {
1096  q->exthevctiles_idx = ext_buf_num;
1097  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&hevc_tile_buf;
1098  }
1099 
1100  q->param.ExtParam = ext_buffers;
1101  q->param.NumExtParam = ext_buf_num;
1102 
1103  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
1104  if (ret < 0)
1105  return ff_qsv_print_error(avctx, ret,
1106  "Error calling GetVideoParam");
1107 
1108  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
1109 
1110  if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)
1111  || (q->hevc_vps && !extradata_vps.VPSBufSize)
1112  ) {
1113  av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
1114  return AVERROR_UNKNOWN;
1115  }
1116 
1117  avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
1118  avctx->extradata_size += q->hevc_vps * extradata_vps.VPSBufSize;
1119 
1121  if (!avctx->extradata)
1122  return AVERROR(ENOMEM);
1123 
1124  if (q->hevc_vps) {
1125  memcpy(avctx->extradata, vps_buf, extradata_vps.VPSBufSize);
1126  extradata_offset += extradata_vps.VPSBufSize;
1127  }
1128 
1129  memcpy(avctx->extradata + extradata_offset, sps_buf, extradata.SPSBufSize);
1130  extradata_offset += extradata.SPSBufSize;
1131  if (need_pps) {
1132  memcpy(avctx->extradata + extradata_offset, pps_buf, extradata.PPSBufSize);
1133  extradata_offset += extradata.PPSBufSize;
1134  }
1135  memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1136 
1137  cpb_props = ff_add_cpb_side_data(avctx);
1138  if (!cpb_props)
1139  return AVERROR(ENOMEM);
1140  cpb_props->max_bitrate = avctx->rc_max_rate;
1141  cpb_props->min_bitrate = avctx->rc_min_rate;
1142  cpb_props->avg_bitrate = avctx->bit_rate;
1143  cpb_props->buffer_size = avctx->rc_buffer_size;
1144 
1145  dump_video_param(avctx, q, ext_buffers);
1146 
1147  return 0;
1148 }
1149 
1151 {
1152  AVQSVContext *qsv = avctx->hwaccel_context;
1153  mfxFrameSurface1 *surfaces;
1154  int nb_surfaces, i;
1155 
1156  nb_surfaces = qsv->nb_opaque_surfaces + q->req.NumFrameSuggested;
1157 
1158  q->opaque_alloc_buf = av_buffer_allocz(sizeof(*surfaces) * nb_surfaces);
1159  if (!q->opaque_alloc_buf)
1160  return AVERROR(ENOMEM);
1161 
1162  q->opaque_surfaces = av_malloc_array(nb_surfaces, sizeof(*q->opaque_surfaces));
1163  if (!q->opaque_surfaces)
1164  return AVERROR(ENOMEM);
1165 
1166  surfaces = (mfxFrameSurface1*)q->opaque_alloc_buf->data;
1167  for (i = 0; i < nb_surfaces; i++) {
1168  surfaces[i].Info = q->req.Info;
1169  q->opaque_surfaces[i] = surfaces + i;
1170  }
1171 
1172  q->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
1173  q->opaque_alloc.Header.BufferSz = sizeof(q->opaque_alloc);
1174  q->opaque_alloc.In.Surfaces = q->opaque_surfaces;
1175  q->opaque_alloc.In.NumSurface = nb_surfaces;
1176  q->opaque_alloc.In.Type = q->req.Type;
1177 
1178  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->opaque_alloc;
1179 
1180  qsv->nb_opaque_surfaces = nb_surfaces;
1182  qsv->opaque_alloc_type = q->req.Type;
1183 
1184  return 0;
1185 }
1186 
1188 {
1189  int ret;
1190 
1191  if (avctx->hwaccel_context) {
1192  AVQSVContext *qsv = avctx->hwaccel_context;
1193  q->session = qsv->session;
1194  } else if (avctx->hw_frames_ctx) {
1196  if (!q->frames_ctx.hw_frames_ctx)
1197  return AVERROR(ENOMEM);
1198 
1200  &q->frames_ctx, q->load_plugins,
1201  q->param.IOPattern == MFX_IOPATTERN_IN_OPAQUE_MEMORY,
1202  MFX_GPUCOPY_OFF);
1203  if (ret < 0) {
1205  return ret;
1206  }
1207 
1208  q->session = q->internal_qs.session;
1209  } else if (avctx->hw_device_ctx) {
1211  avctx->hw_device_ctx, q->load_plugins,
1212  MFX_GPUCOPY_OFF);
1213  if (ret < 0)
1214  return ret;
1215 
1216  q->session = q->internal_qs.session;
1217  } else {
1219  q->load_plugins, MFX_GPUCOPY_OFF);
1220  if (ret < 0)
1221  return ret;
1222 
1223  q->session = q->internal_qs.session;
1224  }
1225 
1226  return 0;
1227 }
1228 
1230 {
1231  int iopattern = 0;
1232  int opaque_alloc = 0;
1233  int ret;
1234 
1235  q->param.AsyncDepth = q->async_depth;
1236 
1237  q->async_fifo = av_fifo_alloc2(q->async_depth, sizeof(QSVPacket), 0);
1238  if (!q->async_fifo)
1239  return AVERROR(ENOMEM);
1240 
1241  if (avctx->hwaccel_context) {
1242  AVQSVContext *qsv = avctx->hwaccel_context;
1243 
1244  iopattern = qsv->iopattern;
1245  opaque_alloc = qsv->opaque_alloc;
1246  }
1247 
1248  if (avctx->hw_frames_ctx) {
1249  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1250  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
1251 
1252  if (!iopattern) {
1253  if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)
1254  iopattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
1255  else if (frames_hwctx->frame_type &
1256  (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
1257  iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
1258  }
1259  }
1260 
1261  if (!iopattern)
1262  iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
1263  q->param.IOPattern = iopattern;
1264  ff_qsv_print_iopattern(avctx, iopattern, "Encoder");
1265 
1266  ret = qsvenc_init_session(avctx, q);
1267  if (ret < 0)
1268  return ret;
1269 
1270  ret = MFXQueryVersion(q->session,&q->ver);
1271  if (ret < 0) {
1272  return ff_qsv_print_error(avctx, ret,
1273  "Error querying mfx version");
1274  }
1275 
1276  // in the mfxInfoMFX struct, JPEG is different from other codecs
1277  switch (avctx->codec_id) {
1278  case AV_CODEC_ID_MJPEG:
1279  ret = init_video_param_jpeg(avctx, q);
1280  break;
1281  default:
1282  ret = init_video_param(avctx, q);
1283  break;
1284  }
1285  if (ret < 0)
1286  return ret;
1287 
1288  if (avctx->hwaccel_context) {
1289  AVQSVContext *qsv = avctx->hwaccel_context;
1290  int i, j;
1291 
1293  sizeof(*q->extparam));
1294  if (!q->extparam)
1295  return AVERROR(ENOMEM);
1296 
1297  q->param.ExtParam = q->extparam;
1298  for (i = 0; i < qsv->nb_ext_buffers; i++)
1299  q->param.ExtParam[i] = qsv->ext_buffers[i];
1300  q->param.NumExtParam = qsv->nb_ext_buffers;
1301 
1302  for (i = 0; i < q->nb_extparam_internal; i++) {
1303  for (j = 0; j < qsv->nb_ext_buffers; j++) {
1304  if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)
1305  break;
1306  }
1307  if (j < qsv->nb_ext_buffers)
1308  continue;
1309 
1310  q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];
1311  }
1312  } else {
1313  q->param.ExtParam = q->extparam_internal;
1314  q->param.NumExtParam = q->nb_extparam_internal;
1315  }
1316 
1317  ret = MFXVideoENCODE_Query(q->session, &q->param, &q->param);
1318  if (ret == MFX_WRN_PARTIAL_ACCELERATION) {
1319  av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
1320  } else if (ret < 0) {
1321  return ff_qsv_print_error(avctx, ret,
1322  "Error querying encoder params");
1323  }
1324 
1325  ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
1326  if (ret < 0)
1327  return ff_qsv_print_error(avctx, ret,
1328  "Error querying (IOSurf) the encoding parameters");
1329 
1330  if (opaque_alloc) {
1331  ret = qsv_init_opaque_alloc(avctx, q);
1332  if (ret < 0)
1333  return ret;
1334  }
1335 
1336  ret = MFXVideoENCODE_Init(q->session, &q->param);
1337  if (ret < 0)
1338  return ff_qsv_print_error(avctx, ret,
1339  "Error initializing the encoder");
1340  else if (ret > 0)
1341  ff_qsv_print_warning(avctx, ret,
1342  "Warning in encoder initialization");
1343 
1344  switch (avctx->codec_id) {
1345  case AV_CODEC_ID_MJPEG:
1346  ret = qsv_retrieve_enc_jpeg_params(avctx, q);
1347  break;
1348  case AV_CODEC_ID_VP9:
1349  ret = qsv_retrieve_enc_vp9_params(avctx, q);
1350  break;
1351  default:
1352  ret = qsv_retrieve_enc_params(avctx, q);
1353  break;
1354  }
1355  if (ret < 0) {
1356  av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
1357  return ret;
1358  }
1359 
1360  q->avctx = avctx;
1361 
1362  return 0;
1363 }
1364 
1365 static void free_encoder_ctrl_payloads(mfxEncodeCtrl* enc_ctrl)
1366 {
1367  if (enc_ctrl) {
1368  int i;
1369  for (i = 0; i < enc_ctrl->NumPayload && i < QSV_MAX_ENC_PAYLOAD; i++) {
1370  av_freep(&enc_ctrl->Payload[i]);
1371  }
1372  enc_ctrl->NumPayload = 0;
1373  }
1374 }
1375 
1377 {
1378  QSVFrame *cur = q->work_frames;
1379  while (cur) {
1380  if (cur->used && !cur->surface.Data.Locked) {
1382  //do not reuse enc_ctrl from previous frame
1383  memset(&cur->enc_ctrl, 0, sizeof(cur->enc_ctrl));
1384  cur->enc_ctrl.Payload = cur->payloads;
1385  if (cur->frame->format == AV_PIX_FMT_QSV) {
1386  av_frame_unref(cur->frame);
1387  }
1388  cur->used = 0;
1389  }
1390  cur = cur->next;
1391  }
1392 }
1393 
1395 {
1396  QSVFrame *frame, **last;
1397 
1399 
1400  frame = q->work_frames;
1401  last = &q->work_frames;
1402  while (frame) {
1403  if (!frame->used) {
1404  *f = frame;
1405  frame->used = 1;
1406  return 0;
1407  }
1408 
1409  last = &frame->next;
1410  frame = frame->next;
1411  }
1412 
1413  frame = av_mallocz(sizeof(*frame));
1414  if (!frame)
1415  return AVERROR(ENOMEM);
1416  frame->frame = av_frame_alloc();
1417  if (!frame->frame) {
1418  av_freep(&frame);
1419  return AVERROR(ENOMEM);
1420  }
1421  frame->enc_ctrl.Payload = frame->payloads;
1422  *last = frame;
1423 
1424  *f = frame;
1425  frame->used = 1;
1426 
1427  return 0;
1428 }
1429 
1430 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
1431  QSVFrame **new_frame)
1432 {
1433  QSVFrame *qf;
1434  int ret;
1435 
1436  ret = get_free_frame(q, &qf);
1437  if (ret < 0)
1438  return ret;
1439 
1440  if (frame->format == AV_PIX_FMT_QSV) {
1441  ret = av_frame_ref(qf->frame, frame);
1442  if (ret < 0)
1443  return ret;
1444 
1445  qf->surface = *(mfxFrameSurface1*)qf->frame->data[3];
1446 
1447  if (q->frames_ctx.mids) {
1449  if (ret < 0)
1450  return ret;
1451 
1452  qf->surface.Data.MemId = &q->frames_ctx.mids[ret];
1453  }
1454  } else {
1455  /* make a copy if the input is not padded as libmfx requires */
1456  /* and to make allocation continious for data[0]/data[1] */
1457  if ((frame->height & 31 || frame->linesize[0] & (q->width_align - 1)) ||
1458  (frame->data[1] - frame->data[0] != frame->linesize[0] * FFALIGN(qf->frame->height, q->height_align))) {
1459  qf->frame->height = FFALIGN(frame->height, q->height_align);
1460  qf->frame->width = FFALIGN(frame->width, q->width_align);
1461 
1462  qf->frame->format = frame->format;
1463 
1464  if (!qf->frame->data[0]) {
1466  if (ret < 0)
1467  return ret;
1468  }
1469 
1470  qf->frame->height = frame->height;
1471  qf->frame->width = frame->width;
1472 
1473  ret = av_frame_copy(qf->frame, frame);
1474  if (ret < 0) {
1475  av_frame_unref(qf->frame);
1476  return ret;
1477  }
1478  } else {
1479  av_frame_unref(qf->frame);
1480  ret = av_frame_ref(qf->frame, frame);
1481  if (ret < 0)
1482  return ret;
1483  }
1484 
1485  qf->surface.Info = q->param.mfx.FrameInfo;
1486 
1487  qf->surface.Info.PicStruct =
1488  !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
1489  frame->top_field_first ? MFX_PICSTRUCT_FIELD_TFF :
1490  MFX_PICSTRUCT_FIELD_BFF;
1491  if (frame->repeat_pict == 1)
1492  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
1493  else if (frame->repeat_pict == 2)
1494  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
1495  else if (frame->repeat_pict == 4)
1496  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
1497 
1499  if (ret < 0) {
1500  av_log(q->avctx, AV_LOG_ERROR, "map frame to surface failed.\n");
1501  return ret;
1502  }
1503  }
1504  qf->surface.Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
1505 
1506  *new_frame = qf;
1507 
1508  return 0;
1509 }
1510 
1512 {
1513  if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
1514  if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
1515  q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
1516  q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
1517  av_log(avctx, AV_LOG_WARNING,
1518  "Interlaced coding is supported"
1519  " at Main/High Profile Level 2.2-4.0\n");
1520  }
1521 }
1522 
1524  const AVFrame *frame)
1525 {
1526  QSVPacket pkt = { { 0 } };
1527  mfxExtAVCEncodedFrameInfo *enc_info = NULL;
1528  mfxExtBuffer **enc_buf = NULL;
1529 
1530  mfxFrameSurface1 *surf = NULL;
1531  QSVFrame *qsv_frame = NULL;
1532  mfxEncodeCtrl* enc_ctrl = NULL;
1533  int ret;
1534 
1535  if (frame) {
1536  ret = submit_frame(q, frame, &qsv_frame);
1537  if (ret < 0) {
1538  av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
1539  return ret;
1540  }
1541  }
1542  if (qsv_frame) {
1543  surf = &qsv_frame->surface;
1544  enc_ctrl = &qsv_frame->enc_ctrl;
1545 
1546  if (frame->pict_type == AV_PICTURE_TYPE_I) {
1547  enc_ctrl->FrameType = MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF;
1548  if (q->forced_idr)
1549  enc_ctrl->FrameType |= MFX_FRAMETYPE_IDR;
1550  }
1551  }
1552 
1553  ret = av_new_packet(&pkt.pkt, q->packet_size);
1554  if (ret < 0) {
1555  av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
1556  return ret;
1557  }
1558 
1559  pkt.bs = av_mallocz(sizeof(*pkt.bs));
1560  if (!pkt.bs)
1561  goto nomem;
1562  pkt.bs->Data = pkt.pkt.data;
1563  pkt.bs->MaxLength = pkt.pkt.size;
1564 
1565  if (avctx->codec_id == AV_CODEC_ID_H264) {
1566  enc_info = av_mallocz(sizeof(*enc_info));
1567  if (!enc_info)
1568  goto nomem;
1569 
1570  enc_info->Header.BufferId = MFX_EXTBUFF_ENCODED_FRAME_INFO;
1571  enc_info->Header.BufferSz = sizeof (*enc_info);
1572  pkt.bs->NumExtParam = 1;
1573  enc_buf = av_mallocz(sizeof(mfxExtBuffer *));
1574  if (!enc_buf)
1575  goto nomem;
1576  enc_buf[0] = (mfxExtBuffer *)enc_info;
1577 
1578  pkt.bs->ExtParam = enc_buf;
1579  }
1580 
1581  if (q->set_encode_ctrl_cb) {
1582  q->set_encode_ctrl_cb(avctx, frame, &qsv_frame->enc_ctrl);
1583  }
1584 
1585  pkt.sync = av_mallocz(sizeof(*pkt.sync));
1586  if (!pkt.sync)
1587  goto nomem;
1588 
1589  do {
1590  ret = MFXVideoENCODE_EncodeFrameAsync(q->session, enc_ctrl, surf, pkt.bs, pkt.sync);
1591  if (ret == MFX_WRN_DEVICE_BUSY)
1592  av_usleep(500);
1593  } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_WRN_IN_EXECUTION);
1594 
1595  if (ret > 0)
1596  ff_qsv_print_warning(avctx, ret, "Warning during encoding");
1597 
1598  if (ret < 0) {
1599  ret = (ret == MFX_ERR_MORE_DATA) ?
1600  0 : ff_qsv_print_error(avctx, ret, "Error during encoding");
1601  goto free;
1602  }
1603 
1604  if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM && frame && frame->interlaced_frame)
1605  print_interlace_msg(avctx, q);
1606 
1607  ret = 0;
1608 
1609  if (*pkt.sync) {
1610  av_fifo_write(q->async_fifo, &pkt, 1);
1611  } else {
1612 free:
1613  av_freep(&pkt.sync);
1614  av_packet_unref(&pkt.pkt);
1615  av_freep(&pkt.bs);
1616  if (avctx->codec_id == AV_CODEC_ID_H264) {
1617  av_freep(&enc_info);
1618  av_freep(&enc_buf);
1619  }
1620  }
1621 
1622  return ret;
1623 nomem:
1624  ret = AVERROR(ENOMEM);
1625  goto free;
1626 }
1627 
1629  AVPacket *pkt, const AVFrame *frame, int *got_packet)
1630 {
1631  int ret;
1632 
1633  ret = encode_frame(avctx, q, frame);
1634  if (ret < 0)
1635  return ret;
1636 
1637  if ((av_fifo_can_read(q->async_fifo) >= q->async_depth) ||
1638  (!frame && av_fifo_can_read(q->async_fifo))) {
1639  QSVPacket qpkt;
1640  mfxExtAVCEncodedFrameInfo *enc_info;
1641  mfxExtBuffer **enc_buf;
1642  enum AVPictureType pict_type;
1643 
1644  av_fifo_read(q->async_fifo, &qpkt, 1);
1645 
1646  do {
1647  ret = MFXVideoCORE_SyncOperation(q->session, *qpkt.sync, 1000);
1648  } while (ret == MFX_WRN_IN_EXECUTION);
1649 
1650  qpkt.pkt.dts = av_rescale_q(qpkt.bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
1651  qpkt.pkt.pts = av_rescale_q(qpkt.bs->TimeStamp, (AVRational){1, 90000}, avctx->time_base);
1652  qpkt.pkt.size = qpkt.bs->DataLength;
1653 
1654  if (qpkt.bs->FrameType & MFX_FRAMETYPE_IDR || qpkt.bs->FrameType & MFX_FRAMETYPE_xIDR) {
1655  qpkt.pkt.flags |= AV_PKT_FLAG_KEY;
1656  pict_type = AV_PICTURE_TYPE_I;
1657  } else if (qpkt.bs->FrameType & MFX_FRAMETYPE_I || qpkt.bs->FrameType & MFX_FRAMETYPE_xI)
1658  pict_type = AV_PICTURE_TYPE_I;
1659  else if (qpkt.bs->FrameType & MFX_FRAMETYPE_P || qpkt.bs->FrameType & MFX_FRAMETYPE_xP)
1660  pict_type = AV_PICTURE_TYPE_P;
1661  else if (qpkt.bs->FrameType & MFX_FRAMETYPE_B || qpkt.bs->FrameType & MFX_FRAMETYPE_xB)
1662  pict_type = AV_PICTURE_TYPE_B;
1663  else if (qpkt.bs->FrameType == MFX_FRAMETYPE_UNKNOWN) {
1664  pict_type = AV_PICTURE_TYPE_NONE;
1665  av_log(avctx, AV_LOG_WARNING, "Unknown FrameType, set pict_type to AV_PICTURE_TYPE_NONE.\n");
1666  } else {
1667  av_log(avctx, AV_LOG_ERROR, "Invalid FrameType:%d.\n", qpkt.bs->FrameType);
1668  return AVERROR_INVALIDDATA;
1669  }
1670 
1671  if (avctx->codec_id == AV_CODEC_ID_H264) {
1672  enc_buf = qpkt.bs->ExtParam;
1673  enc_info = (mfxExtAVCEncodedFrameInfo *)(*enc_buf);
1675  enc_info->QP * FF_QP2LAMBDA, NULL, 0, pict_type);
1676  av_freep(&enc_info);
1677  av_freep(&enc_buf);
1678  }
1679  av_freep(&qpkt.bs);
1680  av_freep(&qpkt.sync);
1681 
1682  av_packet_move_ref(pkt, &qpkt.pkt);
1683 
1684  *got_packet = 1;
1685  }
1686 
1687  return 0;
1688 }
1689 
1691 {
1692  QSVFrame *cur;
1693 
1694  if (q->session)
1695  MFXVideoENCODE_Close(q->session);
1696 
1697  q->session = NULL;
1699 
1702 
1703  cur = q->work_frames;
1704  while (cur) {
1705  q->work_frames = cur->next;
1706  av_frame_free(&cur->frame);
1708  av_freep(&cur);
1709  cur = q->work_frames;
1710  }
1711 
1712  if (q->async_fifo) {
1713  QSVPacket pkt;
1714  while (av_fifo_read(q->async_fifo, &pkt, 1) >= 0) {
1715  if (avctx->codec_id == AV_CODEC_ID_H264) {
1716  mfxExtBuffer **enc_buf = pkt.bs->ExtParam;
1717  mfxExtAVCEncodedFrameInfo *enc_info = (mfxExtAVCEncodedFrameInfo *)(*enc_buf);
1718  av_freep(&enc_info);
1719  av_freep(&enc_buf);
1720  }
1721  av_freep(&pkt.sync);
1722  av_freep(&pkt.bs);
1723  av_packet_unref(&pkt.pkt);
1724  }
1726  }
1727 
1730 
1731  av_freep(&q->extparam);
1732 
1733  return 0;
1734 }
1735 
1737  HW_CONFIG_ENCODER_FRAMES(QSV, QSV),
1738  HW_CONFIG_ENCODER_DEVICE(NV12, QSV),
1739  HW_CONFIG_ENCODER_DEVICE(P010, QSV),
1740  NULL,
1741 };
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:422
AVCodecContext::hwaccel_context
void * hwaccel_context
Hardware accelerator context.
Definition: avcodec.h:1390
QSVEncContext::look_ahead_depth
int look_ahead_depth
Definition: qsvenc.h:160
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
dump_video_vp9_param
static void dump_video_vp9_param(AVCodecContext *avctx, QSVEncContext *q, mfxExtBuffer **coding_opts)
Definition: qsvenc.c:339
av_clip
#define av_clip
Definition: common.h:95
QSVEncContext::repeat_pps
int repeat_pps
Definition: qsvenc.h:193
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:966
qsv_retrieve_enc_vp9_params
static int qsv_retrieve_enc_vp9_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:978
QSVFramesContext::hw_frames_ctx
AVBufferRef * hw_frames_ctx
Definition: qsv_internal.h:102
av_frame_get_buffer
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:254
AVCodecContext::rc_min_rate
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:1221
QSVEncContext::p_strategy
int p_strategy
Definition: qsvenc.h:184
AVProfile::name
const char * name
short name for the profile
Definition: codec.h:190
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2662
ff_side_data_set_encoder_stats
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:602
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AVPictureType
AVPictureType
Definition: avutil.h:272
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:216
QSVEncContext::avbr_accuracy
int avbr_accuracy
Definition: qsvenc.h:156
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:111
QSVEncContext::extco
mfxExtCodingOption extco
Definition: qsvenc.h:122
ff_qsv_close_internal_session
int ff_qsv_close_internal_session(QSVSession *qs)
Definition: qsv.c:851
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:959
AVFrame::width
int width
Definition: frame.h:397
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:599
internal.h
QSVEncContext::adaptive_b
int adaptive_b
Definition: qsvenc.h:182
AVPacket::data
uint8_t * data
Definition: packet.h:374
QSVEncContext::max_frame_size
int max_frame_size
Definition: qsvenc.h:164
av_fifo_can_read
size_t av_fifo_can_read(const AVFifo *f)
Definition: fifo.c:87
QSVEncContext::tile_cols
int tile_cols
Definition: qsvenc.h:170
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:499
QSVEncContext::packet_size
int packet_size
Definition: qsvenc.h:115
ff_qsv_find_surface_idx
int ff_qsv_find_surface_idx(QSVFramesContext *ctx, QSVFrame *frame)
Definition: qsv.c:263
AVCodecContext::b_quant_offset
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:677
dump_video_mjpeg_param
static void dump_video_mjpeg_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:412
QSVEncContext::adaptive_i
int adaptive_i
Definition: qsvenc.h:181
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
QSVEncContext::int_ref_qp_delta
int int_ref_qp_delta
Definition: qsvenc.h:189
print_threestate
static const char * print_threestate(mfxU16 val)
Definition: qsvenc.c:158
av_fifo_read
int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)
Read data from a FIFO.
Definition: fifo.c:240
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:145
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
ff_add_cpb_side_data
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1025
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1185
AVQSVContext::opaque_alloc_type
int opaque_alloc_type
Encoding only, and only if opaque_alloc is set to non-zero.
Definition: qsv.h:97
FF_COMPRESSION_DEFAULT
#define FF_COMPRESSION_DEFAULT
Definition: avcodec.h:462
QSVEncContext::load_plugins
char * load_plugins
Definition: qsvenc.h:203
QSVFrame::frame
AVFrame * frame
Definition: qsv_internal.h:75
AVQSVContext::iopattern
int iopattern
The IO pattern to use.
Definition: qsv.h:46
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
QSVFrame::used
int used
Definition: qsv_internal.h:88
select_rc_mode
static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:424
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
QSVFrame::enc_ctrl
mfxEncodeCtrl enc_ctrl
Definition: qsv_internal.h:77
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:724
QSVEncContext::exthevctiles_idx
int exthevctiles_idx
Definition: qsvenc.h:210
QSVEncContext::extvsi
mfxExtVideoSignalInfo extvsi
Definition: qsvenc.h:136
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1733
QSVEncContext::recovery_point_sei
int recovery_point_sei
Definition: qsvenc.h:191
QSVEncContext::hevc_vps
int hevc_vps
Definition: qsvenc.h:149
ff_qsv_map_frame_to_surface
int ff_qsv_map_frame_to_surface(const AVFrame *frame, mfxFrameSurface1 *surface)
Definition: qsv.c:227
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:694
QSVEncContext::param
mfxVideoParam param
Definition: qsvenc.h:119
QSVEncContext::height_align
int height_align
Definition: qsvenc.h:117
QSVEncContext::profile
int profile
Definition: qsvenc.h:154
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:938
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:469
val
static double val(void *priv, double ch)
Definition: aeval.c:77
qsv_retrieve_enc_params
static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1032
AVRational::num
int num
Numerator.
Definition: rational.h:59
quant
static int quant(float coef, const float Q, const float rounding)
Quantize one coefficient.
Definition: aacenc_utils.h:59
qsv_internal.h
AV_CODEC_FLAG_INTERLACED_DCT
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:266
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:99
QSVEncContext::extbrc
int extbrc
Definition: qsvenc.h:180
ff_qsv_enc_hw_configs
const AVCodecHWConfigInternal *const ff_qsv_enc_hw_configs[]
Definition: qsvenc.c:1736
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:952
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
ff_qsv_print_warning
int ff_qsv_print_warning(void *log_ctx, mfxStatus err, const char *warning_string)
Definition: qsv.c:169
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
profile_names::name
const char * name
Definition: qsvenc.c:48
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:1242
QSVEncContext
Definition: qsvenc.h:107
QSV_HAVE_VCM
#define QSV_HAVE_VCM
Definition: qsvenc.h:46
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:491
qsvenc.h
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:97
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:455
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:218
QSV_RUNTIME_VERSION_ATLEAST
#define QSV_RUNTIME_VERSION_ATLEAST(MFX_VERSION, MAJOR, MINOR)
Definition: qsv_internal.h:61
info
MIPS optimizations info
Definition: mips.txt:2
QSVEncContext::max_frame_size_p
int max_frame_size_p
Definition: qsvenc.h:166
QSVEncContext::nb_extparam_internal
int nb_extparam_internal
Definition: qsvenc.h:139
QSVEncContext::pic_timing_sei
int pic_timing_sei
Definition: qsvenc.h:158
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:76
init_video_param_jpeg
static int init_video_param_jpeg(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:525
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:371
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1214
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:205
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:474
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:104
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:77
AVQSVContext::nb_ext_buffers
int nb_ext_buffers
Definition: qsv.h:52
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:399
print_interlace_msg
static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1511
QSVEncContext::exthevctiles
mfxExtHEVCTiles exthevctiles
Definition: qsvenc.h:129
rc_names
static const struct @115 rc_names[]
if
if(ret)
Definition: filter_design.txt:179
free_encoder_ctrl_payloads
static void free_encoder_ctrl_payloads(mfxEncodeCtrl *enc_ctrl)
Definition: qsvenc.c:1365
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:804
check_enc_param
static int check_enc_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:494
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1199
QSVFrame
Definition: qsv_internal.h:74
QSVEncContext::int_ref_cycle_size
int int_ref_cycle_size
Definition: qsvenc.h:188
QSVEncContext::opaque_surfaces
mfxFrameSurface1 ** opaque_surfaces
Definition: qsvenc.h:133
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:973
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
QSVEncContext::req
mfxFrameAllocRequest req
Definition: qsvenc.h:120
qsv.h
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
QSVEncContext::look_ahead_downsampling
int look_ahead_downsampling
Definition: qsvenc.h:161
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:439
init_video_param
static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:592
QSVEncContext::max_dec_frame_buffering
int max_dec_frame_buffering
Definition: qsvenc.h:176
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
QSVFrame::payloads
mfxPayload * payloads[QSV_MAX_ENC_PAYLOAD]
used for enc_ctrl.Payload
Definition: qsv_internal.h:85
get_free_frame
static int get_free_frame(QSVEncContext *q, QSVFrame **f)
Definition: qsvenc.c:1394
ff_qsv_print_iopattern
int ff_qsv_print_iopattern(void *log_ctx, int mfx_iopattern, const char *extra_string)
Definition: qsv.c:85
QSVFrame::surface
mfxFrameSurface1 surface
Definition: qsv_internal.h:76
print_profile
static const char * print_profile(enum AVCodecID codec_id, mfxU16 profile)
Definition: qsvenc.c:91
time.h
QSVFramesContext::mids_buf
AVBufferRef * mids_buf
Definition: qsv_internal.h:109
AVCodecContext::trellis
int trellis
trellis RD quantization
Definition: avcodec.h:1249
AV_PIX_FMT_QSV
@ AV_PIX_FMT_QSV
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
Definition: pixfmt.h:212
QSVEncContext::extparam_internal
mfxExtBuffer * extparam_internal[5+(QSV_HAVE_MF *2)]
Definition: qsvenc.h:138
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:479
AVCodecContext::level
int level
level
Definition: avcodec.h:1674
QSVEncContext::mbbrc
int mbbrc
Definition: qsvenc.h:179
FrameInfo
Definition: af_amix.c:57
QSVPacket::pkt
AVPacket pkt
Definition: qsvenc.c:86
QSVEncContext::preset
int preset
Definition: qsvenc.h:155
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:47
QSVPacket::sync
mfxSyncPoint * sync
Definition: qsvenc.c:87
ff_qsv_map_pixfmt
int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc)
Definition: qsv.c:194
AVQSVContext::opaque_surfaces
AVBufferRef * opaque_surfaces
Encoding only, and only if opaque_alloc is set to non-zero.
Definition: qsv.h:90
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:512
f
f
Definition: af_crystalizer.c:122
HW_CONFIG_ENCODER_DEVICE
#define HW_CONFIG_ENCODER_DEVICE(format, device_type_)
Definition: hwconfig.h:94
QSVEncContext::extmfp
mfxExtMultiFrameParam extmfp
Definition: qsvenc.h:126
AVPacket::size
int size
Definition: packet.h:375
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:584
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:343
profile_names
Definition: qsvenc.c:46
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:755
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
QSVEncContext::avbr_convergence
int avbr_convergence
Definition: qsvenc.h:157
AVQSVContext::session
mfxSession session
If non-NULL, the session to use for encoding or decoding.
Definition: qsv.h:41
QSVEncContext::opaque_alloc_buf
AVBufferRef * opaque_alloc_buf
Definition: qsvenc.h:134
QSVEncContext::extco2
mfxExtCodingOption2 extco2
Definition: qsvenc.h:123
QSVEncContext::co2_idx
int co2_idx
Definition: qsvenc.h:208
qsv_init_opaque_alloc
static int qsv_init_opaque_alloc(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1150
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:412
AVCodecHWConfigInternal
Definition: hwconfig.h:29
AV_PICTURE_TYPE_NONE
@ AV_PICTURE_TYPE_NONE
Undefined.
Definition: avutil.h:273
AVCPBProperties::min_bitrate
int64_t min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: defs.h:114
AVQSVContext::ext_buffers
mfxExtBuffer ** ext_buffers
Extra buffers to pass to encoder or decoder initialization.
Definition: qsv.h:51
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:373
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
QSVEncContext::max_slice_size
int max_slice_size
Definition: qsvenc.h:167
QSVEncContext::max_frame_size_i
int max_frame_size_i
Definition: qsvenc.h:165
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: defs.h:119
FF_COMPLIANCE_NORMAL
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:1303
QSVEncContext::mfmode
int mfmode
Definition: qsvenc.h:201
QSVEncContext::work_frames
QSVFrame * work_frames
Definition: qsvenc.h:110
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:670
QSVFramesContext::mids
QSVMid * mids
Definition: qsv_internal.h:110
QSVEncContext::bitrate_limit
int bitrate_limit
Definition: qsvenc.h:178
QSVEncContext::rdo
int rdo
Definition: qsvenc.h:163
QSVEncContext::opaque_alloc
mfxExtOpaqueSurfaceAlloc opaque_alloc
Definition: qsvenc.h:132
HW_CONFIG_ENCODER_FRAMES
#define HW_CONFIG_ENCODER_FRAMES(format, device_type_)
Definition: hwconfig.h:97
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:57
QSVEncContext::single_sei_nal_unit
int single_sei_nal_unit
Definition: qsvenc.h:175
QSVEncContext::dblk_idc
int dblk_idc
Definition: qsvenc.h:168
hwcontext_qsv.h
ff_qsv_enc_close
int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1690
QSVEncContext::set_encode_ctrl_cb
SetEncodeCtrlCB * set_encode_ctrl_cb
Definition: qsvenc.h:204
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:490
QSVEncContext::internal_qs
QSVSession internal_qs
Definition: qsvenc.h:113
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_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:109
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:224
QSVEncContext::extco3
mfxExtCodingOption3 extco3
Definition: qsvenc.h:124
QSVEncContext::extparam
mfxExtBuffer ** extparam
Definition: qsvenc.h:141
QSVEncContext::async_depth
int async_depth
Definition: qsvenc.h:152
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:477
submit_frame
static int submit_frame(QSVEncContext *q, const AVFrame *frame, QSVFrame **new_frame)
Definition: qsvenc.c:1430
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
av_fifo_freep2
void av_fifo_freep2(AVFifo **f)
Free an AVFifo and reset pointer to NULL.
Definition: fifo.c:286
QSVEncContext::cavlc
int cavlc
Definition: qsvenc.h:185
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:1931
profile
int profile
Definition: mxfenc.c:2005
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:528
clear_unused_frames
static void clear_unused_frames(QSVEncContext *q)
Definition: qsvenc.c:1376
dump_video_param
static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q, mfxExtBuffer **coding_opts)
Definition: qsvenc.c:167
AVCodecContext::height
int height
Definition: avcodec.h:562
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:599
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
QSVEncContext::aud
int aud
Definition: qsvenc.h:173
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:1881
avcodec.h
QSVEncContext::int_ref_type
int int_ref_type
Definition: qsvenc.h:187
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:124
profile_names::profile
mfxU16 profile
Definition: qsvenc.c:47
av_buffer_allocz
AVBufferRef * av_buffer_allocz(size_t size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:93
AV_CODEC_FLAG_CLOSED_GOP
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:288
ret
ret
Definition: filter_design.txt:187
print_ratecontrol
static const char * print_ratecontrol(mfxU16 rc_mode)
Definition: qsvenc.c:149
QSVEncContext::look_ahead
int look_ahead
Definition: qsvenc.h:159
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:125
UNMATCH
#define UNMATCH(x)
AVHWFramesContext::hwctx
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:162
ff_qsv_codec_id_to_mfx
int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)
Definition: qsv.c:43
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1300
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
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
QSVPacket
Definition: qsvenc.c:85
QSVEncContext::async_fifo
AVFifo * async_fifo
Definition: qsvenc.h:143
QSVEncContext::co3_idx
int co3_idx
Definition: qsvenc.h:209
QSVEncContext::int_ref_cycle_dist
int int_ref_cycle_dist
Definition: qsvenc.h:190
AVCodecContext
main external API structure.
Definition: avcodec.h:389
AVFrame::height
int height
Definition: frame.h:397
QSVEncContext::b_strategy
int b_strategy
Definition: qsvenc.h:183
encode_frame
static int encode_frame(AVCodecContext *avctx, QSVEncContext *q, const AVFrame *frame)
Definition: qsvenc.c:1523
QSVEncContext::gpb
int gpb
Definition: qsvenc.h:195
QSVEncContext::vcm
int vcm
Definition: qsvenc.h:162
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1178
AVRational::den
int den
Denominator.
Definition: rational.h:60
QSVEncContext::idr_interval
int idr_interval
Definition: qsvenc.h:153
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:94
AVCodecContext::i_quant_offset
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:701
profiles
static const AVProfile profiles[]
Definition: libfdk-aacenc.c:429
QSVEncContext::ver
mfxVersion ver
Definition: qsvenc.h:147
QSVEncContext::session
mfxSession session
Definition: qsvenc.h:112
AVQSVFramesContext
This struct is allocated as AVHWFramesContext.hwctx.
Definition: hwcontext_qsv.h:42
desc
const char * desc
Definition: libsvtav1.c:83
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
QSV_MAX_ENC_PAYLOAD
#define QSV_MAX_ENC_PAYLOAD
Definition: qsv_internal.h:53
mem.h
AVCodecContext::max_b_frames
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:661
ff_qsv_enc_init
int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1229
packet_internal.h
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AVQSVContext::opaque_alloc
int opaque_alloc
Encoding only.
Definition: qsv.h:65
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecContext::slices
int slices
Number of slices.
Definition: avcodec.h:989
AVPacket
This structure stores compressed data.
Definition: packet.h:351
QSVEncContext::extvp9param
mfxExtVP9Param extvp9param
Definition: qsvenc.h:130
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
QSVEncContext::low_delay_brc
int low_delay_brc
Definition: qsvenc.h:206
QSVEncContext::transform_skip
int transform_skip
Definition: qsvenc.h:196
FFMAX3
#define FFMAX3(a, b, c)
Definition: macros.h:48
QSVEncContext::width_align
int width_align
Definition: qsvenc.h:116
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:562
bytestream.h
imgutils.h
vp9_profiles
static const struct profile_names vp9_profiles[]
Definition: qsvenc.c:78
hwcontext.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
mpeg2_profiles
static const struct profile_names mpeg2_profiles[]
Definition: qsvenc.c:62
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
qsv_retrieve_enc_jpeg_params
static int qsv_retrieve_enc_jpeg_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:958
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1740
avc_profiles
static const struct profile_names avc_profiles[]
Definition: qsvenc.c:51
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
rc_mode
mfxU16 rc_mode
Definition: qsvenc.c:129
QSVEncContext::avctx
AVCodecContext * avctx
Definition: qsvenc.h:108
QSVFrame::next
struct QSVFrame * next
Definition: qsv_internal.h:90
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:52
ff_qsv_print_error
int ff_qsv_print_error(void *log_ctx, mfxStatus err, const char *error_string)
Definition: qsv.c:160
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:407
QSVEncContext::tile_rows
int tile_rows
Definition: qsvenc.h:171
ff_qsv_encode
int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: qsvenc.c:1628
QSVEncContext::vp9_idx
int vp9_idx
Definition: qsvenc.h:211
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:759
hevc_profiles
static const struct profile_names hevc_profiles[]
Definition: qsvenc.c:68
AVCodecContext::compression_level
int compression_level
Definition: avcodec.h:461
qsvenc_init_session
static int qsvenc_init_session(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1187
QSVEncContext::low_power
int low_power
Definition: qsvenc.h:194
QSVPacket::bs
mfxBitstream * bs
Definition: qsvenc.c:88