Libav
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 Libav.
8  *
9  * Libav 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  * Libav 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 Libav; 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 
36 #include "avcodec.h"
37 #include "internal.h"
38 #include "qsv.h"
39 #include "qsv_internal.h"
40 #include "qsvenc.h"
41 
42 static const struct {
43  mfxU16 profile;
44  const char *name;
45 } profile_names[] = {
46  { MFX_PROFILE_AVC_BASELINE, "baseline" },
47  { MFX_PROFILE_AVC_MAIN, "main" },
48  { MFX_PROFILE_AVC_EXTENDED, "extended" },
49  { MFX_PROFILE_AVC_HIGH, "high" },
50 #if QSV_VERSION_ATLEAST(1, 15)
51  { MFX_PROFILE_AVC_HIGH_422, "high 422" },
52 #endif
53 #if QSV_VERSION_ATLEAST(1, 4)
54  { MFX_PROFILE_AVC_CONSTRAINED_BASELINE, "constrained baseline" },
55  { MFX_PROFILE_AVC_CONSTRAINED_HIGH, "constrained high" },
56  { MFX_PROFILE_AVC_PROGRESSIVE_HIGH, "progressive high" },
57 #endif
58  { MFX_PROFILE_MPEG2_SIMPLE, "simple" },
59  { MFX_PROFILE_MPEG2_MAIN, "main" },
60  { MFX_PROFILE_MPEG2_HIGH, "high" },
61  { MFX_PROFILE_VC1_SIMPLE, "simple" },
62  { MFX_PROFILE_VC1_MAIN, "main" },
63  { MFX_PROFILE_VC1_ADVANCED, "advanced" },
64 #if QSV_VERSION_ATLEAST(1, 8)
65  { MFX_PROFILE_HEVC_MAIN, "main" },
66  { MFX_PROFILE_HEVC_MAIN10, "main10" },
67  { MFX_PROFILE_HEVC_MAINSP, "mainsp" },
68 #endif
69 };
70 
71 static const char *print_profile(mfxU16 profile)
72 {
73  int i;
74  for (i = 0; i < FF_ARRAY_ELEMS(profile_names); i++)
75  if (profile == profile_names[i].profile)
76  return profile_names[i].name;
77  return "unknown";
78 }
79 
80 static const struct {
81  mfxU16 rc_mode;
82  const char *name;
83 } rc_names[] = {
84  { MFX_RATECONTROL_CBR, "CBR" },
85  { MFX_RATECONTROL_VBR, "VBR" },
86  { MFX_RATECONTROL_CQP, "CQP" },
87  { MFX_RATECONTROL_AVBR, "AVBR" },
88 #if QSV_HAVE_LA
89  { MFX_RATECONTROL_LA, "LA" },
90 #endif
91 #if QSV_HAVE_ICQ
92  { MFX_RATECONTROL_ICQ, "ICQ" },
93  { MFX_RATECONTROL_LA_ICQ, "LA_ICQ" },
94 #endif
95 #if QSV_HAVE_VCM
96  { MFX_RATECONTROL_VCM, "VCM" },
97 #endif
98 #if QSV_VERSION_ATLEAST(1, 10)
99  { MFX_RATECONTROL_LA_EXT, "LA_EXT" },
100 #endif
101 #if QSV_HAVE_LA_HRD
102  { MFX_RATECONTROL_LA_HRD, "LA_HRD" },
103 #endif
104 #if QSV_HAVE_QVBR
105  { MFX_RATECONTROL_QVBR, "QVBR" },
106 #endif
107 };
108 
109 static const char *print_ratecontrol(mfxU16 rc_mode)
110 {
111  int i;
112  for (i = 0; i < FF_ARRAY_ELEMS(rc_names); i++)
113  if (rc_mode == rc_names[i].rc_mode)
114  return rc_names[i].name;
115  return "unknown";
116 }
117 
118 static const char *print_threestate(mfxU16 val)
119 {
120  if (val == MFX_CODINGOPTION_ON)
121  return "ON";
122  else if (val == MFX_CODINGOPTION_OFF)
123  return "OFF";
124  return "unknown";
125 }
126 
128  mfxExtBuffer **coding_opts)
129 {
130  mfxInfoMFX *info = &q->param.mfx;
131 
132  mfxExtCodingOption *co = (mfxExtCodingOption*)coding_opts[0];
133 #if QSV_HAVE_CO2
134  mfxExtCodingOption2 *co2 = (mfxExtCodingOption2*)coding_opts[1];
135 #endif
136 #if QSV_HAVE_CO3
137  mfxExtCodingOption3 *co3 = (mfxExtCodingOption3*)coding_opts[2];
138 #endif
139 
140  av_log(avctx, AV_LOG_VERBOSE, "profile: %s; level: %"PRIu16"\n",
141  print_profile(info->CodecProfile), info->CodecLevel);
142 
143  av_log(avctx, AV_LOG_VERBOSE, "GopPicSize: %"PRIu16"; GopRefDist: %"PRIu16"; GopOptFlag: ",
144  info->GopPicSize, info->GopRefDist);
145  if (info->GopOptFlag & MFX_GOP_CLOSED)
146  av_log(avctx, AV_LOG_VERBOSE, "closed ");
147  if (info->GopOptFlag & MFX_GOP_STRICT)
148  av_log(avctx, AV_LOG_VERBOSE, "strict ");
149  av_log(avctx, AV_LOG_VERBOSE, "; IdrInterval: %"PRIu16"\n", info->IdrInterval);
150 
151  av_log(avctx, AV_LOG_VERBOSE, "TargetUsage: %"PRIu16"; RateControlMethod: %s\n",
152  info->TargetUsage, print_ratecontrol(info->RateControlMethod));
153 
154  if (info->RateControlMethod == MFX_RATECONTROL_CBR ||
155  info->RateControlMethod == MFX_RATECONTROL_VBR
156 #if QSV_HAVE_VCM
157  || info->RateControlMethod == MFX_RATECONTROL_VCM
158 #endif
159  ) {
160  av_log(avctx, AV_LOG_VERBOSE,
161  "InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"\n",
162  info->InitialDelayInKB, info->TargetKbps, info->MaxKbps);
163  } else if (info->RateControlMethod == MFX_RATECONTROL_CQP) {
164  av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",
165  info->QPI, info->QPP, info->QPB);
166  } else if (info->RateControlMethod == MFX_RATECONTROL_AVBR) {
167  av_log(avctx, AV_LOG_VERBOSE,
168  "TargetKbps: %"PRIu16"; Accuracy: %"PRIu16"; Convergence: %"PRIu16"\n",
169  info->TargetKbps, info->Accuracy, info->Convergence);
170  }
171 #if QSV_HAVE_LA
172  else if (info->RateControlMethod == MFX_RATECONTROL_LA
173 #if QSV_HAVE_LA_HRD
174  || info->RateControlMethod == MFX_RATECONTROL_LA_HRD
175 #endif
176  ) {
177  av_log(avctx, AV_LOG_VERBOSE,
178  "TargetKbps: %"PRIu16"; LookAheadDepth: %"PRIu16"\n",
179  info->TargetKbps, co2->LookAheadDepth);
180  }
181 #endif
182 #if QSV_HAVE_ICQ
183  else if (info->RateControlMethod == MFX_RATECONTROL_ICQ) {
184  av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);
185  } else if (info->RateControlMethod == MFX_RATECONTROL_LA_ICQ) {
186  av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"; LookAheadDepth: %"PRIu16"\n",
187  info->ICQQuality, co2->LookAheadDepth);
188  }
189 #endif
190 #if QSV_HAVE_QVBR
191  else if (info->RateControlMethod == MFX_RATECONTROL_QVBR) {
192  av_log(avctx, AV_LOG_VERBOSE, "QVBRQuality: %"PRIu16"\n",
193  co3->QVBRQuality);
194  }
195 #endif
196 
197  av_log(avctx, AV_LOG_VERBOSE, "NumSlice: %"PRIu16"; NumRefFrame: %"PRIu16"\n",
198  info->NumSlice, info->NumRefFrame);
199  av_log(avctx, AV_LOG_VERBOSE, "RateDistortionOpt: %s\n",
200  print_threestate(co->RateDistortionOpt));
201 
202 #if QSV_HAVE_CO2
203  av_log(avctx, AV_LOG_VERBOSE,
204  "RecoveryPointSEI: %s IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16"; IntRefQPDelta: %"PRId16"\n",
205  print_threestate(co->RecoveryPointSEI), co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);
206 
207  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %"PRIu16"; ", co2->MaxFrameSize);
208 #if QSV_HAVE_MAX_SLICE_SIZE
209  av_log(avctx, AV_LOG_VERBOSE, "MaxSliceSize: %"PRIu16"; ", co2->MaxSliceSize);
210 #endif
211  av_log(avctx, AV_LOG_VERBOSE, "\n");
212 
213  av_log(avctx, AV_LOG_VERBOSE,
214  "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
215  print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),
216  print_threestate(co2->ExtBRC));
217 
218 #if QSV_HAVE_TRELLIS
219  av_log(avctx, AV_LOG_VERBOSE, "Trellis: ");
220  if (co2->Trellis & MFX_TRELLIS_OFF) {
221  av_log(avctx, AV_LOG_VERBOSE, "off");
222  } else if (!co2->Trellis) {
223  av_log(avctx, AV_LOG_VERBOSE, "auto");
224  } else {
225  if (co2->Trellis & MFX_TRELLIS_I) av_log(avctx, AV_LOG_VERBOSE, "I");
226  if (co2->Trellis & MFX_TRELLIS_P) av_log(avctx, AV_LOG_VERBOSE, "P");
227  if (co2->Trellis & MFX_TRELLIS_B) av_log(avctx, AV_LOG_VERBOSE, "B");
228  }
229  av_log(avctx, AV_LOG_VERBOSE, "\n");
230 #endif
231 
232 #if QSV_VERSION_ATLEAST(1, 8)
233  av_log(avctx, AV_LOG_VERBOSE,
234  "RepeatPPS: %s; NumMbPerSlice: %"PRIu16"; LookAheadDS: ",
235  print_threestate(co2->RepeatPPS), co2->NumMbPerSlice);
236  switch (co2->LookAheadDS) {
237  case MFX_LOOKAHEAD_DS_OFF: av_log(avctx, AV_LOG_VERBOSE, "off"); break;
238  case MFX_LOOKAHEAD_DS_2x: av_log(avctx, AV_LOG_VERBOSE, "2x"); break;
239  case MFX_LOOKAHEAD_DS_4x: av_log(avctx, AV_LOG_VERBOSE, "4x"); break;
240  default: av_log(avctx, AV_LOG_VERBOSE, "unknown"); break;
241  }
242  av_log(avctx, AV_LOG_VERBOSE, "\n");
243 
244  av_log(avctx, AV_LOG_VERBOSE, "AdaptiveI: %s; AdaptiveB: %s; BRefType: ",
245  print_threestate(co2->AdaptiveI), print_threestate(co2->AdaptiveB));
246  switch (co2->BRefType) {
247  case MFX_B_REF_OFF: av_log(avctx, AV_LOG_VERBOSE, "off"); break;
248  case MFX_B_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "pyramid"); break;
249  default: av_log(avctx, AV_LOG_VERBOSE, "auto"); break;
250  }
251  av_log(avctx, AV_LOG_VERBOSE, "\n");
252 #endif
253 
254 #if QSV_VERSION_ATLEAST(1, 9)
255  av_log(avctx, AV_LOG_VERBOSE,
256  "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",
257  co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
258 #endif
259 #endif
260 
261  if (avctx->codec_id == AV_CODEC_ID_H264) {
262  av_log(avctx, AV_LOG_VERBOSE, "Entropy coding: %s; MaxDecFrameBuffering: %"PRIu16"\n",
263  co->CAVLC == MFX_CODINGOPTION_ON ? "CAVLC" : "CABAC", co->MaxDecFrameBuffering);
264  av_log(avctx, AV_LOG_VERBOSE,
265  "NalHrdConformance: %s; SingleSeiNalUnit: %s; VuiVclHrdParameters: %s VuiNalHrdParameters: %s\n",
266  print_threestate(co->NalHrdConformance), print_threestate(co->SingleSeiNalUnit),
267  print_threestate(co->VuiVclHrdParameters), print_threestate(co->VuiNalHrdParameters));
268  }
269 }
270 
272 {
273  const char *rc_desc;
274  mfxU16 rc_mode;
275 
276  int want_la = q->la_depth >= 0;
277  int want_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
278  int want_vcm = q->vcm;
279 
280  if (want_la && !QSV_HAVE_LA) {
281  av_log(avctx, AV_LOG_ERROR,
282  "Lookahead ratecontrol mode requested, but is not supported by this SDK version\n");
283  return AVERROR(ENOSYS);
284  }
285  if (want_vcm && !QSV_HAVE_VCM) {
286  av_log(avctx, AV_LOG_ERROR,
287  "VCM ratecontrol mode requested, but is not supported by this SDK version\n");
288  return AVERROR(ENOSYS);
289  }
290 
291  if (want_la + want_qscale + want_vcm > 1) {
292  av_log(avctx, AV_LOG_ERROR,
293  "More than one of: { constant qscale, lookahead, VCM } requested, "
294  "only one of them can be used at a time.\n");
295  return AVERROR(EINVAL);
296  }
297 
298  if (want_qscale) {
299  rc_mode = MFX_RATECONTROL_CQP;
300  rc_desc = "constant quantization parameter (CQP)";
301  }
302 #if QSV_HAVE_VCM
303  else if (want_vcm) {
304  rc_mode = MFX_RATECONTROL_VCM;
305  rc_desc = "video conferencing mode (VCM)";
306  }
307 #endif
308 #if QSV_HAVE_LA
309  else if (want_la) {
310  rc_mode = MFX_RATECONTROL_LA;
311  rc_desc = "VBR with lookahead (LA)";
312 
313 #if QSV_HAVE_ICQ
314  if (avctx->global_quality > 0) {
315  rc_mode = MFX_RATECONTROL_LA_ICQ;
316  rc_desc = "intelligent constant quality with lookahead (LA_ICQ)";
317  }
318 #endif
319  }
320 #endif
321 #if QSV_HAVE_ICQ
322  else if (avctx->global_quality > 0) {
323  rc_mode = MFX_RATECONTROL_ICQ;
324  rc_desc = "intelligent constant quality (ICQ)";
325  }
326 #endif
327  else if (avctx->rc_max_rate == avctx->bit_rate) {
328  rc_mode = MFX_RATECONTROL_CBR;
329  rc_desc = "constant bitrate (CBR)";
330  } else if (!avctx->rc_max_rate) {
331  rc_mode = MFX_RATECONTROL_AVBR;
332  rc_desc = "average variable bitrate (AVBR)";
333  } else {
334  rc_mode = MFX_RATECONTROL_VBR;
335  rc_desc = "variable bitrate (VBR)";
336  }
337 
338  q->param.mfx.RateControlMethod = rc_mode;
339  av_log(avctx, AV_LOG_VERBOSE, "Using the %s ratecontrol method\n", rc_desc);
340 
341  return 0;
342 }
343 
345 {
346  mfxVideoParam param_out = { .mfx.CodecId = q->param.mfx.CodecId };
347  mfxStatus ret;
348 
349  ret = MFXVideoENCODE_Query(q->session, &q->param, &param_out);
350  if (ret < 0 ||
351  param_out.mfx.RateControlMethod != q->param.mfx.RateControlMethod)
352  return 0;
353  return 1;
354 }
355 
357 {
358  enum AVPixelFormat sw_format = avctx->pix_fmt == AV_PIX_FMT_QSV ?
359  avctx->sw_pix_fmt : avctx->pix_fmt;
360  const AVPixFmtDescriptor *desc;
361  float quant;
362  int ret;
363 
364  ret = ff_qsv_codec_id_to_mfx(avctx->codec_id);
365  if (ret < 0)
366  return AVERROR_BUG;
367  q->param.mfx.CodecId = ret;
368 
369  q->width_align = avctx->codec_id == AV_CODEC_ID_HEVC ? 32 : 16;
370 
371  if (avctx->level > 0)
372  q->param.mfx.CodecLevel = avctx->level;
373 
374  q->param.mfx.CodecProfile = q->profile;
375  q->param.mfx.TargetUsage = q->preset;
376  q->param.mfx.GopPicSize = FFMAX(0, avctx->gop_size);
377  q->param.mfx.GopRefDist = FFMAX(-1, avctx->max_b_frames) + 1;
378  q->param.mfx.GopOptFlag = avctx->flags & AV_CODEC_FLAG_CLOSED_GOP ?
379  MFX_GOP_CLOSED : 0;
380  q->param.mfx.IdrInterval = q->idr_interval;
381  q->param.mfx.NumSlice = avctx->slices;
382  q->param.mfx.NumRefFrame = FFMAX(0, avctx->refs);
383  q->param.mfx.EncodedOrder = 0;
384  q->param.mfx.BufferSizeInKB = 0;
385 
386  desc = av_pix_fmt_desc_get(sw_format);
387  if (!desc)
388  return AVERROR_BUG;
389 
390  ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC);
391 
392  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, q->width_align);
393  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, 32);
394  q->param.mfx.FrameInfo.CropX = 0;
395  q->param.mfx.FrameInfo.CropY = 0;
396  q->param.mfx.FrameInfo.CropW = avctx->width;
397  q->param.mfx.FrameInfo.CropH = avctx->height;
398  q->param.mfx.FrameInfo.AspectRatioW = avctx->sample_aspect_ratio.num;
399  q->param.mfx.FrameInfo.AspectRatioH = avctx->sample_aspect_ratio.den;
400  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
401  q->param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
402  q->param.mfx.FrameInfo.BitDepthLuma = desc->comp[0].depth;
403  q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
404  q->param.mfx.FrameInfo.Shift = desc->comp[0].depth > 8;
405 
406  if (avctx->hw_frames_ctx) {
407  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
408  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
409  q->param.mfx.FrameInfo.Width = frames_hwctx->surfaces[0].Info.Width;
410  q->param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;
411  }
412 
413  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
414  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
415  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
416  } else {
417  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
418  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
419  }
420 
421  ret = select_rc_mode(avctx, q);
422  if (ret < 0)
423  return ret;
424 
425  switch (q->param.mfx.RateControlMethod) {
426  case MFX_RATECONTROL_CBR:
427  case MFX_RATECONTROL_VBR:
428 #if QSV_HAVE_VCM
429  case MFX_RATECONTROL_VCM:
430 #endif
431  q->param.mfx.InitialDelayInKB = avctx->rc_initial_buffer_occupancy / 1000;
432  q->param.mfx.TargetKbps = avctx->bit_rate / 1000;
433  q->param.mfx.MaxKbps = avctx->rc_max_rate / 1000;
434  break;
435  case MFX_RATECONTROL_CQP:
436  quant = avctx->global_quality / FF_QP2LAMBDA;
437 
438  q->param.mfx.QPI = av_clip(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 0, 51);
439  q->param.mfx.QPP = av_clip(quant, 0, 51);
440  q->param.mfx.QPB = av_clip(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 0, 51);
441 
442  break;
443  case MFX_RATECONTROL_AVBR:
444  q->param.mfx.TargetKbps = avctx->bit_rate / 1000;
445  q->param.mfx.Convergence = q->avbr_convergence;
446  q->param.mfx.Accuracy = q->avbr_accuracy;
447  break;
448 #if QSV_HAVE_LA
449  case MFX_RATECONTROL_LA:
450  q->param.mfx.TargetKbps = avctx->bit_rate / 1000;
451  q->extco2.LookAheadDepth = q->la_depth;
452  break;
453 #if QSV_HAVE_ICQ
454  case MFX_RATECONTROL_LA_ICQ:
455  q->extco2.LookAheadDepth = q->la_depth;
456  case MFX_RATECONTROL_ICQ:
457  q->param.mfx.ICQQuality = avctx->global_quality;
458  break;
459 #endif
460 #endif
461  }
462 
463  // the HEVC encoder plugin currently fails if coding options
464  // are provided
465  if (avctx->codec_id != AV_CODEC_ID_HEVC) {
466  q->extco.Header.BufferId = MFX_EXTBUFF_CODING_OPTION;
467  q->extco.Header.BufferSz = sizeof(q->extco);
468 #if FF_API_CODER_TYPE
470  if (avctx->coder_type != 0)
471  q->cavlc = avctx->coder_type == FF_CODER_TYPE_VLC;
473 #endif
474  q->extco.CAVLC = q->cavlc ? MFX_CODINGOPTION_ON
475  : MFX_CODINGOPTION_UNKNOWN;
476 
477  if (q->rdo >= 0)
478  q->extco.RateDistortionOpt = q->rdo > 0 ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
479 
480  if (avctx->codec_id == AV_CODEC_ID_H264) {
482  q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?
483  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
484 
485  if (q->single_sei_nal_unit >= 0)
486  q->extco.SingleSeiNalUnit = q->single_sei_nal_unit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
487  if (q->recovery_point_sei >= 0)
488  q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
489  q->extco.MaxDecFrameBuffering = q->max_dec_frame_buffering;
490  }
491 
492  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco;
493 
494 #if QSV_HAVE_CO2
495  if (avctx->codec_id == AV_CODEC_ID_H264) {
496  q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
497  q->extco2.Header.BufferSz = sizeof(q->extco2);
498 
499  if (q->int_ref_type >= 0)
500  q->extco2.IntRefType = q->int_ref_type;
501  if (q->int_ref_cycle_size >= 0)
502  q->extco2.IntRefCycleSize = q->int_ref_cycle_size;
503  if (q->int_ref_qp_delta != INT16_MIN)
504  q->extco2.IntRefQPDelta = q->int_ref_qp_delta;
505 
506  if (q->bitrate_limit >= 0)
507  q->extco2.BitrateLimit = q->bitrate_limit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
508  if (q->mbbrc >= 0)
509  q->extco2.MBBRC = q->mbbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
510  if (q->extbrc >= 0)
511  q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
512 
513  if (q->max_frame_size >= 0)
514  q->extco2.MaxFrameSize = q->max_frame_size;
515 #if QSV_HAVE_MAX_SLICE_SIZE
516  if (q->max_slice_size >= 0)
517  q->extco2.MaxSliceSize = q->max_slice_size;
518 #endif
519 
520 #if QSV_HAVE_TRELLIS
521  q->extco2.Trellis = q->trellis;
522 #endif
523 
524 #if QSV_HAVE_BREF_TYPE
525 #if FF_API_PRIVATE_OPT
527  if (avctx->b_frame_strategy >= 0)
528  q->b_strategy = avctx->b_frame_strategy;
530 #endif
531  if (q->b_strategy >= 0)
532  q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
533  if (q->adaptive_i >= 0)
534  q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
535  if (q->adaptive_b >= 0)
536  q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
537 #endif
538 
539  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
540  }
541 #endif
542  }
543 
544  if (!rc_supported(q)) {
545  av_log(avctx, AV_LOG_ERROR,
546  "Selected ratecontrol mode is not supported by the QSV "
547  "runtime. Choose a different mode.\n");
548  return AVERROR(ENOSYS);
549  }
550 
551  return 0;
552 }
553 
555 {
556  AVCPBProperties *cpb_props;
557 
558  uint8_t sps_buf[128];
559  uint8_t pps_buf[128];
560 
561  mfxExtCodingOptionSPSPPS extradata = {
562  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
563  .Header.BufferSz = sizeof(extradata),
564  .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),
565  .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
566  };
567 
568  mfxExtCodingOption co = {
569  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
570  .Header.BufferSz = sizeof(co),
571  };
572 #if QSV_HAVE_CO2
573  mfxExtCodingOption2 co2 = {
574  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
575  .Header.BufferSz = sizeof(co2),
576  };
577 #endif
578 #if QSV_HAVE_CO3
579  mfxExtCodingOption3 co3 = {
580  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
581  .Header.BufferSz = sizeof(co3),
582  };
583 #endif
584 
585  mfxExtBuffer *ext_buffers[] = {
586  (mfxExtBuffer*)&extradata,
587  (mfxExtBuffer*)&co,
588 #if QSV_HAVE_CO2
589  (mfxExtBuffer*)&co2,
590 #endif
591 #if QSV_HAVE_CO3
592  (mfxExtBuffer*)&co3,
593 #endif
594  };
595 
596  int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
597  int ret;
598 
599  q->param.ExtParam = ext_buffers;
600  q->param.NumExtParam = FF_ARRAY_ELEMS(ext_buffers);
601 
602  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
603  if (ret < 0)
604  return ff_qsv_print_error(avctx, ret,
605  "Error calling GetVideoParam");
606 
607  q->packet_size = q->param.mfx.BufferSizeInKB * 1000;
608 
609  if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)) {
610  av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
611  return AVERROR_UNKNOWN;
612  }
613 
614  avctx->extradata = av_malloc(extradata.SPSBufSize + need_pps * extradata.PPSBufSize +
616  if (!avctx->extradata)
617  return AVERROR(ENOMEM);
618 
619  memcpy(avctx->extradata, sps_buf, extradata.SPSBufSize);
620  if (need_pps)
621  memcpy(avctx->extradata + extradata.SPSBufSize, pps_buf, extradata.PPSBufSize);
622  avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
623  memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
624 
625  cpb_props = ff_add_cpb_side_data(avctx);
626  if (!cpb_props)
627  return AVERROR(ENOMEM);
628  cpb_props->max_bitrate = avctx->rc_max_rate;
629  cpb_props->min_bitrate = avctx->rc_min_rate;
630  cpb_props->avg_bitrate = avctx->bit_rate;
631  cpb_props->buffer_size = avctx->rc_buffer_size;
632 
633  dump_video_param(avctx, q, ext_buffers + 1);
634 
635  return 0;
636 }
637 
639 {
640  AVQSVContext *qsv = avctx->hwaccel_context;
641  mfxFrameSurface1 *surfaces;
642  int nb_surfaces, i;
643 
644  nb_surfaces = qsv->nb_opaque_surfaces + q->req.NumFrameSuggested + q->async_depth;
645 
646  q->opaque_alloc_buf = av_buffer_allocz(sizeof(*surfaces) * nb_surfaces);
647  if (!q->opaque_alloc_buf)
648  return AVERROR(ENOMEM);
649 
650  q->opaque_surfaces = av_malloc_array(nb_surfaces, sizeof(*q->opaque_surfaces));
651  if (!q->opaque_surfaces)
652  return AVERROR(ENOMEM);
653 
654  surfaces = (mfxFrameSurface1*)q->opaque_alloc_buf->data;
655  for (i = 0; i < nb_surfaces; i++) {
656  surfaces[i].Info = q->req.Info;
657  q->opaque_surfaces[i] = surfaces + i;
658  }
659 
660  q->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
661  q->opaque_alloc.Header.BufferSz = sizeof(q->opaque_alloc);
662  q->opaque_alloc.In.Surfaces = q->opaque_surfaces;
663  q->opaque_alloc.In.NumSurface = nb_surfaces;
664  q->opaque_alloc.In.Type = q->req.Type;
665 
666  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->opaque_alloc;
667 
668  qsv->nb_opaque_surfaces = nb_surfaces;
670  qsv->opaque_alloc_type = q->req.Type;
671 
672  return 0;
673 }
674 
676 {
677  int ret;
678 
679  if (avctx->hwaccel_context) {
680  AVQSVContext *qsv = avctx->hwaccel_context;
681  q->session = qsv->session;
682  } else if (avctx->hw_frames_ctx) {
684  if (!q->frames_ctx.hw_frames_ctx)
685  return AVERROR(ENOMEM);
686 
688  &q->frames_ctx, q->load_plugins,
689  q->param.IOPattern == MFX_IOPATTERN_IN_OPAQUE_MEMORY);
690  if (ret < 0) {
692  return ret;
693  }
694 
695  q->session = q->internal_session;
696  } else {
698  q->load_plugins);
699  if (ret < 0)
700  return ret;
701 
702  q->session = q->internal_session;
703  }
704 
705  return 0;
706 }
707 
709 {
710  int iopattern = 0;
711  int opaque_alloc = 0;
712  int ret;
713 
714  q->param.AsyncDepth = q->async_depth;
715 
716  q->async_fifo = av_fifo_alloc((1 + q->async_depth) *
717  (sizeof(AVPacket) + sizeof(mfxSyncPoint*) + sizeof(mfxBitstream*)));
718  if (!q->async_fifo)
719  return AVERROR(ENOMEM);
720 
721  if (avctx->hwaccel_context) {
722  AVQSVContext *qsv = avctx->hwaccel_context;
723 
724  iopattern = qsv->iopattern;
725  opaque_alloc = qsv->opaque_alloc;
726  }
727 
728  if (avctx->hw_frames_ctx) {
729  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
730  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
731 
732  if (!iopattern) {
733  if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)
734  iopattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
735  else if (frames_hwctx->frame_type &
736  (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
737  iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
738  }
739  }
740 
741  if (!iopattern)
742  iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
743  q->param.IOPattern = iopattern;
744 
745  ret = qsvenc_init_session(avctx, q);
746  if (ret < 0)
747  return ret;
748 
749  ret = init_video_param(avctx, q);
750  if (ret < 0)
751  return ret;
752 
753  ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
754  if (ret < 0)
755  return ff_qsv_print_error(avctx, ret,
756  "Error querying the encoding parameters");
757 
758  if (opaque_alloc) {
759  ret = qsv_init_opaque_alloc(avctx, q);
760  if (ret < 0)
761  return ret;
762  }
763 
764  if (avctx->hwaccel_context) {
765  AVQSVContext *qsv = avctx->hwaccel_context;
766  int i, j;
767 
769  sizeof(*q->extparam));
770  if (!q->extparam)
771  return AVERROR(ENOMEM);
772 
773  q->param.ExtParam = q->extparam;
774  for (i = 0; i < qsv->nb_ext_buffers; i++)
775  q->param.ExtParam[i] = qsv->ext_buffers[i];
776  q->param.NumExtParam = qsv->nb_ext_buffers;
777 
778  for (i = 0; i < q->nb_extparam_internal; i++) {
779  for (j = 0; j < qsv->nb_ext_buffers; j++) {
780  if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)
781  break;
782  }
783  if (j < qsv->nb_ext_buffers)
784  continue;
785 
786  q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];
787  }
788  } else {
789  q->param.ExtParam = q->extparam_internal;
790  q->param.NumExtParam = q->nb_extparam_internal;
791  }
792 
793  ret = MFXVideoENCODE_Init(q->session, &q->param);
794  if (ret < 0)
795  return ff_qsv_print_error(avctx, ret,
796  "Error initializing the encoder");
797  else if (ret > 0)
798  ff_qsv_print_warning(avctx, ret,
799  "Warning in encoder initialization");
800 
801  ret = qsv_retrieve_enc_params(avctx, q);
802  if (ret < 0) {
803  av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
804  return ret;
805  }
806 
807  q->avctx = avctx;
808 
809  return 0;
810 }
811 
813 {
814  QSVFrame *cur = q->work_frames;
815  while (cur) {
816  if (cur->surface && !cur->surface->Data.Locked) {
817  cur->surface = NULL;
818  av_frame_unref(cur->frame);
819  }
820  cur = cur->next;
821  }
822 }
823 
825 {
826  QSVFrame *frame, **last;
827 
829 
830  frame = q->work_frames;
831  last = &q->work_frames;
832  while (frame) {
833  if (!frame->surface) {
834  *f = frame;
835  return 0;
836  }
837 
838  last = &frame->next;
839  frame = frame->next;
840  }
841 
842  frame = av_mallocz(sizeof(*frame));
843  if (!frame)
844  return AVERROR(ENOMEM);
845  frame->frame = av_frame_alloc();
846  if (!frame->frame) {
847  av_freep(&frame);
848  return AVERROR(ENOMEM);
849  }
850  *last = frame;
851 
852  *f = frame;
853 
854  return 0;
855 }
856 
857 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
858  mfxFrameSurface1 **surface)
859 {
860  QSVFrame *qf;
861  int ret;
862 
863  ret = get_free_frame(q, &qf);
864  if (ret < 0)
865  return ret;
866 
867  if (frame->format == AV_PIX_FMT_QSV) {
868  ret = av_frame_ref(qf->frame, frame);
869  if (ret < 0)
870  return ret;
871 
872  qf->surface = (mfxFrameSurface1*)qf->frame->data[3];
873  } else {
874  /* make a copy if the input is not padded as libmfx requires */
875  if (frame->height & 31 || frame->linesize[0] & (q->width_align - 1)) {
876  qf->frame->height = FFALIGN(frame->height, 32);
877  qf->frame->width = FFALIGN(frame->width, q->width_align);
878 
880  if (ret < 0)
881  return ret;
882 
883  qf->frame->height = frame->height;
884  qf->frame->width = frame->width;
885  ret = av_frame_copy(qf->frame, frame);
886  if (ret < 0) {
887  av_frame_unref(qf->frame);
888  return ret;
889  }
890  } else {
891  ret = av_frame_ref(qf->frame, frame);
892  if (ret < 0)
893  return ret;
894  }
895 
896  qf->surface_internal.Info = q->param.mfx.FrameInfo;
897 
898  qf->surface_internal.Info.PicStruct =
899  !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
900  frame->top_field_first ? MFX_PICSTRUCT_FIELD_TFF :
901  MFX_PICSTRUCT_FIELD_BFF;
902  if (frame->repeat_pict == 1)
903  qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
904  else if (frame->repeat_pict == 2)
905  qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
906  else if (frame->repeat_pict == 4)
907  qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
908 
909  qf->surface_internal.Data.PitchLow = qf->frame->linesize[0];
910  qf->surface_internal.Data.Y = qf->frame->data[0];
911  qf->surface_internal.Data.UV = qf->frame->data[1];
912 
913  qf->surface = &qf->surface_internal;
914  }
915 
916  qf->surface->Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
917 
918  *surface = qf->surface;
919 
920  return 0;
921 }
922 
924 {
925  if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
926  if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
927  q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
928  q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
929  av_log(avctx, AV_LOG_WARNING,
930  "Interlaced coding is supported"
931  " at Main/High Profile Level 2.1-4.1\n");
932  }
933 }
934 
936  const AVFrame *frame)
937 {
938  AVPacket new_pkt = { 0 };
939  mfxBitstream *bs;
940 
941  mfxFrameSurface1 *surf = NULL;
942  mfxSyncPoint *sync = NULL;
943  int ret;
944 
945  if (frame) {
946  ret = submit_frame(q, frame, &surf);
947  if (ret < 0) {
948  av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
949  return ret;
950  }
951  }
952 
953  ret = av_new_packet(&new_pkt, q->packet_size);
954  if (ret < 0) {
955  av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
956  return ret;
957  }
958 
959  bs = av_mallocz(sizeof(*bs));
960  if (!bs) {
961  av_packet_unref(&new_pkt);
962  return AVERROR(ENOMEM);
963  }
964  bs->Data = new_pkt.data;
965  bs->MaxLength = new_pkt.size;
966 
967  sync = av_mallocz(sizeof(*sync));
968  if (!sync) {
969  av_freep(&bs);
970  av_packet_unref(&new_pkt);
971  return AVERROR(ENOMEM);
972  }
973 
974  do {
975  ret = MFXVideoENCODE_EncodeFrameAsync(q->session, NULL, surf, bs, sync);
976  if (ret == MFX_WRN_DEVICE_BUSY)
977  av_usleep(1);
978  } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_WRN_IN_EXECUTION);
979 
980  if (ret > 0)
981  ff_qsv_print_warning(avctx, ret, "Warning during encoding");
982 
983  if (ret < 0) {
984  av_packet_unref(&new_pkt);
985  av_freep(&bs);
986  av_freep(&sync);
987  return (ret == MFX_ERR_MORE_DATA) ?
988  0 : ff_qsv_print_error(avctx, ret, "Error during encoding");
989  }
990 
991  if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM && frame->interlaced_frame)
992  print_interlace_msg(avctx, q);
993 
994  if (*sync) {
995  av_fifo_generic_write(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
996  av_fifo_generic_write(q->async_fifo, &sync, sizeof(sync), NULL);
997  av_fifo_generic_write(q->async_fifo, &bs, sizeof(bs), NULL);
998  } else {
999  av_freep(&sync);
1000  av_packet_unref(&new_pkt);
1001  av_freep(&bs);
1002  }
1003 
1004  return 0;
1005 }
1006 
1008  AVPacket *pkt, const AVFrame *frame, int *got_packet)
1009 {
1010  int ret;
1011 
1012  ret = encode_frame(avctx, q, frame);
1013  if (ret < 0)
1014  return ret;
1015 
1016  if (!av_fifo_space(q->async_fifo) ||
1017  (!frame && av_fifo_size(q->async_fifo))) {
1018  AVPacket new_pkt;
1019  mfxBitstream *bs;
1020  mfxSyncPoint *sync;
1021 
1022  av_fifo_generic_read(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1023  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1024  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1025 
1026  do {
1027  ret = MFXVideoCORE_SyncOperation(q->session, *sync, 1000);
1028  } while (ret == MFX_WRN_IN_EXECUTION);
1029 
1030  new_pkt.dts = av_rescale_q(bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
1031  new_pkt.pts = av_rescale_q(bs->TimeStamp, (AVRational){1, 90000}, avctx->time_base);
1032  new_pkt.size = bs->DataLength;
1033 
1034  if (bs->FrameType & MFX_FRAMETYPE_IDR ||
1035  bs->FrameType & MFX_FRAMETYPE_xIDR)
1036  new_pkt.flags |= AV_PKT_FLAG_KEY;
1037 
1038 #if FF_API_CODED_FRAME
1040  if (bs->FrameType & MFX_FRAMETYPE_I || bs->FrameType & MFX_FRAMETYPE_xI)
1042  else if (bs->FrameType & MFX_FRAMETYPE_P || bs->FrameType & MFX_FRAMETYPE_xP)
1044  else if (bs->FrameType & MFX_FRAMETYPE_B || bs->FrameType & MFX_FRAMETYPE_xB)
1047 #endif
1048 
1049  av_freep(&bs);
1050  av_freep(&sync);
1051 
1052  if (pkt->data) {
1053  if (pkt->size < new_pkt.size) {
1054  av_log(avctx, AV_LOG_ERROR, "Submitted buffer not large enough: %d < %d\n",
1055  pkt->size, new_pkt.size);
1056  av_packet_unref(&new_pkt);
1057  return AVERROR(EINVAL);
1058  }
1059 
1060  memcpy(pkt->data, new_pkt.data, new_pkt.size);
1061  pkt->size = new_pkt.size;
1062 
1063  ret = av_packet_copy_props(pkt, &new_pkt);
1064  av_packet_unref(&new_pkt);
1065  if (ret < 0)
1066  return ret;
1067  } else
1068  *pkt = new_pkt;
1069 
1070  *got_packet = 1;
1071  }
1072 
1073  return 0;
1074 }
1075 
1077 {
1078  QSVFrame *cur;
1079 
1080  if (q->session)
1081  MFXVideoENCODE_Close(q->session);
1082  if (q->internal_session)
1083  MFXClose(q->internal_session);
1084  q->session = NULL;
1085  q->internal_session = NULL;
1086 
1088  av_freep(&q->frames_ctx.mids);
1089  q->frames_ctx.nb_mids = 0;
1090 
1091  cur = q->work_frames;
1092  while (cur) {
1093  q->work_frames = cur->next;
1094  av_frame_free(&cur->frame);
1095  av_freep(&cur);
1096  cur = q->work_frames;
1097  }
1098 
1099  while (q->async_fifo && av_fifo_size(q->async_fifo)) {
1100  AVPacket pkt;
1101  mfxSyncPoint *sync;
1102  mfxBitstream *bs;
1103 
1104  av_fifo_generic_read(q->async_fifo, &pkt, sizeof(pkt), NULL);
1105  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1106  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1107 
1108  av_freep(&sync);
1109  av_freep(&bs);
1110  av_packet_unref(&pkt);
1111  }
1113  q->async_fifo = NULL;
1114 
1117 
1118  av_freep(&q->extparam);
1119 
1120  return 0;
1121 }
int single_sei_nal_unit
Definition: qsvenc.h:116
AVRational framerate
Definition: avcodec.h:3063
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
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:106
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:1768
This structure describes decoded (raw) audio or video data.
Definition: frame.h:140
AVBufferRef * opaque_alloc_buf
Definition: qsvenc.h:92
mfxExtBuffer ** extparam
Definition: qsvenc.h:97
int int_ref_type
Definition: qsvenc.h:128
#define QSV_HAVE_LA
Definition: qsvenc.h:44
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:130
mfxExtOpaqueSurfaceAlloc opaque_alloc
Definition: qsvenc.h:90
memory handling functions
This struct is allocated as AVHWFramesContext.hwctx.
Definition: hwcontext_qsv.h:42
const char * desc
Definition: nvenc.c:101
int max_frame_size
Definition: qsvenc.h:113
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:1145
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:1679
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2426
mfxFrameAllocRequest req
Definition: qsvenc.h:83
int avbr_accuracy
Definition: qsvenc.h:108
QSVFrame * work_frames
Definition: qsvenc.h:74
int num
numerator
Definition: rational.h:44
int repeat_pict
When decoding, this signals how much the picture must be delayed.
Definition: frame.h:258
static int get_free_frame(QSVEncContext *q, QSVFrame **f)
Definition: qsvenc.c:824
int size
Definition: avcodec.h:1347
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
static int sync(AVFormatContext *s, uint8_t *header)
Read input until we find the next ident.
Definition: lxfdec.c:86
int int_ref_qp_delta
Definition: qsvenc.h:130
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:1804
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1621
QSVFramesContext frames_ctx
Definition: qsvenc.h:101
int packet_size
Definition: qsvenc.h:79
#define FF_ARRAY_ELEMS(a)
mfxFrameSurface1 * surface
Definition: qsv_internal.h:41
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:68
int ff_qsv_init_session_hwcontext(AVCodecContext *avctx, mfxSession *psession, QSVFramesContext *qsv_frames_ctx, const char *load_plugins, int opaque)
Definition: qsv.c:290
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:77
static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:923
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:1737
int min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: avcodec.h:1150
AVBufferRef * hw_frames_ctx
Definition: qsv_internal.h:51
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:84
int ff_qsv_print_error(void *log_ctx, mfxStatus err, const char *error_string)
Definition: qsv.c:112
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1535
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:202
int bitrate_limit
Definition: qsvenc.h:120
int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: qsvenc.c:1007
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:119
mfxVideoParam param
Definition: qsvenc.h:82
uint8_t
#define QSV_HAVE_CO2
Definition: qsvenc.h:37
#define QSV_HAVE_LA_HRD
Definition: qsvenc.h:45
AVFifoBuffer * async_fifo
Definition: qsvenc.h:99
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:68
void * hwaccel_context
Hardware accelerator context.
Definition: avcodec.h:2708
mfxExtCodingOption extco
Definition: qsvenc.h:85
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:1688
mfxExtBuffer * extparam_internal[2+QSV_HAVE_CO2]
Definition: qsvenc.h:94
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:199
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:211
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1523
int opaque_alloc
Encoding only.
Definition: qsv.h:65
mfxFrameSurface1 ** opaque_surfaces
Definition: qsvenc.h:91
uint8_t * data
Definition: avcodec.h:1346
mfxU16 rc_mode
Definition: qsvenc.c:81
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:140
void av_fifo_free(AVFifoBuffer *f)
Free an AVFifoBuffer.
Definition: fifo.c:38
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:263
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: avcodec.h:1161
int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1076
static const char * print_threestate(mfxU16 val)
Definition: qsvenc.c:118
#define FFALIGN(x, a)
Definition: macros.h:48
int opaque_alloc_type
Encoding only, and only if opaque_alloc is set to non-zero.
Definition: qsv.h:97
int la_depth
Definition: qsvenc.h:110
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1378
static int submit_frame(QSVEncContext *q, const AVFrame *frame, mfxFrameSurface1 **surface)
Definition: qsvenc.c:857
int b_strategy
Definition: qsvenc.h:125
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:99
static int rc_supported(QSVEncContext *q)
Definition: qsvenc.c:344
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:84
int width
width and height of the video frame
Definition: frame.h:179
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:124
#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:80
char * load_plugins
Definition: qsvenc.h:133
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:107
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1503
int rc_max_rate
maximum bitrate
Definition: avcodec.h:2387
int nb_extparam_internal
Definition: qsvenc.h:95
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:1730
int max_dec_frame_buffering
Definition: qsvenc.h:117
int iopattern
The IO pattern to use.
Definition: qsv.h:46
#define FFMAX(a, b)
Definition: common.h:64
static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:554
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:556
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1352
int adaptive_i
Definition: qsvenc.h:123
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2364
int ff_qsv_print_warning(void *log_ctx, mfxStatus err, const char *warning_string)
Definition: qsv.c:122
int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc)
Definition: qsv.c:132
int refs
number of reference frames
Definition: avcodec.h:2071
static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q, mfxExtBuffer **coding_opts)
Definition: qsvenc.c:127
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: avpacket.c:315
const char * name
Definition: qsvenc.c:44
int bit_rate
the average bitrate
Definition: avcodec.h:1473
AVCodecContext * avctx
Definition: qsvenc.h:72
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:201
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:735
int idr_interval
Definition: qsvenc.h:105
int width
picture width / height.
Definition: avcodec.h:1580
int extbrc
Definition: qsvenc.h:122
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:3102
int preset
Definition: qsvenc.h:107
int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)
Definition: qsv.c:36
static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:271
int level
level
Definition: avcodec.h:2970
mfxFrameSurface1 surface_internal
Definition: qsv_internal.h:43
static const char * print_profile(mfxU16 profile)
Definition: qsvenc.c:71
static const struct @69 rc_names[]
int async_depth
Definition: qsvenc.h:104
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:198
attribute_deprecated int coder_type
Definition: avcodec.h:2440
int width_align
Definition: qsvenc.h:80
if(ac->has_optimized_func)
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:191
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:1140
NULL
Definition: eval.c:55
static int qsvenc_init_session(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:675
int av_fifo_space(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:57
#define QSV_HAVE_CO3
Definition: qsvenc.h:38
Libavcodec external API header.
enum AVCodecID codec_id
Definition: avcodec.h:1426
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:158
attribute_deprecated int b_frame_strategy
Definition: avcodec.h:1699
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:80
main external API structure.
Definition: avcodec.h:1409
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:347
uint8_t * data
The data buffer.
Definition: buffer.h:89
struct QSVFrame * next
Definition: qsv_internal.h:47
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:589
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:155
int profile
Definition: qsvenc.h:106
int extradata_size
Definition: avcodec.h:1524
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:82
#define AVERROR_BUG
Bug detected, please report the issue.
Definition: error.h:60
AVBufferRef * opaque_surfaces
Encoding only, and only if opaque_alloc is set to non-zero.
Definition: qsv.h:90
#define FF_CODER_TYPE_VLC
Definition: avcodec.h:2429
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2608
int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:708
rational number numerator/denominator
Definition: rational.h:43
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:117
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
Definition: pixfmt.h:215
mfxMemId * mids
Definition: qsv_internal.h:53
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:1707
int max_slice_size
Definition: qsvenc.h:114
This struct is used for communicating QSV parameters between libavcodec and the caller.
Definition: qsv.h:36
mfxU16 profile
Definition: qsvenc.c:43
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:302
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1489
int int_ref_cycle_size
Definition: qsvenc.h:129
static void * av_malloc_array(size_t nmemb, size_t size)
Definition: mem.h:92
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:146
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1606
int adaptive_b
Definition: qsvenc.h:124
int av_fifo_size(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:52
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:77
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:92
Bi-dir predicted.
Definition: avutil.h:262
int avbr_convergence
Definition: qsvenc.h:109
int ff_qsv_init_internal_session(AVCodecContext *avctx, mfxSession *session, const char *load_plugins)
Definition: qsv.c:200
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2797
int den
denominator
Definition: rational.h:45
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:61
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:2754
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:638
int slices
Number of slices.
Definition: avcodec.h:2143
int recovery_point_sei
Definition: qsvenc.h:131
AVFifoBuffer * av_fifo_alloc(unsigned int size)
Initialize an AVFifoBuffer.
Definition: fifo.c:25
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:78
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:268
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:1155
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:214
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1345
static void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.h:205
static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:356
int height
Definition: frame.h:179
static const struct @68 profile_names[]
static const char * print_ratecontrol(mfxU16 rc_mode)
Definition: qsvenc.c:109
An API-specific header for AV_HWDEVICE_TYPE_QSV.
AVFrame * frame
Definition: qsv_internal.h:40
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:798
int rc_min_rate
minimum bitrate
Definition: avcodec.h:2394
int depth
Number of bits in the component.
Definition: pixdesc.h:57
int trellis
Definition: qsvenc.h:118
AVPixelFormat
Pixel format.
Definition: pixfmt.h:57
This structure stores compressed data.
Definition: avcodec.h:1323
mfxSession session
Definition: qsvenc.h:76
static int qsv_init_opaque_alloc(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:638
#define QSV_HAVE_VCM
Definition: qsvenc.h:47
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1183
mfxSession session
If non-NULL, the session to use for encoding or decoding.
Definition: qsv.h:41
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:211
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:2605
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1339
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:3070
for(j=16;j >0;--j)
static int encode_frame(AVCodecContext *avctx, QSVEncContext *q, const AVFrame *frame)
Definition: qsvenc.c:935
Predicted.
Definition: avutil.h:261
static void clear_unused_frames(QSVEncContext *q)
Definition: qsvenc.c:812