35 const char *
name,
const int *subscripts,
37 uint32_t range_min, uint32_t range_max)
46 for (i = 0; i < 32; i++) {
49 "%s: bitstream ended.\n", name);
53 bits[
i] = k ?
'1' :
'0';
59 "%s: more than 31 zeroes.\n", name);
63 for (j = 0; j <
i; j++) {
65 bits[i + j + 1] = k ?
'1' :
'0';
66 value = value << 1 | k;
75 if (value < range_min || value > range_max) {
77 "%"PRIu32
", but must be in [%"PRIu32
",%"PRIu32
"].\n",
78 name, value, range_min, range_max);
87 const char *
name,
const int *subscripts,
99 for (i = 0; i < 32; i++) {
102 "%s: bitstream ended.\n", name);
106 bits[
i] = k ?
'1' :
'0';
112 "%s: more than 31 zeroes.\n", name);
116 for (j = 0; j <
i; j++) {
118 bits[i + j + 1] = k ?
'1' :
'0';
131 if (value < range_min || value > range_max) {
133 "%"PRId32
", but must be in [%"PRId32
",%"PRId32
"].\n",
134 name, value, range_min, range_max);
143 const char *
name,
const int *subscripts,
145 uint32_t range_min, uint32_t range_max)
149 if (value < range_min || value > range_max) {
151 "%"PRIu32
", but must be in [%"PRIu32
",%"PRIu32
"].\n",
152 name, value, range_min, range_max);
165 for (i = 0; i <
len; i++)
168 for (i = 0; i <
len; i++)
169 bits[len + i + 1] = (value + 1) >> (len - i - 1) & 1 ?
'1' :
'0';
170 bits[len + len + 1] = 0;
173 name, subscripts, bits, value);
186 const char *
name,
const int *subscripts,
193 if (value < range_min || value > range_max) {
195 "%"PRId32
", but must be in [%"PRId32
",%"PRId32
"].\n",
196 name, value, range_min, range_max);
204 uvalue = 2 * (uint32_t)value - 1;
206 uvalue = 2 * (uint32_t)-value;
216 for (i = 0; i <
len; i++)
219 for (i = 0; i <
len; i++)
220 bits[len + i + 1] = (uvalue + 1) >> (len - i - 1) & 1 ?
'1' :
'0';
221 bits[len + len + 1] = 0;
224 name, subscripts, bits, value);
236 #define HEADER(name) do { \ 237 ff_cbs_trace_header(ctx, name); \ 240 #define CHECK(call) do { \ 246 #define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name 247 #define FUNC_H264(rw, name) FUNC_NAME(rw, h264, name) 248 #define FUNC_H265(rw, name) FUNC_NAME(rw, h265, name) 250 #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL) 252 #define u(width, name, range_min, range_max) \ 253 xu(width, name, current->name, range_min, range_max, 0) 254 #define ub(width, name) \ 255 xu(width, name, current->name, 0, MAX_UINT_BITS(width), 0) 256 #define flag(name) ub(1, name) 257 #define ue(name, range_min, range_max) \ 258 xue(name, current->name, range_min, range_max, 0) 259 #define i(width, name, range_min, range_max) \ 260 xi(width, name, current->name, range_min, range_max, 0) 261 #define ib(width, name) \ 262 xi(width, name, current->name, MIN_INT_BITS(width), MAX_INT_BITS(width), 0) 263 #define se(name, range_min, range_max) \ 264 xse(name, current->name, range_min, range_max, 0) 266 #define us(width, name, range_min, range_max, subs, ...) \ 267 xu(width, name, current->name, range_min, range_max, subs, __VA_ARGS__) 268 #define ubs(width, name, subs, ...) \ 269 xu(width, name, current->name, 0, MAX_UINT_BITS(width), subs, __VA_ARGS__) 270 #define flags(name, subs, ...) \ 271 xu(1, name, current->name, 0, 1, subs, __VA_ARGS__) 272 #define ues(name, range_min, range_max, subs, ...) \ 273 xue(name, current->name, range_min, range_max, subs, __VA_ARGS__) 274 #define is(width, name, range_min, range_max, subs, ...) \ 275 xi(width, name, current->name, range_min, range_max, subs, __VA_ARGS__) 276 #define ibs(width, name, subs, ...) \ 277 xi(width, name, current->name, MIN_INT_BITS(width), MAX_INT_BITS(width), subs, __VA_ARGS__) 278 #define ses(name, range_min, range_max, subs, ...) \ 279 xse(name, current->name, range_min, range_max, subs, __VA_ARGS__) 281 #define fixed(width, name, value) do { \ 282 av_unused uint32_t fixed_value = value; \ 283 xu(width, name, fixed_value, value, value, 0); \ 288 #define READWRITE read 289 #define RWContext GetBitContext 291 #define xu(width, name, var, range_min, range_max, subs, ...) do { \ 293 CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \ 294 SUBSCRIPTS(subs, __VA_ARGS__), \ 295 &value, range_min, range_max)); \ 298 #define xue(name, var, range_min, range_max, subs, ...) do { \ 300 CHECK(cbs_read_ue_golomb(ctx, rw, #name, \ 301 SUBSCRIPTS(subs, __VA_ARGS__), \ 302 &value, range_min, range_max)); \ 305 #define xi(width, name, var, range_min, range_max, subs, ...) do { \ 307 CHECK(ff_cbs_read_signed(ctx, rw, width, #name, \ 308 SUBSCRIPTS(subs, __VA_ARGS__), \ 309 &value, range_min, range_max)); \ 312 #define xse(name, var, range_min, range_max, subs, ...) do { \ 314 CHECK(cbs_read_se_golomb(ctx, rw, #name, \ 315 SUBSCRIPTS(subs, __VA_ARGS__), \ 316 &value, range_min, range_max)); \ 321 #define infer(name, value) do { \ 322 current->name = value; \ 337 #define more_rbsp_data(var) ((var) = cbs_h2645_read_more_rbsp_data(rw)) 339 #define byte_alignment(rw) (get_bits_count(rw) % 8) 341 #define allocate(name, size) do { \ 342 name ## _ref = av_buffer_allocz(size + \ 343 AV_INPUT_BUFFER_PADDING_SIZE); \ 345 return AVERROR(ENOMEM); \ 346 name = name ## _ref->data; \ 349 #define FUNC(name) FUNC_H264(READWRITE, name) 353 #define FUNC(name) FUNC_H265(READWRITE, name) 365 #undef more_rbsp_data 366 #undef byte_alignment 371 #define READWRITE write 372 #define RWContext PutBitContext 374 #define xu(width, name, var, range_min, range_max, subs, ...) do { \ 375 uint32_t value = var; \ 376 CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \ 377 SUBSCRIPTS(subs, __VA_ARGS__), \ 378 value, range_min, range_max)); \ 380 #define xue(name, var, range_min, range_max, subs, ...) do { \ 381 uint32_t value = var; \ 382 CHECK(cbs_write_ue_golomb(ctx, rw, #name, \ 383 SUBSCRIPTS(subs, __VA_ARGS__), \ 384 value, range_min, range_max)); \ 386 #define xi(width, name, var, range_min, range_max, subs, ...) do { \ 387 int32_t value = var; \ 388 CHECK(ff_cbs_write_signed(ctx, rw, width, #name, \ 389 SUBSCRIPTS(subs, __VA_ARGS__), \ 390 value, range_min, range_max)); \ 392 #define xse(name, var, range_min, range_max, subs, ...) do { \ 393 int32_t value = var; \ 394 CHECK(cbs_write_se_golomb(ctx, rw, #name, \ 395 SUBSCRIPTS(subs, __VA_ARGS__), \ 396 value, range_min, range_max)); \ 399 #define infer(name, value) do { \ 400 if (current->name != (value)) { \ 401 av_log(ctx->log_ctx, AV_LOG_WARNING, "Warning: " \ 402 "%s does not match inferred value: " \ 403 "%"PRId64", but should be %"PRId64".\n", \ 404 #name, (int64_t)current->name, (int64_t)(value)); \ 408 #define more_rbsp_data(var) (var) 410 #define byte_alignment(rw) (put_bits_count(rw) % 8) 412 #define allocate(name, size) do { \ 414 av_log(ctx->log_ctx, AV_LOG_ERROR, "%s must be set " \ 415 "for writing.\n", #name); \ 416 return AVERROR_INVALIDDATA; \ 420 #define FUNC(name) FUNC_H264(READWRITE, name) 424 #define FUNC(name) FUNC_H265(READWRITE, name) 441 #undef more_rbsp_data 442 #undef byte_alignment 563 for (i = 0; i < packet->
nb_nals; i++) {
569 while (size > 0 && nal->
data[size - 1] == 0)
610 version = bytestream2_get_byte(&gbc);
613 "first byte %u.", version);
621 count = bytestream2_get_byte(&gbc) & 0x1f;
623 for (i = 0; i <
count; i++) {
626 size = bytestream2_get_be16(&gbc);
634 frag->
data + start, end - start,
645 count = bytestream2_get_byte(&gbc);
647 for (i = 0; i <
count; i++) {
650 size = bytestream2_get_be16(&gbc);
658 frag->
data + start, end - start,
676 int i, j, nb_arrays, nal_unit_type, nb_nals,
version;
685 version = bytestream2_get_byte(&gbc);
688 "first byte %u.", version);
695 nb_arrays = bytestream2_get_byte(&gbc);
696 for (i = 0; i < nb_arrays; i++) {
697 nal_unit_type = bytestream2_get_byte(&gbc) & 0x3f;
698 nb_nals = bytestream2_get_be16(&gbc);
701 for (j = 0; j < nb_nals; j++) {
704 size = bytestream2_get_be16(&gbc);
712 frag->
data + start, end - start,
716 "HVCC array %d (%d NAL units of type %d).\n",
717 i, nb_nals, nal_unit_type);
744 #define cbs_h2645_replace_ps(h26n, ps_name, ps_var, id_element) \ 745 static int cbs_h26 ## h26n ## _replace_ ## ps_var(CodedBitstreamContext *ctx, \ 746 CodedBitstreamUnit *unit) \ 748 CodedBitstreamH26 ## h26n ## Context *priv = ctx->priv_data; \ 749 H26 ## h26n ## Raw ## ps_name *ps_var = unit->content; \ 750 unsigned int id = ps_var->id_element; \ 751 if (id > FF_ARRAY_ELEMS(priv->ps_var)) { \ 752 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid " #ps_name \ 753 " id : %d.\n", id); \ 754 return AVERROR_INVALIDDATA; \ 756 if (priv->ps_var[id] == priv->active_ ## ps_var) \ 757 priv->active_ ## ps_var = NULL ; \ 758 av_buffer_unref(&priv->ps_var ## _ref[id]); \ 759 if (unit->content_ref) \ 760 priv->ps_var ## _ref[id] = av_buffer_ref(unit->content_ref); \ 762 priv->ps_var ## _ref[id] = av_buffer_alloc(sizeof(*ps_var)); \ 763 if (!priv->ps_var ## _ref[id]) \ 764 return AVERROR(ENOMEM); \ 765 priv->ps_var[id] = (H26 ## h26n ## Raw ## ps_name *)priv->ps_var ## _ref[id]->data; \ 766 if (!unit->content_ref) \ 767 memcpy(priv->ps_var[id], ps_var, sizeof(*ps_var)); \ 787 switch (unit->
type) {
797 err = cbs_h264_read_sps(ctx, &gbc, sps);
801 err = cbs_h264_replace_sps(ctx, unit);
815 err = cbs_h264_read_sps_extension(ctx, &gbc, unit->
content);
831 err = cbs_h264_read_pps(ctx, &gbc, pps);
835 err = cbs_h264_replace_pps(ctx, unit);
854 err = cbs_h264_read_slice_header(ctx, &gbc, &slice->
header);
860 if (!unit->
data[len - 1]) {
862 for (z = 0; z < len && !unit->
data[len - z - 1]; z++);
864 "from slice data.\n", z);
884 err = cbs_h264_read_aud(ctx, &gbc, unit->
content);
897 err = cbs_h264_read_sei(ctx, &gbc, unit->
content);
910 err = cbs_h264_read_filler(ctx, &gbc, unit->
content);
926 cbs_h264_read_end_of_sequence :
927 cbs_h264_read_end_of_stream)(ctx, &gbc, unit->
content);
950 switch (unit->
type) {
961 err = cbs_h265_read_vps(ctx, &gbc, vps);
965 err = cbs_h265_replace_vps(ctx, unit);
980 err = cbs_h265_read_sps(ctx, &gbc, sps);
984 err = cbs_h265_replace_sps(ctx, unit);
1000 err = cbs_h265_read_pps(ctx, &gbc, pps);
1004 err = cbs_h265_replace_pps(ctx, unit);
1036 err = cbs_h265_read_slice_segment_header(ctx, &gbc, &slice->
header);
1042 if (!unit->
data[len - 1]) {
1044 for (z = 0; z < len && !unit->
data[len - z - 1]; z++);
1046 "from slice data.\n", z);
1054 slice->
data = unit->
data + pos / 8;
1066 err = cbs_h265_read_aud(ctx, &gbc, unit->
content);
1081 err = cbs_h265_read_sei(ctx, &gbc, unit->
content,
1098 size_t data_size,
int data_bit_start)
1100 size_t rest = data_size - (data_bit_start + 7) / 8;
1101 const uint8_t *pos = data + data_bit_start / 8;
1104 data_size > data_bit_start / 8);
1110 goto rbsp_stop_one_bit;
1115 if (data_bit_start % 8)
1116 put_bits(pbc, 8 - data_bit_start % 8,
1133 for (; rest > 4; rest -= 4, pos += 4)
1136 for (; rest > 1; rest--, pos++)
1140 temp = rest ? *pos : *pos &
MAX_UINT_BITS(8 - data_bit_start % 8);
1145 i = rest ? (8 -
i) : (8 - i - data_bit_start % 8);
1160 switch (unit->
type) {
1165 err = cbs_h264_write_sps(ctx, pbc, sps);
1169 err = cbs_h264_replace_sps(ctx, unit);
1179 err = cbs_h264_write_sps_extension(ctx, pbc, sps_ext);
1189 err = cbs_h264_write_pps(ctx, pbc, pps);
1193 err = cbs_h264_replace_pps(ctx, unit);
1205 err = cbs_h264_write_slice_header(ctx, pbc, &slice->
header);
1224 err = cbs_h264_write_aud(ctx, pbc, unit->
content);
1232 err = cbs_h264_write_sei(ctx, pbc, unit->
content);
1240 err = cbs_h264_write_filler(ctx, pbc, unit->
content);
1248 err = cbs_h264_write_end_of_sequence(ctx, pbc, unit->
content);
1256 err = cbs_h264_write_end_of_stream(ctx, pbc, unit->
content);
1264 "NAL unit type %"PRIu32
".\n", unit->
type);
1277 switch (unit->
type) {
1282 err = cbs_h265_write_vps(ctx, pbc, vps);
1286 err = cbs_h265_replace_vps(ctx, unit);
1296 err = cbs_h265_write_sps(ctx, pbc, sps);
1300 err = cbs_h265_replace_sps(ctx, unit);
1310 err = cbs_h265_write_pps(ctx, pbc, pps);
1314 err = cbs_h265_replace_pps(ctx, unit);
1339 err = cbs_h265_write_slice_segment_header(ctx, pbc, &slice->
header);
1357 err = cbs_h265_write_aud(ctx, pbc, unit->
content);
1366 err = cbs_h265_write_sei(ctx, pbc, unit->
content,
1376 "NAL unit type %"PRIu32
".\n", unit->
type);
1387 size_t max_size, dp,
sp;
1388 int err,
i, zero_run;
1390 for (i = 0; i < frag->
nb_units; i++) {
1396 for (i = 0; i < frag->
nb_units; i++) {
1406 for (i = 0; i < frag->
nb_units; i++) {
1410 if (i < frag->nb_units - 1)
1412 "unaligned padding on non-final NAL unit.\n");
1434 for (sp = 0; sp < unit->
data_size; sp++) {
1436 if (unit->
data[sp] == 0)
1441 if ((unit->
data[sp] & ~3) == 0) {
1445 zero_run = unit->
data[
sp] == 0;
1447 data[dp++] = unit->
data[
sp];
1504 .read_unit = &cbs_h264_read_nal_unit,
1533 for (i = 0; i < au->
nb_units; i++) {
1561 for (i = 0; i < au->
nb_units; i++) {
1594 av_assert0(position >= 0 && position < sei->payload_count);
1600 for (i = 0; i < au->
nb_units; i++) {
1601 if (&au->
units[i] == nal)
1610 memmove(sei->
payload + position,
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
struct H265RawSEIPayload::@56::@57 other
int nb_units
Number of units in this fragment.
H265RawPPS * pps[HEVC_MAX_PPS_COUNT]
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
H265RawSEIUserDataUnregistered user_data_unregistered
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
static int cbs_h2645_write_slice_data(CodedBitstreamContext *ctx, PutBitContext *pbc, const uint8_t *data, size_t data_size, int data_bit_start)
AVBufferRef * sps_ref[H264_MAX_SPS_COUNT]
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
#define AV_LOG_WARNING
Something somehow does not look correct.
H264RawPPS * pps[H264_MAX_PPS_COUNT]
AVBufferRef * sps_ref[HEVC_MAX_SPS_COUNT]
void ff_cbs_delete_unit(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int position)
Delete a unit from a fragment and free all memory it uses.
H264RawNALUnitHeader nal_unit_header
CodedBitstreamUnitType type
Codec-specific type of this unit.
static int cbs_h265_write_nal_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
static int cbs_h265_read_nal_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
static int cbs_read_ue_golomb(CodedBitstreamContext *ctx, GetBitContext *gbc, const char *name, const int *subscripts, uint32_t *write_to, uint32_t range_min, uint32_t range_max)
int ff_cbs_alloc_unit_content(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, size_t size, void(*free)(void *opaque, uint8_t *data))
int ff_cbs_insert_unit_content(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, void *content, AVBufferRef *content_buf)
Insert a new unit into a fragment with the given content.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
union H265RawSEIPayload::@56 payload
static void cbs_h265_free_sei_payload(H265RawSEIPayload *payload)
CodedBitstreamH2645Context common
static int cbs_write_se_golomb(CodedBitstreamContext *ctx, PutBitContext *pbc, const char *name, const int *subscripts, int32_t value, int32_t range_min, int32_t range_max)
int ff_cbs_h264_add_sei_message(CodedBitstreamContext *ctx, CodedBitstreamFragment *au, const H264RawSEIPayload *payload)
Add an SEI message to an access unit.
Macro definitions for various function/variable attributes.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int trace_enable
Enable trace output during read/write operations.
static void cbs_h264_free_pps(void *unit, uint8_t *content)
AVBufferRef * pps_ref[HEVC_MAX_PPS_COUNT]
#define MAX_UINT_BITS(length)
static av_cold int end(AVCodecContext *avctx)
int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length, void *logctx, int is_nalff, int nal_length_size, enum AVCodecID codec_id, int small_padding, int use_ref)
Split an input packet into NAL units.
static void cbs_h265_free_slice(void *unit, uint8_t *content)
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
H265RawSPS * sps[HEVC_MAX_SPS_COUNT]
void ff_h2645_packet_uninit(H2645Packet *pkt)
Free all the allocated memory in the packet.
static int get_bits_count(const GetBitContext *s)
H264RawSPS * sps[H264_MAX_SPS_COUNT]
H265RawSEIPayload payload[H265_MAX_SEI_PAYLOADS]
static void cbs_h264_close(CodedBitstreamContext *ctx)
Coded bitstream unit structure.
void * content
Pointer to the decomposed form of this unit.
static const uint8_t header[24]
CodedBitstreamUnit * units
Pointer to an array of units of length nb_units_allocated.
H265RawPSExtensionData extension_data
uint8_t * data
Pointer to the directly-parsable bitstream form of this unit.
int ff_cbs_insert_unit_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, uint8_t *data, size_t data_size, AVBufferRef *data_buf)
Insert a new unit into a fragment with the given data bitstream.
size_t data_size
The number of bytes in the bitstream.
H.264 common definitions.
static int get_bits_left(GetBitContext *gb)
#define i(width, name, range_min, range_max)
AVCodecID
Identify the syntax and semantics of the bitstream.
buffering period (H.264, D.1.1)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
static void cbs_h265_free_pps(void *unit, uint8_t *content)
static int put_bits_left(PutBitContext *s)
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
simple assert() macros that are a bit more flexible than ISO C assert().
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
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.
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
static int put_bits_count(PutBitContext *s)
H264RawSEIUserDataUnregistered user_data_unregistered
void * log_ctx
Logging context to be passed to all av_log() calls associated with this context.
static void cbs_h264_free_sei_payload(H264RawSEIPayload *payload)
const CodedBitstreamType ff_cbs_type_h264
static void cbs_h265_close(CodedBitstreamContext *ctx)
static void skip_put_bytes(PutBitContext *s, int n)
Skip the given number of bytes.
H265RawPSExtensionData extension_data
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
static void cbs_h265_free_vps(void *unit, uint8_t *content)
uint8_t * data
Pointer to the bitstream form of this fragment.
#define FF_ARRAY_ELEMS(a)
AVBufferRef * pps_ref[H264_MAX_PPS_COUNT]
H264RawSEIUserDataRegistered user_data_registered
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static av_always_inline int bytestream2_tell(GetByteContext *g)
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
static void cbs_h264_free_slice(void *unit, uint8_t *content)
H265RawSEIUserDataRegistered user_data_registered
Coded bitstream fragment structure, combining one or more units.
AVBufferRef * rbsp_buffer_ref
AVBufferRef * slice_group_id_ref
static unsigned int get_bits1(GetBitContext *s)
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Context structure for coded bitstream operations.
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
recovery point (frame # to decoder sync)
static int cbs_h2645_read_more_rbsp_data(GetBitContext *gbc)
struct H264RawSEIPayload::@51::@52 other
registered user data as specified by Rec. ITU-T T.35
H264RawSEIPayload payload[H264_MAX_SEI_PAYLOADS]
static void cbs_h265_free_sei(void *unit, uint8_t *content)
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
static int cbs_read_se_golomb(CodedBitstreamContext *ctx, GetBitContext *gbc, const char *name, const int *subscripts, int32_t *write_to, int32_t range_min, int32_t range_max)
AVBufferRef * vps_ref[HEVC_MAX_VPS_COUNT]
void * priv_data
Internal codec-specific data.
A reference to a data buffer.
H265RawPSExtensionData extension_data
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static int ref[MAX_W *MAX_W]
AVBufferRef * data_ref
A reference to the buffer containing data.
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
const CodedBitstreamType ff_cbs_type_h265
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
H265RawSliceHeader header
H264RawSliceHeader header
void ff_cbs_h264_delete_sei_message(CodedBitstreamContext *ctx, CodedBitstreamFragment *au, CodedBitstreamUnit *nal, int position)
Delete an SEI message from an access unit.
union H264RawSEIPayload::@51 payload
mastering display properties
CodedBitstreamH2645Context common
static int cbs_h264_write_nal_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
const struct CodedBitstreamType * codec
Internal codec-specific hooks.
#define cbs_h2645_replace_ps(h26n, ps_name, ps_var, id_element)
static int cbs_h2645_split_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int header)
H265RawVPS * vps[HEVC_MAX_VPS_COUNT]
AVBufferRef * data_ref
A reference to the buffer containing data.
static int cbs_write_ue_golomb(CodedBitstreamContext *ctx, PutBitContext *pbc, const char *name, const int *subscripts, uint32_t value, uint32_t range_min, uint32_t range_max)
void ff_cbs_trace_syntax_element(CodedBitstreamContext *ctx, int position, const char *str, const int *subscripts, const char *bits, int64_t value)
static void cbs_h264_free_sei(void *unit, uint8_t *content)
size_t data_size
The number of bytes in the bitstream (including any padding bits in the final byte).
static int cbs_h2645_fragment_add_nals(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const H2645Packet *packet)
static void cbs_h265_free_sps(void *unit, uint8_t *content)