FFmpeg
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
hwcontext.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 #include "config.h"
20 
21 #include "avassert.h"
22 #include "buffer.h"
23 #include "common.h"
24 #include "hwcontext.h"
25 #include "hwcontext_internal.h"
26 #include "imgutils.h"
27 #include "log.h"
28 #include "mem.h"
29 #include "pixdesc.h"
30 #include "pixfmt.h"
31 
32 static const HWContextType * const hw_table[] = {
33 #if CONFIG_CUDA
35 #endif
36 #if CONFIG_D3D11VA
38 #endif
39 #if CONFIG_D3D12VA
41 #endif
42 #if CONFIG_LIBDRM
44 #endif
45 #if CONFIG_DXVA2
47 #endif
48 #if CONFIG_OPENCL
50 #endif
51 #if CONFIG_QSV
53 #endif
54 #if CONFIG_VAAPI
56 #endif
57 #if CONFIG_VDPAU
59 #endif
60 #if CONFIG_VIDEOTOOLBOX
62 #endif
63 #if CONFIG_MEDIACODEC
65 #endif
66 #if CONFIG_VULKAN
68 #endif
69 #if CONFIG_AMF
71 #endif
72 #if CONFIG_OHCODEC
74 #endif
75  NULL,
76 };
77 
78 static const char *const hw_type_names[] = {
79  [AV_HWDEVICE_TYPE_CUDA] = "cuda",
80  [AV_HWDEVICE_TYPE_DRM] = "drm",
81  [AV_HWDEVICE_TYPE_DXVA2] = "dxva2",
82  [AV_HWDEVICE_TYPE_D3D11VA] = "d3d11va",
83  [AV_HWDEVICE_TYPE_D3D12VA] = "d3d12va",
84  [AV_HWDEVICE_TYPE_OPENCL] = "opencl",
85  [AV_HWDEVICE_TYPE_QSV] = "qsv",
86  [AV_HWDEVICE_TYPE_VAAPI] = "vaapi",
87  [AV_HWDEVICE_TYPE_VDPAU] = "vdpau",
88  [AV_HWDEVICE_TYPE_VIDEOTOOLBOX] = "videotoolbox",
89  [AV_HWDEVICE_TYPE_MEDIACODEC] = "mediacodec",
90  [AV_HWDEVICE_TYPE_VULKAN] = "vulkan",
91  [AV_HWDEVICE_TYPE_AMF] = "amf",
92  [AV_HWDEVICE_TYPE_OHCODEC] = "ohcodec",
93 };
94 
95 typedef struct FFHWDeviceContext {
96  /**
97  * The public AVHWDeviceContext. See hwcontext.h for it.
98  */
100 
102 
103  /**
104  * For a derived device, a reference to the original device
105  * context it was derived from.
106  */
109 
111 {
112  int type;
113  for (type = 0; type < FF_ARRAY_ELEMS(hw_type_names); type++) {
114  if (hw_type_names[type] && !strcmp(hw_type_names[type], name))
115  return type;
116  }
117  return AV_HWDEVICE_TYPE_NONE;
118 }
119 
121 {
122  if (type > AV_HWDEVICE_TYPE_NONE &&
124  return hw_type_names[type];
125  else
126  return NULL;
127 }
128 
130 {
131  enum AVHWDeviceType next;
132  int i, set = 0;
133  for (i = 0; hw_table[i]; i++) {
134  if (prev != AV_HWDEVICE_TYPE_NONE && hw_table[i]->type <= prev)
135  continue;
136  if (!set || hw_table[i]->type < next) {
137  next = hw_table[i]->type;
138  set = 1;
139  }
140  }
141  return set ? next : AV_HWDEVICE_TYPE_NONE;
142 }
143 
144 static const char *hwdevice_ctx_get_name(void *ptr)
145 {
146  FFHWDeviceContext *ctx = ptr;
147  return ctx->hw_type->name;
148 }
149 
150 static const AVClass hwdevice_ctx_class = {
151  .class_name = "AVHWDeviceContext",
152  .item_name = hwdevice_ctx_get_name,
153  .category = AV_CLASS_CATEGORY_HWDEVICE,
154  .version = LIBAVUTIL_VERSION_INT,
155 };
156 
157 static void hwdevice_ctx_free(void *opaque, uint8_t *data)
158 {
160  AVHWDeviceContext *ctx = &ctxi->p;
161 
162  /* uninit might still want access the hw context and the user
163  * free() callback might destroy it, so uninit has to be called first */
164  if (ctxi->hw_type->device_uninit)
165  ctxi->hw_type->device_uninit(ctx);
166 
167  if (ctx->free)
168  ctx->free(ctx);
169 
171 
172  av_freep(&ctx->hwctx);
173  av_freep(&ctx);
174 }
175 
177 {
178  FFHWDeviceContext *ctxi;
180  AVBufferRef *buf;
181  const HWContextType *hw_type = NULL;
182  int i;
183 
184  for (i = 0; hw_table[i]; i++) {
185  if (hw_table[i]->type == type) {
186  hw_type = hw_table[i];
187  break;
188  }
189  }
190  if (!hw_type)
191  return NULL;
192 
193  ctxi = av_mallocz(sizeof(*ctxi));
194  if (!ctxi)
195  return NULL;
196  ctx = &ctxi->p;
197 
198  if (hw_type->device_hwctx_size) {
199  ctx->hwctx = av_mallocz(hw_type->device_hwctx_size);
200  if (!ctx->hwctx)
201  goto fail;
202  }
203 
204  buf = av_buffer_create((uint8_t*)ctx, sizeof(*ctx),
207  if (!buf)
208  goto fail;
209 
210  ctx->type = type;
212 
213  ctxi->hw_type = hw_type;
214 
215  return buf;
216 
217 fail:
218  av_freep(&ctx->hwctx);
219  av_freep(&ctx);
220  return NULL;
221 }
222 
224 {
225  FFHWDeviceContext *ctxi = (FFHWDeviceContext*)ref->data;
226  AVHWDeviceContext *ctx = &ctxi->p;
227  int ret = 0;
228 
229  if (ctxi->hw_type->device_init)
230  ret = ctxi->hw_type->device_init(ctx);
231 
232  return ret;
233 }
234 
235 static const AVClass hwframe_ctx_class = {
236  .class_name = "AVHWFramesContext",
237  .item_name = av_default_item_name,
238  .version = LIBAVUTIL_VERSION_INT,
239 };
240 
241 static void hwframe_ctx_free(void *opaque, uint8_t *data)
242 {
244  AVHWFramesContext *ctx = &ctxi->p;
245 
246  if (ctxi->pool_internal)
248 
249  if (ctxi->hw_type->frames_uninit)
250  ctxi->hw_type->frames_uninit(ctx);
251 
252  if (ctx->free)
253  ctx->free(ctx);
254 
256 
257  av_buffer_unref(&ctx->device_ref);
258 
259  av_freep(&ctx->hwctx);
260  av_freep(&ctx);
261 }
262 
264 {
265  FFHWDeviceContext *device_ctx = (FFHWDeviceContext*)device_ref_in->data;
266  const HWContextType *hw_type = device_ctx->hw_type;
267  FFHWFramesContext *ctxi;
269  AVBufferRef *buf, *device_ref = NULL;
270 
271  ctxi = av_mallocz(sizeof(*ctxi));
272  if (!ctxi)
273  return NULL;
274  ctx = &ctxi->p;
275 
276  if (hw_type->frames_hwctx_size) {
277  ctx->hwctx = av_mallocz(hw_type->frames_hwctx_size);
278  if (!ctx->hwctx)
279  goto fail;
280  }
281 
282  device_ref = av_buffer_ref(device_ref_in);
283  if (!device_ref)
284  goto fail;
285 
286  buf = av_buffer_create((uint8_t*)ctx, sizeof(*ctx),
289  if (!buf)
290  goto fail;
291 
293  ctx->device_ref = device_ref;
294  ctx->device_ctx = &device_ctx->p;
295  ctx->format = AV_PIX_FMT_NONE;
296  ctx->sw_format = AV_PIX_FMT_NONE;
297 
298  ctxi->hw_type = hw_type;
299 
300  return buf;
301 
302 fail:
303  av_buffer_unref(&device_ref);
304  av_freep(&ctx->hwctx);
305  av_freep(&ctx);
306  return NULL;
307 }
308 
310 {
312  AVFrame **frames;
313  int i, ret = 0;
314 
315  frames = av_calloc(ctx->initial_pool_size, sizeof(*frames));
316  if (!frames)
317  return AVERROR(ENOMEM);
318 
319  for (i = 0; i < ctx->initial_pool_size; i++) {
320  frames[i] = av_frame_alloc();
321  if (!frames[i])
322  goto fail;
323 
325  if (ret < 0)
326  goto fail;
327  }
328 
329 fail:
330  for (i = 0; i < ctx->initial_pool_size; i++)
332  av_freep(&frames);
333 
334  return ret;
335 }
336 
338 {
339  FFHWFramesContext *ctxi = (FFHWFramesContext*)ref->data;
340  AVHWFramesContext *ctx = &ctxi->p;
341  const enum AVPixelFormat *pix_fmt;
342  int ret;
343 
344  if (ctxi->source_frames) {
345  /* A derived frame context is already initialised. */
346  return 0;
347  }
348 
349  /* validate the pixel format */
350  for (pix_fmt = ctxi->hw_type->pix_fmts; *pix_fmt != AV_PIX_FMT_NONE; pix_fmt++) {
351  if (*pix_fmt == ctx->format)
352  break;
353  }
354  if (*pix_fmt == AV_PIX_FMT_NONE) {
356  "The hardware pixel format '%s' is not supported by the device type '%s'\n",
357  av_get_pix_fmt_name(ctx->format), ctxi->hw_type->name);
358  return AVERROR(ENOSYS);
359  }
360 
361  /* validate the dimensions */
362  ret = av_image_check_size(ctx->width, ctx->height, 0, ctx);
363  if (ret < 0)
364  return ret;
365 
366  /* format-specific init */
367  if (ctxi->hw_type->frames_init) {
368  ret = ctxi->hw_type->frames_init(ctx);
369  if (ret < 0)
370  return ret;
371  }
372 
373  if (ctxi->pool_internal && !ctx->pool)
374  ctx->pool = ctxi->pool_internal;
375 
376  /* preallocate the frames in the pool, if requested */
377  if (ctx->initial_pool_size > 0) {
379  if (ret < 0)
380  return ret;
381  }
382 
383  return 0;
384 }
385 
388  enum AVPixelFormat **formats, int flags)
389 {
390  FFHWFramesContext *ctxi = (FFHWFramesContext*)hwframe_ref->data;
391 
393  return AVERROR(ENOSYS);
394 
395  return ctxi->hw_type->transfer_get_formats(&ctxi->p, dir, formats);
396 }
397 
398 static int transfer_data_alloc(AVFrame *dst, const AVFrame *src, int flags)
399 {
401  AVFrame *frame_tmp;
402  int ret = 0;
403 
404  if (!src->hw_frames_ctx)
405  return AVERROR(EINVAL);
406  ctx = (AVHWFramesContext*)src->hw_frames_ctx->data;
407 
408  frame_tmp = av_frame_alloc();
409  if (!frame_tmp)
410  return AVERROR(ENOMEM);
411 
412  /* if the format is set, use that
413  * otherwise pick the first supported one */
414  if (dst->format >= 0) {
415  frame_tmp->format = dst->format;
416  } else {
417  enum AVPixelFormat *formats;
418 
419  ret = av_hwframe_transfer_get_formats(src->hw_frames_ctx,
421  &formats, 0);
422  if (ret < 0)
423  goto fail;
424  frame_tmp->format = formats[0];
425  av_freep(&formats);
426  }
427  frame_tmp->width = ctx->width;
428  frame_tmp->height = ctx->height;
429 
430  ret = av_frame_get_buffer(frame_tmp, 0);
431  if (ret < 0)
432  goto fail;
433 
434  ret = av_hwframe_transfer_data(frame_tmp, src, flags);
435  if (ret < 0)
436  goto fail;
437 
438  frame_tmp->width = src->width;
439  frame_tmp->height = src->height;
440 
441  av_frame_move_ref(dst, frame_tmp);
442 
443 fail:
444  av_frame_free(&frame_tmp);
445  return ret;
446 }
447 
449 {
450  int ret;
451 
452  if (!dst->buf[0])
453  return transfer_data_alloc(dst, src, flags);
454 
455  /*
456  * Hardware -> Hardware Transfer.
457  * Unlike Software -> Hardware or Hardware -> Software, the transfer
458  * function could be provided by either the src or dst, depending on
459  * the specific combination of hardware.
460  */
461  if (src->hw_frames_ctx && dst->hw_frames_ctx) {
462  FFHWFramesContext *src_ctx =
463  (FFHWFramesContext*)src->hw_frames_ctx->data;
464  FFHWFramesContext *dst_ctx =
465  (FFHWFramesContext*)dst->hw_frames_ctx->data;
466 
467  if (src_ctx->source_frames) {
468  av_log(src_ctx, AV_LOG_ERROR,
469  "A device with a derived frame context cannot be used as "
470  "the source of a HW -> HW transfer.");
471  return AVERROR(ENOSYS);
472  }
473 
474  if (dst_ctx->source_frames) {
475  av_log(src_ctx, AV_LOG_ERROR,
476  "A device with a derived frame context cannot be used as "
477  "the destination of a HW -> HW transfer.");
478  return AVERROR(ENOSYS);
479  }
480 
481  ret = src_ctx->hw_type->transfer_data_from(&src_ctx->p, dst, src);
482  if (ret == AVERROR(ENOSYS))
483  ret = dst_ctx->hw_type->transfer_data_to(&dst_ctx->p, dst, src);
484  if (ret < 0)
485  return ret;
486  } else {
487  if (src->hw_frames_ctx) {
488  FFHWFramesContext *ctx = (FFHWFramesContext*)src->hw_frames_ctx->data;
489 
490  ret = ctx->hw_type->transfer_data_from(&ctx->p, dst, src);
491  if (ret < 0)
492  return ret;
493  } else if (dst->hw_frames_ctx) {
494  FFHWFramesContext *ctx = (FFHWFramesContext*)dst->hw_frames_ctx->data;
495 
496  ret = ctx->hw_type->transfer_data_to(&ctx->p, dst, src);
497  if (ret < 0)
498  return ret;
499  } else {
500  return AVERROR(ENOSYS);
501  }
502  }
503  return 0;
504 }
505 
507 {
508  FFHWFramesContext *ctxi = (FFHWFramesContext*)hwframe_ref->data;
509  AVHWFramesContext *ctx = &ctxi->p;
510  int ret;
511 
512  if (ctxi->source_frames) {
513  // This is a derived frame context, so we allocate in the source
514  // and map the frame immediately.
515  AVFrame *src_frame;
516 
517  frame->format = ctx->format;
518  frame->hw_frames_ctx = av_buffer_ref(hwframe_ref);
519  if (!frame->hw_frames_ctx)
520  return AVERROR(ENOMEM);
521 
522  src_frame = av_frame_alloc();
523  if (!src_frame)
524  return AVERROR(ENOMEM);
525 
527  src_frame, 0);
528  if (ret < 0) {
529  av_frame_free(&src_frame);
530  return ret;
531  }
532 
533  ret = av_hwframe_map(frame, src_frame,
535  if (ret) {
536  av_log(ctx, AV_LOG_ERROR, "Failed to map frame into derived "
537  "frame context: %d.\n", ret);
538  av_frame_free(&src_frame);
539  return ret;
540  }
541 
542  // Free the source frame immediately - the mapped frame still
543  // contains a reference to it.
544  av_frame_free(&src_frame);
545 
546  return 0;
547  }
548 
549  if (!ctxi->hw_type->frames_get_buffer)
550  return AVERROR(ENOSYS);
551 
552  if (!ctx->pool)
553  return AVERROR(EINVAL);
554 
555  frame->hw_frames_ctx = av_buffer_ref(hwframe_ref);
556  if (!frame->hw_frames_ctx)
557  return AVERROR(ENOMEM);
558 
560  if (ret < 0) {
561  av_buffer_unref(&frame->hw_frames_ctx);
562  return ret;
563  }
564 
565  frame->extended_data = frame->data;
566 
567  return 0;
568 }
569 
571 {
573  const HWContextType *hw_type = ctx->hw_type;
574 
575  if (hw_type->device_hwconfig_size == 0)
576  return NULL;
577 
578  return av_mallocz(hw_type->device_hwconfig_size);
579 }
580 
582  const void *hwconfig)
583 {
585  const HWContextType *hw_type = ctx->hw_type;
586  AVHWFramesConstraints *constraints;
587 
588  if (!hw_type->frames_get_constraints)
589  return NULL;
590 
591  constraints = av_mallocz(sizeof(*constraints));
592  if (!constraints)
593  return NULL;
594 
595  constraints->min_width = constraints->min_height = 0;
596  constraints->max_width = constraints->max_height = INT_MAX;
597 
598  if (hw_type->frames_get_constraints(&ctx->p, hwconfig, constraints) >= 0) {
599  return constraints;
600  } else {
601  av_hwframe_constraints_free(&constraints);
602  return NULL;
603  }
604 }
605 
607 {
608  if (*constraints) {
609  av_freep(&(*constraints)->valid_hw_formats);
610  av_freep(&(*constraints)->valid_sw_formats);
611  }
612  av_freep(constraints);
613 }
614 
616  const char *device, AVDictionary *opts, int flags)
617 {
618  AVBufferRef *device_ref = NULL;
619  FFHWDeviceContext *device_ctx;
620  int ret = 0;
621 
622  device_ref = av_hwdevice_ctx_alloc(type);
623  if (!device_ref) {
624  ret = AVERROR(ENOMEM);
625  goto fail;
626  }
627  device_ctx = (FFHWDeviceContext*)device_ref->data;
628 
629  if (!device_ctx->hw_type->device_create) {
630  ret = AVERROR(ENOSYS);
631  goto fail;
632  }
633 
634  ret = device_ctx->hw_type->device_create(&device_ctx->p, device,
635  opts, flags);
636  if (ret < 0)
637  goto fail;
638 
639  ret = av_hwdevice_ctx_init(device_ref);
640  if (ret < 0)
641  goto fail;
642 
643  *pdevice_ref = device_ref;
644  return 0;
645 fail:
646  av_buffer_unref(&device_ref);
647  *pdevice_ref = NULL;
648  return ret;
649 }
650 
652  enum AVHWDeviceType type,
653  AVBufferRef *src_ref,
654  AVDictionary *options, int flags)
655 {
656  AVBufferRef *dst_ref = NULL, *tmp_ref;
657  FFHWDeviceContext *dst_ctx;
658  int ret = 0;
659 
660  tmp_ref = src_ref;
661  while (tmp_ref) {
662  FFHWDeviceContext *tmp_ctx = (FFHWDeviceContext*)tmp_ref->data;
663  if (tmp_ctx->p.type == type) {
664  dst_ref = av_buffer_ref(tmp_ref);
665  if (!dst_ref) {
666  ret = AVERROR(ENOMEM);
667  goto fail;
668  }
669  goto done;
670  }
671  tmp_ref = tmp_ctx->source_device;
672  }
673 
674  dst_ref = av_hwdevice_ctx_alloc(type);
675  if (!dst_ref) {
676  ret = AVERROR(ENOMEM);
677  goto fail;
678  }
679  dst_ctx = (FFHWDeviceContext*)dst_ref->data;
680 
681  tmp_ref = src_ref;
682  while (tmp_ref) {
683  FFHWDeviceContext *tmp_ctx = (FFHWDeviceContext*)tmp_ref->data;
684  if (dst_ctx->hw_type->device_derive) {
685  ret = dst_ctx->hw_type->device_derive(&dst_ctx->p,
686  &tmp_ctx->p,
687  options, flags);
688  if (ret == 0) {
689  dst_ctx->source_device = av_buffer_ref(src_ref);
690  if (!dst_ctx->source_device) {
691  ret = AVERROR(ENOMEM);
692  goto fail;
693  }
694  ret = av_hwdevice_ctx_init(dst_ref);
695  if (ret < 0)
696  goto fail;
697  goto done;
698  }
699  if (ret != AVERROR(ENOSYS))
700  goto fail;
701  }
702  tmp_ref = tmp_ctx->source_device;
703  }
704 
705  ret = AVERROR(ENOSYS);
706  goto fail;
707 
708 done:
709  *dst_ref_ptr = dst_ref;
710  return 0;
711 
712 fail:
713  av_buffer_unref(&dst_ref);
714  *dst_ref_ptr = NULL;
715  return ret;
716 }
717 
719  enum AVHWDeviceType type,
720  AVBufferRef *src_ref, int flags)
721 {
722  return av_hwdevice_ctx_create_derived_opts(dst_ref_ptr, type, src_ref,
723  NULL, flags);
724 }
725 
726 static void ff_hwframe_unmap(void *opaque, uint8_t *data)
727 {
729  AVHWFramesContext *ctx = opaque;
730 
731  if (hwmap->unmap)
732  hwmap->unmap(ctx, hwmap);
733 
734  av_frame_free(&hwmap->source);
735 
737 
738  av_free(hwmap);
739 }
740 
742  AVFrame *dst, const AVFrame *src,
743  void (*unmap)(AVHWFramesContext *ctx,
744  HWMapDescriptor *hwmap),
745  void *priv)
746 {
747  AVHWFramesContext *ctx = (AVHWFramesContext*)hwframe_ref->data;
748  HWMapDescriptor *hwmap;
749  int ret;
750 
751  hwmap = av_mallocz(sizeof(*hwmap));
752  if (!hwmap) {
753  ret = AVERROR(ENOMEM);
754  goto fail;
755  }
756 
757  hwmap->source = av_frame_alloc();
758  if (!hwmap->source) {
759  ret = AVERROR(ENOMEM);
760  goto fail;
761  }
762  ret = av_frame_ref(hwmap->source, src);
763  if (ret < 0)
764  goto fail;
765 
766  hwmap->hw_frames_ctx = av_buffer_ref(hwframe_ref);
767  if (!hwmap->hw_frames_ctx) {
768  ret = AVERROR(ENOMEM);
769  goto fail;
770  }
771 
772  hwmap->unmap = unmap;
773  hwmap->priv = priv;
774 
775  dst->buf[0] = av_buffer_create((uint8_t*)hwmap, sizeof(*hwmap),
776  &ff_hwframe_unmap, ctx, 0);
777  if (!dst->buf[0]) {
778  ret = AVERROR(ENOMEM);
779  goto fail;
780  }
781 
782  return 0;
783 
784 fail:
785  if (hwmap) {
786  av_buffer_unref(&hwmap->hw_frames_ctx);
787  av_frame_free(&hwmap->source);
788  }
789  av_free(hwmap);
790  return ret;
791 }
792 
794 {
795  AVBufferRef *orig_dst_frames = dst->hw_frames_ctx;
796  enum AVPixelFormat orig_dst_fmt = dst->format;
797  HWMapDescriptor *hwmap;
798  int ret;
799 
800  if (src->hw_frames_ctx && dst->hw_frames_ctx) {
801  FFHWFramesContext *src_frames = (FFHWFramesContext*)src->hw_frames_ctx->data;
802  FFHWFramesContext *dst_frames = (FFHWFramesContext*)dst->hw_frames_ctx->data;
803 
804  if ((src_frames == dst_frames &&
805  src->format == dst_frames->p.sw_format &&
806  dst->format == dst_frames->p.format) ||
807  (src_frames->source_frames &&
808  src_frames->source_frames->data ==
809  (uint8_t*)dst_frames)) {
810  // This is an unmap operation. We don't need to directly
811  // do anything here other than fill in the original frame,
812  // because the real unmap will be invoked when the last
813  // reference to the mapped frame disappears.
814  if (!src->buf[0]) {
815  av_log(src_frames, AV_LOG_ERROR, "Invalid mapping "
816  "found when attempting unmap.\n");
817  return AVERROR(EINVAL);
818  }
819  hwmap = (HWMapDescriptor*)src->buf[0]->data;
820  return av_frame_replace(dst, hwmap->source);
821  }
822  }
823 
824  if (src->hw_frames_ctx) {
825  FFHWFramesContext *src_frames = (FFHWFramesContext*)src->hw_frames_ctx->data;
826 
827  if (src_frames->p.format == src->format &&
828  src_frames->hw_type->map_from) {
829  ret = src_frames->hw_type->map_from(&src_frames->p,
830  dst, src, flags);
831  if (ret >= 0)
832  return ret;
833  else if (ret != AVERROR(ENOSYS))
834  goto fail;
835  }
836  }
837 
838  if (dst->hw_frames_ctx) {
839  FFHWFramesContext *dst_frames = (FFHWFramesContext*)dst->hw_frames_ctx->data;
840 
841  if (dst_frames->p.format == dst->format &&
842  dst_frames->hw_type->map_to) {
843  ret = dst_frames->hw_type->map_to(&dst_frames->p,
844  dst, src, flags);
845  if (ret >= 0)
846  return ret;
847  else if (ret != AVERROR(ENOSYS))
848  goto fail;
849  }
850  }
851 
852  return AVERROR(ENOSYS);
853 
854 fail:
855  // if the caller provided dst frames context, it should be preserved
856  // by this function
857  av_assert0(orig_dst_frames == NULL ||
858  orig_dst_frames == dst->hw_frames_ctx);
859 
860  // preserve user-provided dst frame fields, but clean
861  // anything we might have set
862  dst->hw_frames_ctx = NULL;
864 
865  dst->hw_frames_ctx = orig_dst_frames;
866  dst->format = orig_dst_fmt;
867 
868  return ret;
869 }
870 
872  enum AVPixelFormat format,
873  AVBufferRef *derived_device_ctx,
874  AVBufferRef *source_frame_ctx,
875  int flags)
876 {
877  AVBufferRef *dst_ref = NULL;
878  FFHWFramesContext *dsti = NULL;
879  FFHWFramesContext *srci = (FFHWFramesContext*)source_frame_ctx->data;
880  AVHWFramesContext *dst, *src = &srci->p;
881  int ret;
882 
883  if (srci->source_frames) {
884  AVHWFramesContext *src_src =
886  AVHWDeviceContext *dst_dev =
887  (AVHWDeviceContext*)derived_device_ctx->data;
888 
889  if (src_src->device_ctx == dst_dev) {
890  // This is actually an unmapping, so we just return a
891  // reference to the source frame context.
892  *derived_frame_ctx = av_buffer_ref(srci->source_frames);
893  if (!*derived_frame_ctx) {
894  ret = AVERROR(ENOMEM);
895  goto fail;
896  }
897  return 0;
898  }
899  }
900 
901  dst_ref = av_hwframe_ctx_alloc(derived_device_ctx);
902  if (!dst_ref) {
903  ret = AVERROR(ENOMEM);
904  goto fail;
905  }
906 
907  dsti = (FFHWFramesContext*)dst_ref->data;
908  dst = &dsti->p;
909 
910  dst->format = format;
911  dst->sw_format = src->sw_format;
912  dst->width = src->width;
913  dst->height = src->height;
914 
915  dsti->source_frames = av_buffer_ref(source_frame_ctx);
916  if (!dsti->source_frames) {
917  ret = AVERROR(ENOMEM);
918  goto fail;
919  }
920 
926 
927  ret = AVERROR(ENOSYS);
928  if (srci->hw_type->frames_derive_from)
930  if (ret == AVERROR(ENOSYS) &&
931  dsti->hw_type->frames_derive_to)
932  ret = dsti->hw_type->frames_derive_to(dst, src, flags);
933  if (ret == AVERROR(ENOSYS))
934  ret = 0;
935  if (ret)
936  goto fail;
937 
938  *derived_frame_ctx = dst_ref;
939  return 0;
940 
941 fail:
942  if (dsti)
944  av_buffer_unref(&dst_ref);
945  return ret;
946 }
947 
949 {
950  HWMapDescriptor *hwmap = (HWMapDescriptor*)dst->buf[0]->data;
951  return av_frame_replace(hwmap->source, src);
952 }
flags
const SwsFlags flags[]
Definition: swscale.c:61
formats
formats
Definition: signature.h:47
FFHWFramesContext::pool_internal
AVBufferPool * pool_internal
Definition: hwcontext_internal.h:101
hwframe_ctx_free
static void hwframe_ctx_free(void *opaque, uint8_t *data)
Definition: hwcontext.c:241
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
HWContextType::device_uninit
void(* device_uninit)(AVHWDeviceContext *ctx)
Definition: hwcontext_internal.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
AV_HWFRAME_TRANSFER_DIRECTION_FROM
@ AV_HWFRAME_TRANSFER_DIRECTION_FROM
Transfer the data from the queried hw frame.
Definition: hwcontext.h:410
HWContextType::frames_get_buffer
int(* frames_get_buffer)(AVHWFramesContext *ctx, AVFrame *frame)
Definition: hwcontext_internal.h:73
HWMapDescriptor::source
AVFrame * source
A reference to the original source of the mapping.
Definition: hwcontext_internal.h:124
av_frame_get_buffer
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:205
transfer_data_alloc
static int transfer_data_alloc(AVFrame *dst, const AVFrame *src, int flags)
Definition: hwcontext.c:398
av_hwdevice_hwconfig_alloc
void * av_hwdevice_hwconfig_alloc(AVBufferRef *ref)
Allocate a HW-specific configuration structure for a given HW device.
Definition: hwcontext.c:570
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
ff_hwframe_unmap
static void ff_hwframe_unmap(void *opaque, uint8_t *data)
Definition: hwcontext.c:726
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:200
hwdevice_ctx_free
static void hwdevice_ctx_free(void *opaque, uint8_t *data)
Definition: hwcontext.c:157
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:63
av_hwframe_ctx_init
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:337
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:421
pixdesc.h
FFHWFramesContext
Definition: hwcontext_internal.h:93
AVFrame::width
int width
Definition: frame.h:493
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:263
AV_HWDEVICE_TYPE_NONE
@ AV_HWDEVICE_TYPE_NONE
Definition: hwcontext.h:28
ff_hwcontext_type_qsv
const HWContextType ff_hwcontext_type_qsv
Definition: hwcontext_qsv.c:2624
av_hwframe_map
int av_hwframe_map(AVFrame *dst, const AVFrame *src, int flags)
Map a hardware frame.
Definition: hwcontext.c:793
ff_hwcontext_type_drm
const HWContextType ff_hwcontext_type_drm
Definition: hwcontext_drm.c:305
data
const char data[16]
Definition: mxf.c:149
AV_HWDEVICE_TYPE_MEDIACODEC
@ AV_HWDEVICE_TYPE_MEDIACODEC
Definition: hwcontext.h:38
HWContextType::map_to
int(* map_to)(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src, int flags)
Definition: hwcontext_internal.h:82
ff_hwcontext_type_vdpau
const HWContextType ff_hwcontext_type_vdpau
Definition: hwcontext_vdpau.c:513
av_hwdevice_find_type_by_name
enum AVHWDeviceType av_hwdevice_find_type_by_name(const char *name)
Look up an AVHWDeviceType by name.
Definition: hwcontext.c:110
HWContextType::frames_init
int(* frames_init)(AVHWFramesContext *ctx)
Definition: hwcontext_internal.h:70
ff_hwcontext_type_vaapi
const HWContextType ff_hwcontext_type_vaapi
Definition: hwcontext_vaapi.c:2057
HWContextType::map_from
int(* map_from)(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src, int flags)
Definition: hwcontext_internal.h:84
av_hwdevice_iterate_types
enum AVHWDeviceType av_hwdevice_iterate_types(enum AVHWDeviceType prev)
Iterate over supported device types.
Definition: hwcontext.c:129
AVDictionary
Definition: dict.c:32
HWMapDescriptor::hw_frames_ctx
AVBufferRef * hw_frames_ctx
A reference to the hardware frames context in which this mapping was made.
Definition: hwcontext_internal.h:130
ff_hwframe_map_create
int ff_hwframe_map_create(AVBufferRef *hwframe_ref, AVFrame *dst, const AVFrame *src, void(*unmap)(AVHWFramesContext *ctx, HWMapDescriptor *hwmap), void *priv)
Definition: hwcontext.c:741
AV_HWDEVICE_TYPE_VIDEOTOOLBOX
@ AV_HWDEVICE_TYPE_VIDEOTOOLBOX
Definition: hwcontext.h:34
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
AV_HWFRAME_MAP_OVERWRITE
@ AV_HWFRAME_MAP_OVERWRITE
The mapped frame will be overwritten completely in subsequent operations, so the current frame data n...
Definition: hwcontext.h:525
HWMapDescriptor::priv
void * priv
Hardware-specific private data associated with the mapping.
Definition: hwcontext_internal.h:139
av_hwdevice_get_hwframe_constraints
AVHWFramesConstraints * av_hwdevice_get_hwframe_constraints(AVBufferRef *ref, const void *hwconfig)
Get the constraints on HW frames given a device and the HW-specific configuration to be used with tha...
Definition: hwcontext.c:581
av_hwdevice_ctx_init
int av_hwdevice_ctx_init(AVBufferRef *ref)
Finalize the device context before use.
Definition: hwcontext.c:223
AV_HWFRAME_MAP_DIRECT
@ AV_HWFRAME_MAP_DIRECT
The mapping must be direct.
Definition: hwcontext.h:531
AV_HWDEVICE_TYPE_VULKAN
@ AV_HWDEVICE_TYPE_VULKAN
Definition: hwcontext.h:39
AVHWFramesConstraints
This struct describes the constraints on hardware frames attached to a given device with a hardware-s...
Definition: hwcontext.h:444
AV_HWDEVICE_TYPE_CUDA
@ AV_HWDEVICE_TYPE_CUDA
Definition: hwcontext.h:30
ff_hwcontext_type_d3d11va
const HWContextType ff_hwcontext_type_d3d11va
Definition: hwcontext_d3d11va.c:712
HWContextType::device_derive
int(* device_derive)(AVHWDeviceContext *dst_ctx, AVHWDeviceContext *src_ctx, AVDictionary *opts, int flags)
Definition: hwcontext_internal.h:59
fail
#define fail()
Definition: checkasm.h:199
frames
if it could not because there are no more frames
Definition: filter_design.txt:267
AV_HWDEVICE_TYPE_D3D11VA
@ AV_HWDEVICE_TYPE_D3D11VA
Definition: hwcontext.h:35
av_hwdevice_ctx_create_derived_opts
int av_hwdevice_ctx_create_derived_opts(AVBufferRef **dst_ref_ptr, enum AVHWDeviceType type, AVBufferRef *src_ref, AVDictionary *options, int flags)
Create a new device of the specified type from an existing device.
Definition: hwcontext.c:651
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
ff_hwcontext_type_mediacodec
const HWContextType ff_hwcontext_type_mediacodec
Definition: hwcontext_mediacodec.c:107
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:63
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:51
hwframe_pool_prealloc
static int hwframe_pool_prealloc(AVBufferRef *ref)
Definition: hwcontext.c:309
FFHWDeviceContext::hw_type
const HWContextType * hw_type
Definition: hwcontext.c:101
avassert.h
HWContextType::type
enum AVHWDeviceType type
Definition: hwcontext_internal.h:30
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
ff_hwcontext_type_dxva2
const HWContextType ff_hwcontext_type_dxva2
Definition: hwcontext_dxva2.c:595
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
set
static void set(uint8_t *a[], int ch, int index, int ch_count, enum AVSampleFormat f, double v)
Definition: swresample.c:59
hw_type_names
static const char *const hw_type_names[]
Definition: hwcontext.c:78
av_hwdevice_ctx_alloc
AVBufferRef * av_hwdevice_ctx_alloc(enum AVHWDeviceType type)
Allocate an AVHWDeviceContext for a given hardware type.
Definition: hwcontext.c:176
hw_table
static const HWContextType *const hw_table[]
Definition: hwcontext.c:32
av_hwframe_constraints_free
void av_hwframe_constraints_free(AVHWFramesConstraints **constraints)
Free an AVHWFrameConstraints structure.
Definition: hwcontext.c:606
AV_BUFFER_FLAG_READONLY
#define AV_BUFFER_FLAG_READONLY
Always treat the buffer as read-only, even when it has only one reference.
Definition: buffer.h:114
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
HWContextType::frames_uninit
void(* frames_uninit)(AVHWFramesContext *ctx)
Definition: hwcontext_internal.h:71
FFHWFramesContext::source_allocation_map_flags
int source_allocation_map_flags
Flags to apply to the mapping from the source to the derived frame context when trying to allocate in...
Definition: hwcontext_internal.h:112
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
AVHWDeviceType
AVHWDeviceType
Definition: hwcontext.h:27
AV_HWDEVICE_TYPE_AMF
@ AV_HWDEVICE_TYPE_AMF
Definition: hwcontext.h:41
ctx
AVFormatContext * ctx
Definition: movenc.c:49
HWContextType::device_create
int(* device_create)(AVHWDeviceContext *ctx, const char *device, AVDictionary *opts, int flags)
Definition: hwcontext_internal.h:57
AV_CLASS_CATEGORY_HWDEVICE
@ AV_CLASS_CATEGORY_HWDEVICE
Definition: log.h:40
av_hwdevice_get_type_name
const char * av_hwdevice_get_type_name(enum AVHWDeviceType type)
Get the string name of an AVHWDeviceType.
Definition: hwcontext.c:120
FFHWFramesContext::p
AVHWFramesContext p
The public AVHWFramesContext.
Definition: hwcontext_internal.h:97
ff_hwcontext_type_videotoolbox
const HWContextType ff_hwcontext_type_videotoolbox
Definition: hwcontext_videotoolbox.c:828
if
if(ret)
Definition: filter_design.txt:179
opts
AVDictionary * opts
Definition: movenc.c:51
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
NULL
#define NULL
Definition: coverity.c:32
format
New swscale design to change SwsGraph is what coordinates multiple passes These can include cascaded scaling error diffusion and so on Or we could have separate passes for the vertical and horizontal scaling In between each SwsPass lies a fully allocated image buffer Graph passes may have different levels of e g we can have a single threaded error diffusion pass following a multi threaded scaling pass SwsGraph is internally recreated whenever the image format
Definition: swscale-v2.txt:14
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
HWContextType::transfer_get_formats
int(* transfer_get_formats)(AVHWFramesContext *ctx, enum AVHWFrameTransferDirection dir, enum AVPixelFormat **formats)
Definition: hwcontext_internal.h:74
AV_HWDEVICE_TYPE_DXVA2
@ AV_HWDEVICE_TYPE_DXVA2
Definition: hwcontext.h:32
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:240
av_buffer_pool_uninit
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:328
options
Definition: swscale.c:43
av_hwframe_ctx_create_derived
int av_hwframe_ctx_create_derived(AVBufferRef **derived_frame_ctx, enum AVPixelFormat format, AVBufferRef *derived_device_ctx, AVBufferRef *source_frame_ctx, int flags)
Create and initialise an AVHWFramesContext as a mapping of another existing AVHWFramesContext on a di...
Definition: hwcontext.c:871
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
AV_HWDEVICE_TYPE_OHCODEC
@ AV_HWDEVICE_TYPE_OHCODEC
Definition: hwcontext.h:43
HWContextType::frames_derive_to
int(* frames_derive_to)(AVHWFramesContext *dst_ctx, AVHWFramesContext *src_ctx, int flags)
Definition: hwcontext_internal.h:87
AV_HWDEVICE_TYPE_D3D12VA
@ AV_HWDEVICE_TYPE_D3D12VA
Definition: hwcontext.h:40
AV_HWDEVICE_TYPE_OPENCL
@ AV_HWDEVICE_TYPE_OPENCL
Definition: hwcontext.h:37
FFHWFramesContext::hw_type
const HWContextType * hw_type
Definition: hwcontext_internal.h:99
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:276
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
FFHWFramesContext::source_frames
AVBufferRef * source_frames
For a derived context, a reference to the original frames context it was derived from.
Definition: hwcontext_internal.h:107
ff_hwcontext_type_amf
const HWContextType ff_hwcontext_type_amf
Definition: hwcontext_amf.c:639
ff_hwcontext_type_cuda
const HWContextType ff_hwcontext_type_cuda
Definition: hwcontext_cuda.c:568
AV_HWFRAME_MAP_READ
@ AV_HWFRAME_MAP_READ
The mapping must be readable.
Definition: hwcontext.h:515
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:508
buffer.h
HWContextType::frames_derive_from
int(* frames_derive_from)(AVHWFramesContext *dst_ctx, AVHWFramesContext *src_ctx, int flags)
Definition: hwcontext_internal.h:89
hwframe_ctx_class
static const AVClass hwframe_ctx_class
Definition: hwcontext.c:235
hwdevice_ctx_class
static const AVClass hwdevice_ctx_class
Definition: hwcontext.c:150
AV_HWDEVICE_TYPE_VAAPI
@ AV_HWDEVICE_TYPE_VAAPI
Definition: hwcontext.h:31
FFHWDeviceContext
Definition: hwcontext.c:95
ff_hwcontext_type_vulkan
const HWContextType ff_hwcontext_type_vulkan
Definition: hwcontext_vulkan.c:4647
av_hwdevice_ctx_create_derived
int av_hwdevice_ctx_create_derived(AVBufferRef **dst_ref_ptr, enum AVHWDeviceType type, AVBufferRef *src_ref, int flags)
Create a new device of the specified type from an existing device.
Definition: hwcontext.c:718
HWContextType::device_hwctx_size
size_t device_hwctx_size
size of the public hardware-specific context, i.e.
Definition: hwcontext_internal.h:43
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
FFHWDeviceContext::source_device
AVBufferRef * source_device
For a derived device, a reference to the original device context it was derived from.
Definition: hwcontext.c:107
HWContextType::name
const char * name
Definition: hwcontext_internal.h:31
common.h
HWMapDescriptor::unmap
void(* unmap)(AVHWFramesContext *ctx, struct HWMapDescriptor *hwmap)
Unmap function.
Definition: hwcontext_internal.h:134
av_frame_move_ref
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:521
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:494
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_HWDEVICE_TYPE_VDPAU
@ AV_HWDEVICE_TYPE_VDPAU
Definition: hwcontext.h:29
ff_hwframe_map_replace
int ff_hwframe_map_replace(AVFrame *dst, const AVFrame *src)
Replace the current hwmap of dst with the one from src, used for indirect mappings like VAAPI->(DRM)-...
Definition: hwcontext.c:948
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
AVHWFrameTransferDirection
AVHWFrameTransferDirection
Definition: hwcontext.h:406
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:118
ret
ret
Definition: filter_design.txt:187
AVHWDeviceContext::type
enum AVHWDeviceType type
This field identifies the underlying API used for hardware access.
Definition: hwcontext.h:75
pixfmt.h
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:81
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:265
AVHWFramesContext::device_ctx
AVHWDeviceContext * device_ctx
The parent AVHWDeviceContext.
Definition: hwcontext.h:137
av_hwdevice_ctx_create
int av_hwdevice_ctx_create(AVBufferRef **pdevice_ref, enum AVHWDeviceType type, const char *device, AVDictionary *opts, int flags)
Open a device of the specified type and create an AVHWDeviceContext for it.
Definition: hwcontext.c:615
AVFormatContext::av_class
const AVClass * av_class
A class for logging and AVOptions.
Definition: avformat.h:1269
av_hwframe_transfer_data
int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags)
Copy data to or from a hw surface.
Definition: hwcontext.c:448
HWContextType::device_init
int(* device_init)(AVHWDeviceContext *ctx)
Definition: hwcontext_internal.h:63
AV_HWDEVICE_TYPE_QSV
@ AV_HWDEVICE_TYPE_QSV
Definition: hwcontext.h:33
av_frame_replace
int av_frame_replace(AVFrame *dst, const AVFrame *src)
Ensure the destination frame refers to the same data described by the source frame,...
Definition: frame.c:374
AVFrame::height
int height
Definition: frame.h:493
ff_hwcontext_type_d3d12va
const HWContextType ff_hwcontext_type_d3d12va
Definition: hwcontext_d3d12va.c:679
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
ff_hwcontext_type_oh
const HWContextType ff_hwcontext_type_oh
Definition: hwcontext_oh.c:38
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
HWContextType::pix_fmts
enum AVPixelFormat * pix_fmts
An array of pixel formats supported by the AVHWFramesContext instances Terminated by AV_PIX_FMT_NONE.
Definition: hwcontext_internal.h:37
av_hwframe_transfer_get_formats
int av_hwframe_transfer_get_formats(AVBufferRef *hwframe_ref, enum AVHWFrameTransferDirection dir, enum AVPixelFormat **formats, int flags)
Get a list of possible source or target formats usable in av_hwframe_transfer_data().
Definition: hwcontext.c:386
FFHWDeviceContext::p
AVHWDeviceContext p
The public AVHWDeviceContext.
Definition: hwcontext.c:99
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
hwdevice_ctx_get_name
static const char * hwdevice_ctx_get_name(void *ptr)
Definition: hwcontext.c:144
hwcontext_internal.h
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
imgutils.h
AV_HWFRAME_MAP_WRITE
@ AV_HWFRAME_MAP_WRITE
The mapping must be writeable.
Definition: hwcontext.h:519
hwcontext.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
HWContextType::transfer_data_from
int(* transfer_data_from)(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src)
Definition: hwcontext_internal.h:79
HWContextType
Definition: hwcontext_internal.h:29
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:318
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:506
HWMapDescriptor
Definition: hwcontext_internal.h:120
ff_hwcontext_type_opencl
const HWContextType ff_hwcontext_type_opencl
Definition: hwcontext_opencl.c:3039
src
#define src
Definition: vp8dsp.c:248
AV_HWDEVICE_TYPE_DRM
@ AV_HWDEVICE_TYPE_DRM
Definition: hwcontext.h:36
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:3361