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  "BufferSizeInKB: %"PRIu16"; InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"\n",
162  info->BufferSizeInKB, 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 
457  avctx->compression_level = q->preset;
458  } else if (avctx->compression_level >= 0) {
459  if (avctx->compression_level > MFX_TARGETUSAGE_BEST_SPEED) {
460  av_log(avctx, AV_LOG_WARNING, "Invalid compression level: "
461  "valid range is 0-%d, using %d instead\n",
462  MFX_TARGETUSAGE_BEST_SPEED, MFX_TARGETUSAGE_BEST_SPEED);
463  avctx->compression_level = MFX_TARGETUSAGE_BEST_SPEED;
464  }
465  }
466 
467  q->param.mfx.CodecProfile = q->profile;
468  q->param.mfx.TargetUsage = avctx->compression_level;
469  q->param.mfx.GopPicSize = FFMAX(0, avctx->gop_size);
470  q->param.mfx.GopRefDist = FFMAX(-1, avctx->max_b_frames) + 1;
471  q->param.mfx.GopOptFlag = avctx->flags & AV_CODEC_FLAG_CLOSED_GOP ?
472  MFX_GOP_CLOSED : 0;
473  q->param.mfx.IdrInterval = q->idr_interval;
474  q->param.mfx.NumSlice = avctx->slices;
475  q->param.mfx.NumRefFrame = FFMAX(0, avctx->refs);
476  q->param.mfx.EncodedOrder = 0;
477  q->param.mfx.BufferSizeInKB = 0;
478 
479  desc = av_pix_fmt_desc_get(sw_format);
480  if (!desc)
481  return AVERROR_BUG;
482 
483  ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC);
484 
485  q->param.mfx.FrameInfo.CropX = 0;
486  q->param.mfx.FrameInfo.CropY = 0;
487  q->param.mfx.FrameInfo.CropW = avctx->width;
488  q->param.mfx.FrameInfo.CropH = avctx->height;
489  q->param.mfx.FrameInfo.AspectRatioW = avctx->sample_aspect_ratio.num;
490  q->param.mfx.FrameInfo.AspectRatioH = avctx->sample_aspect_ratio.den;
491  q->param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
492  q->param.mfx.FrameInfo.BitDepthLuma = desc->comp[0].depth;
493  q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
494  q->param.mfx.FrameInfo.Shift = desc->comp[0].depth > 8;
495 
496  // TODO: detect version of MFX--if the minor version is greater than
497  // or equal to 19, then can use the same alignment settings as H.264
498  // for HEVC
499  q->width_align = avctx->codec_id == AV_CODEC_ID_HEVC ? 32 : 16;
500  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, q->width_align);
501 
502  if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
503  // it is important that PicStruct be setup correctly from the
504  // start--otherwise, encoding doesn't work and results in a bunch
505  // of incompatible video parameter errors
506  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_FIELD_TFF;
507  // height alignment always must be 32 for interlaced video
508  q->height_align = 32;
509  } else {
510  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
511  // for progressive video, the height should be aligned to 16 for
512  // H.264. For HEVC, depending on the version of MFX, it should be
513  // either 32 or 16. The lower number is better if possible.
514  q->height_align = avctx->codec_id == AV_CODEC_ID_HEVC ? 32 : 16;
515  }
516  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, q->height_align);
517 
518  if (avctx->hw_frames_ctx) {
519  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
520  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
521  q->param.mfx.FrameInfo.Width = frames_hwctx->surfaces[0].Info.Width;
522  q->param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;
523  }
524 
525  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
526  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
527  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
528  } else {
529  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
530  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
531  }
532 
533  ret = select_rc_mode(avctx, q);
534  if (ret < 0)
535  return ret;
536 
537  switch (q->param.mfx.RateControlMethod) {
538  case MFX_RATECONTROL_CBR:
539  case MFX_RATECONTROL_VBR:
540 #if QSV_HAVE_VCM
541  case MFX_RATECONTROL_VCM:
542 #endif
543  q->param.mfx.BufferSizeInKB = avctx->rc_buffer_size / 8000;
544  q->param.mfx.InitialDelayInKB = avctx->rc_initial_buffer_occupancy / 1000;
545  q->param.mfx.TargetKbps = avctx->bit_rate / 1000;
546  q->param.mfx.MaxKbps = avctx->rc_max_rate / 1000;
547  break;
548  case MFX_RATECONTROL_CQP:
549  quant = avctx->global_quality / FF_QP2LAMBDA;
550 
551  q->param.mfx.QPI = av_clip(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 0, 51);
552  q->param.mfx.QPP = av_clip(quant, 0, 51);
553  q->param.mfx.QPB = av_clip(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 0, 51);
554 
555  break;
556 #if QSV_HAVE_AVBR
557  case MFX_RATECONTROL_AVBR:
558  q->param.mfx.TargetKbps = avctx->bit_rate / 1000;
559  q->param.mfx.Convergence = q->avbr_convergence;
560  q->param.mfx.Accuracy = q->avbr_accuracy;
561  break;
562 #endif
563 #if QSV_HAVE_LA
564  case MFX_RATECONTROL_LA:
565  q->param.mfx.TargetKbps = avctx->bit_rate / 1000;
566  q->extco2.LookAheadDepth = q->look_ahead_depth;
567  break;
568 #if QSV_HAVE_ICQ
569  case MFX_RATECONTROL_LA_ICQ:
570  q->extco2.LookAheadDepth = q->look_ahead_depth;
571  case MFX_RATECONTROL_ICQ:
572  q->param.mfx.ICQQuality = avctx->global_quality;
573  break;
574 #endif
575 #endif
576  }
577 
578  // the HEVC encoder plugin currently fails if coding options
579  // are provided
580  if (avctx->codec_id != AV_CODEC_ID_HEVC) {
581  q->extco.Header.BufferId = MFX_EXTBUFF_CODING_OPTION;
582  q->extco.Header.BufferSz = sizeof(q->extco);
583 
584  q->extco.PicTimingSEI = q->pic_timing_sei ?
585  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;
586 
587  if (q->rdo >= 0)
588  q->extco.RateDistortionOpt = q->rdo > 0 ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
589 
590  if (avctx->codec_id == AV_CODEC_ID_H264) {
591 #if FF_API_CODER_TYPE
593  if (avctx->coder_type >= 0)
594  q->cavlc = avctx->coder_type == FF_CODER_TYPE_VLC;
596 #endif
597  q->extco.CAVLC = q->cavlc ? MFX_CODINGOPTION_ON
598  : MFX_CODINGOPTION_UNKNOWN;
599 
601  q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?
602  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
603 
604  if (q->single_sei_nal_unit >= 0)
605  q->extco.SingleSeiNalUnit = q->single_sei_nal_unit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
606  if (q->recovery_point_sei >= 0)
607  q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
608  q->extco.MaxDecFrameBuffering = q->max_dec_frame_buffering;
609  q->extco.AUDelimiter = q->aud ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
610  }
611 
612  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco;
613 
614 #if QSV_HAVE_CO2
615  if (avctx->codec_id == AV_CODEC_ID_H264) {
616  q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
617  q->extco2.Header.BufferSz = sizeof(q->extco2);
618 
619  if (q->int_ref_type >= 0)
620  q->extco2.IntRefType = q->int_ref_type;
621  if (q->int_ref_cycle_size >= 0)
622  q->extco2.IntRefCycleSize = q->int_ref_cycle_size;
623  if (q->int_ref_qp_delta != INT16_MIN)
624  q->extco2.IntRefQPDelta = q->int_ref_qp_delta;
625 
626  if (q->bitrate_limit >= 0)
627  q->extco2.BitrateLimit = q->bitrate_limit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
628  if (q->mbbrc >= 0)
629  q->extco2.MBBRC = q->mbbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
630  if (q->extbrc >= 0)
631  q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
632 
633  if (q->max_frame_size >= 0)
634  q->extco2.MaxFrameSize = q->max_frame_size;
635 #if QSV_HAVE_MAX_SLICE_SIZE
636  if (q->max_slice_size >= 0)
637  q->extco2.MaxSliceSize = q->max_slice_size;
638 #endif
639 
640 #if QSV_HAVE_TRELLIS
641  q->extco2.Trellis = q->trellis;
642 #endif
643 
644 #if QSV_HAVE_LA_DS
645  q->extco2.LookAheadDS = q->look_ahead_downsampling;
646 #endif
647 
648 #if QSV_HAVE_BREF_TYPE
649 #if FF_API_PRIVATE_OPT
651  if (avctx->b_frame_strategy >= 0)
652  q->b_strategy = avctx->b_frame_strategy;
654 #endif
655  if (q->b_strategy >= 0)
656  q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
657  if (q->adaptive_i >= 0)
658  q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
659  if (q->adaptive_b >= 0)
660  q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
661 #endif
662 
663 #if QSV_VERSION_ATLEAST(1, 9)
664  if (avctx->qmin >= 0 && avctx->qmax >= 0 && avctx->qmin > avctx->qmax) {
665  av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are set but invalid, please make sure min <= max\n");
666  return AVERROR(EINVAL);
667  }
668  if (avctx->qmin >= 0) {
669  q->extco2.MinQPI = avctx->qmin > 51 ? 51 : avctx->qmin;
670  q->extco2.MinQPP = q->extco2.MinQPB = q->extco2.MinQPI;
671  }
672  if (avctx->qmax >= 0) {
673  q->extco2.MaxQPI = avctx->qmax > 51 ? 51 : avctx->qmax;
674  q->extco2.MaxQPP = q->extco2.MaxQPB = q->extco2.MaxQPI;
675  }
676 #endif
677  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
678  }
679 #endif
680 #if QSV_HAVE_MF
681  if (avctx->codec_id == AV_CODEC_ID_H264) {
682  mfxVersion ver;
683  ret = MFXQueryVersion(q->session,&ver);
684  if (ret >= MFX_ERR_NONE && QSV_RUNTIME_VERSION_ATLEAST(ver, 1, 25)) {
685  q->extmfp.Header.BufferId = MFX_EXTBUFF_MULTI_FRAME_PARAM;
686  q->extmfp.Header.BufferSz = sizeof(q->extmfp);
687 
688  q->extmfp.MFMode = q->mfmode;
689  av_log(avctx,AV_LOG_VERBOSE,"MFMode:%d\n", q->extmfp.MFMode);
690  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extmfp;
691  }
692  }
693 #endif
694  }
695 
696  if (!check_enc_param(avctx,q)) {
697  av_log(avctx, AV_LOG_ERROR,
698  "some encoding parameters are not supported by the QSV "
699  "runtime. Please double check the input parameters.\n");
700  return AVERROR(ENOSYS);
701  }
702 
703  return 0;
704 }
705 
707 {
708  int ret = 0;
709 
710  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
711  if (ret < 0)
712  return ff_qsv_print_error(avctx, ret,
713  "Error calling GetVideoParam");
714 
715  q->packet_size = q->param.mfx.BufferSizeInKB * 1000;
716 
717  // for qsv mjpeg the return value maybe 0 so alloc the buffer
718  if (q->packet_size == 0)
719  q->packet_size = q->param.mfx.FrameInfo.Height * q->param.mfx.FrameInfo.Width * 4;
720 
721  return 0;
722 }
723 
725 {
726  AVCPBProperties *cpb_props;
727 
728  uint8_t sps_buf[128];
729  uint8_t pps_buf[128];
730 
731  mfxExtCodingOptionSPSPPS extradata = {
732  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
733  .Header.BufferSz = sizeof(extradata),
734  .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),
735  .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
736  };
737 
738  mfxExtCodingOption co = {
739  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
740  .Header.BufferSz = sizeof(co),
741  };
742 #if QSV_HAVE_CO2
743  mfxExtCodingOption2 co2 = {
744  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
745  .Header.BufferSz = sizeof(co2),
746  };
747 #endif
748 
749  mfxExtBuffer *ext_buffers[] = {
750  (mfxExtBuffer*)&extradata,
751  (mfxExtBuffer*)&co,
752 #if QSV_HAVE_CO2
753  (mfxExtBuffer*)&co2,
754 #endif
755  };
756 
757  int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
758  int ret;
759 
760  q->param.ExtParam = ext_buffers;
761  q->param.NumExtParam = FF_ARRAY_ELEMS(ext_buffers);
762 
763  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
764  if (ret < 0)
765  return ff_qsv_print_error(avctx, ret,
766  "Error calling GetVideoParam");
767 
768  q->packet_size = q->param.mfx.BufferSizeInKB * 1000;
769 
770  if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)) {
771  av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
772  return AVERROR_UNKNOWN;
773  }
774 
775  avctx->extradata = av_malloc(extradata.SPSBufSize + need_pps * extradata.PPSBufSize +
777  if (!avctx->extradata)
778  return AVERROR(ENOMEM);
779 
780  memcpy(avctx->extradata, sps_buf, extradata.SPSBufSize);
781  if (need_pps)
782  memcpy(avctx->extradata + extradata.SPSBufSize, pps_buf, extradata.PPSBufSize);
783  avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
784  memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
785 
786  cpb_props = ff_add_cpb_side_data(avctx);
787  if (!cpb_props)
788  return AVERROR(ENOMEM);
789  cpb_props->max_bitrate = avctx->rc_max_rate;
790  cpb_props->min_bitrate = avctx->rc_min_rate;
791  cpb_props->avg_bitrate = avctx->bit_rate;
792  cpb_props->buffer_size = avctx->rc_buffer_size;
793 
794  dump_video_param(avctx, q, ext_buffers + 1);
795 
796  return 0;
797 }
798 
800 {
801  AVQSVContext *qsv = avctx->hwaccel_context;
802  mfxFrameSurface1 *surfaces;
803  int nb_surfaces, i;
804 
805  nb_surfaces = qsv->nb_opaque_surfaces + q->req.NumFrameSuggested;
806 
807  q->opaque_alloc_buf = av_buffer_allocz(sizeof(*surfaces) * nb_surfaces);
808  if (!q->opaque_alloc_buf)
809  return AVERROR(ENOMEM);
810 
811  q->opaque_surfaces = av_malloc_array(nb_surfaces, sizeof(*q->opaque_surfaces));
812  if (!q->opaque_surfaces)
813  return AVERROR(ENOMEM);
814 
815  surfaces = (mfxFrameSurface1*)q->opaque_alloc_buf->data;
816  for (i = 0; i < nb_surfaces; i++) {
817  surfaces[i].Info = q->req.Info;
818  q->opaque_surfaces[i] = surfaces + i;
819  }
820 
821  q->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
822  q->opaque_alloc.Header.BufferSz = sizeof(q->opaque_alloc);
823  q->opaque_alloc.In.Surfaces = q->opaque_surfaces;
824  q->opaque_alloc.In.NumSurface = nb_surfaces;
825  q->opaque_alloc.In.Type = q->req.Type;
826 
827  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->opaque_alloc;
828 
829  qsv->nb_opaque_surfaces = nb_surfaces;
831  qsv->opaque_alloc_type = q->req.Type;
832 
833  return 0;
834 }
835 
837 {
838  int ret;
839 
840  if (avctx->hwaccel_context) {
841  AVQSVContext *qsv = avctx->hwaccel_context;
842  q->session = qsv->session;
843  } else if (avctx->hw_frames_ctx) {
845  if (!q->frames_ctx.hw_frames_ctx)
846  return AVERROR(ENOMEM);
847 
849  &q->frames_ctx, q->load_plugins,
850  q->param.IOPattern == MFX_IOPATTERN_IN_OPAQUE_MEMORY);
851  if (ret < 0) {
853  return ret;
854  }
855 
856  q->session = q->internal_session;
857  } else if (avctx->hw_device_ctx) {
859  avctx->hw_device_ctx, q->load_plugins);
860  if (ret < 0)
861  return ret;
862 
863  q->session = q->internal_session;
864  } else {
866  q->load_plugins);
867  if (ret < 0)
868  return ret;
869 
870  q->session = q->internal_session;
871  }
872 
873  return 0;
874 }
875 
876 static inline unsigned int qsv_fifo_item_size(void)
877 {
878  return sizeof(AVPacket) + sizeof(mfxSyncPoint*) + sizeof(mfxBitstream*);
879 }
880 
881 static inline unsigned int qsv_fifo_size(const AVFifoBuffer* fifo)
882 {
883  return av_fifo_size(fifo)/qsv_fifo_item_size();
884 }
885 
887 {
888  int iopattern = 0;
889  int opaque_alloc = 0;
890  int ret;
891 
892  q->param.AsyncDepth = q->async_depth;
893 
895  if (!q->async_fifo)
896  return AVERROR(ENOMEM);
897 
898  if (avctx->hwaccel_context) {
899  AVQSVContext *qsv = avctx->hwaccel_context;
900 
901  iopattern = qsv->iopattern;
902  opaque_alloc = qsv->opaque_alloc;
903  }
904 
905  if (avctx->hw_frames_ctx) {
906  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
907  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
908 
909  if (!iopattern) {
910  if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)
911  iopattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
912  else if (frames_hwctx->frame_type &
913  (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
914  iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
915  }
916  }
917 
918  if (!iopattern)
919  iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
920  q->param.IOPattern = iopattern;
921 
922  ret = qsvenc_init_session(avctx, q);
923  if (ret < 0)
924  return ret;
925 
926  // in the mfxInfoMFX struct, JPEG is different from other codecs
927  switch (avctx->codec_id) {
928  case AV_CODEC_ID_MJPEG:
929  ret = init_video_param_jpeg(avctx, q);
930  break;
931  default:
932  ret = init_video_param(avctx, q);
933  break;
934  }
935  if (ret < 0)
936  return ret;
937 
938  ret = MFXVideoENCODE_Query(q->session, &q->param, &q->param);
939  if (ret == MFX_WRN_PARTIAL_ACCELERATION) {
940  av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
941  } else if (ret < 0) {
942  return ff_qsv_print_error(avctx, ret,
943  "Error querying encoder params");
944  }
945 
946  ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
947  if (ret < 0)
948  return ff_qsv_print_error(avctx, ret,
949  "Error querying (IOSurf) the encoding parameters");
950 
951  if (opaque_alloc) {
952  ret = qsv_init_opaque_alloc(avctx, q);
953  if (ret < 0)
954  return ret;
955  }
956 
957  if (avctx->hwaccel_context) {
958  AVQSVContext *qsv = avctx->hwaccel_context;
959  int i, j;
960 
962  sizeof(*q->extparam));
963  if (!q->extparam)
964  return AVERROR(ENOMEM);
965 
966  q->param.ExtParam = q->extparam;
967  for (i = 0; i < qsv->nb_ext_buffers; i++)
968  q->param.ExtParam[i] = qsv->ext_buffers[i];
969  q->param.NumExtParam = qsv->nb_ext_buffers;
970 
971  for (i = 0; i < q->nb_extparam_internal; i++) {
972  for (j = 0; j < qsv->nb_ext_buffers; j++) {
973  if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)
974  break;
975  }
976  if (j < qsv->nb_ext_buffers)
977  continue;
978 
979  q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];
980  }
981  } else {
982  q->param.ExtParam = q->extparam_internal;
983  q->param.NumExtParam = q->nb_extparam_internal;
984  }
985 
986  ret = MFXVideoENCODE_Init(q->session, &q->param);
987  if (ret < 0)
988  return ff_qsv_print_error(avctx, ret,
989  "Error initializing the encoder");
990  else if (ret > 0)
991  ff_qsv_print_warning(avctx, ret,
992  "Warning in encoder initialization");
993 
994  switch (avctx->codec_id) {
995  case AV_CODEC_ID_MJPEG:
996  ret = qsv_retrieve_enc_jpeg_params(avctx, q);
997  break;
998  default:
999  ret = qsv_retrieve_enc_params(avctx, q);
1000  break;
1001  }
1002  if (ret < 0) {
1003  av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
1004  return ret;
1005  }
1006 
1007  q->avctx = avctx;
1008 
1009  return 0;
1010 }
1011 
1012 static void free_encoder_ctrl_payloads(mfxEncodeCtrl* enc_ctrl)
1013 {
1014  if (enc_ctrl) {
1015  int i;
1016  for (i = 0; i < enc_ctrl->NumPayload && i < QSV_MAX_ENC_PAYLOAD; i++) {
1017  av_free(enc_ctrl->Payload[i]);
1018  }
1019  enc_ctrl->NumPayload = 0;
1020  }
1021 }
1022 
1024 {
1025  QSVFrame *cur = q->work_frames;
1026  while (cur) {
1027  if (cur->used && !cur->surface.Data.Locked) {
1029  if (cur->frame->format == AV_PIX_FMT_QSV) {
1030  av_frame_unref(cur->frame);
1031  }
1032  cur->used = 0;
1033  }
1034  cur = cur->next;
1035  }
1036 }
1037 
1039 {
1040  QSVFrame *frame, **last;
1041 
1043 
1044  frame = q->work_frames;
1045  last = &q->work_frames;
1046  while (frame) {
1047  if (!frame->used) {
1048  *f = frame;
1049  frame->used = 1;
1050  return 0;
1051  }
1052 
1053  last = &frame->next;
1054  frame = frame->next;
1055  }
1056 
1057  frame = av_mallocz(sizeof(*frame));
1058  if (!frame)
1059  return AVERROR(ENOMEM);
1060  frame->frame = av_frame_alloc();
1061  if (!frame->frame) {
1062  av_freep(&frame);
1063  return AVERROR(ENOMEM);
1064  }
1065  frame->enc_ctrl.Payload = av_mallocz(sizeof(mfxPayload*) * QSV_MAX_ENC_PAYLOAD);
1066  if (!frame->enc_ctrl.Payload) {
1067  av_freep(&frame);
1068  return AVERROR(ENOMEM);
1069  }
1070  *last = frame;
1071 
1072  *f = frame;
1073  frame->used = 1;
1074 
1075  return 0;
1076 }
1077 
1078 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
1079  QSVFrame **new_frame)
1080 {
1081  QSVFrame *qf;
1082  int ret;
1083 
1084  ret = get_free_frame(q, &qf);
1085  if (ret < 0)
1086  return ret;
1087 
1088  if (frame->format == AV_PIX_FMT_QSV) {
1089  ret = av_frame_ref(qf->frame, frame);
1090  if (ret < 0)
1091  return ret;
1092 
1093  qf->surface = *(mfxFrameSurface1*)qf->frame->data[3];
1094 
1095  if (q->frames_ctx.mids) {
1096  ret = ff_qsv_find_surface_idx(&q->frames_ctx, qf);
1097  if (ret < 0)
1098  return ret;
1099 
1100  qf->surface.Data.MemId = &q->frames_ctx.mids[ret];
1101  }
1102  } else {
1103  /* make a copy if the input is not padded as libmfx requires */
1104  /* and to make allocation continious for data[0]/data[1] */
1105  if ((frame->height & 31 || frame->linesize[0] & (q->width_align - 1)) ||
1106  (frame->data[1] - frame->data[0] != frame->linesize[0] * FFALIGN(qf->frame->height, q->height_align))) {
1107  qf->frame->height = FFALIGN(frame->height, q->height_align);
1108  qf->frame->width = FFALIGN(frame->width, q->width_align);
1109 
1110  qf->frame->format = frame->format;
1111 
1112  if (!qf->frame->data[0]) {
1113  ret = av_frame_get_buffer(qf->frame, q->width_align);
1114  if (ret < 0)
1115  return ret;
1116  }
1117 
1118  qf->frame->height = frame->height;
1119  qf->frame->width = frame->width;
1120 
1121  ret = av_frame_copy(qf->frame, frame);
1122  if (ret < 0) {
1123  av_frame_unref(qf->frame);
1124  return ret;
1125  }
1126  } else {
1127  ret = av_frame_ref(qf->frame, frame);
1128  if (ret < 0)
1129  return ret;
1130  }
1131 
1132  qf->surface.Info = q->param.mfx.FrameInfo;
1133 
1134  qf->surface.Info.PicStruct =
1135  !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
1136  frame->top_field_first ? MFX_PICSTRUCT_FIELD_TFF :
1137  MFX_PICSTRUCT_FIELD_BFF;
1138  if (frame->repeat_pict == 1)
1139  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
1140  else if (frame->repeat_pict == 2)
1141  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
1142  else if (frame->repeat_pict == 4)
1143  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
1144 
1145  qf->surface.Data.PitchLow = qf->frame->linesize[0];
1146  qf->surface.Data.Y = qf->frame->data[0];
1147  qf->surface.Data.UV = qf->frame->data[1];
1148  }
1149 
1150  qf->surface.Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
1151 
1152  *new_frame = qf;
1153 
1154  return 0;
1155 }
1156 
1158 {
1159  if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
1160  if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
1161  q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
1162  q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
1163  av_log(avctx, AV_LOG_WARNING,
1164  "Interlaced coding is supported"
1165  " at Main/High Profile Level 2.2-4.0\n");
1166  }
1167 }
1168 
1170  const AVFrame *frame)
1171 {
1172  AVPacket new_pkt = { 0 };
1173  mfxBitstream *bs;
1174 #if QSV_VERSION_ATLEAST(1, 26)
1175  mfxExtAVCEncodedFrameInfo *enc_info;
1176  mfxExtBuffer **enc_buf;
1177 #endif
1178 
1179  mfxFrameSurface1 *surf = NULL;
1180  mfxSyncPoint *sync = NULL;
1181  QSVFrame *qsv_frame = NULL;
1182  mfxEncodeCtrl* enc_ctrl = NULL;
1183  int ret;
1184 
1185  if (frame) {
1186  ret = submit_frame(q, frame, &qsv_frame);
1187  if (ret < 0) {
1188  av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
1189  return ret;
1190  }
1191  }
1192  if (qsv_frame) {
1193  surf = &qsv_frame->surface;
1194  enc_ctrl = &qsv_frame->enc_ctrl;
1195  }
1196 
1197  ret = av_new_packet(&new_pkt, q->packet_size);
1198  if (ret < 0) {
1199  av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
1200  return ret;
1201  }
1202 
1203  bs = av_mallocz(sizeof(*bs));
1204  if (!bs) {
1205  av_packet_unref(&new_pkt);
1206  return AVERROR(ENOMEM);
1207  }
1208  bs->Data = new_pkt.data;
1209  bs->MaxLength = new_pkt.size;
1210 
1211 #if QSV_VERSION_ATLEAST(1, 26)
1212  if (avctx->codec_id == AV_CODEC_ID_H264) {
1213  enc_info = av_mallocz(sizeof(*enc_info));
1214  if (!enc_info)
1215  return AVERROR(ENOMEM);
1216 
1217  enc_info->Header.BufferId = MFX_EXTBUFF_ENCODED_FRAME_INFO;
1218  enc_info->Header.BufferSz = sizeof (*enc_info);
1219  bs->NumExtParam = 1;
1220  enc_buf = av_mallocz(sizeof(mfxExtBuffer *));
1221  if (!enc_buf)
1222  return AVERROR(ENOMEM);
1223  enc_buf[0] = (mfxExtBuffer *)enc_info;
1224 
1225  bs->ExtParam = enc_buf;
1226  }
1227 #endif
1228 
1229  if (q->set_encode_ctrl_cb) {
1230  q->set_encode_ctrl_cb(avctx, frame, &qsv_frame->enc_ctrl);
1231  }
1232 
1233  sync = av_mallocz(sizeof(*sync));
1234  if (!sync) {
1235  av_freep(&bs);
1236  #if QSV_VERSION_ATLEAST(1, 26)
1237  if (avctx->codec_id == AV_CODEC_ID_H264) {
1238  av_freep(&enc_info);
1239  av_freep(&enc_buf);
1240  }
1241  #endif
1242  av_packet_unref(&new_pkt);
1243  return AVERROR(ENOMEM);
1244  }
1245 
1246  do {
1247  ret = MFXVideoENCODE_EncodeFrameAsync(q->session, enc_ctrl, surf, bs, sync);
1248  if (ret == MFX_WRN_DEVICE_BUSY)
1249  av_usleep(500);
1250  } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_WRN_IN_EXECUTION);
1251 
1252  if (ret > 0)
1253  ff_qsv_print_warning(avctx, ret, "Warning during encoding");
1254 
1255  if (ret < 0) {
1256  av_packet_unref(&new_pkt);
1257  av_freep(&bs);
1258 #if QSV_VERSION_ATLEAST(1, 26)
1259  if (avctx->codec_id == AV_CODEC_ID_H264) {
1260  av_freep(&enc_info);
1261  av_freep(&enc_buf);
1262  }
1263 #endif
1264  av_freep(&sync);
1265  return (ret == MFX_ERR_MORE_DATA) ?
1266  0 : ff_qsv_print_error(avctx, ret, "Error during encoding");
1267  }
1268 
1269  if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM && frame->interlaced_frame)
1270  print_interlace_msg(avctx, q);
1271 
1272  if (*sync) {
1273  av_fifo_generic_write(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1274  av_fifo_generic_write(q->async_fifo, &sync, sizeof(sync), NULL);
1275  av_fifo_generic_write(q->async_fifo, &bs, sizeof(bs), NULL);
1276  } else {
1277  av_freep(&sync);
1278  av_packet_unref(&new_pkt);
1279  av_freep(&bs);
1280 #if QSV_VERSION_ATLEAST(1, 26)
1281  if (avctx->codec_id == AV_CODEC_ID_H264) {
1282  av_freep(&enc_info);
1283  av_freep(&enc_buf);
1284  }
1285 #endif
1286  }
1287 
1288  return 0;
1289 }
1290 
1292  AVPacket *pkt, const AVFrame *frame, int *got_packet)
1293 {
1294  int ret;
1295 
1296  ret = encode_frame(avctx, q, frame);
1297  if (ret < 0)
1298  return ret;
1299 
1300  if ((qsv_fifo_size(q->async_fifo) >= q->async_depth) ||
1301  (!frame && av_fifo_size(q->async_fifo))) {
1302  AVPacket new_pkt;
1303  mfxBitstream *bs;
1304  mfxSyncPoint *sync;
1305 #if QSV_VERSION_ATLEAST(1, 26)
1306  mfxExtAVCEncodedFrameInfo *enc_info;
1307  mfxExtBuffer **enc_buf;
1308 #endif
1309  enum AVPictureType pict_type;
1310 
1311  av_fifo_generic_read(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1312  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1313  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1314 
1315  do {
1316  ret = MFXVideoCORE_SyncOperation(q->session, *sync, 1000);
1317  } while (ret == MFX_WRN_IN_EXECUTION);
1318 
1319  new_pkt.dts = av_rescale_q(bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
1320  new_pkt.pts = av_rescale_q(bs->TimeStamp, (AVRational){1, 90000}, avctx->time_base);
1321  new_pkt.size = bs->DataLength;
1322 
1323  if (bs->FrameType & MFX_FRAMETYPE_IDR ||
1324  bs->FrameType & MFX_FRAMETYPE_xIDR)
1325  new_pkt.flags |= AV_PKT_FLAG_KEY;
1326 
1327  if (bs->FrameType & MFX_FRAMETYPE_I || bs->FrameType & MFX_FRAMETYPE_xI)
1328  pict_type = AV_PICTURE_TYPE_I;
1329  else if (bs->FrameType & MFX_FRAMETYPE_P || bs->FrameType & MFX_FRAMETYPE_xP)
1330  pict_type = AV_PICTURE_TYPE_P;
1331  else if (bs->FrameType & MFX_FRAMETYPE_B || bs->FrameType & MFX_FRAMETYPE_xB)
1332  pict_type = AV_PICTURE_TYPE_B;
1333 
1334 #if FF_API_CODED_FRAME
1336  avctx->coded_frame->pict_type = pict_type;
1338 #endif
1339 
1340 #if QSV_VERSION_ATLEAST(1, 26)
1341  if (avctx->codec_id == AV_CODEC_ID_H264) {
1342  enc_buf = bs->ExtParam;
1343  enc_info = (mfxExtAVCEncodedFrameInfo *)(*bs->ExtParam);
1345  enc_info->QP * FF_QP2LAMBDA, NULL, 0, pict_type);
1346  av_freep(&enc_info);
1347  av_freep(&enc_buf);
1348  }
1349 #endif
1350  av_freep(&bs);
1351  av_freep(&sync);
1352 
1353  if (pkt->data) {
1354  if (pkt->size < new_pkt.size) {
1355  av_log(avctx, AV_LOG_ERROR, "Submitted buffer not large enough: %d < %d\n",
1356  pkt->size, new_pkt.size);
1357  av_packet_unref(&new_pkt);
1358  return AVERROR(EINVAL);
1359  }
1360 
1361  memcpy(pkt->data, new_pkt.data, new_pkt.size);
1362  pkt->size = new_pkt.size;
1363 
1364  ret = av_packet_copy_props(pkt, &new_pkt);
1365  av_packet_unref(&new_pkt);
1366  if (ret < 0)
1367  return ret;
1368  } else
1369  *pkt = new_pkt;
1370 
1371  *got_packet = 1;
1372  }
1373 
1374  return 0;
1375 }
1376 
1378 {
1379  QSVFrame *cur;
1380 
1381  if (q->session)
1382  MFXVideoENCODE_Close(q->session);
1383  if (q->internal_session)
1384  MFXClose(q->internal_session);
1385  q->session = NULL;
1386  q->internal_session = NULL;
1387 
1390 
1391  cur = q->work_frames;
1392  while (cur) {
1393  q->work_frames = cur->next;
1394  av_frame_free(&cur->frame);
1395  av_free(cur->enc_ctrl.Payload);
1396  av_freep(&cur);
1397  cur = q->work_frames;
1398  }
1399 
1400  while (q->async_fifo && av_fifo_size(q->async_fifo)) {
1401  AVPacket pkt;
1402  mfxSyncPoint *sync;
1403  mfxBitstream *bs;
1404 
1405  av_fifo_generic_read(q->async_fifo, &pkt, sizeof(pkt), NULL);
1406  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1407  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1408 
1409  av_freep(&sync);
1410  av_freep(&bs);
1411  av_packet_unref(&pkt);
1412  }
1414  q->async_fifo = NULL;
1415 
1418 
1419  av_freep(&q->extparam);
1420 
1421  return 0;
1422 }
int single_sei_nal_unit
Definition: qsvenc.h:147
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:3055
const char const char void * val
Definition: avisynth_c.h:771
#define FF_COMPRESSION_DEFAULT
Definition: avcodec.h:1605
#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:2406
This structure describes decoded (raw) audio or video data.
Definition: frame.h:218
AVBufferRef * opaque_alloc_buf
Definition: qsvenc.h:118
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:716
mfxExtBuffer ** extparam
Definition: qsvenc.h:123
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:882
int int_ref_type
Definition: qsvenc.h:159
#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:116
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1582
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:142
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:1112
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:1792
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2434
mfxFrameAllocRequest req
Definition: qsvenc.h:106
int avbr_accuracy
Definition: qsvenc.h:134
mfxEncodeCtrl enc_ctrl
Definition: qsv_internal.h:57
QSVFrame * work_frames
Definition: qsvenc.h:96
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:138
static int get_free_frame(QSVEncContext *q, QSVFrame **f)
Definition: qsvenc.c:1038
int size
Definition: avcodec.h:1445
int int_ref_qp_delta
Definition: qsvenc.h:161
#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:1911
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1742
QSVFramesContext frames_ctx
Definition: qsvenc.h:127
int packet_size
Definition: qsvenc.h:101
#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:99
static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1157
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:1844
int min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: avcodec.h:1117
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:1655
int bitrate_limit
Definition: qsvenc.h:151
int look_ahead
Definition: qsvenc.h:137
int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: qsvenc.c:1291
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
mfxVideoParam param
Definition: qsvenc.h:105
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:125
#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:2701
AVBufferRef * mids_buf
Definition: qsv_internal.h:75
mfxExtCodingOption extco
Definition: qsvenc.h:108
#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:1801
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
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1633
int opaque_alloc
Encoding only.
Definition: qsv.h:65
static AVFrame * frame
mfxFrameSurface1 ** opaque_surfaces
Definition: qsvenc.h:117
uint8_t * data
Definition: avcodec.h:1444
static int qsv_retrieve_enc_jpeg_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:706
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:1128
int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1377
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:1476
int b_strategy
Definition: qsvenc.h:156
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
int qmax
maximum quantizer
Definition: avcodec.h:2377
char * load_plugins
Definition: qsvenc.h:169
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:1612
static unsigned int qsv_fifo_item_size(void)
Definition: qsvenc.c:876
int nb_extparam_internal
Definition: qsvenc.h:121
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:1837
int max_dec_frame_buffering
Definition: qsvenc.h:148
int iopattern
The IO pattern to use.
Definition: qsv.h:46
static unsigned int qsv_fifo_size(const AVFifoBuffer *fifo)
Definition: qsvenc.c:881
#define FFMAX(a, b)
Definition: common.h:94
static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:724
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:154
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2391
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:2413
int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc)
Definition: qsv.c:171
int refs
number of reference frames
Definition: avcodec.h:2116
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:564
const char * name
Definition: qsvenc.c:45
AVCodecContext * avctx
Definition: qsvenc.h:94
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:301
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:841
int idr_interval
Definition: qsvenc.h:131
int width
picture width / height.
Definition: avcodec.h:1705
int extbrc
Definition: qsvenc.h:153
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:3212
int preset
Definition: qsvenc.h:133
int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)
Definition: qsv.c:43
static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:268
int level
level
Definition: avcodec.h:2968
#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:130
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
attribute_deprecated int coder_type
Definition: avcodec.h:2445
#define FF_ARRAY_ELEMS(a)
int width_align
Definition: qsvenc.h:102
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:1107
static int qsvenc_init_session(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:836
Libavcodec external API header.
enum AVCodecID codec_id
Definition: avcodec.h:1542
int av_fifo_size(const AVFifoBuffer *f)
Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from ...
Definition: fifo.c:77
int compression_level
Definition: avcodec.h:1604
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:1806
static const struct @131 rc_names[]
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:1532
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:598
uint8_t * data
The data buffer.
Definition: buffer.h:89
struct QSVFrame * next
Definition: qsv_internal.h:64
int qmin
minimum quantizer
Definition: avcodec.h:2370
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:161
int profile
Definition: qsvenc.h:132
static void free_encoder_ctrl_payloads(mfxEncodeCtrl *enc_ctrl)
Definition: qsvenc.c:1012
int extradata_size
Definition: avcodec.h:1634
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:103
#define FF_CODER_TYPE_VLC
Definition: avcodec.h:2437
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2594
int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:886
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
AVPictureType
Definition: avutil.h:272
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:1814
int max_slice_size
Definition: qsvenc.h:143
This struct is used for communicating QSV parameters between libavcodec and the caller.
Definition: qsv.h:36
mfxU16 profile
Definition: qsvenc.c:44
const uint8_t * quant
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:322
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:1598
int int_ref_cycle_size
Definition: qsvenc.h:160
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:1727
static int check_enc_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:351
int adaptive_b
Definition: qsvenc.h:155
#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:135
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:2775
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:1945
static const struct @130 profile_names[]
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:781
int slices
Number of slices.
Definition: avcodec.h:2179
#define MFX_LOOKAHEAD_DS_4x
Definition: qsvenc.h:66
int recovery_point_sei
Definition: qsvenc.h:162
#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:1122
#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:1443
int look_ahead_downsampling
Definition: qsvenc.h:139
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:120
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:904
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:3264
int trellis
Definition: qsvenc.h:149
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1421
mfxSession session
Definition: qsvenc.h:98
static int qsv_init_opaque_alloc(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:799
#define QSV_HAVE_VCM
Definition: qsvenc.h:57
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:2591
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:3062
for(j=16;j >0;--j)
int pic_timing_sei
Definition: qsvenc.h:136
static int encode_frame(AVCodecContext *avctx, QSVEncContext *q, const AVFrame *frame)
Definition: qsvenc.c:1169
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:1078
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2406
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
SetEncodeCtrlCB * set_encode_ctrl_cb
Definition: qsvenc.h:170
static void clear_unused_frames(QSVEncContext *q)
Definition: qsvenc.c:1023