FFmpeg
qsvdec.c
Go to the documentation of this file.
1 /*
2  * Intel MediaSDK QSV codec-independent code
3  *
4  * copyright (c) 2013 Luca Barbato
5  * copyright (c) 2015 Anton Khirnov <anton@khirnov.net>
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 <stdint.h>
27 #include <string.h>
28 #include <sys/types.h>
29 
30 #include <mfxvideo.h>
31 
32 #include "libavutil/common.h"
33 #include "libavutil/fifo.h"
34 #include "libavutil/frame.h"
35 #include "libavutil/hwcontext.h"
37 #include "libavutil/mem.h"
38 #include "libavutil/log.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/pixfmt.h"
41 #include "libavutil/time.h"
42 #include "libavutil/imgutils.h"
45 
46 #include "avcodec.h"
47 #include "codec_internal.h"
48 #include "internal.h"
49 #include "decode.h"
50 #include "hwconfig.h"
51 #include "qsv.h"
52 #include "qsv_internal.h"
53 
54 #if QSV_ONEVPL
55 #include <mfxdispatcher.h>
56 #else
57 #define MFXUnload(a) do { } while(0)
58 #endif
59 
60 static const AVRational mfx_tb = { 1, 90000 };
61 
62 #define PTS_TO_MFX_PTS(pts, pts_tb) ((pts) == AV_NOPTS_VALUE ? \
63  MFX_TIMESTAMP_UNKNOWN : pts_tb.num ? \
64  av_rescale_q(pts, pts_tb, mfx_tb) : pts)
65 
66 #define MFX_PTS_TO_PTS(mfx_pts, pts_tb) ((mfx_pts) == MFX_TIMESTAMP_UNKNOWN ? \
67  AV_NOPTS_VALUE : pts_tb.num ? \
68  av_rescale_q(mfx_pts, mfx_tb, pts_tb) : mfx_pts)
69 
70 typedef struct QSVAsyncFrame {
71  mfxSyncPoint *sync;
74 
75 typedef struct QSVContext {
76  // the session used for decoding
77  mfxSession session;
78  mfxVersion ver;
79 
80  // the session we allocated internally, in case the caller did not provide
81  // one
83 
85 
86  /**
87  * a linked list of frames currently being used by QSV
88  */
90 
94 
96  uint32_t fourcc;
97  mfxFrameInfo frame_info;
101 
102  // options set by the caller
105  int gpu_copy;
106 
108 
109  mfxExtBuffer **ext_buffers;
111 } QSVContext;
112 
113 static const AVCodecHWConfigInternal *const qsv_hw_configs[] = {
114  &(const AVCodecHWConfigInternal) {
115  .public = {
119  .device_type = AV_HWDEVICE_TYPE_QSV,
120  },
121  .hwaccel = NULL,
122  },
123  NULL
124 };
125 
127  AVBufferPool *pool)
128 {
129  int ret = 0;
130 
131  ret = ff_decode_frame_props(avctx, frame);
132  if (ret < 0)
133  return ret;
134 
135  frame->width = avctx->width;
136  frame->height = avctx->height;
137 
138  switch (avctx->pix_fmt) {
139  case AV_PIX_FMT_NV12:
140  frame->linesize[0] = FFALIGN(avctx->width, 128);
141  break;
142  case AV_PIX_FMT_P010:
143  case AV_PIX_FMT_P012:
144  case AV_PIX_FMT_YUYV422:
145  frame->linesize[0] = 2 * FFALIGN(avctx->width, 128);
146  break;
147  case AV_PIX_FMT_Y210:
148  case AV_PIX_FMT_VUYX:
149  case AV_PIX_FMT_XV30:
150  case AV_PIX_FMT_Y212:
151  frame->linesize[0] = 4 * FFALIGN(avctx->width, 128);
152  break;
153  case AV_PIX_FMT_XV36:
154  frame->linesize[0] = 8 * FFALIGN(avctx->width, 128);
155  break;
156  default:
157  av_log(avctx, AV_LOG_ERROR, "Unsupported pixel format.\n");
158  return AVERROR(EINVAL);
159  }
160 
161  frame->buf[0] = av_buffer_pool_get(pool);
162  if (!frame->buf[0])
163  return AVERROR(ENOMEM);
164 
165  frame->data[0] = frame->buf[0]->data;
166  if (avctx->pix_fmt == AV_PIX_FMT_NV12 ||
167  avctx->pix_fmt == AV_PIX_FMT_P010 ||
168  avctx->pix_fmt == AV_PIX_FMT_P012) {
169  frame->linesize[1] = frame->linesize[0];
170  frame->data[1] = frame->data[0] +
171  frame->linesize[0] * FFALIGN(avctx->height, 64);
172  }
173 
175  if (ret < 0)
176  return ret;
177 
178  return 0;
179 }
180 
181 static int qsv_init_session(AVCodecContext *avctx, QSVContext *q, mfxSession session,
182  AVBufferRef *hw_frames_ref, AVBufferRef *hw_device_ref)
183 {
184  int ret;
185 
186  if (q->gpu_copy == MFX_GPUCOPY_ON &&
187  !(q->iopattern & MFX_IOPATTERN_OUT_SYSTEM_MEMORY)) {
188  av_log(avctx, AV_LOG_WARNING, "GPU-accelerated memory copy "
189  "only works in system memory mode.\n");
190  q->gpu_copy = MFX_GPUCOPY_OFF;
191  }
192  if (session) {
193  q->session = session;
194  } else if (hw_frames_ref) {
195  if (q->internal_qs.session) {
196  MFXClose(q->internal_qs.session);
197  q->internal_qs.session = NULL;
198  }
200 
201  q->frames_ctx.hw_frames_ctx = av_buffer_ref(hw_frames_ref);
202  if (!q->frames_ctx.hw_frames_ctx)
203  return AVERROR(ENOMEM);
204 
206  &q->frames_ctx, q->load_plugins,
207 #if QSV_HAVE_OPAQUE
208  q->iopattern == MFX_IOPATTERN_OUT_OPAQUE_MEMORY,
209 #else
210  0,
211 #endif
212  q->gpu_copy);
213  if (ret < 0) {
215  return ret;
216  }
217 
218  q->session = q->internal_qs.session;
219  } else if (hw_device_ref) {
220  if (q->internal_qs.session) {
221  MFXClose(q->internal_qs.session);
222  q->internal_qs.session = NULL;
223  }
224 
226  hw_device_ref, q->load_plugins, q->gpu_copy);
227  if (ret < 0)
228  return ret;
229 
230  q->session = q->internal_qs.session;
231  } else {
232  if (!q->internal_qs.session) {
234  q->load_plugins, q->gpu_copy);
235  if (ret < 0)
236  return ret;
237  }
238 
239  q->session = q->internal_qs.session;
240  }
241 
242  if (MFXQueryVersion(q->session, &q->ver) != MFX_ERR_NONE) {
243  av_log(avctx, AV_LOG_ERROR, "Error querying the session version. \n");
244  q->session = NULL;
245 
246  if (q->internal_qs.session) {
247  MFXClose(q->internal_qs.session);
248  q->internal_qs.session = NULL;
249  }
250 
251  if (q->internal_qs.loader) {
253  q->internal_qs.loader = NULL;
254  }
255 
256  return AVERROR_EXTERNAL;
257  }
258 
259  /* make sure the decoder is uninitialized */
260  MFXVideoDECODE_Close(q->session);
261 
262  return 0;
263 }
264 
265 static int qsv_decode_preinit(AVCodecContext *avctx, QSVContext *q, enum AVPixelFormat pix_fmt, mfxVideoParam *param)
266 {
267  mfxSession session = NULL;
268  int iopattern = 0;
269  int ret;
270  enum AVPixelFormat pix_fmts[3] = {
271  AV_PIX_FMT_QSV, /* opaque format in case of video memory output */
272  pix_fmt, /* system memory format obtained from bitstream parser */
273  AV_PIX_FMT_NONE };
274 
275  ret = ff_get_format(avctx, pix_fmts);
276  if (ret < 0) {
277  q->orig_pix_fmt = avctx->pix_fmt = AV_PIX_FMT_NONE;
278  return ret;
279  }
280 
281  if (!q->async_fifo) {
282  q->async_fifo = av_fifo_alloc2(q->async_depth, sizeof(QSVAsyncFrame), 0);
283  if (!q->async_fifo)
284  return AVERROR(ENOMEM);
285  }
286 
287  if (avctx->pix_fmt == AV_PIX_FMT_QSV && avctx->hwaccel_context) {
288  AVQSVContext *user_ctx = avctx->hwaccel_context;
289  session = user_ctx->session;
290  iopattern = user_ctx->iopattern;
291  q->ext_buffers = user_ctx->ext_buffers;
292  q->nb_ext_buffers = user_ctx->nb_ext_buffers;
293  }
294 
295  if (avctx->hw_device_ctx && !avctx->hw_frames_ctx && ret == AV_PIX_FMT_QSV) {
296  AVHWFramesContext *hwframes_ctx;
297  AVQSVFramesContext *frames_hwctx;
298 
300 
301  if (!avctx->hw_frames_ctx) {
302  av_log(avctx, AV_LOG_ERROR, "av_hwframe_ctx_alloc failed\n");
303  return AVERROR(ENOMEM);
304  }
305 
306  hwframes_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
307  frames_hwctx = hwframes_ctx->hwctx;
308  hwframes_ctx->width = FFALIGN(avctx->coded_width, 32);
309  hwframes_ctx->height = FFALIGN(avctx->coded_height, 32);
310  hwframes_ctx->format = AV_PIX_FMT_QSV;
311  hwframes_ctx->sw_format = avctx->sw_pix_fmt;
312  hwframes_ctx->initial_pool_size = q->suggest_pool_size + 16 + avctx->extra_hw_frames;
313  frames_hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
314 
316 
317  if (ret < 0) {
318  av_log(NULL, AV_LOG_ERROR, "Error initializing a QSV frame pool\n");
320  return ret;
321  }
322  }
323 
324  if (avctx->hw_frames_ctx) {
325  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
326  AVQSVFramesContext *frames_hwctx = frames_ctx->hwctx;
327 
328  if (!iopattern) {
329 #if QSV_HAVE_OPAQUE
330  if (frames_hwctx->frame_type & MFX_MEMTYPE_OPAQUE_FRAME)
331  iopattern = MFX_IOPATTERN_OUT_OPAQUE_MEMORY;
332  else if (frames_hwctx->frame_type & MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET)
333  iopattern = MFX_IOPATTERN_OUT_VIDEO_MEMORY;
334 #else
335  if (frames_hwctx->frame_type & MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET)
336  iopattern = MFX_IOPATTERN_OUT_VIDEO_MEMORY;
337 #endif
338  }
339  }
340 
341  if (!iopattern)
342  iopattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
343  q->iopattern = iopattern;
344 
345  ff_qsv_print_iopattern(avctx, q->iopattern, "Decoder");
346 
347  ret = qsv_init_session(avctx, q, session, avctx->hw_frames_ctx, avctx->hw_device_ctx);
348  if (ret < 0) {
349  av_log(avctx, AV_LOG_ERROR, "Error initializing an MFX session\n");
350  return ret;
351  }
352 
353  param->IOPattern = q->iopattern;
354  param->AsyncDepth = q->async_depth;
355  param->ExtParam = q->ext_buffers;
356  param->NumExtParam = q->nb_ext_buffers;
357 
358  return 0;
359  }
360 
361 static int qsv_decode_init_context(AVCodecContext *avctx, QSVContext *q, mfxVideoParam *param)
362 {
363  int ret;
364 
365  avctx->width = param->mfx.FrameInfo.CropW;
366  avctx->height = param->mfx.FrameInfo.CropH;
367  avctx->coded_width = param->mfx.FrameInfo.Width;
368  avctx->coded_height = param->mfx.FrameInfo.Height;
369  avctx->level = param->mfx.CodecLevel;
370  avctx->profile = param->mfx.CodecProfile;
371  avctx->field_order = ff_qsv_map_picstruct(param->mfx.FrameInfo.PicStruct);
372  avctx->pix_fmt = ff_qsv_map_fourcc(param->mfx.FrameInfo.FourCC);
373 
374  ret = MFXVideoDECODE_Init(q->session, param);
375  if (ret < 0)
376  return ff_qsv_print_error(avctx, ret,
377  "Error initializing the MFX video decoder");
378 
379  q->frame_info = param->mfx.FrameInfo;
380 
381  if (!avctx->hw_frames_ctx)
383  FFALIGN(avctx->width, 128), FFALIGN(avctx->height, 64), 1), av_buffer_allocz);
384  return 0;
385 }
386 
388  const AVPacket *avpkt, enum AVPixelFormat pix_fmt,
389  mfxVideoParam *param)
390 {
391  int ret;
392  mfxExtVideoSignalInfo video_signal_info = { 0 };
393  mfxExtBuffer *header_ext_params[1] = { (mfxExtBuffer *)&video_signal_info };
394  mfxBitstream bs = { 0 };
395 
396  if (avpkt->size) {
397  bs.Data = avpkt->data;
398  bs.DataLength = avpkt->size;
399  bs.MaxLength = bs.DataLength;
400  bs.TimeStamp = PTS_TO_MFX_PTS(avpkt->pts, avctx->pkt_timebase);
401  if (avctx->field_order == AV_FIELD_PROGRESSIVE)
402  bs.DataFlag |= MFX_BITSTREAM_COMPLETE_FRAME;
403  } else
404  return AVERROR_INVALIDDATA;
405 
406 
407  if(!q->session) {
408  ret = qsv_decode_preinit(avctx, q, pix_fmt, param);
409  if (ret < 0)
410  return ret;
411  }
412 
414  if (ret < 0)
415  return ret;
416 
417  param->mfx.CodecId = ret;
418  video_signal_info.Header.BufferId = MFX_EXTBUFF_VIDEO_SIGNAL_INFO;
419  video_signal_info.Header.BufferSz = sizeof(video_signal_info);
420  // The SDK doesn't support other ext buffers when calling MFXVideoDECODE_DecodeHeader,
421  // so do not append this buffer to the existent buffer array
422  param->ExtParam = header_ext_params;
423  param->NumExtParam = 1;
424  ret = MFXVideoDECODE_DecodeHeader(q->session, &bs, param);
425  if (MFX_ERR_MORE_DATA == ret) {
426  return AVERROR(EAGAIN);
427  }
428  if (ret < 0)
429  return ff_qsv_print_error(avctx, ret,
430  "Error decoding stream header");
431 
432  avctx->color_range = video_signal_info.VideoFullRange ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
433 
434  if (video_signal_info.ColourDescriptionPresent) {
435  avctx->color_primaries = video_signal_info.ColourPrimaries;
436  avctx->color_trc = video_signal_info.TransferCharacteristics;
437  avctx->colorspace = video_signal_info.MatrixCoefficients;
438  }
439 
440  param->ExtParam = q->ext_buffers;
441  param->NumExtParam = q->nb_ext_buffers;
442 
443 #if QSV_VERSION_ATLEAST(1, 34)
444  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 34) && avctx->codec_id == AV_CODEC_ID_AV1)
445  param->mfx.FilmGrain = (avctx->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN) ? 0 : param->mfx.FilmGrain;
446 #endif
447 
448  return 0;
449 }
450 
452 {
453  int ret;
454 
455  if (q->pool)
456  ret = qsv_get_continuous_buffer(avctx, frame->frame, q->pool);
457  else
458  ret = ff_get_buffer(avctx, frame->frame, AV_GET_BUFFER_FLAG_REF);
459 
460  if (ret < 0)
461  return ret;
462 
463  if (frame->frame->format == AV_PIX_FMT_QSV) {
464  frame->surface = *(mfxFrameSurface1*)frame->frame->data[3];
465  } else {
466  ret = ff_qsv_map_frame_to_surface(frame->frame, &frame->surface);
467  if (ret < 0) {
468  av_log(avctx, AV_LOG_ERROR, "map frame to surface failed.\n");
469  return ret;
470  }
471  }
472 
473  frame->surface.Info = q->frame_info;
474 
475  if (q->frames_ctx.mids) {
477  if (ret < 0)
478  return ret;
479 
480  frame->surface.Data.MemId = &q->frames_ctx.mids[ret];
481  }
482 
483  frame->surface.Data.ExtParam = frame->ext_param;
484  frame->surface.Data.NumExtParam = 0;
485  frame->num_ext_params = 0;
486  frame->dec_info.Header.BufferId = MFX_EXTBUFF_DECODED_FRAME_INFO;
487  frame->dec_info.Header.BufferSz = sizeof(frame->dec_info);
488  ff_qsv_frame_add_ext_param(avctx, frame, (mfxExtBuffer *)&frame->dec_info);
489 #if QSV_VERSION_ATLEAST(1, 34)
490  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 34) && avctx->codec_id == AV_CODEC_ID_AV1) {
491  frame->av1_film_grain_param.Header.BufferId = MFX_EXTBUFF_AV1_FILM_GRAIN_PARAM;
492  frame->av1_film_grain_param.Header.BufferSz = sizeof(frame->av1_film_grain_param);
493  frame->av1_film_grain_param.FilmGrainFlags = 0;
494  ff_qsv_frame_add_ext_param(avctx, frame, (mfxExtBuffer *)&frame->av1_film_grain_param);
495  }
496 #endif
497 
498 #if QSV_VERSION_ATLEAST(1, 35)
499  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 35) && avctx->codec_id == AV_CODEC_ID_HEVC) {
500  frame->mdcv.Header.BufferId = MFX_EXTBUFF_MASTERING_DISPLAY_COLOUR_VOLUME;
501  frame->mdcv.Header.BufferSz = sizeof(frame->mdcv);
502  // The data in mdcv is valid when this flag is 1
503  frame->mdcv.InsertPayloadToggle = 0;
504  ff_qsv_frame_add_ext_param(avctx, frame, (mfxExtBuffer *)&frame->mdcv);
505 
506  frame->clli.Header.BufferId = MFX_EXTBUFF_CONTENT_LIGHT_LEVEL_INFO;
507  frame->clli.Header.BufferSz = sizeof(frame->clli);
508  // The data in clli is valid when this flag is 1
509  frame->clli.InsertPayloadToggle = 0;
510  ff_qsv_frame_add_ext_param(avctx, frame, (mfxExtBuffer *)&frame->clli);
511  }
512 #endif
513 
514  frame->used = 1;
515 
516  return 0;
517 }
518 
520 {
521  QSVFrame *cur = q->work_frames;
522  while (cur) {
523  if (cur->used && !cur->surface.Data.Locked && !cur->queued) {
524  cur->used = 0;
525  av_frame_unref(cur->frame);
526  }
527  cur = cur->next;
528  }
529 }
530 
531 static int get_surface(AVCodecContext *avctx, QSVContext *q, mfxFrameSurface1 **surf)
532 {
533  QSVFrame *frame, **last;
534  int ret;
535 
537 
538  frame = q->work_frames;
539  last = &q->work_frames;
540  while (frame) {
541  if (!frame->used) {
542  ret = alloc_frame(avctx, q, frame);
543  if (ret < 0)
544  return ret;
545  *surf = &frame->surface;
546  return 0;
547  }
548 
549  last = &frame->next;
550  frame = frame->next;
551  }
552 
553  frame = av_mallocz(sizeof(*frame));
554  if (!frame)
555  return AVERROR(ENOMEM);
556  frame->frame = av_frame_alloc();
557  if (!frame->frame) {
558  av_freep(&frame);
559  return AVERROR(ENOMEM);
560  }
561  *last = frame;
562 
563  ret = alloc_frame(avctx, q, frame);
564  if (ret < 0)
565  return ret;
566 
567  *surf = &frame->surface;
568 
569  return 0;
570 }
571 
572 static QSVFrame *find_frame(QSVContext *q, mfxFrameSurface1 *surf)
573 {
574  QSVFrame *cur = q->work_frames;
575  while (cur) {
576  if (surf == &cur->surface)
577  return cur;
578  cur = cur->next;
579  }
580  return NULL;
581 }
582 
583 #if QSV_VERSION_ATLEAST(1, 34)
584 static int qsv_export_film_grain(AVCodecContext *avctx, mfxExtAV1FilmGrainParam *ext_param, AVFrame *frame)
585 {
586  AVFilmGrainParams *fgp;
588  int i;
589 
590  if (!(ext_param->FilmGrainFlags & MFX_FILM_GRAIN_APPLY))
591  return 0;
592 
594 
595  if (!fgp)
596  return AVERROR(ENOMEM);
597 
599  fgp->seed = ext_param->GrainSeed;
600  aom = &fgp->codec.aom;
601 
602  aom->chroma_scaling_from_luma = !!(ext_param->FilmGrainFlags & MFX_FILM_GRAIN_CHROMA_SCALING_FROM_LUMA);
603  aom->scaling_shift = ext_param->GrainScalingMinus8 + 8;
604  aom->ar_coeff_lag = ext_param->ArCoeffLag;
605  aom->ar_coeff_shift = ext_param->ArCoeffShiftMinus6 + 6;
606  aom->grain_scale_shift = ext_param->GrainScaleShift;
607  aom->overlap_flag = !!(ext_param->FilmGrainFlags & MFX_FILM_GRAIN_OVERLAP);
608  aom->limit_output_range = !!(ext_param->FilmGrainFlags & MFX_FILM_GRAIN_CLIP_TO_RESTRICTED_RANGE);
609 
610  aom->num_y_points = ext_param->NumYPoints;
611 
612  for (i = 0; i < aom->num_y_points; i++) {
613  aom->y_points[i][0] = ext_param->PointY[i].Value;
614  aom->y_points[i][1] = ext_param->PointY[i].Scaling;
615  }
616 
617  aom->num_uv_points[0] = ext_param->NumCbPoints;
618 
619  for (i = 0; i < aom->num_uv_points[0]; i++) {
620  aom->uv_points[0][i][0] = ext_param->PointCb[i].Value;
621  aom->uv_points[0][i][1] = ext_param->PointCb[i].Scaling;
622  }
623 
624  aom->num_uv_points[1] = ext_param->NumCrPoints;
625 
626  for (i = 0; i < aom->num_uv_points[1]; i++) {
627  aom->uv_points[1][i][0] = ext_param->PointCr[i].Value;
628  aom->uv_points[1][i][1] = ext_param->PointCr[i].Scaling;
629  }
630 
631  for (i = 0; i < 24; i++)
632  aom->ar_coeffs_y[i] = ext_param->ArCoeffsYPlus128[i] - 128;
633 
634  for (i = 0; i < 25; i++) {
635  aom->ar_coeffs_uv[0][i] = ext_param->ArCoeffsCbPlus128[i] - 128;
636  aom->ar_coeffs_uv[1][i] = ext_param->ArCoeffsCrPlus128[i] - 128;
637  }
638 
639  aom->uv_mult[0] = ext_param->CbMult;
640  aom->uv_mult[1] = ext_param->CrMult;
641  aom->uv_mult_luma[0] = ext_param->CbLumaMult;
642  aom->uv_mult_luma[1] = ext_param->CrLumaMult;
643  aom->uv_offset[0] = ext_param->CbOffset;
644  aom->uv_offset[1] = ext_param->CrOffset;
645 
646  return 0;
647 }
648 #endif
649 
650 #if QSV_VERSION_ATLEAST(1, 35)
651 static int qsv_export_hdr_side_data(AVCodecContext *avctx, mfxExtMasteringDisplayColourVolume *mdcv,
652  mfxExtContentLightLevelInfo *clli, AVFrame *frame)
653 {
654  // The SDK re-uses this flag for HDR SEI parsing
655  if (mdcv->InsertPayloadToggle) {
657  const int mapping[3] = {2, 0, 1};
658  const int chroma_den = 50000;
659  const int luma_den = 10000;
660  int i;
661 
662  if (!mastering)
663  return AVERROR(ENOMEM);
664 
665  for (i = 0; i < 3; i++) {
666  const int j = mapping[i];
667  mastering->display_primaries[i][0] = av_make_q(mdcv->DisplayPrimariesX[j], chroma_den);
668  mastering->display_primaries[i][1] = av_make_q(mdcv->DisplayPrimariesY[j], chroma_den);
669  }
670 
671  mastering->white_point[0] = av_make_q(mdcv->WhitePointX, chroma_den);
672  mastering->white_point[1] = av_make_q(mdcv->WhitePointY, chroma_den);
673 
674  mastering->max_luminance = av_make_q(mdcv->MaxDisplayMasteringLuminance, luma_den);
675  mastering->min_luminance = av_make_q(mdcv->MinDisplayMasteringLuminance, luma_den);
676 
677  mastering->has_luminance = 1;
678  mastering->has_primaries = 1;
679  }
680 
681  // The SDK re-uses this flag for HDR SEI parsing
682  if (clli->InsertPayloadToggle) {
684 
685  if (!light)
686  return AVERROR(ENOMEM);
687 
688  light->MaxCLL = clli->MaxContentLightLevel;
689  light->MaxFALL = clli->MaxPicAverageLightLevel;
690  }
691 
692  return 0;
693 }
694 
695 #endif
696 
697 static int qsv_decode(AVCodecContext *avctx, QSVContext *q,
698  AVFrame *frame, int *got_frame,
699  const AVPacket *avpkt)
700 {
701  mfxFrameSurface1 *insurf;
702  mfxFrameSurface1 *outsurf;
703  mfxSyncPoint *sync;
704  mfxBitstream bs = { { { 0 } } };
705  int ret;
706 
707  if (avpkt->size) {
708  bs.Data = avpkt->data;
709  bs.DataLength = avpkt->size;
710  bs.MaxLength = bs.DataLength;
711  bs.TimeStamp = PTS_TO_MFX_PTS(avpkt->pts, avctx->pkt_timebase);
712  if (avctx->field_order == AV_FIELD_PROGRESSIVE)
713  bs.DataFlag |= MFX_BITSTREAM_COMPLETE_FRAME;
714  }
715 
716  sync = av_mallocz(sizeof(*sync));
717  if (!sync) {
718  av_freep(&sync);
719  return AVERROR(ENOMEM);
720  }
721 
722  do {
723  ret = get_surface(avctx, q, &insurf);
724  if (ret < 0) {
725  av_freep(&sync);
726  return ret;
727  }
728 
729  ret = MFXVideoDECODE_DecodeFrameAsync(q->session, avpkt->size ? &bs : NULL,
730  insurf, &outsurf, sync);
731  if (ret == MFX_WRN_DEVICE_BUSY)
732  av_usleep(500);
733 
734  } while (ret == MFX_WRN_DEVICE_BUSY || ret == MFX_ERR_MORE_SURFACE);
735 
736  if (ret == MFX_ERR_INCOMPATIBLE_VIDEO_PARAM) {
737  q->reinit_flag = 1;
738  av_log(avctx, AV_LOG_DEBUG, "Video parameter change\n");
739  av_freep(&sync);
740  return 0;
741  }
742 
743  if (ret != MFX_ERR_NONE &&
744  ret != MFX_ERR_MORE_DATA &&
745  ret != MFX_WRN_VIDEO_PARAM_CHANGED &&
746  ret != MFX_ERR_MORE_SURFACE) {
747  av_freep(&sync);
748  return ff_qsv_print_error(avctx, ret,
749  "Error during QSV decoding.");
750  }
751 
752  /* make sure we do not enter an infinite loop if the SDK
753  * did not consume any data and did not return anything */
754  if (!*sync && !bs.DataOffset) {
755  bs.DataOffset = avpkt->size;
756  ++q->zero_consume_run;
757  if (q->zero_consume_run > 1)
758  ff_qsv_print_warning(avctx, ret, "A decode call did not consume any data");
759  } else {
760  q->zero_consume_run = 0;
761  }
762 
763  if (*sync) {
764  QSVAsyncFrame aframe;
765  QSVFrame *out_frame = find_frame(q, outsurf);
766 
767  if (!out_frame) {
768  av_log(avctx, AV_LOG_ERROR,
769  "The returned surface does not correspond to any frame\n");
770  av_freep(&sync);
771  return AVERROR_BUG;
772  }
773 
774  out_frame->queued += 1;
775 
776  aframe = (QSVAsyncFrame){ sync, out_frame };
777  av_fifo_write(q->async_fifo, &aframe, 1);
778  } else {
779  av_freep(&sync);
780  }
781 
782  if ((av_fifo_can_read(q->async_fifo) >= q->async_depth) ||
783  (!avpkt->size && av_fifo_can_read(q->async_fifo))) {
784  QSVAsyncFrame aframe;
785  AVFrame *src_frame;
786 
787  av_fifo_read(q->async_fifo, &aframe, 1);
788  aframe.frame->queued -= 1;
789 
790  if (avctx->pix_fmt != AV_PIX_FMT_QSV) {
791  do {
792  ret = MFXVideoCORE_SyncOperation(q->session, *aframe.sync, 1000);
793  } while (ret == MFX_WRN_IN_EXECUTION);
794  }
795 
796  av_freep(&aframe.sync);
797 
798  src_frame = aframe.frame->frame;
799 
800  ret = av_frame_ref(frame, src_frame);
801  if (ret < 0)
802  return ret;
803 
804  outsurf = &aframe.frame->surface;
805 
806  frame->pts = MFX_PTS_TO_PTS(outsurf->Data.TimeStamp, avctx->pkt_timebase);
807 #if QSV_VERSION_ATLEAST(1, 34)
809  QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 34) &&
810  avctx->codec_id == AV_CODEC_ID_AV1) {
811  ret = qsv_export_film_grain(avctx, &aframe.frame->av1_film_grain_param, frame);
812 
813  if (ret < 0)
814  return ret;
815  }
816 #endif
817 
818 #if QSV_VERSION_ATLEAST(1, 35)
819  if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 35) && avctx->codec_id == AV_CODEC_ID_HEVC) {
820  ret = qsv_export_hdr_side_data(avctx, &aframe.frame->mdcv, &aframe.frame->clli, frame);
821 
822  if (ret < 0)
823  return ret;
824  }
825 #endif
826 
827  frame->repeat_pict =
828  outsurf->Info.PicStruct & MFX_PICSTRUCT_FRAME_TRIPLING ? 4 :
829  outsurf->Info.PicStruct & MFX_PICSTRUCT_FRAME_DOUBLING ? 2 :
830  outsurf->Info.PicStruct & MFX_PICSTRUCT_FIELD_REPEATED ? 1 : 0;
832  !!(outsurf->Info.PicStruct & MFX_PICSTRUCT_FIELD_TFF);
834  !(outsurf->Info.PicStruct & MFX_PICSTRUCT_PROGRESSIVE);
835  frame->pict_type = ff_qsv_map_pictype(aframe.frame->dec_info.FrameType);
836  //Key frame is IDR frame is only suitable for H264. For HEVC, IRAPs are key frames.
837  if (avctx->codec_id == AV_CODEC_ID_H264) {
838  if (aframe.frame->dec_info.FrameType & MFX_FRAMETYPE_IDR)
840  else
842  }
843 
844  /* update the surface properties */
845  if (avctx->pix_fmt == AV_PIX_FMT_QSV)
846  ((mfxFrameSurface1*)frame->data[3])->Info = outsurf->Info;
847 
848  *got_frame = 1;
849  }
850 
851  return bs.DataOffset;
852 }
853 
855 {
856  QSVFrame *cur = q->work_frames;
857 
858  if (q->session)
859  MFXVideoDECODE_Close(q->session);
860 
861  if (q->async_fifo) {
862  QSVAsyncFrame aframe;
863  while (av_fifo_read(q->async_fifo, &aframe, 1) >= 0)
864  av_freep(&aframe.sync);
866  }
867 
868  while (cur) {
869  q->work_frames = cur->next;
870  av_frame_free(&cur->frame);
871  av_freep(&cur);
872  cur = q->work_frames;
873  }
874 
876 
880 }
881 
883  AVFrame *frame, int *got_frame, const AVPacket *pkt)
884 {
885  int ret;
886  mfxVideoParam param = { 0 };
888 
889  if (!pkt->size)
890  return qsv_decode(avctx, q, frame, got_frame, pkt);
891 
892  /* TODO: flush delayed frames on reinit */
893 
894  // sw_pix_fmt, coded_width/height should be set for ff_get_format(),
895  // assume sw_pix_fmt is NV12 and coded_width/height to be 1280x720,
896  // the assumption may be not corret but will be updated after header decoded if not true.
897  if (q->orig_pix_fmt != AV_PIX_FMT_NONE)
898  pix_fmt = q->orig_pix_fmt;
899  if (!avctx->coded_width)
900  avctx->coded_width = 1280;
901  if (!avctx->coded_height)
902  avctx->coded_height = 720;
903 
904  /* decode zero-size pkt to flush the buffered pkt before reinit */
905  if (q->reinit_flag) {
906  AVPacket zero_pkt = {0};
907  ret = qsv_decode(avctx, q, frame, got_frame, &zero_pkt);
908  if (ret < 0 || *got_frame)
909  return ret;
910  }
911 
912  if (q->reinit_flag || !q->session || !q->initialized) {
913  mfxFrameAllocRequest request;
914  memset(&request, 0, sizeof(request));
915 
916  q->reinit_flag = 0;
917  ret = qsv_decode_header(avctx, q, pkt, pix_fmt, &param);
918  if (ret < 0) {
919  if (ret == AVERROR(EAGAIN))
920  av_log(avctx, AV_LOG_VERBOSE, "More data is required to decode header\n");
921  else
922  av_log(avctx, AV_LOG_ERROR, "Error decoding header\n");
923  goto reinit_fail;
924  }
925  param.IOPattern = q->iopattern;
926 
927  q->orig_pix_fmt = avctx->pix_fmt = pix_fmt = ff_qsv_map_fourcc(param.mfx.FrameInfo.FourCC);
928 
929  avctx->coded_width = param.mfx.FrameInfo.Width;
930  avctx->coded_height = param.mfx.FrameInfo.Height;
931 
932  ret = MFXVideoDECODE_QueryIOSurf(q->session, &param, &request);
933  if (ret < 0)
934  return ff_qsv_print_error(avctx, ret, "Error querying IO surface");
935 
936  q->suggest_pool_size = request.NumFrameSuggested;
937 
938  ret = qsv_decode_preinit(avctx, q, pix_fmt, &param);
939  if (ret < 0)
940  goto reinit_fail;
941  q->initialized = 0;
942  }
943 
944  if (!q->initialized) {
945  ret = qsv_decode_init_context(avctx, q, &param);
946  if (ret < 0)
947  goto reinit_fail;
948  q->initialized = 1;
949  }
950 
951  return qsv_decode(avctx, q, frame, got_frame, pkt);
952 
953 reinit_fail:
954  q->orig_pix_fmt = avctx->pix_fmt = AV_PIX_FMT_NONE;
955  return ret;
956 }
957 
962 };
963 
964 typedef struct QSVDecContext {
965  AVClass *class;
967 
969 
971 
973 } QSVDecContext;
974 
976 {
977  AVPacket pkt;
978  while (av_fifo_read(s->packet_fifo, &pkt, 1) >= 0)
980 
981  av_packet_unref(&s->buffer_pkt);
982 }
983 
985 {
986  QSVDecContext *s = avctx->priv_data;
987 
989 
991 
992  av_fifo_freep2(&s->packet_fifo);
993 
994  return 0;
995 }
996 
998 {
999  QSVDecContext *s = avctx->priv_data;
1000  int ret;
1001  const char *uid = NULL;
1002 
1003  if (avctx->codec_id == AV_CODEC_ID_VP8) {
1004  uid = "f622394d8d87452f878c51f2fc9b4131";
1005  } else if (avctx->codec_id == AV_CODEC_ID_VP9) {
1006  uid = "a922394d8d87452f878c51f2fc9b4131";
1007  }
1008  else if (avctx->codec_id == AV_CODEC_ID_HEVC && s->load_plugin != LOAD_PLUGIN_NONE) {
1009  static const char * const uid_hevcdec_sw = "15dd936825ad475ea34e35f3f54217a6";
1010  static const char * const uid_hevcdec_hw = "33a61c0b4c27454ca8d85dde757c6f8e";
1011 
1012  if (s->qsv.load_plugins[0]) {
1013  av_log(avctx, AV_LOG_WARNING,
1014  "load_plugins is not empty, but load_plugin is not set to 'none'."
1015  "The load_plugin value will be ignored.\n");
1016  } else {
1017  if (s->load_plugin == LOAD_PLUGIN_HEVC_SW)
1018  uid = uid_hevcdec_sw;
1019  else
1020  uid = uid_hevcdec_hw;
1021  }
1022  }
1023  if (uid) {
1024  av_freep(&s->qsv.load_plugins);
1025  s->qsv.load_plugins = av_strdup(uid);
1026  if (!s->qsv.load_plugins)
1027  return AVERROR(ENOMEM);
1028  }
1029 
1030  s->qsv.orig_pix_fmt = AV_PIX_FMT_NV12;
1031  s->packet_fifo = av_fifo_alloc2(1, sizeof(AVPacket),
1033  if (!s->packet_fifo) {
1034  ret = AVERROR(ENOMEM);
1035  goto fail;
1036  }
1037 
1038  if (!avctx->pkt_timebase.num)
1039  av_log(avctx, AV_LOG_WARNING, "Invalid pkt_timebase, passing timestamps as-is.\n");
1040 
1041  return 0;
1042 fail:
1043  qsv_decode_close(avctx);
1044  return ret;
1045 }
1046 
1048  int *got_frame, AVPacket *avpkt)
1049 {
1050  QSVDecContext *s = avctx->priv_data;
1051  int ret;
1052 
1053  /* buffer the input packet */
1054  if (avpkt->size) {
1055  AVPacket input_ref;
1056 
1057  ret = av_packet_ref(&input_ref, avpkt);
1058  if (ret < 0)
1059  return ret;
1060  av_fifo_write(s->packet_fifo, &input_ref, 1);
1061  }
1062 
1063  /* process buffered data */
1064  while (!*got_frame) {
1065  /* prepare the input data */
1066  if (s->buffer_pkt.size <= 0) {
1067  /* no more data */
1068  if (!av_fifo_can_read(s->packet_fifo))
1069  return avpkt->size ? avpkt->size : qsv_process_data(avctx, &s->qsv, frame, got_frame, avpkt);
1070  /* in progress of reinit, no read from fifo and keep the buffer_pkt */
1071  if (!s->qsv.reinit_flag) {
1072  av_packet_unref(&s->buffer_pkt);
1073  av_fifo_read(s->packet_fifo, &s->buffer_pkt, 1);
1074  }
1075  }
1076 
1077  ret = qsv_process_data(avctx, &s->qsv, frame, got_frame, &s->buffer_pkt);
1078  if (ret < 0){
1079  if (ret == AVERROR(EAGAIN))
1080  ret = 0;
1081 
1082  /* Drop buffer_pkt when failed to decode the packet. Otherwise,
1083  the decoder will keep decoding the failure packet. */
1084  av_packet_unref(&s->buffer_pkt);
1085  return ret;
1086  }
1087  if (s->qsv.reinit_flag)
1088  continue;
1089 
1090  s->buffer_pkt.size -= ret;
1091  s->buffer_pkt.data += ret;
1092  }
1093 
1094  return avpkt->size;
1095 }
1096 
1098 {
1099  QSVDecContext *s = avctx->priv_data;
1100 
1102 
1103  s->qsv.orig_pix_fmt = AV_PIX_FMT_NONE;
1104  s->qsv.initialized = 0;
1105 }
1106 
1107 #define OFFSET(x) offsetof(QSVDecContext, x)
1108 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1109 
1110 #define DEFINE_QSV_DECODER_WITH_OPTION(x, X, bsf_name, opt) \
1111 static const AVClass x##_qsv_class = { \
1112  .class_name = #x "_qsv", \
1113  .item_name = av_default_item_name, \
1114  .option = opt, \
1115  .version = LIBAVUTIL_VERSION_INT, \
1116 }; \
1117 const FFCodec ff_##x##_qsv_decoder = { \
1118  .p.name = #x "_qsv", \
1119  CODEC_LONG_NAME(#X " video (Intel Quick Sync Video acceleration)"), \
1120  .priv_data_size = sizeof(QSVDecContext), \
1121  .p.type = AVMEDIA_TYPE_VIDEO, \
1122  .p.id = AV_CODEC_ID_##X, \
1123  .init = qsv_decode_init, \
1124  FF_CODEC_DECODE_CB(qsv_decode_frame), \
1125  .flush = qsv_decode_flush, \
1126  .close = qsv_decode_close, \
1127  .bsfs = bsf_name, \
1128  .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_HYBRID, \
1129  .p.priv_class = &x##_qsv_class, \
1130  .hw_configs = qsv_hw_configs, \
1131  .p.wrapper_name = "qsv", \
1132  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE, \
1133 }; \
1134 
1135 #define DEFINE_QSV_DECODER(x, X, bsf_name) DEFINE_QSV_DECODER_WITH_OPTION(x, X, bsf_name, options)
1136 
1137 #if CONFIG_HEVC_QSV_DECODER
1138 static const AVOption hevc_options[] = {
1139  { "async_depth", "Internal parallelization depth, the higher the value the higher the latency.", OFFSET(qsv.async_depth), AV_OPT_TYPE_INT, { .i64 = ASYNC_DEPTH_DEFAULT }, 1, INT_MAX, VD },
1140 
1141  { "load_plugin", "A user plugin to load in an internal session", OFFSET(load_plugin), AV_OPT_TYPE_INT, { .i64 = LOAD_PLUGIN_HEVC_HW }, LOAD_PLUGIN_NONE, LOAD_PLUGIN_HEVC_HW, VD, .unit = "load_plugin" },
1142  { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LOAD_PLUGIN_NONE }, 0, 0, VD, .unit = "load_plugin" },
1143  { "hevc_sw", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LOAD_PLUGIN_HEVC_SW }, 0, 0, VD, .unit = "load_plugin" },
1144  { "hevc_hw", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LOAD_PLUGIN_HEVC_HW }, 0, 0, VD, .unit = "load_plugin" },
1145 
1146  { "load_plugins", "A :-separate list of hexadecimal plugin UIDs to load in an internal session",
1147  OFFSET(qsv.load_plugins), AV_OPT_TYPE_STRING, { .str = "" }, 0, 0, VD },
1148 
1149  { "gpu_copy", "A GPU-accelerated copy between video and system memory", OFFSET(qsv.gpu_copy), AV_OPT_TYPE_INT, { .i64 = MFX_GPUCOPY_DEFAULT }, MFX_GPUCOPY_DEFAULT, MFX_GPUCOPY_OFF, VD, .unit = "gpu_copy"},
1150  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_GPUCOPY_DEFAULT }, 0, 0, VD, .unit = "gpu_copy"},
1151  { "on", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_GPUCOPY_ON }, 0, 0, VD, .unit = "gpu_copy"},
1152  { "off", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_GPUCOPY_OFF }, 0, 0, VD, .unit = "gpu_copy"},
1153  { NULL },
1154 };
1155 DEFINE_QSV_DECODER_WITH_OPTION(hevc, HEVC, "hevc_mp4toannexb", hevc_options)
1156 #endif
1157 
1158 static const AVOption options[] = {
1159  { "async_depth", "Internal parallelization depth, the higher the value the higher the latency.", OFFSET(qsv.async_depth), AV_OPT_TYPE_INT, { .i64 = ASYNC_DEPTH_DEFAULT }, 1, INT_MAX, VD },
1160 
1161  { "gpu_copy", "A GPU-accelerated copy between video and system memory", OFFSET(qsv.gpu_copy), AV_OPT_TYPE_INT, { .i64 = MFX_GPUCOPY_DEFAULT }, MFX_GPUCOPY_DEFAULT, MFX_GPUCOPY_OFF, VD, .unit = "gpu_copy"},
1162  { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_GPUCOPY_DEFAULT }, 0, 0, VD, .unit = "gpu_copy"},
1163  { "on", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_GPUCOPY_ON }, 0, 0, VD, .unit = "gpu_copy"},
1164  { "off", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_GPUCOPY_OFF }, 0, 0, VD, .unit = "gpu_copy"},
1165  { NULL },
1166 };
1167 
1168 #if CONFIG_H264_QSV_DECODER
1169 DEFINE_QSV_DECODER(h264, H264, "h264_mp4toannexb")
1170 #endif
1171 
1172 #if CONFIG_MPEG2_QSV_DECODER
1173 DEFINE_QSV_DECODER(mpeg2, MPEG2VIDEO, NULL)
1174 #endif
1175 
1176 #if CONFIG_VC1_QSV_DECODER
1177 DEFINE_QSV_DECODER(vc1, VC1, NULL)
1178 #endif
1179 
1180 #if CONFIG_MJPEG_QSV_DECODER
1181 DEFINE_QSV_DECODER(mjpeg, MJPEG, NULL)
1182 #endif
1183 
1184 #if CONFIG_VP8_QSV_DECODER
1185 DEFINE_QSV_DECODER(vp8, VP8, NULL)
1186 #endif
1187 
1188 #if CONFIG_VP9_QSV_DECODER
1189 DEFINE_QSV_DECODER(vp9, VP9, NULL)
1190 #endif
1191 
1192 #if CONFIG_AV1_QSV_DECODER
1193 DEFINE_QSV_DECODER(av1, AV1, NULL)
1194 #endif
hwconfig.h
AVMasteringDisplayMetadata::has_primaries
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
Definition: mastering_display_metadata.h:62
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:427
AVQSVFramesContext::frame_type
int frame_type
A combination of MFX_MEMTYPE_* describing the frame pool.
Definition: hwcontext_qsv.h:60
AVCodecContext::hwaccel_context
void * hwaccel_context
Legacy hardware accelerator context.
Definition: avcodec.h:1463
av_buffer_pool_init
AVBufferPool * av_buffer_pool_init(size_t size, AVBufferRef *(*alloc)(size_t size))
Allocate and initialize a buffer pool.
Definition: buffer.c:280
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVMasteringDisplayMetadata::max_luminance
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:57
LOAD_PLUGIN_HEVC_HW
@ LOAD_PLUGIN_HEVC_HW
Definition: qsvdec.c:961
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
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
uid
UID uid
Definition: mxfenc.c:2421
opt.h
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1033
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1264
QSVFramesContext::hw_frames_ctx
AVBufferRef * hw_frames_ctx
Definition: qsv_internal.h:115
AVBufferPool
The buffer pool.
Definition: buffer_internal.h:88
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: defs.h:200
options
static const AVOption options[]
Definition: qsvdec.c:1158
AVMasteringDisplayMetadata::display_primaries
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
Definition: mastering_display_metadata.h:42
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:210
AVMasteringDisplayMetadata::has_luminance
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
Definition: mastering_display_metadata.h:67
LOAD_PLUGIN_NONE
@ LOAD_PLUGIN_NONE
Definition: qsvdec.c:959
AVFilmGrainAOMParams::uv_points
uint8_t uv_points[2][10][2]
Definition: film_grain_params.h:63
OFFSET
#define OFFSET(x)
Definition: qsvdec.c:1107
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:102
AVFilmGrainParams::aom
AVFilmGrainAOMParams aom
Definition: film_grain_params.h:236
av_hwframe_ctx_init
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:337
ff_qsv_close_internal_session
int ff_qsv_close_internal_session(QSVSession *qs)
Definition: qsv.c:1125
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:452
ff_qsv_map_pictype
enum AVPictureType ff_qsv_map_pictype(int mfx_pic_type)
Definition: qsv.c:375
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1026
AVFrame::width
int width
Definition: frame.h:412
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:687
av_hwframe_ctx_alloc
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
Definition: hwcontext.c:252
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:522
AVCodecContext::field_order
enum AVFieldOrder field_order
Field order.
Definition: avcodec.h:1065
AVOption
AVOption.
Definition: opt.h:251
qsv_decode_close_qsvcontext
static void qsv_decode_close_qsvcontext(QSVContext *q)
Definition: qsvdec.c:854
ff_qsv_find_surface_idx
int ff_qsv_find_surface_idx(QSVFramesContext *ctx, QSVFrame *frame)
Definition: qsv.c:344
AV_PIX_FMT_XV30
#define AV_PIX_FMT_XV30
Definition: pixfmt.h:538
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
QSVContext::work_frames
QSVFrame * work_frames
a linked list of frames currently being used by QSV
Definition: qsvdec.c:89
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:649
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
AVHWFramesContext::width
int width
The allocated dimensions of the frames in this pool.
Definition: hwcontext.h:230
LOAD_PLUGIN_HEVC_SW
@ LOAD_PLUGIN_HEVC_SW
Definition: qsvdec.c:960
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:590
qsv_decode_init_context
static int qsv_decode_init_context(AVCodecContext *avctx, QSVContext *q, mfxVideoParam *param)
Definition: qsvdec.c:361
QSVFrame::frame
AVFrame * frame
Definition: qsv_internal.h:80
AVQSVContext::iopattern
int iopattern
The IO pattern to use.
Definition: qsv.h:46
QSVFrame::used
int used
Definition: qsv_internal.h:100
AVFilmGrainParams::seed
uint64_t seed
Seed to use for the synthesis process, if the codec allows for it.
Definition: film_grain_params.h:228
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
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:1001
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:641
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:98
ff_qsv_map_frame_to_surface
int ff_qsv_map_frame_to_surface(const AVFrame *frame, mfxFrameSurface1 *surface)
Definition: qsv.c:283
fifo.h
qsv_decode_flush
static void qsv_decode_flush(AVCodecContext *avctx)
Definition: qsvdec.c:1097
QSVContext::suggest_pool_size
int suggest_pool_size
Definition: qsvdec.c:99
fail
#define fail()
Definition: checkasm.h:179
qsv_decode
static int qsv_decode(AVCodecContext *avctx, QSVContext *q, AVFrame *frame, int *got_frame, const AVPacket *avpkt)
Definition: qsvdec.c:697
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
AVFilmGrainAOMParams::grain_scale_shift
int grain_scale_shift
Signals the down shift applied to the generated gaussian numbers during synthesis.
Definition: film_grain_params.h:99
QSVDecContext::qsv
QSVContext qsv
Definition: qsvdec.c:966
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:640
AVFilmGrainAOMParams::limit_output_range
int limit_output_range
Signals to clip to limited color levels after film grain application.
Definition: film_grain_params.h:122
AVFilmGrainAOMParams::num_y_points
int num_y_points
Number of points, and the scale and value for each point of the piecewise linear scaling function for...
Definition: film_grain_params.h:49
AVRational::num
int num
Numerator.
Definition: rational.h:59
QSVDecContext::packet_fifo
AVFifo * packet_fifo
Definition: qsvdec.c:970
QSVContext::async_fifo
AVFifo * async_fifo
Definition: qsvdec.c:91
QSVContext
Definition: qsvdec.c:75
qsv_internal.h
AVFilmGrainAOMParams
This structure describes how to handle film grain synthesis for AOM codecs.
Definition: film_grain_params.h:44
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:88
get_surface
static int get_surface(AVCodecContext *avctx, QSVContext *q, mfxFrameSurface1 **surf)
Definition: qsvdec.c:531
AV_PIX_FMT_Y210
#define AV_PIX_FMT_Y210
Definition: pixfmt.h:536
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1019
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
ASYNC_DEPTH_DEFAULT
#define ASYNC_DEPTH_DEFAULT
Definition: qsv_internal.h:50
film_grain_params.h
av_cold
#define av_cold
Definition: attributes.h:90
av_fifo_read
int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)
Read data from a FIFO.
Definition: fifo.c:240
AVHWFramesContext::height
int height
Definition: hwcontext.h:230
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:628
QSVDecContext
Definition: qsvdec.c:964
QSVContext::iopattern
int iopattern
Definition: qsvdec.c:104
av_buffer_pool_get
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:384
AVMasteringDisplayMetadata::white_point
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
Definition: mastering_display_metadata.h:47
s
#define s(width, name)
Definition: cbs_vp9.c:198
hevc_options
static const AVOption hevc_options[]
Definition: videotoolboxenc.c:2931
QSVContext::reinit_flag
int reinit_flag
Definition: qsvdec.c:93
QSVContext::frames_ctx
QSVFramesContext frames_ctx
Definition: qsvdec.c:84
QSVContext::internal_qs
QSVSession internal_qs
Definition: qsvdec.c:82
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:425
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
mfx_tb
static const AVRational mfx_tb
Definition: qsvdec.c:60
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:220
QSVContext::ver
mfxVersion ver
Definition: qsvdec.c:78
qsv_process_data
static int qsv_process_data(AVCodecContext *avctx, QSVContext *q, AVFrame *frame, int *got_frame, const AVPacket *pkt)
Definition: qsvdec.c:882
QSV_RUNTIME_VERSION_ATLEAST
#define QSV_RUNTIME_VERSION_ATLEAST(MFX_VERSION, MAJOR, MINOR)
Definition: qsv_internal.h:63
av_film_grain_params_create_side_data
AVFilmGrainParams * av_film_grain_params_create_side_data(AVFrame *frame)
Allocate a complete AVFilmGrainParams and add it to the frame.
Definition: film_grain_params.c:31
MFX_PTS_TO_PTS
#define MFX_PTS_TO_PTS(mfx_pts, pts_tb)
Definition: qsvdec.c:66
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:304
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
decode.h
AVCodecHWConfig::pix_fmt
enum AVPixelFormat pix_fmt
For decoders, a hardware pixel format which that decoder may be able to decode to if suitable hardwar...
Definition: codec.h:350
av_usleep
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:84
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
frame
static AVFrame * frame
Definition: demux_decode.c:54
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:455
if
if(ret)
Definition: filter_design.txt:179
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:1078
QSVFrame
Definition: qsv_internal.h:79
AVFilmGrainAOMParams::uv_mult_luma
int uv_mult_luma[2]
Definition: film_grain_params.h:106
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AVFilmGrainParams::codec
union AVFilmGrainParams::@351 codec
Additional fields may be added both here and in any structure included.
AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX
@ AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX
The codec supports this format via the hw_frames_ctx interface.
Definition: codec.h:322
AVHWFramesContext::sw_format
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
Definition: hwcontext.h:223
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1043
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
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:283
qsv.h
AV_PIX_FMT_YUYV422
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:74
QSV_HAVE_OPAQUE
#define QSV_HAVE_OPAQUE
Definition: qsv_internal.h:68
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
qsv_decode_preinit
static int qsv_decode_preinit(AVCodecContext *avctx, QSVContext *q, enum AVPixelFormat pix_fmt, mfxVideoParam *param)
Definition: qsvdec.c:265
ff_qsv_print_iopattern
int ff_qsv_print_iopattern(void *log_ctx, int mfx_iopattern, const char *extra_string)
Definition: qsv.c:100
av_buffer_pool_uninit
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:322
av_fifo_can_read
size_t av_fifo_can_read(const AVFifo *f)
Definition: fifo.c:87
qsv_get_continuous_buffer
static int qsv_get_continuous_buffer(AVCodecContext *avctx, AVFrame *frame, AVBufferPool *pool)
Definition: qsvdec.c:126
QSVContext::nb_ext_buffers
int nb_ext_buffers
Definition: qsvdec.c:110
QSVFrame::surface
mfxFrameSurface1 surface
Definition: qsv_internal.h:81
time.h
QSVFramesContext::mids_buf
AVBufferRef * mids_buf
Definition: qsv_internal.h:122
alloc_frame
static int alloc_frame(AVCodecContext *avctx, QSVContext *q, QSVFrame *frame)
Definition: qsvdec.c:451
AV_PIX_FMT_QSV
@ AV_PIX_FMT_QSV
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
Definition: pixfmt.h:247
av_packet_ref
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:435
QSVContext::load_plugins
char * load_plugins
Definition: qsvdec.c:107
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1744
QSVContext::initialized
int initialized
Definition: qsvdec.c:100
AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX
@ AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX
The codec supports this format via the hw_device_ctx interface.
Definition: codec.h:309
QSVContext::fourcc
uint32_t fourcc
Definition: qsvdec.c:96
QSVContext::ext_buffers
mfxExtBuffer ** ext_buffers
Definition: qsvdec.c:109
AVFilmGrainAOMParams::num_uv_points
int num_uv_points[2]
If chroma_scaling_from_luma is set to 0, signals the chroma scaling function parameters.
Definition: film_grain_params.h:62
QSVContext::frame_info
mfxFrameInfo frame_info
Definition: qsvdec.c:97
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:442
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1618
AVPacket::size
int size
Definition: packet.h:523
AVFifo
Definition: fifo.c:35
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:361
AVCodecContext::extra_hw_frames
int extra_hw_frames
Definition: avcodec.h:2035
DEFINE_QSV_DECODER_WITH_OPTION
#define DEFINE_QSV_DECODER_WITH_OPTION(x, X, bsf_name, opt)
Definition: qsvdec.c:1110
codec_internal.h
AV_PIX_FMT_P012
#define AV_PIX_FMT_P012
Definition: pixfmt.h:533
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
AVQSVContext::session
mfxSession session
If non-NULL, the session to use for encoding or decoding.
Definition: qsv.h:41
qsv_init_session
static int qsv_init_session(AVCodecContext *avctx, QSVContext *q, mfxSession session, AVBufferRef *hw_frames_ref, AVBufferRef *hw_device_ref)
Definition: qsvdec.c:181
AVCodecContext::pkt_timebase
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are expressed.
Definition: avcodec.h:1821
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
qsv_decode_close
static av_cold int qsv_decode_close(AVCodecContext *avctx)
Definition: qsvdec.c:984
AVFilmGrainParams
This structure describes how to handle film grain synthesis in video for specific codecs.
Definition: film_grain_params.h:216
qsv_clear_unused_frames
static void qsv_clear_unused_frames(QSVContext *q)
Definition: qsvdec.c:519
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:427
AVCodecHWConfigInternal
Definition: hwconfig.h:25
frame.h
AV_PIX_FMT_Y212
#define AV_PIX_FMT_Y212
Definition: pixfmt.h:537
AVQSVContext::ext_buffers
mfxExtBuffer ** ext_buffers
Extra buffers to pass to encoder or decoder initialization.
Definition: qsv.h:51
av_image_get_buffer_size
int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align)
Return the size in bytes of the amount of data required to store an image with the given parameters.
Definition: imgutils.c:466
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
av_content_light_metadata_create_side_data
AVContentLightMetadata * av_content_light_metadata_create_side_data(AVFrame *frame)
Allocate a complete AVContentLightMetadata and add it to the frame.
Definition: mastering_display_metadata.c:55
AVFilmGrainAOMParams::ar_coeffs_y
int8_t ar_coeffs_y[24]
Luma auto-regression coefficients.
Definition: film_grain_params.h:80
QSVFramesContext::mids
QSVMid * mids
Definition: qsv_internal.h:123
QSVAsyncFrame::frame
QSVFrame * frame
Definition: qsvdec.c:72
hwcontext_qsv.h
MFXUnload
#define MFXUnload(a)
Definition: qsvdec.c:57
qsv_decode_header
static int qsv_decode_header(AVCodecContext *avctx, QSVContext *q, const AVPacket *avpkt, enum AVPixelFormat pix_fmt, mfxVideoParam *param)
Definition: qsvdec.c:387
QSVContext::pool
AVBufferPool * pool
Definition: qsvdec.c:98
log.h
ff_qsv_map_picstruct
enum AVFieldOrder ff_qsv_map_picstruct(int mfx_pic_struct)
Definition: qsv.c:357
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
qsv_hw_configs
static const AVCodecHWConfigInternal *const qsv_hw_configs[]
Definition: qsvdec.c:113
QSVDecContext::buffer_pkt
AVPacket buffer_pkt
Definition: qsvdec.c:972
common.h
QSVContext::session
mfxSession session
Definition: qsvdec.c:77
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:622
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:254
AVFilmGrainAOMParams::scaling_shift
int scaling_shift
Specifies the shift applied to the chroma components.
Definition: film_grain_params.h:69
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:1985
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
AVCodecContext::height
int height
Definition: avcodec.h:625
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:662
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:636
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:670
QSVDecContext::load_plugin
int load_plugin
Definition: qsvdec.c:968
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:1944
avcodec.h
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:125
find_frame
static QSVFrame * find_frame(QSVContext *q, mfxFrameSurface1 *surf)
Definition: qsvdec.c:572
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
ret
ret
Definition: filter_design.txt:187
pixfmt.h
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:96
QSVFrame::queued
int queued
Definition: qsv_internal.h:99
QSVContext::async_depth
int async_depth
Definition: qsvdec.c:103
QSVSession
Definition: qsv_internal.h:105
AVHWFramesContext::hwctx
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:163
ff_qsv_codec_id_to_mfx
int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)
Definition: qsv.c:54
LoadPlugin
LoadPlugin
Definition: qsvdec.c:958
QSVContext::zero_consume_run
int zero_consume_run
Definition: qsvdec.c:92
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_HWDEVICE_TYPE_QSV
@ AV_HWDEVICE_TYPE_QSV
Definition: hwcontext.h:33
ff_decode_frame_props
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
Definition: decode.c:1505
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVFrame::height
int height
Definition: frame.h:412
AVFilmGrainAOMParams::ar_coeff_lag
int ar_coeff_lag
Specifies the auto-regression lag.
Definition: film_grain_params.h:74
QSVContext::orig_pix_fmt
enum AVPixelFormat orig_pix_fmt
Definition: qsvdec.c:95
av_mastering_display_metadata_create_side_data
AVMasteringDisplayMetadata * av_mastering_display_metadata_create_side_data(AVFrame *frame)
Allocate a complete AVMasteringDisplayMetadata and add it to the frame.
Definition: mastering_display_metadata.c:32
AVFilmGrainAOMParams::y_points
uint8_t y_points[14][2]
Definition: film_grain_params.h:50
AVFilmGrainAOMParams::uv_offset
int uv_offset[2]
Offset used for component scaling function.
Definition: film_grain_params.h:112
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1600
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:106
ff_qsv_map_fourcc
enum AVPixelFormat ff_qsv_map_fourcc(uint32_t fourcc)
Definition: qsv.c:203
AVFilmGrainAOMParams::uv_mult
int uv_mult[2]
Specifies the luma/chroma multipliers for the index to the component scaling function.
Definition: film_grain_params.h:105
AVCodecContext::export_side_data
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame,...
Definition: avcodec.h:2061
qsv_decode_frame
static int qsv_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: qsvdec.c:1047
AVMasteringDisplayMetadata::min_luminance
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:52
AV_PIX_FMT_P010
#define AV_PIX_FMT_P010
Definition: pixfmt.h:532
AVFilmGrainAOMParams::overlap_flag
int overlap_flag
Signals whether to overlap film grain blocks.
Definition: film_grain_params.h:117
AVQSVFramesContext
This struct is allocated as AVHWFramesContext.hwctx.
Definition: hwcontext_qsv.h:53
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:640
AVHWFramesContext::initial_pool_size
int initial_pool_size
Initial size of the frame pool.
Definition: hwcontext.h:200
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:270
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
qsv_decode_init
static av_cold int qsv_decode_init(AVCodecContext *avctx)
Definition: qsvdec.c:997
QSVFrame::dec_info
mfxExtDecodedFrameInfo dec_info
Definition: qsv_internal.h:83
mastering_display_metadata.h
ff_attach_decode_data
int ff_attach_decode_data(AVFrame *frame)
Definition: decode.c:1594
qsv_clear_buffers
static void qsv_clear_buffers(QSVDecContext *s)
Definition: qsvdec.c:975
DEFINE_QSV_DECODER
#define DEFINE_QSV_DECODER(x, X, bsf_name)
Definition: qsvdec.c:1135
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
QSVAsyncFrame::sync
mfxSyncPoint * sync
Definition: qsvdec.c:71
QSVFramesContext
Definition: qsv_internal.h:114
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:107
AVPacket
This structure stores compressed data.
Definition: packet.h:499
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:625
imgutils.h
PTS_TO_MFX_PTS
#define PTS_TO_MFX_PTS(pts, pts_tb)
Definition: qsvdec.c:62
AV_PIX_FMT_XV36
#define AV_PIX_FMT_XV36
Definition: pixfmt.h:539
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:192
hwcontext.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
VD
#define VD
Definition: qsvdec.c:1108
av_fifo_freep2
void av_fifo_freep2(AVFifo **f)
Free an AVFifo and reset pointer to NULL.
Definition: fifo.c:286
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
QSVContext::gpu_copy
int gpu_copy
Definition: qsvdec.c:105
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1814
QSVAsyncFrame
Definition: qsvdec.c:70
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
AVFilmGrainAOMParams::chroma_scaling_from_luma
int chroma_scaling_from_luma
Signals whether to derive the chroma scaling function from the luma.
Definition: film_grain_params.h:56
AV_PIX_FMT_VUYX
@ AV_PIX_FMT_VUYX
packed VUYX 4:4:4, 32bpp, Variant of VUYA where alpha channel is left undefined
Definition: pixfmt.h:410
QSVSession::loader
void * loader
Definition: qsv_internal.h:111
ff_qsv_frame_add_ext_param
void ff_qsv_frame_add_ext_param(AVCodecContext *avctx, QSVFrame *frame, mfxExtBuffer *param)
Definition: qsv.c:1143
AVCodecHWConfigInternal::public
AVCodecHWConfig public
This is the structure which will be returned to the user by avcodec_get_hw_config().
Definition: hwconfig.h:30
AV_FILM_GRAIN_PARAMS_AV1
@ AV_FILM_GRAIN_PARAMS_AV1
The union is valid when interpreted as AVFilmGrainAOMParams (codec.aom)
Definition: film_grain_params.h:30
QSVFrame::next
struct QSVFrame * next
Definition: qsv_internal.h:102
ff_qsv_print_error
int ff_qsv_print_error(void *log_ctx, mfxStatus err, const char *error_string)
Definition: qsv.c:185
AVFilmGrainParams::type
enum AVFilmGrainParamsType type
Specifies the codec for which this structure is valid.
Definition: film_grain_params.h:220
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
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:677
AVFrame::repeat_pict
int repeat_pict
Number of fields in this frame which should be repeated, i.e.
Definition: frame.h:521
AV_CODEC_EXPORT_DATA_FILM_GRAIN
#define AV_CODEC_EXPORT_DATA_FILM_GRAIN
Decoding only.
Definition: avcodec.h:420
AV_FIFO_FLAG_AUTO_GROW
#define AV_FIFO_FLAG_AUTO_GROW
Automatically resize the FIFO on writes, so that the data fits.
Definition: fifo.h:67
AVFilmGrainAOMParams::ar_coeff_shift
int ar_coeff_shift
Specifies the range of the auto-regressive coefficients.
Definition: film_grain_params.h:93
AVFilmGrainAOMParams::ar_coeffs_uv
int8_t ar_coeffs_uv[2][25]
Chroma auto-regression coefficients.
Definition: film_grain_params.h:86