chromium/third_party/ffmpeg/libavutil/frame.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 "channel_layout.h"
#include "avassert.h"
#include "buffer.h"
#include "common.h"
#include "cpu.h"
#include "dict.h"
#include "frame.h"
#include "imgutils.h"
#include "mem.h"
#include "samplefmt.h"
#include "hwcontext.h"

static const AVSideDataDescriptor sd_props[] = …;

static void get_frame_defaults(AVFrame *frame)
{ … }

static void free_side_data(AVFrameSideData **ptr_sd)
{ … }

static void wipe_side_data(AVFrameSideData ***sd, int *nb_side_data)
{ … }

static void frame_side_data_wipe(AVFrame *frame)
{ … }

void av_frame_side_data_free(AVFrameSideData ***sd, int *nb_sd)
{ … }

static void remove_side_data(AVFrameSideData ***sd, int *nb_side_data,
                             const enum AVFrameSideDataType type)
{ … }

static void remove_side_data_by_entry(AVFrameSideData ***sd, int *nb_sd,
                                      const AVFrameSideData *target)
{ … }

AVFrame *av_frame_alloc(void)
{ … }

void av_frame_free(AVFrame **frame)
{ … }

static int get_video_buffer(AVFrame *frame, int align)
{ … }

static int get_audio_buffer(AVFrame *frame, int align)
{ … }

int av_frame_get_buffer(AVFrame *frame, int align)
{ … }

static int frame_copy_props(AVFrame *dst, const AVFrame *src, int force_copy)
{ … }

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

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

AVFrame *av_frame_clone(const AVFrame *src)
{ … }

void av_frame_unref(AVFrame *frame)
{ … }

void av_frame_move_ref(AVFrame *dst, AVFrame *src)
{ … }

int av_frame_is_writable(AVFrame *frame)
{ … }

int av_frame_make_writable(AVFrame *frame)
{ … }

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

AVBufferRef *av_frame_get_plane_buffer(const AVFrame *frame, int plane)
{ … }

static AVFrameSideData *add_side_data_from_buf_ext(AVFrameSideData ***sd,
                                                   int *nb_sd,
                                                   enum AVFrameSideDataType type,
                                                   AVBufferRef *buf, uint8_t *data,
                                                   size_t size)
{ … }

static AVFrameSideData *add_side_data_from_buf(AVFrameSideData ***sd,
                                               int *nb_sd,
                                               enum AVFrameSideDataType type,
                                               AVBufferRef *buf)
{ … }

AVFrameSideData *av_frame_new_side_data_from_buf(AVFrame *frame,
                                                 enum AVFrameSideDataType type,
                                                 AVBufferRef *buf)
{ … }

AVFrameSideData *av_frame_new_side_data(AVFrame *frame,
                                        enum AVFrameSideDataType type,
                                        size_t size)
{ … }

static AVFrameSideData *replace_side_data_from_buf(AVFrameSideData *dst,
                                                   AVBufferRef *buf, int flags)
{ … }

AVFrameSideData *av_frame_side_data_new(AVFrameSideData ***sd, int *nb_sd,
                                        enum AVFrameSideDataType type,
                                        size_t size, unsigned int flags)
{ … }

AVFrameSideData *av_frame_side_data_add(AVFrameSideData ***sd, int *nb_sd,
                                        enum AVFrameSideDataType type,
                                        AVBufferRef **pbuf, unsigned int flags)
{ … }

int av_frame_side_data_clone(AVFrameSideData ***sd, int *nb_sd,
                             const AVFrameSideData *src, unsigned int flags)
{ … }

const AVFrameSideData *av_frame_side_data_get_c(const AVFrameSideData * const *sd,
                                                const int nb_sd,
                                                enum AVFrameSideDataType type)
{ … }

void av_frame_side_data_remove(AVFrameSideData ***sd, int *nb_sd,
                               enum AVFrameSideDataType type)
{ … }

AVFrameSideData *av_frame_get_side_data(const AVFrame *frame,
                                        enum AVFrameSideDataType type)
{ … }

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

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

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

void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type)
{ … }

const AVSideDataDescriptor *av_frame_side_data_desc(enum AVFrameSideDataType type)
{ … }

const char *av_frame_side_data_name(enum AVFrameSideDataType type)
{ … }

static int calc_cropping_offsets(size_t offsets[4], const AVFrame *frame,
                                 const AVPixFmtDescriptor *desc)
{ … }

int av_frame_apply_cropping(AVFrame *frame, int flags)
{ … }