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