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