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