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/mem.h"
30 #include "libavutil/log.h"
31 #include "libavutil/time.h"
32 #include "libavutil/imgutils.h"
33 #include "libavcodec/bytestream.h"
34 
35 #include "avcodec.h"
36 #include "internal.h"
37 #include "qsv.h"
38 #include "qsv_internal.h"
39 #include "qsvenc.h"
40 
41 static const struct {
42  mfxU16 profile;
43  const char *name;
44 } profile_names[] = {
45  { MFX_PROFILE_AVC_BASELINE, "baseline" },
46  { MFX_PROFILE_AVC_MAIN, "main" },
47  { MFX_PROFILE_AVC_EXTENDED, "extended" },
48  { MFX_PROFILE_AVC_HIGH, "high" },
49 #if QSV_VERSION_ATLEAST(1, 15)
50  { MFX_PROFILE_AVC_HIGH_422, "high 422" },
51 #endif
52 #if QSV_VERSION_ATLEAST(1, 4)
53  { MFX_PROFILE_AVC_CONSTRAINED_BASELINE, "constrained baseline" },
54  { MFX_PROFILE_AVC_CONSTRAINED_HIGH, "constrained high" },
55  { MFX_PROFILE_AVC_PROGRESSIVE_HIGH, "progressive high" },
56 #endif
57  { MFX_PROFILE_MPEG2_SIMPLE, "simple" },
58  { MFX_PROFILE_MPEG2_MAIN, "main" },
59  { MFX_PROFILE_MPEG2_HIGH, "high" },
60  { MFX_PROFILE_VC1_SIMPLE, "simple" },
61  { MFX_PROFILE_VC1_MAIN, "main" },
62  { MFX_PROFILE_VC1_ADVANCED, "advanced" },
63 #if QSV_VERSION_ATLEAST(1, 8)
64  { MFX_PROFILE_HEVC_MAIN, "main" },
65  { MFX_PROFILE_HEVC_MAIN10, "main10" },
66  { MFX_PROFILE_HEVC_MAINSP, "mainsp" },
67 #endif
68 };
69 
70 static const char *print_profile(mfxU16 profile)
71 {
72  int i;
73  for (i = 0; i < FF_ARRAY_ELEMS(profile_names); i++)
74  if (profile == profile_names[i].profile)
75  return profile_names[i].name;
76  return "unknown";
77 }
78 
79 static const struct {
80  mfxU16 rc_mode;
81  const char *name;
82 } rc_names[] = {
83  { MFX_RATECONTROL_CBR, "CBR" },
84  { MFX_RATECONTROL_VBR, "VBR" },
85  { MFX_RATECONTROL_CQP, "CQP" },
86  { MFX_RATECONTROL_AVBR, "AVBR" },
87 #if QSV_HAVE_LA
88  { MFX_RATECONTROL_LA, "LA" },
89 #endif
90 #if QSV_HAVE_ICQ
91  { MFX_RATECONTROL_ICQ, "ICQ" },
92  { MFX_RATECONTROL_LA_ICQ, "LA_ICQ" },
93 #endif
94 #if QSV_HAVE_VCM
95  { MFX_RATECONTROL_VCM, "VCM" },
96 #endif
97 #if QSV_VERSION_ATLEAST(1, 10)
98  { MFX_RATECONTROL_LA_EXT, "LA_EXT" },
99 #endif
100 #if QSV_HAVE_LA_HRD
101  { MFX_RATECONTROL_LA_HRD, "LA_HRD" },
102 #endif
103 #if QSV_HAVE_QVBR
104  { MFX_RATECONTROL_QVBR, "QVBR" },
105 #endif
106 };
107 
108 static const char *print_ratecontrol(mfxU16 rc_mode)
109 {
110  int i;
111  for (i = 0; i < FF_ARRAY_ELEMS(rc_names); i++)
112  if (rc_mode == rc_names[i].rc_mode)
113  return rc_names[i].name;
114  return "unknown";
115 }
116 
117 static const char *print_threestate(mfxU16 val)
118 {
119  if (val == MFX_CODINGOPTION_ON)
120  return "ON";
121  else if (val == MFX_CODINGOPTION_OFF)
122  return "OFF";
123  return "unknown";
124 }
125 
127  mfxExtBuffer **coding_opts)
128 {
129  mfxInfoMFX *info = &q->param.mfx;
130 
131  mfxExtCodingOption *co = (mfxExtCodingOption*)coding_opts[0];
132 #if QSV_HAVE_CO2
133  mfxExtCodingOption2 *co2 = (mfxExtCodingOption2*)coding_opts[1];
134 #endif
135 #if QSV_HAVE_CO3
136  mfxExtCodingOption3 *co3 = (mfxExtCodingOption3*)coding_opts[2];
137 #endif
138 
139  av_log(avctx, AV_LOG_VERBOSE, "profile: %s; level: %"PRIu16"\n",
140  print_profile(info->CodecProfile), info->CodecLevel);
141 
142  av_log(avctx, AV_LOG_VERBOSE, "GopPicSize: %"PRIu16"; GopRefDist: %"PRIu16"; GopOptFlag: ",
143  info->GopPicSize, info->GopRefDist);
144  if (info->GopOptFlag & MFX_GOP_CLOSED)
145  av_log(avctx, AV_LOG_VERBOSE, "closed ");
146  if (info->GopOptFlag & MFX_GOP_STRICT)
147  av_log(avctx, AV_LOG_VERBOSE, "strict ");
148  av_log(avctx, AV_LOG_VERBOSE, "; IdrInterval: %"PRIu16"\n", info->IdrInterval);
149 
150  av_log(avctx, AV_LOG_VERBOSE, "TargetUsage: %"PRIu16"; RateControlMethod: %s\n",
151  info->TargetUsage, print_ratecontrol(info->RateControlMethod));
152 
153  if (info->RateControlMethod == MFX_RATECONTROL_CBR ||
154  info->RateControlMethod == MFX_RATECONTROL_VBR
155 #if QSV_HAVE_VCM
156  || info->RateControlMethod == MFX_RATECONTROL_VCM
157 #endif
158  ) {
159  av_log(avctx, AV_LOG_VERBOSE,
160  "InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"\n",
161  info->InitialDelayInKB, info->TargetKbps, info->MaxKbps);
162  } else if (info->RateControlMethod == MFX_RATECONTROL_CQP) {
163  av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",
164  info->QPI, info->QPP, info->QPB);
165  } else if (info->RateControlMethod == MFX_RATECONTROL_AVBR) {
166  av_log(avctx, AV_LOG_VERBOSE,
167  "TargetKbps: %"PRIu16"; Accuracy: %"PRIu16"; Convergence: %"PRIu16"\n",
168  info->TargetKbps, info->Accuracy, info->Convergence);
169  }
170 #if QSV_HAVE_LA
171  else if (info->RateControlMethod == MFX_RATECONTROL_LA
172 #if QSV_HAVE_LA_HRD
173  || info->RateControlMethod == MFX_RATECONTROL_LA_HRD
174 #endif
175  ) {
176  av_log(avctx, AV_LOG_VERBOSE,
177  "TargetKbps: %"PRIu16"; LookAheadDepth: %"PRIu16"\n",
178  info->TargetKbps, co2->LookAheadDepth);
179  }
180 #endif
181 #if QSV_HAVE_ICQ
182  else if (info->RateControlMethod == MFX_RATECONTROL_ICQ) {
183  av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);
184  } else if (info->RateControlMethod == MFX_RATECONTROL_LA_ICQ) {
185  av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"; LookAheadDepth: %"PRIu16"\n",
186  info->ICQQuality, co2->LookAheadDepth);
187  }
188 #endif
189 #if QSV_HAVE_QVBR
190  else if (info->RateControlMethod == MFX_RATECONTROL_QVBR) {
191  av_log(avctx, AV_LOG_VERBOSE, "QVBRQuality: %"PRIu16"\n",
192  co3->QVBRQuality);
193  }
194 #endif
195 
196  av_log(avctx, AV_LOG_VERBOSE, "NumSlice: %"PRIu16"; NumRefFrame: %"PRIu16"\n",
197  info->NumSlice, info->NumRefFrame);
198  av_log(avctx, AV_LOG_VERBOSE, "RateDistortionOpt: %s\n",
199  print_threestate(co->RateDistortionOpt));
200 
201 #if QSV_HAVE_CO2
202  av_log(avctx, AV_LOG_VERBOSE,
203  "RecoveryPointSEI: %s IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16"; IntRefQPDelta: %"PRId16"\n",
204  print_threestate(co->RecoveryPointSEI), co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);
205 
206  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %"PRIu16"; ", co2->MaxFrameSize);
207 #if QSV_HAVE_MAX_SLICE_SIZE
208  av_log(avctx, AV_LOG_VERBOSE, "MaxSliceSize: %"PRIu16"; ", co2->MaxSliceSize);
209 #endif
210  av_log(avctx, AV_LOG_VERBOSE, "\n");
211 
212  av_log(avctx, AV_LOG_VERBOSE,
213  "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
214  print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),
215  print_threestate(co2->ExtBRC));
216 
217 #if QSV_HAVE_TRELLIS
218  av_log(avctx, AV_LOG_VERBOSE, "Trellis: ");
219  if (co2->Trellis & MFX_TRELLIS_OFF) {
220  av_log(avctx, AV_LOG_VERBOSE, "off");
221  } else if (!co2->Trellis) {
222  av_log(avctx, AV_LOG_VERBOSE, "auto");
223  } else {
224  if (co2->Trellis & MFX_TRELLIS_I) av_log(avctx, AV_LOG_VERBOSE, "I");
225  if (co2->Trellis & MFX_TRELLIS_P) av_log(avctx, AV_LOG_VERBOSE, "P");
226  if (co2->Trellis & MFX_TRELLIS_B) av_log(avctx, AV_LOG_VERBOSE, "B");
227  }
228  av_log(avctx, AV_LOG_VERBOSE, "\n");
229 #endif
230 
231 #if QSV_VERSION_ATLEAST(1, 8)
232  av_log(avctx, AV_LOG_VERBOSE,
233  "RepeatPPS: %s; NumMbPerSlice: %"PRIu16"; LookAheadDS: ",
234  print_threestate(co2->RepeatPPS), co2->NumMbPerSlice);
235  switch (co2->LookAheadDS) {
236  case MFX_LOOKAHEAD_DS_OFF: av_log(avctx, AV_LOG_VERBOSE, "off"); break;
237  case MFX_LOOKAHEAD_DS_2x: av_log(avctx, AV_LOG_VERBOSE, "2x"); break;
238  case MFX_LOOKAHEAD_DS_4x: av_log(avctx, AV_LOG_VERBOSE, "4x"); break;
239  default: av_log(avctx, AV_LOG_VERBOSE, "unknown"); break;
240  }
241  av_log(avctx, AV_LOG_VERBOSE, "\n");
242 
243  av_log(avctx, AV_LOG_VERBOSE, "AdaptiveI: %s; AdaptiveB: %s; BRefType: ",
244  print_threestate(co2->AdaptiveI), print_threestate(co2->AdaptiveB));
245  switch (co2->BRefType) {
246  case MFX_B_REF_OFF: av_log(avctx, AV_LOG_VERBOSE, "off"); break;
247  case MFX_B_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "pyramid"); break;
248  default: av_log(avctx, AV_LOG_VERBOSE, "auto"); break;
249  }
250  av_log(avctx, AV_LOG_VERBOSE, "\n");
251 #endif
252 
253 #if QSV_VERSION_ATLEAST(1, 9)
254  av_log(avctx, AV_LOG_VERBOSE,
255  "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",
256  co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
257 #endif
258 #endif
259 
260  if (avctx->codec_id == AV_CODEC_ID_H264) {
261  av_log(avctx, AV_LOG_VERBOSE, "Entropy coding: %s; MaxDecFrameBuffering: %"PRIu16"\n",
262  co->CAVLC == MFX_CODINGOPTION_ON ? "CAVLC" : "CABAC", co->MaxDecFrameBuffering);
263  av_log(avctx, AV_LOG_VERBOSE,
264  "NalHrdConformance: %s; SingleSeiNalUnit: %s; VuiVclHrdParameters: %s VuiNalHrdParameters: %s\n",
265  print_threestate(co->NalHrdConformance), print_threestate(co->SingleSeiNalUnit),
266  print_threestate(co->VuiVclHrdParameters), print_threestate(co->VuiNalHrdParameters));
267  }
268 }
269 
271 {
272  const char *rc_desc;
273  mfxU16 rc_mode;
274 
275  int want_la = q->look_ahead;
276  int want_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
277  int want_vcm = q->vcm;
278 
279  if (want_la && !QSV_HAVE_LA) {
280  av_log(avctx, AV_LOG_ERROR,
281  "Lookahead ratecontrol mode requested, but is not supported by this SDK version\n");
282  return AVERROR(ENOSYS);
283  }
284  if (want_vcm && !QSV_HAVE_VCM) {
285  av_log(avctx, AV_LOG_ERROR,
286  "VCM ratecontrol mode requested, but is not supported by this SDK version\n");
287  return AVERROR(ENOSYS);
288  }
289 
290  if (want_la + want_qscale + want_vcm > 1) {
291  av_log(avctx, AV_LOG_ERROR,
292  "More than one of: { constant qscale, lookahead, VCM } requested, "
293  "only one of them can be used at a time.\n");
294  return AVERROR(EINVAL);
295  }
296 
297  if (want_qscale) {
298  rc_mode = MFX_RATECONTROL_CQP;
299  rc_desc = "constant quantization parameter (CQP)";
300  }
301 #if QSV_HAVE_VCM
302  else if (want_vcm) {
303  rc_mode = MFX_RATECONTROL_VCM;
304  rc_desc = "video conferencing mode (VCM)";
305  }
306 #endif
307 #if QSV_HAVE_LA
308  else if (want_la) {
309  rc_mode = MFX_RATECONTROL_LA;
310  rc_desc = "VBR with lookahead (LA)";
311 
312 #if QSV_HAVE_ICQ
313  if (avctx->global_quality > 0) {
314  rc_mode = MFX_RATECONTROL_LA_ICQ;
315  rc_desc = "intelligent constant quality with lookahead (LA_ICQ)";
316  }
317 #endif
318  }
319 #endif
320 #if QSV_HAVE_ICQ
321  else if (avctx->global_quality > 0) {
322  rc_mode = MFX_RATECONTROL_ICQ;
323  rc_desc = "intelligent constant quality (ICQ)";
324  }
325 #endif
326  else if (avctx->rc_max_rate == avctx->bit_rate) {
327  rc_mode = MFX_RATECONTROL_CBR;
328  rc_desc = "constant bitrate (CBR)";
329  } else if (!avctx->rc_max_rate) {
330  rc_mode = MFX_RATECONTROL_AVBR;
331  rc_desc = "average variable bitrate (AVBR)";
332  } else {
333  rc_mode = MFX_RATECONTROL_VBR;
334  rc_desc = "variable bitrate (VBR)";
335  }
336 
337  q->param.mfx.RateControlMethod = rc_mode;
338  av_log(avctx, AV_LOG_VERBOSE, "Using the %s ratecontrol method\n", rc_desc);
339 
340  return 0;
341 }
342 
344 {
345  mfxVideoParam param_out = { .mfx.CodecId = q->param.mfx.CodecId };
346  mfxStatus ret;
347 
348  ret = MFXVideoENCODE_Query(q->session, &q->param, &param_out);
349  if (ret < 0 ||
350  param_out.mfx.RateControlMethod != q->param.mfx.RateControlMethod)
351  return 0;
352  return 1;
353 }
354 
356 {
357  float quant;
358  int ret;
359 
360  ret = ff_qsv_codec_id_to_mfx(avctx->codec_id);
361  if (ret < 0)
362  return AVERROR_BUG;
363  q->param.mfx.CodecId = ret;
364 
365  q->width_align = avctx->codec_id == AV_CODEC_ID_HEVC ? 32 : 16;
366 
367  if (avctx->level > 0)
368  q->param.mfx.CodecLevel = avctx->level;
369 
370  q->param.mfx.CodecProfile = q->profile;
371  q->param.mfx.TargetUsage = q->preset;
372  q->param.mfx.GopPicSize = FFMAX(0, avctx->gop_size);
373  q->param.mfx.GopRefDist = FFMAX(-1, avctx->max_b_frames) + 1;
374  q->param.mfx.GopOptFlag = avctx->flags & AV_CODEC_FLAG_CLOSED_GOP ?
375  MFX_GOP_CLOSED : 0;
376  q->param.mfx.IdrInterval = q->idr_interval;
377  q->param.mfx.NumSlice = avctx->slices;
378  q->param.mfx.NumRefFrame = FFMAX(0, avctx->refs);
379  q->param.mfx.EncodedOrder = 0;
380  q->param.mfx.BufferSizeInKB = 0;
381 
382  q->param.mfx.FrameInfo.FourCC = MFX_FOURCC_NV12;
383  q->param.mfx.FrameInfo.CropX = 0;
384  q->param.mfx.FrameInfo.CropY = 0;
385  q->param.mfx.FrameInfo.CropW = avctx->width;
386  q->param.mfx.FrameInfo.CropH = avctx->height;
387  q->param.mfx.FrameInfo.AspectRatioW = avctx->sample_aspect_ratio.num;
388  q->param.mfx.FrameInfo.AspectRatioH = avctx->sample_aspect_ratio.den;
389  q->param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
390  q->param.mfx.FrameInfo.BitDepthLuma = 8;
391  q->param.mfx.FrameInfo.BitDepthChroma = 8;
392  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, q->width_align);
393 
394  if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
395  /* A true field layout (TFF or BFF) is not important here,
396  it will specified later during frame encoding. But it is important
397  to specify is frame progressive or not because allowed heigh alignment
398  does depend by this.
399  */
400  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_FIELD_TFF;
401  q->height_align = 32;
402  } else {
403  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
404  q->height_align = 16;
405  }
406  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, q->height_align);
407 
408  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
409  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
410  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
411  } else {
412  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
413  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
414  }
415 
416  ret = select_rc_mode(avctx, q);
417  if (ret < 0)
418  return ret;
419 
420  switch (q->param.mfx.RateControlMethod) {
421  case MFX_RATECONTROL_CBR:
422  case MFX_RATECONTROL_VBR:
423 #if QSV_HAVE_VCM
424  case MFX_RATECONTROL_VCM:
425 #endif
426  q->param.mfx.InitialDelayInKB = avctx->rc_initial_buffer_occupancy / 1000;
427  q->param.mfx.TargetKbps = avctx->bit_rate / 1000;
428  q->param.mfx.MaxKbps = avctx->rc_max_rate / 1000;
429  break;
430  case MFX_RATECONTROL_CQP:
431  quant = avctx->global_quality / FF_QP2LAMBDA;
432 
433  q->param.mfx.QPI = av_clip(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 0, 51);
434  q->param.mfx.QPP = av_clip(quant, 0, 51);
435  q->param.mfx.QPB = av_clip(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 0, 51);
436 
437  break;
438  case MFX_RATECONTROL_AVBR:
439  q->param.mfx.TargetKbps = avctx->bit_rate / 1000;
440  q->param.mfx.Convergence = q->avbr_convergence;
441  q->param.mfx.Accuracy = q->avbr_accuracy;
442  break;
443 #if QSV_HAVE_LA
444  case MFX_RATECONTROL_LA:
445  q->param.mfx.TargetKbps = avctx->bit_rate / 1000;
446  q->extco2.LookAheadDepth = q->look_ahead_depth;
447  break;
448 #if QSV_HAVE_ICQ
449  case MFX_RATECONTROL_LA_ICQ:
450  q->extco2.LookAheadDepth = q->look_ahead_depth;
451  case MFX_RATECONTROL_ICQ:
452  q->param.mfx.ICQQuality = avctx->global_quality;
453  break;
454 #endif
455 #endif
456  }
457 
458  // the HEVC encoder plugin currently fails if coding options
459  // are provided
460  if (avctx->codec_id != AV_CODEC_ID_HEVC) {
461  q->extco.Header.BufferId = MFX_EXTBUFF_CODING_OPTION;
462  q->extco.Header.BufferSz = sizeof(q->extco);
463 #if FF_API_CODER_TYPE
465  if (avctx->coder_type != 0)
466  q->cavlc = avctx->coder_type == FF_CODER_TYPE_VLC;
468 #endif
469  q->extco.CAVLC = q->cavlc ? MFX_CODINGOPTION_ON
470  : MFX_CODINGOPTION_UNKNOWN;
471 
472  q->extco.PicTimingSEI = q->pic_timing_sei ?
473  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;
474 
475  if (q->rdo >= 0)
476  q->extco.RateDistortionOpt = q->rdo > 0 ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
477 
478  if (avctx->codec_id == AV_CODEC_ID_H264) {
480  q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?
481  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
482 
483  if (q->single_sei_nal_unit >= 0)
484  q->extco.SingleSeiNalUnit = q->single_sei_nal_unit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
485  if (q->recovery_point_sei >= 0)
486  q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
487  q->extco.MaxDecFrameBuffering = q->max_dec_frame_buffering;
488  }
489 
490  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco;
491 
492 #if QSV_HAVE_CO2
493  if (avctx->codec_id == AV_CODEC_ID_H264) {
494  q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
495  q->extco2.Header.BufferSz = sizeof(q->extco2);
496 
497  if (q->int_ref_type >= 0)
498  q->extco2.IntRefType = q->int_ref_type;
499  if (q->int_ref_cycle_size >= 0)
500  q->extco2.IntRefCycleSize = q->int_ref_cycle_size;
501  if (q->int_ref_qp_delta != INT16_MIN)
502  q->extco2.IntRefQPDelta = q->int_ref_qp_delta;
503 
504  if (q->bitrate_limit >= 0)
505  q->extco2.BitrateLimit = q->bitrate_limit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
506  if (q->mbbrc >= 0)
507  q->extco2.MBBRC = q->mbbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
508  if (q->extbrc >= 0)
509  q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
510 
511  if (q->max_frame_size >= 0)
512  q->extco2.MaxFrameSize = q->max_frame_size;
513 #if QSV_HAVE_MAX_SLICE_SIZE
514  if (q->max_slice_size >= 0)
515  q->extco2.MaxSliceSize = q->max_slice_size;
516 #endif
517 
518 #if QSV_HAVE_TRELLIS
519  q->extco2.Trellis = q->trellis;
520 #endif
521 
522 #if QSV_HAVE_BREF_TYPE
523 #if FF_API_PRIVATE_OPT
525  if (avctx->b_frame_strategy >= 0)
526  q->b_strategy = avctx->b_frame_strategy;
528 #endif
529  if (q->b_strategy >= 0)
530  q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
531  if (q->adaptive_i >= 0)
532  q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
533  if (q->adaptive_b >= 0)
534  q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
535 #endif
536 
537  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
538 
539 #if QSV_VERSION_ATLEAST(1,8)
540  q->extco2.LookAheadDS = q->look_ahead_downsampling;
541 #endif
542  }
543 #endif
544  }
545 
546  if (!rc_supported(q)) {
547  av_log(avctx, AV_LOG_ERROR,
548  "Selected ratecontrol mode is not supported by the QSV "
549  "runtime. Choose a different mode.\n");
550  return AVERROR(ENOSYS);
551  }
552 
553  return 0;
554 }
555 
557 {
558  AVCPBProperties *cpb_props;
559 
560  uint8_t sps_buf[128];
561  uint8_t pps_buf[128];
562 
563  mfxExtCodingOptionSPSPPS extradata = {
564  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
565  .Header.BufferSz = sizeof(extradata),
566  .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),
567  .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
568  };
569 
570  mfxExtCodingOption co = {
571  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
572  .Header.BufferSz = sizeof(co),
573  };
574 #if QSV_HAVE_CO2
575  mfxExtCodingOption2 co2 = {
576  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
577  .Header.BufferSz = sizeof(co2),
578  };
579 #endif
580 #if QSV_HAVE_CO3
581  mfxExtCodingOption3 co3 = {
582  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
583  .Header.BufferSz = sizeof(co3),
584  };
585 #endif
586 
587  mfxExtBuffer *ext_buffers[] = {
588  (mfxExtBuffer*)&extradata,
589  (mfxExtBuffer*)&co,
590 #if QSV_HAVE_CO2
591  (mfxExtBuffer*)&co2,
592 #endif
593 #if QSV_HAVE_CO3
594  (mfxExtBuffer*)&co3,
595 #endif
596  };
597 
598  int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
599  int ret;
600 
601  q->param.ExtParam = ext_buffers;
602  q->param.NumExtParam = FF_ARRAY_ELEMS(ext_buffers);
603 
604  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
605  if (ret < 0)
606  return ff_qsv_error(ret);
607 
608  q->packet_size = q->param.mfx.BufferSizeInKB * 1000;
609 
610  if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)) {
611  av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
612  return AVERROR_UNKNOWN;
613  }
614 
615  avctx->extradata = av_malloc(extradata.SPSBufSize + need_pps * extradata.PPSBufSize +
617  if (!avctx->extradata)
618  return AVERROR(ENOMEM);
619 
620  memcpy(avctx->extradata, sps_buf, extradata.SPSBufSize);
621  if (need_pps)
622  memcpy(avctx->extradata + extradata.SPSBufSize, pps_buf, extradata.PPSBufSize);
623  avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
624  memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
625 
626  cpb_props = ff_add_cpb_side_data(avctx);
627  if (!cpb_props)
628  return AVERROR(ENOMEM);
629  cpb_props->max_bitrate = avctx->rc_max_rate;
630  cpb_props->min_bitrate = avctx->rc_min_rate;
631  cpb_props->avg_bitrate = avctx->bit_rate;
632  cpb_props->buffer_size = avctx->rc_buffer_size;
633 
634  dump_video_param(avctx, q, ext_buffers + 1);
635 
636  return 0;
637 }
638 
640 {
641  AVQSVContext *qsv = avctx->hwaccel_context;
642  mfxFrameSurface1 *surfaces;
643  int nb_surfaces, i;
644 
645  nb_surfaces = qsv->nb_opaque_surfaces + q->req.NumFrameSuggested + q->async_depth;
646 
647  q->opaque_alloc_buf = av_buffer_allocz(sizeof(*surfaces) * nb_surfaces);
648  if (!q->opaque_alloc_buf)
649  return AVERROR(ENOMEM);
650 
651  q->opaque_surfaces = av_malloc_array(nb_surfaces, sizeof(*q->opaque_surfaces));
652  if (!q->opaque_surfaces)
653  return AVERROR(ENOMEM);
654 
655  surfaces = (mfxFrameSurface1*)q->opaque_alloc_buf->data;
656  for (i = 0; i < nb_surfaces; i++) {
657  surfaces[i].Info = q->req.Info;
658  q->opaque_surfaces[i] = surfaces + i;
659  }
660 
661  q->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
662  q->opaque_alloc.Header.BufferSz = sizeof(q->opaque_alloc);
663  q->opaque_alloc.In.Surfaces = q->opaque_surfaces;
664  q->opaque_alloc.In.NumSurface = nb_surfaces;
665  q->opaque_alloc.In.Type = q->req.Type;
666 
667  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->opaque_alloc;
668 
669  qsv->nb_opaque_surfaces = nb_surfaces;
671  qsv->opaque_alloc_type = q->req.Type;
672 
673  return 0;
674 }
675 
677 {
678  int opaque_alloc = 0;
679  int ret;
680 
681  q->param.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
682  q->param.AsyncDepth = q->async_depth;
683 
684  q->async_fifo = av_fifo_alloc((1 + q->async_depth) *
685  (sizeof(AVPacket) + sizeof(mfxSyncPoint*) + sizeof(mfxBitstream*)));
686  if (!q->async_fifo)
687  return AVERROR(ENOMEM);
688 
689  if (avctx->hwaccel_context) {
690  AVQSVContext *qsv = avctx->hwaccel_context;
691 
692  q->session = qsv->session;
693  q->param.IOPattern = qsv->iopattern;
694 
695  opaque_alloc = qsv->opaque_alloc;
696  }
697 
698  if (!q->session) {
699  ret = ff_qsv_init_internal_session(avctx, &q->internal_qs,
700  q->load_plugins);
701  if (ret < 0)
702  return ret;
703 
704  q->session = q->internal_qs.session;
705  }
706 
707  ret = init_video_param(avctx, q);
708  if (ret < 0)
709  return ret;
710 
711  ret = MFXVideoENCODE_Query(q->session, &q->param,&q->param);
712  if (MFX_WRN_PARTIAL_ACCELERATION==ret) {
713  av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
714  } else if (ret < 0) {
715  av_log(avctx, AV_LOG_ERROR, "Error %d querying encoder params\n", ret);
716  return ff_qsv_error(ret);
717  }
718 
719  ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
720  if (ret < 0) {
721  av_log(avctx, AV_LOG_ERROR, "Error querying the encoding parameters\n");
722  return ff_qsv_error(ret);
723  }
724 
725  if (opaque_alloc) {
726  ret = qsv_init_opaque_alloc(avctx, q);
727  if (ret < 0)
728  return ret;
729  }
730 
731  if (avctx->hwaccel_context) {
732  AVQSVContext *qsv = avctx->hwaccel_context;
733  int i, j;
734 
736  sizeof(*q->extparam));
737  if (!q->extparam)
738  return AVERROR(ENOMEM);
739 
740  q->param.ExtParam = q->extparam;
741  for (i = 0; i < qsv->nb_ext_buffers; i++)
742  q->param.ExtParam[i] = qsv->ext_buffers[i];
743  q->param.NumExtParam = qsv->nb_ext_buffers;
744 
745  for (i = 0; i < q->nb_extparam_internal; i++) {
746  for (j = 0; j < qsv->nb_ext_buffers; j++) {
747  if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)
748  break;
749  }
750  if (j < qsv->nb_ext_buffers)
751  continue;
752 
753  q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];
754  }
755  } else {
756  q->param.ExtParam = q->extparam_internal;
757  q->param.NumExtParam = q->nb_extparam_internal;
758  }
759 
760  ret = MFXVideoENCODE_Init(q->session, &q->param);
761  if (MFX_WRN_PARTIAL_ACCELERATION==ret) {
762  av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
763  } else if (ret < 0) {
764  av_log(avctx, AV_LOG_ERROR, "Error initializing the encoder\n");
765  return ff_qsv_error(ret);
766  }
767 
768  ret = qsv_retrieve_enc_params(avctx, q);
769  if (ret < 0) {
770  av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
771  return ret;
772  }
773 
774  q->avctx = avctx;
775 
776  return 0;
777 }
778 
779 static void free_encoder_ctrl_payloads(mfxEncodeCtrl* enc_ctrl)
780 {
781  if (enc_ctrl) {
782  int i;
783  for (i = 0; i < enc_ctrl->NumPayload && i < QSV_MAX_ENC_PAYLOAD; i++) {
784  av_free(enc_ctrl->Payload[i]);
785  }
786  enc_ctrl->NumPayload = 0;
787  }
788 }
789 
791 {
792  QSVFrame *cur = q->work_frames;
793  while (cur) {
794  if (cur->surface && !cur->surface->Data.Locked) {
795  cur->surface = NULL;
797  av_frame_unref(cur->frame);
798  }
799  cur = cur->next;
800  }
801 }
802 
804 {
805  QSVFrame *frame, **last;
806 
808 
809  frame = q->work_frames;
810  last = &q->work_frames;
811  while (frame) {
812  if (!frame->surface) {
813  *f = frame;
814  return 0;
815  }
816 
817  last = &frame->next;
818  frame = frame->next;
819  }
820 
821  frame = av_mallocz(sizeof(*frame));
822  if (!frame)
823  return AVERROR(ENOMEM);
824  frame->frame = av_frame_alloc();
825  if (!frame->frame) {
826  av_freep(&frame);
827  return AVERROR(ENOMEM);
828  }
829  frame->enc_ctrl.Payload = av_mallocz(sizeof(mfxPayload*) * QSV_MAX_ENC_PAYLOAD);
830  if (!frame->enc_ctrl.Payload) {
831  av_freep(&frame);
832  return AVERROR(ENOMEM);
833  }
834  *last = frame;
835 
836  *f = frame;
837 
838  return 0;
839 }
840 
841 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
842  QSVFrame **new_frame)
843 {
844  QSVFrame *qf;
845  int ret;
846 
847  ret = get_free_frame(q, &qf);
848  if (ret < 0)
849  return ret;
850 
851  if (frame->format == AV_PIX_FMT_QSV) {
852  ret = av_frame_ref(qf->frame, frame);
853  if (ret < 0)
854  return ret;
855 
856  qf->surface = (mfxFrameSurface1*)qf->frame->data[3];
857  } else {
858  /* make a copy if the input is not padded as libmfx requires */
859  if ( frame->height & (q->height_align - 1) ||
860  frame->linesize[0] & (q->width_align - 1)) {
861  qf->frame->height = FFALIGN(frame->height, q->height_align);
862  qf->frame->width = FFALIGN(frame->width, q->width_align);
863 
865  if (ret < 0)
866  return ret;
867 
868  qf->frame->height = frame->height;
869  qf->frame->width = frame->width;
870  ret = av_frame_copy(qf->frame, frame);
871  if (ret < 0) {
872  av_frame_unref(qf->frame);
873  return ret;
874  }
875  } else {
876  ret = av_frame_ref(qf->frame, frame);
877  if (ret < 0)
878  return ret;
879  }
880 
881  qf->surface_internal.Info = q->param.mfx.FrameInfo;
882 
883  qf->surface_internal.Info.PicStruct =
884  !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
885  frame->top_field_first ? MFX_PICSTRUCT_FIELD_TFF :
886  MFX_PICSTRUCT_FIELD_BFF;
887  if (frame->repeat_pict == 1)
888  qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
889  else if (frame->repeat_pict == 2)
890  qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
891  else if (frame->repeat_pict == 4)
892  qf->surface_internal.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
893 
894  qf->surface_internal.Data.PitchLow = qf->frame->linesize[0];
895  qf->surface_internal.Data.Y = qf->frame->data[0];
896  qf->surface_internal.Data.UV = qf->frame->data[1];
897 
898  qf->surface = &qf->surface_internal;
899  }
900 
901  qf->surface->Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
902 
903  *new_frame = qf;
904 
905  return 0;
906 }
907 
909 {
910  if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
911  if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
912  q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
913  q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
914  av_log(avctx, AV_LOG_WARNING,
915  "Interlaced coding is supported"
916  " at Main/High Profile Level 2.1-4.1\n");
917  }
918 }
919 
921  const AVFrame *frame)
922 {
923  AVPacket new_pkt = { 0 };
924  mfxBitstream *bs;
925 
926  mfxFrameSurface1 *surf = NULL;
927  mfxSyncPoint *sync = NULL;
928  QSVFrame *qsv_frame = NULL;
929  mfxEncodeCtrl* enc_ctrl = NULL;
930  int ret;
931 
932  if (frame) {
933  ret = submit_frame(q, frame, &qsv_frame);
934  if (ret < 0) {
935  av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
936  return ret;
937  }
938  }
939  if (qsv_frame) {
940  surf = qsv_frame->surface;
941  enc_ctrl = &qsv_frame->enc_ctrl;
942  }
943 
944  ret = av_new_packet(&new_pkt, q->packet_size);
945  if (ret < 0) {
946  av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
947  return ret;
948  }
949 
950  bs = av_mallocz(sizeof(*bs));
951  if (!bs) {
952  av_packet_unref(&new_pkt);
953  return AVERROR(ENOMEM);
954  }
955  bs->Data = new_pkt.data;
956  bs->MaxLength = new_pkt.size;
957 
958  if (q->set_encode_ctrl_cb) {
959  q->set_encode_ctrl_cb(avctx, frame, &qsv_frame->enc_ctrl);
960  }
961 
962  sync = av_mallocz(sizeof(*sync));
963  if (!sync) {
964  av_freep(&bs);
965  av_packet_unref(&new_pkt);
966  return AVERROR(ENOMEM);
967  }
968 
969  do {
970  ret = MFXVideoENCODE_EncodeFrameAsync(q->session, enc_ctrl, surf, bs, sync);
971  if (ret == MFX_WRN_DEVICE_BUSY) {
972  av_usleep(500);
973  continue;
974  }
975  break;
976  } while ( 1 );
977 
978  if (ret < 0) {
979  av_packet_unref(&new_pkt);
980  av_freep(&bs);
981  if (ret == MFX_ERR_MORE_DATA)
982  return 0;
983  av_log(avctx, AV_LOG_ERROR, "EncodeFrameAsync returned %d\n", ret);
984  return ff_qsv_error(ret);
985  }
986 
987  if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM) {
988  if (frame->interlaced_frame)
989  print_interlace_msg(avctx, q);
990  else
991  av_log(avctx, AV_LOG_WARNING,
992  "EncodeFrameAsync returned 'incompatible param' code\n");
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  q->session = NULL;
1083 
1085 
1086  cur = q->work_frames;
1087  while (cur) {
1088  q->work_frames = cur->next;
1089  av_frame_free(&cur->frame);
1090  av_free(cur->enc_ctrl.Payload);
1091  av_freep(&cur);
1092  cur = q->work_frames;
1093  }
1094 
1095  while (q->async_fifo && av_fifo_size(q->async_fifo)) {
1096  AVPacket pkt;
1097  mfxSyncPoint *sync;
1098  mfxBitstream *bs;
1099 
1100  av_fifo_generic_read(q->async_fifo, &pkt, sizeof(pkt), NULL);
1101  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1102  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1103 
1104  av_freep(&sync);
1105  av_freep(&bs);
1106  av_packet_unref(&pkt);
1107  }
1109  q->async_fifo = NULL;
1110 
1113 
1114  av_freep(&q->extparam);
1115 
1116  return 0;
1117 }
int single_sei_nal_unit
Definition: qsvenc.h:123
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:3338
const char const char void * val
Definition: avisynth_c.h:634
#define QSV_MAX_ENC_PAYLOAD
Definition: qsv_internal.h:50
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:124
This structure describes decoded (raw) audio or video data.
Definition: frame.h:184
AVBufferRef * opaque_alloc_buf
Definition: qsvenc.h:98
mfxExtBuffer ** extparam
Definition: qsvenc.h:103
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:871
int int_ref_type
Definition: qsvenc.h:135
#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:96
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1714
memory handling functions
int max_frame_size
Definition: qsvenc.h:120
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:1303
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:1935
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2687
mfxFrameAllocRequest req
Definition: qsvenc.h:89
int avbr_accuracy
Definition: qsvenc.h:112
mfxEncodeCtrl enc_ctrl
Definition: qsv_internal.h:59
QSVFrame * work_frames
Definition: qsvenc.h:79
int num
numerator
Definition: rational.h:44
int repeat_pict
When decoding, this signals how much the picture must be delayed.
Definition: frame.h:313
int look_ahead_depth
Definition: qsvenc.h:116
static int get_free_frame(QSVEncContext *q, QSVFrame **f)
Definition: qsvenc.c:803
int size
Definition: avcodec.h:1581
int int_ref_qp_delta
Definition: qsvenc.h:137
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:2060
int packet_size
Definition: qsvenc.h:84
mfxFrameSurface1 * surface
Definition: qsv_internal.h:58
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:76
static AVPacket pkt
int nb_opaque_surfaces
Encoding only, and only if opaque_alloc is set to non-zero.
Definition: qsv.h:76
static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:908
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:1993
int min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: avcodec.h:1308
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
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1786
int bitrate_limit
Definition: qsvenc.h:127
int look_ahead
Definition: qsvenc.h:115
int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: qsvenc.c:1007
mfxVideoParam param
Definition: qsvenc.h:88
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:105
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:140
void * hwaccel_context
Hardware accelerator context.
Definition: avcodec.h:2980
mfxExtCodingOption extco
Definition: qsvenc.h:91
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:1944
mfxExtBuffer * extparam_internal[2+QSV_HAVE_CO2]
Definition: qsvenc.h:100
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:374
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:268
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:1764
int opaque_alloc
Encoding only.
Definition: qsv.h:65
static AVFrame * frame
mfxFrameSurface1 ** opaque_surfaces
Definition: qsvenc.h:97
uint8_t * data
Definition: avcodec.h:1580
mfxU16 rc_mode
Definition: qsvenc.c:80
#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:318
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: avcodec.h:1319
int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1076
static const char * print_threestate(mfxU16 val)
Definition: qsvenc.c:117
#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:1612
int b_strategy
Definition: qsvenc.h:132
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:343
#define QSV_VERSION_ATLEAST(MAJOR, MINOR)
Definition: qsv_internal.h:52
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
width and height of the video frame
Definition: frame.h:236
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
struct QSVFrame * next
Definition: qsv_internal.h:65
#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:153
char * load_plugins
Definition: qsvenc.h:141
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:1744
int nb_extparam_internal
Definition: qsvenc.h:101
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:1986
int max_dec_frame_buffering
Definition: qsvenc.h:124
int iopattern
The IO pattern to use.
Definition: qsv.h:46
#define FFMAX(a, b)
Definition: common.h:94
int ff_qsv_close_internal_session(QSVSession *qs)
Definition: qsv.c:254
static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:556
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:710
AVFrame * frame
Definition: qsv_internal.h:57
int adaptive_i
Definition: qsvenc.h:130
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2625
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:2655
int refs
number of reference frames
Definition: avcodec.h:2329
static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q, mfxExtBuffer **coding_opts)
Definition: qsvenc.c:126
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: avpacket.c:531
const char * name
Definition: qsvenc.c:43
AVCodecContext * avctx
Definition: qsvenc.h:77
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:258
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:830
int idr_interval
Definition: qsvenc.h:109
int width
picture width / height.
Definition: avcodec.h:1836
int extbrc
Definition: qsvenc.h:129
int preset
Definition: qsvenc.h:111
int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)
Definition: qsv.c:33
static const struct @94 profile_names[]
static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:270
int level
level
Definition: avcodec.h:3242
mfxFrameSurface1 surface_internal
Definition: qsv_internal.h:61
static const char * print_profile(mfxU16 profile)
Definition: qsvenc.c:70
int async_depth
Definition: qsvenc.h:108
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:194
attribute_deprecated int coder_type
Definition: avcodec.h:2701
int ff_qsv_init_internal_session(AVCodecContext *avctx, QSVSession *qs, const char *load_plugins)
Initialize a MSDK session.
Definition: qsv.c:171
#define FF_ARRAY_ELEMS(a)
int width_align
Definition: qsvenc.h:85
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:248
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:1298
#define QSV_HAVE_CO3
Definition: qsvenc.h:38
Libavcodec external API header.
enum AVCodecID codec_id
Definition: avcodec.h:1666
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:215
attribute_deprecated int b_frame_strategy
Definition: avcodec.h:1955
main external API structure.
Definition: avcodec.h:1649
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:563
uint8_t * data
The data buffer.
Definition: buffer.h:89
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:928
int profile
Definition: qsvenc.h:110
static void free_encoder_ctrl_payloads(mfxEncodeCtrl *enc_ctrl)
Definition: qsvenc.c:779
int extradata_size
Definition: avcodec.h:1765
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
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:86
QSVSession internal_qs
Definition: qsvenc.h:82
#define FF_CODER_TYPE_VLC
Definition: avcodec.h:2690
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2869
int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:676
rational number numerator/denominator
Definition: rational.h:43
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
Definition: pixfmt.h:235
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:1963
int max_slice_size
Definition: qsvenc.h:121
This struct is used for communicating QSV parameters between libavcodec and the caller.
Definition: qsv.h:36
mfxU16 profile
Definition: qsvenc.c:42
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:484
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1730
int int_ref_cycle_size
Definition: qsvenc.h:136
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:198
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1862
int adaptive_b
Definition: qsvenc.h:131
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:80
common internal api header.
common internal and external API header
if(ret< 0)
Definition: vf_mcdeint.c:282
static const struct @95 rc_names[]
Bi-dir predicted.
Definition: avutil.h:268
int avbr_convergence
Definition: qsvenc.h:113
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:3070
int ff_qsv_error(int mfx_err)
Convert a libmfx error code into a ffmpeg error code.
Definition: qsv.c:54
int den
denominator
Definition: rational.h:45
#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:3992
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:731
int slices
Number of slices.
Definition: avcodec.h:2401
int recovery_point_sei
Definition: qsvenc.h:138
#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:81
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:323
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:1313
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:219
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1579
static void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.h:229
int look_ahead_downsampling
Definition: qsvenc.h:117
static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:355
int height
Definition: frame.h:236
static const char * print_ratecontrol(mfxU16 rc_mode)
Definition: qsvenc.c:108
#define av_freep(p)
#define av_malloc_array(a, b)
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:893
int trellis
Definition: qsvenc.h:125
This structure stores compressed data.
Definition: avcodec.h:1557
mfxSession session
Definition: qsvenc.h:81
static int qsv_init_opaque_alloc(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:639
#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:1341
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:252
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:2866
mfxSession session
Definition: qsv_internal.h:69
for(j=16;j >0;--j)
int pic_timing_sei
Definition: qsvenc.h:114
static int encode_frame(AVCodecContext *avctx, QSVEncContext *q, const AVFrame *frame)
Definition: qsvenc.c:920
Predicted.
Definition: avutil.h:267
static int submit_frame(QSVEncContext *q, const AVFrame *frame, QSVFrame **new_frame)
Definition: qsvenc.c:841
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2648
SetEncodeCtrlCB * set_encode_ctrl_cb
Definition: qsvenc.h:142
static void clear_unused_frames(QSVEncContext *q)
Definition: qsvenc.c:790