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