mirror of
https://github.com/LizardByte/Sunshine.git
synced 2024-11-18 02:09:49 +00:00
221 lines
8.0 KiB
C
221 lines
8.0 KiB
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
|
|
*/
|
|
|
|
#ifndef AVCODEC_CBS_INTERNAL_H
|
|
#define AVCODEC_CBS_INTERNAL_H
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <libavutil/buffer.h>
|
|
#include <libavutil/log.h>
|
|
|
|
#include "cbs/cbs.h"
|
|
#include "get_bits.h"
|
|
#include "put_bits.h"
|
|
|
|
|
|
enum CBSContentType {
|
|
// Unit content is a simple structure.
|
|
CBS_CONTENT_TYPE_POD,
|
|
// Unit content contains some references to other structures, but all
|
|
// managed via buffer reference counting. The descriptor defines the
|
|
// structure offsets of every buffer reference.
|
|
CBS_CONTENT_TYPE_INTERNAL_REFS,
|
|
// Unit content is something more complex. The descriptor defines
|
|
// special functions to manage the content.
|
|
CBS_CONTENT_TYPE_COMPLEX,
|
|
};
|
|
|
|
enum {
|
|
// Maximum number of unit types described by the same unit type
|
|
// descriptor.
|
|
CBS_MAX_UNIT_TYPES = 3,
|
|
// Maximum number of reference buffer offsets in any one unit.
|
|
CBS_MAX_REF_OFFSETS = 2,
|
|
// Special value used in a unit type descriptor to indicate that it
|
|
// applies to a large range of types rather than a set of discrete
|
|
// values.
|
|
CBS_UNIT_TYPE_RANGE = -1,
|
|
};
|
|
|
|
typedef const struct CodedBitstreamUnitTypeDescriptor {
|
|
// Number of entries in the unit_types array, or the special value
|
|
// CBS_UNIT_TYPE_RANGE to indicate that the range fields should be
|
|
// used instead.
|
|
int nb_unit_types;
|
|
|
|
// Array of unit types that this entry describes.
|
|
const CodedBitstreamUnitType unit_types[CBS_MAX_UNIT_TYPES];
|
|
|
|
// Start and end of unit type range, used if nb_unit_types is
|
|
// CBS_UNIT_TYPE_RANGE.
|
|
const CodedBitstreamUnitType unit_type_range_start;
|
|
const CodedBitstreamUnitType unit_type_range_end;
|
|
|
|
// The type of content described.
|
|
enum CBSContentType content_type;
|
|
// The size of the structure which should be allocated to contain
|
|
// the decomposed content of this type of unit.
|
|
size_t content_size;
|
|
|
|
// Number of entries in the ref_offsets array. Only used if the
|
|
// content_type is CBS_CONTENT_TYPE_INTERNAL_REFS.
|
|
int nb_ref_offsets;
|
|
// The structure must contain two adjacent elements:
|
|
// type *field;
|
|
// AVBufferRef *field_ref;
|
|
// where field points to something in the buffer referred to by
|
|
// field_ref. This offset is then set to offsetof(struct, field).
|
|
size_t ref_offsets[CBS_MAX_REF_OFFSETS];
|
|
|
|
void (*content_free)(void *opaque, uint8_t *data);
|
|
int (*content_clone)(AVBufferRef **ref, CodedBitstreamUnit *unit);
|
|
} CodedBitstreamUnitTypeDescriptor;
|
|
|
|
typedef struct CodedBitstreamType {
|
|
enum AVCodecID codec_id;
|
|
|
|
// A class for the private data, used to declare private AVOptions.
|
|
// This field is NULL for types that do not declare any options.
|
|
// If this field is non-NULL, the first member of the filter private data
|
|
// must be a pointer to AVClass.
|
|
const AVClass *priv_class;
|
|
|
|
size_t priv_data_size;
|
|
|
|
// List of unit type descriptors for this codec.
|
|
// Terminated by a descriptor with nb_unit_types equal to zero.
|
|
const CodedBitstreamUnitTypeDescriptor *unit_types;
|
|
|
|
// Split frag->data into coded bitstream units, creating the
|
|
// frag->units array. Fill data but not content on each unit.
|
|
// The header argument should be set if the fragment came from
|
|
// a header block, which may require different parsing for some
|
|
// codecs (e.g. the AVCC header in H.264).
|
|
int (*split_fragment)(CodedBitstreamContext *ctx,
|
|
CodedBitstreamFragment *frag,
|
|
int header);
|
|
|
|
// Read the unit->data bitstream and decompose it, creating
|
|
// unit->content.
|
|
int (*read_unit)(CodedBitstreamContext *ctx,
|
|
CodedBitstreamUnit *unit);
|
|
|
|
// Write the data bitstream from unit->content into pbc.
|
|
// Return value AVERROR(ENOSPC) indicates that pbc was too small.
|
|
int (*write_unit)(CodedBitstreamContext *ctx,
|
|
CodedBitstreamUnit *unit,
|
|
PutBitContext *pbc);
|
|
|
|
// Read the data from all of frag->units and assemble it into
|
|
// a bitstream for the whole fragment.
|
|
int (*assemble_fragment)(CodedBitstreamContext *ctx,
|
|
CodedBitstreamFragment *frag);
|
|
|
|
// Reset the codec internal state.
|
|
void (*flush)(CodedBitstreamContext *ctx);
|
|
|
|
// Free the codec internal state.
|
|
void (*close)(CodedBitstreamContext *ctx);
|
|
} CodedBitstreamType;
|
|
|
|
|
|
// Helper functions for trace output.
|
|
|
|
void ff_cbs_trace_header(CodedBitstreamContext *ctx,
|
|
const char *name);
|
|
|
|
void ff_cbs_trace_syntax_element(CodedBitstreamContext *ctx, int position,
|
|
const char *name, const int *subscripts,
|
|
const char *bitstring, int64_t value);
|
|
|
|
|
|
// Helper functions for read/write of common bitstream elements, including
|
|
// generation of trace output.
|
|
|
|
int ff_cbs_read_unsigned(CodedBitstreamContext *ctx, GetBitContext *gbc,
|
|
int width, const char *name,
|
|
const int *subscripts, uint32_t *write_to,
|
|
uint32_t range_min, uint32_t range_max);
|
|
|
|
int ff_cbs_write_unsigned(CodedBitstreamContext *ctx, PutBitContext *pbc,
|
|
int width, const char *name,
|
|
const int *subscripts, uint32_t value,
|
|
uint32_t range_min, uint32_t range_max);
|
|
|
|
int ff_cbs_read_signed(CodedBitstreamContext *ctx, GetBitContext *gbc,
|
|
int width, const char *name,
|
|
const int *subscripts, int32_t *write_to,
|
|
int32_t range_min, int32_t range_max);
|
|
|
|
int ff_cbs_write_signed(CodedBitstreamContext *ctx, PutBitContext *pbc,
|
|
int width, const char *name,
|
|
const int *subscripts, int32_t value,
|
|
int32_t range_min, int32_t range_max);
|
|
|
|
// The largest unsigned value representable in N bits, suitable for use as
|
|
// range_max in the above functions.
|
|
#define MAX_UINT_BITS(length) ((UINT64_C(1) << (length)) - 1)
|
|
|
|
// The largest signed value representable in N bits, suitable for use as
|
|
// range_max in the above functions.
|
|
#define MAX_INT_BITS(length) ((INT64_C(1) << ((length)-1)) - 1)
|
|
|
|
// The smallest signed value representable in N bits, suitable for use as
|
|
// range_min in the above functions.
|
|
#define MIN_INT_BITS(length) (-(INT64_C(1) << ((length)-1)))
|
|
|
|
|
|
#define CBS_UNIT_TYPE_POD(type, structure) \
|
|
{ \
|
|
.nb_unit_types = 1, \
|
|
.unit_types = { type }, \
|
|
.content_type = CBS_CONTENT_TYPE_POD, \
|
|
.content_size = sizeof(structure), \
|
|
}
|
|
#define CBS_UNIT_TYPE_INTERNAL_REF(type, structure, ref_field) \
|
|
{ \
|
|
.nb_unit_types = 1, \
|
|
.unit_types = { type }, \
|
|
.content_type = CBS_CONTENT_TYPE_INTERNAL_REFS, \
|
|
.content_size = sizeof(structure), \
|
|
.nb_ref_offsets = 1, \
|
|
.ref_offsets = { offsetof(structure, ref_field) }, \
|
|
}
|
|
#define CBS_UNIT_TYPE_COMPLEX(type, structure, free_func) \
|
|
{ \
|
|
.nb_unit_types = 1, \
|
|
.unit_types = { type }, \
|
|
.content_type = CBS_CONTENT_TYPE_COMPLEX, \
|
|
.content_size = sizeof(structure), \
|
|
.content_free = free_func, \
|
|
}
|
|
#define CBS_UNIT_TYPE_END_OF_LIST \
|
|
{ .nb_unit_types = 0 }
|
|
|
|
|
|
extern const CodedBitstreamType ff_cbs_type_av1;
|
|
extern const CodedBitstreamType ff_cbs_type_h264;
|
|
extern const CodedBitstreamType ff_cbs_type_h265;
|
|
extern const CodedBitstreamType ff_cbs_type_jpeg;
|
|
extern const CodedBitstreamType ff_cbs_type_mpeg2;
|
|
extern const CodedBitstreamType ff_cbs_type_vp9;
|
|
|
|
|
|
#endif /* AVCODEC_CBS_INTERNAL_H */
|