chromium/third_party/ffmpeg/libavutil/hwcontext.c

/*
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "config.h"

#include "avassert.h"
#include "buffer.h"
#include "common.h"
#include "hwcontext.h"
#include "hwcontext_internal.h"
#include "imgutils.h"
#include "log.h"
#include "mem.h"
#include "pixdesc.h"
#include "pixfmt.h"

static const HWContextType * const hw_table[] = …;

static const char *const hw_type_names[] = …;

FFHWDeviceContext;

enum AVHWDeviceType av_hwdevice_find_type_by_name(const char *name)
{ … }

const char *av_hwdevice_get_type_name(enum AVHWDeviceType type)
{ … }

enum AVHWDeviceType av_hwdevice_iterate_types(enum AVHWDeviceType prev)
{ … }

static const AVClass hwdevice_ctx_class = …;

static void hwdevice_ctx_free(void *opaque, uint8_t *data)
{ … }

AVBufferRef *av_hwdevice_ctx_alloc(enum AVHWDeviceType type)
{ … }

int av_hwdevice_ctx_init(AVBufferRef *ref)
{ … }

static const AVClass hwframe_ctx_class = …;

static void hwframe_ctx_free(void *opaque, uint8_t *data)
{ … }

AVBufferRef *av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
{ … }

static int hwframe_pool_prealloc(AVBufferRef *ref)
{ … }

int av_hwframe_ctx_init(AVBufferRef *ref)
{ … }

int av_hwframe_transfer_get_formats(AVBufferRef *hwframe_ref,
                                    enum AVHWFrameTransferDirection dir,
                                    enum AVPixelFormat **formats, int flags)
{ … }

static int transfer_data_alloc(AVFrame *dst, const AVFrame *src, int flags)
{ … }

int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags)
{ … }

int av_hwframe_get_buffer(AVBufferRef *hwframe_ref, AVFrame *frame, int flags)
{ … }

void *av_hwdevice_hwconfig_alloc(AVBufferRef *ref)
{ … }

AVHWFramesConstraints *av_hwdevice_get_hwframe_constraints(AVBufferRef *ref,
                                                           const void *hwconfig)
{ … }

void av_hwframe_constraints_free(AVHWFramesConstraints **constraints)
{ … }

int av_hwdevice_ctx_create(AVBufferRef **pdevice_ref, enum AVHWDeviceType type,
                           const char *device, AVDictionary *opts, int flags)
{ … }

int av_hwdevice_ctx_create_derived_opts(AVBufferRef **dst_ref_ptr,
                                        enum AVHWDeviceType type,
                                        AVBufferRef *src_ref,
                                        AVDictionary *options, int flags)
{ … }

int av_hwdevice_ctx_create_derived(AVBufferRef **dst_ref_ptr,
                                   enum AVHWDeviceType type,
                                   AVBufferRef *src_ref, int flags)
{ … }

static void ff_hwframe_unmap(void *opaque, uint8_t *data)
{ … }

int ff_hwframe_map_create(AVBufferRef *hwframe_ref,
                          AVFrame *dst, const AVFrame *src,
                          void (*unmap)(AVHWFramesContext *ctx,
                                        HWMapDescriptor *hwmap),
                          void *priv)
{ … }

int av_hwframe_map(AVFrame *dst, const AVFrame *src, int flags)
{ … }

int av_hwframe_ctx_create_derived(AVBufferRef **derived_frame_ctx,
                                  enum AVPixelFormat format,
                                  AVBufferRef *derived_device_ctx,
                                  AVBufferRef *source_frame_ctx,
                                  int flags)
{ … }

int ff_hwframe_map_replace(AVFrame *dst, const AVFrame *src)
{ … }