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 "config_components.h"
25 
26 #include <string.h>
27 #include <sys/types.h>
28 #include <mfxvideo.h>
29 
30 #include "libavutil/common.h"
31 #include "libavutil/hwcontext.h"
33 #include "libavutil/mem.h"
34 #include "libavutil/log.h"
35 #include "libavutil/time.h"
36 #include "libavutil/imgutils.h"
37 #include "libavcodec/bytestream.h"
38 
39 #include "avcodec.h"
40 #include "internal.h"
41 #include "packet_internal.h"
42 #include "qsv.h"
43 #include "qsv_internal.h"
44 #include "qsvenc.h"
45 
46 struct profile_names {
47  mfxU16 profile;
48  const char *name;
49 };
50 
51 static const struct profile_names avc_profiles[] = {
52  { MFX_PROFILE_AVC_BASELINE, "avc baseline" },
53  { MFX_PROFILE_AVC_MAIN, "avc main" },
54  { MFX_PROFILE_AVC_EXTENDED, "avc extended" },
55  { MFX_PROFILE_AVC_HIGH, "avc high" },
56  { MFX_PROFILE_AVC_HIGH_422, "avc high 422" },
57  { MFX_PROFILE_AVC_CONSTRAINED_BASELINE, "avc constrained baseline" },
58  { MFX_PROFILE_AVC_CONSTRAINED_HIGH, "avc constrained high" },
59  { MFX_PROFILE_AVC_PROGRESSIVE_HIGH, "avc progressive high" },
60 };
61 
62 static const struct profile_names mpeg2_profiles[] = {
63  { MFX_PROFILE_MPEG2_SIMPLE, "mpeg2 simple" },
64  { MFX_PROFILE_MPEG2_MAIN, "mpeg2 main" },
65  { MFX_PROFILE_MPEG2_HIGH, "mpeg2 high" },
66 };
67 
68 static const struct profile_names hevc_profiles[] = {
69  { MFX_PROFILE_HEVC_MAIN, "hevc main" },
70  { MFX_PROFILE_HEVC_MAIN10, "hevc main10" },
71  { MFX_PROFILE_HEVC_MAINSP, "hevc mainsp" },
72  { MFX_PROFILE_HEVC_REXT, "hevc rext" },
73 #if QSV_VERSION_ATLEAST(1, 32)
74  { MFX_PROFILE_HEVC_SCC, "hevc scc" },
75 #endif
76 };
77 
78 static const struct profile_names vp9_profiles[] = {
79  { MFX_PROFILE_VP9_0, "vp9 0" },
80  { MFX_PROFILE_VP9_1, "vp9 1" },
81  { MFX_PROFILE_VP9_2, "vp9 2" },
82  { MFX_PROFILE_VP9_3, "vp9 3" },
83 };
84 
85 typedef struct QSVPacket {
87  mfxSyncPoint *sync;
88  mfxBitstream *bs;
89 } QSVPacket;
90 
91 static const char *print_profile(enum AVCodecID codec_id, mfxU16 profile)
92 {
93  const struct profile_names *profiles;
94  int i, num_profiles;
95 
96  switch (codec_id) {
97  case AV_CODEC_ID_H264:
99  num_profiles = FF_ARRAY_ELEMS(avc_profiles);
100  break;
101 
104  num_profiles = FF_ARRAY_ELEMS(mpeg2_profiles);
105  break;
106 
107  case AV_CODEC_ID_HEVC:
109  num_profiles = FF_ARRAY_ELEMS(hevc_profiles);
110  break;
111 
112  case AV_CODEC_ID_VP9:
114  num_profiles = FF_ARRAY_ELEMS(vp9_profiles);
115  break;
116 
117  default:
118  return "unknown";
119  }
120 
121  for (i = 0; i < num_profiles; i++)
122  if (profile == profiles[i].profile)
123  return profiles[i].name;
124 
125  return "unknown";
126 }
127 
128 static const struct {
129  mfxU16 rc_mode;
130  const char *name;
131 } rc_names[] = {
132  { MFX_RATECONTROL_CBR, "CBR" },
133  { MFX_RATECONTROL_VBR, "VBR" },
134  { MFX_RATECONTROL_CQP, "CQP" },
135 #if QSV_HAVE_AVBR
136  { MFX_RATECONTROL_AVBR, "AVBR" },
137 #endif
138  { MFX_RATECONTROL_LA, "LA" },
139  { MFX_RATECONTROL_ICQ, "ICQ" },
140  { MFX_RATECONTROL_LA_ICQ, "LA_ICQ" },
141 #if QSV_HAVE_VCM
142  { MFX_RATECONTROL_VCM, "VCM" },
143 #endif
144 #if !QSV_ONEVPL
145  { MFX_RATECONTROL_LA_EXT, "LA_EXT" },
146 #endif
147  { MFX_RATECONTROL_LA_HRD, "LA_HRD" },
148  { MFX_RATECONTROL_QVBR, "QVBR" },
149 };
150 
151 #define UPDATE_PARAM(a, b) \
152 do { \
153  if ((a) != (b)) { \
154  a = b; \
155  updated = 1; \
156  } \
157 } while (0) \
158 
159 static const char *print_ratecontrol(mfxU16 rc_mode)
160 {
161  int i;
162  for (i = 0; i < FF_ARRAY_ELEMS(rc_names); i++)
163  if (rc_mode == rc_names[i].rc_mode)
164  return rc_names[i].name;
165  return "unknown";
166 }
167 
168 static const char *print_threestate(mfxU16 val)
169 {
170  if (val == MFX_CODINGOPTION_ON)
171  return "ON";
172  else if (val == MFX_CODINGOPTION_OFF)
173  return "OFF";
174  return "unknown";
175 }
176 
178  mfxExtBuffer **coding_opts)
179 {
180  mfxInfoMFX *info = &q->param.mfx;
181 
182  // co is always at index 1
183  mfxExtCodingOption *co = (mfxExtCodingOption*)coding_opts[1];
184  mfxExtCodingOption2 *co2 = NULL;
185  mfxExtCodingOption3 *co3 = NULL;
186  mfxExtHEVCTiles *exthevctiles = NULL;
187  const char *tmp_str = NULL;
188 
189  if (q->co2_idx > 0)
190  co2 = (mfxExtCodingOption2*)coding_opts[q->co2_idx];
191 
192  if (q->co3_idx > 0)
193  co3 = (mfxExtCodingOption3*)coding_opts[q->co3_idx];
194 
195  if (q->exthevctiles_idx > 0)
196  exthevctiles = (mfxExtHEVCTiles *)coding_opts[q->exthevctiles_idx];
197 
198  av_log(avctx, AV_LOG_VERBOSE, "profile: %s; level: %"PRIu16"\n",
199  print_profile(avctx->codec_id, info->CodecProfile), info->CodecLevel);
200 
201  av_log(avctx, AV_LOG_VERBOSE,
202  "GopPicSize: %"PRIu16"; GopRefDist: %"PRIu16"; GopOptFlag:%s%s; IdrInterval: %"PRIu16"\n",
203  info->GopPicSize, info->GopRefDist,
204  info->GopOptFlag & MFX_GOP_CLOSED ? " closed" : "",
205  info->GopOptFlag & MFX_GOP_STRICT ? " strict" : "",
206  info->IdrInterval);
207 
208  av_log(avctx, AV_LOG_VERBOSE, "TargetUsage: %"PRIu16"; RateControlMethod: %s\n",
209  info->TargetUsage, print_ratecontrol(info->RateControlMethod));
210 
211  if (info->RateControlMethod == MFX_RATECONTROL_CBR ||
212  info->RateControlMethod == MFX_RATECONTROL_VBR
213 #if QSV_HAVE_VCM
214  || info->RateControlMethod == MFX_RATECONTROL_VCM
215 #endif
216  ) {
217  av_log(avctx, AV_LOG_VERBOSE,
218  "BufferSizeInKB: %"PRIu16"; InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
219  info->BufferSizeInKB, info->InitialDelayInKB, info->TargetKbps, info->MaxKbps, info->BRCParamMultiplier);
220  } else if (info->RateControlMethod == MFX_RATECONTROL_CQP) {
221  av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",
222  info->QPI, info->QPP, info->QPB);
223  }
224 #if QSV_HAVE_AVBR
225  else if (info->RateControlMethod == MFX_RATECONTROL_AVBR) {
226  av_log(avctx, AV_LOG_VERBOSE,
227  "TargetKbps: %"PRIu16"; Accuracy: %"PRIu16"; Convergence: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
228  info->TargetKbps, info->Accuracy, info->Convergence, info->BRCParamMultiplier);
229  }
230 #endif
231  else if (info->RateControlMethod == MFX_RATECONTROL_LA
232  || info->RateControlMethod == MFX_RATECONTROL_LA_HRD
233  ) {
234  av_log(avctx, AV_LOG_VERBOSE,
235  "TargetKbps: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
236  info->TargetKbps, info->BRCParamMultiplier);
237  } else if (info->RateControlMethod == MFX_RATECONTROL_ICQ ||
238  info->RateControlMethod == MFX_RATECONTROL_LA_ICQ)
239  av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);
240  av_log(avctx, AV_LOG_VERBOSE, "NumSlice: %"PRIu16"; NumRefFrame: %"PRIu16"\n",
241  info->NumSlice, info->NumRefFrame);
242  av_log(avctx, AV_LOG_VERBOSE, "RateDistortionOpt: %s\n",
243  print_threestate(co->RateDistortionOpt));
244 
245  av_log(avctx, AV_LOG_VERBOSE, "RecoveryPointSEI: %s\n", print_threestate(co->RecoveryPointSEI));
246  av_log(avctx, AV_LOG_VERBOSE, "VDENC: %s\n", print_threestate(info->LowPower));
247 
248  if (avctx->codec_id == AV_CODEC_ID_H264) {
249  av_log(avctx, AV_LOG_VERBOSE, "Entropy coding: %s; MaxDecFrameBuffering: %"PRIu16"\n",
250  co->CAVLC == MFX_CODINGOPTION_ON ? "CAVLC" : "CABAC", co->MaxDecFrameBuffering);
251  av_log(avctx, AV_LOG_VERBOSE,
252  "NalHrdConformance: %s; SingleSeiNalUnit: %s; VuiVclHrdParameters: %s VuiNalHrdParameters: %s\n",
253  print_threestate(co->NalHrdConformance), print_threestate(co->SingleSeiNalUnit),
254  print_threestate(co->VuiVclHrdParameters), print_threestate(co->VuiNalHrdParameters));
255  } else if ((avctx->codec_id == AV_CODEC_ID_HEVC) && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 28)) {
256  av_log(avctx, AV_LOG_VERBOSE,
257  "NalHrdConformance: %s; VuiNalHrdParameters: %s\n",
258  print_threestate(co->NalHrdConformance), print_threestate(co->VuiNalHrdParameters));
259  }
260 
261  av_log(avctx, AV_LOG_VERBOSE, "FrameRateExtD: %"PRIu32"; FrameRateExtN: %"PRIu32" \n",
262  info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);
263 
264  if (co2) {
265  if ((info->RateControlMethod == MFX_RATECONTROL_VBR && q->extbrc && q->look_ahead_depth > 0) ||
266  (info->RateControlMethod == MFX_RATECONTROL_LA) ||
267  (info->RateControlMethod == MFX_RATECONTROL_LA_HRD) ||
268  (info->RateControlMethod == MFX_RATECONTROL_LA_ICQ))
269  av_log(avctx, AV_LOG_VERBOSE, "LookAheadDepth: %"PRIu16"\n", co2->LookAheadDepth);
270 
271  av_log(avctx, AV_LOG_VERBOSE, "IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16"; IntRefQPDelta: %"PRId16"\n",
272  co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);
273 
274  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %d; MaxSliceSize: %d\n",
275  co2->MaxFrameSize, co2->MaxSliceSize);
276 
277  av_log(avctx, AV_LOG_VERBOSE,
278  "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
279  print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),
280  print_threestate(co2->ExtBRC));
281 
282  if (co2->Trellis & MFX_TRELLIS_OFF) {
283  av_log(avctx, AV_LOG_VERBOSE, "Trellis: off\n");
284  } else if (!co2->Trellis) {
285  av_log(avctx, AV_LOG_VERBOSE, "Trellis: auto\n");
286  } else {
287  char trellis_type[4];
288  int i = 0;
289  if (co2->Trellis & MFX_TRELLIS_I) trellis_type[i++] = 'I';
290  if (co2->Trellis & MFX_TRELLIS_P) trellis_type[i++] = 'P';
291  if (co2->Trellis & MFX_TRELLIS_B) trellis_type[i++] = 'B';
292  trellis_type[i] = 0;
293  av_log(avctx, AV_LOG_VERBOSE, "Trellis: %s\n", trellis_type);
294  }
295 
296  switch (co2->LookAheadDS) {
297  case MFX_LOOKAHEAD_DS_OFF: tmp_str = "off"; break;
298  case MFX_LOOKAHEAD_DS_2x: tmp_str = "2x"; break;
299  case MFX_LOOKAHEAD_DS_4x: tmp_str = "4x"; break;
300  default: tmp_str = "unknown"; break;
301  }
302  av_log(avctx, AV_LOG_VERBOSE,
303  "RepeatPPS: %s; NumMbPerSlice: %"PRIu16"; LookAheadDS: %s\n",
304  print_threestate(co2->RepeatPPS), co2->NumMbPerSlice, tmp_str);
305 
306  switch (co2->BRefType) {
307  case MFX_B_REF_OFF: tmp_str = "off"; break;
308  case MFX_B_REF_PYRAMID: tmp_str = "pyramid"; break;
309  default: tmp_str = "auto"; break;
310  }
311  av_log(avctx, AV_LOG_VERBOSE,
312  "AdaptiveI: %s; AdaptiveB: %s; BRefType:%s\n",
313  print_threestate(co2->AdaptiveI), print_threestate(co2->AdaptiveB), tmp_str);
314 
315  av_log(avctx, AV_LOG_VERBOSE,
316  "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",
317  co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
318  av_log(avctx, AV_LOG_VERBOSE, "DisableDeblockingIdc: %"PRIu32" \n", co2->DisableDeblockingIdc);
319  }
320 
321  if (co3) {
322  if (info->RateControlMethod == MFX_RATECONTROL_QVBR)
323  av_log(avctx, AV_LOG_VERBOSE, "QVBRQuality: %"PRIu16"\n", co3->QVBRQuality);
324 
325  switch (co3->PRefType) {
326  case MFX_P_REF_DEFAULT: av_log(avctx, AV_LOG_VERBOSE, "PRefType: default\n"); break;
327  case MFX_P_REF_SIMPLE: av_log(avctx, AV_LOG_VERBOSE, "PRefType: simple\n"); break;
328  case MFX_P_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "PRefType: pyramid\n"); break;
329  default: av_log(avctx, AV_LOG_VERBOSE, "PRefType: unknown\n"); break;
330  }
331 
332  if (avctx->codec_id == AV_CODEC_ID_HEVC)
333  av_log(avctx, AV_LOG_VERBOSE,"GPB: %s\n", print_threestate(co3->GPB));
334 
335  av_log(avctx, AV_LOG_VERBOSE, "TransformSkip: %s \n", print_threestate(co3->TransformSkip));
336  av_log(avctx, AV_LOG_VERBOSE, "IntRefCycleDist: %"PRId16"\n", co3->IntRefCycleDist);
337  av_log(avctx, AV_LOG_VERBOSE, "LowDelayBRC: %s\n", print_threestate(co3->LowDelayBRC));
338  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSizeI: %d; ", co3->MaxFrameSizeI);
339  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSizeP: %d\n", co3->MaxFrameSizeP);
340  av_log(avctx, AV_LOG_VERBOSE, "ScenarioInfo: %"PRId16"\n", co3->ScenarioInfo);
341  }
342 
343  if (exthevctiles) {
344  av_log(avctx, AV_LOG_VERBOSE, "NumTileColumns: %"PRIu16"; NumTileRows: %"PRIu16"\n",
345  exthevctiles->NumTileColumns, exthevctiles->NumTileRows);
346  }
347 }
348 
350  mfxExtBuffer **coding_opts)
351 {
352  mfxInfoMFX *info = &q->param.mfx;
353  mfxExtVP9Param *vp9_param = NULL;
354  mfxExtCodingOption2 *co2 = NULL;
355 
356  if (q->vp9_idx >= 0)
357  vp9_param = (mfxExtVP9Param *)coding_opts[q->vp9_idx];
358 
359  if (q->co2_idx >= 0)
360  co2 = (mfxExtCodingOption2*)coding_opts[q->co2_idx];
361 
362  av_log(avctx, AV_LOG_VERBOSE, "profile: %s \n",
363  print_profile(avctx->codec_id, info->CodecProfile));
364 
365  av_log(avctx, AV_LOG_VERBOSE,
366  "GopPicSize: %"PRIu16"; GopRefDist: %"PRIu16"; GopOptFlag:%s%s; IdrInterval: %"PRIu16"\n",
367  info->GopPicSize, info->GopRefDist,
368  info->GopOptFlag & MFX_GOP_CLOSED ? " closed" : "",
369  info->GopOptFlag & MFX_GOP_STRICT ? " strict" : "",
370  info->IdrInterval);
371 
372  av_log(avctx, AV_LOG_VERBOSE, "TargetUsage: %"PRIu16"; RateControlMethod: %s\n",
373  info->TargetUsage, print_ratecontrol(info->RateControlMethod));
374 
375  if (info->RateControlMethod == MFX_RATECONTROL_CBR ||
376  info->RateControlMethod == MFX_RATECONTROL_VBR) {
377  av_log(avctx, AV_LOG_VERBOSE,
378  "BufferSizeInKB: %"PRIu16"; InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
379  info->BufferSizeInKB, info->InitialDelayInKB, info->TargetKbps, info->MaxKbps, info->BRCParamMultiplier);
380  } else if (info->RateControlMethod == MFX_RATECONTROL_CQP) {
381  av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",
382  info->QPI, info->QPP, info->QPB);
383  }
384  else if (info->RateControlMethod == MFX_RATECONTROL_ICQ) {
385  av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);
386  }
387  else {
388  av_log(avctx, AV_LOG_VERBOSE, "Unsupported ratecontrol method: %d \n", info->RateControlMethod);
389  }
390 
391  av_log(avctx, AV_LOG_VERBOSE, "NumRefFrame: %"PRIu16"\n", info->NumRefFrame);
392  av_log(avctx, AV_LOG_VERBOSE, "FrameRateExtD: %"PRIu32"; FrameRateExtN: %"PRIu32" \n",
393  info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);
394 
395  if (co2) {
396  av_log(avctx, AV_LOG_VERBOSE,
397  "IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16"; IntRefQPDelta: %"PRId16"\n",
398  co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);
399 
400  av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %d\n", co2->MaxFrameSize);
401 
402  av_log(avctx, AV_LOG_VERBOSE,
403  "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
404  print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),
405  print_threestate(co2->ExtBRC));
406 
407  av_log(avctx, AV_LOG_VERBOSE, "VDENC: %s\n", print_threestate(info->LowPower));
408 
409  av_log(avctx, AV_LOG_VERBOSE,
410  "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",
411  co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
412  }
413 
414  if (vp9_param) {
415  av_log(avctx, AV_LOG_VERBOSE, "WriteIVFHeaders: %s \n",
416  print_threestate(vp9_param->WriteIVFHeaders));
417  }
418 }
419 
421 {
422  mfxInfoMFX *info = &q->param.mfx;
423 
424  av_log(avctx, AV_LOG_VERBOSE, "Interleaved: %"PRIu16" \n", info->Interleaved);
425  av_log(avctx, AV_LOG_VERBOSE, "Quality: %"PRIu16" \n", info->Quality);
426  av_log(avctx, AV_LOG_VERBOSE, "RestartInterval: %"PRIu16" \n", info->RestartInterval);
427 
428  av_log(avctx, AV_LOG_VERBOSE, "FrameRateExtD: %"PRIu32"; FrameRateExtN: %"PRIu32" \n",
429  info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);
430 }
431 
433 {
434  const char *rc_desc;
435  mfxU16 rc_mode;
436 
437  int want_la = q->look_ahead;
438  int want_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
439  int want_vcm = q->vcm;
440 
441  if (want_vcm && !QSV_HAVE_VCM) {
442  av_log(avctx, AV_LOG_ERROR,
443  "VCM ratecontrol mode requested, but is not supported by this SDK version\n");
444  return AVERROR(ENOSYS);
445  }
446 
447  if (want_la + want_qscale + want_vcm > 1) {
448  av_log(avctx, AV_LOG_ERROR,
449  "More than one of: { constant qscale, lookahead, VCM } requested, "
450  "only one of them can be used at a time.\n");
451  return AVERROR(EINVAL);
452  }
453 
454  if (want_qscale) {
455  rc_mode = MFX_RATECONTROL_CQP;
456  rc_desc = "constant quantization parameter (CQP)";
457  }
458 #if QSV_HAVE_VCM
459  else if (want_vcm) {
460  rc_mode = MFX_RATECONTROL_VCM;
461  rc_desc = "video conferencing mode (VCM)";
462  }
463 #endif
464  else if (want_la) {
465  rc_mode = MFX_RATECONTROL_LA;
466  rc_desc = "VBR with lookahead (LA)";
467 
468  if (avctx->global_quality > 0) {
469  rc_mode = MFX_RATECONTROL_LA_ICQ;
470  rc_desc = "intelligent constant quality with lookahead (LA_ICQ)";
471  }
472  }
473  else if (avctx->global_quality > 0 && !avctx->rc_max_rate) {
474  rc_mode = MFX_RATECONTROL_ICQ;
475  rc_desc = "intelligent constant quality (ICQ)";
476  }
477  else if (avctx->rc_max_rate == avctx->bit_rate) {
478  rc_mode = MFX_RATECONTROL_CBR;
479  rc_desc = "constant bitrate (CBR)";
480  }
481 #if QSV_HAVE_AVBR
482  else if (!avctx->rc_max_rate &&
483  (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_HEVC) &&
484  q->avbr_accuracy &&
485  q->avbr_convergence) {
486  rc_mode = MFX_RATECONTROL_AVBR;
487  rc_desc = "average variable bitrate (AVBR)";
488  }
489 #endif
490  else if (avctx->global_quality > 0) {
491  rc_mode = MFX_RATECONTROL_QVBR;
492  rc_desc = "constant quality with VBR algorithm (QVBR)";
493  }
494  else {
495  rc_mode = MFX_RATECONTROL_VBR;
496  rc_desc = "variable bitrate (VBR)";
497  }
498 
499  q->param.mfx.RateControlMethod = rc_mode;
500  av_log(avctx, AV_LOG_VERBOSE, "Using the %s ratecontrol method\n", rc_desc);
501 
502  return 0;
503 }
504 
506 {
507  mfxVideoParam param_out = { .mfx.CodecId = q->param.mfx.CodecId };
508  mfxStatus ret;
509 
510 #define UNMATCH(x) (param_out.mfx.x != q->param.mfx.x)
511 
512  ret = MFXVideoENCODE_Query(q->session, &q->param, &param_out);
513 
514  if (ret < 0) {
515  if (UNMATCH(CodecId))
516  av_log(avctx, AV_LOG_ERROR, "Current codec type is unsupported\n");
517  if (UNMATCH(CodecProfile))
518  av_log(avctx, AV_LOG_ERROR, "Current profile is unsupported\n");
519  if (UNMATCH(RateControlMethod))
520  av_log(avctx, AV_LOG_ERROR, "Selected ratecontrol mode is unsupported\n");
521  if (UNMATCH(LowPower))
522  av_log(avctx, AV_LOG_ERROR, "Low power mode is unsupported\n");
523  if (UNMATCH(FrameInfo.FrameRateExtN) || UNMATCH(FrameInfo.FrameRateExtD))
524  av_log(avctx, AV_LOG_ERROR, "Current frame rate is unsupported\n");
525  if (UNMATCH(FrameInfo.PicStruct))
526  av_log(avctx, AV_LOG_ERROR, "Current picture structure is unsupported\n");
527  if (UNMATCH(FrameInfo.Width) || UNMATCH(FrameInfo.Height))
528  av_log(avctx, AV_LOG_ERROR, "Current resolution is unsupported\n");
529  if (UNMATCH(FrameInfo.FourCC))
530  av_log(avctx, AV_LOG_ERROR, "Current pixel format is unsupported\n");
531  return 0;
532  }
533  return 1;
534 }
535 
537 {
538  enum AVPixelFormat sw_format = avctx->pix_fmt == AV_PIX_FMT_QSV ?
539  avctx->sw_pix_fmt : avctx->pix_fmt;
540  const AVPixFmtDescriptor *desc;
541  int ret;
542 
544  if (ret < 0)
545  return AVERROR_BUG;
546  q->param.mfx.CodecId = ret;
547 
548  if (avctx->level > 0)
549  q->param.mfx.CodecLevel = avctx->level;
550  q->param.mfx.CodecProfile = q->profile;
551 
552  desc = av_pix_fmt_desc_get(sw_format);
553  if (!desc)
554  return AVERROR_BUG;
555 
556  ret = ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC);
557  if (ret < 0)
558  return AVERROR_BUG;
559 
560  q->param.mfx.FrameInfo.CropX = 0;
561  q->param.mfx.FrameInfo.CropY = 0;
562  q->param.mfx.FrameInfo.CropW = avctx->width;
563  q->param.mfx.FrameInfo.CropH = avctx->height;
564  q->param.mfx.FrameInfo.AspectRatioW = avctx->sample_aspect_ratio.num;
565  q->param.mfx.FrameInfo.AspectRatioH = avctx->sample_aspect_ratio.den;
566  q->param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420 +
567  !desc->log2_chroma_w + !desc->log2_chroma_h;
568  q->param.mfx.FrameInfo.BitDepthLuma = desc->comp[0].depth;
569  q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
570  q->param.mfx.FrameInfo.Shift = desc->comp[0].depth > 8;
571 
572  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, 16);
573  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, 16);
574 
575  if (avctx->hw_frames_ctx) {
576  AVHWFramesContext *frames_ctx = (AVHWFramesContext *)avctx->hw_frames_ctx->data;
577  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
578  q->param.mfx.FrameInfo.Width = frames_hwctx->surfaces[0].Info.Width;
579  q->param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;
580  }
581 
582  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
583  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
584  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
585  } else {
586  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
587  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
588  }
589 
590  q->param.mfx.Interleaved = 1;
591  q->param.mfx.Quality = av_clip(avctx->global_quality, 1, 100);
592  q->param.mfx.RestartInterval = 0;
593 
594  q->width_align = 16;
595  q->height_align = 16;
596 
597  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, q->width_align);
598  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, q->height_align);
599 
600  return 0;
601 }
602 
604 {
605  enum AVPixelFormat sw_format = avctx->pix_fmt == AV_PIX_FMT_QSV ?
606  avctx->sw_pix_fmt : avctx->pix_fmt;
607  const AVPixFmtDescriptor *desc;
608  float quant;
609  int target_bitrate_kbps, max_bitrate_kbps, brc_param_multiplier;
610  int buffer_size_in_kilobytes, initial_delay_in_kilobytes;
611  int ret;
612 
614  if (ret < 0)
615  return AVERROR_BUG;
616  q->param.mfx.CodecId = ret;
617 
618  if (avctx->level > 0)
619  q->param.mfx.CodecLevel = avctx->level;
620 
622  avctx->compression_level = q->preset;
623  } else if (avctx->compression_level >= 0) {
624  if (avctx->compression_level > MFX_TARGETUSAGE_BEST_SPEED) {
625  av_log(avctx, AV_LOG_WARNING, "Invalid compression level: "
626  "valid range is 0-%d, using %d instead\n",
627  MFX_TARGETUSAGE_BEST_SPEED, MFX_TARGETUSAGE_BEST_SPEED);
628  avctx->compression_level = MFX_TARGETUSAGE_BEST_SPEED;
629  }
630  }
631 
632  if (q->low_power == 1) {
633  q->param.mfx.LowPower = MFX_CODINGOPTION_ON;
634  } else if (q->low_power == -1)
635  q->param.mfx.LowPower = MFX_CODINGOPTION_UNKNOWN;
636  else
637  q->param.mfx.LowPower = MFX_CODINGOPTION_OFF;
638 
639  q->param.mfx.CodecProfile = q->profile;
640  q->param.mfx.TargetUsage = avctx->compression_level;
641  q->param.mfx.GopPicSize = FFMAX(0, avctx->gop_size);
642  q->old_gop_size = avctx->gop_size;
643  q->param.mfx.GopRefDist = FFMAX(-1, avctx->max_b_frames) + 1;
644  q->param.mfx.GopOptFlag = avctx->flags & AV_CODEC_FLAG_CLOSED_GOP ?
645  MFX_GOP_CLOSED : MFX_GOP_STRICT;
646  q->param.mfx.IdrInterval = q->idr_interval;
647  q->param.mfx.NumSlice = avctx->slices;
648  q->param.mfx.NumRefFrame = FFMAX(0, avctx->refs);
649  q->param.mfx.EncodedOrder = 0;
650  q->param.mfx.BufferSizeInKB = 0;
651 
652  desc = av_pix_fmt_desc_get(sw_format);
653  if (!desc)
654  return AVERROR_BUG;
655 
656  ret = ff_qsv_map_pixfmt(sw_format, &q->param.mfx.FrameInfo.FourCC);
657  if (ret < 0)
658  return AVERROR_BUG;
659 
660  q->param.mfx.FrameInfo.CropX = 0;
661  q->param.mfx.FrameInfo.CropY = 0;
662  q->param.mfx.FrameInfo.CropW = avctx->width;
663  q->param.mfx.FrameInfo.CropH = avctx->height;
664  q->param.mfx.FrameInfo.AspectRatioW = avctx->sample_aspect_ratio.num;
665  q->param.mfx.FrameInfo.AspectRatioH = avctx->sample_aspect_ratio.den;
666  q->param.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420 +
667  !desc->log2_chroma_w + !desc->log2_chroma_h;
668  q->param.mfx.FrameInfo.BitDepthLuma = desc->comp[0].depth;
669  q->param.mfx.FrameInfo.BitDepthChroma = desc->comp[0].depth;
670  q->param.mfx.FrameInfo.Shift = desc->comp[0].depth > 8;
671 
672  // If the minor version is greater than or equal to 19,
673  // then can use the same alignment settings as H.264 for HEVC
674  q->width_align = (avctx->codec_id != AV_CODEC_ID_HEVC ||
675  QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 19)) ? 16 : 32;
676  q->param.mfx.FrameInfo.Width = FFALIGN(avctx->width, q->width_align);
677 
678  if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
679  // it is important that PicStruct be setup correctly from the
680  // start--otherwise, encoding doesn't work and results in a bunch
681  // of incompatible video parameter errors
682  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_FIELD_TFF;
683  // height alignment always must be 32 for interlaced video
684  q->height_align = 32;
685  } else {
686  q->param.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
687  // for progressive video, the height should be aligned to 16 for
688  // H.264. For HEVC, depending on the version of MFX, it should be
689  // either 32 or 16. The lower number is better if possible.
690  q->height_align = avctx->codec_id == AV_CODEC_ID_HEVC ? 32 : 16;
691  }
692  q->param.mfx.FrameInfo.Height = FFALIGN(avctx->height, q->height_align);
693 
694  if (avctx->hw_frames_ctx) {
695  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
696  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
697  q->param.mfx.FrameInfo.Width = frames_hwctx->surfaces[0].Info.Width;
698  q->param.mfx.FrameInfo.Height = frames_hwctx->surfaces[0].Info.Height;
699  }
700 
701  if (avctx->framerate.den > 0 && avctx->framerate.num > 0) {
702  q->param.mfx.FrameInfo.FrameRateExtN = avctx->framerate.num;
703  q->param.mfx.FrameInfo.FrameRateExtD = avctx->framerate.den;
704  } else {
705  q->param.mfx.FrameInfo.FrameRateExtN = avctx->time_base.den;
706  q->param.mfx.FrameInfo.FrameRateExtD = avctx->time_base.num;
707  }
708 
709  ret = select_rc_mode(avctx, q);
710  if (ret < 0)
711  return ret;
712 
713  //libmfx BRC parameters are 16 bits thus maybe overflow, then BRCParamMultiplier is needed
714  buffer_size_in_kilobytes = avctx->rc_buffer_size / 8000;
715  initial_delay_in_kilobytes = avctx->rc_initial_buffer_occupancy / 8000;
716  target_bitrate_kbps = avctx->bit_rate / 1000;
717  max_bitrate_kbps = avctx->rc_max_rate / 1000;
718  brc_param_multiplier = (FFMAX(FFMAX3(target_bitrate_kbps, max_bitrate_kbps, buffer_size_in_kilobytes),
719  initial_delay_in_kilobytes) + 0x10000) / 0x10000;
720 
721  switch (q->param.mfx.RateControlMethod) {
722  case MFX_RATECONTROL_CBR:
723  case MFX_RATECONTROL_VBR:
724  if (q->extbrc) {
725  q->extco2.LookAheadDepth = q->look_ahead_depth;
726  }
727 #if QSV_HAVE_VCM
728  case MFX_RATECONTROL_VCM:
729 #endif
730  case MFX_RATECONTROL_QVBR:
731  q->param.mfx.BufferSizeInKB = buffer_size_in_kilobytes / brc_param_multiplier;
732  q->param.mfx.InitialDelayInKB = initial_delay_in_kilobytes / brc_param_multiplier;
733  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
734  q->param.mfx.MaxKbps = max_bitrate_kbps / brc_param_multiplier;
735  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
736  if (q->param.mfx.RateControlMethod == MFX_RATECONTROL_QVBR)
737  q->extco3.QVBRQuality = av_clip(avctx->global_quality, 0, 51);
738  break;
739  case MFX_RATECONTROL_CQP:
740  quant = avctx->global_quality / FF_QP2LAMBDA;
741 
742  q->param.mfx.QPI = av_clip(quant * fabs(avctx->i_quant_factor) + avctx->i_quant_offset, 0, 51);
743  q->param.mfx.QPP = av_clip(quant, 0, 51);
744  q->param.mfx.QPB = av_clip(quant * fabs(avctx->b_quant_factor) + avctx->b_quant_offset, 0, 51);
750 
751  break;
752 #if QSV_HAVE_AVBR
753  case MFX_RATECONTROL_AVBR:
754  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
755  q->param.mfx.Convergence = q->avbr_convergence;
756  q->param.mfx.Accuracy = q->avbr_accuracy;
757  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
758  break;
759 #endif
760  case MFX_RATECONTROL_LA:
761  q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
762  q->extco2.LookAheadDepth = q->look_ahead_depth;
763  q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
764  break;
765  case MFX_RATECONTROL_LA_ICQ:
766  q->extco2.LookAheadDepth = q->look_ahead_depth;
767  case MFX_RATECONTROL_ICQ:
768  q->param.mfx.ICQQuality = av_clip(avctx->global_quality, 1, 51);
769  break;
770  }
771 
772  // The HEVC encoder plugin currently fails with some old libmfx version if coding options
773  // are provided. Can't find the extract libmfx version which fixed it, just enable it from
774  // V1.28 in order to keep compatibility security.
775  if (((avctx->codec_id != AV_CODEC_ID_HEVC) || QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 28))
776  && (avctx->codec_id != AV_CODEC_ID_VP9)) {
777  q->extco.Header.BufferId = MFX_EXTBUFF_CODING_OPTION;
778  q->extco.Header.BufferSz = sizeof(q->extco);
779 
780  q->extco.PicTimingSEI = q->pic_timing_sei ?
781  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_UNKNOWN;
782 
783  if (q->rdo >= 0)
784  q->extco.RateDistortionOpt = q->rdo > 0 ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
785 
786  if (avctx->codec_id == AV_CODEC_ID_H264) {
787  q->extco.CAVLC = q->cavlc ? MFX_CODINGOPTION_ON
788  : MFX_CODINGOPTION_UNKNOWN;
789 
791  q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?
792  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
793 
794  if (q->single_sei_nal_unit >= 0)
795  q->extco.SingleSeiNalUnit = q->single_sei_nal_unit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
796  if (q->recovery_point_sei >= 0)
797  q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
798  q->extco.MaxDecFrameBuffering = q->max_dec_frame_buffering;
799  q->extco.AUDelimiter = q->aud ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
800  } else if (avctx->codec_id == AV_CODEC_ID_HEVC) {
802  q->extco.NalHrdConformance = avctx->strict_std_compliance > FF_COMPLIANCE_NORMAL ?
803  MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
804 
805  if (q->recovery_point_sei >= 0)
806  q->extco.RecoveryPointSEI = q->recovery_point_sei ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
807 
808  q->extco.AUDelimiter = q->aud ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
809  }
810 
811  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco;
812 
813  if (avctx->codec_id == AV_CODEC_ID_H264) {
814  if (q->bitrate_limit >= 0)
815  q->extco2.BitrateLimit = q->bitrate_limit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
816 
817  if (avctx->trellis >= 0)
818  q->extco2.Trellis = (avctx->trellis == 0) ? MFX_TRELLIS_OFF : (MFX_TRELLIS_I | MFX_TRELLIS_P | MFX_TRELLIS_B);
819  else
820  q->extco2.Trellis = MFX_TRELLIS_UNKNOWN;
821 
822  q->extco2.LookAheadDS = q->look_ahead_downsampling;
823  q->extco2.RepeatPPS = q->repeat_pps ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
824  }
825 
826  if (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_HEVC) {
827  if (q->extbrc >= 0)
828  q->extco2.ExtBRC = q->extbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
829  if (q->max_frame_size >= 0)
830  q->extco2.MaxFrameSize = q->max_frame_size;
832  if (q->int_ref_type >= 0)
833  q->extco2.IntRefType = q->int_ref_type;
835  if (q->int_ref_cycle_size >= 0)
836  q->extco2.IntRefCycleSize = q->int_ref_cycle_size;
838  if (q->int_ref_qp_delta != INT16_MIN)
839  q->extco2.IntRefQPDelta = q->int_ref_qp_delta;
841  if (q->max_slice_size >= 0)
842  q->extco2.MaxSliceSize = q->max_slice_size;
843  q->extco2.DisableDeblockingIdc = q->dblk_idc;
844 
845  if (q->b_strategy >= 0)
846  q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
847  if (q->adaptive_i >= 0)
848  q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
849  if (q->adaptive_b >= 0)
850  q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
851  if ((avctx->qmin >= 0 && avctx->qmax >= 0 && avctx->qmin > avctx->qmax) ||
852  (q->max_qp_i >= 0 && q->min_qp_i >= 0 && q->min_qp_i > q->max_qp_i) ||
853  (q->max_qp_p >= 0 && q->min_qp_p >= 0 && q->min_qp_p > q->max_qp_p) ||
854  (q->max_qp_b >= 0 && q->min_qp_b >= 0 && q->min_qp_b > q->max_qp_b)) {
855  av_log(avctx, AV_LOG_ERROR,
856  "qmin and or qmax are set but invalid,"
857  " please make sure min <= max\n");
858  return AVERROR(EINVAL);
859  }
860  if (avctx->qmin >= 0) {
861  q->extco2.MinQPI = avctx->qmin > 51 ? 51 : avctx->qmin;
862  q->extco2.MinQPP = q->extco2.MinQPB = q->extco2.MinQPI;
863  }
864  q->old_qmin = avctx->qmin;
865  if (avctx->qmax >= 0) {
866  q->extco2.MaxQPI = avctx->qmax > 51 ? 51 : avctx->qmax;
867  q->extco2.MaxQPP = q->extco2.MaxQPB = q->extco2.MaxQPI;
868  }
869  q->old_qmax = avctx->qmax;
870  if (q->min_qp_i >= 0)
871  q->extco2.MinQPI = q->min_qp_i > 51 ? 51 : q->min_qp_i;
872  q->old_min_qp_i = q->min_qp_i;
873  if (q->max_qp_i >= 0)
874  q->extco2.MaxQPI = q->max_qp_i > 51 ? 51 : q->max_qp_i;
875  q->old_max_qp_i = q->max_qp_i;
876  if (q->min_qp_p >= 0)
877  q->extco2.MinQPP = q->min_qp_p > 51 ? 51 : q->min_qp_p;
878  q->old_min_qp_p = q->min_qp_p;
879  if (q->max_qp_p >= 0)
880  q->extco2.MaxQPP = q->max_qp_p > 51 ? 51 : q->max_qp_p;
881  q->old_max_qp_p = q->max_qp_p;
882  if (q->min_qp_b >= 0)
883  q->extco2.MinQPB = q->min_qp_b > 51 ? 51 : q->min_qp_b;
884  q->old_min_qp_b = q->min_qp_b;
885  if (q->max_qp_b >= 0)
886  q->extco2.MaxQPB = q->max_qp_b > 51 ? 51 : q->max_qp_b;
887  q->old_max_qp_b = q->max_qp_b;
888  if (q->mbbrc >= 0)
889  q->extco2.MBBRC = q->mbbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
890 
891  q->extco2.Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
892  q->extco2.Header.BufferSz = sizeof(q->extco2);
893 
894  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
895  }
896 
897  if (avctx->codec_id == AV_CODEC_ID_H264) {
898 #if QSV_HAVE_MF
899  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 25)) {
900  q->extmfp.Header.BufferId = MFX_EXTBUFF_MULTI_FRAME_PARAM;
901  q->extmfp.Header.BufferSz = sizeof(q->extmfp);
902 
903  q->extmfp.MFMode = q->mfmode;
904  av_log(avctx,AV_LOG_VERBOSE,"MFMode:%d\n", q->extmfp.MFMode);
905  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extmfp;
906  }
907 #endif
908  }
909  q->extco3.Header.BufferId = MFX_EXTBUFF_CODING_OPTION3;
910  q->extco3.Header.BufferSz = sizeof(q->extco3);
911 
912  if (avctx->codec_id == AV_CODEC_ID_HEVC ||
913  avctx->codec_id == AV_CODEC_ID_H264) {
914  switch (q->p_strategy) {
915  case 0:
916  q->extco3.PRefType = MFX_P_REF_DEFAULT;
917  break;
918  case 1:
919  q->extco3.PRefType = MFX_P_REF_SIMPLE;
920  break;
921  case 2:
922  q->extco3.PRefType = MFX_P_REF_PYRAMID;
923  break;
924  default:
925  q->extco3.PRefType = MFX_P_REF_DEFAULT;
926  av_log(avctx, AV_LOG_WARNING,
927  "invalid p_strategy, set to default\n");
928  break;
929  }
930  if (q->extco3.PRefType == MFX_P_REF_PYRAMID &&
931  avctx->max_b_frames != 0) {
932  av_log(avctx, AV_LOG_WARNING,
933  "Please set max_b_frames(-bf) to 0 to enable P-pyramid\n");
934  }
935  if (q->int_ref_cycle_dist >= 0)
936  q->extco3.IntRefCycleDist = q->int_ref_cycle_dist;
938  if (q->low_delay_brc >= 0)
939  q->extco3.LowDelayBRC = q->low_delay_brc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
941  if (q->max_frame_size_i >= 0)
942  q->extco3.MaxFrameSizeI = q->max_frame_size_i;
943  if (q->max_frame_size_p >= 0)
944  q->extco3.MaxFrameSizeP = q->max_frame_size_p;
945 
946  q->extco3.ScenarioInfo = q->scenario;
947  }
948 
949  if (avctx->codec_id == AV_CODEC_ID_HEVC) {
950  if (q->transform_skip >= 0)
951  q->extco3.TransformSkip = q->transform_skip ? MFX_CODINGOPTION_ON :
952  MFX_CODINGOPTION_OFF;
953  else
954  q->extco3.TransformSkip = MFX_CODINGOPTION_UNKNOWN;
955  q->extco3.GPB = q->gpb ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
956  }
957  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco3;
958  }
959 
960  if (avctx->codec_id == AV_CODEC_ID_VP9) {
961  q->extvp9param.Header.BufferId = MFX_EXTBUFF_VP9_PARAM;
962  q->extvp9param.Header.BufferSz = sizeof(q->extvp9param);
963  q->extvp9param.WriteIVFHeaders = MFX_CODINGOPTION_OFF;
964 #if QSV_HAVE_EXT_VP9_TILES
965  q->extvp9param.NumTileColumns = q->tile_cols;
966  q->extvp9param.NumTileRows = q->tile_rows;
967 #endif
968  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extvp9param;
969  }
970 
971  if (avctx->codec_id == AV_CODEC_ID_HEVC) {
972  q->exthevctiles.Header.BufferId = MFX_EXTBUFF_HEVC_TILES;
973  q->exthevctiles.Header.BufferSz = sizeof(q->exthevctiles);
974  q->exthevctiles.NumTileColumns = q->tile_cols;
975  q->exthevctiles.NumTileRows = q->tile_rows;
976  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->exthevctiles;
977  }
978 
979  q->extvsi.VideoFullRange = (avctx->color_range == AVCOL_RANGE_JPEG);
980  q->extvsi.ColourDescriptionPresent = 0;
981 
982  if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
983  avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
984  avctx->colorspace != AVCOL_SPC_UNSPECIFIED) {
985  q->extvsi.ColourDescriptionPresent = 1;
986  q->extvsi.ColourPrimaries = avctx->color_primaries;
987  q->extvsi.TransferCharacteristics = avctx->color_trc;
988  q->extvsi.MatrixCoefficients = avctx->colorspace;
989  }
990 
991  if ((avctx->codec_id != AV_CODEC_ID_VP9) && (q->extvsi.VideoFullRange || q->extvsi.ColourDescriptionPresent)) {
992  q->extvsi.Header.BufferId = MFX_EXTBUFF_VIDEO_SIGNAL_INFO;
993  q->extvsi.Header.BufferSz = sizeof(q->extvsi);
994  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extvsi;
995  }
996 
997  if (!check_enc_param(avctx,q)) {
998  av_log(avctx, AV_LOG_ERROR,
999  "some encoding parameters are not supported by the QSV "
1000  "runtime. Please double check the input parameters.\n");
1001  return AVERROR(ENOSYS);
1002  }
1003 
1004  return 0;
1005 }
1006 
1008 {
1009  int ret = 0;
1010 
1011  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
1012  if (ret < 0)
1013  return ff_qsv_print_error(avctx, ret,
1014  "Error calling GetVideoParam");
1015 
1016  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
1017 
1018  // for qsv mjpeg the return value maybe 0 so alloc the buffer
1019  if (q->packet_size == 0)
1020  q->packet_size = q->param.mfx.FrameInfo.Height * q->param.mfx.FrameInfo.Width * 4;
1021 
1022  dump_video_mjpeg_param(avctx, q);
1023 
1024  return 0;
1025 }
1026 
1028 {
1029  int ret = 0;
1030  mfxExtVP9Param vp9_extend_buf = {
1031  .Header.BufferId = MFX_EXTBUFF_VP9_PARAM,
1032  .Header.BufferSz = sizeof(vp9_extend_buf),
1033  };
1034 
1035  mfxExtCodingOption2 co2 = {
1036  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
1037  .Header.BufferSz = sizeof(co2),
1038  };
1039 
1040  mfxExtCodingOption3 co3 = {
1041  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
1042  .Header.BufferSz = sizeof(co3),
1043  };
1044 
1045  mfxExtBuffer *ext_buffers[3];
1046  int ext_buf_num = 0;
1047 
1048  q->co2_idx = q->co3_idx = q->vp9_idx = -1;
1049 
1050  // It is possible the runtime doesn't support the given ext buffer
1051  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 6)) {
1052  q->co2_idx = ext_buf_num;
1053  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;
1054  }
1055 
1056  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 11)) {
1057  q->co3_idx = ext_buf_num;
1058  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;
1059  }
1060 
1061  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 26)) {
1062  q->vp9_idx = ext_buf_num;
1063  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&vp9_extend_buf;
1064  }
1065 
1066  q->param.ExtParam = ext_buffers;
1067  q->param.NumExtParam = ext_buf_num;
1068 
1069  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
1070  if (ret < 0)
1071  return ff_qsv_print_error(avctx, ret,
1072  "Error calling GetVideoParam");
1073 
1074  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
1075 
1076  dump_video_vp9_param(avctx, q, ext_buffers);
1077 
1078  return 0;
1079 }
1080 
1082 {
1083  AVCPBProperties *cpb_props;
1084 
1085  uint8_t sps_buf[512];
1086  uint8_t pps_buf[128];
1087 
1088  mfxExtCodingOptionSPSPPS extradata = {
1089  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_SPSPPS,
1090  .Header.BufferSz = sizeof(extradata),
1091  .SPSBuffer = sps_buf, .SPSBufSize = sizeof(sps_buf),
1092  .PPSBuffer = pps_buf, .PPSBufSize = sizeof(pps_buf)
1093  };
1094 
1095  mfxExtCodingOption co = {
1096  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
1097  .Header.BufferSz = sizeof(co),
1098  };
1099  mfxExtCodingOption2 co2 = {
1100  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
1101  .Header.BufferSz = sizeof(co2),
1102  };
1103  mfxExtCodingOption3 co3 = {
1104  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
1105  .Header.BufferSz = sizeof(co3),
1106  };
1107 
1108  uint8_t vps_buf[128];
1109  mfxExtCodingOptionVPS extradata_vps = {
1110  .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_VPS,
1111  .Header.BufferSz = sizeof(extradata_vps),
1112  .VPSBuffer = vps_buf,
1113  .VPSBufSize = sizeof(vps_buf),
1114  };
1115 
1116  mfxExtHEVCTiles hevc_tile_buf = {
1117  .Header.BufferId = MFX_EXTBUFF_HEVC_TILES,
1118  .Header.BufferSz = sizeof(hevc_tile_buf),
1119  };
1120 
1121  mfxExtBuffer *ext_buffers[6];
1122 
1123  int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
1124  int ret, ext_buf_num = 0, extradata_offset = 0;
1125 
1126  q->co2_idx = q->co3_idx = q->exthevctiles_idx = -1;
1127  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata;
1128  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co;
1129 
1130  // It is possible the runtime doesn't support the given ext buffer
1131  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 6)) {
1132  q->co2_idx = ext_buf_num;
1133  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;
1134  }
1135 
1136  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 11)) {
1137  q->co3_idx = ext_buf_num;
1138  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;
1139  }
1140 
1141  q->hevc_vps = ((avctx->codec_id == AV_CODEC_ID_HEVC) && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 17));
1142  if (q->hevc_vps)
1143  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata_vps;
1144  if (avctx->codec_id == AV_CODEC_ID_HEVC && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 13)) {
1145  q->exthevctiles_idx = ext_buf_num;
1146  ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&hevc_tile_buf;
1147  }
1148 
1149  q->param.ExtParam = ext_buffers;
1150  q->param.NumExtParam = ext_buf_num;
1151 
1152  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
1153  if (ret < 0)
1154  return ff_qsv_print_error(avctx, ret,
1155  "Error calling GetVideoParam");
1156 
1157  q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
1158 
1159  if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)
1160  || (q->hevc_vps && !extradata_vps.VPSBufSize)
1161  ) {
1162  av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
1163  return AVERROR_UNKNOWN;
1164  }
1165 
1166  avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
1167  avctx->extradata_size += q->hevc_vps * extradata_vps.VPSBufSize;
1168 
1170  if (!avctx->extradata)
1171  return AVERROR(ENOMEM);
1172 
1173  if (q->hevc_vps) {
1174  memcpy(avctx->extradata, vps_buf, extradata_vps.VPSBufSize);
1175  extradata_offset += extradata_vps.VPSBufSize;
1176  }
1177 
1178  memcpy(avctx->extradata + extradata_offset, sps_buf, extradata.SPSBufSize);
1179  extradata_offset += extradata.SPSBufSize;
1180  if (need_pps) {
1181  memcpy(avctx->extradata + extradata_offset, pps_buf, extradata.PPSBufSize);
1182  extradata_offset += extradata.PPSBufSize;
1183  }
1184  memset(avctx->extradata + avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
1185 
1186  cpb_props = ff_add_cpb_side_data(avctx);
1187  if (!cpb_props)
1188  return AVERROR(ENOMEM);
1189  cpb_props->max_bitrate = avctx->rc_max_rate;
1190  cpb_props->min_bitrate = avctx->rc_min_rate;
1191  cpb_props->avg_bitrate = avctx->bit_rate;
1192  cpb_props->buffer_size = avctx->rc_buffer_size;
1193 
1194  dump_video_param(avctx, q, ext_buffers);
1195 
1196  return 0;
1197 }
1198 
1199 #if QSV_HAVE_OPAQUE
1201 {
1202  AVQSVContext *qsv = avctx->hwaccel_context;
1203  mfxFrameSurface1 *surfaces;
1204  int nb_surfaces, i;
1205 
1206  nb_surfaces = qsv->nb_opaque_surfaces + q->req.NumFrameSuggested;
1207 
1208  q->opaque_alloc_buf = av_buffer_allocz(sizeof(*surfaces) * nb_surfaces);
1209  if (!q->opaque_alloc_buf)
1210  return AVERROR(ENOMEM);
1211 
1212  q->opaque_surfaces = av_malloc_array(nb_surfaces, sizeof(*q->opaque_surfaces));
1213  if (!q->opaque_surfaces)
1214  return AVERROR(ENOMEM);
1215 
1216  surfaces = (mfxFrameSurface1*)q->opaque_alloc_buf->data;
1217  for (i = 0; i < nb_surfaces; i++) {
1218  surfaces[i].Info = q->req.Info;
1219  q->opaque_surfaces[i] = surfaces + i;
1220  }
1221 
1222  q->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
1223  q->opaque_alloc.Header.BufferSz = sizeof(q->opaque_alloc);
1224  q->opaque_alloc.In.Surfaces = q->opaque_surfaces;
1225  q->opaque_alloc.In.NumSurface = nb_surfaces;
1226  q->opaque_alloc.In.Type = q->req.Type;
1227 
1228  q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->opaque_alloc;
1229 
1230  qsv->nb_opaque_surfaces = nb_surfaces;
1232  qsv->opaque_alloc_type = q->req.Type;
1233 
1234  return 0;
1235 }
1236 #endif
1237 
1239 {
1240  int ret;
1241 
1242  if (avctx->hwaccel_context) {
1243  AVQSVContext *qsv = avctx->hwaccel_context;
1244  q->session = qsv->session;
1245  } else if (avctx->hw_frames_ctx) {
1247  if (!q->frames_ctx.hw_frames_ctx)
1248  return AVERROR(ENOMEM);
1249 
1251  &q->frames_ctx, q->load_plugins,
1252 #if QSV_HAVE_OPAQUE
1253  q->param.IOPattern == MFX_IOPATTERN_IN_OPAQUE_MEMORY,
1254 #else
1255  0,
1256 #endif
1257  MFX_GPUCOPY_OFF);
1258  if (ret < 0) {
1260  return ret;
1261  }
1262 
1263  q->session = q->internal_qs.session;
1264  } else if (avctx->hw_device_ctx) {
1266  avctx->hw_device_ctx, q->load_plugins,
1267  MFX_GPUCOPY_OFF);
1268  if (ret < 0)
1269  return ret;
1270 
1271  q->session = q->internal_qs.session;
1272  } else {
1274  q->load_plugins, MFX_GPUCOPY_OFF);
1275  if (ret < 0)
1276  return ret;
1277 
1278  q->session = q->internal_qs.session;
1279  }
1280 
1281  return 0;
1282 }
1283 
1285 {
1286  int iopattern = 0;
1287  int opaque_alloc = 0;
1288  int ret;
1289 
1290  q->param.AsyncDepth = q->async_depth;
1291 
1292  q->async_fifo = av_fifo_alloc2(q->async_depth, sizeof(QSVPacket), 0);
1293  if (!q->async_fifo)
1294  return AVERROR(ENOMEM);
1295 
1296  if (avctx->hwaccel_context) {
1297  AVQSVContext *qsv = avctx->hwaccel_context;
1298 
1299  iopattern = qsv->iopattern;
1300  opaque_alloc = qsv->opaque_alloc;
1301  }
1302 
1303  if (avctx->hw_frames_ctx) {
1304  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1305  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
1306 
1307  if (!iopattern) {
1308 #if QSV_HAVE_OPAQUE
1309  if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)
1310  iopattern = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
1311  else if (frames_hwctx->frame_type &
1312  (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
1313  iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
1314 #else
1315  if (frames_hwctx->frame_type &
1316  (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
1317  iopattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
1318 #endif
1319  }
1320  }
1321 
1322  if (!iopattern)
1323  iopattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
1324  q->param.IOPattern = iopattern;
1325  ff_qsv_print_iopattern(avctx, iopattern, "Encoder");
1326 
1327  ret = qsvenc_init_session(avctx, q);
1328  if (ret < 0)
1329  return ret;
1330 
1331  ret = MFXQueryVersion(q->session,&q->ver);
1332  if (ret < 0) {
1333  return ff_qsv_print_error(avctx, ret,
1334  "Error querying mfx version");
1335  }
1336 
1337  // in the mfxInfoMFX struct, JPEG is different from other codecs
1338  switch (avctx->codec_id) {
1339  case AV_CODEC_ID_MJPEG:
1340  ret = init_video_param_jpeg(avctx, q);
1341  break;
1342  default:
1343  ret = init_video_param(avctx, q);
1344  break;
1345  }
1346  if (ret < 0)
1347  return ret;
1348 
1349  if (avctx->hwaccel_context) {
1350  AVQSVContext *qsv = avctx->hwaccel_context;
1351  int i, j;
1352 
1354  sizeof(*q->extparam));
1355  if (!q->extparam)
1356  return AVERROR(ENOMEM);
1357 
1358  q->param.ExtParam = q->extparam;
1359  for (i = 0; i < qsv->nb_ext_buffers; i++)
1360  q->param.ExtParam[i] = qsv->ext_buffers[i];
1361  q->param.NumExtParam = qsv->nb_ext_buffers;
1362 
1363  for (i = 0; i < q->nb_extparam_internal; i++) {
1364  for (j = 0; j < qsv->nb_ext_buffers; j++) {
1365  if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)
1366  break;
1367  }
1368  if (j < qsv->nb_ext_buffers)
1369  continue;
1370 
1371  q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];
1372  }
1373  } else {
1374  q->param.ExtParam = q->extparam_internal;
1375  q->param.NumExtParam = q->nb_extparam_internal;
1376  }
1377 
1378  ret = MFXVideoENCODE_Query(q->session, &q->param, &q->param);
1379  if (ret == MFX_WRN_PARTIAL_ACCELERATION) {
1380  av_log(avctx, AV_LOG_WARNING, "Encoder will work with partial HW acceleration\n");
1381  } else if (ret < 0) {
1382  return ff_qsv_print_error(avctx, ret,
1383  "Error querying encoder params");
1384  }
1385 
1386  ret = MFXVideoENCODE_QueryIOSurf(q->session, &q->param, &q->req);
1387  if (ret < 0)
1388  return ff_qsv_print_error(avctx, ret,
1389  "Error querying (IOSurf) the encoding parameters");
1390 
1391  if (opaque_alloc) {
1392 #if QSV_HAVE_OPAQUE
1393  ret = qsv_init_opaque_alloc(avctx, q);
1394  if (ret < 0)
1395  return ret;
1396 #else
1397  av_log(avctx, AV_LOG_ERROR, "User is requesting to allocate OPAQUE surface, "
1398  "however libmfx %d.%d doesn't support OPAQUE memory.\n",
1399  q->ver.Major, q->ver.Minor);
1400  return AVERROR_UNKNOWN;
1401 #endif
1402  }
1403 
1404  ret = MFXVideoENCODE_Init(q->session, &q->param);
1405  if (ret < 0)
1406  return ff_qsv_print_error(avctx, ret,
1407  "Error initializing the encoder");
1408  else if (ret > 0)
1409  ff_qsv_print_warning(avctx, ret,
1410  "Warning in encoder initialization");
1411 
1412  switch (avctx->codec_id) {
1413  case AV_CODEC_ID_MJPEG:
1414  ret = qsv_retrieve_enc_jpeg_params(avctx, q);
1415  break;
1416  case AV_CODEC_ID_VP9:
1417  ret = qsv_retrieve_enc_vp9_params(avctx, q);
1418  break;
1419  default:
1420  ret = qsv_retrieve_enc_params(avctx, q);
1421  break;
1422  }
1423  if (ret < 0) {
1424  av_log(avctx, AV_LOG_ERROR, "Error retrieving encoding parameters.\n");
1425  return ret;
1426  }
1427 
1428  q->avctx = avctx;
1429 
1430  return 0;
1431 }
1432 
1433 static void free_encoder_ctrl_payloads(mfxEncodeCtrl* enc_ctrl)
1434 {
1435  if (enc_ctrl) {
1436  int i;
1437  for (i = 0; i < enc_ctrl->NumPayload && i < QSV_MAX_ENC_PAYLOAD; i++) {
1438  av_freep(&enc_ctrl->Payload[i]);
1439  }
1440  enc_ctrl->NumPayload = 0;
1441  }
1442 }
1443 
1444 static void free_encoder_ctrl_extparam(mfxEncodeCtrl* enc_ctrl)
1445 {
1446  if (enc_ctrl) {
1447  int i;
1448  for (i = 0; i < enc_ctrl->NumExtParam && i < QSV_MAX_ENC_EXTPARAM; i++) {
1449  if (enc_ctrl->ExtParam[i])
1450  av_freep(&(enc_ctrl->ExtParam[i]));
1451  }
1452  enc_ctrl->NumExtParam = 0;
1453  }
1454 }
1455 
1457 {
1458  QSVFrame *cur = q->work_frames;
1459  while (cur) {
1460  if (cur->used && !cur->surface.Data.Locked) {
1463  //do not reuse enc_ctrl from previous frame
1464  memset(&cur->enc_ctrl, 0, sizeof(cur->enc_ctrl));
1465  cur->enc_ctrl.Payload = cur->payloads;
1466  cur->enc_ctrl.ExtParam = cur->extparam;
1467  if (cur->frame->format == AV_PIX_FMT_QSV) {
1468  av_frame_unref(cur->frame);
1469  }
1470  cur->used = 0;
1471  }
1472  cur = cur->next;
1473  }
1474 }
1475 
1477 {
1478  QSVFrame *frame, **last;
1479 
1481 
1482  frame = q->work_frames;
1483  last = &q->work_frames;
1484  while (frame) {
1485  if (!frame->used) {
1486  *f = frame;
1487  frame->used = 1;
1488  return 0;
1489  }
1490 
1491  last = &frame->next;
1492  frame = frame->next;
1493  }
1494 
1495  frame = av_mallocz(sizeof(*frame));
1496  if (!frame)
1497  return AVERROR(ENOMEM);
1498  frame->frame = av_frame_alloc();
1499  if (!frame->frame) {
1500  av_freep(&frame);
1501  return AVERROR(ENOMEM);
1502  }
1503  frame->enc_ctrl.Payload = frame->payloads;
1504  frame->enc_ctrl.ExtParam = frame->extparam;
1505  *last = frame;
1506 
1507  *f = frame;
1508  frame->used = 1;
1509 
1510  return 0;
1511 }
1512 
1513 static int submit_frame(QSVEncContext *q, const AVFrame *frame,
1514  QSVFrame **new_frame)
1515 {
1516  QSVFrame *qf;
1517  int ret;
1518 
1519  ret = get_free_frame(q, &qf);
1520  if (ret < 0)
1521  return ret;
1522 
1523  if (frame->format == AV_PIX_FMT_QSV) {
1524  ret = av_frame_ref(qf->frame, frame);
1525  if (ret < 0)
1526  return ret;
1527 
1528  qf->surface = *(mfxFrameSurface1*)qf->frame->data[3];
1529 
1530  if (q->frames_ctx.mids) {
1532  if (ret < 0)
1533  return ret;
1534 
1535  qf->surface.Data.MemId = &q->frames_ctx.mids[ret];
1536  }
1537  } else {
1538  /* make a copy if the input is not padded as libmfx requires */
1539  /* and to make allocation continious for data[0]/data[1] */
1540  if ((frame->height & 31 || frame->linesize[0] & (q->width_align - 1)) ||
1541  (frame->data[1] - frame->data[0] != frame->linesize[0] * FFALIGN(qf->frame->height, q->height_align))) {
1542  qf->frame->height = FFALIGN(frame->height, q->height_align);
1543  qf->frame->width = FFALIGN(frame->width, q->width_align);
1544 
1545  qf->frame->format = frame->format;
1546 
1547  if (!qf->frame->data[0]) {
1549  if (ret < 0)
1550  return ret;
1551  }
1552 
1553  qf->frame->height = frame->height;
1554  qf->frame->width = frame->width;
1555 
1556  ret = av_frame_copy(qf->frame, frame);
1557  if (ret < 0) {
1558  av_frame_unref(qf->frame);
1559  return ret;
1560  }
1561  } else {
1562  av_frame_unref(qf->frame);
1563  ret = av_frame_ref(qf->frame, frame);
1564  if (ret < 0)
1565  return ret;
1566  }
1567 
1568  qf->surface.Info = q->param.mfx.FrameInfo;
1569 
1570  qf->surface.Info.PicStruct =
1571  !frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
1572  frame->top_field_first ? MFX_PICSTRUCT_FIELD_TFF :
1573  MFX_PICSTRUCT_FIELD_BFF;
1574  if (frame->repeat_pict == 1)
1575  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
1576  else if (frame->repeat_pict == 2)
1577  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
1578  else if (frame->repeat_pict == 4)
1579  qf->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
1580 
1582  if (ret < 0) {
1583  av_log(q->avctx, AV_LOG_ERROR, "map frame to surface failed.\n");
1584  return ret;
1585  }
1586  }
1587  qf->surface.Data.TimeStamp = av_rescale_q(frame->pts, q->avctx->time_base, (AVRational){1, 90000});
1588 
1589  *new_frame = qf;
1590 
1591  return 0;
1592 }
1593 
1595 {
1596  if (q->param.mfx.CodecId == MFX_CODEC_AVC) {
1597  if (q->param.mfx.CodecProfile == MFX_PROFILE_AVC_BASELINE ||
1598  q->param.mfx.CodecLevel < MFX_LEVEL_AVC_21 ||
1599  q->param.mfx.CodecLevel > MFX_LEVEL_AVC_41)
1600  av_log(avctx, AV_LOG_WARNING,
1601  "Interlaced coding is supported"
1602  " at Main/High Profile Level 2.2-4.0\n");
1603  }
1604 }
1605 
1607  mfxEncodeCtrl *enc_ctrl)
1608 {
1609  AVFrameSideData *sd = NULL;
1610  int mb_size;
1611 
1612  if (avctx->codec_id == AV_CODEC_ID_H264)
1613  mb_size = 16;
1614  else if (avctx->codec_id == AV_CODEC_ID_H265)
1615  mb_size = 32;
1616  else
1617  return 0;
1618 
1619  if (frame)
1621 
1622  if (sd) {
1623  mfxExtEncoderROI *enc_roi = NULL;
1624  AVRegionOfInterest *roi;
1625  uint32_t roi_size;
1626  int nb_roi, i;
1627 
1628  roi = (AVRegionOfInterest *)sd->data;
1629  roi_size = roi->self_size;
1630  if (!roi_size || sd->size % roi_size) {
1631  av_log(avctx, AV_LOG_ERROR, "Invalid ROI Data.\n");
1632  return AVERROR(EINVAL);
1633  }
1634  nb_roi = sd->size / roi_size;
1635  if (nb_roi > QSV_MAX_ROI_NUM) {
1636  av_log(avctx, AV_LOG_WARNING, "More ROIs set than "
1637  "supported by driver (%d > %d).\n",
1638  nb_roi, QSV_MAX_ROI_NUM);
1639  nb_roi = QSV_MAX_ROI_NUM;
1640  }
1641 
1642  enc_roi = av_mallocz(sizeof(*enc_roi));
1643  if (!enc_roi)
1644  return AVERROR(ENOMEM);
1645  enc_roi->Header.BufferId = MFX_EXTBUFF_ENCODER_ROI;
1646  enc_roi->Header.BufferSz = sizeof(*enc_roi);
1647  enc_roi->NumROI = nb_roi;
1648  enc_roi->ROIMode = MFX_ROI_MODE_QP_DELTA;
1649  for (i = 0; i < nb_roi; i++) {
1650  roi = (AVRegionOfInterest *)(sd->data + roi_size * i);
1651  enc_roi->ROI[i].Top = FFALIGN(roi->top, mb_size);
1652  enc_roi->ROI[i].Bottom = FFALIGN(roi->bottom, mb_size);
1653  enc_roi->ROI[i].Left = FFALIGN(roi->left, mb_size);
1654  enc_roi->ROI[i].Right = FFALIGN(roi->right, mb_size);
1655  enc_roi->ROI[i].DeltaQP =
1656  roi->qoffset.num * 51 / roi->qoffset.den;
1657  av_log(avctx, AV_LOG_DEBUG, "ROI: (%d,%d)-(%d,%d) -> %+d.\n",
1658  roi->top, roi->left, roi->bottom, roi->right,
1659  enc_roi->ROI[i].DeltaQP);
1660  }
1661  enc_ctrl->ExtParam[enc_ctrl->NumExtParam] = (mfxExtBuffer *)enc_roi;
1662  enc_ctrl->NumExtParam++;
1663  }
1664  return 0;
1665 }
1666 
1668 {
1669  int updated = 0, new_qp = 0;
1670 
1671  if (avctx->codec_id != AV_CODEC_ID_H264 && avctx->codec_id != AV_CODEC_ID_HEVC)
1672  return 0;
1673 
1674  if (q->param.mfx.RateControlMethod == MFX_RATECONTROL_CQP) {
1680  if (!updated)
1681  return 0;
1682 
1683  new_qp = avctx->global_quality / FF_QP2LAMBDA;
1684  q->param.mfx.QPI = av_clip(new_qp * fabs(avctx->i_quant_factor) +
1685  avctx->i_quant_offset, 0, 51);
1686  q->param.mfx.QPP = av_clip(new_qp, 0, 51);
1687  q->param.mfx.QPB = av_clip(new_qp * fabs(avctx->b_quant_factor) +
1688  avctx->b_quant_offset, 0, 51);
1689  av_log(avctx, AV_LOG_DEBUG,
1690  "Reset qp = %d/%d/%d for idr/p/b frames\n",
1691  q->param.mfx.QPI, q->param.mfx.QPP, q->param.mfx.QPB);
1692  }
1693  return updated;
1694 }
1695 
1697 {
1698  int updated = 0;
1699 
1700  if (avctx->codec_id != AV_CODEC_ID_H264 && avctx->codec_id != AV_CODEC_ID_HEVC)
1701  return 0;
1702 
1704  if (!updated)
1705  return 0;
1706 
1707  q->extco2.MaxFrameSize = FFMAX(0, q->max_frame_size);
1708  av_log(avctx, AV_LOG_DEBUG,
1709  "Reset MaxFrameSize: %d;\n", q->extco2.MaxFrameSize);
1710 
1711  return updated;
1712 }
1713 
1715 {
1716  int updated = 0;
1717  UPDATE_PARAM(q->old_gop_size, avctx->gop_size);
1718  if (!updated)
1719  return 0;
1720 
1721  q->param.mfx.GopPicSize = FFMAX(0, avctx->gop_size);
1722  av_log(avctx, AV_LOG_DEBUG, "reset GopPicSize to %d\n",
1723  q->param.mfx.GopPicSize);
1724 
1725  return updated;
1726 }
1727 
1729 {
1730  int updated = 0;
1731 
1732  if (avctx->codec_id != AV_CODEC_ID_H264 && avctx->codec_id != AV_CODEC_ID_HEVC)
1733  return 0;
1734 
1739  if (!updated)
1740  return 0;
1741 
1742  q->extco2.IntRefType = FFMAX(0, q->int_ref_type);
1743  q->extco2.IntRefCycleSize = FFMAX(0, q->int_ref_cycle_size);
1744  q->extco2.IntRefQPDelta =
1745  q->int_ref_qp_delta != INT16_MIN ? q->int_ref_qp_delta : 0;
1746  q->extco3.IntRefCycleDist = FFMAX(0, q->int_ref_cycle_dist);
1747  av_log(avctx, AV_LOG_DEBUG,
1748  "Reset IntRefType: %d; IntRefCycleSize: %d; "
1749  "IntRefQPDelta: %d; IntRefCycleDist: %d\n",
1750  q->extco2.IntRefType, q->extco2.IntRefCycleSize,
1751  q->extco2.IntRefQPDelta, q->extco3.IntRefCycleDist);
1752 
1753  return updated;
1754 }
1755 
1757 {
1758  int updated = 0;
1759 
1760  if (avctx->codec_id != AV_CODEC_ID_H264)
1761  return 0;
1762 
1763  UPDATE_PARAM(q->old_qmax, avctx->qmin);
1764  UPDATE_PARAM(q->old_qmax, avctx->qmin);
1771  if (!updated)
1772  return 0;
1773 
1774  if ((avctx->qmin >= 0 && avctx->qmax >= 0 && avctx->qmin > avctx->qmax) ||
1775  (q->max_qp_i >= 0 && q->min_qp_i >= 0 && q->min_qp_i > q->max_qp_i) ||
1776  (q->max_qp_p >= 0 && q->min_qp_p >= 0 && q->min_qp_p > q->max_qp_p) ||
1777  (q->max_qp_b >= 0 && q->min_qp_b >= 0 && q->min_qp_b > q->max_qp_b)) {
1778  av_log(avctx, AV_LOG_ERROR,
1779  "qmin and or qmax are set but invalid,"
1780  " please make sure min <= max\n");
1781  return AVERROR(EINVAL);
1782  }
1783 
1784  q->extco2.MinQPI = 0;
1785  q->extco2.MaxQPI = 0;
1786  q->extco2.MinQPP = 0;
1787  q->extco2.MaxQPP = 0;
1788  q->extco2.MinQPB = 0;
1789  q->extco2.MaxQPB = 0;
1790  if (avctx->qmin >= 0) {
1791  q->extco2.MinQPI = avctx->qmin > 51 ? 51 : avctx->qmin;
1792  q->extco2.MinQPB = q->extco2.MinQPP = q->extco2.MinQPI;
1793  }
1794  if (avctx->qmax >= 0) {
1795  q->extco2.MaxQPI = avctx->qmax > 51 ? 51 : avctx->qmax;
1796  q->extco2.MaxQPB = q->extco2.MaxQPP = q->extco2.MaxQPI;
1797  }
1798  if (q->min_qp_i >= 0)
1799  q->extco2.MinQPI = q->min_qp_i > 51 ? 51 : q->min_qp_i;
1800  if (q->max_qp_i >= 0)
1801  q->extco2.MaxQPI = q->max_qp_i > 51 ? 51 : q->max_qp_i;
1802  if (q->min_qp_p >= 0)
1803  q->extco2.MinQPP = q->min_qp_p > 51 ? 51 : q->min_qp_p;
1804  if (q->max_qp_p >= 0)
1805  q->extco2.MaxQPP = q->max_qp_p > 51 ? 51 : q->max_qp_p;
1806  if (q->min_qp_b >= 0)
1807  q->extco2.MinQPB = q->min_qp_b > 51 ? 51 : q->min_qp_b;
1808  if (q->max_qp_b >= 0)
1809  q->extco2.MaxQPB = q->max_qp_b > 51 ? 51 : q->max_qp_b;
1810 
1811  av_log(avctx, AV_LOG_VERBOSE, "Reset MinQPI: %d; MaxQPI: %d; "
1812  "MinQPP: %d; MaxQPP: %d; "
1813  "MinQPB: %d; MaxQPB: %d\n",
1814  q->extco2.MinQPI, q->extco2.MaxQPI,
1815  q->extco2.MinQPP, q->extco2.MaxQPP,
1816  q->extco2.MinQPB, q->extco2.MaxQPB);
1817 
1818  return updated;
1819 }
1820 
1822 {
1823  int updated = 0;
1824 
1825  if (avctx->codec_id != AV_CODEC_ID_H264 && avctx->codec_id != AV_CODEC_ID_HEVC)
1826  return 0;
1827 
1829  if (!updated)
1830  return 0;
1831 
1832  q->extco3.LowDelayBRC = MFX_CODINGOPTION_UNKNOWN;
1833  if (q->low_delay_brc >= 0)
1834  q->extco3.LowDelayBRC = q->low_delay_brc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1835  av_log(avctx, AV_LOG_DEBUG, "Reset LowDelayBRC: %s\n",
1836  print_threestate(q->extco3.LowDelayBRC));
1837 
1838  return updated;
1839 }
1840 
1842  const AVFrame *frame)
1843 {
1844  int needReset = 0, ret = 0;
1845 
1846  if (!frame || avctx->codec_id == AV_CODEC_ID_MJPEG)
1847  return 0;
1848 
1849  needReset = update_qp(avctx, q);
1850  needReset |= update_max_frame_size(avctx, q);
1851  needReset |= update_gop_size(avctx, q);
1852  needReset |= update_rir(avctx, q);
1853  needReset |= update_low_delay_brc(avctx, q);
1854  ret = update_min_max_qp(avctx, q);
1855  if (ret < 0)
1856  return ret;
1857  needReset |= ret;
1858  if (!needReset)
1859  return 0;
1860 
1861  if (avctx->hwaccel_context) {
1862  AVQSVContext *qsv = avctx->hwaccel_context;
1863  int i, j;
1864  q->param.ExtParam = q->extparam;
1865  for (i = 0; i < qsv->nb_ext_buffers; i++)
1866  q->param.ExtParam[i] = qsv->ext_buffers[i];
1867  q->param.NumExtParam = qsv->nb_ext_buffers;
1868 
1869  for (i = 0; i < q->nb_extparam_internal; i++) {
1870  for (j = 0; j < qsv->nb_ext_buffers; j++) {
1871  if (qsv->ext_buffers[j]->BufferId == q->extparam_internal[i]->BufferId)
1872  break;
1873  }
1874  if (j < qsv->nb_ext_buffers)
1875  continue;
1876  q->param.ExtParam[q->param.NumExtParam++] = q->extparam_internal[i];
1877  }
1878  } else {
1879  q->param.ExtParam = q->extparam_internal;
1880  q->param.NumExtParam = q->nb_extparam_internal;
1881  }
1882  av_log(avctx, AV_LOG_DEBUG, "Parameter change, call msdk reset.\n");
1883  ret = MFXVideoENCODE_Reset(q->session, &q->param);
1884  if (ret < 0)
1885  return ff_qsv_print_error(avctx, ret, "Error during resetting");
1886 
1887  return 0;
1888 }
1889 
1891  const AVFrame *frame)
1892 {
1893  QSVPacket pkt = { { 0 } };
1894  mfxExtAVCEncodedFrameInfo *enc_info = NULL;
1895  mfxExtBuffer **enc_buf = NULL;
1896 
1897  mfxFrameSurface1 *surf = NULL;
1898  QSVFrame *qsv_frame = NULL;
1899  mfxEncodeCtrl* enc_ctrl = NULL;
1900  int ret;
1901 
1902  if (frame) {
1903  ret = submit_frame(q, frame, &qsv_frame);
1904  if (ret < 0) {
1905  av_log(avctx, AV_LOG_ERROR, "Error submitting the frame for encoding.\n");
1906  return ret;
1907  }
1908  }
1909  if (qsv_frame) {
1910  surf = &qsv_frame->surface;
1911  enc_ctrl = &qsv_frame->enc_ctrl;
1912 
1913  if (frame->pict_type == AV_PICTURE_TYPE_I) {
1914  enc_ctrl->FrameType = MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF;
1915  if (q->forced_idr)
1916  enc_ctrl->FrameType |= MFX_FRAMETYPE_IDR;
1917  }
1918  }
1919 
1920  ret = av_new_packet(&pkt.pkt, q->packet_size);
1921  if (ret < 0) {
1922  av_log(avctx, AV_LOG_ERROR, "Error allocating the output packet\n");
1923  return ret;
1924  }
1925 
1926  pkt.bs = av_mallocz(sizeof(*pkt.bs));
1927  if (!pkt.bs)
1928  goto nomem;
1929  pkt.bs->Data = pkt.pkt.data;
1930  pkt.bs->MaxLength = pkt.pkt.size;
1931 
1932  if (avctx->codec_id == AV_CODEC_ID_H264) {
1933  enc_info = av_mallocz(sizeof(*enc_info));
1934  if (!enc_info)
1935  goto nomem;
1936 
1937  enc_info->Header.BufferId = MFX_EXTBUFF_ENCODED_FRAME_INFO;
1938  enc_info->Header.BufferSz = sizeof (*enc_info);
1939  pkt.bs->NumExtParam = 1;
1940  enc_buf = av_mallocz(sizeof(mfxExtBuffer *));
1941  if (!enc_buf)
1942  goto nomem;
1943  enc_buf[0] = (mfxExtBuffer *)enc_info;
1944 
1945  pkt.bs->ExtParam = enc_buf;
1946  }
1947 
1948  if (q->set_encode_ctrl_cb) {
1949  q->set_encode_ctrl_cb(avctx, frame, &qsv_frame->enc_ctrl);
1950  }
1951 
1952  if ((avctx->codec_id == AV_CODEC_ID_H264 ||
1953  avctx->codec_id == AV_CODEC_ID_H265) &&
1954  enc_ctrl && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 8)) {
1955  ret = set_roi_encode_ctrl(avctx, frame, enc_ctrl);
1956  if (ret < 0)
1957  goto free;
1958  }
1959 
1960  pkt.sync = av_mallocz(sizeof(*pkt.sync));
1961  if (!pkt.sync)
1962  goto nomem;
1963 
1964  do {
1965  ret = MFXVideoENCODE_EncodeFrameAsync(q->session, enc_ctrl, surf, pkt.bs, pkt.sync);
1966  if (ret == MFX_WRN_DEVICE_BUSY)
1967  av_usleep(500);
1968  } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_WRN_IN_EXECUTION);
1969 
1970  if (ret > 0)
1971  ff_qsv_print_warning(avctx, ret, "Warning during encoding");
1972 
1973  if (ret < 0) {
1974  ret = (ret == MFX_ERR_MORE_DATA) ?
1975  0 : ff_qsv_print_error(avctx, ret, "Error during encoding");
1976  goto free;
1977  }
1978 
1979  if (ret == MFX_WRN_INCOMPATIBLE_VIDEO_PARAM && frame && frame->interlaced_frame)
1980  print_interlace_msg(avctx, q);
1981 
1982  ret = 0;
1983 
1984  if (*pkt.sync) {
1985  av_fifo_write(q->async_fifo, &pkt, 1);
1986  } else {
1987 free:
1988  av_freep(&pkt.sync);
1989  av_packet_unref(&pkt.pkt);
1990  av_freep(&pkt.bs);
1991  if (avctx->codec_id == AV_CODEC_ID_H264) {
1992  av_freep(&enc_info);
1993  av_freep(&enc_buf);
1994  }
1995  }
1996 
1997  return ret;
1998 nomem:
1999  ret = AVERROR(ENOMEM);
2000  goto free;
2001 }
2002 
2004  AVPacket *pkt, const AVFrame *frame, int *got_packet)
2005 {
2006  int ret;
2007 
2008  ret = update_parameters(avctx, q, frame);
2009  if (ret < 0)
2010  return ret;
2011 
2012  ret = encode_frame(avctx, q, frame);
2013  if (ret < 0)
2014  return ret;
2015 
2016  if ((av_fifo_can_read(q->async_fifo) >= q->async_depth) ||
2017  (!frame && av_fifo_can_read(q->async_fifo))) {
2018  QSVPacket qpkt;
2019  mfxExtAVCEncodedFrameInfo *enc_info;
2020  mfxExtBuffer **enc_buf;
2021  enum AVPictureType pict_type;
2022 
2023  av_fifo_read(q->async_fifo, &qpkt, 1);
2024 
2025  do {
2026  ret = MFXVideoCORE_SyncOperation(q->session, *qpkt.sync, 1000);
2027  } while (ret == MFX_WRN_IN_EXECUTION);
2028 
2029  qpkt.pkt.dts = av_rescale_q(qpkt.bs->DecodeTimeStamp, (AVRational){1, 90000}, avctx->time_base);
2030  qpkt.pkt.pts = av_rescale_q(qpkt.bs->TimeStamp, (AVRational){1, 90000}, avctx->time_base);
2031  qpkt.pkt.size = qpkt.bs->DataLength;
2032 
2033  if (qpkt.bs->FrameType & MFX_FRAMETYPE_IDR || qpkt.bs->FrameType & MFX_FRAMETYPE_xIDR) {
2034  qpkt.pkt.flags |= AV_PKT_FLAG_KEY;
2035  pict_type = AV_PICTURE_TYPE_I;
2036  } else if (qpkt.bs->FrameType & MFX_FRAMETYPE_I || qpkt.bs->FrameType & MFX_FRAMETYPE_xI)
2037  pict_type = AV_PICTURE_TYPE_I;
2038  else if (qpkt.bs->FrameType & MFX_FRAMETYPE_P || qpkt.bs->FrameType & MFX_FRAMETYPE_xP)
2039  pict_type = AV_PICTURE_TYPE_P;
2040  else if (qpkt.bs->FrameType & MFX_FRAMETYPE_B || qpkt.bs->FrameType & MFX_FRAMETYPE_xB)
2041  pict_type = AV_PICTURE_TYPE_B;
2042  else if (qpkt.bs->FrameType == MFX_FRAMETYPE_UNKNOWN) {
2043  pict_type = AV_PICTURE_TYPE_NONE;
2044  av_log(avctx, AV_LOG_WARNING, "Unknown FrameType, set pict_type to AV_PICTURE_TYPE_NONE.\n");
2045  } else {
2046  av_log(avctx, AV_LOG_ERROR, "Invalid FrameType:%d.\n", qpkt.bs->FrameType);
2047  return AVERROR_INVALIDDATA;
2048  }
2049 
2050  if (avctx->codec_id == AV_CODEC_ID_H264) {
2051  enc_buf = qpkt.bs->ExtParam;
2052  enc_info = (mfxExtAVCEncodedFrameInfo *)(*enc_buf);
2054  enc_info->QP * FF_QP2LAMBDA, NULL, 0, pict_type);
2055  av_freep(&enc_info);
2056  av_freep(&enc_buf);
2057  }
2058  av_freep(&qpkt.bs);
2059  av_freep(&qpkt.sync);
2060 
2061  av_packet_move_ref(pkt, &qpkt.pkt);
2062 
2063  *got_packet = 1;
2064  }
2065 
2066  return 0;
2067 }
2068 
2070 {
2071  QSVFrame *cur;
2072 
2073  if (q->session)
2074  MFXVideoENCODE_Close(q->session);
2075 
2076  q->session = NULL;
2078 
2081 
2082  cur = q->work_frames;
2083  while (cur) {
2084  q->work_frames = cur->next;
2085  av_frame_free(&cur->frame);
2088  av_freep(&cur);
2089  cur = q->work_frames;
2090  }
2091 
2092  if (q->async_fifo) {
2093  QSVPacket pkt;
2094  while (av_fifo_read(q->async_fifo, &pkt, 1) >= 0) {
2095  if (avctx->codec_id == AV_CODEC_ID_H264) {
2096  mfxExtBuffer **enc_buf = pkt.bs->ExtParam;
2097  mfxExtAVCEncodedFrameInfo *enc_info = (mfxExtAVCEncodedFrameInfo *)(*enc_buf);
2098  av_freep(&enc_info);
2099  av_freep(&enc_buf);
2100  }
2101  av_freep(&pkt.sync);
2102  av_freep(&pkt.bs);
2103  av_packet_unref(&pkt.pkt);
2104  }
2106  }
2107 
2108 #if QSV_HAVE_OPAQUE
2111 #endif
2112 
2113  av_freep(&q->extparam);
2114 
2115  return 0;
2116 }
2117 
2119  HW_CONFIG_ENCODER_FRAMES(QSV, QSV),
2120  HW_CONFIG_ENCODER_DEVICE(NV12, QSV),
2121  HW_CONFIG_ENCODER_DEVICE(P010, QSV),
2122  NULL,
2123 };
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:422
update_gop_size
static int update_gop_size(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1714
AVCodecContext::hwaccel_context
void * hwaccel_context
Legacy hardware accelerator context.
Definition: avcodec.h:1412
QSVEncContext::look_ahead_depth
int look_ahead_depth
Definition: qsvenc.h:188
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
QSVEncContext::old_max_qp_i
int old_max_qp_i
Definition: qsvenc.h:266
dump_video_vp9_param
static void dump_video_vp9_param(AVCodecContext *avctx, QSVEncContext *q, mfxExtBuffer **coding_opts)
Definition: qsvenc.c:349
av_clip
#define av_clip
Definition: common.h:95
QSVEncContext::repeat_pps
int repeat_pps
Definition: qsvenc.h:222
set_roi_encode_ctrl
static int set_roi_encode_ctrl(AVCodecContext *avctx, const AVFrame *frame, mfxEncodeCtrl *enc_ctrl)
Definition: qsvenc.c:1606
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:975
qsv_retrieve_enc_vp9_params
static int qsv_retrieve_enc_vp9_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1027
QSVFramesContext::hw_frames_ctx
AVBufferRef * hw_frames_ctx
Definition: qsv_internal.h:110
av_frame_get_buffer
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:259
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:691
QSVEncContext::max_qp_i
int max_qp_i
Definition: qsvenc.h:242
AVCodecContext::rc_min_rate
int64_t rc_min_rate
minimum bitrate
Definition: avcodec.h:1230
QSVEncContext::p_strategy
int p_strategy
Definition: qsvenc.h:213
AVProfile::name
const char * name
short name for the profile
Definition: codec.h:198
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2807
ff_side_data_set_encoder_stats
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:602
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
rc_names
static const struct @122 rc_names[]
AVPictureType
AVPictureType
Definition: avutil.h:272
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:216
QSVEncContext::avbr_accuracy
int avbr_accuracy
Definition: qsvenc.h:184
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:116
QSVEncContext::extco
mfxExtCodingOption extco
Definition: qsvenc.h:148
QSVEncContext::old_int_ref_type
int old_int_ref_type
Definition: qsvenc.h:259
QSVFrame::extparam
mfxExtBuffer * extparam[QSV_MAX_ENC_EXTPARAM]
used for enc_ctrl.ExtParam
Definition: qsv_internal.h:92
ff_qsv_close_internal_session
int ff_qsv_close_internal_session(QSVSession *qs)
Definition: qsv.c:1070
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:968
AVFrame::width
int width
Definition: frame.h:397
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:624
internal.h
QSVEncContext::adaptive_b
int adaptive_b
Definition: qsvenc.h:211
AVPacket::data
uint8_t * data
Definition: packet.h:374
QSVEncContext::max_frame_size
int max_frame_size
Definition: qsvenc.h:192
QSVEncContext::tile_cols
int tile_cols
Definition: qsvenc.h:199
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:524
QSVEncContext::packet_size
int packet_size
Definition: qsvenc.h:141
ff_qsv_find_surface_idx
int ff_qsv_find_surface_idx(QSVFramesContext *ctx, QSVFrame *frame)
Definition: qsv.c:302
AVCodecContext::b_quant_offset
float b_quant_offset
qscale offset between IP and B-frames
Definition: avcodec.h:686
dump_video_mjpeg_param
static void dump_video_mjpeg_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:420
QSVEncContext::adaptive_i
int adaptive_i
Definition: qsvenc.h:210
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
QSVEncContext::int_ref_qp_delta
int int_ref_qp_delta
Definition: qsvenc.h:218
print_threestate
static const char * print_threestate(mfxU16 val)
Definition: qsvenc.c:168
QSVEncContext::old_int_ref_cycle_size
int old_int_ref_cycle_size
Definition: qsvenc.h:260
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
QSVEncContext::frames_ctx
QSVFramesContext frames_ctx
Definition: qsvenc.h:173
QSVEncContext::old_gop_size
int old_gop_size
Definition: qsvenc.h:257
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
ff_add_cpb_side_data
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1034
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1194
AVQSVContext::opaque_alloc_type
int opaque_alloc_type
Encoding only, and only if opaque_alloc is set to non-zero.
Definition: qsv.h:99
FF_COMPRESSION_DEFAULT
#define FF_COMPRESSION_DEFAULT
Definition: avcodec.h:471
QSVEncContext::load_plugins
char * load_plugins
Definition: qsvenc.h:232
QSVFrame::frame
AVFrame * frame
Definition: qsv_internal.h:81
AVQSVContext::iopattern
int iopattern
The IO pattern to use.
Definition: qsv.h:46
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
QSVFrame::used
int used
Definition: qsv_internal.h:95
select_rc_mode
static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:432
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
QSVFrame::enc_ctrl
mfxEncodeCtrl enc_ctrl
Definition: qsv_internal.h:83
ff_qsv_init_session_device
int ff_qsv_init_session_device(AVCodecContext *avctx, mfxSession *psession, AVBufferRef *device_ref, const char *load_plugins, int gpu_copy)
Definition: qsv.c:946
QSVEncContext::exthevctiles_idx
int exthevctiles_idx
Definition: qsvenc.h:239
QSVEncContext::extvsi
mfxExtVideoSignalInfo extvsi
Definition: qsvenc.h:164
update_min_max_qp
static int update_min_max_qp(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1756
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1754
QSVEncContext::recovery_point_sei
int recovery_point_sei
Definition: qsvenc.h:220
QSVEncContext::hevc_vps
int hevc_vps
Definition: qsvenc.h:177
ff_qsv_map_frame_to_surface
int ff_qsv_map_frame_to_surface(const AVFrame *frame, mfxFrameSurface1 *surface)
Definition: qsv.c:256
AVCodecContext::i_quant_factor
float i_quant_factor
qscale factor between P- and I-frames If > 0 then the last P-frame quantizer will be used (q = lastp_...
Definition: avcodec.h:703
QSVEncContext::param
mfxVideoParam param
Definition: qsvenc.h:145
QSVEncContext::height_align
int height_align
Definition: qsvenc.h:143
av_fifo_write
int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems)
Write data into a FIFO.
Definition: fifo.c:188
QSVEncContext::profile
int profile
Definition: qsvenc.h:182
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:947
QSVEncContext::old_global_quality
int old_global_quality
Definition: qsvenc.h:249
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:478
val
static double val(void *priv, double ch)
Definition: aeval.c:77
update_parameters
static int update_parameters(AVCodecContext *avctx, QSVEncContext *q, const AVFrame *frame)
Definition: qsvenc.c:1841
qsv_retrieve_enc_params
static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1081
AVRational::num
int num
Numerator.
Definition: rational.h:59
quant
static int quant(float coef, const float Q, const float rounding)
Quantize one coefficient.
Definition: aacenc_utils.h:59
qsv_internal.h
AV_CODEC_FLAG_INTERLACED_DCT
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:276
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:104
QSVEncContext::extbrc
int extbrc
Definition: qsvenc.h:209
ff_qsv_enc_hw_configs
const AVCodecHWConfigInternal *const ff_qsv_enc_hw_configs[]
Definition: qsvenc.c:2118
QSVEncContext::min_qp_i
int min_qp_i
Definition: qsvenc.h:243
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:961
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
ff_qsv_print_warning
int ff_qsv_print_warning(void *log_ctx, mfxStatus err, const char *warning_string)
Definition: qsv.c:194
AVFrameSideData::size
size_t size
Definition: frame.h:234
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
profile_names::name
const char * name
Definition: qsvenc.c:48
AVRegionOfInterest
Structure describing a single Region Of Interest.
Definition: frame.h:250
av_fifo_read
int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)
Read data from a FIFO.
Definition: fifo.c:240
AVCodecContext::rc_initial_buffer_occupancy
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:1251
QSVEncContext
Definition: qsvenc.h:133
QSV_HAVE_VCM
#define QSV_HAVE_VCM
Definition: qsvenc.h:49
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:500
QSVEncContext::old_int_ref_qp_delta
int old_int_ref_qp_delta
Definition: qsvenc.h:261
qsvenc.h
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:97
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:464
AVRegionOfInterest::bottom
int bottom
Definition: frame.h:266
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:220
QSV_RUNTIME_VERSION_ATLEAST
#define QSV_RUNTIME_VERSION_ATLEAST(MFX_VERSION, MAJOR, MINOR)
Definition: qsv_internal.h:64
info
MIPS optimizations info
Definition: mips.txt:2
update_rir
static int update_rir(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1728
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
QSVEncContext::max_frame_size_p
int max_frame_size_p
Definition: qsvenc.h:194
QSVEncContext::nb_extparam_internal
int nb_extparam_internal
Definition: qsvenc.h:167
QSVEncContext::pic_timing_sei
int pic_timing_sei
Definition: qsvenc.h:186
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AVQSVContext::nb_opaque_surfaces
int nb_opaque_surfaces
Encoding only, and only if opaque_alloc is set to non-zero.
Definition: qsv.h:78
init_video_param_jpeg
static int init_video_param_jpeg(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:536
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:388
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1223
av_usleep
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:84
QSVEncContext::forced_idr
int forced_idr
Definition: qsvenc.h:234
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:499
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:104
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
AVQSVContext::nb_ext_buffers
int nb_ext_buffers
Definition: qsv.h:52
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:408
print_interlace_msg
static void print_interlace_msg(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1594
QSVEncContext::exthevctiles
mfxExtHEVCTiles exthevctiles
Definition: qsvenc.h:155
if
if(ret)
Definition: filter_design.txt:179
free_encoder_ctrl_payloads
static void free_encoder_ctrl_payloads(mfxEncodeCtrl *enc_ctrl)
Definition: qsvenc.c:1433
ff_qsv_init_session_frames
int ff_qsv_init_session_frames(AVCodecContext *avctx, mfxSession *psession, QSVFramesContext *qsv_frames_ctx, const char *load_plugins, int opaque, int gpu_copy)
Definition: qsv.c:1023
check_enc_param
static int check_enc_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:505
update_max_frame_size
static int update_max_frame_size(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1696
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1208
QSVFrame
Definition: qsv_internal.h:80
QSVEncContext::int_ref_cycle_size
int int_ref_cycle_size
Definition: qsvenc.h:217
QSVEncContext::opaque_surfaces
mfxFrameSurface1 ** opaque_surfaces
Definition: qsvenc.h:160
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:982
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
QSVEncContext::req
mfxFrameAllocRequest req
Definition: qsvenc.h:146
qsv.h
QSV_HAVE_OPAQUE
#define QSV_HAVE_OPAQUE
Definition: qsv_internal.h:69
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
QSVEncContext::look_ahead_downsampling
int look_ahead_downsampling
Definition: qsvenc.h:189
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:448
init_video_param
static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:603
QSVEncContext::max_dec_frame_buffering
int max_dec_frame_buffering
Definition: qsvenc.h:205
AVRegionOfInterest::self_size
uint32_t self_size
Must be set to the size of this data structure (that is, sizeof(AVRegionOfInterest)).
Definition: frame.h:255
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
QSVFrame::payloads
mfxPayload * payloads[QSV_MAX_ENC_PAYLOAD]
used for enc_ctrl.Payload
Definition: qsv_internal.h:91
QSVEncContext::old_max_frame_size
int old_max_frame_size
Definition: qsvenc.h:255
get_free_frame
static int get_free_frame(QSVEncContext *q, QSVFrame **f)
Definition: qsvenc.c:1476
ff_qsv_print_iopattern
int ff_qsv_print_iopattern(void *log_ctx, int mfx_iopattern, const char *extra_string)
Definition: qsv.c:100
av_fifo_can_read
size_t av_fifo_can_read(const AVFifo *f)
Definition: fifo.c:87
QSVFrame::surface
mfxFrameSurface1 surface
Definition: qsv_internal.h:82
print_profile
static const char * print_profile(enum AVCodecID codec_id, mfxU16 profile)
Definition: qsvenc.c:91
time.h
QSVFramesContext::mids_buf
AVBufferRef * mids_buf
Definition: qsv_internal.h:117
AVCodecContext::trellis
int trellis
trellis RD quantization
Definition: avcodec.h:1258
update_low_delay_brc
static int update_low_delay_brc(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1821
AV_PIX_FMT_QSV
@ AV_PIX_FMT_QSV
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
Definition: pixfmt.h:212
QSVEncContext::extparam_internal
mfxExtBuffer * extparam_internal[5+(QSV_HAVE_MF *2)]
Definition: qsvenc.h:166
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:479
AVCodecContext::level
int level
level
Definition: avcodec.h:1695
QSVEncContext::mbbrc
int mbbrc
Definition: qsvenc.h:208
FrameInfo
Definition: af_amix.c:57
QSVPacket::pkt
AVPacket pkt
Definition: qsvenc.c:86
QSVEncContext::preset
int preset
Definition: qsvenc.h:183
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
QSVPacket::sync
mfxSyncPoint * sync
Definition: qsvenc.c:87
ff_qsv_map_pixfmt
int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc)
Definition: qsv.c:220
QSV_MAX_ENC_EXTPARAM
#define QSV_MAX_ENC_EXTPARAM
Definition: qsv_internal.h:54
AVQSVContext::opaque_surfaces
AVBufferRef * opaque_surfaces
Encoding only, and only if opaque_alloc is set to non-zero.
Definition: qsv.h:92
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:521
QSVEncContext::min_qp_p
int min_qp_p
Definition: qsvenc.h:245
f
f
Definition: af_crystalizer.c:122
HW_CONFIG_ENCODER_DEVICE
#define HW_CONFIG_ENCODER_DEVICE(format, device_type_)
Definition: hwconfig.h:94
QSVEncContext::extmfp
mfxExtMultiFrameParam extmfp
Definition: qsvenc.h:152
AVPacket::size
int size
Definition: packet.h:375
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:593
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:353
profile_names
Definition: qsvenc.c:46
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:771
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
QSVEncContext::avbr_convergence
int avbr_convergence
Definition: qsvenc.h:185
AVQSVContext::session
mfxSession session
If non-NULL, the session to use for encoding or decoding.
Definition: qsv.h:41
QSVEncContext::opaque_alloc_buf
AVBufferRef * opaque_alloc_buf
Definition: qsvenc.h:161
QSVEncContext::min_qp_b
int min_qp_b
Definition: qsvenc.h:247
QSVEncContext::old_min_qp_b
int old_min_qp_b
Definition: qsvenc.h:271
QSVEncContext::extco2
mfxExtCodingOption2 extco2
Definition: qsvenc.h:149
QSVEncContext::max_qp_b
int max_qp_b
Definition: qsvenc.h:246
AVFrameSideData::data
uint8_t * data
Definition: frame.h:233
QSVEncContext::old_low_delay_brc
int old_low_delay_brc
Definition: qsvenc.h:273
QSVEncContext::co2_idx
int co2_idx
Definition: qsvenc.h:237
qsv_init_opaque_alloc
static int qsv_init_opaque_alloc(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1200
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:412
AVCodecHWConfigInternal
Definition: hwconfig.h:29
AV_PICTURE_TYPE_NONE
@ AV_PICTURE_TYPE_NONE
Undefined.
Definition: avutil.h:273
AVCPBProperties::min_bitrate
int64_t min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: defs.h:114
AVQSVContext::ext_buffers
mfxExtBuffer ** ext_buffers
Extra buffers to pass to encoder or decoder initialization.
Definition: qsv.h:51
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:373
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
QSVEncContext::max_slice_size
int max_slice_size
Definition: qsvenc.h:195
QSVEncContext::max_frame_size_i
int max_frame_size_i
Definition: qsvenc.h:193
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: defs.h:119
AVRegionOfInterest::right
int right
Definition: frame.h:268
FF_COMPLIANCE_NORMAL
#define FF_COMPLIANCE_NORMAL
Definition: avcodec.h:1312
QSVEncContext::mfmode
int mfmode
Definition: qsvenc.h:230
QSVEncContext::work_frames
QSVFrame * work_frames
Definition: qsvenc.h:136
AVCodecContext::b_quant_factor
float b_quant_factor
qscale factor between IP and B-frames If > 0 then the last P-frame quantizer will be used (q= lastp_q...
Definition: avcodec.h:679
QSVFramesContext::mids
QSVMid * mids
Definition: qsv_internal.h:118
QSVEncContext::old_i_quant_offset
float old_i_quant_offset
Definition: qsvenc.h:251
QSVEncContext::bitrate_limit
int bitrate_limit
Definition: qsvenc.h:207
QSVEncContext::rdo
int rdo
Definition: qsvenc.h:191
QSVEncContext::opaque_alloc
mfxExtOpaqueSurfaceAlloc opaque_alloc
Definition: qsvenc.h:159
HW_CONFIG_ENCODER_FRAMES
#define HW_CONFIG_ENCODER_FRAMES(format, device_type_)
Definition: hwconfig.h:97
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:59
QSVEncContext::single_sei_nal_unit
int single_sei_nal_unit
Definition: qsvenc.h:204
QSVEncContext::dblk_idc
int dblk_idc
Definition: qsvenc.h:196
AVRegionOfInterest::left
int left
Definition: frame.h:267
hwcontext_qsv.h
ff_qsv_enc_close
int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:2069
QSVEncContext::set_encode_ctrl_cb
SetEncodeCtrlCB * set_encode_ctrl_cb
Definition: qsvenc.h:233
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
UPDATE_PARAM
#define UPDATE_PARAM(a, b)
Definition: qsvenc.c:151
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:499
QSVEncContext::internal_qs
QSVSession internal_qs
Definition: qsvenc.h:139
AVRegionOfInterest::top
int top
Distance in pixels from the top edge of the frame to the top and bottom edges and from the left edge ...
Definition: frame.h:265
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
common.h
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:109
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
QSVEncContext::extco3
mfxExtCodingOption3 extco3
Definition: qsvenc.h:150
QSVEncContext::extparam
mfxExtBuffer ** extparam
Definition: qsvenc.h:169
QSVEncContext::async_depth
int async_depth
Definition: qsvenc.h:180
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:487
submit_frame
static int submit_frame(QSVEncContext *q, const AVFrame *frame, QSVFrame **new_frame)
Definition: qsvenc.c:1513
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
QSVEncContext::cavlc
int cavlc
Definition: qsvenc.h:214
AVCodecContext::hw_device_ctx
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
Definition: avcodec.h:1952
profile
int profile
Definition: mxfenc.c:2005
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:553
clear_unused_frames
static void clear_unused_frames(QSVEncContext *q)
Definition: qsvenc.c:1456
dump_video_param
static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q, mfxExtBuffer **coding_opts)
Definition: qsvenc.c:177
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
free_encoder_ctrl_extparam
static void free_encoder_ctrl_extparam(mfxEncodeCtrl *enc_ctrl)
Definition: qsvenc.c:1444
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
update_qp
static int update_qp(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1667
QSVEncContext::old_qmax
int old_qmax
Definition: qsvenc.h:264
QSVEncContext::aud
int aud
Definition: qsvenc.h:202
AVCodecContext::hw_frames_ctx
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.
Definition: avcodec.h:1902
avcodec.h
QSVEncContext::int_ref_type
int int_ref_type
Definition: qsvenc.h:216
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:124
QSVEncContext::old_min_qp_i
int old_min_qp_i
Definition: qsvenc.h:267
profile_names::profile
mfxU16 profile
Definition: qsvenc.c:47
av_buffer_allocz
AVBufferRef * av_buffer_allocz(size_t size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:93
AV_CODEC_FLAG_CLOSED_GOP
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:298
ret
ret
Definition: filter_design.txt:187
print_ratecontrol
static const char * print_ratecontrol(mfxU16 rc_mode)
Definition: qsvenc.c:159
QSVEncContext::max_qp_p
int max_qp_p
Definition: qsvenc.h:244
QSVEncContext::look_ahead
int look_ahead
Definition: qsvenc.h:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AVCPBProperties::buffer_size
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: defs.h:125
UNMATCH
#define UNMATCH(x)
AVHWFramesContext::hwctx
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:162
ff_qsv_codec_id_to_mfx
int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)
Definition: qsv.c:54
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1309
av_fifo_alloc2
AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)
Allocate and initialize an AVFifo with a given element size.
Definition: fifo.c:47
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
QSVPacket
Definition: qsvenc.c:85
QSVEncContext::async_fifo
AVFifo * async_fifo
Definition: qsvenc.h:171
QSVEncContext::co3_idx
int co3_idx
Definition: qsvenc.h:238
QSVEncContext::int_ref_cycle_dist
int int_ref_cycle_dist
Definition: qsvenc.h:219
AVCodecContext
main external API structure.
Definition: avcodec.h:398
AVFrame::height
int height
Definition: frame.h:397
QSVEncContext::b_strategy
int b_strategy
Definition: qsvenc.h:212
QSVEncContext::old_b_quant_factor
float old_b_quant_factor
Definition: qsvenc.h:252
encode_frame
static int encode_frame(AVCodecContext *avctx, QSVEncContext *q, const AVFrame *frame)
Definition: qsvenc.c:1890
QSVEncContext::gpb
int gpb
Definition: qsvenc.h:224
QSVEncContext::vcm
int vcm
Definition: qsvenc.h:190
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
AVCodecContext::qmin
int qmin
minimum quantizer
Definition: avcodec.h:1187
AVRational::den
int den
Denominator.
Definition: rational.h:60
QSVEncContext::idr_interval
int idr_interval
Definition: qsvenc.h:181
AVQSVContext
This struct is used for communicating QSV parameters between libavcodec and the caller.
Definition: qsv.h:36
QSVSession::session
mfxSession session
Definition: qsv_internal.h:101
AVCodecContext::i_quant_offset
float i_quant_offset
qscale offset between P and I-frames
Definition: avcodec.h:710
AV_CODEC_ID_H265
#define AV_CODEC_ID_H265
Definition: codec_id.h:227
profiles
static const AVProfile profiles[]
Definition: libfdk-aacenc.c:429
QSVEncContext::ver
mfxVersion ver
Definition: qsvenc.h:175
QSVEncContext::session
mfxSession session
Definition: qsvenc.h:138
AVQSVFramesContext
This struct is allocated as AVHWFramesContext.hwctx.
Definition: hwcontext_qsv.h:53
desc
const char * desc
Definition: libsvtav1.c:83
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
QSV_MAX_ENC_PAYLOAD
#define QSV_MAX_ENC_PAYLOAD
Definition: qsv_internal.h:53
mem.h
AVCodecContext::max_b_frames
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:670
ff_qsv_enc_init
int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1284
packet_internal.h
QSVEncContext::old_qmin
int old_qmin
Definition: qsvenc.h:265
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:231
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
QSVEncContext::old_min_qp_p
int old_min_qp_p
Definition: qsvenc.h:269
AVQSVContext::opaque_alloc
int opaque_alloc
Encoding only.
Definition: qsv.h:67
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecContext::slices
int slices
Number of slices.
Definition: avcodec.h:998
AVPacket
This structure stores compressed data.
Definition: packet.h:351
QSVEncContext::extvp9param
mfxExtVP9Param extvp9param
Definition: qsvenc.h:156
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
QSVEncContext::low_delay_brc
int low_delay_brc
Definition: qsvenc.h:235
QSVEncContext::transform_skip
int transform_skip
Definition: qsvenc.h:225
FFMAX3
#define FFMAX3(a, b, c)
Definition: macros.h:48
QSVEncContext::width_align
int width_align
Definition: qsvenc.h:142
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
bytestream.h
AV_FRAME_DATA_REGIONS_OF_INTEREST
@ AV_FRAME_DATA_REGIONS_OF_INTEREST
Regions Of Interest, the data is an array of AVRegionOfInterest type, the number of array element is ...
Definition: frame.h:165
imgutils.h
vp9_profiles
static const struct profile_names vp9_profiles[]
Definition: qsvenc.c:78
QSVEncContext::scenario
int scenario
Definition: qsvenc.h:197
hwcontext.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
QSV_MAX_ROI_NUM
#define QSV_MAX_ROI_NUM
Definition: qsv_internal.h:56
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
av_fifo_freep2
void av_fifo_freep2(AVFifo **f)
Free an AVFifo and reset pointer to NULL.
Definition: fifo.c:286
mpeg2_profiles
static const struct profile_names mpeg2_profiles[]
Definition: qsvenc.c:62
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
qsv_retrieve_enc_jpeg_params
static int qsv_retrieve_enc_jpeg_params(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1007
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1761
avc_profiles
static const struct profile_names avc_profiles[]
Definition: qsvenc.c:51
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
rc_mode
mfxU16 rc_mode
Definition: qsvenc.c:129
QSVEncContext::avctx
AVCodecContext * avctx
Definition: qsvenc.h:134
QSVEncContext::old_i_quant_factor
float old_i_quant_factor
Definition: qsvenc.h:250
QSVFrame::next
struct QSVFrame * next
Definition: qsv_internal.h:97
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
ff_qsv_print_error
int ff_qsv_print_error(void *log_ctx, mfxStatus err, const char *error_string)
Definition: qsv.c:185
AVRegionOfInterest::qoffset
AVRational qoffset
Quantisation offset.
Definition: frame.h:292
ff_qsv_init_internal_session
int ff_qsv_init_internal_session(AVCodecContext *avctx, QSVSession *qs, const char *load_plugins, int gpu_copy)
Definition: qsv.c:635
QSVEncContext::tile_rows
int tile_rows
Definition: qsvenc.h:200
ff_qsv_encode
int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: qsvenc.c:2003
QSVEncContext::vp9_idx
int vp9_idx
Definition: qsvenc.h:240
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:768
QSVEncContext::old_max_qp_b
int old_max_qp_b
Definition: qsvenc.h:270
QSVEncContext::old_b_quant_offset
float old_b_quant_offset
Definition: qsvenc.h:253
hevc_profiles
static const struct profile_names hevc_profiles[]
Definition: qsvenc.c:68
AVCodecContext::compression_level
int compression_level
Definition: avcodec.h:470
qsvenc_init_session
static int qsvenc_init_session(AVCodecContext *avctx, QSVEncContext *q)
Definition: qsvenc.c:1238
QSVEncContext::old_int_ref_cycle_dist
int old_int_ref_cycle_dist
Definition: qsvenc.h:262
QSVEncContext::low_power
int low_power
Definition: qsvenc.h:223
QSVEncContext::old_max_qp_p
int old_max_qp_p
Definition: qsvenc.h:268
QSVPacket::bs
mfxBitstream * bs
Definition: qsvenc.c:88