FFmpeg: libavfilter/qsvvpp.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /