FFmpeg  4.3
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 #if QSV_VERSION_ATLEAST(1, 9)
740  if (avctx->qmin >= 0 && avctx->qmax >= 0 && avctx->qmin > avctx->qmax) {
741  av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are set but invalid, please make sure min <= max\n");
742  return AVERROR(EINVAL);
743  }
744  if (avctx->qmin >= 0) {
745  q->extco2.MinQPI = avctx->qmin > 51 ? 51 : avctx->qmin;
746  q->extco2.MinQPP = q->extco2.MinQPB = q->extco2.MinQPI;
747  }
748  if (avctx->qmax >= 0) {
749  q->extco2.MaxQPI = avctx->qmax > 51 ? 51 : avctx->qmax;
750  q->extco2.MaxQPP = q->extco2.MaxQPB = q->extco2.MaxQPI;
751  }
752 #endif
753  }
754 
755  if (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_HEVC) {
756  if (q->extbrc >= 0)
757  q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
758 
759  q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
760  q->extco2.Header.BufferSz = sizeof(q->extco2);
761 
762  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
763  }
764 #endif
765 
766  if (avctx->codec_id == AV_CODEC_ID_H264) {
767 #if QSV_HAVE_MF
768  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 25)) {
769  q->extmfp.Header.BufferId = MFX_EXTBUFF_MULTI_FRAME_PARAM;
770  q->extmfp.Header.BufferSz = sizeof(q->extmfp);
771 
772  q->extmfp.MFMode = q->mfmode;
773  av_log(avctx,AV_LOG_VERBOSE,"MFMode:%d\n", q->extmfp.MFMode);
774  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extmfp;
775  }
776 #endif
777  }
778 #if QSV_HAVE_CO3
779  q->extco3.Header.BufferId = MFX_EXTBUFF_CODING_OPTION3;
780  q->extco3.Header.BufferSz = sizeof(q->extco3);
781 #if QSV_HAVE_GPB
782  if (avctx->codec_id == AV_CODEC_ID_HEVC)
783  q->extco3.GPB = q->gpb ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
784 #endif
785  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco3;
786 #endif
787  }
788 
789 #if QSV_HAVE_EXT_VP9_PARAM
790  if (avctx->codec_id == AV_CODEC_ID_VP9) {
791  q->extvp9param.Header.BufferId = MFX_EXTBUFF_VP9_PARAM;
792  q->extvp9param.Header.BufferSz = sizeof(q->extvp9param);
793  q->extvp9param.WriteIVFHeaders = MFX_CODINGOPTION_OFF;
794  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extvp9param;
795  }
796 #endif
797 
798 #if QSV_HAVE_EXT_HEVC_TILES
799  if (avctx->codec_id == AV_CODEC_ID_HEVC) {
800  q->exthevctiles.Header.BufferId = MFX_EXTBUFF_HEVC_TILES;
801  q->exthevctiles.Header.BufferSz = sizeof(q->exthevctiles);
802  q->exthevctiles.NumTileColumns = q->tile_cols;
803  q->exthevctiles.NumTileRows = q->tile_rows;
804  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->exthevctiles;
805  }
806 #endif
807 
808  if (!check_enc_param(avctx,q)) {
809  av_log(avctx, AV_LOG_ERROR,
810  "some encoding parameters are not supported by the QSV "
811  "runtime. Please double check the input parameters.\n");
812  return AVERROR(ENOSYS);
813  }
814 
815  return 0;
816 }
817 
819 {
820  int ret = 0;
821 
822  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
823  if (ret < 0)
824  return ff_qsv_print_error(avctx, ret,
825  "Error calling GetVideoParam");
826 
827  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
828 
829  // for qsv mjpeg the return value maybe 0 so alloc the buffer
830  if (q->packet_size == 0)
831  q->packet_size = q->param.mfx.FrameInfo.Height * q->param.mfx.FrameInfo.Width * 4;
832 
833  return 0;
834 }
835 
837 {
838  int ret = 0;
839 #if QSV_HAVE_EXT_VP9_PARAM
840  mfxExtVP9Param vp9_extend_buf = {
841  .Header.BufferId = MFX_EXTBUFF_VP9_PARAM,
842  .Header.BufferSz = sizeof(vp9_extend_buf),
843  };
844 #endif
845 
846 #if QSV_HAVE_CO2
847  mfxExtCodingOption2 co2 = {
848  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
849  .Header.BufferSz = sizeof(co2),
850  };
851 #endif
852 
853 #if QSV_HAVE_CO3
854  mfxExtCodingOption3 co3 = {
855  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
856  .Header.BufferSz = sizeof(co3),
857  };
858 #endif
859 
860  mfxExtBuffer *ext_buffers[] = {
861 #if QSV_HAVE_EXT_VP9_PARAM
862  (mfxExtBuffer*)&vp9_extend_buf,
863 #endif
864 #if QSV_HAVE_CO2
865  (mfxExtBuffer*)&co2,
866 #endif
867 #if QSV_HAVE_CO3
868  (mfxExtBuffer*)&co3,
869 #endif
870  };
871 
872  q->param.ExtParam = ext_buffers;
873  q->param.NumExtParam = FF_ARRAY_ELEMS(ext_buffers);
874 
875  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
876  if (ret < 0)
877  return ff_qsv_print_error(avctx, ret,
878  "Error calling GetVideoParam");
879 
880  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
881 
882  return 0;
883 }
884 
886 {
887  AVCPBProperties *cpb_props;
888 
889  uint8_t sps_buf[128];
890  uint8_t pps_buf[128];
891 
892  mfxExtCodingOptionSPSPPS extradata = {
893  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
894  .Header.BufferSz = sizeof(extradata),
895  .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),
896  .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
897  };
898 
899  mfxExtCodingOption co = {
900  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
901  .Header.BufferSz = sizeof(co),
902  };
903 #if QSV_HAVE_CO2
904  mfxExtCodingOption2 co2 = {
905  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
906  .Header.BufferSz = sizeof(co2),
907  };
908 #endif
909 #if QSV_HAVE_CO3
910  mfxExtCodingOption3 co3 = {
911  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
912  .Header.BufferSz = sizeof(co3),
913  };
914 #endif
915 
916 #if QSV_HAVE_CO_VPS
917  uint8_t vps_buf[128];
918  mfxExtCodingOptionVPS extradata_vps = {
919  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_VPS,
920  .Header.BufferSz = sizeof(extradata_vps),
921  .VPSBuffer = vps_buf,
922  .VPSBufSize = sizeof(vps_buf),
923  };
924 #endif
925 
926 #if QSV_HAVE_EXT_HEVC_TILES
927  mfxExtHEVCTiles hevc_tile_buf = {
928  .Header.BufferId = MFX_EXTBUFF_HEVC_TILES,
929  .Header.BufferSz = sizeof(hevc_tile_buf),
930  };
931 #endif
932 
933  mfxExtBuffer *ext_buffers[2 + QSV_HAVE_CO2 + QSV_HAVE_CO3 + QSV_HAVE_CO_VPS + QSV_HAVE_EXT_HEVC_TILES];
934 
935  int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
936  int ret, ext_buf_num = 0, extradata_offset = 0;
937 
938  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata;
939  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co;
940 #if QSV_HAVE_CO2
941  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;
942 #endif
943 #if QSV_HAVE_CO3
944  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;
945 #endif
946 #if QSV_HAVE_CO_VPS
947  q->hevc_vps = ((avctx->codec_id == AV_CODEC_ID_HEVC) && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 17));
948  if (q->hevc_vps)
949  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata_vps;
950 #endif
951 #if QSV_HAVE_EXT_HEVC_TILES
952  if (avctx->codec_id == AV_CODEC_ID_HEVC)
953  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&hevc_tile_buf;
954 #endif
955 
956  q->param.ExtParam = ext_buffers;
957  q->param.NumExtParam = ext_buf_num;
958 
959  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
960  if (ret < 0)
961  return ff_qsv_print_error(avctx, ret,
962  "Error calling GetVideoParam");
963 
964  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
965 
966  if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)
967 #if QSV_HAVE_CO_VPS
968  || (q->hevc_vps && !extradata_vps.VPSBufSize)
969 #endif
970  ) {
971  av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
972  return AVERROR_UNKNOWN;
973  }
974 
975  avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
976 #if QSV_HAVE_CO_VPS
977  avctx->extradata_size += q->hevc_vps * extradata_vps.VPSBufSize;
978 #endif
979 
981  if (!avctx->extradata)
982  return AVERROR(ENOMEM);
983 
984 #if QSV_HAVE_CO_VPS
985  if (q->hevc_vps) {
986  memcpy(avctx->extradata, vps_buf, extradata_vps.VPSBufSize);
987  extradata_offset += extradata_vps.VPSBufSize;
988  }
989 #endif
990 
991  memcpy(avctx->extradata + extradata_offset, sps_buf, extradata.SPSBufSize);
992  extradata_offset += extradata.SPSBufSize;
993  if (need_pps) {
994  memcpy(avctx->extradata + extradata_offset, pps_buf, extradata.PPSBufSize);
995  extradata_offset += extradata.PPSBufSize;
996  }
997  memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
998 
999  cpb_props = ff_add_cpb_side_data(avctx);
1000  if (!cpb_props)
1001  return AVERROR(ENOMEM);
1002  cpb_props->max_bitrate = avctx->rc_max_rate;
1003  cpb_props->min_bitrate = avctx->rc_min_rate;
1004  cpb_props->avg_bitrate = avctx->bit_rate;
1005  cpb_props->buffer_size = avctx->rc_buffer_size;
1006 
1007  dump_video_param(avctx, q, ext_buffers + 1);
1008 
1009  return 0;
1010 }
1011 
1013 {
1014  AVQSVContext *qsv = avctx->hwaccel_context;
1015  mfxFrameSurface1 *surfaces;
1016  int nb_surfaces, i;
1017 
1018  nb_surfaces = qsv->nb_opaque_surfaces + q->req.NumFrameSuggested;
1019 
1020  q->opaque_alloc_buf = av_buffer_allocz(sizeof(*surfaces) * nb_surfaces);
1021  if (!q->opaque_alloc_buf)
1022  return AVERROR(ENOMEM);
1023 
1024  q->opaque_surfaces = av_malloc_array(nb_surfaces, sizeof(*q->opaque_surfaces));
1025  if (!q->opaque_surfaces)
1026  return AVERROR(ENOMEM);
1027 
1028  surfaces = (mfxFrameSurface1*)q->opaque_alloc_buf->data;
1029  for (i = 0; i < nb_surfaces; i++) {
1030  surfaces[i].Info = q->req.Info;
1031  q->opaque_surfaces[i] = surfaces + i;
1032  }
1033 
1034  q->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
1035  q->opaque_alloc.Header.BufferSz = sizeof(q->opaque_alloc);
1036  q->opaque_alloc.In.Surfaces = q->opaque_surfaces;
1037  q->opaque_alloc.In.NumSurface = nb_surfaces;
1038  q->opaque_alloc.In.Type = q->req.Type;
1039 
1040  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->opaque_alloc;
1041 
1042  qsv->nb_opaque_surfaces = nb_surfaces;
1044  qsv->opaque_alloc_type = q->req.Type;
1045 
1046  return 0;
1047 }
1048 
1050 {
1051  int ret;
1052 
1053  if (avctx->hwaccel_context) {
1054  AVQSVContext *qsv = avctx->hwaccel_context;
1055  q->session = qsv->session;
1056  } else if (avctx->hw_frames_ctx) {
1058  if (!q->frames_ctx.hw_frames_ctx)
1059  return AVERROR(ENOMEM);
1060 
1062  &q->frames_ctx, q->load_plugins,
1063  q->param.IOPattern == MFX_IOPATTERN_IN_OPAQUE_MEMORY,
1064  MFX_GPUCOPY_OFF);
1065  if (ret < 0) {
1067  return ret;
1068  }
1069 
1070  q->session = q->internal_qs.session;
1071  } else if (avctx->hw_device_ctx) {
1073  avctx->hw_device_ctx, q->load_plugins,
1074  MFX_GPUCOPY_OFF);
1075  if (ret < 0)
1076  return ret;
1077 
1078  q->session = q->internal_qs.session;
1079  } else {
1080  ret = ff_qsv_init_internal_session(avctx, &q->internal_qs,
1081  q->load_plugins, MFX_GPUCOPY_OFF);
1082  if (ret < 0)
1083  return ret;
1084 
1085  q->session = q->internal_qs.session;
1086  }
1087 
1088  return 0;
1089 }
1090 
1091 static inline unsigned int qsv_fifo_item_size(void)
1092 {
1093  return sizeof(AVPacket) + sizeof(mfxSyncPoint*) + sizeof(mfxBitstream*);
1094 }
1095 
1096 static inline unsigned int qsv_fifo_size(const AVFifoBuffer* fifo)
1097 {
1098  return av_fifo_size(fifo)/qsv_fifo_item_size();
1099 }
1100 
1102 {
1103  int iopattern = 0;
1104  int opaque_alloc = 0;
1105  int ret;
1106 
1107  q->param.AsyncDepth = q->async_depth;
1108 
1110  if (!q->async_fifo)
1111  return AVERROR(ENOMEM);
1112 
1113  if (avctx->hwaccel_context) {
1114  AVQSVContext *qsv = avctx->hwaccel_context;
1115 
1116  iopattern = qsv->iopattern;
1117  opaque_alloc = qsv->opaque_alloc;
1118  }
1119 
1120  if (avctx->hw_frames_ctx) {
1121  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1122  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
1123 
1124  if (!iopattern) {
1125  if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)
1126  iopattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
1127  else if (frames_hwctx->frame_type &
1128  (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
1129  iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
1130  }
1131  }
1132 
1133  if (!iopattern)
1134  iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
1135  q->param.IOPattern = iopattern;
1136 
1137  ret = qsvenc_init_session(avctx, q);
1138  if (ret < 0)
1139  return ret;
1140 
1141  ret = MFXQueryVersion(q->session,&q->ver);
1142  if (ret < 0) {
1143  return ff_qsv_print_error(avctx, ret,
1144  "Error querying mfx version");
1145  }
1146 
1147  // in the mfxInfoMFX struct, JPEG is different from other codecs
1148  switch (avctx->codec_id) {
1149  case AV_CODEC_ID_MJPEG:
1150  ret = init_video_param_jpeg(avctx, q);
1151  break;
1152  default:
1153  ret = init_video_param(avctx, q);
1154  break;
1155  }
1156  if (ret < 0)
1157  return ret;
1158 
1159  if (avctx->hwaccel_context) {
1160  AVQSVContext *qsv = avctx->hwaccel_context;
1161  int i, j;
1162 
1164  sizeof(*q->extparam));
1165  if (!q->extparam)
1166  return AVERROR(ENOMEM);
1167 
1168  q->param.ExtParam = q->extparam;
1169  for (i = 0; i < qsv->nb_ext_buffers; i++)
1170  q->param.ExtParam[i] = qsv->ext_buffers[i];
1171  q->param.NumExtParam = qsv->nb_ext_buffers;
1172 
1173  for (i = 0; i < q->nb_extparam_internal; i++) {
1174  for (j = 0; j < qsv->nb_ext_buffers; j++) {
1175  if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)
1176  break;
1177  }
1178  if (j < qsv->nb_ext_buffers)
1179  continue;
1180 
1181  q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];
1182  }
1183  } else {
1184  q->param.ExtParam = q->extparam_internal;
1185  q->param.NumExtParam = q->nb_extparam_internal;
1186  }
1187 
1188  ret = MFXVideoENCODE_Query(q->session, &q->param, &q->param);
1189  if (ret == MFX_WRN_PARTIAL_ACCELERATION) {
1190  av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
1191  } else if (ret < 0) {
1192  return ff_qsv_print_error(avctx, ret,
1193  "Error querying encoder params");
1194  }
1195 
1196  ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
1197  if (ret < 0)
1198  return ff_qsv_print_error(avctx, ret,
1199  "Error querying (IOSurf) the encoding parameters");
1200 
1201  if (opaque_alloc) {
1202  ret = qsv_init_opaque_alloc(avctx, q);
1203  if (ret < 0)
1204  return ret;
1205  }
1206 
1207  ret = MFXVideoENCODE_Init(q->session, &q->param);
1208  if (ret < 0)
1209  return ff_qsv_print_error(avctx, ret,
1210  "Error initializing the encoder");
1211  else if (ret > 0)
1212  ff_qsv_print_warning(avctx, ret,
1213  "Warning in encoder initialization");
1214 
1215  switch (avctx->codec_id) {
1216  case AV_CODEC_ID_MJPEG:
1217  ret = qsv_retrieve_enc_jpeg_params(avctx, q);
1218  break;
1219  case AV_CODEC_ID_VP9:
1220  ret = qsv_retrieve_enc_vp9_params(avctx, q);
1221  break;
1222  default:
1223  ret = qsv_retrieve_enc_params(avctx, q);
1224  break;
1225  }
1226  if (ret < 0) {
1227  av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
1228  return ret;
1229  }
1230 
1231  q->avctx = avctx;
1232 
1233  return 0;
1234 }
1235 
1236 static void free_encoder_ctrl_payloads(mfxEncodeCtrl* enc_ctrl)
1237 {
1238  if (enc_ctrl) {
1239  int i;
1240  for (i = 0; i < enc_ctrl->NumPayload && i < QSV_MAX_ENC_PAYLOAD; i++) {
1241  av_free(enc_ctrl->Payload[i]);
1242  }
1243  enc_ctrl->NumPayload = 0;
1244  }
1245 }
1246 
1248 {
1249  QSVFrame *cur = q->work_frames;
1250  while (cur) {
1251  if (cur->used && !cur->surface.Data.Locked) {
1253  if (cur->frame->format == AV_PIX_FMT_QSV) {
1254  av_frame_unref(cur->frame);
1255  }
1256  cur->used = 0;
1257  }
1258  cur = cur->next;
1259  }
1260 }
1261 
1263 {
1264  QSVFrame *frame, **last;
1265 
1267 
1268  frame = q->work_frames;
1269  last = &q->work_frames;
1270  while (frame) {
1271  if (!frame->used) {
1272  *f = frame;
1273  frame->used = 1;
1274  return 0;
1275  }
1276 
1277  last = &frame->next;
1278  frame = frame->next;
1279  }
1280 
1281  frame = av_mallocz(sizeof(*frame));
1282  if (!frame)
1283  return AVERROR(ENOMEM);
1284  frame->frame = av_frame_alloc();
1285  if (!frame->frame) {
1286  av_freep(&frame);
1287  return AVERROR(ENOMEM);
1288  }
1289  frame->enc_ctrl.Payload = av_mallocz(sizeof(mfxPayload*) * QSV_MAX_ENC_PAYLOAD);
1290  if (!frame->enc_ctrl.Payload) {
1291  av_freep(&frame);
1292  return AVERROR(ENOMEM);
1293  }
1294  *last = frame;
1295 
1296  *f = frame;
1297  frame->used = 1;
1298 
1299  return 0;
1300 }
1301 
1302 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
1303  QSVFrame **new_frame)
1304 {
1305  QSVFrame *qf;
1306  int ret;
1307 
1308  ret = get_free_frame(q, &qf);
1309  if (ret < 0)
1310  return ret;
1311 
1312  if (frame->format == AV_PIX_FMT_QSV) {
1313  ret = av_frame_ref(qf->frame, frame);
1314  if (ret < 0)
1315  return ret;
1316 
1317  qf->surface = *(mfxFrameSurface1*)qf->frame->data[3];
1318 
1319  if (q->frames_ctx.mids) {
1320  ret = ff_qsv_find_surface_idx(&q->frames_ctx, qf);
1321  if (ret < 0)
1322  return ret;
1323 
1324  qf->surface.Data.MemId = &q->frames_ctx.mids[ret];
1325  }
1326  } else {
1327  /* make a copy if the input is not padded as libmfx requires */
1328  /* and to make allocation continious for data[0]/data[1] */
1329  if ((frame->height & 31 || frame->linesize[0] & (q->width_align - 1)) ||
1330  (frame->data[1] - frame->data[0] != frame->linesize[0] * FFALIGN(qf->frame->height, q->height_align))) {
1331  qf->frame->height = FFALIGN(frame->height, q->height_align);
1332  qf->frame->width = FFALIGN(frame->width, q->width_align);
1333 
1334  qf->frame->format = frame->format;
1335 
1336  if (!qf->frame->data[0]) {
1337  ret = av_frame_get_buffer(qf->frame, q->width_align);
1338  if (ret < 0)
1339  return ret;
1340  }
1341 
1342  qf->frame->height = frame->height;
1343  qf->frame->width = frame->width;
1344 
1345  ret = av_frame_copy(qf->frame, frame);
1346  if (ret < 0) {
1347  av_frame_unref(qf->frame);
1348  return ret;
1349  }
1350  } else {
1351  ret = av_frame_ref(qf->frame, frame);
1352  if (ret < 0)
1353  return ret;
1354  }
1355 
1356  qf->surface.Info = q->param.mfx.FrameInfo;
1357 
1358  qf->surface.Info.PicStruct =
1359  !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
1360  frame->top_field_first ? MFX_PICSTRUCT_FIELD_TFF :
1361  MFX_PICSTRUCT_FIELD_BFF;
1362  if (frame->repeat_pict == 1)
1363  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
1364  else if (frame->repeat_pict == 2)
1365  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
1366  else if (frame->repeat_pict == 4)
1367  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
1368 
1369  qf->surface.Data.PitchLow = qf->frame->linesize[0];
1370  qf->surface.Data.Y = qf->frame->data[0];
1371  qf->surface.Data.UV = qf->frame->data[1];
1372  }
1373 
1374  qf->surface.Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
1375 
1376  *new_frame = qf;
1377 
1378  return 0;
1379 }
1380 
1382 {
1383  if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
1384  if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
1385  q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
1386  q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
1387  av_log(avctx, AV_LOG_WARNING,
1388  "Interlaced coding is supported"
1389  " at Main/High Profile Level 2.2-4.0\n");
1390  }
1391 }
1392 
1394  const AVFrame *frame)
1395 {
1396  AVPacket new_pkt = { 0 };
1397  mfxBitstream *bs;
1398 #if QSV_VERSION_ATLEAST(1, 26)
1399  mfxExtAVCEncodedFrameInfo *enc_info;
1400  mfxExtBuffer **enc_buf;
1401 #endif
1402 
1403  mfxFrameSurface1 *surf = NULL;
1404  mfxSyncPoint *sync = NULL;
1405  QSVFrame *qsv_frame = NULL;
1406  mfxEncodeCtrl* enc_ctrl = NULL;
1407  int ret;
1408 
1409  if (frame) {
1410  ret = submit_frame(q, frame, &qsv_frame);
1411  if (ret < 0) {
1412  av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
1413  return ret;
1414  }
1415  }
1416  if (qsv_frame) {
1417  surf = &qsv_frame->surface;
1418  enc_ctrl = &qsv_frame->enc_ctrl;
1419 
1420  if (frame->pict_type == AV_PICTURE_TYPE_I) {
1421  enc_ctrl->FrameType = MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF;
1422  if (q->forced_idr)
1423  enc_ctrl->FrameType |= MFX_FRAMETYPE_IDR;
1424  }
1425  }
1426 
1427  ret = av_new_packet(&new_pkt, q->packet_size);
1428  if (ret < 0) {
1429  av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
1430  return ret;
1431  }
1432 
1433  bs = av_mallocz(sizeof(*bs));
1434  if (!bs) {
1435  av_packet_unref(&new_pkt);
1436  return AVERROR(ENOMEM);
1437  }
1438  bs->Data = new_pkt.data;
1439  bs->MaxLength = new_pkt.size;
1440 
1441 #if QSV_VERSION_ATLEAST(1, 26)
1442  if (avctx->codec_id == AV_CODEC_ID_H264) {
1443  enc_info = av_mallocz(sizeof(*enc_info));
1444  if (!enc_info)
1445  return AVERROR(ENOMEM);
1446 
1447  enc_info->Header.BufferId = MFX_EXTBUFF_ENCODED_FRAME_INFO;
1448  enc_info->Header.BufferSz = sizeof (*enc_info);
1449  bs->NumExtParam = 1;
1450  enc_buf = av_mallocz(sizeof(mfxExtBuffer *));
1451  if (!enc_buf)
1452  return AVERROR(ENOMEM);
1453  enc_buf[0] = (mfxExtBuffer *)enc_info;
1454 
1455  bs->ExtParam = enc_buf;
1456  }
1457 #endif
1458 
1459  if (q->set_encode_ctrl_cb) {
1460  q->set_encode_ctrl_cb(avctx, frame, &qsv_frame->enc_ctrl);
1461  }
1462 
1463  sync = av_mallocz(sizeof(*sync));
1464  if (!sync) {
1465  av_freep(&bs);
1466  #if QSV_VERSION_ATLEAST(1, 26)
1467  if (avctx->codec_id == AV_CODEC_ID_H264) {
1468  av_freep(&enc_info);
1469  av_freep(&enc_buf);
1470  }
1471  #endif
1472  av_packet_unref(&new_pkt);
1473  return AVERROR(ENOMEM);
1474  }
1475 
1476  do {
1477  ret = MFXVideoENCODE_EncodeFrameAsync(q->session, enc_ctrl, surf, bs, sync);
1478  if (ret == MFX_WRN_DEVICE_BUSY)
1479  av_usleep(500);
1480  } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_WRN_IN_EXECUTION);
1481 
1482  if (ret > 0)
1483  ff_qsv_print_warning(avctx, ret, "Warning during encoding");
1484 
1485  if (ret < 0) {
1486  av_packet_unref(&new_pkt);
1487  av_freep(&bs);
1488 #if QSV_VERSION_ATLEAST(1, 26)
1489  if (avctx->codec_id == AV_CODEC_ID_H264) {
1490  av_freep(&enc_info);
1491  av_freep(&enc_buf);
1492  }
1493 #endif
1494  av_freep(&sync);
1495  return (ret == MFX_ERR_MORE_DATA) ?
1496  0 : ff_qsv_print_error(avctx, ret, "Error during encoding");
1497  }
1498 
1499  if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM && frame->interlaced_frame)
1500  print_interlace_msg(avctx, q);
1501 
1502  if (*sync) {
1503  av_fifo_generic_write(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1504  av_fifo_generic_write(q->async_fifo, &sync, sizeof(sync), NULL);
1505  av_fifo_generic_write(q->async_fifo, &bs, sizeof(bs), NULL);
1506  } else {
1507  av_freep(&sync);
1508  av_packet_unref(&new_pkt);
1509  av_freep(&bs);
1510 #if QSV_VERSION_ATLEAST(1, 26)
1511  if (avctx->codec_id == AV_CODEC_ID_H264) {
1512  av_freep(&enc_info);
1513  av_freep(&enc_buf);
1514  }
1515 #endif
1516  }
1517 
1518  return 0;
1519 }
1520 
1522  AVPacket *pkt, const AVFrame *frame, int *got_packet)
1523 {
1524  int ret;
1525 
1526  ret = encode_frame(avctx, q, frame);
1527  if (ret < 0)
1528  return ret;
1529 
1530  if ((qsv_fifo_size(q->async_fifo) >= q->async_depth) ||
1531  (!frame && av_fifo_size(q->async_fifo))) {
1532  AVPacket new_pkt;
1533  mfxBitstream *bs;
1534  mfxSyncPoint *sync;
1535 #if QSV_VERSION_ATLEAST(1, 26)
1536  mfxExtAVCEncodedFrameInfo *enc_info;
1537  mfxExtBuffer **enc_buf;
1538 #endif
1539  enum AVPictureType pict_type;
1540 
1541  av_fifo_generic_read(q->async_fifo, &new_pkt, sizeof(new_pkt), NULL);
1542  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1543  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1544 
1545  do {
1546  ret = MFXVideoCORE_SyncOperation(q->session, *sync, 1000);
1547  } while (ret == MFX_WRN_IN_EXECUTION);
1548 
1549  new_pkt.dts = av_rescale_q(bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
1550  new_pkt.pts = av_rescale_q(bs->TimeStamp, (AVRational){1, 90000}, avctx->time_base);
1551  new_pkt.size = bs->DataLength;
1552 
1553  if (bs->FrameType & MFX_FRAMETYPE_IDR || bs->FrameType & MFX_FRAMETYPE_xIDR) {
1554  new_pkt.flags |= AV_PKT_FLAG_KEY;
1555  pict_type = AV_PICTURE_TYPE_I;
1556  } else if (bs->FrameType & MFX_FRAMETYPE_I || bs->FrameType & MFX_FRAMETYPE_xI)
1557  pict_type = AV_PICTURE_TYPE_I;
1558  else if (bs->FrameType & MFX_FRAMETYPE_P || bs->FrameType & MFX_FRAMETYPE_xP)
1559  pict_type = AV_PICTURE_TYPE_P;
1560  else if (bs->FrameType & MFX_FRAMETYPE_B || bs->FrameType & MFX_FRAMETYPE_xB)
1561  pict_type = AV_PICTURE_TYPE_B;
1562  else if (bs->FrameType == MFX_FRAMETYPE_UNKNOWN) {
1563  pict_type = AV_PICTURE_TYPE_NONE;
1564  av_log(avctx, AV_LOG_WARNING, "Unknown FrameType, set pict_type to AV_PICTURE_TYPE_NONE.\n");
1565  } else {
1566  av_log(avctx, AV_LOG_ERROR, "Invalid FrameType:%d.\n", bs->FrameType);
1567  return AVERROR_INVALIDDATA;
1568  }
1569 
1570 #if FF_API_CODED_FRAME
1572  avctx->coded_frame->pict_type = pict_type;
1574 #endif
1575 
1576 #if QSV_VERSION_ATLEAST(1, 26)
1577  if (avctx->codec_id == AV_CODEC_ID_H264) {
1578  enc_buf = bs->ExtParam;
1579  enc_info = (mfxExtAVCEncodedFrameInfo *)(*bs->ExtParam);
1581  enc_info->QP * FF_QP2LAMBDA, NULL, 0, pict_type);
1582  av_freep(&enc_info);
1583  av_freep(&enc_buf);
1584  }
1585 #endif
1586  av_freep(&bs);
1587  av_freep(&sync);
1588 
1589  if (pkt->data) {
1590  if (pkt->size < new_pkt.size) {
1591  av_log(avctx, AV_LOG_ERROR, "Submitted buffer not large enough: %d < %d\n",
1592  pkt->size, new_pkt.size);
1593  av_packet_unref(&new_pkt);
1594  return AVERROR(EINVAL);
1595  }
1596 
1597  memcpy(pkt->data, new_pkt.data, new_pkt.size);
1598  pkt->size = new_pkt.size;
1599 
1600  ret = av_packet_copy_props(pkt, &new_pkt);
1601  av_packet_unref(&new_pkt);
1602  if (ret < 0)
1603  return ret;
1604  } else
1605  *pkt = new_pkt;
1606 
1607  *got_packet = 1;
1608  }
1609 
1610  return 0;
1611 }
1612 
1614 {
1615  QSVFrame *cur;
1616 
1617  if (q->session)
1618  MFXVideoENCODE_Close(q->session);
1619 
1620  q->session = NULL;
1622 
1625 
1626  cur = q->work_frames;
1627  while (cur) {
1628  q->work_frames = cur->next;
1629  av_frame_free(&cur->frame);
1630  av_free(cur->enc_ctrl.Payload);
1631  av_freep(&cur);
1632  cur = q->work_frames;
1633  }
1634 
1635  while (q->async_fifo && av_fifo_size(q->async_fifo)) {
1636  AVPacket pkt;
1637  mfxSyncPoint *sync;
1638  mfxBitstream *bs;
1639 
1640  av_fifo_generic_read(q->async_fifo, &pkt, sizeof(pkt), NULL);
1641  av_fifo_generic_read(q->async_fifo, &sync, sizeof(sync), NULL);
1642  av_fifo_generic_read(q->async_fifo, &bs, sizeof(bs), NULL);
1643 
1644  av_freep(&sync);
1645  av_freep(&bs);
1646  av_packet_unref(&pkt);
1647  }
1649  q->async_fifo = NULL;
1650 
1653 
1654  av_freep(&q->extparam);
1655 
1656  return 0;
1657 }
1658 
1660  HW_CONFIG_ENCODER_FRAMES(QSV, QSV),
1661  HW_CONFIG_ENCODER_DEVICE(NV12, QSV),
1662  HW_CONFIG_ENCODER_DEVICE(P010, QSV),
1663  NULL,
1664 };
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:51
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
mfxExtBuffer * extparam_internal[2+QSV_HAVE_CO2+QSV_HAVE_CO3+(QSV_HAVE_MF *2)]
Definition: qsvenc.h:142
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2549
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
AVBufferRef * opaque_alloc_buf
Definition: qsvenc.h:140
if(ret< 0)
Definition: vf_mcdeint.c:279
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:182
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:79
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:73
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:442
int look_ahead_depth
Definition: qsvenc.h:164
static int get_free_frame(QSVEncContext *q, QSVFrame **f)
Definition: qsvenc.c:1262
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:57
int ff_qsv_init_session_device(AVCodecContext *avctx, mfxSession *psession, AVBufferRef *device_ref, const char *load_plugins, int gpu_copy)
Definition: qsv.c:686
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:1381
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:92
int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int(*func)(void *, void *, int))
Feed data from a user-supplied callback to an AVFifoBuffer.
Definition: fifo.c:122
int ff_qsv_print_error(void *log_ctx, mfxStatus err, const char *error_string)
Definition: qsv.c: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:1521
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:99
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:393
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
static AVFrame * frame
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:818
mfxU16 rc_mode
Definition: qsvenc.c:84
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
void av_fifo_free(AVFifoBuffer *f)
Free an AVFifoBuffer.
Definition: fifo.c:55
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:447
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:1613
#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
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
int width
Definition: frame.h:358
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int ff_qsv_find_surface_idx(QSVFramesContext *ctx, QSVFrame *frame)
Definition: qsv.c:237
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c: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:1091
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:239
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:1096
#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:885
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
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:383
#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
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:72
#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
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:373
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:1049
#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:331
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:80
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:1236
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:1659
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:1592
int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1101
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:314
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:1992
#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:452
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:836
#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:358
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:71
#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
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:1012
#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:84
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
#define FFMAX3(a, b, c)
Definition: common.h:95
static int encode_frame(AVCodecContext *avctx, QSVEncContext *q, const AVFrame *frame)
Definition: qsvenc.c:1393
Predicted.
Definition: avutil.h:275
static int submit_frame(QSVEncContext *q, const AVFrame *frame, QSVFrame **new_frame)
Definition: qsvenc.c:1302
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1404
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:192
SetEncodeCtrlCB * set_encode_ctrl_cb
Definition: qsvenc.h:202
static void clear_unused_frames(QSVEncContext *q)
Definition: qsvenc.c:1247