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