FFmpeg
qsvvpp.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 /**
20  * @file
21  * Intel Quick Sync Video VPP base function
22  */
23 
24 #include "libavutil/common.h"
25 #include "libavutil/mathematics.h"
26 #include "libavutil/time.h"
27 #include "libavutil/pixdesc.h"
28 
29 #include "internal.h"
30 #include "qsvvpp.h"
31 #include "video.h"
32 
33 #if QSV_ONEVPL
34 #include <mfxdispatcher.h>
35 #else
36 #define MFXUnload(a) do { } while(0)
37 #endif
38 
39 #define IS_VIDEO_MEMORY(mode) (mode & (MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | \
40  MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET))
41 #if QSV_HAVE_OPAQUE
42 #define IS_OPAQUE_MEMORY(mode) (mode & MFX_MEMTYPE_OPAQUE_FRAME)
43 #endif
44 #define IS_SYSTEM_MEMORY(mode) (mode & MFX_MEMTYPE_SYSTEM_MEMORY)
45 #define MFX_IMPL_VIA_MASK(impl) (0x0f00 & (impl))
46 
47 #define QSV_HAVE_AUDIO !QSV_ONEVPL
48 
49 static const AVRational default_tb = { 1, 90000 };
50 
51 typedef struct QSVAsyncFrame {
52  mfxSyncPoint sync;
53  QSVFrame *frame;
55 
56 static const struct {
58  const char *desc;
59 } qsv_iopatterns[] = {
60  {MFX_IOPATTERN_IN_VIDEO_MEMORY, "input is video memory surface" },
61  {MFX_IOPATTERN_IN_SYSTEM_MEMORY, "input is system memory surface" },
62 #if QSV_HAVE_OPAQUE
63  {MFX_IOPATTERN_IN_OPAQUE_MEMORY, "input is opaque memory surface" },
64 #endif
65  {MFX_IOPATTERN_OUT_VIDEO_MEMORY, "output is video memory surface" },
66  {MFX_IOPATTERN_OUT_SYSTEM_MEMORY, "output is system memory surface" },
67 #if QSV_HAVE_OPAQUE
68  {MFX_IOPATTERN_OUT_OPAQUE_MEMORY, "output is opaque memory surface" },
69 #endif
70 };
71 
73  const char *extra_string)
74 {
75  const char *desc = NULL;
76 
77  for (int i = 0; i < FF_ARRAY_ELEMS(qsv_iopatterns); i++) {
79  desc = qsv_iopatterns[i].desc;
80  }
81  }
82  if (!desc)
83  desc = "unknown iopattern";
84 
85  av_log(log_ctx, AV_LOG_VERBOSE, "%s: %s\n", extra_string, desc);
86  return 0;
87 }
88 
89 static const struct {
90  mfxStatus mfxerr;
91  int averr;
92  const char *desc;
93 } qsv_errors[] = {
94  { MFX_ERR_NONE, 0, "success" },
95  { MFX_ERR_UNKNOWN, AVERROR_UNKNOWN, "unknown error" },
96  { MFX_ERR_NULL_PTR, AVERROR(EINVAL), "NULL pointer" },
97  { MFX_ERR_UNSUPPORTED, AVERROR(ENOSYS), "unsupported" },
98  { MFX_ERR_MEMORY_ALLOC, AVERROR(ENOMEM), "failed to allocate memory" },
99  { MFX_ERR_NOT_ENOUGH_BUFFER, AVERROR(ENOMEM), "insufficient input/output buffer" },
100  { MFX_ERR_INVALID_HANDLE, AVERROR(EINVAL), "invalid handle" },
101  { MFX_ERR_LOCK_MEMORY, AVERROR(EIO), "failed to lock the memory block" },
102  { MFX_ERR_NOT_INITIALIZED, AVERROR_BUG, "not initialized" },
103  { MFX_ERR_NOT_FOUND, AVERROR(ENOSYS), "specified object was not found" },
104  /* the following 3 errors should always be handled explicitly, so those "mappings"
105  * are for completeness only */
106  { MFX_ERR_MORE_DATA, AVERROR_UNKNOWN, "expect more data at input" },
107  { MFX_ERR_MORE_SURFACE, AVERROR_UNKNOWN, "expect more surface at output" },
108  { MFX_ERR_MORE_BITSTREAM, AVERROR_UNKNOWN, "expect more bitstream at output" },
109  { MFX_ERR_ABORTED, AVERROR_UNKNOWN, "operation aborted" },
110  { MFX_ERR_DEVICE_LOST, AVERROR(EIO), "device lost" },
111  { MFX_ERR_INCOMPATIBLE_VIDEO_PARAM, AVERROR(EINVAL), "incompatible video parameters" },
112  { MFX_ERR_INVALID_VIDEO_PARAM, AVERROR(EINVAL), "invalid video parameters" },
113  { MFX_ERR_UNDEFINED_BEHAVIOR, AVERROR_BUG, "undefined behavior" },
114  { MFX_ERR_DEVICE_FAILED, AVERROR(EIO), "device failed" },
115 #if QSV_HAVE_AUDIO
116  { MFX_ERR_INCOMPATIBLE_AUDIO_PARAM, AVERROR(EINVAL), "incompatible audio parameters" },
117  { MFX_ERR_INVALID_AUDIO_PARAM, AVERROR(EINVAL), "invalid audio parameters" },
118 #endif
119  { MFX_ERR_GPU_HANG, AVERROR(EIO), "GPU Hang" },
120  { MFX_ERR_REALLOC_SURFACE, AVERROR_UNKNOWN, "need bigger surface for output" },
121 
122  { MFX_WRN_IN_EXECUTION, 0, "operation in execution" },
123  { MFX_WRN_DEVICE_BUSY, 0, "device busy" },
124  { MFX_WRN_VIDEO_PARAM_CHANGED, 0, "video parameters changed" },
125  { MFX_WRN_PARTIAL_ACCELERATION, 0, "partial acceleration" },
126  { MFX_WRN_INCOMPATIBLE_VIDEO_PARAM, 0, "incompatible video parameters" },
127  { MFX_WRN_VALUE_NOT_CHANGED, 0, "value is saturated" },
128  { MFX_WRN_OUT_OF_RANGE, 0, "value out of range" },
129  { MFX_WRN_FILTER_SKIPPED, 0, "filter skipped" },
130 #if QSV_HAVE_AUDIO
131  { MFX_WRN_INCOMPATIBLE_AUDIO_PARAM, 0, "incompatible audio parameters" },
132 #endif
133 
134 #if QSV_VERSION_ATLEAST(1, 31)
135  { MFX_ERR_NONE_PARTIAL_OUTPUT, 0, "partial output" },
136 #endif
137 };
138 
139 static int qsv_map_error(mfxStatus mfx_err, const char **desc)
140 {
141  int i;
142  for (i = 0; i < FF_ARRAY_ELEMS(qsv_errors); i++) {
143  if (qsv_errors[i].mfxerr == mfx_err) {
144  if (desc)
145  *desc = qsv_errors[i].desc;
146  return qsv_errors[i].averr;
147  }
148  }
149  if (desc)
150  *desc = "unknown error";
151  return AVERROR_UNKNOWN;
152 }
153 
154 int ff_qsvvpp_print_error(void *log_ctx, mfxStatus err,
155  const char *error_string)
156 {
157  const char *desc;
158  int ret;
159  ret = qsv_map_error(err, &desc);
160  av_log(log_ctx, AV_LOG_ERROR, "%s: %s (%d)\n", error_string, desc, err);
161  return ret;
162 }
163 
164 int ff_qsvvpp_print_warning(void *log_ctx, mfxStatus err,
165  const char *warning_string)
166 {
167  const char *desc;
168  int ret;
169  ret = qsv_map_error(err, &desc);
170  av_log(log_ctx, AV_LOG_WARNING, "%s: %s (%d)\n", warning_string, desc, err);
171  return ret;
172 }
173 
174 /* functions for frameAlloc */
175 static mfxStatus frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req,
176  mfxFrameAllocResponse *resp)
177 {
178  QSVVPPContext *s = pthis;
179  int i;
180 
181  if (!(req->Type & MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET) ||
182  !(req->Type & (MFX_MEMTYPE_FROM_VPPIN | MFX_MEMTYPE_FROM_VPPOUT)) ||
183  !(req->Type & MFX_MEMTYPE_EXTERNAL_FRAME))
184  return MFX_ERR_UNSUPPORTED;
185 
186  if (req->Type & MFX_MEMTYPE_FROM_VPPIN) {
187  resp->mids = av_mallocz(s->nb_surface_ptrs_in * sizeof(*resp->mids));
188  if (!resp->mids)
189  return AVERROR(ENOMEM);
190 
191  for (i = 0; i < s->nb_surface_ptrs_in; i++)
192  resp->mids[i] = s->surface_ptrs_in[i]->Data.MemId;
193 
194  resp->NumFrameActual = s->nb_surface_ptrs_in;
195  } else {
196  resp->mids = av_mallocz(s->nb_surface_ptrs_out * sizeof(*resp->mids));
197  if (!resp->mids)
198  return AVERROR(ENOMEM);
199 
200  for (i = 0; i < s->nb_surface_ptrs_out; i++)
201  resp->mids[i] = s->surface_ptrs_out[i]->Data.MemId;
202 
203  resp->NumFrameActual = s->nb_surface_ptrs_out;
204  }
205 
206  return MFX_ERR_NONE;
207 }
208 
209 static mfxStatus frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp)
210 {
211  av_freep(&resp->mids);
212  return MFX_ERR_NONE;
213 }
214 
215 static mfxStatus frame_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
216 {
217  return MFX_ERR_UNSUPPORTED;
218 }
219 
220 static mfxStatus frame_unlock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
221 {
222  return MFX_ERR_UNSUPPORTED;
223 }
224 
225 static mfxStatus frame_get_hdl(mfxHDL pthis, mfxMemId mid, mfxHDL *hdl)
226 {
227  mfxHDLPair *pair_dst = (mfxHDLPair*)hdl;
228  mfxHDLPair *pair_src = (mfxHDLPair*)mid;
229 
230  pair_dst->first = pair_src->first;
231 
232  if (pair_src->second != (mfxMemId)MFX_INFINITE)
233  pair_dst->second = pair_src->second;
234  return MFX_ERR_NONE;
235 }
236 
238 {
239  switch (format) {
240  case AV_PIX_FMT_YUV420P:
241  return MFX_FOURCC_YV12;
242  case AV_PIX_FMT_NV12:
243  return MFX_FOURCC_NV12;
244  case AV_PIX_FMT_YUYV422:
245  return MFX_FOURCC_YUY2;
246  case AV_PIX_FMT_BGRA:
247  return MFX_FOURCC_RGB4;
248  case AV_PIX_FMT_P010:
249  return MFX_FOURCC_P010;
250  }
251 
252  return MFX_FOURCC_NV12;
253 }
254 
255 static int map_frame_to_surface(AVFrame *frame, mfxFrameSurface1 *surface)
256 {
257  switch (frame->format) {
258  case AV_PIX_FMT_NV12:
259  case AV_PIX_FMT_P010:
260  surface->Data.Y = frame->data[0];
261  surface->Data.UV = frame->data[1];
262  break;
263  case AV_PIX_FMT_YUV420P:
264  surface->Data.Y = frame->data[0];
265  surface->Data.U = frame->data[1];
266  surface->Data.V = frame->data[2];
267  break;
268  case AV_PIX_FMT_YUYV422:
269  surface->Data.Y = frame->data[0];
270  surface->Data.U = frame->data[0] + 1;
271  surface->Data.V = frame->data[0] + 3;
272  break;
273  case AV_PIX_FMT_RGB32:
274  surface->Data.B = frame->data[0];
275  surface->Data.G = frame->data[0] + 1;
276  surface->Data.R = frame->data[0] + 2;
277  surface->Data.A = frame->data[0] + 3;
278  break;
279  default:
280  return MFX_ERR_UNSUPPORTED;
281  }
282  surface->Data.Pitch = frame->linesize[0];
283 
284  return 0;
285 }
286 
287 /* fill the surface info */
288 static int fill_frameinfo_by_link(mfxFrameInfo *frameinfo, AVFilterLink *link)
289 {
290  enum AVPixelFormat pix_fmt;
291  AVHWFramesContext *frames_ctx;
292  AVQSVFramesContext *frames_hwctx;
293  const AVPixFmtDescriptor *desc;
294 
295  if (link->format == AV_PIX_FMT_QSV) {
296  if (!link->hw_frames_ctx)
297  return AVERROR(EINVAL);
298 
299  frames_ctx = (AVHWFramesContext *)link->hw_frames_ctx->data;
300  frames_hwctx = frames_ctx->hwctx;
301  *frameinfo = frames_hwctx->surfaces[0].Info;
302  } else {
303  pix_fmt = link->format;
305  if (!desc)
306  return AVERROR_BUG;
307 
308  frameinfo->CropX = 0;
309  frameinfo->CropY = 0;
310  frameinfo->Width = FFALIGN(link->w, 32);
311  frameinfo->Height = FFALIGN(link->h, 32);
312  frameinfo->PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
313  frameinfo->FourCC = pix_fmt_to_mfx_fourcc(pix_fmt);
314  frameinfo->BitDepthLuma = desc->comp[0].depth;
315  frameinfo->BitDepthChroma = desc->comp[0].depth;
316  frameinfo->Shift = desc->comp[0].depth > 8;
317  if (desc->log2_chroma_w && desc->log2_chroma_h)
318  frameinfo->ChromaFormat = MFX_CHROMAFORMAT_YUV420;
319  else if (desc->log2_chroma_w)
320  frameinfo->ChromaFormat = MFX_CHROMAFORMAT_YUV422;
321  else
322  frameinfo->ChromaFormat = MFX_CHROMAFORMAT_YUV444;
323  }
324 
325  frameinfo->CropW = link->w;
326  frameinfo->CropH = link->h;
327  frameinfo->FrameRateExtN = link->frame_rate.num;
328  frameinfo->FrameRateExtD = link->frame_rate.den;
329 
330  /* Apparently VPP in the SDK requires the frame rate to be set to some value, otherwise
331  * init will fail */
332  if (frameinfo->FrameRateExtD == 0 || frameinfo->FrameRateExtN == 0) {
333  frameinfo->FrameRateExtN = 25;
334  frameinfo->FrameRateExtD = 1;
335  }
336 
337  frameinfo->AspectRatioW = link->sample_aspect_ratio.num ? link->sample_aspect_ratio.num : 1;
338  frameinfo->AspectRatioH = link->sample_aspect_ratio.den ? link->sample_aspect_ratio.den : 1;
339 
340  return 0;
341 }
342 
344 {
345  while (list) {
346  /* list->queued==1 means the frame is not cached in VPP
347  * process any more, it can be released to pool. */
348  if ((list->queued == 1) && !list->surface.Data.Locked) {
349  av_frame_free(&list->frame);
350  list->queued = 0;
351  }
352  list = list->next;
353  }
354 }
355 
357 {
358  while (*list) {
359  QSVFrame *frame;
360 
361  frame = *list;
362  *list = (*list)->next;
363  av_frame_free(&frame->frame);
364  av_freep(&frame);
365  }
366 }
367 
369 {
370  QSVFrame *out = *list;
371 
372  for (; out; out = out->next) {
373  if (!out->queued) {
374  out->queued = 1;
375  break;
376  }
377  }
378 
379  if (!out) {
380  out = av_mallocz(sizeof(*out));
381  if (!out) {
382  av_log(NULL, AV_LOG_ERROR, "Can't alloc new output frame.\n");
383  return NULL;
384  }
385  out->queued = 1;
386  out->next = *list;
387  *list = out;
388  }
389 
390  return out;
391 }
392 
393 /* get the input surface */
395 {
396  QSVFrame *qsv_frame;
397  AVFilterContext *ctx = inlink->dst;
398 
399  clear_unused_frames(s->in_frame_list);
400 
401  qsv_frame = get_free_frame(&s->in_frame_list);
402  if (!qsv_frame)
403  return NULL;
404 
405  /* Turn AVFrame into mfxFrameSurface1.
406  * For video/opaque memory mode, pix_fmt is AV_PIX_FMT_QSV, and
407  * mfxFrameSurface1 is stored in AVFrame->data[3];
408  * for system memory mode, raw video data is stored in
409  * AVFrame, we should map it into mfxFrameSurface1.
410  */
411  if (!IS_SYSTEM_MEMORY(s->in_mem_mode)) {
412  if (picref->format != AV_PIX_FMT_QSV) {
413  av_log(ctx, AV_LOG_ERROR, "QSVVPP gets a wrong frame.\n");
414  return NULL;
415  }
416  qsv_frame->frame = av_frame_clone(picref);
417  qsv_frame->surface = *(mfxFrameSurface1 *)qsv_frame->frame->data[3];
418  } else {
419  /* make a copy if the input is not padded as libmfx requires */
420  if (picref->height & 31 || picref->linesize[0] & 31) {
421  qsv_frame->frame = ff_get_video_buffer(inlink,
422  FFALIGN(inlink->w, 32),
423  FFALIGN(inlink->h, 32));
424  if (!qsv_frame->frame)
425  return NULL;
426 
427  qsv_frame->frame->width = picref->width;
428  qsv_frame->frame->height = picref->height;
429 
430  if (av_frame_copy(qsv_frame->frame, picref) < 0) {
431  av_frame_free(&qsv_frame->frame);
432  return NULL;
433  }
434 
435  av_frame_copy_props(qsv_frame->frame, picref);
436  } else
437  qsv_frame->frame = av_frame_clone(picref);
438 
439  if (map_frame_to_surface(qsv_frame->frame,
440  &qsv_frame->surface) < 0) {
441  av_log(ctx, AV_LOG_ERROR, "Unsupported frame.\n");
442  return NULL;
443  }
444  }
445 
446  qsv_frame->surface.Info = s->frame_infos[FF_INLINK_IDX(inlink)];
447  qsv_frame->surface.Data.TimeStamp = av_rescale_q(qsv_frame->frame->pts,
448  inlink->time_base, default_tb);
449 
450  qsv_frame->surface.Info.PicStruct =
451  !qsv_frame->frame->interlaced_frame ? MFX_PICSTRUCT_PROGRESSIVE :
452  (qsv_frame->frame->top_field_first ? MFX_PICSTRUCT_FIELD_TFF :
453  MFX_PICSTRUCT_FIELD_BFF);
454  if (qsv_frame->frame->repeat_pict == 1)
455  qsv_frame->surface.Info.PicStruct |= MFX_PICSTRUCT_FIELD_REPEATED;
456  else if (qsv_frame->frame->repeat_pict == 2)
457  qsv_frame->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_DOUBLING;
458  else if (qsv_frame->frame->repeat_pict == 4)
459  qsv_frame->surface.Info.PicStruct |= MFX_PICSTRUCT_FRAME_TRIPLING;
460 
461  return qsv_frame;
462 }
463 
464 /* get the output surface */
466 {
467  AVFilterContext *ctx = outlink->src;
468  QSVFrame *out_frame;
469  int ret;
470 
471  clear_unused_frames(s->out_frame_list);
472 
473  out_frame = get_free_frame(&s->out_frame_list);
474  if (!out_frame)
475  return NULL;
476 
477  /* For video memory, get a hw frame;
478  * For system memory, get a sw frame and map it into a mfx_surface. */
479  if (!IS_SYSTEM_MEMORY(s->out_mem_mode)) {
480  out_frame->frame = av_frame_alloc();
481  if (!out_frame->frame)
482  return NULL;
483 
484  ret = av_hwframe_get_buffer(outlink->hw_frames_ctx, out_frame->frame, 0);
485  if (ret < 0) {
486  av_log(ctx, AV_LOG_ERROR, "Can't allocate a surface.\n");
487  return NULL;
488  }
489 
490  out_frame->surface = *(mfxFrameSurface1 *)out_frame->frame->data[3];
491  } else {
492  /* Get a frame with aligned dimensions.
493  * Libmfx need system memory being 128x64 aligned */
494  out_frame->frame = ff_get_video_buffer(outlink,
495  FFALIGN(outlink->w, 128),
496  FFALIGN(outlink->h, 64));
497  if (!out_frame->frame)
498  return NULL;
499 
500  ret = map_frame_to_surface(out_frame->frame,
501  &out_frame->surface);
502  if (ret < 0)
503  return NULL;
504  }
505 
506  if (outlink->frame_rate.num && outlink->frame_rate.den)
507  out_frame->frame->duration = av_rescale_q(1, av_inv_q(outlink->frame_rate), outlink->time_base);
508  else
509  out_frame->frame->duration = 0;
510 
511  out_frame->frame->width = outlink->w;
512  out_frame->frame->height = outlink->h;
513  out_frame->surface.Info = s->vpp_param.vpp.Out;
514 
515  return out_frame;
516 }
517 
518 /* create the QSV session */
520 {
521  AVFilterLink *inlink = avctx->inputs[0];
522  AVFilterLink *outlink = avctx->outputs[0];
523  AVQSVFramesContext *in_frames_hwctx = NULL;
524  AVQSVFramesContext *out_frames_hwctx = NULL;
525 
526  AVBufferRef *device_ref;
527  AVHWDeviceContext *device_ctx;
528  AVQSVDeviceContext *device_hwctx;
529  mfxHDL handle;
530  mfxHandleType handle_type;
531  mfxVersion ver;
532  mfxIMPL impl;
533  int ret, i;
534 
535  if (inlink->hw_frames_ctx) {
536  AVHWFramesContext *frames_ctx = (AVHWFramesContext *)inlink->hw_frames_ctx->data;
537 
538  device_ref = frames_ctx->device_ref;
539  in_frames_hwctx = frames_ctx->hwctx;
540 
541  s->in_mem_mode = in_frames_hwctx->frame_type;
542 
543  s->surface_ptrs_in = av_calloc(in_frames_hwctx->nb_surfaces,
544  sizeof(*s->surface_ptrs_in));
545  if (!s->surface_ptrs_in)
546  return AVERROR(ENOMEM);
547 
548  for (i = 0; i < in_frames_hwctx->nb_surfaces; i++)
549  s->surface_ptrs_in[i] = in_frames_hwctx->surfaces + i;
550 
551  s->nb_surface_ptrs_in = in_frames_hwctx->nb_surfaces;
552  } else if (avctx->hw_device_ctx) {
553  device_ref = avctx->hw_device_ctx;
554  s->in_mem_mode = MFX_MEMTYPE_SYSTEM_MEMORY;
555  } else {
556  av_log(avctx, AV_LOG_ERROR, "No hw context provided.\n");
557  return AVERROR(EINVAL);
558  }
559 
560  device_ctx = (AVHWDeviceContext *)device_ref->data;
561  device_hwctx = device_ctx->hwctx;
562 
563  if (outlink->format == AV_PIX_FMT_QSV) {
564  AVHWFramesContext *out_frames_ctx;
565  AVBufferRef *out_frames_ref = av_hwframe_ctx_alloc(device_ref);
566  if (!out_frames_ref)
567  return AVERROR(ENOMEM);
568 
569 #if QSV_HAVE_OPAQUE
570  s->out_mem_mode = IS_OPAQUE_MEMORY(s->in_mem_mode) ?
571  MFX_MEMTYPE_OPAQUE_FRAME :
572  MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_FROM_VPPOUT;
573 #else
574  s->out_mem_mode = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET | MFX_MEMTYPE_FROM_VPPOUT;
575 #endif
576 
577  out_frames_ctx = (AVHWFramesContext *)out_frames_ref->data;
578  out_frames_hwctx = out_frames_ctx->hwctx;
579 
580  out_frames_ctx->format = AV_PIX_FMT_QSV;
581  out_frames_ctx->width = FFALIGN(outlink->w, 32);
582  out_frames_ctx->height = FFALIGN(outlink->h, 32);
583  out_frames_ctx->sw_format = s->out_sw_format;
584  out_frames_ctx->initial_pool_size = 64;
585  if (avctx->extra_hw_frames > 0)
586  out_frames_ctx->initial_pool_size += avctx->extra_hw_frames;
587  out_frames_hwctx->frame_type = s->out_mem_mode;
588 
589  ret = av_hwframe_ctx_init(out_frames_ref);
590  if (ret < 0) {
591  av_buffer_unref(&out_frames_ref);
592  av_log(avctx, AV_LOG_ERROR, "Error creating frames_ctx for output pad.\n");
593  return ret;
594  }
595 
596  s->surface_ptrs_out = av_calloc(out_frames_hwctx->nb_surfaces,
597  sizeof(*s->surface_ptrs_out));
598  if (!s->surface_ptrs_out) {
599  av_buffer_unref(&out_frames_ref);
600  return AVERROR(ENOMEM);
601  }
602 
603  for (i = 0; i < out_frames_hwctx->nb_surfaces; i++)
604  s->surface_ptrs_out[i] = out_frames_hwctx->surfaces + i;
605  s->nb_surface_ptrs_out = out_frames_hwctx->nb_surfaces;
606 
607  av_buffer_unref(&outlink->hw_frames_ctx);
608  outlink->hw_frames_ctx = out_frames_ref;
609  } else
610  s->out_mem_mode = MFX_MEMTYPE_SYSTEM_MEMORY;
611 
612  /* extract the properties of the "master" session given to us */
613  ret = MFXQueryIMPL(device_hwctx->session, &impl);
614  if (ret == MFX_ERR_NONE)
615  ret = MFXQueryVersion(device_hwctx->session, &ver);
616  if (ret != MFX_ERR_NONE) {
617  av_log(avctx, AV_LOG_ERROR, "Error querying the session attributes\n");
618  return AVERROR_UNKNOWN;
619  }
620 
621  if (MFX_IMPL_VIA_VAAPI == MFX_IMPL_VIA_MASK(impl)) {
622  handle_type = MFX_HANDLE_VA_DISPLAY;
623  } else if (MFX_IMPL_VIA_D3D11 == MFX_IMPL_VIA_MASK(impl)) {
624  handle_type = MFX_HANDLE_D3D11_DEVICE;
625  } else if (MFX_IMPL_VIA_D3D9 == MFX_IMPL_VIA_MASK(impl)) {
626  handle_type = MFX_HANDLE_D3D9_DEVICE_MANAGER;
627  } else {
628  av_log(avctx, AV_LOG_ERROR, "Error unsupported handle type\n");
629  return AVERROR_UNKNOWN;
630  }
631 
632  ret = MFXVideoCORE_GetHandle(device_hwctx->session, handle_type, &handle);
633  if (ret < 0)
634  return ff_qsvvpp_print_error(avctx, ret, "Error getting the session handle");
635  else if (ret > 0) {
636  ff_qsvvpp_print_warning(avctx, ret, "Warning in getting the session handle");
637  return AVERROR_UNKNOWN;
638  }
639 
640  /* create a "slave" session with those same properties, to be used for vpp */
641  ret = ff_qsvvpp_create_mfx_session(avctx, device_hwctx->loader, impl, &ver,
642  &s->session);
643  if (ret)
644  return ret;
645 
646  if (handle) {
647  ret = MFXVideoCORE_SetHandle(s->session, handle_type, handle);
648  if (ret != MFX_ERR_NONE)
649  return AVERROR_UNKNOWN;
650  }
651 
652  if (QSV_RUNTIME_VERSION_ATLEAST(ver, 1, 25)) {
653  ret = MFXJoinSession(device_hwctx->session, s->session);
654  if (ret != MFX_ERR_NONE)
655  return AVERROR_UNKNOWN;
656  }
657 
658 #if QSV_HAVE_OPAQUE
659  if (IS_OPAQUE_MEMORY(s->in_mem_mode) || IS_OPAQUE_MEMORY(s->out_mem_mode)) {
660  s->opaque_alloc.In.Surfaces = s->surface_ptrs_in;
661  s->opaque_alloc.In.NumSurface = s->nb_surface_ptrs_in;
662  s->opaque_alloc.In.Type = s->in_mem_mode;
663 
664  s->opaque_alloc.Out.Surfaces = s->surface_ptrs_out;
665  s->opaque_alloc.Out.NumSurface = s->nb_surface_ptrs_out;
666  s->opaque_alloc.Out.Type = s->out_mem_mode;
667 
668  s->opaque_alloc.Header.BufferId = MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION;
669  s->opaque_alloc.Header.BufferSz = sizeof(s->opaque_alloc);
670  } else
671 #endif
672  if (IS_VIDEO_MEMORY(s->in_mem_mode) || IS_VIDEO_MEMORY(s->out_mem_mode)) {
673  mfxFrameAllocator frame_allocator = {
674  .pthis = s,
675  .Alloc = frame_alloc,
676  .Lock = frame_lock,
677  .Unlock = frame_unlock,
678  .GetHDL = frame_get_hdl,
679  .Free = frame_free,
680  };
681 
682  ret = MFXVideoCORE_SetFrameAllocator(s->session, &frame_allocator);
683  if (ret != MFX_ERR_NONE)
684  return AVERROR_UNKNOWN;
685  }
686 
687  return 0;
688 }
689 
691 {
692  int i;
693  int ret;
694  QSVVPPContext *s = avctx->priv;
695 
696  s->filter_frame = param->filter_frame;
697  if (!s->filter_frame)
698  s->filter_frame = ff_filter_frame;
699  s->out_sw_format = param->out_sw_format;
700 
701  /* create the vpp session */
702  ret = init_vpp_session(avctx, s);
703  if (ret < 0)
704  goto failed;
705 
706  s->frame_infos = av_calloc(avctx->nb_inputs, sizeof(*s->frame_infos));
707  if (!s->frame_infos) {
708  ret = AVERROR(ENOMEM);
709  goto failed;
710  }
711 
712  /* Init each input's information */
713  for (i = 0; i < avctx->nb_inputs; i++) {
714  ret = fill_frameinfo_by_link(&s->frame_infos[i], avctx->inputs[i]);
715  if (ret < 0)
716  goto failed;
717  }
718 
719  /* Update input's frame info according to crop */
720  for (i = 0; i < param->num_crop; i++) {
721  QSVVPPCrop *crop = param->crop + i;
722  if (crop->in_idx > avctx->nb_inputs) {
723  ret = AVERROR(EINVAL);
724  goto failed;
725  }
726  s->frame_infos[crop->in_idx].CropX = crop->x;
727  s->frame_infos[crop->in_idx].CropY = crop->y;
728  s->frame_infos[crop->in_idx].CropW = crop->w;
729  s->frame_infos[crop->in_idx].CropH = crop->h;
730  }
731 
732  s->vpp_param.vpp.In = s->frame_infos[0];
733 
734  ret = fill_frameinfo_by_link(&s->vpp_param.vpp.Out, avctx->outputs[0]);
735  if (ret < 0) {
736  av_log(avctx, AV_LOG_ERROR, "Fail to get frame info from link.\n");
737  goto failed;
738  }
739 
740 #if QSV_HAVE_OPAQUE
741  if (IS_OPAQUE_MEMORY(s->in_mem_mode) || IS_OPAQUE_MEMORY(s->out_mem_mode)) {
742  s->nb_ext_buffers = param->num_ext_buf + 1;
743  s->ext_buffers = av_calloc(s->nb_ext_buffers, sizeof(*s->ext_buffers));
744  if (!s->ext_buffers) {
745  ret = AVERROR(ENOMEM);
746  goto failed;
747  }
748 
749  s->ext_buffers[0] = (mfxExtBuffer *)&s->opaque_alloc;
750  for (i = 1; i < param->num_ext_buf; i++)
751  s->ext_buffers[i] = param->ext_buf[i - 1];
752  s->vpp_param.ExtParam = s->ext_buffers;
753  s->vpp_param.NumExtParam = s->nb_ext_buffers;
754  } else {
755  s->vpp_param.NumExtParam = param->num_ext_buf;
756  s->vpp_param.ExtParam = param->ext_buf;
757  }
758 #else
759  s->vpp_param.NumExtParam = param->num_ext_buf;
760  s->vpp_param.ExtParam = param->ext_buf;
761 #endif
762 
763  s->got_frame = 0;
764 
765  /** keep fifo size at least 1. Even when async_depth is 0, fifo is used. */
766  s->async_fifo = av_fifo_alloc2(s->async_depth + 1, sizeof(QSVAsyncFrame), 0);
767  if (!s->async_fifo) {
768  ret = AVERROR(ENOMEM);
769  goto failed;
770  }
771 
772  s->vpp_param.AsyncDepth = s->async_depth;
773 
774  if (IS_SYSTEM_MEMORY(s->in_mem_mode))
775  s->vpp_param.IOPattern |= MFX_IOPATTERN_IN_SYSTEM_MEMORY;
776  else if (IS_VIDEO_MEMORY(s->in_mem_mode))
777  s->vpp_param.IOPattern |= MFX_IOPATTERN_IN_VIDEO_MEMORY;
778 #if QSV_HAVE_OPAQUE
779  else if (IS_OPAQUE_MEMORY(s->in_mem_mode))
780  s->vpp_param.IOPattern |= MFX_IOPATTERN_IN_OPAQUE_MEMORY;
781 #endif
782 
783  if (IS_SYSTEM_MEMORY(s->out_mem_mode))
784  s->vpp_param.IOPattern |= MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
785  else if (IS_VIDEO_MEMORY(s->out_mem_mode))
786  s->vpp_param.IOPattern |= MFX_IOPATTERN_OUT_VIDEO_MEMORY;
787 #if QSV_HAVE_OPAQUE
788  else if (IS_OPAQUE_MEMORY(s->out_mem_mode))
789  s->vpp_param.IOPattern |= MFX_IOPATTERN_OUT_OPAQUE_MEMORY;
790 #endif
791 
792  /* Print input memory mode */
793  ff_qsvvpp_print_iopattern(avctx, s->vpp_param.IOPattern & 0x0F, "VPP");
794  /* Print output memory mode */
795  ff_qsvvpp_print_iopattern(avctx, s->vpp_param.IOPattern & 0xF0, "VPP");
796  ret = MFXVideoVPP_Init(s->session, &s->vpp_param);
797  if (ret < 0) {
798  ret = ff_qsvvpp_print_error(avctx, ret, "Failed to create a qsvvpp");
799  goto failed;
800  } else if (ret > 0)
801  ff_qsvvpp_print_warning(avctx, ret, "Warning When creating qsvvpp");
802 
803  return 0;
804 
805 failed:
806  ff_qsvvpp_close(avctx);
807 
808  return ret;
809 }
810 
812 {
813  QSVVPPContext *s = avctx->priv;
814 
815  if (s->session) {
816  MFXVideoVPP_Close(s->session);
817  MFXClose(s->session);
818  s->session = NULL;
819  }
820 
821  /* release all the resources */
822  clear_frame_list(&s->in_frame_list);
823  clear_frame_list(&s->out_frame_list);
824  av_freep(&s->surface_ptrs_in);
825  av_freep(&s->surface_ptrs_out);
826 #if QSV_HAVE_OPAQUE
827  av_freep(&s->ext_buffers);
828 #endif
829  av_freep(&s->frame_infos);
830  av_fifo_freep2(&s->async_fifo);
831 
832  return 0;
833 }
834 
836 {
837  AVFilterContext *ctx = inlink->dst;
838  AVFilterLink *outlink = ctx->outputs[0];
839  QSVAsyncFrame aframe;
840  mfxSyncPoint sync;
841  QSVFrame *in_frame, *out_frame;
842  int ret, ret1, filter_ret;
843 
844  while (s->eof && av_fifo_read(s->async_fifo, &aframe, 1) >= 0) {
845  if (MFXVideoCORE_SyncOperation(s->session, aframe.sync, 1000) < 0)
846  av_log(ctx, AV_LOG_WARNING, "Sync failed.\n");
847 
848  filter_ret = s->filter_frame(outlink, aframe.frame->frame);
849  if (filter_ret < 0) {
850  av_frame_free(&aframe.frame->frame);
851  return filter_ret;
852  }
853  aframe.frame->queued--;
854  s->got_frame = 1;
855  aframe.frame->frame = NULL;
856  };
857 
858  if (!picref)
859  return 0;
860 
861  in_frame = submit_frame(s, inlink, picref);
862  if (!in_frame) {
863  av_log(ctx, AV_LOG_ERROR, "Failed to submit frame on input[%d]\n",
865  return AVERROR(ENOMEM);
866  }
867 
868  do {
869  out_frame = query_frame(s, outlink);
870  if (!out_frame) {
871  av_log(ctx, AV_LOG_ERROR, "Failed to query an output frame.\n");
872  return AVERROR(ENOMEM);
873  }
874 
875  do {
876  ret = MFXVideoVPP_RunFrameVPPAsync(s->session, &in_frame->surface,
877  &out_frame->surface, NULL, &sync);
878  if (ret == MFX_WRN_DEVICE_BUSY)
879  av_usleep(500);
880  } while (ret == MFX_WRN_DEVICE_BUSY);
881 
882  if (ret < 0 && ret != MFX_ERR_MORE_SURFACE) {
883  /* Ignore more_data error */
884  if (ret == MFX_ERR_MORE_DATA)
885  return AVERROR(EAGAIN);
886  break;
887  }
888  out_frame->frame->pts = av_rescale_q(out_frame->surface.Data.TimeStamp,
889  default_tb, outlink->time_base);
890 
891  out_frame->queued++;
892  aframe = (QSVAsyncFrame){ sync, out_frame };
893  av_fifo_write(s->async_fifo, &aframe, 1);
894 
895  if (av_fifo_can_read(s->async_fifo) > s->async_depth) {
896  av_fifo_read(s->async_fifo, &aframe, 1);
897 
898  do {
899  ret1 = MFXVideoCORE_SyncOperation(s->session, aframe.sync, 1000);
900  } while (ret1 == MFX_WRN_IN_EXECUTION);
901 
902  if (ret1 < 0) {
903  ret = ret1;
904  break;
905  }
906 
907  filter_ret = s->filter_frame(outlink, aframe.frame->frame);
908  if (filter_ret < 0) {
909  av_frame_free(&aframe.frame->frame);
910  return filter_ret;
911  }
912 
913  aframe.frame->queued--;
914  s->got_frame = 1;
915  aframe.frame->frame = NULL;
916  }
917  } while(ret == MFX_ERR_MORE_SURFACE);
918 
919  if (ret < 0)
920  return ff_qsvvpp_print_error(ctx, ret, "Error running VPP");
921  else if (ret > 0)
922  ff_qsvvpp_print_warning(ctx, ret, "Warning in running VPP");
923 
924  return 0;
925 }
926 
927 #if QSV_ONEVPL
928 
930  void *loader,
931  mfxIMPL implementation,
932  mfxVersion *pver,
933  mfxSession *psession)
934 {
935  mfxStatus sts;
936  mfxSession session = NULL;
937  uint32_t impl_idx = 0;
938 
940  "Use Intel(R) oneVPL to create MFX session with the specified MFX loader\n");
941 
942  if (!loader) {
943  av_log(ctx, AV_LOG_ERROR, "Invalid MFX Loader handle\n");
944  return AVERROR(EINVAL);
945  }
946 
947  while (1) {
948  /* Enumerate all implementations */
949  mfxImplDescription *impl_desc;
950 
951  sts = MFXEnumImplementations(loader, impl_idx,
952  MFX_IMPLCAPS_IMPLDESCSTRUCTURE,
953  (mfxHDL *)&impl_desc);
954  /* Failed to find an available implementation */
955  if (sts == MFX_ERR_NOT_FOUND)
956  break;
957  else if (sts != MFX_ERR_NONE) {
958  impl_idx++;
959  continue;
960  }
961 
962  sts = MFXCreateSession(loader, impl_idx, &session);
963  MFXDispReleaseImplDescription(loader, impl_desc);
964  if (sts == MFX_ERR_NONE)
965  break;
966 
967  impl_idx++;
968  }
969 
970  if (sts < 0)
971  return ff_qsvvpp_print_error(ctx, sts,
972  "Error creating a MFX session");
973  else if (sts > 0) {
975  "Warning in MFX session creation");
976  return AVERROR_UNKNOWN;
977  }
978 
979  *psession = session;
980 
981  return 0;
982 }
983 
984 #else
985 
987  void *loader,
988  mfxIMPL implementation,
989  mfxVersion *pver,
990  mfxSession *psession)
991 {
992  mfxSession session = NULL;
993  mfxStatus sts;
994 
996  "Use Intel(R) Media SDK to create MFX session, API version is "
997  "%d.%d, the required implementation version is %d.%d\n",
998  MFX_VERSION_MAJOR, MFX_VERSION_MINOR, pver->Major, pver->Minor);
999 
1000  *psession = NULL;
1001  sts = MFXInit(implementation, pver, &session);
1002  if (sts < 0)
1003  return ff_qsvvpp_print_error(ctx, sts,
1004  "Error initializing an MFX session");
1005  else if (sts > 0) {
1006  ff_qsvvpp_print_warning(ctx, sts, "Warning in MFX session initialization");
1007  return AVERROR_UNKNOWN;
1008  }
1009 
1010  *psession = session;
1011 
1012  return 0;
1013 }
1014 
1015 #endif
1016 
1018 {
1019  /* When process YUV420 frames, FFmpeg uses same alignment on Y/U/V
1020  * planes. VPL and MSDK use Y plane's pitch / 2 as U/V planes's
1021  * pitch, which makes U/V planes 16-bytes aligned. We need to set a
1022  * separate alignment to meet runtime's behaviour.
1023  */
1025  FFALIGN(inlink->w, 32),
1026  FFALIGN(inlink->h, 32),
1027  16);
1028 }
ff_default_get_video_buffer2
AVFrame * ff_default_get_video_buffer2(AVFilterLink *link, int w, int h, int align)
Definition: video.c:41
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:101
frame_get_hdl
static mfxStatus frame_get_hdl(mfxHDL pthis, mfxMemId mid, mfxHDL *hdl)
Definition: qsvvpp.c:225
AVHWDeviceContext::hwctx
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
Definition: hwcontext.h:92
QSVVPPCrop::in_idx
int in_idx
Input index.
Definition: qsvvpp.h:89
AVQSVFramesContext::frame_type
int frame_type
A combination of MFX_MEMTYPE_* describing the frame pool.
Definition: hwcontext_qsv.h:60
mfx_iopattern
int mfx_iopattern
Definition: qsvvpp.c:57
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
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
IS_OPAQUE_MEMORY
#define IS_OPAQUE_MEMORY(mode)
Definition: qsvvpp.c:42
out
FILE * out
Definition: movenc.c:54
init_vpp_session
static int init_vpp_session(AVFilterContext *avctx, QSVVPPContext *s)
Definition: qsvvpp.c:519
frame_alloc
static mfxStatus frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req, mfxFrameAllocResponse *resp)
Definition: qsvvpp.c:175
QSVVPPParam::crop
QSVVPPCrop * crop
Definition: qsvvpp.h:106
QSVVPPParam::out_sw_format
enum AVPixelFormat out_sw_format
Definition: qsvvpp.h:102
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:978
AVFrame::duration
int64_t duration
Duration of the frame, in the same units as pts.
Definition: frame.h:719
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2888
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:209
ff_qsvvpp_get_video_buffer
AVFrame * ff_qsvvpp_get_video_buffer(AVFilterLink *inlink, int w, int h)
Definition: qsvvpp.c:1017
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
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
av_hwframe_ctx_init
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:334
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:437
AVFrame::width
int width
Definition: frame.h:402
AVQSVDeviceContext
This struct is allocated as AVHWDeviceContext.hwctx.
Definition: hwcontext_qsv.h:35
w
uint8_t w
Definition: llviddspenc.c:38
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:248
AVFrame::top_field_first
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:487
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AVFilterContext::hw_device_ctx
AVBufferRef * hw_device_ctx
For filters which will create hardware frames, sets the device the filter should create them in.
Definition: avfilter.h:458
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
mathematics.h
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
AVHWFramesContext::width
int width
The allocated dimensions of the frames in this pool.
Definition: hwcontext.h:229
video.h
QSVFrame::frame
AVFrame * frame
Definition: qsv_internal.h:81
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:351
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:417
qsvvpp.h
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
AVFilterContext::extra_hw_frames
int extra_hw_frames
Sets the number of extra hardware frames which the filter will allocate on its output links for use i...
Definition: avfilter.h:488
clear_unused_frames
static void clear_unused_frames(QSVFrame *list)
Definition: qsvvpp.c:343
AVRational::num
int num
Numerator.
Definition: rational.h:59
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:61
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:104
ff_qsvvpp_print_iopattern
int ff_qsvvpp_print_iopattern(void *log_ctx, int mfx_iopattern, const char *extra_string)
Definition: qsvvpp.c:72
MFX_IMPL_VIA_MASK
#define MFX_IMPL_VIA_MASK(impl)
Definition: qsvvpp.c:45
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
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:229
QSVVPPCrop::w
int w
Definition: qsvvpp.h:90
s
#define s(width, name)
Definition: cbs_vp9.c:256
format
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 format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
QSV_RUNTIME_VERSION_ATLEAST
#define QSV_RUNTIME_VERSION_ATLEAST(MFX_VERSION, MAJOR, MINOR)
Definition: qsv_internal.h:64
ctx
AVFormatContext * ctx
Definition: movenc.c:48
av_frame_clone
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:474
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
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:41
default_tb
static const AVRational default_tb
Definition: qsvvpp.c:49
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
av_usleep
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:84
link
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 link
Definition: filter_design.txt:23
if
if(ret)
Definition: filter_design.txt:179
fill_frameinfo_by_link
static int fill_frameinfo_by_link(mfxFrameInfo *frameinfo, AVFilterLink *link)
Definition: qsvvpp.c:288
QSVFrame
Definition: qsv_internal.h:80
QSVVPPContext
Definition: qsvvpp.h:55
ff_qsvvpp_close
int ff_qsvvpp_close(AVFilterContext *avctx)
Definition: qsvvpp.c:811
AVQSVFramesContext::surfaces
mfxFrameSurface1 * surfaces
Definition: hwcontext_qsv.h:54
NULL
#define NULL
Definition: coverity.c:32
AVHWFramesContext::sw_format
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
Definition: hwcontext.h:222
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:603
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
QSVVPPParam::num_crop
int num_crop
Definition: qsvvpp.h:105
QSVVPPParam
Definition: qsvvpp.h:93
QSVVPPCrop::x
int x
Definition: qsvvpp.h:90
qsv_errors
static const struct @232 qsv_errors[]
AV_PIX_FMT_YUYV422
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:67
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVHWFramesContext::device_ref
AVBufferRef * device_ref
A reference to the parent AVHWDeviceContext.
Definition: hwcontext.h:141
pix_fmt_to_mfx_fourcc
static int pix_fmt_to_mfx_fourcc(int format)
Definition: qsvvpp.c:237
ff_qsvvpp_print_error
int ff_qsvvpp_print_error(void *log_ctx, mfxStatus err, const char *error_string)
Definition: qsvvpp.c:154
AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:410
av_fifo_can_read
size_t av_fifo_can_read(const AVFifo *f)
Definition: fifo.c:87
list
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 list
Definition: filter_design.txt:25
QSVFrame::surface
mfxFrameSurface1 surface
Definition: qsv_internal.h:82
time.h
AV_PIX_FMT_QSV
@ AV_PIX_FMT_QSV
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
Definition: pixfmt.h:240
AVFilterContext::nb_inputs
unsigned nb_inputs
number of input pads
Definition: avfilter.h:411
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
IS_VIDEO_MEMORY
#define IS_VIDEO_MEMORY(mode)
Definition: qsvvpp.c:39
frame_unlock
static mfxStatus frame_unlock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
Definition: qsvvpp.c:220
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:417
mfxerr
mfxStatus mfxerr
Definition: qsvvpp.c:90
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:432
AVQSVDeviceContext::loader
void * loader
The mfxLoader handle used for mfxSession creation.
Definition: hwcontext_qsv.h:47
AVQSVFramesContext::nb_surfaces
int nb_surfaces
Definition: hwcontext_qsv.h:55
internal.h
QSVAsyncFrame::frame
QSVFrame * frame
Definition: qsvdec.c:72
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:482
QSVAsyncFrame::sync
mfxSyncPoint sync
Definition: qsvvpp.c:52
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
common.h
desc
const char * desc
Definition: qsvvpp.c:58
QSVVPPParam::num_ext_buf
int num_ext_buf
Definition: qsvvpp.h:98
frame_lock
static mfxStatus frame_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
Definition: qsvvpp.c:215
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
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
QSVVPPParam::filter_frame
int(* filter_frame)(AVFilterLink *outlink, AVFrame *frame)
Definition: qsvvpp.h:95
ff_qsvvpp_init
int ff_qsvvpp_init(AVFilterContext *avctx, QSVVPPParam *param)
Definition: qsvvpp.c:690
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
map_frame_to_surface
static int map_frame_to_surface(AVFrame *frame, mfxFrameSurface1 *surface)
Definition: qsvvpp.c:255
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:124
ret
ret
Definition: filter_design.txt:187
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:89
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
QSVFrame::queued
int queued
Definition: qsv_internal.h:100
AVHWFramesContext::hwctx
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:162
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
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:432
AVFrame::hw_frames_ctx
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame.
Definition: frame.h:669
QSVVPPCrop::h
int h
Crop rectangle.
Definition: qsvvpp.h:90
QSVVPPCrop::y
int y
Definition: qsvvpp.h:90
AVFrame::height
int height
Definition: frame.h:402
ff_qsvvpp_filter_frame
int ff_qsvvpp_filter_frame(QSVVPPContext *s, AVFilterLink *inlink, AVFrame *picref)
Definition: qsvvpp.c:835
AVQSVDeviceContext::session
mfxSession session
Definition: hwcontext_qsv.h:36
AVRational::den
int den
Denominator.
Definition: rational.h:60
averr
int averr
Definition: qsvvpp.c:91
FF_INLINK_IDX
#define FF_INLINK_IDX(link)
Find the index of a link.
Definition: internal.h:333
qsv_map_error
static int qsv_map_error(mfxStatus mfx_err, const char **desc)
Definition: qsvvpp.c:139
clear_frame_list
static void clear_frame_list(QSVFrame **list)
Definition: qsvvpp.c:356
AVFilterContext
An instance of a filter.
Definition: avfilter.h:402
AV_PIX_FMT_P010
#define AV_PIX_FMT_P010
Definition: pixfmt.h:508
qsv_iopatterns
static const struct @231 qsv_iopatterns[]
AVQSVFramesContext
This struct is allocated as AVHWFramesContext.hwctx.
Definition: hwcontext_qsv.h:53
AVHWFramesContext::initial_pool_size
int initial_pool_size
Initial size of the frame pool.
Definition: hwcontext.h:199
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
QSVAsyncFrame::sync
mfxSyncPoint * sync
Definition: qsvdec.c:71
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
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:375
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
h
h
Definition: vp9dsp_template.c:2038
IS_SYSTEM_MEMORY
#define IS_SYSTEM_MEMORY(mode)
Definition: qsvvpp.c:44
QSVVPPCrop
Definition: qsvvpp.h:88
get_free_frame
static QSVFrame * get_free_frame(QSVFrame **list)
Definition: qsvvpp.c:368
QSVAsyncFrame
Definition: qsvdec.c:70
ff_qsvvpp_create_mfx_session
int ff_qsvvpp_create_mfx_session(void *ctx, void *loader, mfxIMPL implementation, mfxVersion *pver, mfxSession *psession)
Definition: qsvvpp.c:986
av_hwframe_get_buffer
int av_hwframe_get_buffer(AVBufferRef *hwframe_ref, AVFrame *frame, int flags)
Allocate a new frame attached to the given AVHWFramesContext.
Definition: hwcontext.c:507
frame_free
static mfxStatus frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp)
Definition: qsvvpp.c:209
ff_qsvvpp_print_warning
int ff_qsvvpp_print_warning(void *log_ctx, mfxStatus err, const char *warning_string)
Definition: qsvvpp.c:164
AVFrame::repeat_pict
int repeat_pict
When decoding, this signals how much the picture must be delayed.
Definition: frame.h:477
QSVVPPParam::ext_buf
mfxExtBuffer ** ext_buf
Definition: qsvvpp.h:99
submit_frame
static QSVFrame * submit_frame(QSVVPPContext *s, AVFilterLink *inlink, AVFrame *picref)
Definition: qsvvpp.c:394
AVFilterContext::outputs
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:414
query_frame
static QSVFrame * query_frame(QSVVPPContext *s, AVFilterLink *outlink)
Definition: qsvvpp.c:465