FFmpeg
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 #if QSV_HAVE_CO3
140  mfxExtCodingOption3 *co3 = (mfxExtCodingOption3*)coding_opts[2];
141 #endif
142 
143  av_log(avctx, AV_LOG_VERBOSE, "profile: %s; level: %"PRIu16"\n",
144  print_profile(info->CodecProfile), info->CodecLevel);
145 
146  av_log(avctx, AV_LOG_VERBOSE, "GopPicSize: %"PRIu16"; GopRefDist: %"PRIu16"; GopOptFlag: ",
147  info->GopPicSize, info->GopRefDist);
148  if (info->GopOptFlag & MFX_GOP_CLOSED)
149  av_log(avctx, AV_LOG_VERBOSE, "closed ");
150  if (info->GopOptFlag & MFX_GOP_STRICT)
151  av_log(avctx, AV_LOG_VERBOSE, "strict ");
152  av_log(avctx, AV_LOG_VERBOSE, "; IdrInterval: %"PRIu16"\n", info->IdrInterval);
153 
154  av_log(avctx, AV_LOG_VERBOSE, "TargetUsage: %"PRIu16"; RateControlMethod: %s\n",
155  info->TargetUsage, print_ratecontrol(info->RateControlMethod));
156 
157  if (info->RateControlMethod == MFX_RATECONTROL_CBR ||
158  info->RateControlMethod == MFX_RATECONTROL_VBR
159 #if QSV_HAVE_VCM
160  || info->RateControlMethod == MFX_RATECONTROL_VCM
161 #endif
162  ) {
163  av_log(avctx, AV_LOG_VERBOSE,
164  "BufferSizeInKB: %"PRIu16"; InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
165  info->BufferSizeInKB, info->InitialDelayInKB, info->TargetKbps, info->MaxKbps, info->BRCParamMultiplier);
166  } else if (info->RateControlMethod == MFX_RATECONTROL_CQP) {
167  av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",
168  info->QPI, info->QPP, info->QPB);
169  }
170 #if QSV_HAVE_AVBR
171  else if (info->RateControlMethod == MFX_RATECONTROL_AVBR) {
172  av_log(avctx, AV_LOG_VERBOSE,
173  "TargetKbps: %"PRIu16"; Accuracy: %"PRIu16"; Convergence: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
174  info->TargetKbps, info->Accuracy, info->Convergence, info->BRCParamMultiplier);
175  }
176 #endif
177 #if QSV_HAVE_LA
178  else if (info->RateControlMethod == MFX_RATECONTROL_LA
179 #if QSV_HAVE_LA_HRD
180  || info->RateControlMethod == MFX_RATECONTROL_LA_HRD
181 #endif
182  ) {
183  av_log(avctx, AV_LOG_VERBOSE,
184  "TargetKbps: %"PRIu16"; LookAheadDepth: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
185  info->TargetKbps, co2->LookAheadDepth, info->BRCParamMultiplier);
186  }
187 #endif
188 #if QSV_HAVE_ICQ
189  else if (info->RateControlMethod == MFX_RATECONTROL_ICQ) {
190  av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);
191  } else if (info->RateControlMethod == MFX_RATECONTROL_LA_ICQ) {
192  av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"; LookAheadDepth: %"PRIu16"\n",
193  info->ICQQuality, co2->LookAheadDepth);
194  }
195 #endif
196 #if QSV_HAVE_QVBR
197  else if (info->RateControlMethod == MFX_RATECONTROL_QVBR) {
198  av_log(avctx, AV_LOG_VERBOSE, "QVBRQuality: %"PRIu16"\n",
199  co3->QVBRQuality);
200  }
201 #endif
202  av_log(avctx, AV_LOG_VERBOSE, "NumSlice: %"PRIu16"; NumRefFrame: %"PRIu16"\n",
203  info->NumSlice, info->NumRefFrame);
204  av_log(avctx, AV_LOG_VERBOSE, "RateDistortionOpt: %s\n",
205  print_threestate(co->RateDistortionOpt));
206 
207 #if QSV_HAVE_CO2
208  av_log(avctx, AV_LOG_VERBOSE,
209  "RecoveryPointSEI: %s IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16"; IntRefQPDelta: %"PRId16"\n",
210  print_threestate(co->RecoveryPointSEI), co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);
211 
212  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %"PRIu16"; ", co2->MaxFrameSize);
213 #if QSV_HAVE_MAX_SLICE_SIZE
214  av_log(avctx, AV_LOG_VERBOSE, "MaxSliceSize: %"PRIu16"; ", co2->MaxSliceSize);
215 #endif
216  av_log(avctx, AV_LOG_VERBOSE, "\n");
217 
218  av_log(avctx, AV_LOG_VERBOSE,
219  "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
220  print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),
221  print_threestate(co2->ExtBRC));
222 
223 #if QSV_HAVE_TRELLIS
224  av_log(avctx, AV_LOG_VERBOSE, "Trellis: ");
225  if (co2->Trellis & MFX_TRELLIS_OFF) {
226  av_log(avctx, AV_LOG_VERBOSE, "off");
227  } else if (!co2->Trellis) {
228  av_log(avctx, AV_LOG_VERBOSE, "auto");
229  } else {
230  if (co2->Trellis & MFX_TRELLIS_I) av_log(avctx, AV_LOG_VERBOSE, "I");
231  if (co2->Trellis & MFX_TRELLIS_P) av_log(avctx, AV_LOG_VERBOSE, "P");
232  if (co2->Trellis & MFX_TRELLIS_B) av_log(avctx, AV_LOG_VERBOSE, "B");
233  }
234  av_log(avctx, AV_LOG_VERBOSE, "\n");
235 #endif
236 
237 #if QSV_HAVE_VDENC
238  av_log(avctx, AV_LOG_VERBOSE, "VDENC: %s\n", print_threestate(info->LowPower));
239 #endif
240 
241 #if QSV_VERSION_ATLEAST(1, 8)
242  av_log(avctx, AV_LOG_VERBOSE,
243  "RepeatPPS: %s; NumMbPerSlice: %"PRIu16"; LookAheadDS: ",
244  print_threestate(co2->RepeatPPS), co2->NumMbPerSlice);
245  switch (co2->LookAheadDS) {
246  case MFX_LOOKAHEAD_DS_OFF: av_log(avctx, AV_LOG_VERBOSE, "off"); break;
247  case MFX_LOOKAHEAD_DS_2x: av_log(avctx, AV_LOG_VERBOSE, "2x"); break;
248  case MFX_LOOKAHEAD_DS_4x: av_log(avctx, AV_LOG_VERBOSE, "4x"); break;
249  default: av_log(avctx, AV_LOG_VERBOSE, "unknown"); break;
250  }
251  av_log(avctx, AV_LOG_VERBOSE, "\n");
252 
253  av_log(avctx, AV_LOG_VERBOSE, "AdaptiveI: %s; AdaptiveB: %s; BRefType: ",
254  print_threestate(co2->AdaptiveI), print_threestate(co2->AdaptiveB));
255  switch (co2->BRefType) {
256  case MFX_B_REF_OFF: av_log(avctx, AV_LOG_VERBOSE, "off"); break;
257  case MFX_B_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "pyramid"); break;
258  default: av_log(avctx, AV_LOG_VERBOSE, "auto"); break;
259  }
260  av_log(avctx, AV_LOG_VERBOSE, "\n");
261 #endif
262 
263 #if QSV_VERSION_ATLEAST(1, 9)
264  av_log(avctx, AV_LOG_VERBOSE,
265  "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",
266  co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
267 #endif
268 #endif
269 
270 #if QSV_HAVE_GPB
271  if (avctx->codec_id == AV_CODEC_ID_HEVC)
272  av_log(avctx, AV_LOG_VERBOSE,"GPB: %s\n", print_threestate(co3->GPB));
273 #endif
274 
275  if (avctx->codec_id == AV_CODEC_ID_H264) {
276  av_log(avctx, AV_LOG_VERBOSE, "Entropy coding: %s; MaxDecFrameBuffering: %"PRIu16"\n",
277  co->CAVLC == MFX_CODINGOPTION_ON ? "CAVLC" : "CABAC", co->MaxDecFrameBuffering);
278  av_log(avctx, AV_LOG_VERBOSE,
279  "NalHrdConformance: %s; SingleSeiNalUnit: %s; VuiVclHrdParameters: %s VuiNalHrdParameters: %s\n",
280  print_threestate(co->NalHrdConformance), print_threestate(co->SingleSeiNalUnit),
281  print_threestate(co->VuiVclHrdParameters), print_threestate(co->VuiNalHrdParameters));
282  }
283 
284  av_log(avctx, AV_LOG_VERBOSE, "FrameRateExtD: %"PRIu32"; FrameRateExtN: %"PRIu32" \n",
285  info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);
286 
287 }
288 
290 {
291  const char *rc_desc;
292  mfxU16 rc_mode;
293 
294  int want_la = q->look_ahead;
295  int want_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
296  int want_vcm = q->vcm;
297 
298  if (want_la && !QSV_HAVE_LA) {
299  av_log(avctx, AV_LOG_ERROR,
300  "Lookahead ratecontrol mode requested, but is not supported by this SDK version\n");
301  return AVERROR(ENOSYS);
302  }
303  if (want_vcm && !QSV_HAVE_VCM) {
304  av_log(avctx, AV_LOG_ERROR,
305  "VCM ratecontrol mode requested, but is not supported by this SDK version\n");
306  return AVERROR(ENOSYS);
307  }
308 
309  if (want_la + want_qscale + want_vcm > 1) {
310  av_log(avctx, AV_LOG_ERROR,
311  "More than one of: { constant qscale, lookahead, VCM } requested, "
312  "only one of them can be used at a time.\n");
313  return AVERROR(EINVAL);
314  }
315 
316  if (!want_qscale && avctx->global_quality > 0 && !QSV_HAVE_ICQ){
317  av_log(avctx, AV_LOG_ERROR,
318  "ICQ ratecontrol mode requested, but is not supported by this SDK version\n");
319  return AVERROR(ENOSYS);
320  }
321 
322  if (want_qscale) {
323  rc_mode = MFX_RATECONTROL_CQP;
324  rc_desc = "constant quantization parameter (CQP)";
325  }
326 #if QSV_HAVE_VCM
327  else if (want_vcm) {
328  rc_mode = MFX_RATECONTROL_VCM;
329  rc_desc = "video conferencing mode (VCM)";
330  }
331 #endif
332 #if QSV_HAVE_LA
333  else if (want_la) {
334  rc_mode = MFX_RATECONTROL_LA;
335  rc_desc = "VBR with lookahead (LA)";
336 
337 #if QSV_HAVE_ICQ
338  if (avctx->global_quality > 0) {
339  rc_mode = MFX_RATECONTROL_LA_ICQ;
340  rc_desc = "intelligent constant quality with lookahead (LA_ICQ)";
341  }
342 #endif
343  }
344 #endif
345 #if QSV_HAVE_ICQ
346  else if (avctx->global_quality > 0 && !avctx->rc_max_rate) {
347  rc_mode = MFX_RATECONTROL_ICQ;
348  rc_desc = "intelligent constant quality (ICQ)";
349  }
350 #endif
351  else if (avctx->rc_max_rate == avctx->bit_rate) {
352  rc_mode = MFX_RATECONTROL_CBR;
353  rc_desc = "constant bitrate (CBR)";
354  }
355 #if QSV_HAVE_AVBR
356  else if (!avctx->rc_max_rate) {
357  rc_mode = MFX_RATECONTROL_AVBR;
358  rc_desc = "average variable bitrate (AVBR)";
359  }
360 #endif
361 #if QSV_HAVE_QVBR
362  else if (avctx->global_quality > 0) {
363  rc_mode = MFX_RATECONTROL_QVBR;
364  rc_desc = "constant quality with VBR algorithm (QVBR)";
365  }
366 #endif
367  else {
368  rc_mode = MFX_RATECONTROL_VBR;
369  rc_desc = "variable bitrate (VBR)";
370  }
371 
372  q->param.mfx.RateControlMethod = rc_mode;
373  av_log(avctx, AV_LOG_VERBOSE, "Using the %s ratecontrol method\n", rc_desc);
374 
375  return 0;
376 }
377 
379 {
380  mfxVideoParam param_out = { .mfx.CodecId = q->param.mfx.CodecId };
381  mfxStatus ret;
382 
383 #define UNMATCH(x) (param_out.mfx.x != q->param.mfx.x)
384 
385  ret = MFXVideoENCODE_Query(q->session, &q->param, &param_out);
386 
387  if (ret < 0) {
388  if (UNMATCH(CodecId))
389  av_log(avctx, AV_LOG_ERROR, "Current codec type is unsupported\n");
390  if (UNMATCH(CodecProfile))
391  av_log(avctx, AV_LOG_ERROR, "Current profile is unsupported\n");
392  if (UNMATCH(RateControlMethod))
393  av_log(avctx, AV_LOG_ERROR, "Selected ratecontrol mode is unsupported\n");
394  if (UNMATCH(LowPower))
395  av_log(avctx, AV_LOG_ERROR, "Low power mode is unsupported\n");
396  if (UNMATCH(FrameInfo.FrameRateExtN) || UNMATCH(FrameInfo.FrameRateExtD))
397  av_log(avctx, AV_LOG_ERROR, "Current frame rate is unsupported\n");
398  if (UNMATCH(FrameInfo.PicStruct))
399  av_log(avctx, AV_LOG_ERROR, "Current picture structure is unsupported\n");
400  if (UNMATCH(FrameInfo.Width) || UNMATCH(FrameInfo.Height))
401  av_log(avctx, AV_LOG_ERROR, "Current resolution is unsupported\n");
402  if (UNMATCH(FrameInfo.FourCC))
403  av_log(avctx, AV_LOG_ERROR, "Current pixel format is unsupported\n");
404  return 0;
405  }
406  return 1;
407 }
408 
410 {
411  enum AVPixelFormat sw_format = avctx->pix_fmt == AV_PIX_FMT_QSV ?
412  avctx->sw_pix_fmt : avctx->pix_fmt;
413  const AVPixFmtDescriptor *desc;
414  int ret;
415 
416  ret = ff_qsv_codec_id_to_mfx(avctx->codec_id);
417  if (ret < 0)
418  return AVERROR_BUG;
419  q->param.mfx.CodecId = ret;
420 
421  if (avctx->level > 0)
422  q->param.mfx.CodecLevel = avctx->level;
423  q->param.mfx.CodecProfile = q->profile;
424 
425  desc = av_pix_fmt_desc_get(sw_format);
426  if (!desc)
427  return AVERROR_BUG;
428 
429  ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC);
430 
431  q->param.mfx.FrameInfo.CropX = 0;
432  q->param.mfx.FrameInfo.CropY = 0;
433  q->param.mfx.FrameInfo.CropW = avctx->width;
434  q->param.mfx.FrameInfo.CropH = avctx->height;
435  q->param.mfx.FrameInfo.AspectRatioW = avctx->sample_aspect_ratio.num;
436  q->param.mfx.FrameInfo.AspectRatioH = avctx->sample_aspect_ratio.den;
437  q->param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
438  q->param.mfx.FrameInfo.BitDepthLuma = desc->comp[0].depth;
439  q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
440  q->param.mfx.FrameInfo.Shift = desc->comp[0].depth > 8;
441 
442  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, 16);
443  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, 16);
444 
445  if (avctx->hw_frames_ctx) {
446  AVHWFramesContext *frames_ctx = (AVHWFramesContext *)avctx->hw_frames_ctx->data;
447  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
448  q->param.mfx.FrameInfo.Width = frames_hwctx->surfaces[0].Info.Width;
449  q->param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;
450  }
451 
452  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
453  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
454  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
455  } else {
456  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
457  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
458  }
459 
460  q->param.mfx.Interleaved = 1;
461  q->param.mfx.Quality = av_clip(avctx->global_quality, 1, 100);
462  q->param.mfx.RestartInterval = 0;
463 
464  return 0;
465 }
466 
468 {
469  enum AVPixelFormat sw_format = avctx->pix_fmt == AV_PIX_FMT_QSV ?
470  avctx->sw_pix_fmt : avctx->pix_fmt;
471  const AVPixFmtDescriptor *desc;
472  float quant;
473  int target_bitrate_kbps, max_bitrate_kbps, brc_param_multiplier;
474  int buffer_size_in_kilobytes, initial_delay_in_kilobytes;
475  int ret;
476 
477  ret = ff_qsv_codec_id_to_mfx(avctx->codec_id);
478  if (ret < 0)
479  return AVERROR_BUG;
480  q->param.mfx.CodecId = ret;
481 
482  if (avctx->level > 0)
483  q->param.mfx.CodecLevel = avctx->level;
484 
486  avctx->compression_level = q->preset;
487  } else if (avctx->compression_level >= 0) {
488  if (avctx->compression_level > MFX_TARGETUSAGE_BEST_SPEED) {
489  av_log(avctx, AV_LOG_WARNING, "Invalid compression level: "
490  "valid range is 0-%d, using %d instead\n",
491  MFX_TARGETUSAGE_BEST_SPEED, MFX_TARGETUSAGE_BEST_SPEED);
492  avctx->compression_level = MFX_TARGETUSAGE_BEST_SPEED;
493  }
494  }
495 
496  if (q->low_power) {
497 #if QSV_HAVE_VDENC
498  q->param.mfx.LowPower = MFX_CODINGOPTION_ON;
499 #else
500  av_log(avctx, AV_LOG_WARNING, "The low_power option is "
501  "not supported with this MSDK version.\n");
502  q->low_power = 0;
503  q->param.mfx.LowPower = MFX_CODINGOPTION_OFF;
504 #endif
505  } else
506  q->param.mfx.LowPower = MFX_CODINGOPTION_OFF;
507 
508  q->param.mfx.CodecProfile = q->profile;
509  q->param.mfx.TargetUsage = avctx->compression_level;
510  q->param.mfx.GopPicSize = FFMAX(0, avctx->gop_size);
511  q->param.mfx.GopRefDist = FFMAX(-1, avctx->max_b_frames) + 1;
512  q->param.mfx.GopOptFlag = avctx->flags & AV_CODEC_FLAG_CLOSED_GOP ?
513  MFX_GOP_CLOSED : 0;
514  q->param.mfx.IdrInterval = q->idr_interval;
515  q->param.mfx.NumSlice = avctx->slices;
516  q->param.mfx.NumRefFrame = FFMAX(0, avctx->refs);
517  q->param.mfx.EncodedOrder = 0;
518  q->param.mfx.BufferSizeInKB = 0;
519 
520  desc = av_pix_fmt_desc_get(sw_format);
521  if (!desc)
522  return AVERROR_BUG;
523 
524  ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC);
525 
526  q->param.mfx.FrameInfo.CropX = 0;
527  q->param.mfx.FrameInfo.CropY = 0;
528  q->param.mfx.FrameInfo.CropW = avctx->width;
529  q->param.mfx.FrameInfo.CropH = avctx->height;
530  q->param.mfx.FrameInfo.AspectRatioW = avctx->sample_aspect_ratio.num;
531  q->param.mfx.FrameInfo.AspectRatioH = avctx->sample_aspect_ratio.den;
532  q->param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
533  q->param.mfx.FrameInfo.BitDepthLuma = desc->comp[0].depth;
534  q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
535  q->param.mfx.FrameInfo.Shift = desc->comp[0].depth > 8;
536 
537  // If the minor version is greater than or equal to 19,
538  // then can use the same alignment settings as H.264 for HEVC
539  q->width_align = (avctx->codec_id != AV_CODEC_ID_HEVC ||
540  QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 19)) ? 16 : 32;
541  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, q->width_align);
542 
543  if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
544  // it is important that PicStruct be setup correctly from the
545  // start--otherwise, encoding doesn't work and results in a bunch
546  // of incompatible video parameter errors
547  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_FIELD_TFF;
548  // height alignment always must be 32 for interlaced video
549  q->height_align = 32;
550  } else {
551  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
552  // for progressive video, the height should be aligned to 16 for
553  // H.264. For HEVC, depending on the version of MFX, it should be
554  // either 32 or 16. The lower number is better if possible.
555  q->height_align = avctx->codec_id == AV_CODEC_ID_HEVC ? 32 : 16;
556  }
557  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, q->height_align);
558 
559  if (avctx->hw_frames_ctx) {
560  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
561  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
562  q->param.mfx.FrameInfo.Width = frames_hwctx->surfaces[0].Info.Width;
563  q->param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;
564  }
565 
566  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
567  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
568  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
569  } else {
570  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
571  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
572  }
573 
574  ret = select_rc_mode(avctx, q);
575  if (ret < 0)
576  return ret;
577 
578  //libmfx BRC parameters are 16 bits thus maybe overflow, then BRCParamMultiplier is needed
579  buffer_size_in_kilobytes = avctx->rc_buffer_size / 8000;
580  initial_delay_in_kilobytes = avctx->rc_initial_buffer_occupancy / 8000;
581  target_bitrate_kbps = avctx->bit_rate / 1000;
582  max_bitrate_kbps = avctx->rc_max_rate / 1000;
583  brc_param_multiplier = (FFMAX(FFMAX3(target_bitrate_kbps, max_bitrate_kbps, buffer_size_in_kilobytes),
584  initial_delay_in_kilobytes) + 0x10000) / 0x10000;
585 
586  switch (q->param.mfx.RateControlMethod) {
587  case MFX_RATECONTROL_CBR:
588  case MFX_RATECONTROL_VBR:
589 #if QSV_HAVE_VCM
590  case MFX_RATECONTROL_VCM:
591 #endif
592 #if QSV_HAVE_QVBR
593  case MFX_RATECONTROL_QVBR:
594 #endif
595  q->param.mfx.BufferSizeInKB = buffer_size_in_kilobytes / brc_param_multiplier;
596  q->param.mfx.InitialDelayInKB = initial_delay_in_kilobytes / brc_param_multiplier;
597  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
598  q->param.mfx.MaxKbps = max_bitrate_kbps / brc_param_multiplier;
599  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
600 #if QSV_HAVE_QVBR
601  if (q->param.mfx.RateControlMethod == MFX_RATECONTROL_QVBR)
602  q->extco3.QVBRQuality = av_clip(avctx->global_quality, 0, 51);
603 #endif
604  break;
605  case MFX_RATECONTROL_CQP:
606  quant = avctx->global_quality / FF_QP2LAMBDA;
607 
608  q->param.mfx.QPI = av_clip(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 0, 51);
609  q->param.mfx.QPP = av_clip(quant, 0, 51);
610  q->param.mfx.QPB = av_clip(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 0, 51);
611 
612  break;
613 #if QSV_HAVE_AVBR
614  case MFX_RATECONTROL_AVBR:
615  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
616  q->param.mfx.Convergence = q->avbr_convergence;
617  q->param.mfx.Accuracy = q->avbr_accuracy;
618  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
619  break;
620 #endif
621 #if QSV_HAVE_LA
622  case MFX_RATECONTROL_LA:
623  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
624  q->extco2.LookAheadDepth = q->look_ahead_depth;
625  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
626  break;
627 #if QSV_HAVE_ICQ
628  case MFX_RATECONTROL_LA_ICQ:
629  q->extco2.LookAheadDepth = q->look_ahead_depth;
630  case MFX_RATECONTROL_ICQ:
631  q->param.mfx.ICQQuality = avctx->global_quality;
632  break;
633 #endif
634 #endif
635  }
636 
637  // The HEVC encoder plugin currently fails with some old libmfx version if coding options
638  // are provided. Can't find the extract libmfx version which fixed it, just enable it from
639  // V1.28 in order to keep compatibility security.
640  if ((avctx->codec_id != AV_CODEC_ID_HEVC) || QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 28)) {
641  q->extco.Header.BufferId = MFX_EXTBUFF_CODING_OPTION;
642  q->extco.Header.BufferSz = sizeof(q->extco);
643 
644  q->extco.PicTimingSEI = q->pic_timing_sei ?
645  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;
646 
647  if (q->rdo >= 0)
648  q->extco.RateDistortionOpt = q->rdo > 0 ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
649 
650  if (avctx->codec_id == AV_CODEC_ID_H264) {
651 #if FF_API_CODER_TYPE
653  if (avctx->coder_type >= 0)
654  q->cavlc = avctx->coder_type == FF_CODER_TYPE_VLC;
656 #endif
657  q->extco.CAVLC = q->cavlc ? MFX_CODINGOPTION_ON
658  : MFX_CODINGOPTION_UNKNOWN;
659 
661  q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?
662  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
663 
664  if (q->single_sei_nal_unit >= 0)
665  q->extco.SingleSeiNalUnit = q->single_sei_nal_unit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
666  if (q->recovery_point_sei >= 0)
667  q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
668  q->extco.MaxDecFrameBuffering = q->max_dec_frame_buffering;
669  q->extco.AUDelimiter = q->aud ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
670  }
671 
672  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco;
673 
674  if (avctx->codec_id == AV_CODEC_ID_H264) {
675 #if QSV_HAVE_CO2
676  q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
677  q->extco2.Header.BufferSz = sizeof(q->extco2);
678 
679  if (q->int_ref_type >= 0)
680  q->extco2.IntRefType = q->int_ref_type;
681  if (q->int_ref_cycle_size >= 0)
682  q->extco2.IntRefCycleSize = q->int_ref_cycle_size;
683  if (q->int_ref_qp_delta != INT16_MIN)
684  q->extco2.IntRefQPDelta = q->int_ref_qp_delta;
685 
686  if (q->bitrate_limit >= 0)
687  q->extco2.BitrateLimit = q->bitrate_limit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
688  if (q->mbbrc >= 0)
689  q->extco2.MBBRC = q->mbbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
690  if (q->extbrc >= 0)
691  q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
692 
693  if (q->max_frame_size >= 0)
694  q->extco2.MaxFrameSize = q->max_frame_size;
695 #if QSV_HAVE_MAX_SLICE_SIZE
696  if (q->max_slice_size >= 0)
697  q->extco2.MaxSliceSize = q->max_slice_size;
698 #endif
699 
700 #if QSV_HAVE_TRELLIS
701  if (avctx->trellis >= 0)
702  q->extco2.Trellis = (avctx->trellis == 0) ? MFX_TRELLIS_OFF : (MFX_TRELLIS_I | MFX_TRELLIS_P | MFX_TRELLIS_B);
703  else
704  q->extco2.Trellis = MFX_TRELLIS_UNKNOWN;
705 #endif
706 
707 #if QSV_VERSION_ATLEAST(1, 8)
708  q->extco2.LookAheadDS = q->look_ahead_downsampling;
709  q->extco2.RepeatPPS = q->repeat_pps ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
710 
711 #if FF_API_PRIVATE_OPT
713  if (avctx->b_frame_strategy >= 0)
714  q->b_strategy = avctx->b_frame_strategy;
716 #endif
717  if (q->b_strategy >= 0)
718  q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
719  if (q->adaptive_i >= 0)
720  q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
721  if (q->adaptive_b >= 0)
722  q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
723 #endif
724 
725 #if QSV_VERSION_ATLEAST(1, 9)
726  if (avctx->qmin >= 0 && avctx->qmax >= 0 && avctx->qmin > avctx->qmax) {
727  av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are set but invalid, please make sure min <= max\n");
728  return AVERROR(EINVAL);
729  }
730  if (avctx->qmin >= 0) {
731  q->extco2.MinQPI = avctx->qmin > 51 ? 51 : avctx->qmin;
732  q->extco2.MinQPP = q->extco2.MinQPB = q->extco2.MinQPI;
733  }
734  if (avctx->qmax >= 0) {
735  q->extco2.MaxQPI = avctx->qmax > 51 ? 51 : avctx->qmax;
736  q->extco2.MaxQPP = q->extco2.MaxQPB = q->extco2.MaxQPI;
737  }
738 #endif
739  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
740 #endif
741 
742 #if QSV_HAVE_MF
743  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 25)) {
744  q->extmfp.Header.BufferId = MFX_EXTBUFF_MULTI_FRAME_PARAM;
745  q->extmfp.Header.BufferSz = sizeof(q->extmfp);
746 
747  q->extmfp.MFMode = q->mfmode;
748  av_log(avctx,AV_LOG_VERBOSE,"MFMode:%d\n", q->extmfp.MFMode);
749  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extmfp;
750  }
751 #endif
752  }
753 #if QSV_HAVE_CO3
754  q->extco3.Header.BufferId = MFX_EXTBUFF_CODING_OPTION3;
755  q->extco3.Header.BufferSz = sizeof(q->extco3);
756 #if QSV_HAVE_GPB
757  if (avctx->codec_id == AV_CODEC_ID_HEVC)
758  q->extco3.GPB = q->gpb ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
759 #endif
760  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco3;
761 #endif
762  }
763 
764  if (!check_enc_param(avctx,q)) {
765  av_log(avctx, AV_LOG_ERROR,
766  "some encoding parameters are not supported by the QSV "
767  "runtime. Please double check the input parameters.\n");
768  return AVERROR(ENOSYS);
769  }
770 
771  return 0;
772 }
773 
775 {
776  int ret = 0;
777 
778  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
779  if (ret < 0)
780  return ff_qsv_print_error(avctx, ret,
781  "Error calling GetVideoParam");
782 
783  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
784 
785  // for qsv mjpeg the return value maybe 0 so alloc the buffer
786  if (q->packet_size == 0)
787  q->packet_size = q->param.mfx.FrameInfo.Height * q->param.mfx.FrameInfo.Width * 4;
788 
789  return 0;
790 }
791 
793 {
794  AVCPBProperties *cpb_props;
795 
796  uint8_t sps_buf[128];
797  uint8_t pps_buf[128];
798 
799  mfxExtCodingOptionSPSPPS extradata = {
800  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
801  .Header.BufferSz = sizeof(extradata),
802  .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),
803  .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
804  };
805 
806  mfxExtCodingOption co = {
807  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
808  .Header.BufferSz = sizeof(co),
809  };
810 #if QSV_HAVE_CO2
811  mfxExtCodingOption2 co2 = {
812  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
813  .Header.BufferSz = sizeof(co2),
814  };
815 #endif
816 #if QSV_HAVE_CO3
817  mfxExtCodingOption3 co3 = {
818  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
819  .Header.BufferSz = sizeof(co3),
820  };
821 #endif
822 
823 #if QSV_HAVE_CO_VPS
824  uint8_t vps_buf[128];
825  mfxExtCodingOptionVPS extradata_vps = {
826  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_VPS,
827  .Header.BufferSz = sizeof(extradata_vps),
828  .VPSBuffer = vps_buf,
829  .VPSBufSize = sizeof(vps_buf),
830  };
831 #endif
832 
833  mfxExtBuffer *ext_buffers[2 + QSV_HAVE_CO2 + QSV_HAVE_CO3 + QSV_HAVE_CO_VPS];
834 
835  int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
836  int ret, ext_buf_num = 0, extradata_offset = 0;
837 
838  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata;
839  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co;
840 #if QSV_HAVE_CO2
841  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;
842 #endif
843 #if QSV_HAVE_CO3
844  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;
845 #endif
846 #if QSV_HAVE_CO_VPS
847  q->hevc_vps = ((avctx->codec_id == AV_CODEC_ID_HEVC) && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 17));
848  if (q->hevc_vps)
849  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata_vps;
850 #endif
851 
852  q->param.ExtParam = ext_buffers;
853  q->param.NumExtParam = ext_buf_num;
854 
855  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
856  if (ret < 0)
857  return ff_qsv_print_error(avctx, ret,
858  "Error calling GetVideoParam");
859 
860  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
861 
862  if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)
863 #if QSV_HAVE_CO_VPS
864  || (q->hevc_vps && !extradata_vps.VPSBufSize)
865 #endif
866  ) {
867  av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
868  return AVERROR_UNKNOWN;
869  }
870 
871  avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
872 #if QSV_HAVE_CO_VPS
873  avctx->extradata_size += q->hevc_vps * extradata_vps.VPSBufSize;
874 #endif
875 
877  if (!avctx->extradata)
878  return AVERROR(ENOMEM);
879 
880 #if QSV_HAVE_CO_VPS
881  if (q->hevc_vps) {
882  memcpy(avctx->extradata, vps_buf, extradata_vps.VPSBufSize);
883  extradata_offset += extradata_vps.VPSBufSize;
884  }
885 #endif
886 
887  memcpy(avctx->extradata + extradata_offset, sps_buf, extradata.SPSBufSize);
888  extradata_offset += extradata.SPSBufSize;
889  if (need_pps) {
890  memcpy(avctx->extradata + extradata_offset, pps_buf, extradata.PPSBufSize);
891  extradata_offset += extradata.PPSBufSize;
892  }
893  memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
894 
895  cpb_props = ff_add_cpb_side_data(avctx);
896  if (!cpb_props)
897  return AVERROR(ENOMEM);
898  cpb_props->max_bitrate = avctx->rc_max_rate;
899  cpb_props->min_bitrate = avctx->rc_min_rate;
900  cpb_props->avg_bitrate = avctx->bit_rate;
901  cpb_props->buffer_size = avctx->rc_buffer_size;
902 
903  dump_video_param(avctx, q, ext_buffers + 1);
904 
905  return 0;
906 }
907 
909 {
910  AVQSVContext *qsv = avctx->hwaccel_context;
911  mfxFrameSurface1 *surfaces;
912  int nb_surfaces, i;
913 
914  nb_surfaces = qsv->nb_opaque_surfaces + q->req.NumFrameSuggested;
915 
916  q->opaque_alloc_buf = av_buffer_allocz(sizeof(*surfaces) * nb_surfaces);
917  if (!q->opaque_alloc_buf)
918  return AVERROR(ENOMEM);
919 
920  q->opaque_surfaces = av_malloc_array(nb_surfaces, sizeof(*q->opaque_surfaces));
921  if (!q->opaque_surfaces)
922  return AVERROR(ENOMEM);
923 
924  surfaces = (mfxFrameSurface1*)q->opaque_alloc_buf->data;
925  for (i = 0; i < nb_surfaces; i++) {
926  surfaces[i].Info = q->req.Info;
927  q->opaque_surfaces[i] = surfaces + i;
928  }
929 
930  q->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
931  q->opaque_alloc.Header.BufferSz = sizeof(q->opaque_alloc);
932  q->opaque_alloc.In.Surfaces = q->opaque_surfaces;
933  q->opaque_alloc.In.NumSurface = nb_surfaces;
934  q->opaque_alloc.In.Type = q->req.Type;
935 
936  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->opaque_alloc;
937 
938  qsv->nb_opaque_surfaces = nb_surfaces;
940  qsv->opaque_alloc_type = q->req.Type;
941 
942  return 0;
943 }
944 
946 {
947  int ret;
948 
949  if (avctx->hwaccel_context) {
950  AVQSVContext *qsv = avctx->hwaccel_context;
951  q->session = qsv->session;
952  } else if (avctx->hw_frames_ctx) {
954  if (!q->frames_ctx.hw_frames_ctx)
955  return AVERROR(ENOMEM);
956 
958  &q->frames_ctx, q->load_plugins,
959  q->param.IOPattern == MFX_IOPATTERN_IN_OPAQUE_MEMORY,
960  MFX_GPUCOPY_OFF);
961  if (ret < 0) {
963  return ret;
964  }
965 
966  q->session = q->internal_qs.session;
967  } else if (avctx->hw_device_ctx) {
969  avctx->hw_device_ctx, q->load_plugins,
970  MFX_GPUCOPY_OFF);
971  if (ret < 0)
972  return ret;
973 
974  q->session = q->internal_qs.session;
975  } else {
976  ret = ff_qsv_init_internal_session(avctx, &q->internal_qs,
977  q->load_plugins, MFX_GPUCOPY_OFF);
978  if (ret < 0)
979  return ret;
980 
981  q->session = q->internal_qs.session;
982  }
983 
984  return 0;
985 }
986 
987 static inline unsigned int qsv_fifo_item_size(void)
988 {
989  return sizeof(AVPacket) + sizeof(mfxSyncPoint*) + sizeof(mfxBitstream*);
990 }
991 
992 static inline unsigned int qsv_fifo_size(const AVFifoBuffer* fifo)
993 {
994  return av_fifo_size(fifo)/qsv_fifo_item_size();
995 }
996 
998 {
999  int iopattern = 0;
1000  int opaque_alloc = 0;
1001  int ret;
1002 
1003  q->param.AsyncDepth = q->async_depth;
1004 
1006  if (!q->async_fifo)
1007  return AVERROR(ENOMEM);
1008 
1009  if (avctx->hwaccel_context) {
1010  AVQSVContext *qsv = avctx->hwaccel_context;
1011 
1012  iopattern = qsv->iopattern;
1013  opaque_alloc = qsv->opaque_alloc;
1014  }
1015 
1016  if (avctx->hw_frames_ctx) {
1017  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1018  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
1019 
1020  if (!iopattern) {
1021  if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)
1022  iopattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
1023  else if (frames_hwctx->frame_type &
1024  (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
1025  iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
1026  }
1027  }
1028 
1029  if (!iopattern)
1030  iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
1031  q->param.IOPattern = iopattern;
1032 
1033  ret = qsvenc_init_session(avctx, q);
1034  if (ret < 0)
1035  return ret;
1036 
1037  ret = MFXQueryVersion(q->session,&q->ver);
1038  if (ret < 0) {
1039  return ff_qsv_print_error(avctx, ret,
1040  "Error querying mfx version");
1041  }
1042 
1043  // in the mfxInfoMFX struct, JPEG is different from other codecs
1044  switch (avctx->codec_id) {
1045  case AV_CODEC_ID_MJPEG:
1046  ret = init_video_param_jpeg(avctx, q);
1047  break;
1048  default:
1049  ret = init_video_param(avctx, q);
1050  break;
1051  }
1052  if (ret < 0)
1053  return ret;
1054 
1055  ret = MFXVideoENCODE_Query(q->session, &q->param, &q->param);
1056  if (ret == MFX_WRN_PARTIAL_ACCELERATION) {
1057  av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
1058  } else if (ret < 0) {
1059  return ff_qsv_print_error(avctx, ret,
1060  "Error querying encoder params");
1061  }
1062 
1063  ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
1064  if (ret < 0)
1065  return ff_qsv_print_error(avctx, ret,
1066  "Error querying (IOSurf) the encoding parameters");
1067 
1068  if (opaque_alloc) {
1069  ret = qsv_init_opaque_alloc(avctx, q);
1070  if (ret < 0)
1071  return ret;
1072  }
1073 
1074  if (avctx->hwaccel_context) {
1075  AVQSVContext *qsv = avctx->hwaccel_context;
1076  int i, j;
1077 
1079  sizeof(*q->extparam));
1080  if (!q->extparam)
1081  return AVERROR(ENOMEM);
1082 
1083  q->param.ExtParam = q->extparam;
1084  for (i = 0; i < qsv->nb_ext_buffers; i++)
1085  q->param.ExtParam[i] = qsv->ext_buffers[i];
1086  q->param.NumExtParam = qsv->nb_ext_buffers;
1087 
1088  for (i = 0; i < q->nb_extparam_internal; i++) {
1089  for (j = 0; j < qsv->nb_ext_buffers; j++) {
1090  if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)
1091  break;
1092  }
1093  if (j < qsv->nb_ext_buffers)
1094  continue;
1095 
1096  q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];
1097  }
1098  } else {
1099  q->param.ExtParam = q->extparam_internal;
1100  q->param.NumExtParam = q->nb_extparam_internal;
1101  }
1102 
1103  ret = MFXVideoENCODE_Init(q->session, &q->param);
1104  if (ret < 0)
1105  return ff_qsv_print_error(avctx, ret,
1106  "Error initializing the encoder");
1107  else if (ret > 0)
1108  ff_qsv_print_warning(avctx, ret,
1109  "Warning in encoder initialization");
1110 
1111  switch (avctx->codec_id) {
1112  case AV_CODEC_ID_MJPEG:
1113  ret = qsv_retrieve_enc_jpeg_params(avctx, q);
1114  break;
1115  default:
1116  ret = qsv_retrieve_enc_params(avctx, q);
1117  break;
1118  }
1119  if (ret < 0) {
1120  av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
1121  return ret;
1122  }
1123 
1124  q->avctx = avctx;
1125 
1126  return 0;
1127 }
1128 
1129 static void free_encoder_ctrl_payloads(mfxEncodeCtrl* enc_ctrl)
1130 {
1131  if (enc_ctrl) {
1132  int i;
1133  for (i = 0; i < enc_ctrl->NumPayload && i < QSV_MAX_ENC_PAYLOAD; i++) {
1134  av_free(enc_ctrl->Payload[i]);
1135  }
1136  enc_ctrl->NumPayload = 0;
1137  }
1138 }
1139 
1141 {
1142  QSVFrame *cur = q->work_frames;
1143  while (cur) {
1144  if (cur->used && !cur->surface.Data.Locked) {
1146  if (cur->frame->format == AV_PIX_FMT_QSV) {
1147  av_frame_unref(cur->frame);
1148  }
1149  cur->used = 0;
1150  }
1151  cur = cur->next;
1152  }
1153 }
1154 
1156 {
1157  QSVFrame *frame, **last;
1158 
1160 
1161  frame = q->work_frames;
1162  last = &q->work_frames;
1163  while (frame) {
1164  if (!frame->used) {
1165  *f = frame;
1166  frame->used = 1;
1167  return 0;
1168  }
1169 
1170  last = &frame->next;
1171  frame = frame->next;
1172  }
1173 
1174  frame = av_mallocz(sizeof(*frame));
1175  if (!frame)
1176  return AVERROR(ENOMEM);
1177  frame->frame = av_frame_alloc();
1178  if (!frame->frame) {
1179  av_freep(&frame);
1180  return AVERROR(ENOMEM);
1181  }
1182  frame->enc_ctrl.Payload = av_mallocz(sizeof(mfxPayload*) * QSV_MAX_ENC_PAYLOAD);
1183  if (!frame->enc_ctrl.Payload) {
1184  av_freep(&frame);
1185  return AVERROR(ENOMEM);
1186  }
1187  *last = frame;
1188 
1189  *f = frame;
1190  frame->used = 1;
1191 
1192  return 0;
1193 }
1194 
1195 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
1196  QSVFrame **new_frame)
1197 {
1198  QSVFrame *qf;
1199  int ret;
1200 
1201  ret = get_free_frame(q, &qf);
1202  if (ret < 0)
1203  return ret;
1204 
1205  if (frame->format == AV_PIX_FMT_QSV) {
1206  ret = av_frame_ref(qf->frame, frame);
1207  if (ret < 0)
1208  return ret;
1209 
1210  qf->surface = *(mfxFrameSurface1*)qf->frame->data[3];
1211 
1212  if (q->frames_ctx.mids) {
1213  ret = ff_qsv_find_surface_idx(&q->frames_ctx, qf);
1214  if (ret < 0)
1215  return ret;
1216 
1217  qf->surface.Data.MemId = &q->frames_ctx.mids[ret];
1218  }
1219  } else {
1220  /* make a copy if the input is not padded as libmfx requires */
1221  /* and to make allocation continious for data[0]/data[1] */
1222  if ((frame->height & 31 || frame->linesize[0] & (q->width_align - 1)) ||
1223  (frame->data[1] - frame->data[0] != frame->linesize[0] * FFALIGN(qf->frame->height, q->height_align))) {
1224  qf->frame->height = FFALIGN(frame->height, q->height_align);
1225  qf->frame->width = FFALIGN(frame->width, q->width_align);
1226 
1227  qf->frame->format = frame->format;
1228 
1229  if (!qf->frame->data[0]) {
1230  ret = av_frame_get_buffer(qf->frame, q->width_align);
1231  if (ret < 0)
1232  return ret;
1233  }
1234 
1235  qf->frame->height = frame->height;
1236  qf->frame->width = frame->width;
1237 
1238  ret = av_frame_copy(qf->frame, frame);
1239  if (ret < 0) {
1240  av_frame_unref(qf->frame);
1241  return ret;
1242  }
1243  } else {
1244  ret = av_frame_ref(qf->frame, frame);
1245  if (ret < 0)
1246  return ret;
1247  }
1248 
1249  qf->surface.Info = q->param.mfx.FrameInfo;
1250 
1251  qf->surface.Info.PicStruct =
1252  !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
1253  frame->top_field_first ? MFX_PICSTRUCT_FIELD_TFF :
1254  MFX_PICSTRUCT_FIELD_BFF;
1255  if (frame->repeat_pict == 1)
1256  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
1257  else if (frame->repeat_pict == 2)
1258  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
1259  else if (frame->repeat_pict == 4)
1260  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
1261 
1262  qf->surface.Data.PitchLow = qf->frame->linesize[0];
1263  qf->surface.Data.Y = qf->frame->data[0];
1264  qf->surface.Data.UV = qf->frame->data[1];
1265  }
1266 
1267  qf->surface.Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
1268 
1269  *new_frame = qf;
1270 
1271  return 0;
1272 }
1273 
1275 {
1276  if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
1277  if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
1278  q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
1279  q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
1280  av_log(avctx, AV_LOG_WARNING,
1281  "Interlaced coding is supported"
1282  " at Main/High Profile Level 2.2-4.0\n");
1283  }
1284 }
1285 
1287  const AVFrame *frame)
1288 {
1289  AVPacket new_pkt = { 0 };
1290  mfxBitstream *bs;
1291 #if QSV_VERSION_ATLEAST(1, 26)
1292  mfxExtAVCEncodedFrameInfo *enc_info;
1293  mfxExtBuffer **enc_buf;
1294 #endif
1295 
1296  mfxFrameSurface1 *surf = NULL;
1297  mfxSyncPoint *sync = NULL;
1298  QSVFrame *qsv_frame = NULL;
1299  mfxEncodeCtrl* enc_ctrl = NULL;
1300  int ret;
1301 
1302  if (frame) {
1303  ret = submit_frame(q, frame, &qsv_frame);
1304  if (ret < 0) {
1305  av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
1306  return ret;
1307  }
1308  }
1309  if (qsv_frame) {
1310  surf = &qsv_frame->surface;
1311  enc_ctrl = &qsv_frame->enc_ctrl;
1312 
1313  if (frame->pict_type == AV_PICTURE_TYPE_I) {
1314  enc_ctrl->FrameType = MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF;
1315  if (q->forced_idr)
1316  enc_ctrl->FrameType |= MFX_FRAMETYPE_IDR;
1317  }
1318  }
1319 
1320  ret = av_new_packet(&new_pkt, q->packet_size);
1321  if (ret < 0) {
1322  av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
1323  return ret;
1324  }
1325 
1326  bs = av_mallocz(sizeof(*bs));
1327  if (!bs) {
1328  av_packet_unref(&new_pkt);
1329  return AVERROR(ENOMEM);
1330  }
1331  bs->Data = new_pkt.data;
1332  bs->MaxLength = new_pkt.size;
1333 
1334 #if QSV_VERSION_ATLEAST(1, 26)
1335  if (avctx->codec_id == AV_CODEC_ID_H264) {
1336  enc_info = av_mallocz(sizeof(*enc_info));
1337  if (!enc_info)
1338  return AVERROR(ENOMEM);
1339 
1340  enc_info->Header.BufferId = MFX_EXTBUFF_ENCODED_FRAME_INFO;
1341  enc_info->Header.BufferSz = sizeof (*enc_info);
1342  bs->NumExtParam = 1;
1343  enc_buf = av_mallocz(sizeof(mfxExtBuffer *));
1344  if (!enc_buf)
1345  return AVERROR(ENOMEM);
1346  enc_buf[0] = (mfxExtBuffer *)enc_info;
1347 
1348  bs->ExtParam = enc_buf;
1349  }
1350 #endif
1351 
1352  if (q->set_encode_ctrl_cb) {
1353  q->set_encode_ctrl_cb(avctx, frame, &qsv_frame->enc_ctrl);
1354  }
1355 
1356  sync = av_mallocz(sizeof(*sync));
1357  if (!sync) {
1358  av_freep(&bs);
1359  #if QSV_VERSION_ATLEAST(1, 26)
1360  if (avctx->codec_id == AV_CODEC_ID_H264) {
1361  av_freep(&enc_info);
1362  av_freep(&enc_buf);
1363  }
1364  #endif
1365  av_packet_unref(&new_pkt);
1366  return AVERROR(ENOMEM);
1367  }
1368 
1369  do {
1370  ret = MFXVideoENCODE_EncodeFrameAsync(q->session, enc_ctrl, surf, bs, sync);
1371  if (ret == MFX_WRN_DEVICE_BUSY)
1372  av_usleep(500);
1373  } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_WRN_IN_EXECUTION);
1374 
1375  if (ret > 0)
1376  ff_qsv_print_warning(avctx, ret, "Warning during encoding");
1377 
1378  if (ret < 0) {
1379  av_packet_unref(&new_pkt);
1380  av_freep(&bs);
1381 #if QSV_VERSION_ATLEAST(1, 26)
1382  if (avctx->codec_id == AV_CODEC_ID_H264) {
1383  av_freep(&enc_info);
1384  av_freep(&enc_buf);
1385  }
1386 #endif
1387  av_freep(&sync);
1388  return (ret == MFX_ERR_MORE_DATA) ?
1389  0 : ff_qsv_print_error(avctx, ret, "Error during encoding");
1390  }
1391 
1392  if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM && frame->interlaced_frame)
1393  print_interlace_msg(avctx, q);
1394 
1395  if (*sync) {
1396  av_fifo_generic_write(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1397  av_fifo_generic_write(q->async_fifo, &sync, sizeof(sync), NULL);
1398  av_fifo_generic_write(q->async_fifo, &bs, sizeof(bs), NULL);
1399  } else {
1400  av_freep(&sync);
1401  av_packet_unref(&new_pkt);
1402  av_freep(&bs);
1403 #if QSV_VERSION_ATLEAST(1, 26)
1404  if (avctx->codec_id == AV_CODEC_ID_H264) {
1405  av_freep(&enc_info);
1406  av_freep(&enc_buf);
1407  }
1408 #endif
1409  }
1410 
1411  return 0;
1412 }
1413 
1415  AVPacket *pkt, const AVFrame *frame, int *got_packet)
1416 {
1417  int ret;
1418 
1419  ret = encode_frame(avctx, q, frame);
1420  if (ret < 0)
1421  return ret;
1422 
1423  if ((qsv_fifo_size(q->async_fifo) >= q->async_depth) ||
1424  (!frame && av_fifo_size(q->async_fifo))) {
1425  AVPacket new_pkt;
1426  mfxBitstream *bs;
1427  mfxSyncPoint *sync;
1428 #if QSV_VERSION_ATLEAST(1, 26)
1429  mfxExtAVCEncodedFrameInfo *enc_info;
1430  mfxExtBuffer **enc_buf;
1431 #endif
1432  enum AVPictureType pict_type;
1433 
1434  av_fifo_generic_read(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1435  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1436  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1437 
1438  do {
1439  ret = MFXVideoCORE_SyncOperation(q->session, *sync, 1000);
1440  } while (ret == MFX_WRN_IN_EXECUTION);
1441 
1442  new_pkt.dts = av_rescale_q(bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
1443  new_pkt.pts = av_rescale_q(bs->TimeStamp, (AVRational){1, 90000}, avctx->time_base);
1444  new_pkt.size = bs->DataLength;
1445 
1446  if (bs->FrameType & MFX_FRAMETYPE_IDR || bs->FrameType & MFX_FRAMETYPE_xIDR) {
1447  new_pkt.flags |= AV_PKT_FLAG_KEY;
1448  pict_type = AV_PICTURE_TYPE_I;
1449  } else if (bs->FrameType & MFX_FRAMETYPE_I || bs->FrameType & MFX_FRAMETYPE_xI)
1450  pict_type = AV_PICTURE_TYPE_I;
1451  else if (bs->FrameType & MFX_FRAMETYPE_P || bs->FrameType & MFX_FRAMETYPE_xP)
1452  pict_type = AV_PICTURE_TYPE_P;
1453  else if (bs->FrameType & MFX_FRAMETYPE_B || bs->FrameType & MFX_FRAMETYPE_xB)
1454  pict_type = AV_PICTURE_TYPE_B;
1455  else if (bs->FrameType == MFX_FRAMETYPE_UNKNOWN) {
1456  pict_type = AV_PICTURE_TYPE_NONE;
1457  av_log(avctx, AV_LOG_WARNING, "Unknown FrameType, set pict_type to AV_PICTURE_TYPE_NONE.\n");
1458  } else {
1459  av_log(avctx, AV_LOG_ERROR, "Invalid FrameType:%d.\n", bs->FrameType);
1460  return AVERROR_INVALIDDATA;
1461  }
1462 
1463 #if FF_API_CODED_FRAME
1465  avctx->coded_frame->pict_type = pict_type;
1467 #endif
1468 
1469 #if QSV_VERSION_ATLEAST(1, 26)
1470  if (avctx->codec_id == AV_CODEC_ID_H264) {
1471  enc_buf = bs->ExtParam;
1472  enc_info = (mfxExtAVCEncodedFrameInfo *)(*bs->ExtParam);
1474  enc_info->QP * FF_QP2LAMBDA, NULL, 0, pict_type);
1475  av_freep(&enc_info);
1476  av_freep(&enc_buf);
1477  }
1478 #endif
1479  av_freep(&bs);
1480  av_freep(&sync);
1481 
1482  if (pkt->data) {
1483  if (pkt->size < new_pkt.size) {
1484  av_log(avctx, AV_LOG_ERROR, "Submitted buffer not large enough: %d < %d\n",
1485  pkt->size, new_pkt.size);
1486  av_packet_unref(&new_pkt);
1487  return AVERROR(EINVAL);
1488  }
1489 
1490  memcpy(pkt->data, new_pkt.data, new_pkt.size);
1491  pkt->size = new_pkt.size;
1492 
1493  ret = av_packet_copy_props(pkt, &new_pkt);
1494  av_packet_unref(&new_pkt);
1495  if (ret < 0)
1496  return ret;
1497  } else
1498  *pkt = new_pkt;
1499 
1500  *got_packet = 1;
1501  }
1502 
1503  return 0;
1504 }
1505 
1507 {
1508  QSVFrame *cur;
1509 
1510  if (q->session)
1511  MFXVideoENCODE_Close(q->session);
1512 
1513  q->session = NULL;
1515 
1518 
1519  cur = q->work_frames;
1520  while (cur) {
1521  q->work_frames = cur->next;
1522  av_frame_free(&cur->frame);
1523  av_free(cur->enc_ctrl.Payload);
1524  av_freep(&cur);
1525  cur = q->work_frames;
1526  }
1527 
1528  while (q->async_fifo && av_fifo_size(q->async_fifo)) {
1529  AVPacket pkt;
1530  mfxSyncPoint *sync;
1531  mfxBitstream *bs;
1532 
1533  av_fifo_generic_read(q->async_fifo, &pkt, sizeof(pkt), NULL);
1534  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1535  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1536 
1537  av_freep(&sync);
1538  av_freep(&bs);
1539  av_packet_unref(&pkt);
1540  }
1542  q->async_fifo = NULL;
1543 
1546 
1547  av_freep(&q->extparam);
1548 
1549  return 0;
1550 }
int single_sei_nal_unit
Definition: qsvenc.h:160
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:3108
const char const char void * val
Definition: avisynth_c.h:863
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define FF_COMPRESSION_DEFAULT
Definition: avcodec.h:1641
#define QSV_MAX_ENC_PAYLOAD
Definition: qsv_internal.h:51
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
mfxExtBuffer * extparam_internal[2+QSV_HAVE_CO2+QSV_HAVE_CO3+(QSV_HAVE_MF *2)]
Definition: qsvenc.h:129
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
AVBufferRef * opaque_alloc_buf
Definition: qsvenc.h:127
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:720
mfxExtBuffer ** extparam
Definition: qsvenc.h:132
static int init_video_param_jpeg(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:409
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:899
int int_ref_type
Definition: qsvenc.h:171
#define QSV_HAVE_LA
Definition: qsvenc.h:45
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
mfxExtOpaqueSurfaceAlloc opaque_alloc
Definition: qsvenc.h:125
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1618
Memory handling functions.
This struct is allocated as AVHWFramesContext.hwctx.
Definition: hwcontext_qsv.h:42
const char * desc
Definition: nvenc.c:68
int max_frame_size
Definition: qsvenc.h:155
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:1137
int hevc_vps
Definition: qsvenc.h:140
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:1828
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:2474
mfxFrameAllocRequest req
Definition: qsvenc.h:112
int avbr_accuracy
Definition: qsvenc.h:147
mfxEncodeCtrl enc_ctrl
Definition: qsv_internal.h:73
QSVFrame * work_frames
Definition: qsvenc.h:102
int num
Numerator.
Definition: rational.h:59
int repeat_pict
When decoding, this signals how much the picture must be delayed.
Definition: frame.h:437
int look_ahead_depth
Definition: qsvenc.h:151
static int get_free_frame(QSVEncContext *q, QSVFrame **f)
Definition: qsvenc.c:1155
int size
Definition: avcodec.h:1481
int int_ref_qp_delta
Definition: qsvenc.h:173
#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:1947
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1778
QSVFramesContext frames_ctx
Definition: qsvenc.h:136
int packet_size
Definition: qsvenc.h:107
#define QSV_RUNTIME_VERSION_ATLEAST(MFX_VERSION, MAJOR, MINOR)
Definition: qsv_internal.h:57
int ff_qsv_init_session_device(AVCodecContext *avctx, mfxSession *psession, AVBufferRef *device_ref, const char *load_plugins, int gpu_copy)
Definition: qsv.c:720
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
static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1274
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:1880
int min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: avcodec.h:1146
AVBufferRef * hw_frames_ctx
Definition: qsv_internal.h:92
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:224
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1691
Undefined.
Definition: avutil.h:273
int bitrate_limit
Definition: qsvenc.h:163
int look_ahead
Definition: qsvenc.h:150
int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: qsvenc.c:1414
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
mfxVideoParam param
Definition: qsvenc.h:111
uint8_t
#define QSV_HAVE_CO2
Definition: qsvenc.h:37
#define QSV_HAVE_LA_HRD
Definition: qsvenc.h:47
AVFifoBuffer * async_fifo
Definition: qsvenc.h:134
#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:2744
AVBufferRef * mids_buf
Definition: qsv_internal.h:99
mfxExtCodingOption extco
Definition: qsvenc.h:114
#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:1837
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:443
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1669
int opaque_alloc
Encoding only.
Definition: qsv.h:65
mfxFrameSurface1 ** opaque_surfaces
Definition: qsvenc.h:126
uint8_t * data
Definition: avcodec.h:1480
static int qsv_retrieve_enc_jpeg_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:774
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:442
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: avcodec.h:1164
int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1506
static const char * print_threestate(mfxU16 val)
Definition: qsvenc.c:121
#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:1512
int b_strategy
Definition: qsvenc.h:168
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 ff_qsv_init_session_frames(AVCodecContext *avctx, mfxSession *psession, QSVFramesContext *qsv_frames_ctx, const char *load_plugins, int opaque, int gpu_copy)
Definition: qsv.c:797
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int width
Definition: frame.h:353
#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:271
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:2417
char * load_plugins
Definition: qsvenc.h:185
int low_power
Definition: qsvenc.h:177
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:1648
static unsigned int qsv_fifo_item_size(void)
Definition: qsvenc.c:987
int nb_extparam_internal
Definition: qsvenc.h:130
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:1873
int max_dec_frame_buffering
Definition: qsvenc.h:161
int iopattern
The IO pattern to use.
Definition: qsv.h:46
static unsigned int qsv_fifo_size(const AVFifoBuffer *fifo)
Definition: qsvenc.c:992
#define FFMAX(a, b)
Definition: common.h:94
int ff_qsv_close_internal_session(QSVSession *qs)
Definition: qsv.c:844
static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:792
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:792
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1486
int adaptive_i
Definition: qsvenc.h:166
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2431
int ff_qsv_print_warning(void *log_ctx, mfxStatus err, const char *warning_string)
Definition: qsv.c:234
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:2453
int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc)
Definition: qsv.c:254
int refs
number of reference frames
Definition: avcodec.h:2156
static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q, mfxExtBuffer **coding_opts)
Definition: qsvenc.c:130
MIPS optimizations info
Definition: mips.txt:2
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: avpacket.c:565
const char * name
Definition: qsvenc.c:45
AVCodecContext * avctx
Definition: qsvenc.h:100
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:853
int idr_interval
Definition: qsvenc.h:144
mfxVersion ver
Definition: qsvenc.h:138
int width
picture width / height.
Definition: avcodec.h:1741
int extbrc
Definition: qsvenc.h:165
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:3265
int preset
Definition: qsvenc.h:146
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:289
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
int level
level
Definition: avcodec.h:3021
#define MFX_LOOKAHEAD_DS_OFF
Definition: qsvenc.h:68
static const char * print_profile(mfxU16 profile)
Definition: qsvenc.c:72
mfxFrameSurface1 surface
Definition: qsv_internal.h:72
#define MFX_LOOKAHEAD_DS_2x
Definition: qsvenc.h:69
int repeat_pps
Definition: qsvenc.h:176
int async_depth
Definition: qsvenc.h:143
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
attribute_deprecated int coder_type
Definition: avcodec.h:2485
#define FF_ARRAY_ELEMS(a)
int width_align
Definition: qsvenc.h:108
if(ret)
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:368
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:1131
static int qsvenc_init_session(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:945
#define QSV_HAVE_CO3
Definition: qsvenc.h:38
Libavcodec external API header.
enum AVCodecID codec_id
Definition: avcodec.h:1578
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:1640
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:326
attribute_deprecated int b_frame_strategy
Definition: avcodec.h:1842
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:1568
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
uint8_t * data
The data buffer.
Definition: buffer.h:89
struct QSVFrame * next
Definition: qsv_internal.h:80
int qmin
minimum quantizer
Definition: avcodec.h:2410
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:161
#define QSV_HAVE_CO_VPS
Definition: qsvenc.h:39
int profile
Definition: qsvenc.h:145
static void free_encoder_ctrl_payloads(mfxEncodeCtrl *enc_ctrl)
Definition: qsvenc.c:1129
int extradata_size
Definition: avcodec.h:1670
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:109
QSVSession internal_qs
Definition: qsvenc.h:105
#define FF_CODER_TYPE_VLC
Definition: avcodec.h:2477
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:2634
int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:997
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
int ff_qsv_init_internal_session(AVCodecContext *avctx, QSVSession *qs, const char *load_plugins, int gpu_copy)
Definition: qsv.c:414
AVPictureType
Definition: avutil.h:272
static const struct @134 profile_names[]
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:1850
int max_slice_size
Definition: qsvenc.h:156
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:324
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1634
int int_ref_cycle_size
Definition: qsvenc.h:172
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1763
static int check_enc_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:378
int adaptive_b
Definition: qsvenc.h:167
#define QSV_HAVE_ICQ
Definition: qsvenc.h:60
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
common internal and external API header
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
Bi-dir predicted.
Definition: avutil.h:276
int avbr_convergence
Definition: qsvenc.h:148
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2818
int den
Denominator.
Definition: rational.h:60
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
int trellis
trellis RD quantization
Definition: avcodec.h:2517
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1968
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:793
int slices
Number of slices.
Definition: avcodec.h:2219
#define MFX_LOOKAHEAD_DS_4x
Definition: qsvenc.h:70
int forced_idr
Definition: qsvenc.h:187
int recovery_point_sei
Definition: qsvenc.h:174
#define av_free(p)
static const struct @135 rc_names[]
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:447
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:1155
#define QSV_HAVE_MF
Definition: qsvenc.h:63
#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:1479
int look_ahead_downsampling
Definition: qsvenc.h:152
static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:467
int height
Definition: frame.h:353
static const char * print_ratecontrol(mfxU16 rc_mode)
Definition: qsvenc.c:112
#define av_freep(p)
An API-specific header for AV_HWDEVICE_TYPE_QSV.
AVFrame * frame
Definition: qsv_internal.h:71
#define av_malloc_array(a, b)
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:921
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
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:3317
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1457
mfxSession session
Definition: qsvenc.h:104
static int qsv_init_opaque_alloc(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:908
#define QSV_HAVE_VCM
Definition: qsvenc.h:61
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:2631
mfxSession session
Definition: qsv_internal.h:84
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1473
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:3115
for(j=16;j >0;--j)
int pic_timing_sei
Definition: qsvenc.h:149
#define FFMAX3(a, b, c)
Definition: common.h:95
static int encode_frame(AVCodecContext *avctx, QSVEncContext *q, const AVFrame *frame)
Definition: qsvenc.c:1286
Predicted.
Definition: avutil.h:275
static int submit_frame(QSVEncContext *q, const AVFrame *frame, QSVFrame **new_frame)
Definition: qsvenc.c:1195
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2446
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
SetEncodeCtrlCB * set_encode_ctrl_cb
Definition: qsvenc.h:186
static void clear_unused_frames(QSVEncContext *q)
Definition: qsvenc.c:1140