FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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  { MFX_RATECONTROL_AVBR, "AVBR" },
89 #if QSV_HAVE_LA
90  { MFX_RATECONTROL_LA, "LA" },
91 #endif
92 #if QSV_HAVE_ICQ
93  { MFX_RATECONTROL_ICQ, "ICQ" },
94  { MFX_RATECONTROL_LA_ICQ, "LA_ICQ" },
95 #endif
96 #if QSV_HAVE_VCM
97  { MFX_RATECONTROL_VCM, "VCM" },
98 #endif
99 #if QSV_VERSION_ATLEAST(1, 10)
100  { MFX_RATECONTROL_LA_EXT, "LA_EXT" },
101 #endif
102 #if QSV_HAVE_LA_HRD
103  { MFX_RATECONTROL_LA_HRD, "LA_HRD" },
104 #endif
105 #if QSV_HAVE_QVBR
106  { MFX_RATECONTROL_QVBR, "QVBR" },
107 #endif
108 };
109 
110 static const char *print_ratecontrol(mfxU16 rc_mode)
111 {
112  int i;
113  for (i = 0; i < FF_ARRAY_ELEMS(rc_names); i++)
114  if (rc_mode == rc_names[i].rc_mode)
115  return rc_names[i].name;
116  return "unknown";
117 }
118 
119 static const char *print_threestate(mfxU16 val)
120 {
121  if (val == MFX_CODINGOPTION_ON)
122  return "ON";
123  else if (val == MFX_CODINGOPTION_OFF)
124  return "OFF";
125  return "unknown";
126 }
127 
129  mfxExtBuffer **coding_opts)
130 {
131  mfxInfoMFX *info = &q->param.mfx;
132 
133  mfxExtCodingOption *co = (mfxExtCodingOption*)coding_opts[0];
134 #if QSV_HAVE_CO2
135  mfxExtCodingOption2 *co2 = (mfxExtCodingOption2*)coding_opts[1];
136 #endif
137 
138  av_log(avctx, AV_LOG_VERBOSE, "profile: %s; level: %"PRIu16"\n",
139  print_profile(info->CodecProfile), info->CodecLevel);
140 
141  av_log(avctx, AV_LOG_VERBOSE, "GopPicSize: %"PRIu16"; GopRefDist: %"PRIu16"; GopOptFlag: ",
142  info->GopPicSize, info->GopRefDist);
143  if (info->GopOptFlag & MFX_GOP_CLOSED)
144  av_log(avctx, AV_LOG_VERBOSE, "closed ");
145  if (info->GopOptFlag & MFX_GOP_STRICT)
146  av_log(avctx, AV_LOG_VERBOSE, "strict ");
147  av_log(avctx, AV_LOG_VERBOSE, "; IdrInterval: %"PRIu16"\n", info->IdrInterval);
148 
149  av_log(avctx, AV_LOG_VERBOSE, "TargetUsage: %"PRIu16"; RateControlMethod: %s\n",
150  info->TargetUsage, print_ratecontrol(info->RateControlMethod));
151 
152  if (info->RateControlMethod == MFX_RATECONTROL_CBR ||
153  info->RateControlMethod == MFX_RATECONTROL_VBR
154 #if QSV_HAVE_VCM
155  || info->RateControlMethod == MFX_RATECONTROL_VCM
156 #endif
157  ) {
158  av_log(avctx, AV_LOG_VERBOSE,
159  "InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"\n",
160  info->InitialDelayInKB, info->TargetKbps, info->MaxKbps);
161  } else if (info->RateControlMethod == MFX_RATECONTROL_CQP) {
162  av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",
163  info->QPI, info->QPP, info->QPB);
164  } else if (info->RateControlMethod == MFX_RATECONTROL_AVBR) {
165  av_log(avctx, AV_LOG_VERBOSE,
166  "TargetKbps: %"PRIu16"; Accuracy: %"PRIu16"; Convergence: %"PRIu16"\n",
167  info->TargetKbps, info->Accuracy, info->Convergence);
168  }
169 #if QSV_HAVE_LA
170  else if (info->RateControlMethod == MFX_RATECONTROL_LA
171 #if QSV_HAVE_LA_HRD
172  || info->RateControlMethod == MFX_RATECONTROL_LA_HRD
173 #endif
174  ) {
175  av_log(avctx, AV_LOG_VERBOSE,
176  "TargetKbps: %"PRIu16"; LookAheadDepth: %"PRIu16"\n",
177  info->TargetKbps, co2->LookAheadDepth);
178  }
179 #endif
180 #if QSV_HAVE_ICQ
181  else if (info->RateControlMethod == MFX_RATECONTROL_ICQ) {
182  av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);
183  } else if (info->RateControlMethod == MFX_RATECONTROL_LA_ICQ) {
184  av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"; LookAheadDepth: %"PRIu16"\n",
185  info->ICQQuality, co2->LookAheadDepth);
186  }
187 #endif
188 
189  av_log(avctx, AV_LOG_VERBOSE, "NumSlice: %"PRIu16"; NumRefFrame: %"PRIu16"\n",
190  info->NumSlice, info->NumRefFrame);
191  av_log(avctx, AV_LOG_VERBOSE, "RateDistortionOpt: %s\n",
192  print_threestate(co->RateDistortionOpt));
193 
194 #if QSV_HAVE_CO2
195  av_log(avctx, AV_LOG_VERBOSE,
196  "RecoveryPointSEI: %s IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16"; IntRefQPDelta: %"PRId16"\n",
197  print_threestate(co->RecoveryPointSEI), co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);
198 
199  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %"PRIu16"; ", co2->MaxFrameSize);
200 #if QSV_HAVE_MAX_SLICE_SIZE
201  av_log(avctx, AV_LOG_VERBOSE, "MaxSliceSize: %"PRIu16"; ", co2->MaxSliceSize);
202 #endif
203  av_log(avctx, AV_LOG_VERBOSE, "\n");
204 
205  av_log(avctx, AV_LOG_VERBOSE,
206  "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
207  print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),
208  print_threestate(co2->ExtBRC));
209 
210 #if QSV_HAVE_TRELLIS
211  av_log(avctx, AV_LOG_VERBOSE, "Trellis: ");
212  if (co2->Trellis & MFX_TRELLIS_OFF) {
213  av_log(avctx, AV_LOG_VERBOSE, "off");
214  } else if (!co2->Trellis) {
215  av_log(avctx, AV_LOG_VERBOSE, "auto");
216  } else {
217  if (co2->Trellis & MFX_TRELLIS_I) av_log(avctx, AV_LOG_VERBOSE, "I");
218  if (co2->Trellis & MFX_TRELLIS_P) av_log(avctx, AV_LOG_VERBOSE, "P");
219  if (co2->Trellis & MFX_TRELLIS_B) av_log(avctx, AV_LOG_VERBOSE, "B");
220  }
221  av_log(avctx, AV_LOG_VERBOSE, "\n");
222 #endif
223 
224 #if QSV_VERSION_ATLEAST(1, 8)
225  av_log(avctx, AV_LOG_VERBOSE,
226  "RepeatPPS: %s; NumMbPerSlice: %"PRIu16"; LookAheadDS: ",
227  print_threestate(co2->RepeatPPS), co2->NumMbPerSlice);
228  switch (co2->LookAheadDS) {
229  case MFX_LOOKAHEAD_DS_OFF: av_log(avctx, AV_LOG_VERBOSE, "off"); break;
230  case MFX_LOOKAHEAD_DS_2x: av_log(avctx, AV_LOG_VERBOSE, "2x"); break;
231  case MFX_LOOKAHEAD_DS_4x: av_log(avctx, AV_LOG_VERBOSE, "4x"); break;
232  default: av_log(avctx, AV_LOG_VERBOSE, "unknown"); break;
233  }
234  av_log(avctx, AV_LOG_VERBOSE, "\n");
235 
236  av_log(avctx, AV_LOG_VERBOSE, "AdaptiveI: %s; AdaptiveB: %s; BRefType: ",
237  print_threestate(co2->AdaptiveI), print_threestate(co2->AdaptiveB));
238  switch (co2->BRefType) {
239  case MFX_B_REF_OFF: av_log(avctx, AV_LOG_VERBOSE, "off"); break;
240  case MFX_B_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "pyramid"); break;
241  default: av_log(avctx, AV_LOG_VERBOSE, "auto"); break;
242  }
243  av_log(avctx, AV_LOG_VERBOSE, "\n");
244 #endif
245 
246 #if QSV_VERSION_ATLEAST(1, 9)
247  av_log(avctx, AV_LOG_VERBOSE,
248  "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",
249  co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
250 #endif
251 #endif
252 
253  if (avctx->codec_id == AV_CODEC_ID_H264) {
254  av_log(avctx, AV_LOG_VERBOSE, "Entropy coding: %s; MaxDecFrameBuffering: %"PRIu16"\n",
255  co->CAVLC == MFX_CODINGOPTION_ON ? "CAVLC" : "CABAC", co->MaxDecFrameBuffering);
256  av_log(avctx, AV_LOG_VERBOSE,
257  "NalHrdConformance: %s; SingleSeiNalUnit: %s; VuiVclHrdParameters: %s VuiNalHrdParameters: %s\n",
258  print_threestate(co->NalHrdConformance), print_threestate(co->SingleSeiNalUnit),
259  print_threestate(co->VuiVclHrdParameters), print_threestate(co->VuiNalHrdParameters));
260  }
261 }
262 
264 {
265  const char *rc_desc;
266  mfxU16 rc_mode;
267 
268  int want_la = q->look_ahead;
269  int want_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
270  int want_vcm = q->vcm;
271 
272  if (want_la && !QSV_HAVE_LA) {
273  av_log(avctx, AV_LOG_ERROR,
274  "Lookahead ratecontrol mode requested, but is not supported by this SDK version\n");
275  return AVERROR(ENOSYS);
276  }
277  if (want_vcm && !QSV_HAVE_VCM) {
278  av_log(avctx, AV_LOG_ERROR,
279  "VCM ratecontrol mode requested, but is not supported by this SDK version\n");
280  return AVERROR(ENOSYS);
281  }
282 
283  if (want_la + want_qscale + want_vcm > 1) {
284  av_log(avctx, AV_LOG_ERROR,
285  "More than one of: { constant qscale, lookahead, VCM } requested, "
286  "only one of them can be used at a time.\n");
287  return AVERROR(EINVAL);
288  }
289 
290  if (!want_qscale && avctx->global_quality > 0 && !QSV_HAVE_ICQ){
291  av_log(avctx, AV_LOG_ERROR,
292  "ICQ ratecontrol mode requested, but is not supported by this SDK version\n");
293  return AVERROR(ENOSYS);
294  }
295 
296  if (want_qscale) {
297  rc_mode = MFX_RATECONTROL_CQP;
298  rc_desc = "constant quantization parameter (CQP)";
299  }
300 #if QSV_HAVE_VCM
301  else if (want_vcm) {
302  rc_mode = MFX_RATECONTROL_VCM;
303  rc_desc = "video conferencing mode (VCM)";
304  }
305 #endif
306 #if QSV_HAVE_LA
307  else if (want_la) {
308  rc_mode = MFX_RATECONTROL_LA;
309  rc_desc = "VBR with lookahead (LA)";
310 
311 #if QSV_HAVE_ICQ
312  if (avctx->global_quality > 0) {
313  rc_mode = MFX_RATECONTROL_LA_ICQ;
314  rc_desc = "intelligent constant quality with lookahead (LA_ICQ)";
315  }
316 #endif
317  }
318 #endif
319 #if QSV_HAVE_ICQ
320  else if (avctx->global_quality > 0) {
321  rc_mode = MFX_RATECONTROL_ICQ;
322  rc_desc = "intelligent constant quality (ICQ)";
323  }
324 #endif
325  else if (avctx->rc_max_rate == avctx->bit_rate) {
326  rc_mode = MFX_RATECONTROL_CBR;
327  rc_desc = "constant bitrate (CBR)";
328  } else if (!avctx->rc_max_rate) {
329  rc_mode = MFX_RATECONTROL_AVBR;
330  rc_desc = "average variable bitrate (AVBR)";
331  } else {
332  rc_mode = MFX_RATECONTROL_VBR;
333  rc_desc = "variable bitrate (VBR)";
334  }
335 
336  q->param.mfx.RateControlMethod = rc_mode;
337  av_log(avctx, AV_LOG_VERBOSE, "Using the %s ratecontrol method\n", rc_desc);
338 
339  return 0;
340 }
341 
343 {
344  mfxVideoParam param_out = { .mfx.CodecId = q->param.mfx.CodecId };
345  mfxStatus ret;
346 
347  ret = MFXVideoENCODE_Query(q->session, &q->param, &param_out);
348  if (ret < 0 ||
349  param_out.mfx.RateControlMethod != q->param.mfx.RateControlMethod)
350  return 0;
351  return 1;
352 }
353 
355 {
356  enum AVPixelFormat sw_format = avctx->pix_fmt == AV_PIX_FMT_QSV ?
357  avctx->sw_pix_fmt : avctx->pix_fmt;
358  const AVPixFmtDescriptor *desc;
359  int ret;
360 
361  ret = ff_qsv_codec_id_to_mfx(avctx->codec_id);
362  if (ret < 0)
363  return AVERROR_BUG;
364  q->param.mfx.CodecId = ret;
365 
366  if (avctx->level > 0)
367  q->param.mfx.CodecLevel = avctx->level;
368  q->param.mfx.CodecProfile = q->profile;
369 
370  desc = av_pix_fmt_desc_get(sw_format);
371  if (!desc)
372  return AVERROR_BUG;
373 
374  ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC);
375 
376  q->param.mfx.FrameInfo.CropX = 0;
377  q->param.mfx.FrameInfo.CropY = 0;
378  q->param.mfx.FrameInfo.CropW = avctx->width;
379  q->param.mfx.FrameInfo.CropH = avctx->height;
380  q->param.mfx.FrameInfo.AspectRatioW = avctx->sample_aspect_ratio.num;
381  q->param.mfx.FrameInfo.AspectRatioH = avctx->sample_aspect_ratio.den;
382  q->param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
383  q->param.mfx.FrameInfo.BitDepthLuma = desc->comp[0].depth;
384  q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
385  q->param.mfx.FrameInfo.Shift = desc->comp[0].depth > 8;
386 
387  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, 16);
388  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, 16);
389 
390  if (avctx->hw_frames_ctx) {
391  AVHWFramesContext *frames_ctx = (AVHWFramesContext *)avctx->hw_frames_ctx->data;
392  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
393  q->param.mfx.FrameInfo.Width = frames_hwctx->surfaces[0].Info.Width;
394  q->param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;
395  }
396 
397  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
398  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
399  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
400  } else {
401  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
402  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
403  }
404 
405  q->param.mfx.Interleaved = 1;
406  q->param.mfx.Quality = av_clip(avctx->global_quality, 1, 100);
407  q->param.mfx.RestartInterval = 0;
408 
409  return 0;
410 }
411 
413 {
414  enum AVPixelFormat sw_format = avctx->pix_fmt == AV_PIX_FMT_QSV ?
415  avctx->sw_pix_fmt : avctx->pix_fmt;
416  const AVPixFmtDescriptor *desc;
417  float quant;
418  int ret;
419 
420  ret = ff_qsv_codec_id_to_mfx(avctx->codec_id);
421  if (ret < 0)
422  return AVERROR_BUG;
423  q->param.mfx.CodecId = ret;
424 
425  if (avctx->level > 0)
426  q->param.mfx.CodecLevel = avctx->level;
427 
428  q->param.mfx.CodecProfile = q->profile;
429  q->param.mfx.TargetUsage = q->preset;
430  q->param.mfx.GopPicSize = FFMAX(0, avctx->gop_size);
431  q->param.mfx.GopRefDist = FFMAX(-1, avctx->max_b_frames) + 1;
432  q->param.mfx.GopOptFlag = avctx->flags & AV_CODEC_FLAG_CLOSED_GOP ?
433  MFX_GOP_CLOSED : 0;
434  q->param.mfx.IdrInterval = q->idr_interval;
435  q->param.mfx.NumSlice = avctx->slices;
436  q->param.mfx.NumRefFrame = FFMAX(0, avctx->refs);
437  q->param.mfx.EncodedOrder = 0;
438  q->param.mfx.BufferSizeInKB = 0;
439 
440  desc = av_pix_fmt_desc_get(sw_format);
441  if (!desc)
442  return AVERROR_BUG;
443 
444  ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC);
445 
446  q->param.mfx.FrameInfo.CropX = 0;
447  q->param.mfx.FrameInfo.CropY = 0;
448  q->param.mfx.FrameInfo.CropW = avctx->width;
449  q->param.mfx.FrameInfo.CropH = avctx->height;
450  q->param.mfx.FrameInfo.AspectRatioW = avctx->sample_aspect_ratio.num;
451  q->param.mfx.FrameInfo.AspectRatioH = avctx->sample_aspect_ratio.den;
452  q->param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
453  q->param.mfx.FrameInfo.BitDepthLuma = desc->comp[0].depth;
454  q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
455  q->param.mfx.FrameInfo.Shift = desc->comp[0].depth > 8;
456 
457  // TODO: detect version of MFX--if the minor version is greater than
458  // or equal to 19, then can use the same alignment settings as H.264
459  // for HEVC
460  q->width_align = avctx->codec_id == AV_CODEC_ID_HEVC ? 32 : 16;
461  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, q->width_align);
462 
463  if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
464  // it is important that PicStruct be setup correctly from the
465  // start--otherwise, encoding doesn't work and results in a bunch
466  // of incompatible video parameter errors
467  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_FIELD_TFF;
468  // height alignment always must be 32 for interlaced video
469  q->height_align = 32;
470  } else {
471  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
472  // for progressive video, the height should be aligned to 16 for
473  // H.264. For HEVC, depending on the version of MFX, it should be
474  // either 32 or 16. The lower number is better if possible.
475  q->height_align = avctx->codec_id == AV_CODEC_ID_HEVC ? 32 : 16;
476  }
477  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, q->height_align);
478 
479  if (avctx->hw_frames_ctx) {
480  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
481  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
482  q->param.mfx.FrameInfo.Width = frames_hwctx->surfaces[0].Info.Width;
483  q->param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;
484  }
485 
486  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
487  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
488  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
489  } else {
490  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
491  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
492  }
493 
494  ret = select_rc_mode(avctx, q);
495  if (ret < 0)
496  return ret;
497 
498  switch (q->param.mfx.RateControlMethod) {
499  case MFX_RATECONTROL_CBR:
500  case MFX_RATECONTROL_VBR:
501 #if QSV_HAVE_VCM
502  case MFX_RATECONTROL_VCM:
503 #endif
504  q->param.mfx.BufferSizeInKB = avctx->rc_buffer_size / 8000;
505  q->param.mfx.InitialDelayInKB = avctx->rc_initial_buffer_occupancy / 1000;
506  q->param.mfx.TargetKbps = avctx->bit_rate / 1000;
507  q->param.mfx.MaxKbps = avctx->rc_max_rate / 1000;
508  break;
509  case MFX_RATECONTROL_CQP:
510  quant = avctx->global_quality / FF_QP2LAMBDA;
511 
512  q->param.mfx.QPI = av_clip(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 0, 51);
513  q->param.mfx.QPP = av_clip(quant, 0, 51);
514  q->param.mfx.QPB = av_clip(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 0, 51);
515 
516  break;
517  case MFX_RATECONTROL_AVBR:
518  q->param.mfx.TargetKbps = avctx->bit_rate / 1000;
519  q->param.mfx.Convergence = q->avbr_convergence;
520  q->param.mfx.Accuracy = q->avbr_accuracy;
521  break;
522 #if QSV_HAVE_LA
523  case MFX_RATECONTROL_LA:
524  q->param.mfx.TargetKbps = avctx->bit_rate / 1000;
525  q->extco2.LookAheadDepth = q->look_ahead_depth;
526  break;
527 #if QSV_HAVE_ICQ
528  case MFX_RATECONTROL_LA_ICQ:
529  q->extco2.LookAheadDepth = q->look_ahead_depth;
530  case MFX_RATECONTROL_ICQ:
531  q->param.mfx.ICQQuality = avctx->global_quality;
532  break;
533 #endif
534 #endif
535  }
536 
537  // the HEVC encoder plugin currently fails if coding options
538  // are provided
539  if (avctx->codec_id != AV_CODEC_ID_HEVC) {
540  q->extco.Header.BufferId = MFX_EXTBUFF_CODING_OPTION;
541  q->extco.Header.BufferSz = sizeof(q->extco);
542 
543  q->extco.PicTimingSEI = q->pic_timing_sei ?
544  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;
545 
546  if (q->rdo >= 0)
547  q->extco.RateDistortionOpt = q->rdo > 0 ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
548 
549  if (avctx->codec_id == AV_CODEC_ID_H264) {
550 #if FF_API_CODER_TYPE
552  if (avctx->coder_type >= 0)
553  q->cavlc = avctx->coder_type == FF_CODER_TYPE_VLC;
555 #endif
556  q->extco.CAVLC = q->cavlc ? MFX_CODINGOPTION_ON
557  : MFX_CODINGOPTION_UNKNOWN;
558 
560  q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?
561  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
562 
563  if (q->single_sei_nal_unit >= 0)
564  q->extco.SingleSeiNalUnit = q->single_sei_nal_unit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
565  if (q->recovery_point_sei >= 0)
566  q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
567  q->extco.MaxDecFrameBuffering = q->max_dec_frame_buffering;
568  }
569 
570  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco;
571 
572 #if QSV_HAVE_CO2
573  if (avctx->codec_id == AV_CODEC_ID_H264) {
574  q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
575  q->extco2.Header.BufferSz = sizeof(q->extco2);
576 
577  if (q->int_ref_type >= 0)
578  q->extco2.IntRefType = q->int_ref_type;
579  if (q->int_ref_cycle_size >= 0)
580  q->extco2.IntRefCycleSize = q->int_ref_cycle_size;
581  if (q->int_ref_qp_delta != INT16_MIN)
582  q->extco2.IntRefQPDelta = q->int_ref_qp_delta;
583 
584  if (q->bitrate_limit >= 0)
585  q->extco2.BitrateLimit = q->bitrate_limit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
586  if (q->mbbrc >= 0)
587  q->extco2.MBBRC = q->mbbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
588  if (q->extbrc >= 0)
589  q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
590 
591  if (q->max_frame_size >= 0)
592  q->extco2.MaxFrameSize = q->max_frame_size;
593 #if QSV_HAVE_MAX_SLICE_SIZE
594  if (q->max_slice_size >= 0)
595  q->extco2.MaxSliceSize = q->max_slice_size;
596 #endif
597 
598 #if QSV_HAVE_TRELLIS
599  q->extco2.Trellis = q->trellis;
600 #endif
601 
602 #if QSV_HAVE_LA_DS
603  q->extco2.LookAheadDS = q->look_ahead_downsampling;
604 #endif
605 
606 #if QSV_HAVE_BREF_TYPE
607 #if FF_API_PRIVATE_OPT
609  if (avctx->b_frame_strategy >= 0)
610  q->b_strategy = avctx->b_frame_strategy;
612 #endif
613  if (q->b_strategy >= 0)
614  q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
615  if (q->adaptive_i >= 0)
616  q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
617  if (q->adaptive_b >= 0)
618  q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
619 #endif
620 
621  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
622  }
623 #endif
624  }
625 
626  if (!rc_supported(q)) {
627  av_log(avctx, AV_LOG_ERROR,
628  "Selected ratecontrol mode is not supported by the QSV "
629  "runtime. Choose a different mode.\n");
630  return AVERROR(ENOSYS);
631  }
632 
633  return 0;
634 }
635 
637 {
638  int ret = 0;
639 
640  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
641  if (ret < 0)
642  return ff_qsv_print_error(avctx, ret,
643  "Error calling GetVideoParam");
644 
645  q->packet_size = q->param.mfx.BufferSizeInKB * 1000;
646 
647  // for qsv mjpeg the return value maybe 0 so alloc the buffer
648  if (q->packet_size == 0)
649  q->packet_size = q->param.mfx.FrameInfo.Height * q->param.mfx.FrameInfo.Width * 4;
650 
651  return 0;
652 }
653 
655 {
656  AVCPBProperties *cpb_props;
657 
658  uint8_t sps_buf[128];
659  uint8_t pps_buf[128];
660 
661  mfxExtCodingOptionSPSPPS extradata = {
662  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
663  .Header.BufferSz = sizeof(extradata),
664  .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),
665  .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
666  };
667 
668  mfxExtCodingOption co = {
669  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
670  .Header.BufferSz = sizeof(co),
671  };
672 #if QSV_HAVE_CO2
673  mfxExtCodingOption2 co2 = {
674  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
675  .Header.BufferSz = sizeof(co2),
676  };
677 #endif
678 
679  mfxExtBuffer *ext_buffers[] = {
680  (mfxExtBuffer*)&extradata,
681  (mfxExtBuffer*)&co,
682 #if QSV_HAVE_CO2
683  (mfxExtBuffer*)&co2,
684 #endif
685  };
686 
687  int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
688  int ret;
689 
690  q->param.ExtParam = ext_buffers;
691  q->param.NumExtParam = FF_ARRAY_ELEMS(ext_buffers);
692 
693  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
694  if (ret < 0)
695  return ff_qsv_print_error(avctx, ret,
696  "Error calling GetVideoParam");
697 
698  q->packet_size = q->param.mfx.BufferSizeInKB * 1000;
699 
700  if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)) {
701  av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
702  return AVERROR_UNKNOWN;
703  }
704 
705  avctx->extradata = av_malloc(extradata.SPSBufSize + need_pps * extradata.PPSBufSize +
707  if (!avctx->extradata)
708  return AVERROR(ENOMEM);
709 
710  memcpy(avctx->extradata, sps_buf, extradata.SPSBufSize);
711  if (need_pps)
712  memcpy(avctx->extradata + extradata.SPSBufSize, pps_buf, extradata.PPSBufSize);
713  avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
714  memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
715 
716  cpb_props = ff_add_cpb_side_data(avctx);
717  if (!cpb_props)
718  return AVERROR(ENOMEM);
719  cpb_props->max_bitrate = avctx->rc_max_rate;
720  cpb_props->min_bitrate = avctx->rc_min_rate;
721  cpb_props->avg_bitrate = avctx->bit_rate;
722  cpb_props->buffer_size = avctx->rc_buffer_size;
723 
724  dump_video_param(avctx, q, ext_buffers + 1);
725 
726  return 0;
727 }
728 
730 {
731  AVQSVContext *qsv = avctx->hwaccel_context;
732  mfxFrameSurface1 *surfaces;
733  int nb_surfaces, i;
734 
735  nb_surfaces = qsv->nb_opaque_surfaces + q->req.NumFrameSuggested + q->async_depth;
736 
737  q->opaque_alloc_buf = av_buffer_allocz(sizeof(*surfaces) * nb_surfaces);
738  if (!q->opaque_alloc_buf)
739  return AVERROR(ENOMEM);
740 
741  q->opaque_surfaces = av_malloc_array(nb_surfaces, sizeof(*q->opaque_surfaces));
742  if (!q->opaque_surfaces)
743  return AVERROR(ENOMEM);
744 
745  surfaces = (mfxFrameSurface1*)q->opaque_alloc_buf->data;
746  for (i = 0; i < nb_surfaces; i++) {
747  surfaces[i].Info = q->req.Info;
748  q->opaque_surfaces[i] = surfaces + i;
749  }
750 
751  q->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
752  q->opaque_alloc.Header.BufferSz = sizeof(q->opaque_alloc);
753  q->opaque_alloc.In.Surfaces = q->opaque_surfaces;
754  q->opaque_alloc.In.NumSurface = nb_surfaces;
755  q->opaque_alloc.In.Type = q->req.Type;
756 
757  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->opaque_alloc;
758 
759  qsv->nb_opaque_surfaces = nb_surfaces;
761  qsv->opaque_alloc_type = q->req.Type;
762 
763  return 0;
764 }
765 
767 {
768  int ret;
769 
770  if (avctx->hwaccel_context) {
771  AVQSVContext *qsv = avctx->hwaccel_context;
772  q->session = qsv->session;
773  } else if (avctx->hw_frames_ctx) {
775  if (!q->frames_ctx.hw_frames_ctx)
776  return AVERROR(ENOMEM);
777 
779  &q->frames_ctx, q->load_plugins,
780  q->param.IOPattern == MFX_IOPATTERN_IN_OPAQUE_MEMORY);
781  if (ret < 0) {
783  return ret;
784  }
785 
786  q->session = q->internal_session;
787  } else if (avctx->hw_device_ctx) {
789  avctx->hw_device_ctx, q->load_plugins);
790  if (ret < 0)
791  return ret;
792 
793  q->session = q->internal_session;
794  } else {
796  q->load_plugins);
797  if (ret < 0)
798  return ret;
799 
800  q->session = q->internal_session;
801  }
802 
803  return 0;
804 }
805 
807 {
808  int iopattern = 0;
809  int opaque_alloc = 0;
810  int ret;
811 
812  q->param.AsyncDepth = q->async_depth;
813 
814  q->async_fifo = av_fifo_alloc((1 + q->async_depth) *
815  (sizeof(AVPacket) + sizeof(mfxSyncPoint*) + sizeof(mfxBitstream*)));
816  if (!q->async_fifo)
817  return AVERROR(ENOMEM);
818 
819  if (avctx->hwaccel_context) {
820  AVQSVContext *qsv = avctx->hwaccel_context;
821 
822  iopattern = qsv->iopattern;
823  opaque_alloc = qsv->opaque_alloc;
824  }
825 
826  if (avctx->hw_frames_ctx) {
827  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
828  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
829 
830  if (!iopattern) {
831  if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)
832  iopattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
833  else if (frames_hwctx->frame_type &
834  (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
835  iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
836  }
837  }
838 
839  if (!iopattern)
840  iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
841  q->param.IOPattern = iopattern;
842 
843  ret = qsvenc_init_session(avctx, q);
844  if (ret < 0)
845  return ret;
846 
847  // in the mfxInfoMFX struct, JPEG is different from other codecs
848  switch (avctx->codec_id) {
849  case AV_CODEC_ID_MJPEG:
850  ret = init_video_param_jpeg(avctx, q);
851  break;
852  default:
853  ret = init_video_param(avctx, q);
854  break;
855  }
856  if (ret < 0)
857  return ret;
858 
859  ret = MFXVideoENCODE_Query(q->session, &q->param, &q->param);
860  if (ret == MFX_WRN_PARTIAL_ACCELERATION) {
861  av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
862  } else if (ret < 0) {
863  return ff_qsv_print_error(avctx, ret,
864  "Error querying encoder params");
865  }
866 
867  ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
868  if (ret < 0)
869  return ff_qsv_print_error(avctx, ret,
870  "Error querying (IOSurf) the encoding parameters");
871 
872  if (opaque_alloc) {
873  ret = qsv_init_opaque_alloc(avctx, q);
874  if (ret < 0)
875  return ret;
876  }
877 
878  if (avctx->hwaccel_context) {
879  AVQSVContext *qsv = avctx->hwaccel_context;
880  int i, j;
881 
883  sizeof(*q->extparam));
884  if (!q->extparam)
885  return AVERROR(ENOMEM);
886 
887  q->param.ExtParam = q->extparam;
888  for (i = 0; i < qsv->nb_ext_buffers; i++)
889  q->param.ExtParam[i] = qsv->ext_buffers[i];
890  q->param.NumExtParam = qsv->nb_ext_buffers;
891 
892  for (i = 0; i < q->nb_extparam_internal; i++) {
893  for (j = 0; j < qsv->nb_ext_buffers; j++) {
894  if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)
895  break;
896  }
897  if (j < qsv->nb_ext_buffers)
898  continue;
899 
900  q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];
901  }
902  } else {
903  q->param.ExtParam = q->extparam_internal;
904  q->param.NumExtParam = q->nb_extparam_internal;
905  }
906 
907  ret = MFXVideoENCODE_Init(q->session, &q->param);
908  if (ret < 0)
909  return ff_qsv_print_error(avctx, ret,
910  "Error initializing the encoder");
911  else if (ret > 0)
912  ff_qsv_print_warning(avctx, ret,
913  "Warning in encoder initialization");
914 
915  switch (avctx->codec_id) {
916  case AV_CODEC_ID_MJPEG:
917  ret = qsv_retrieve_enc_jpeg_params(avctx, q);
918  break;
919  default:
920  ret = qsv_retrieve_enc_params(avctx, q);
921  break;
922  }
923  if (ret < 0) {
924  av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
925  return ret;
926  }
927 
928  q->avctx = avctx;
929 
930  return 0;
931 }
932 
933 static void free_encoder_ctrl_payloads(mfxEncodeCtrl* enc_ctrl)
934 {
935  if (enc_ctrl) {
936  int i;
937  for (i = 0; i < enc_ctrl->NumPayload && i < QSV_MAX_ENC_PAYLOAD; i++) {
938  av_free(enc_ctrl->Payload[i]);
939  }
940  enc_ctrl->NumPayload = 0;
941  }
942 }
943 
945 {
946  QSVFrame *cur = q->work_frames;
947  while (cur) {
948  if (cur->used && !cur->surface.Data.Locked) {
950  av_frame_unref(cur->frame);
951  cur->used = 0;
952  }
953  cur = cur->next;
954  }
955 }
956 
958 {
959  QSVFrame *frame, **last;
960 
962 
963  frame = q->work_frames;
964  last = &q->work_frames;
965  while (frame) {
966  if (!frame->used) {
967  *f = frame;
968  frame->used = 1;
969  return 0;
970  }
971 
972  last = &frame->next;
973  frame = frame->next;
974  }
975 
976  frame = av_mallocz(sizeof(*frame));
977  if (!frame)
978  return AVERROR(ENOMEM);
979  frame->frame = av_frame_alloc();
980  if (!frame->frame) {
981  av_freep(&frame);
982  return AVERROR(ENOMEM);
983  }
984  frame->enc_ctrl.Payload = av_mallocz(sizeof(mfxPayload*) * QSV_MAX_ENC_PAYLOAD);
985  if (!frame->enc_ctrl.Payload) {
986  av_freep(&frame);
987  return AVERROR(ENOMEM);
988  }
989  *last = frame;
990 
991  *f = frame;
992  frame->used = 1;
993 
994  return 0;
995 }
996 
997 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
998  QSVFrame **new_frame)
999 {
1000  QSVFrame *qf;
1001  int ret;
1002 
1003  ret = get_free_frame(q, &qf);
1004  if (ret < 0)
1005  return ret;
1006 
1007  if (frame->format == AV_PIX_FMT_QSV) {
1008  ret = av_frame_ref(qf->frame, frame);
1009  if (ret < 0)
1010  return ret;
1011 
1012  qf->surface = *(mfxFrameSurface1*)qf->frame->data[3];
1013 
1014  if (q->frames_ctx.mids) {
1015  ret = ff_qsv_find_surface_idx(&q->frames_ctx, qf);
1016  if (ret < 0)
1017  return ret;
1018 
1019  qf->surface.Data.MemId = &q->frames_ctx.mids[ret];
1020  }
1021  } else {
1022  /* make a copy if the input is not padded as libmfx requires */
1023  if (frame->height & 31 || frame->linesize[0] & (q->width_align - 1)) {
1024  qf->frame->height = FFALIGN(frame->height, q->height_align);
1025  qf->frame->width = FFALIGN(frame->width, q->width_align);
1026 
1028  if (ret < 0)
1029  return ret;
1030 
1031  qf->frame->height = frame->height;
1032  qf->frame->width = frame->width;
1033  ret = av_frame_copy(qf->frame, frame);
1034  if (ret < 0) {
1035  av_frame_unref(qf->frame);
1036  return ret;
1037  }
1038  } else {
1039  ret = av_frame_ref(qf->frame, frame);
1040  if (ret < 0)
1041  return ret;
1042  }
1043 
1044  qf->surface.Info = q->param.mfx.FrameInfo;
1045 
1046  qf->surface.Info.PicStruct =
1047  !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
1048  frame->top_field_first ? MFX_PICSTRUCT_FIELD_TFF :
1049  MFX_PICSTRUCT_FIELD_BFF;
1050  if (frame->repeat_pict == 1)
1051  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
1052  else if (frame->repeat_pict == 2)
1053  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
1054  else if (frame->repeat_pict == 4)
1055  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
1056 
1057  qf->surface.Data.PitchLow = qf->frame->linesize[0];
1058  qf->surface.Data.Y = qf->frame->data[0];
1059  qf->surface.Data.UV = qf->frame->data[1];
1060  }
1061 
1062  qf->surface.Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
1063 
1064  *new_frame = qf;
1065 
1066  return 0;
1067 }
1068 
1070 {
1071  if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
1072  if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
1073  q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
1074  q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
1075  av_log(avctx, AV_LOG_WARNING,
1076  "Interlaced coding is supported"
1077  " at Main/High Profile Level 2.1-4.1\n");
1078  }
1079 }
1080 
1082  const AVFrame *frame)
1083 {
1084  AVPacket new_pkt = { 0 };
1085  mfxBitstream *bs;
1086 
1087  mfxFrameSurface1 *surf = NULL;
1088  mfxSyncPoint *sync = NULL;
1089  QSVFrame *qsv_frame = NULL;
1090  mfxEncodeCtrl* enc_ctrl = NULL;
1091  int ret;
1092 
1093  if (frame) {
1094  ret = submit_frame(q, frame, &qsv_frame);
1095  if (ret < 0) {
1096  av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
1097  return ret;
1098  }
1099  }
1100  if (qsv_frame) {
1101  surf = &qsv_frame->surface;
1102  enc_ctrl = &qsv_frame->enc_ctrl;
1103  }
1104 
1105  ret = av_new_packet(&new_pkt, q->packet_size);
1106  if (ret < 0) {
1107  av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
1108  return ret;
1109  }
1110 
1111  bs = av_mallocz(sizeof(*bs));
1112  if (!bs) {
1113  av_packet_unref(&new_pkt);
1114  return AVERROR(ENOMEM);
1115  }
1116  bs->Data = new_pkt.data;
1117  bs->MaxLength = new_pkt.size;
1118 
1119  if (q->set_encode_ctrl_cb) {
1120  q->set_encode_ctrl_cb(avctx, frame, &qsv_frame->enc_ctrl);
1121  }
1122 
1123  sync = av_mallocz(sizeof(*sync));
1124  if (!sync) {
1125  av_freep(&bs);
1126  av_packet_unref(&new_pkt);
1127  return AVERROR(ENOMEM);
1128  }
1129 
1130  do {
1131  ret = MFXVideoENCODE_EncodeFrameAsync(q->session, enc_ctrl, surf, bs, sync);
1132  if (ret == MFX_WRN_DEVICE_BUSY)
1133  av_usleep(500);
1134  } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_WRN_IN_EXECUTION);
1135 
1136  if (ret > 0)
1137  ff_qsv_print_warning(avctx, ret, "Warning during encoding");
1138 
1139  if (ret < 0) {
1140  av_packet_unref(&new_pkt);
1141  av_freep(&bs);
1142  av_freep(&sync);
1143  return (ret == MFX_ERR_MORE_DATA) ?
1144  0 : ff_qsv_print_error(avctx, ret, "Error during encoding");
1145  }
1146 
1147  if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM && frame->interlaced_frame)
1148  print_interlace_msg(avctx, q);
1149 
1150  if (*sync) {
1151  av_fifo_generic_write(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1152  av_fifo_generic_write(q->async_fifo, &sync, sizeof(sync), NULL);
1153  av_fifo_generic_write(q->async_fifo, &bs, sizeof(bs), NULL);
1154  } else {
1155  av_freep(&sync);
1156  av_packet_unref(&new_pkt);
1157  av_freep(&bs);
1158  }
1159 
1160  return 0;
1161 }
1162 
1164  AVPacket *pkt, const AVFrame *frame, int *got_packet)
1165 {
1166  int ret;
1167 
1168  ret = encode_frame(avctx, q, frame);
1169  if (ret < 0)
1170  return ret;
1171 
1172  if (!av_fifo_space(q->async_fifo) ||
1173  (!frame && av_fifo_size(q->async_fifo))) {
1174  AVPacket new_pkt;
1175  mfxBitstream *bs;
1176  mfxSyncPoint *sync;
1177 
1178  av_fifo_generic_read(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1179  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1180  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1181 
1182  do {
1183  ret = MFXVideoCORE_SyncOperation(q->session, *sync, 1000);
1184  } while (ret == MFX_WRN_IN_EXECUTION);
1185 
1186  new_pkt.dts = av_rescale_q(bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
1187  new_pkt.pts = av_rescale_q(bs->TimeStamp, (AVRational){1, 90000}, avctx->time_base);
1188  new_pkt.size = bs->DataLength;
1189 
1190  if (bs->FrameType & MFX_FRAMETYPE_IDR ||
1191  bs->FrameType & MFX_FRAMETYPE_xIDR)
1192  new_pkt.flags |= AV_PKT_FLAG_KEY;
1193 
1194 #if FF_API_CODED_FRAME
1196  if (bs->FrameType & MFX_FRAMETYPE_I || bs->FrameType & MFX_FRAMETYPE_xI)
1198  else if (bs->FrameType & MFX_FRAMETYPE_P || bs->FrameType & MFX_FRAMETYPE_xP)
1200  else if (bs->FrameType & MFX_FRAMETYPE_B || bs->FrameType & MFX_FRAMETYPE_xB)
1203 #endif
1204 
1205  av_freep(&bs);
1206  av_freep(&sync);
1207 
1208  if (pkt->data) {
1209  if (pkt->size < new_pkt.size) {
1210  av_log(avctx, AV_LOG_ERROR, "Submitted buffer not large enough: %d < %d\n",
1211  pkt->size, new_pkt.size);
1212  av_packet_unref(&new_pkt);
1213  return AVERROR(EINVAL);
1214  }
1215 
1216  memcpy(pkt->data, new_pkt.data, new_pkt.size);
1217  pkt->size = new_pkt.size;
1218 
1219  ret = av_packet_copy_props(pkt, &new_pkt);
1220  av_packet_unref(&new_pkt);
1221  if (ret < 0)
1222  return ret;
1223  } else
1224  *pkt = new_pkt;
1225 
1226  *got_packet = 1;
1227  }
1228 
1229  return 0;
1230 }
1231 
1233 {
1234  QSVFrame *cur;
1235 
1236  if (q->session)
1237  MFXVideoENCODE_Close(q->session);
1238  if (q->internal_session)
1239  MFXClose(q->internal_session);
1240  q->session = NULL;
1241  q->internal_session = NULL;
1242 
1245 
1246  cur = q->work_frames;
1247  while (cur) {
1248  q->work_frames = cur->next;
1249  av_frame_free(&cur->frame);
1250  av_free(cur->enc_ctrl.Payload);
1251  av_freep(&cur);
1252  cur = q->work_frames;
1253  }
1254 
1255  while (q->async_fifo && av_fifo_size(q->async_fifo)) {
1256  AVPacket pkt;
1257  mfxSyncPoint *sync;
1258  mfxBitstream *bs;
1259 
1260  av_fifo_generic_read(q->async_fifo, &pkt, sizeof(pkt), NULL);
1261  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1262  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1263 
1264  av_freep(&sync);
1265  av_freep(&bs);
1266  av_packet_unref(&pkt);
1267  }
1269  q->async_fifo = NULL;
1270 
1273 
1274  av_freep(&q->extparam);
1275 
1276  return 0;
1277 }
int single_sei_nal_unit
Definition: qsvenc.h:139
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:3012
const char const char void * val
Definition: avisynth_c.h:771
#define QSV_MAX_ENC_PAYLOAD
Definition: qsv_internal.h:35
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:125
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2363
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201
AVBufferRef * opaque_alloc_buf
Definition: qsvenc.h:112
mfxExtBuffer ** extparam
Definition: qsvenc.h:117
static int init_video_param_jpeg(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:354
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:871
int int_ref_type
Definition: qsvenc.h:151
#define QSV_HAVE_LA
Definition: qsvenc.h:44
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
mfxExtOpaqueSurfaceAlloc opaque_alloc
Definition: qsvenc.h:110
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1552
Memory handling functions.
This struct is allocated as AVHWFramesContext.hwctx.
Definition: hwcontext_qsv.h:42
const char * desc
Definition: nvenc.c:63
int max_frame_size
Definition: qsvenc.h:136
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:1101
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:1761
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2403
mfxFrameAllocRequest req
Definition: qsvenc.h:103
int avbr_accuracy
Definition: qsvenc.h:128
mfxEncodeCtrl enc_ctrl
Definition: qsv_internal.h:53
QSVFrame * work_frames
Definition: qsvenc.h:93
int num
Numerator.
Definition: rational.h:59
int repeat_pict
When decoding, this signals how much the picture must be delayed.
Definition: frame.h:343
int look_ahead_depth
Definition: qsvenc.h:132
static int get_free_frame(QSVEncContext *q, QSVFrame **f)
Definition: qsvenc.c:957
int size
Definition: avcodec.h:1415
int int_ref_qp_delta
Definition: qsvenc.h:153
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:1880
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1711
QSVFramesContext frames_ctx
Definition: qsvenc.h:121
int packet_size
Definition: qsvenc.h:98
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
mfxSession internal_session
Definition: qsvenc.h:96
static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1069
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:1813
int min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: avcodec.h:1106
AVBufferRef * hw_frames_ctx
Definition: qsv_internal.h:62
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:140
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1624
int bitrate_limit
Definition: qsvenc.h:143
int look_ahead
Definition: qsvenc.h:131
int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: qsvenc.c:1163
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
mfxVideoParam param
Definition: qsvenc.h:102
uint8_t
#define QSV_HAVE_CO2
Definition: qsvenc.h:37
#define QSV_HAVE_LA_HRD
Definition: qsvenc.h:46
AVFifoBuffer * async_fifo
Definition: qsvenc.h:119
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:150
void * hwaccel_context
Hardware accelerator context.
Definition: avcodec.h:2670
AVBufferRef * mids_buf
Definition: qsv_internal.h:69
mfxExtCodingOption extco
Definition: qsvenc.h:105
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:1770
mfxExtBuffer * extparam_internal[2+QSV_HAVE_CO2]
Definition: qsvenc.h:114
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:400
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:294
int av_fifo_space(const AVFifoBuffer *f)
Return the amount of space in bytes in the AVFifoBuffer, that is the amount of data you can write int...
Definition: fifo.c:82
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1602
int opaque_alloc
Encoding only.
Definition: qsv.h:65
static AVFrame * frame
mfxFrameSurface1 ** opaque_surfaces
Definition: qsvenc.h:111
uint8_t * data
Definition: avcodec.h:1414
static int qsv_retrieve_enc_jpeg_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:636
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:348
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: avcodec.h:1117
int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1232
static const char * print_threestate(mfxU16 val)
Definition: qsvenc.c:119
int ff_qsv_init_session_frames(AVCodecContext *avctx, mfxSession *psession, QSVFramesContext *qsv_frames_ctx, const char *load_plugins, int opaque)
Definition: qsv.c:611
#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:1446
int b_strategy
Definition: qsvenc.h:148
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
static int rc_supported(QSVEncContext *q)
Definition: qsvenc.c:342
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 width
Definition: frame.h:259
#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:187
static const struct @121 profile_names[]
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:163
char * load_plugins
Definition: qsvenc.h:157
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 flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1582
int nb_extparam_internal
Definition: qsvenc.h:115
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:1806
int max_dec_frame_buffering
Definition: qsvenc.h:140
int iopattern
The IO pattern to use.
Definition: qsv.h:46
#define FFMAX(a, b)
Definition: common.h:94
static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:654
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:746
int adaptive_i
Definition: qsvenc.h:146
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2360
int ff_qsv_print_warning(void *log_ctx, mfxStatus err, const char *warning_string)
Definition: qsv.c:150
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:2382
int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc)
Definition: qsv.c:170
int refs
number of reference frames
Definition: avcodec.h:2085
static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q, mfxExtBuffer **coding_opts)
Definition: qsvenc.c:128
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: avpacket.c:558
const char * name
Definition: qsvenc.c:45
AVCodecContext * avctx
Definition: qsvenc.h:91
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:284
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:830
int idr_interval
Definition: qsvenc.h:125
int width
picture width / height.
Definition: avcodec.h:1674
int extbrc
Definition: qsvenc.h:145
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:3168
int preset
Definition: qsvenc.h:127
int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)
Definition: qsv.c:42
static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:263
int level
level
Definition: avcodec.h:2925
#define MFX_LOOKAHEAD_DS_OFF
Definition: qsvenc.h:60
static const char * print_profile(mfxU16 profile)
Definition: qsvenc.c:72
mfxFrameSurface1 surface
Definition: qsv_internal.h:52
#define MFX_LOOKAHEAD_DS_2x
Definition: qsvenc.h:61
int async_depth
Definition: qsvenc.h:124
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
attribute_deprecated int coder_type
Definition: avcodec.h:2414
#define FF_ARRAY_ELEMS(a)
int width_align
Definition: qsvenc.h:99
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:274
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:1096
static int qsvenc_init_session(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:766
Libavcodec external API header.
enum AVCodecID codec_id
Definition: avcodec.h:1512
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
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:232
attribute_deprecated int b_frame_strategy
Definition: avcodec.h:1775
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:1502
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:590
uint8_t * data
The data buffer.
Definition: buffer.h:89
struct QSVFrame * next
Definition: qsv_internal.h:58
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:161
int profile
Definition: qsvenc.h:126
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1886
static void free_encoder_ctrl_payloads(mfxEncodeCtrl *enc_ctrl)
Definition: qsvenc.c:933
int extradata_size
Definition: avcodec.h:1603
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:83
#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:100
#define FF_CODER_TYPE_VLC
Definition: avcodec.h:2406
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2563
int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:806
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:218
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:1783
int max_slice_size
Definition: qsvenc.h:137
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
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:510
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1568
int int_ref_cycle_size
Definition: qsvenc.h:152
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:215
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1696
int adaptive_b
Definition: qsvenc.h:147
#define QSV_HAVE_ICQ
Definition: qsvenc.h:53
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
common internal and external API header
if(ret< 0)
Definition: vf_mcdeint.c:279
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
Bi-dir predicted.
Definition: avutil.h:276
int avbr_convergence
Definition: qsvenc.h:129
int ff_qsv_init_internal_session(AVCodecContext *avctx, mfxSession *session, const char *load_plugins)
Definition: qsv.c:249
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2744
int den
Denominator.
Definition: rational.h:60
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:2164
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:770
static const struct @122 rc_names[]
int slices
Number of slices.
Definition: avcodec.h:2148
#define MFX_LOOKAHEAD_DS_4x
Definition: qsvenc.h:62
int recovery_point_sei
Definition: qsvenc.h:154
#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:353
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:1111
#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:1413
int look_ahead_downsampling
Definition: qsvenc.h:133
static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:412
int height
Definition: frame.h:259
static const char * print_ratecontrol(mfxU16 rc_mode)
Definition: qsvenc.c:110
#define av_freep(p)
An API-specific header for AV_HWDEVICE_TYPE_QSV.
AVFrame * frame
Definition: qsv_internal.h:51
#define av_malloc_array(a, b)
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:893
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:3220
int trellis
Definition: qsvenc.h:141
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
This structure stores compressed data.
Definition: avcodec.h:1391
mfxSession session
Definition: qsvenc.h:95
static int qsv_init_opaque_alloc(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:729
#define QSV_HAVE_VCM
Definition: qsvenc.h:54
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1132
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:2560
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:3019
for(j=16;j >0;--j)
int pic_timing_sei
Definition: qsvenc.h:130
static int encode_frame(AVCodecContext *avctx, QSVEncContext *q, const AVFrame *frame)
Definition: qsvenc.c:1081
Predicted.
Definition: avutil.h:275
int ff_qsv_init_session_device(AVCodecContext *avctx, mfxSession *psession, AVBufferRef *device_ref, const char *load_plugins)
Definition: qsv.c:543
static int submit_frame(QSVEncContext *q, const AVFrame *frame, QSVFrame **new_frame)
Definition: qsvenc.c:997
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2375
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
SetEncodeCtrlCB * set_encode_ctrl_cb
Definition: qsvenc.h:158
static void clear_unused_frames(QSVEncContext *q)
Definition: qsvenc.c:944