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++)
78  if (profile == profile_names[i].profile)
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 
427  ret = ff_qsv_codec_id_to_mfx(avctx->codec_id);
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 
494  ret = ff_qsv_codec_id_to_mfx(avctx->codec_id);
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 #if FF_API_CODER_TYPE
672  if (avctx->coder_type >= 0)
673  q->cavlc = avctx->coder_type == FF_CODER_TYPE_VLC;
675 #endif
676  q->extco.CAVLC = q->cavlc ? MFX_CODINGOPTION_ON
677  : MFX_CODINGOPTION_UNKNOWN;
678 
680  q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?
681  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
682 
683  if (q->single_sei_nal_unit >= 0)
684  q->extco.SingleSeiNalUnit = q->single_sei_nal_unit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
685  if (q->recovery_point_sei >= 0)
686  q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
687  q->extco.MaxDecFrameBuffering = q->max_dec_frame_buffering;
688  q->extco.AUDelimiter = q->aud ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
689  }
690 
691  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco;
692 
693 #if QSV_HAVE_CO2
694  if (avctx->codec_id == AV_CODEC_ID_H264) {
695  if (q->int_ref_type >= 0)
696  q->extco2.IntRefType = q->int_ref_type;
697  if (q->int_ref_cycle_size >= 0)
698  q->extco2.IntRefCycleSize = q->int_ref_cycle_size;
699  if (q->int_ref_qp_delta != INT16_MIN)
700  q->extco2.IntRefQPDelta = q->int_ref_qp_delta;
701 
702  if (q->bitrate_limit >= 0)
703  q->extco2.BitrateLimit = q->bitrate_limit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
704  if (q->mbbrc >= 0)
705  q->extco2.MBBRC = q->mbbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
706 
707  if (q->max_frame_size >= 0)
708  q->extco2.MaxFrameSize = q->max_frame_size;
709 #if QSV_HAVE_MAX_SLICE_SIZE
710  if (q->max_slice_size >= 0)
711  q->extco2.MaxSliceSize = q->max_slice_size;
712 #endif
713 
714 #if QSV_HAVE_TRELLIS
715  if (avctx->trellis >= 0)
716  q->extco2.Trellis = (avctx->trellis == 0) ? MFX_TRELLIS_OFF : (MFX_TRELLIS_I | MFX_TRELLIS_P | MFX_TRELLIS_B);
717  else
718  q->extco2.Trellis = MFX_TRELLIS_UNKNOWN;
719 #endif
720 
721 #if QSV_VERSION_ATLEAST(1, 8)
722  q->extco2.LookAheadDS = q->look_ahead_downsampling;
723  q->extco2.RepeatPPS = q->repeat_pps ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
724 
725 #if FF_API_PRIVATE_OPT
727  if (avctx->b_frame_strategy >= 0)
728  q->b_strategy = avctx->b_frame_strategy;
730 #endif
731  if (q->b_strategy >= 0)
732  q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
733  if (q->adaptive_i >= 0)
734  q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
735  if (q->adaptive_b >= 0)
736  q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
737 #endif
738  }
739 
740  if (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_HEVC) {
741  if (q->extbrc >= 0)
742  q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
743 
744 #if QSV_VERSION_ATLEAST(1, 9)
745  if (avctx->qmin >= 0 && avctx->qmax >= 0 && avctx->qmin > avctx->qmax) {
746  av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are set but invalid, please make sure min <= max\n");
747  return AVERROR(EINVAL);
748  }
749  if (avctx->qmin >= 0) {
750  q->extco2.MinQPI = avctx->qmin > 51 ? 51 : avctx->qmin;
751  q->extco2.MinQPP = q->extco2.MinQPB = q->extco2.MinQPI;
752  }
753  if (avctx->qmax >= 0) {
754  q->extco2.MaxQPI = avctx->qmax > 51 ? 51 : avctx->qmax;
755  q->extco2.MaxQPP = q->extco2.MaxQPB = q->extco2.MaxQPI;
756  }
757 #endif
758  q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
759  q->extco2.Header.BufferSz = sizeof(q->extco2);
760 
761  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
762  }
763 #endif
764 
765  if (avctx->codec_id == AV_CODEC_ID_H264) {
766 #if QSV_HAVE_MF
767  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 25)) {
768  q->extmfp.Header.BufferId = MFX_EXTBUFF_MULTI_FRAME_PARAM;
769  q->extmfp.Header.BufferSz = sizeof(q->extmfp);
770 
771  q->extmfp.MFMode = q->mfmode;
772  av_log(avctx,AV_LOG_VERBOSE,"MFMode:%d\n", q->extmfp.MFMode);
773  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extmfp;
774  }
775 #endif
776  }
777 #if QSV_HAVE_CO3
778  q->extco3.Header.BufferId = MFX_EXTBUFF_CODING_OPTION3;
779  q->extco3.Header.BufferSz = sizeof(q->extco3);
780 #if QSV_HAVE_GPB
781  if (avctx->codec_id == AV_CODEC_ID_HEVC)
782  q->extco3.GPB = q->gpb ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
783 #endif
784  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco3;
785 #endif
786  }
787 
788 #if QSV_HAVE_EXT_VP9_PARAM
789  if (avctx->codec_id == AV_CODEC_ID_VP9) {
790  q->extvp9param.Header.BufferId = MFX_EXTBUFF_VP9_PARAM;
791  q->extvp9param.Header.BufferSz = sizeof(q->extvp9param);
792  q->extvp9param.WriteIVFHeaders = MFX_CODINGOPTION_OFF;
793  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extvp9param;
794  }
795 #endif
796 
797 #if QSV_HAVE_EXT_HEVC_TILES
798  if (avctx->codec_id == AV_CODEC_ID_HEVC) {
799  q->exthevctiles.Header.BufferId = MFX_EXTBUFF_HEVC_TILES;
800  q->exthevctiles.Header.BufferSz = sizeof(q->exthevctiles);
801  q->exthevctiles.NumTileColumns = q->tile_cols;
802  q->exthevctiles.NumTileRows = q->tile_rows;
803  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->exthevctiles;
804  }
805 #endif
806 
807  if (!check_enc_param(avctx,q)) {
808  av_log(avctx, AV_LOG_ERROR,
809  "some encoding parameters are not supported by the QSV "
810  "runtime. Please double check the input parameters.\n");
811  return AVERROR(ENOSYS);
812  }
813 
814  return 0;
815 }
816 
818 {
819  int ret = 0;
820 
821  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
822  if (ret < 0)
823  return ff_qsv_print_error(avctx, ret,
824  "Error calling GetVideoParam");
825 
826  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
827 
828  // for qsv mjpeg the return value maybe 0 so alloc the buffer
829  if (q->packet_size == 0)
830  q->packet_size = q->param.mfx.FrameInfo.Height * q->param.mfx.FrameInfo.Width * 4;
831 
832  return 0;
833 }
834 
836 {
837  int ret = 0;
838 #if QSV_HAVE_EXT_VP9_PARAM
839  mfxExtVP9Param vp9_extend_buf = {
840  .Header.BufferId = MFX_EXTBUFF_VP9_PARAM,
841  .Header.BufferSz = sizeof(vp9_extend_buf),
842  };
843 #endif
844 
845 #if QSV_HAVE_CO2
846  mfxExtCodingOption2 co2 = {
847  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
848  .Header.BufferSz = sizeof(co2),
849  };
850 #endif
851 
852 #if QSV_HAVE_CO3
853  mfxExtCodingOption3 co3 = {
854  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
855  .Header.BufferSz = sizeof(co3),
856  };
857 #endif
858 
859  mfxExtBuffer *ext_buffers[] = {
860 #if QSV_HAVE_EXT_VP9_PARAM
861  (mfxExtBuffer*)&vp9_extend_buf,
862 #endif
863 #if QSV_HAVE_CO2
864  (mfxExtBuffer*)&co2,
865 #endif
866 #if QSV_HAVE_CO3
867  (mfxExtBuffer*)&co3,
868 #endif
869  };
870 
871  q->param.ExtParam = ext_buffers;
872  q->param.NumExtParam = FF_ARRAY_ELEMS(ext_buffers);
873 
874  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
875  if (ret < 0)
876  return ff_qsv_print_error(avctx, ret,
877  "Error calling GetVideoParam");
878 
879  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
880 
881  return 0;
882 }
883 
885 {
886  AVCPBProperties *cpb_props;
887 
888  uint8_t sps_buf[128];
889  uint8_t pps_buf[128];
890 
891  mfxExtCodingOptionSPSPPS extradata = {
892  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
893  .Header.BufferSz = sizeof(extradata),
894  .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),
895  .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
896  };
897 
898  mfxExtCodingOption co = {
899  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
900  .Header.BufferSz = sizeof(co),
901  };
902 #if QSV_HAVE_CO2
903  mfxExtCodingOption2 co2 = {
904  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
905  .Header.BufferSz = sizeof(co2),
906  };
907 #endif
908 #if QSV_HAVE_CO3
909  mfxExtCodingOption3 co3 = {
910  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
911  .Header.BufferSz = sizeof(co3),
912  };
913 #endif
914 
915 #if QSV_HAVE_CO_VPS
916  uint8_t vps_buf[128];
917  mfxExtCodingOptionVPS extradata_vps = {
918  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_VPS,
919  .Header.BufferSz = sizeof(extradata_vps),
920  .VPSBuffer = vps_buf,
921  .VPSBufSize = sizeof(vps_buf),
922  };
923 #endif
924 
925 #if QSV_HAVE_EXT_HEVC_TILES
926  mfxExtHEVCTiles hevc_tile_buf = {
927  .Header.BufferId = MFX_EXTBUFF_HEVC_TILES,
928  .Header.BufferSz = sizeof(hevc_tile_buf),
929  };
930 #endif
931 
932  mfxExtBuffer *ext_buffers[2 + QSV_HAVE_CO2 + QSV_HAVE_CO3 + QSV_HAVE_CO_VPS + QSV_HAVE_EXT_HEVC_TILES];
933 
934  int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
935  int ret, ext_buf_num = 0, extradata_offset = 0;
936 
937  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata;
938  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co;
939 #if QSV_HAVE_CO2
940  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;
941 #endif
942 #if QSV_HAVE_CO3
943  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;
944 #endif
945 #if QSV_HAVE_CO_VPS
946  q->hevc_vps = ((avctx->codec_id == AV_CODEC_ID_HEVC) && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 17));
947  if (q->hevc_vps)
948  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata_vps;
949 #endif
950 #if QSV_HAVE_EXT_HEVC_TILES
951  if (avctx->codec_id == AV_CODEC_ID_HEVC)
952  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&hevc_tile_buf;
953 #endif
954 
955  q->param.ExtParam = ext_buffers;
956  q->param.NumExtParam = ext_buf_num;
957 
958  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
959  if (ret < 0)
960  return ff_qsv_print_error(avctx, ret,
961  "Error calling GetVideoParam");
962 
963  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
964 
965  if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)
966 #if QSV_HAVE_CO_VPS
967  || (q->hevc_vps && !extradata_vps.VPSBufSize)
968 #endif
969  ) {
970  av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
971  return AVERROR_UNKNOWN;
972  }
973 
974  avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
975 #if QSV_HAVE_CO_VPS
976  avctx->extradata_size += q->hevc_vps * extradata_vps.VPSBufSize;
977 #endif
978 
980  if (!avctx->extradata)
981  return AVERROR(ENOMEM);
982 
983 #if QSV_HAVE_CO_VPS
984  if (q->hevc_vps) {
985  memcpy(avctx->extradata, vps_buf, extradata_vps.VPSBufSize);
986  extradata_offset += extradata_vps.VPSBufSize;
987  }
988 #endif
989 
990  memcpy(avctx->extradata + extradata_offset, sps_buf, extradata.SPSBufSize);
991  extradata_offset += extradata.SPSBufSize;
992  if (need_pps) {
993  memcpy(avctx->extradata + extradata_offset, pps_buf, extradata.PPSBufSize);
994  extradata_offset += extradata.PPSBufSize;
995  }
996  memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
997 
998  cpb_props = ff_add_cpb_side_data(avctx);
999  if (!cpb_props)
1000  return AVERROR(ENOMEM);
1001  cpb_props->max_bitrate = avctx->rc_max_rate;
1002  cpb_props->min_bitrate = avctx->rc_min_rate;
1003  cpb_props->avg_bitrate = avctx->bit_rate;
1004  cpb_props->buffer_size = avctx->rc_buffer_size;
1005 
1006  dump_video_param(avctx, q, ext_buffers + 1);
1007 
1008  return 0;
1009 }
1010 
1012 {
1013  AVQSVContext *qsv = avctx->hwaccel_context;
1014  mfxFrameSurface1 *surfaces;
1015  int nb_surfaces, i;
1016 
1017  nb_surfaces = qsv->nb_opaque_surfaces + q->req.NumFrameSuggested;
1018 
1019  q->opaque_alloc_buf = av_buffer_allocz(sizeof(*surfaces) * nb_surfaces);
1020  if (!q->opaque_alloc_buf)
1021  return AVERROR(ENOMEM);
1022 
1023  q->opaque_surfaces = av_malloc_array(nb_surfaces, sizeof(*q->opaque_surfaces));
1024  if (!q->opaque_surfaces)
1025  return AVERROR(ENOMEM);
1026 
1027  surfaces = (mfxFrameSurface1*)q->opaque_alloc_buf->data;
1028  for (i = 0; i < nb_surfaces; i++) {
1029  surfaces[i].Info = q->req.Info;
1030  q->opaque_surfaces[i] = surfaces + i;
1031  }
1032 
1033  q->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
1034  q->opaque_alloc.Header.BufferSz = sizeof(q->opaque_alloc);
1035  q->opaque_alloc.In.Surfaces = q->opaque_surfaces;
1036  q->opaque_alloc.In.NumSurface = nb_surfaces;
1037  q->opaque_alloc.In.Type = q->req.Type;
1038 
1039  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->opaque_alloc;
1040 
1041  qsv->nb_opaque_surfaces = nb_surfaces;
1043  qsv->opaque_alloc_type = q->req.Type;
1044 
1045  return 0;
1046 }
1047 
1049 {
1050  int ret;
1051 
1052  if (avctx->hwaccel_context) {
1053  AVQSVContext *qsv = avctx->hwaccel_context;
1054  q->session = qsv->session;
1055  } else if (avctx->hw_frames_ctx) {
1057  if (!q->frames_ctx.hw_frames_ctx)
1058  return AVERROR(ENOMEM);
1059 
1061  &q->frames_ctx, q->load_plugins,
1062  q->param.IOPattern == MFX_IOPATTERN_IN_OPAQUE_MEMORY,
1063  MFX_GPUCOPY_OFF);
1064  if (ret < 0) {
1066  return ret;
1067  }
1068 
1069  q->session = q->internal_qs.session;
1070  } else if (avctx->hw_device_ctx) {
1072  avctx->hw_device_ctx, q->load_plugins,
1073  MFX_GPUCOPY_OFF);
1074  if (ret < 0)
1075  return ret;
1076 
1077  q->session = q->internal_qs.session;
1078  } else {
1079  ret = ff_qsv_init_internal_session(avctx, &q->internal_qs,
1080  q->load_plugins, MFX_GPUCOPY_OFF);
1081  if (ret < 0)
1082  return ret;
1083 
1084  q->session = q->internal_qs.session;
1085  }
1086 
1087  return 0;
1088 }
1089 
1090 static inline unsigned int qsv_fifo_item_size(void)
1091 {
1092  return sizeof(AVPacket) + sizeof(mfxSyncPoint*) + sizeof(mfxBitstream*);
1093 }
1094 
1095 static inline unsigned int qsv_fifo_size(const AVFifoBuffer* fifo)
1096 {
1097  return av_fifo_size(fifo)/qsv_fifo_item_size();
1098 }
1099 
1101 {
1102  int iopattern = 0;
1103  int opaque_alloc = 0;
1104  int ret;
1105 
1106  q->param.AsyncDepth = q->async_depth;
1107 
1109  if (!q->async_fifo)
1110  return AVERROR(ENOMEM);
1111 
1112  if (avctx->hwaccel_context) {
1113  AVQSVContext *qsv = avctx->hwaccel_context;
1114 
1115  iopattern = qsv->iopattern;
1116  opaque_alloc = qsv->opaque_alloc;
1117  }
1118 
1119  if (avctx->hw_frames_ctx) {
1120  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1121  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
1122 
1123  if (!iopattern) {
1124  if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)
1125  iopattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
1126  else if (frames_hwctx->frame_type &
1127  (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
1128  iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
1129  }
1130  }
1131 
1132  if (!iopattern)
1133  iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
1134  q->param.IOPattern = iopattern;
1135 
1136  ret = qsvenc_init_session(avctx, q);
1137  if (ret < 0)
1138  return ret;
1139 
1140  ret = MFXQueryVersion(q->session,&q->ver);
1141  if (ret < 0) {
1142  return ff_qsv_print_error(avctx, ret,
1143  "Error querying mfx version");
1144  }
1145 
1146  // in the mfxInfoMFX struct, JPEG is different from other codecs
1147  switch (avctx->codec_id) {
1148  case AV_CODEC_ID_MJPEG:
1149  ret = init_video_param_jpeg(avctx, q);
1150  break;
1151  default:
1152  ret = init_video_param(avctx, q);
1153  break;
1154  }
1155  if (ret < 0)
1156  return ret;
1157 
1158  if (avctx->hwaccel_context) {
1159  AVQSVContext *qsv = avctx->hwaccel_context;
1160  int i, j;
1161 
1163  sizeof(*q->extparam));
1164  if (!q->extparam)
1165  return AVERROR(ENOMEM);
1166 
1167  q->param.ExtParam = q->extparam;
1168  for (i = 0; i < qsv->nb_ext_buffers; i++)
1169  q->param.ExtParam[i] = qsv->ext_buffers[i];
1170  q->param.NumExtParam = qsv->nb_ext_buffers;
1171 
1172  for (i = 0; i < q->nb_extparam_internal; i++) {
1173  for (j = 0; j < qsv->nb_ext_buffers; j++) {
1174  if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)
1175  break;
1176  }
1177  if (j < qsv->nb_ext_buffers)
1178  continue;
1179 
1180  q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];
1181  }
1182  } else {
1183  q->param.ExtParam = q->extparam_internal;
1184  q->param.NumExtParam = q->nb_extparam_internal;
1185  }
1186 
1187  ret = MFXVideoENCODE_Query(q->session, &q->param, &q->param);
1188  if (ret == MFX_WRN_PARTIAL_ACCELERATION) {
1189  av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
1190  } else if (ret < 0) {
1191  return ff_qsv_print_error(avctx, ret,
1192  "Error querying encoder params");
1193  }
1194 
1195  ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
1196  if (ret < 0)
1197  return ff_qsv_print_error(avctx, ret,
1198  "Error querying (IOSurf) the encoding parameters");
1199 
1200  if (opaque_alloc) {
1201  ret = qsv_init_opaque_alloc(avctx, q);
1202  if (ret < 0)
1203  return ret;
1204  }
1205 
1206  ret = MFXVideoENCODE_Init(q->session, &q->param);
1207  if (ret < 0)
1208  return ff_qsv_print_error(avctx, ret,
1209  "Error initializing the encoder");
1210  else if (ret > 0)
1211  ff_qsv_print_warning(avctx, ret,
1212  "Warning in encoder initialization");
1213 
1214  switch (avctx->codec_id) {
1215  case AV_CODEC_ID_MJPEG:
1216  ret = qsv_retrieve_enc_jpeg_params(avctx, q);
1217  break;
1218  case AV_CODEC_ID_VP9:
1219  ret = qsv_retrieve_enc_vp9_params(avctx, q);
1220  break;
1221  default:
1222  ret = qsv_retrieve_enc_params(avctx, q);
1223  break;
1224  }
1225  if (ret < 0) {
1226  av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
1227  return ret;
1228  }
1229 
1230  q->avctx = avctx;
1231 
1232  return 0;
1233 }
1234 
1235 static void free_encoder_ctrl_payloads(mfxEncodeCtrl* enc_ctrl)
1236 {
1237  if (enc_ctrl) {
1238  int i;
1239  for (i = 0; i < enc_ctrl->NumPayload && i < QSV_MAX_ENC_PAYLOAD; i++) {
1240  av_free(enc_ctrl->Payload[i]);
1241  }
1242  enc_ctrl->NumPayload = 0;
1243  }
1244 }
1245 
1247 {
1248  QSVFrame *cur = q->work_frames;
1249  while (cur) {
1250  if (cur->used && !cur->surface.Data.Locked) {
1252  if (cur->frame->format == AV_PIX_FMT_QSV) {
1253  av_frame_unref(cur->frame);
1254  }
1255  cur->used = 0;
1256  }
1257  cur = cur->next;
1258  }
1259 }
1260 
1262 {
1263  QSVFrame *frame, **last;
1264 
1266 
1267  frame = q->work_frames;
1268  last = &q->work_frames;
1269  while (frame) {
1270  if (!frame->used) {
1271  *f = frame;
1272  frame->used = 1;
1273  return 0;
1274  }
1275 
1276  last = &frame->next;
1277  frame = frame->next;
1278  }
1279 
1280  frame = av_mallocz(sizeof(*frame));
1281  if (!frame)
1282  return AVERROR(ENOMEM);
1283  frame->frame = av_frame_alloc();
1284  if (!frame->frame) {
1285  av_freep(&frame);
1286  return AVERROR(ENOMEM);
1287  }
1288  frame->enc_ctrl.Payload = av_mallocz(sizeof(mfxPayload*) * QSV_MAX_ENC_PAYLOAD);
1289  if (!frame->enc_ctrl.Payload) {
1290  av_freep(&frame);
1291  return AVERROR(ENOMEM);
1292  }
1293  *last = frame;
1294 
1295  *f = frame;
1296  frame->used = 1;
1297 
1298  return 0;
1299 }
1300 
1301 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
1302  QSVFrame **new_frame)
1303 {
1304  QSVFrame *qf;
1305  int ret;
1306 
1307  ret = get_free_frame(q, &qf);
1308  if (ret < 0)
1309  return ret;
1310 
1311  if (frame->format == AV_PIX_FMT_QSV) {
1312  ret = av_frame_ref(qf->frame, frame);
1313  if (ret < 0)
1314  return ret;
1315 
1316  qf->surface = *(mfxFrameSurface1*)qf->frame->data[3];
1317 
1318  if (q->frames_ctx.mids) {
1319  ret = ff_qsv_find_surface_idx(&q->frames_ctx, qf);
1320  if (ret < 0)
1321  return ret;
1322 
1323  qf->surface.Data.MemId = &q->frames_ctx.mids[ret];
1324  }
1325  } else {
1326  /* make a copy if the input is not padded as libmfx requires */
1327  /* and to make allocation continious for data[0]/data[1] */
1328  if ((frame->height & 31 || frame->linesize[0] & (q->width_align - 1)) ||
1329  (frame->data[1] - frame->data[0] != frame->linesize[0] * FFALIGN(qf->frame->height, q->height_align))) {
1330  qf->frame->height = FFALIGN(frame->height, q->height_align);
1331  qf->frame->width = FFALIGN(frame->width, q->width_align);
1332 
1333  qf->frame->format = frame->format;
1334 
1335  if (!qf->frame->data[0]) {
1336  ret = av_frame_get_buffer(qf->frame, q->width_align);
1337  if (ret < 0)
1338  return ret;
1339  }
1340 
1341  qf->frame->height = frame->height;
1342  qf->frame->width = frame->width;
1343 
1344  ret = av_frame_copy(qf->frame, frame);
1345  if (ret < 0) {
1346  av_frame_unref(qf->frame);
1347  return ret;
1348  }
1349  } else {
1350  ret = av_frame_ref(qf->frame, frame);
1351  if (ret < 0)
1352  return ret;
1353  }
1354 
1355  qf->surface.Info = q->param.mfx.FrameInfo;
1356 
1357  qf->surface.Info.PicStruct =
1358  !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
1359  frame->top_field_first ? MFX_PICSTRUCT_FIELD_TFF :
1360  MFX_PICSTRUCT_FIELD_BFF;
1361  if (frame->repeat_pict == 1)
1362  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
1363  else if (frame->repeat_pict == 2)
1364  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
1365  else if (frame->repeat_pict == 4)
1366  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
1367 
1368  qf->surface.Data.PitchLow = qf->frame->linesize[0];
1369  qf->surface.Data.Y = qf->frame->data[0];
1370  qf->surface.Data.UV = qf->frame->data[1];
1371  }
1372 
1373  qf->surface.Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
1374 
1375  *new_frame = qf;
1376 
1377  return 0;
1378 }
1379 
1381 {
1382  if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
1383  if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
1384  q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
1385  q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
1386  av_log(avctx, AV_LOG_WARNING,
1387  "Interlaced coding is supported"
1388  " at Main/High Profile Level 2.2-4.0\n");
1389  }
1390 }
1391 
1393  const AVFrame *frame)
1394 {
1395  AVPacket new_pkt = { 0 };
1396  mfxBitstream *bs;
1397 #if QSV_VERSION_ATLEAST(1, 26)
1398  mfxExtAVCEncodedFrameInfo *enc_info;
1399  mfxExtBuffer **enc_buf;
1400 #endif
1401 
1402  mfxFrameSurface1 *surf = NULL;
1403  mfxSyncPoint *sync = NULL;
1404  QSVFrame *qsv_frame = NULL;
1405  mfxEncodeCtrl* enc_ctrl = NULL;
1406  int ret;
1407 
1408  if (frame) {
1409  ret = submit_frame(q, frame, &qsv_frame);
1410  if (ret < 0) {
1411  av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
1412  return ret;
1413  }
1414  }
1415  if (qsv_frame) {
1416  surf = &qsv_frame->surface;
1417  enc_ctrl = &qsv_frame->enc_ctrl;
1418 
1419  if (frame->pict_type == AV_PICTURE_TYPE_I) {
1420  enc_ctrl->FrameType = MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF;
1421  if (q->forced_idr)
1422  enc_ctrl->FrameType |= MFX_FRAMETYPE_IDR;
1423  }
1424  }
1425 
1426  ret = av_new_packet(&new_pkt, q->packet_size);
1427  if (ret < 0) {
1428  av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
1429  return ret;
1430  }
1431 
1432  bs = av_mallocz(sizeof(*bs));
1433  if (!bs) {
1434  av_packet_unref(&new_pkt);
1435  return AVERROR(ENOMEM);
1436  }
1437  bs->Data = new_pkt.data;
1438  bs->MaxLength = new_pkt.size;
1439 
1440 #if QSV_VERSION_ATLEAST(1, 26)
1441  if (avctx->codec_id == AV_CODEC_ID_H264) {
1442  enc_info = av_mallocz(sizeof(*enc_info));
1443  if (!enc_info)
1444  return AVERROR(ENOMEM);
1445 
1446  enc_info->Header.BufferId = MFX_EXTBUFF_ENCODED_FRAME_INFO;
1447  enc_info->Header.BufferSz = sizeof (*enc_info);
1448  bs->NumExtParam = 1;
1449  enc_buf = av_mallocz(sizeof(mfxExtBuffer *));
1450  if (!enc_buf)
1451  return AVERROR(ENOMEM);
1452  enc_buf[0] = (mfxExtBuffer *)enc_info;
1453 
1454  bs->ExtParam = enc_buf;
1455  }
1456 #endif
1457 
1458  if (q->set_encode_ctrl_cb) {
1459  q->set_encode_ctrl_cb(avctx, frame, &qsv_frame->enc_ctrl);
1460  }
1461 
1462  sync = av_mallocz(sizeof(*sync));
1463  if (!sync) {
1464  av_freep(&bs);
1465  #if QSV_VERSION_ATLEAST(1, 26)
1466  if (avctx->codec_id == AV_CODEC_ID_H264) {
1467  av_freep(&enc_info);
1468  av_freep(&enc_buf);
1469  }
1470  #endif
1471  av_packet_unref(&new_pkt);
1472  return AVERROR(ENOMEM);
1473  }
1474 
1475  do {
1476  ret = MFXVideoENCODE_EncodeFrameAsync(q->session, enc_ctrl, surf, bs, sync);
1477  if (ret == MFX_WRN_DEVICE_BUSY)
1478  av_usleep(500);
1479  } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_WRN_IN_EXECUTION);
1480 
1481  if (ret > 0)
1482  ff_qsv_print_warning(avctx, ret, "Warning during encoding");
1483 
1484  if (ret < 0) {
1485  av_packet_unref(&new_pkt);
1486  av_freep(&bs);
1487 #if QSV_VERSION_ATLEAST(1, 26)
1488  if (avctx->codec_id == AV_CODEC_ID_H264) {
1489  av_freep(&enc_info);
1490  av_freep(&enc_buf);
1491  }
1492 #endif
1493  av_freep(&sync);
1494  return (ret == MFX_ERR_MORE_DATA) ?
1495  0 : ff_qsv_print_error(avctx, ret, "Error during encoding");
1496  }
1497 
1498  if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM && frame->interlaced_frame)
1499  print_interlace_msg(avctx, q);
1500 
1501  if (*sync) {
1502  av_fifo_generic_write(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1503  av_fifo_generic_write(q->async_fifo, &sync, sizeof(sync), NULL);
1504  av_fifo_generic_write(q->async_fifo, &bs, sizeof(bs), NULL);
1505  } else {
1506  av_freep(&sync);
1507  av_packet_unref(&new_pkt);
1508  av_freep(&bs);
1509 #if QSV_VERSION_ATLEAST(1, 26)
1510  if (avctx->codec_id == AV_CODEC_ID_H264) {
1511  av_freep(&enc_info);
1512  av_freep(&enc_buf);
1513  }
1514 #endif
1515  }
1516 
1517  return 0;
1518 }
1519 
1521  AVPacket *pkt, const AVFrame *frame, int *got_packet)
1522 {
1523  int ret;
1524 
1525  ret = encode_frame(avctx, q, frame);
1526  if (ret < 0)
1527  return ret;
1528 
1529  if ((qsv_fifo_size(q->async_fifo) >= q->async_depth) ||
1530  (!frame && av_fifo_size(q->async_fifo))) {
1531  AVPacket new_pkt;
1532  mfxBitstream *bs;
1533  mfxSyncPoint *sync;
1534 #if QSV_VERSION_ATLEAST(1, 26)
1535  mfxExtAVCEncodedFrameInfo *enc_info;
1536  mfxExtBuffer **enc_buf;
1537 #endif
1538  enum AVPictureType pict_type;
1539 
1540  av_fifo_generic_read(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1541  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1542  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1543 
1544  do {
1545  ret = MFXVideoCORE_SyncOperation(q->session, *sync, 1000);
1546  } while (ret == MFX_WRN_IN_EXECUTION);
1547 
1548  new_pkt.dts = av_rescale_q(bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
1549  new_pkt.pts = av_rescale_q(bs->TimeStamp, (AVRational){1, 90000}, avctx->time_base);
1550  new_pkt.size = bs->DataLength;
1551 
1552  if (bs->FrameType & MFX_FRAMETYPE_IDR || bs->FrameType & MFX_FRAMETYPE_xIDR) {
1553  new_pkt.flags |= AV_PKT_FLAG_KEY;
1554  pict_type = AV_PICTURE_TYPE_I;
1555  } else if (bs->FrameType & MFX_FRAMETYPE_I || bs->FrameType & MFX_FRAMETYPE_xI)
1556  pict_type = AV_PICTURE_TYPE_I;
1557  else if (bs->FrameType & MFX_FRAMETYPE_P || bs->FrameType & MFX_FRAMETYPE_xP)
1558  pict_type = AV_PICTURE_TYPE_P;
1559  else if (bs->FrameType & MFX_FRAMETYPE_B || bs->FrameType & MFX_FRAMETYPE_xB)
1560  pict_type = AV_PICTURE_TYPE_B;
1561  else if (bs->FrameType == MFX_FRAMETYPE_UNKNOWN) {
1562  pict_type = AV_PICTURE_TYPE_NONE;
1563  av_log(avctx, AV_LOG_WARNING, "Unknown FrameType, set pict_type to AV_PICTURE_TYPE_NONE.\n");
1564  } else {
1565  av_log(avctx, AV_LOG_ERROR, "Invalid FrameType:%d.\n", bs->FrameType);
1566  return AVERROR_INVALIDDATA;
1567  }
1568 
1569 #if FF_API_CODED_FRAME
1571  avctx->coded_frame->pict_type = pict_type;
1573 #endif
1574 
1575 #if QSV_VERSION_ATLEAST(1, 26)
1576  if (avctx->codec_id == AV_CODEC_ID_H264) {
1577  enc_buf = bs->ExtParam;
1578  enc_info = (mfxExtAVCEncodedFrameInfo *)(*bs->ExtParam);
1580  enc_info->QP * FF_QP2LAMBDA, NULL, 0, pict_type);
1581  av_freep(&enc_info);
1582  av_freep(&enc_buf);
1583  }
1584 #endif
1585  av_freep(&bs);
1586  av_freep(&sync);
1587 
1588  if (pkt->data) {
1589  if (pkt->size < new_pkt.size) {
1590  av_log(avctx, AV_LOG_ERROR, "Submitted buffer not large enough: %d < %d\n",
1591  pkt->size, new_pkt.size);
1592  av_packet_unref(&new_pkt);
1593  return AVERROR(EINVAL);
1594  }
1595 
1596  memcpy(pkt->data, new_pkt.data, new_pkt.size);
1597  pkt->size = new_pkt.size;
1598 
1599  ret = av_packet_copy_props(pkt, &new_pkt);
1600  av_packet_unref(&new_pkt);
1601  if (ret < 0)
1602  return ret;
1603  } else
1604  *pkt = new_pkt;
1605 
1606  *got_packet = 1;
1607  }
1608 
1609  return 0;
1610 }
1611 
1613 {
1614  QSVFrame *cur;
1615 
1616  if (q->session)
1617  MFXVideoENCODE_Close(q->session);
1618 
1619  q->session = NULL;
1621 
1624 
1625  cur = q->work_frames;
1626  while (cur) {
1627  q->work_frames = cur->next;
1628  av_frame_free(&cur->frame);
1629  av_free(cur->enc_ctrl.Payload);
1630  av_freep(&cur);
1631  cur = q->work_frames;
1632  }
1633 
1634  while (q->async_fifo && av_fifo_size(q->async_fifo)) {
1635  AVPacket pkt;
1636  mfxSyncPoint *sync;
1637  mfxBitstream *bs;
1638 
1639  av_fifo_generic_read(q->async_fifo, &pkt, sizeof(pkt), NULL);
1640  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1641  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1642 
1643  av_freep(&sync);
1644  av_freep(&bs);
1645  av_packet_unref(&pkt);
1646  }
1648  q->async_fifo = NULL;
1649 
1652 
1653  av_freep(&q->extparam);
1654 
1655  return 0;
1656 }
1657 
1659  HW_CONFIG_ENCODER_FRAMES(QSV, QSV),
1660  HW_CONFIG_ENCODER_DEVICE(NV12, QSV),
1661  HW_CONFIG_ENCODER_DEVICE(P010, QSV),
1662  NULL,
1663 };
int single_sei_nal_unit
Definition: qsvenc.h:176
#define NULL
Definition: coverity.c:32
AVRational framerate
Definition: avcodec.h:2069
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define FF_COMPRESSION_DEFAULT
Definition: avcodec.h:599
#define QSV_MAX_ENC_PAYLOAD
Definition: qsv_internal.h:53
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:142
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
AVBufferRef * opaque_alloc_buf
Definition: qsvenc.h:140
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:728
mfxExtBuffer ** extparam
Definition: qsvenc.h:145
static int init_video_param_jpeg(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:420
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:321
int int_ref_type
Definition: qsvenc.h:187
#define QSV_HAVE_LA
Definition: qsvenc.h:49
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
mfxExtOpaqueSurfaceAlloc opaque_alloc
Definition: qsvenc.h:138
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
Memory handling functions.
This struct is allocated as AVHWFramesContext.hwctx.
Definition: hwcontext_qsv.h:42
#define HW_CONFIG_ENCODER_FRAMES(format, device_type_)
Definition: hwconfig.h:99
const char * desc
Definition: nvenc.c:87
int max_frame_size
Definition: qsvenc.h:168
int max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: avcodec.h:454
int hevc_vps
Definition: qsvenc.h:153
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:786
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:1432
mfxFrameAllocRequest req
Definition: qsvenc.h:118
int avbr_accuracy
Definition: qsvenc.h:160
mfxEncodeCtrl enc_ctrl
Definition: qsv_internal.h:75
QSVFrame * work_frames
Definition: qsvenc.h:108
int num
Numerator.
Definition: rational.h:59
int repeat_pict
When decoding, this signals how much the picture must be delayed.
Definition: frame.h:450
int look_ahead_depth
Definition: qsvenc.h:164
static int get_free_frame(QSVEncContext *q, QSVFrame **f)
Definition: qsvenc.c:1261
int size
Definition: packet.h:356
int int_ref_qp_delta
Definition: qsvenc.h:189
#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:905
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
QSVFramesContext frames_ctx
Definition: qsvenc.h:149
int packet_size
Definition: qsvenc.h:113
#define QSV_RUNTIME_VERSION_ATLEAST(MFX_VERSION, MAJOR, MINOR)
Definition: qsv_internal.h:59
int ff_qsv_init_session_device(AVCodecContext *avctx, mfxSession *psession, AVBufferRef *device_ref, const char *load_plugins, int gpu_copy)
Definition: qsv.c:686
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
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:1380
static const struct @118 profile_names[]
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:838
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
int min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: avcodec.h:463
AVBufferRef * hw_frames_ctx
Definition: qsv_internal.h:94
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:172
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:649
Undefined.
Definition: avutil.h:273
int bitrate_limit
Definition: qsvenc.h:179
int look_ahead
Definition: qsvenc.h:163
int tile_cols
Definition: qsvenc.h:171
int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: qsvenc.c:1520
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
mfxVideoParam param
Definition: qsvenc.h:117
uint8_t
#define QSV_HAVE_CO2
Definition: qsvenc.h:38
#define QSV_HAVE_LA_HRD
Definition: qsvenc.h:51
AVFifoBuffer * async_fifo
Definition: qsvenc.h:147
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
void * hwaccel_context
Hardware accelerator context.
Definition: avcodec.h:1702
AVBufferRef * mids_buf
Definition: qsv_internal.h:101
mfxExtCodingOption extco
Definition: qsvenc.h:120
#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:795
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:444
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:401
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
int opaque_alloc
Encoding only.
Definition: qsv.h:65
mfxFrameSurface1 ** opaque_surfaces
Definition: qsvenc.h:139
uint8_t * data
Definition: packet.h:355
static int qsv_retrieve_enc_jpeg_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:817
mfxU16 rc_mode
Definition: qsvenc.c:84
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
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:455
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: avcodec.h:481
int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1612
#define HW_CONFIG_ENCODER_DEVICE(format, device_type_)
Definition: hwconfig.h:96
static const char * print_threestate(mfxU16 val)
Definition: qsvenc.c:123
#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: packet.h:388
int b_strategy
Definition: qsvenc.h:184
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:88
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:763
int width
Definition: frame.h:366
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int ff_qsv_find_surface_idx(QSVFramesContext *ctx, QSVFrame *frame)
Definition: qsv.c:237
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
int qmax
maximum quantizer
Definition: avcodec.h:1375
char * load_plugins
Definition: qsvenc.h:201
int low_power
Definition: qsvenc.h:193
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 tile_rows
Definition: qsvenc.h:172
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
static unsigned int qsv_fifo_item_size(void)
Definition: qsvenc.c:1090
int nb_extparam_internal
Definition: qsvenc.h:143
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:831
int max_dec_frame_buffering
Definition: qsvenc.h:177
int iopattern
The IO pattern to use.
Definition: qsv.h:46
static unsigned int qsv_fifo_size(const AVFifoBuffer *fifo)
Definition: qsvenc.c:1095
#define FFMAX(a, b)
Definition: common.h:94
int ff_qsv_close_internal_session(QSVSession *qs)
Definition: qsv.c:810
static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:884
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:800
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:361
int adaptive_i
Definition: qsvenc.h:182
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1389
int ff_qsv_print_warning(void *log_ctx, mfxStatus err, const char *warning_string)
Definition: qsv.c:182
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:1411
int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc)
Definition: qsv.c:208
int refs
number of reference frames
Definition: avcodec.h:1114
static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q, mfxExtBuffer **coding_opts)
Definition: qsvenc.c:132
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:571
const char * name
Definition: qsvenc.c:46
AVCodecContext * avctx
Definition: qsvenc.h:106
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:391
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:275
int idr_interval
Definition: qsvenc.h:157
mfxVersion ver
Definition: qsvenc.h:151
int width
picture width / height.
Definition: avcodec.h:699
int extbrc
Definition: qsvenc.h:181
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:2226
int preset
Definition: qsvenc.h:159
int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)
Definition: qsv.c:43
static const struct @119 rc_names[]
static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:300
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:1982
#define MFX_LOOKAHEAD_DS_OFF
Definition: qsvenc.h:72
static const char * print_profile(mfxU16 profile)
Definition: qsvenc.c:74
mfxFrameSurface1 surface
Definition: qsv_internal.h:74
#define MFX_LOOKAHEAD_DS_2x
Definition: qsvenc.h:73
int repeat_pps
Definition: qsvenc.h:192
int async_depth
Definition: qsvenc.h:156
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
attribute_deprecated int coder_type
Definition: avcodec.h:1443
#define FF_ARRAY_ELEMS(a)
int width_align
Definition: qsvenc.h:114
if(ret)
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:381
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:448
static int qsvenc_init_session(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1048
#define QSV_HAVE_CO3
Definition: qsvenc.h:39
Libavcodec external API header.
enum AVCodecID codec_id
Definition: avcodec.h:536
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:598
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:339
attribute_deprecated int b_frame_strategy
Definition: avcodec.h:800
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:526
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:605
uint8_t * data
The data buffer.
Definition: buffer.h:89
struct QSVFrame * next
Definition: qsv_internal.h:82
int qmin
minimum quantizer
Definition: avcodec.h:1368
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:162
#define QSV_HAVE_CO_VPS
Definition: qsvenc.h:40
int profile
Definition: qsvenc.h:158
static void free_encoder_ctrl_payloads(mfxEncodeCtrl *enc_ctrl)
Definition: qsvenc.c:1235
int extradata_size
Definition: avcodec.h:628
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:115
QSVSession internal_qs
Definition: qsvenc.h:111
#define FF_CODER_TYPE_VLC
Definition: avcodec.h:1435
const AVCodecHWConfigInternal * ff_qsv_enc_hw_configs[]
Definition: qsvenc.c:1658
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:1592
int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1100
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:124
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:380
AVPictureType
Definition: avutil.h:272
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:808
int max_slice_size
Definition: qsvenc.h:169
This struct is used for communicating QSV parameters between libavcodec and the caller.
Definition: qsv.h:36
mfxU16 profile
Definition: qsvenc.c:45
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:325
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:554
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:592
int int_ref_cycle_size
Definition: qsvenc.h:188
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:721
static int check_enc_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:389
int adaptive_b
Definition: qsvenc.h:183
#define QSV_HAVE_ICQ
Definition: qsvenc.h:64
#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:161
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:1776
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:1475
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:2001
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
int slices
Number of slices.
Definition: avcodec.h:1177
#define MFX_LOOKAHEAD_DS_4x
Definition: qsvenc.h:74
int forced_idr
Definition: qsvenc.h:203
int recovery_point_sei
Definition: qsvenc.h:190
#define av_free(p)
AVFifoBuffer * av_fifo_alloc(unsigned int size)
Initialize an AVFifoBuffer.
Definition: fifo.c:43
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:460
int avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: avcodec.h:472
static int qsv_retrieve_enc_vp9_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:835
#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: packet.h:354
int look_ahead_downsampling
Definition: qsvenc.h:165
static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:484
int height
Definition: frame.h:366
static const char * print_ratecontrol(mfxU16 rc_mode)
Definition: qsvenc.c:114
#define av_freep(p)
An API-specific header for AV_HWDEVICE_TYPE_QSV.
AVFrame * frame
Definition: qsv_internal.h:73
#define av_malloc_array(a, b)
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:343
#define QSV_HAVE_EXT_HEVC_TILES
Definition: qsvenc.h:42
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:2278
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:332
mfxSession session
Definition: qsvenc.h:110
static int qsv_init_opaque_alloc(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1011
#define QSV_HAVE_VCM
Definition: qsvenc.h:65
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:1589
mfxSession session
Definition: qsv_internal.h:86
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:348
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:2076
for(j=16;j >0;--j)
int pic_timing_sei
Definition: qsvenc.h:162
int i
Definition: input.c:406
#define FFMAX3(a, b, c)
Definition: common.h:95
static int encode_frame(AVCodecContext *avctx, QSVEncContext *q, const AVFrame *frame)
Definition: qsvenc.c:1392
Predicted.
Definition: avutil.h:275
static int submit_frame(QSVEncContext *q, const AVFrame *frame, QSVFrame **new_frame)
Definition: qsvenc.c:1301
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1404
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
SetEncodeCtrlCB * set_encode_ctrl_cb
Definition: qsvenc.h:202
static void clear_unused_frames(QSVEncContext *q)
Definition: qsvenc.c:1246