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