FFmpeg: libavutil/hwcontext.c Source File

FFmpeg
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 "buffer.h"
22 #include "common.h"
23 #include "hwcontext.h"
24 #include "hwcontext_internal.h"
25 #include "imgutils.h"
26 #include "log.h"
27 #include "mem.h"
28 #include "pixdesc.h"
29 #include "pixfmt.h"
30 
31  static const HWContextType *hw_table[] = {
32 #if CONFIG_CUDA
33  &ff_hwcontext_type_cuda,
34 #endif
35 #if CONFIG_DXVA2
36  &ff_hwcontext_type_dxva2,
37 #endif
38 #if CONFIG_QSV
39  &ff_hwcontext_type_qsv,
40 #endif
41 #if CONFIG_VAAPI
42  &ff_hwcontext_type_vaapi,
43 #endif
44 #if CONFIG_VDPAU
45  &ff_hwcontext_type_vdpau,
46 #endif
47  NULL,
48 };
49 
50  static const AVClass hwdevice_ctx_class = {
51  .class_name = "AVHWDeviceContext",
52  .item_name = av_default_item_name,
53  .version = LIBAVUTIL_VERSION_INT,
54 };
55 
56  static void hwdevice_ctx_free(void *opaque, uint8_t *data)
57 {
58  AVHWDeviceContext *ctx = (AVHWDeviceContext*)data;
59 
60  /* uninit might still want access the hw context and the user
61  * free() callback might destroy it, so uninit has to be called first */
62  if (ctx->internal->hw_type->device_uninit)
63  ctx->internal->hw_type->device_uninit(ctx);
64 
65  if (ctx->free)
66  ctx->free(ctx);
67 
68  av_freep(&ctx->hwctx);
69  av_freep(&ctx->internal->priv);
70  av_freep(&ctx->internal);
71  av_freep(&ctx);
72 }
73 
74  AVBufferRef *av_hwdevice_ctx_alloc(enum AVHWDeviceType type)
75 {
76  AVHWDeviceContext *ctx;
77  AVBufferRef *buf;
78  const HWContextType *hw_type = NULL;
79  int i;
80 
81  for (i = 0; hw_table[i]; i++) {
82  if (hw_table[i]->type == type) {
83  hw_type = hw_table[i];
84  break;
85  }
86  }
87  if (!hw_type)
88  return NULL;
89 
90  ctx = av_mallocz(sizeof(*ctx));
91  if (!ctx)
92  return NULL;
93 
94  ctx->internal = av_mallocz(sizeof(*ctx->internal));
95  if (!ctx->internal)
96  goto fail;
97 
98  if (hw_type->device_priv_size) {
99  ctx->internal->priv = av_mallocz(hw_type->device_priv_size);
100  if (!ctx->internal->priv)
101  goto fail;
102  }
103 
104  if (hw_type->device_hwctx_size) {
105  ctx->hwctx = av_mallocz(hw_type->device_hwctx_size);
106  if (!ctx->hwctx)
107  goto fail;
108  }
109 
110  buf = av_buffer_create((uint8_t*)ctx, sizeof(*ctx),
111  hwdevice_ctx_free, NULL,
112  AV_BUFFER_FLAG_READONLY);
113  if (!buf)
114  goto fail;
115 
116  ctx->type = type;
117  ctx->av_class = &hwdevice_ctx_class;
118 
119  ctx->internal->hw_type = hw_type;
120 
121  return buf;
122 
123 fail:
124  if (ctx->internal)
125  av_freep(&ctx->internal->priv);
126  av_freep(&ctx->internal);
127  av_freep(&ctx->hwctx);
128  av_freep(&ctx);
129  return NULL;
130 }
131 
132  int av_hwdevice_ctx_init(AVBufferRef *ref)
133 {
134  AVHWDeviceContext *ctx = (AVHWDeviceContext*)ref->data;
135  int ret;
136 
137  if (ctx->internal->hw_type->device_init) {
138  ret = ctx->internal->hw_type->device_init(ctx);
139  if (ret < 0)
140  goto fail;
141  }
142 
143  return 0;
144 fail:
145  if (ctx->internal->hw_type->device_uninit)
146  ctx->internal->hw_type->device_uninit(ctx);
147  return ret;
148 }
149 
150  static const AVClass hwframe_ctx_class = {
151  .class_name = "AVHWFramesContext",
152  .item_name = av_default_item_name,
153  .version = LIBAVUTIL_VERSION_INT,
154 };
155 
156  static void hwframe_ctx_free(void *opaque, uint8_t *data)
157 {
158  AVHWFramesContext *ctx = (AVHWFramesContext*)data;
159 
160  if (ctx->internal->pool_internal)
161  av_buffer_pool_uninit(&ctx->internal->pool_internal);
162 
163  if (ctx->internal->hw_type->frames_uninit)
164  ctx->internal->hw_type->frames_uninit(ctx);
165 
166  if (ctx->free)
167  ctx->free(ctx);
168 
169  av_buffer_unref(&ctx->device_ref);
170 
171  av_freep(&ctx->hwctx);
172  av_freep(&ctx->internal->priv);
173  av_freep(&ctx->internal);
174  av_freep(&ctx);
175 }
176 
177  AVBufferRef *av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
178 {
179  AVHWDeviceContext *device_ctx = (AVHWDeviceContext*)device_ref_in->data;
180  const HWContextType *hw_type = device_ctx->internal->hw_type;
181  AVHWFramesContext *ctx;
182  AVBufferRef *buf, *device_ref = NULL;
183 
184  ctx = av_mallocz(sizeof(*ctx));
185  if (!ctx)
186  return NULL;
187 
188  ctx->internal = av_mallocz(sizeof(*ctx->internal));
189  if (!ctx->internal)
190  goto fail;
191 
192  if (hw_type->frames_priv_size) {
193  ctx->internal->priv = av_mallocz(hw_type->frames_priv_size);
194  if (!ctx->internal->priv)
195  goto fail;
196  }
197 
198  if (hw_type->frames_hwctx_size) {
199  ctx->hwctx = av_mallocz(hw_type->frames_hwctx_size);
200  if (!ctx->hwctx)
201  goto fail;
202  }
203 
204  device_ref = av_buffer_ref(device_ref_in);
205  if (!device_ref)
206  goto fail;
207 
208  buf = av_buffer_create((uint8_t*)ctx, sizeof(*ctx),
209  hwframe_ctx_free, NULL,
210  AV_BUFFER_FLAG_READONLY);
211  if (!buf)
212  goto fail;
213 
214  ctx->av_class = &hwframe_ctx_class;
215  ctx->device_ref = device_ref;
216  ctx->device_ctx = device_ctx;
217  ctx->format = AV_PIX_FMT_NONE;
218  ctx->sw_format = AV_PIX_FMT_NONE;
219 
220  ctx->internal->hw_type = hw_type;
221 
222  return buf;
223 
224 fail:
225  if (device_ref)
226  av_buffer_unref(&device_ref);
227  if (ctx->internal)
228  av_freep(&ctx->internal->priv);
229  av_freep(&ctx->internal);
230  av_freep(&ctx->hwctx);
231  av_freep(&ctx);
232  return NULL;
233 }
234 
235  static int hwframe_pool_prealloc(AVBufferRef *ref)
236 {
237  AVHWFramesContext *ctx = (AVHWFramesContext*)ref->data;
238  AVFrame **frames;
239  int i, ret = 0;
240 
241  frames = av_mallocz_array(ctx->initial_pool_size, sizeof(*frames));
242  if (!frames)
243  return AVERROR(ENOMEM);
244 
245  for (i = 0; i < ctx->initial_pool_size; i++) {
246  frames[i] = av_frame_alloc();
247  if (!frames[i])
248  goto fail;
249 
250  ret = av_hwframe_get_buffer(ref, frames[i], 0);
251  if (ret < 0)
252  goto fail;
253  }
254 
255 fail:
256  for (i = 0; i < ctx->initial_pool_size; i++)
257  av_frame_free(&frames[i]);
258  av_freep(&frames);
259 
260  return ret;
261 }
262 
263  int av_hwframe_ctx_init(AVBufferRef *ref)
264 {
265  AVHWFramesContext *ctx = (AVHWFramesContext*)ref->data;
266  const enum AVPixelFormat *pix_fmt;
267  int ret;
268 
269  /* validate the pixel format */
270  for (pix_fmt = ctx->internal->hw_type->pix_fmts; *pix_fmt != AV_PIX_FMT_NONE; pix_fmt++) {
271  if (*pix_fmt == ctx->format)
272  break;
273  }
274  if (*pix_fmt == AV_PIX_FMT_NONE) {
275  av_log(ctx, AV_LOG_ERROR,
276  "The hardware pixel format '%s' is not supported by the device type '%s'\n",
277  av_get_pix_fmt_name(ctx->format), ctx->internal->hw_type->name);
278  return AVERROR(ENOSYS);
279  }
280 
281  /* validate the dimensions */
282  ret = av_image_check_size(ctx->width, ctx->height, 0, ctx);
283  if (ret < 0)
284  return ret;
285 
286  /* format-specific init */
287  if (ctx->internal->hw_type->frames_init) {
288  ret = ctx->internal->hw_type->frames_init(ctx);
289  if (ret < 0)
290  goto fail;
291  }
292 
293  if (ctx->internal->pool_internal && !ctx->pool)
294  ctx->pool = ctx->internal->pool_internal;
295 
296  /* preallocate the frames in the pool, if requested */
297  if (ctx->initial_pool_size > 0) {
298  ret = hwframe_pool_prealloc(ref);
299  if (ret < 0)
300  goto fail;
301  }
302 
303  return 0;
304 fail:
305  if (ctx->internal->hw_type->frames_uninit)
306  ctx->internal->hw_type->frames_uninit(ctx);
307  return ret;
308 }
309 
310  int av_hwframe_transfer_get_formats(AVBufferRef *hwframe_ref,
311  enum AVHWFrameTransferDirection dir,
312  enum AVPixelFormat **formats, int flags)
313 {
314  AVHWFramesContext *ctx = (AVHWFramesContext*)hwframe_ref->data;
315 
316  if (!ctx->internal->hw_type->transfer_get_formats)
317  return AVERROR(ENOSYS);
318 
319  return ctx->internal->hw_type->transfer_get_formats(ctx, dir, formats);
320 }
321 
322  static int transfer_data_alloc(AVFrame *dst, const AVFrame *src, int flags)
323 {
324  AVFrame *frame_tmp;
325  int ret = 0;
326 
327  frame_tmp = av_frame_alloc();
328  if (!frame_tmp)
329  return AVERROR(ENOMEM);
330 
331  /* if the format is set, use that
332  * otherwise pick the first supported one */
333  if (dst->format >= 0) {
334  frame_tmp->format = dst->format;
335  } else {
336  enum AVPixelFormat *formats;
337 
338  ret = av_hwframe_transfer_get_formats(src->hw_frames_ctx,
339  AV_HWFRAME_TRANSFER_DIRECTION_FROM,
340  &formats, 0);
341  if (ret < 0)
342  goto fail;
343  frame_tmp->format = formats[0];
344  av_freep(&formats);
345  }
346  frame_tmp->width = src->width;
347  frame_tmp->height = src->height;
348 
349  ret = av_frame_get_buffer(frame_tmp, 32);
350  if (ret < 0)
351  goto fail;
352 
353  ret = av_hwframe_transfer_data(frame_tmp, src, flags);
354  if (ret < 0)
355  goto fail;
356 
357  av_frame_move_ref(dst, frame_tmp);
358 
359 fail:
360  av_frame_free(&frame_tmp);
361  return ret;
362 }
363 
364  int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags)
365 {
366  AVHWFramesContext *ctx;
367  int ret;
368 
369  if (!dst->buf[0])
370  return transfer_data_alloc(dst, src, flags);
371 
372  if (src->hw_frames_ctx) {
373  ctx = (AVHWFramesContext*)src->hw_frames_ctx->data;
374 
375  ret = ctx->internal->hw_type->transfer_data_from(ctx, dst, src);
376  if (ret < 0)
377  return ret;
378  } else if (dst->hw_frames_ctx) {
379  ctx = (AVHWFramesContext*)dst->hw_frames_ctx->data;
380 
381  ret = ctx->internal->hw_type->transfer_data_to(ctx, dst, src);
382  if (ret < 0)
383  return ret;
384  } else
385  return AVERROR(ENOSYS);
386 
387  return 0;
388 }
389 
390  int av_hwframe_get_buffer(AVBufferRef *hwframe_ref, AVFrame *frame, int flags)
391 {
392  AVHWFramesContext *ctx = (AVHWFramesContext*)hwframe_ref->data;
393  int ret;
394 
395  if (!ctx->internal->hw_type->frames_get_buffer)
396  return AVERROR(ENOSYS);
397 
398  if (!ctx->pool)
399  return AVERROR(EINVAL);
400 
401  frame->hw_frames_ctx = av_buffer_ref(hwframe_ref);
402  if (!frame->hw_frames_ctx)
403  return AVERROR(ENOMEM);
404 
405  ret = ctx->internal->hw_type->frames_get_buffer(ctx, frame);
406  if (ret < 0) {
407  av_buffer_unref(&frame->hw_frames_ctx);
408  return ret;
409  }
410 
411  return 0;
412 }
413 
414  void *av_hwdevice_hwconfig_alloc(AVBufferRef *ref)
415 {
416  AVHWDeviceContext *ctx = (AVHWDeviceContext*)ref->data;
417  const HWContextType *hw_type = ctx->internal->hw_type;
418 
419  if (hw_type->device_hwconfig_size == 0)
420  return NULL;
421 
422  return av_mallocz(hw_type->device_hwconfig_size);
423 }
424 
425  AVHWFramesConstraints *av_hwdevice_get_hwframe_constraints(AVBufferRef *ref,
426  const void *hwconfig)
427 {
428  AVHWDeviceContext *ctx = (AVHWDeviceContext*)ref->data;
429  const HWContextType *hw_type = ctx->internal->hw_type;
430  AVHWFramesConstraints *constraints;
431 
432  if (!hw_type->frames_get_constraints)
433  return NULL;
434 
435  constraints = av_mallocz(sizeof(*constraints));
436  if (!constraints)
437  return NULL;
438 
439  constraints->min_width = constraints->min_height = 0;
440  constraints->max_width = constraints->max_height = INT_MAX;
441 
442  if (hw_type->frames_get_constraints(ctx, hwconfig, constraints) >= 0) {
443  return constraints;
444  } else {
445  av_hwframe_constraints_free(&constraints);
446  return NULL;
447  }
448 }
449 
450  void av_hwframe_constraints_free(AVHWFramesConstraints **constraints)
451 {
452  if (*constraints) {
453  av_freep(&(*constraints)->valid_hw_formats);
454  av_freep(&(*constraints)->valid_sw_formats);
455  }
456  av_freep(constraints);
457 }
458 
459  int av_hwdevice_ctx_create(AVBufferRef **pdevice_ref, enum AVHWDeviceType type,
460  const char *device, AVDictionary *opts, int flags)
461 {
462  AVBufferRef *device_ref = NULL;
463  AVHWDeviceContext *device_ctx;
464  int ret = 0;
465 
466  device_ref = av_hwdevice_ctx_alloc(type);
467  if (!device_ref) {
468  ret = AVERROR(ENOMEM);
469  goto fail;
470  }
471  device_ctx = (AVHWDeviceContext*)device_ref->data;
472 
473  if (!device_ctx->internal->hw_type->device_create) {
474  ret = AVERROR(ENOSYS);
475  goto fail;
476  }
477 
478  ret = device_ctx->internal->hw_type->device_create(device_ctx, device,
479  opts, flags);
480  if (ret < 0)
481  goto fail;
482 
483  ret = av_hwdevice_ctx_init(device_ref);
484  if (ret < 0)
485  goto fail;
486 
487  *pdevice_ref = device_ref;
488  return 0;
489 fail:
490  av_buffer_unref(&device_ref);
491  *pdevice_ref = NULL;
492  return ret;
493 }
hwcontext_internal.h
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:54
NULL
#define NULL
Definition: coverity.c:32
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:40
hwdevice_ctx_free
static void hwdevice_ctx_free(void *opaque, uint8_t *data)
Definition: hwcontext.c:56
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:124
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:184
data
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
imgutils.h
misc image utilities
HWContextType::frames_uninit
void(* frames_uninit)(AVHWFramesContext *ctx)
Definition: hwcontext_internal.h:78
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
mem.h
Memory handling functions.
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:367
ff_hwcontext_type_vdpau
const HWContextType ff_hwcontext_type_vdpau
Definition: hwcontext_vdpau.c:470
AVFormatContext::internal
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1767
formats
static enum AVSampleFormat formats[]
Definition: avresample.c:163
AVHWFramesContext::width
int width
The allocated dimensions of the frames in this pool.
Definition: hwcontext.h:222
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:414
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:202
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:517
HWContextType::device_priv_size
size_t device_priv_size
size of the private data, i.e.
Definition: hwcontext_internal.h:48
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:252
AVHWFramesInternal::hw_type
const HWContextType * hw_type
Definition: hwcontext_internal.h:96
av_hwframe_constraints_free
void av_hwframe_constraints_free(AVHWFramesConstraints **constraints)
Free an AVHWFrameConstraints structure.
Definition: hwcontext.c:450
AVFrame::hw_frames_ctx
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame...
Definition: frame.h:534
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:72
AVHWFramesInternal::pool_internal
AVBufferPool * pool_internal
Definition: hwcontext_internal.h:99
uint8_t
uint8_t
Definition: audio_convert.c:194
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:145
hwframe_pool_prealloc
static int hwframe_pool_prealloc(AVBufferRef *ref)
Definition: hwcontext.c:235
HWContextType::device_hwctx_size
size_t device_hwctx_size
size of the public hardware-specific context, i.e.
Definition: hwcontext_internal.h:43
frame
static AVFrame * frame
Definition: demuxing_decoding.c:53
AVHWDeviceContext::hwctx
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
Definition: hwcontext.h:85
ff_hwcontext_type_qsv
const HWContextType ff_hwcontext_type_qsv
Definition: hwcontext_qsv.c:771
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:459
hwframe_ctx_free
static void hwframe_ctx_free(void *opaque, uint8_t *data)
Definition: hwcontext.c:156
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:113
hwframe_ctx_class
static const AVClass hwframe_ctx_class
Definition: hwcontext.c:150
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVHWFramesContext::free
void(* free)(struct AVHWFramesContext *ctx)
This field may be set by the caller before calling av_hwframe_ctx_init().
Definition: hwcontext.h:163
AVDictionary
Definition: dict.c:30
AVFrame::width
int width
width and height of the video frame
Definition: frame.h:236
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVHWDeviceContext::free
void(* free)(struct AVHWDeviceContext *ctx)
This field may be set by the caller before calling av_hwdevice_ctx_init().
Definition: hwcontext.h:97
av_default_item_name
av_default_item_name
Definition: libopenh264enc.c:78
AVERROR
#define AVERROR(e)
Definition: error.h:43
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:158
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:28
av_hwframe_ctx_init
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:263
AVHWDeviceContext::type
enum AVHWDeviceType type
This field identifies the underlying API used for hardware access.
Definition: hwcontext.h:72
av_mallocz_array
static void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.h:226
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:390
fail
#define fail()
Definition: checkasm.h:83
HWContextType::device_uninit
void(* device_uninit)(AVHWDeviceContext *ctx)
Definition: hwcontext_internal.h:71
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:364
AVHWFramesContext::initial_pool_size
int initial_pool_size
Initial size of the frame pool.
Definition: hwcontext.h:192
opts
AVDictionary * opts
Definition: movenc.c:50
AV_HWFRAME_TRANSFER_DIRECTION_FROM
Transfer the data from the queried hw frame.
Definition: hwcontext.h:332
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:251
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
HWContextType::name
const char * name
Definition: hwcontext_internal.h:31
ctx
AVFormatContext * ctx
Definition: movenc.c:48
frames
int frames
Definition: movenc.c:65
src
#define src
Definition: vp9dsp.c:530
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:248
av_hwdevice_ctx_alloc
AVBufferRef * av_hwdevice_ctx_alloc(enum AVHWDeviceType type)
Allocate an AVHWDeviceContext for a given pixel format.
Definition: hwcontext.c:74
AVHWFramesConstraints
This struct describes the constraints on hardware frames attached to a given device with a hardware-s...
Definition: hwcontext.h:366
HWContextType::device_create
int(* device_create)(AVHWDeviceContext *ctx, const char *device, AVDictionary *opts, int flags)
Definition: hwcontext_internal.h:67
ff_hwcontext_type_cuda
const HWContextType ff_hwcontext_type_cuda
Definition: hwcontext_cuda.c:304
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:425
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:89
AVHWFramesContext::hwctx
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
Definition: hwcontext.h:155
AVHWDeviceContext::av_class
const AVClass * av_class
A class for logging.
Definition: hwcontext.h:58
buf
void * buf
Definition: avisynth_c.h:690
type
GLint GLenum type
Definition: opengl_enc.c:105
av_hwdevice_ctx_init
int av_hwdevice_ctx_init(AVBufferRef *ref)
Finalize the device context before use.
Definition: hwcontext.c:132
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
av_buffer_pool_uninit
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:274
HWContextType::frames_get_buffer
int(* frames_get_buffer)(AVHWFramesContext *ctx, AVFrame *frame)
Definition: hwcontext_internal.h:80
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:117
AVFormatContext::av_class
const AVClass * av_class
A class for logging and AVOptions.
Definition: avformat.h:1343
buffer.h
refcounted data buffer API
hw_table
static const HWContextType * hw_table[]
Definition: hwcontext.c:31
transfer_data_alloc
static int transfer_data_alloc(AVFrame *dst, const AVFrame *src, int flags)
Definition: hwcontext.c:322
AVHWFramesContext::internal
AVHWFramesInternal * internal
Private data used internally by libavutil.
Definition: hwcontext.h:127
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:275
HWContextType::transfer_data_from
int(* transfer_data_from)(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src)
Definition: hwcontext_internal.h:86
flags
static int flags
Definition: cpu.c:47
AVHWFramesContext::device_ref
AVBufferRef * device_ref
A reference to the parent AVHWDeviceContext.
Definition: hwcontext.h:134
HWContextType::transfer_data_to
int(* transfer_data_to)(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src)
Definition: hwcontext_internal.h:84
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:81
AVHWDeviceInternal::hw_type
const HWContextType * hw_type
Definition: hwcontext_internal.h:91
common.h
common internal and external API header
if
if(ret< 0)
Definition: vf_mcdeint.c:282
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
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:177
av_buffer_ref
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:92
AVHWFrameTransferDirection
AVHWFrameTransferDirection
Definition: hwcontext.h:328
pixfmt.h
pixel format definitions
AVHWFramesContext::pool
AVBufferPool * pool
A pool from which the frames are allocated by av_hwframe_get_buffer().
Definition: hwcontext.h:183
AVHWDeviceType
AVHWDeviceType
Definition: hwcontext.h:27
HWContextType::transfer_get_formats
int(* transfer_get_formats)(AVHWFramesContext *ctx, enum AVHWFrameTransferDirection dir, enum AVPixelFormat **formats)
Definition: hwcontext_internal.h:81
AVFrame::height
int height
Definition: frame.h:236
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
HWContextType::device_init
int(* device_init)(AVHWDeviceContext *ctx)
Definition: hwcontext_internal.h:70
AVHWDeviceContext::internal
AVHWDeviceInternal * internal
Private data used internally by libavutil.
Definition: hwcontext.h:64
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:2182
hwdevice_ctx_class
static const AVClass hwdevice_ctx_class
Definition: hwcontext.c:50
HWContextType::frames_init
int(* frames_init)(AVHWFramesContext *ctx)
Definition: hwcontext_internal.h:77
ff_hwcontext_type_dxva2
const HWContextType ff_hwcontext_type_dxva2
Definition: hwcontext_dxva2.c:422
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
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:310
ff_hwcontext_type_vaapi
const HWContextType ff_hwcontext_type_vaapi
Definition: hwcontext_vaapi.c:918
Generated on Thu Oct 27 2016 19:33:42 for FFmpeg by   doxygen 1.8.6

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