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);
241 int bits_left = payload_size * 8 - cur_pos;
242 return (bits_left > 0 &&
246 #define HEADER(name) do { \ 247 ff_cbs_trace_header(ctx, name); \ 250 #define CHECK(call) do { \ 256 #define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name 257 #define FUNC_H264(rw, name) FUNC_NAME(rw, h264, name) 258 #define FUNC_H265(rw, name) FUNC_NAME(rw, h265, name) 260 #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL) 262 #define u(width, name, range_min, range_max) \ 263 xu(width, name, current->name, range_min, range_max, 0, ) 264 #define ub(width, name) \ 265 xu(width, name, current->name, 0, MAX_UINT_BITS(width), 0, ) 266 #define flag(name) ub(1, name) 267 #define ue(name, range_min, range_max) \ 268 xue(name, current->name, range_min, range_max, 0, ) 269 #define i(width, name, range_min, range_max) \ 270 xi(width, name, current->name, range_min, range_max, 0, ) 271 #define ib(width, name) \ 272 xi(width, name, current->name, MIN_INT_BITS(width), MAX_INT_BITS(width), 0, ) 273 #define se(name, range_min, range_max) \ 274 xse(name, current->name, range_min, range_max, 0, ) 276 #define us(width, name, range_min, range_max, subs, ...) \ 277 xu(width, name, current->name, range_min, range_max, subs, __VA_ARGS__) 278 #define ubs(width, name, subs, ...) \ 279 xu(width, name, current->name, 0, MAX_UINT_BITS(width), subs, __VA_ARGS__) 280 #define flags(name, subs, ...) \ 281 xu(1, name, current->name, 0, 1, subs, __VA_ARGS__) 282 #define ues(name, range_min, range_max, subs, ...) \ 283 xue(name, current->name, range_min, range_max, subs, __VA_ARGS__) 284 #define is(width, name, range_min, range_max, subs, ...) \ 285 xi(width, name, current->name, range_min, range_max, subs, __VA_ARGS__) 286 #define ibs(width, name, subs, ...) \ 287 xi(width, name, current->name, MIN_INT_BITS(width), MAX_INT_BITS(width), subs, __VA_ARGS__) 288 #define ses(name, range_min, range_max, subs, ...) \ 289 xse(name, current->name, range_min, range_max, subs, __VA_ARGS__) 291 #define fixed(width, name, value) do { \ 292 av_unused uint32_t fixed_value = value; \ 293 xu(width, name, fixed_value, value, value, 0, ); \ 298 #define READWRITE read 299 #define RWContext GetBitContext 301 #define xu(width, name, var, range_min, range_max, subs, ...) do { \ 303 CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \ 304 SUBSCRIPTS(subs, __VA_ARGS__), \ 305 &value, range_min, range_max)); \ 308 #define xue(name, var, range_min, range_max, subs, ...) do { \ 310 CHECK(cbs_read_ue_golomb(ctx, rw, #name, \ 311 SUBSCRIPTS(subs, __VA_ARGS__), \ 312 &value, range_min, range_max)); \ 315 #define xi(width, name, var, range_min, range_max, subs, ...) do { \ 317 CHECK(ff_cbs_read_signed(ctx, rw, width, #name, \ 318 SUBSCRIPTS(subs, __VA_ARGS__), \ 319 &value, range_min, range_max)); \ 322 #define xse(name, var, range_min, range_max, subs, ...) do { \ 324 CHECK(cbs_read_se_golomb(ctx, rw, #name, \ 325 SUBSCRIPTS(subs, __VA_ARGS__), \ 326 &value, range_min, range_max)); \ 331 #define infer(name, value) do { \ 332 current->name = value; \ 347 #define more_rbsp_data(var) ((var) = cbs_h2645_read_more_rbsp_data(rw)) 349 #define byte_alignment(rw) (get_bits_count(rw) % 8) 351 #define allocate(name, size) do { \ 352 name ## _ref = av_buffer_allocz(size + \ 353 AV_INPUT_BUFFER_PADDING_SIZE); \ 355 return AVERROR(ENOMEM); \ 356 name = name ## _ref->data; \ 359 #define FUNC(name) FUNC_H264(READWRITE, name) 363 #define FUNC(name) FUNC_H265(READWRITE, name) 375 #undef more_rbsp_data 376 #undef byte_alignment 381 #define READWRITE write 382 #define RWContext PutBitContext 384 #define xu(width, name, var, range_min, range_max, subs, ...) do { \ 385 uint32_t value = var; \ 386 CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \ 387 SUBSCRIPTS(subs, __VA_ARGS__), \ 388 value, range_min, range_max)); \ 390 #define xue(name, var, range_min, range_max, subs, ...) do { \ 391 uint32_t value = var; \ 392 CHECK(cbs_write_ue_golomb(ctx, rw, #name, \ 393 SUBSCRIPTS(subs, __VA_ARGS__), \ 394 value, range_min, range_max)); \ 396 #define xi(width, name, var, range_min, range_max, subs, ...) do { \ 397 int32_t value = var; \ 398 CHECK(ff_cbs_write_signed(ctx, rw, width, #name, \ 399 SUBSCRIPTS(subs, __VA_ARGS__), \ 400 value, range_min, range_max)); \ 402 #define xse(name, var, range_min, range_max, subs, ...) do { \ 403 int32_t value = var; \ 404 CHECK(cbs_write_se_golomb(ctx, rw, #name, \ 405 SUBSCRIPTS(subs, __VA_ARGS__), \ 406 value, range_min, range_max)); \ 409 #define infer(name, value) do { \ 410 if (current->name != (value)) { \ 411 av_log(ctx->log_ctx, AV_LOG_ERROR, \ 412 "%s does not match inferred value: " \ 413 "%"PRId64", but should be %"PRId64".\n", \ 414 #name, (int64_t)current->name, (int64_t)(value)); \ 415 return AVERROR_INVALIDDATA; \ 419 #define more_rbsp_data(var) (var) 421 #define byte_alignment(rw) (put_bits_count(rw) % 8) 423 #define allocate(name, size) do { \ 425 av_log(ctx->log_ctx, AV_LOG_ERROR, "%s must be set " \ 426 "for writing.\n", #name); \ 427 return AVERROR_INVALIDDATA; \ 431 #define FUNC(name) FUNC_H264(READWRITE, name) 435 #define FUNC(name) FUNC_H265(READWRITE, name) 452 #undef more_rbsp_data 453 #undef byte_alignment 575 for (i = 0; i < packet->
nb_nals; i++) {
584 while (size > 0 && nal->
data[size - 1] == 0)
628 version = bytestream2_get_byte(&gbc);
631 "first byte %u.\n", version);
639 count = bytestream2_get_byte(&gbc) & 0x1f;
641 for (i = 0; i < count; i++) {
644 size = bytestream2_get_be16(&gbc);
652 frag->
data + start, end - start,
663 count = bytestream2_get_byte(&gbc);
665 for (i = 0; i < count; i++) {
668 size = bytestream2_get_be16(&gbc);
676 frag->
data + start, end - start,
694 int i, j, nb_arrays, nal_unit_type, nb_nals,
version;
703 version = bytestream2_get_byte(&gbc);
706 "first byte %u.\n", version);
713 nb_arrays = bytestream2_get_byte(&gbc);
714 for (i = 0; i < nb_arrays; i++) {
715 nal_unit_type = bytestream2_get_byte(&gbc) & 0x3f;
716 nb_nals = bytestream2_get_be16(&gbc);
719 for (j = 0; j < nb_nals; j++) {
722 size = bytestream2_get_be16(&gbc);
730 frag->
data + start, end - start,
734 "HVCC array %d (%d NAL units of type %d).\n",
735 i, nb_nals, nal_unit_type);
762 #define cbs_h2645_replace_ps(h26n, ps_name, ps_var, id_element) \ 763 static int cbs_h26 ## h26n ## _replace_ ## ps_var(CodedBitstreamContext *ctx, \ 764 CodedBitstreamUnit *unit) \ 766 CodedBitstreamH26 ## h26n ## Context *priv = ctx->priv_data; \ 767 H26 ## h26n ## Raw ## ps_name *ps_var = unit->content; \ 768 unsigned int id = ps_var->id_element; \ 769 if (id >= FF_ARRAY_ELEMS(priv->ps_var)) { \ 770 av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid " #ps_name \ 771 " id : %d.\n", id); \ 772 return AVERROR_INVALIDDATA; \ 774 if (priv->ps_var[id] == priv->active_ ## ps_var) \ 775 priv->active_ ## ps_var = NULL ; \ 776 av_buffer_unref(&priv->ps_var ## _ref[id]); \ 777 if (unit->content_ref) \ 778 priv->ps_var ## _ref[id] = av_buffer_ref(unit->content_ref); \ 780 priv->ps_var ## _ref[id] = av_buffer_alloc(sizeof(*ps_var)); \ 781 if (!priv->ps_var ## _ref[id]) \ 782 return AVERROR(ENOMEM); \ 783 priv->ps_var[id] = (H26 ## h26n ## Raw ## ps_name *)priv->ps_var ## _ref[id]->data; \ 784 if (!unit->content_ref) \ 785 memcpy(priv->ps_var[id], ps_var, sizeof(*ps_var)); \ 805 switch (unit->
type) {
815 err = cbs_h264_read_sps(ctx, &gbc, sps);
819 err = cbs_h264_replace_sps(ctx, unit);
833 err = cbs_h264_read_sps_extension(ctx, &gbc, unit->
content);
849 err = cbs_h264_read_pps(ctx, &gbc, pps);
853 err = cbs_h264_replace_pps(ctx, unit);
872 err = cbs_h264_read_slice_header(ctx, &gbc, &slice->
header);
898 err = cbs_h264_read_aud(ctx, &gbc, unit->
content);
911 err = cbs_h264_read_sei(ctx, &gbc, unit->
content);
924 err = cbs_h264_read_filler(ctx, &gbc, unit->
content);
940 cbs_h264_read_end_of_sequence :
941 cbs_h264_read_end_of_stream)(ctx, &gbc, unit->
content);
964 switch (unit->
type) {
975 err = cbs_h265_read_vps(ctx, &gbc, vps);
979 err = cbs_h265_replace_vps(ctx, unit);
994 err = cbs_h265_read_sps(ctx, &gbc, sps);
998 err = cbs_h265_replace_sps(ctx, unit);
1014 err = cbs_h265_read_pps(ctx, &gbc, pps);
1018 err = cbs_h265_replace_pps(ctx, unit);
1050 err = cbs_h265_read_slice_segment_header(ctx, &gbc, &slice->
header);
1064 slice->
data = unit->
data + pos / 8;
1076 err = cbs_h265_read_aud(ctx, &gbc, unit->
content);
1091 err = cbs_h265_read_sei(ctx, &gbc, unit->
content,
1108 size_t data_size,
int data_bit_start)
1110 size_t rest = data_size - (data_bit_start + 7) / 8;
1111 const uint8_t *
pos = data + data_bit_start / 8;
1114 data_size > data_bit_start / 8);
1120 goto rbsp_stop_one_bit;
1125 if (data_bit_start % 8)
1126 put_bits(pbc, 8 - data_bit_start % 8,
1143 for (; rest > 4; rest -= 4, pos += 4)
1146 for (; rest > 1; rest--, pos++)
1155 i = rest ? (8 -
i) : (8 - i - data_bit_start % 8);
1170 switch (unit->
type) {
1175 err = cbs_h264_write_sps(ctx, pbc, sps);
1179 err = cbs_h264_replace_sps(ctx, unit);
1189 err = cbs_h264_write_sps_extension(ctx, pbc, sps_ext);
1199 err = cbs_h264_write_pps(ctx, pbc, pps);
1203 err = cbs_h264_replace_pps(ctx, unit);
1215 err = cbs_h264_write_slice_header(ctx, pbc, &slice->
header);
1234 err = cbs_h264_write_aud(ctx, pbc, unit->
content);
1242 err = cbs_h264_write_sei(ctx, pbc, unit->
content);
1250 err = cbs_h264_write_filler(ctx, pbc, unit->
content);
1258 err = cbs_h264_write_end_of_sequence(ctx, pbc, unit->
content);
1266 err = cbs_h264_write_end_of_stream(ctx, pbc, unit->
content);
1274 "NAL unit type %"PRIu32
".\n", unit->
type);
1287 switch (unit->
type) {
1292 err = cbs_h265_write_vps(ctx, pbc, vps);
1296 err = cbs_h265_replace_vps(ctx, unit);
1306 err = cbs_h265_write_sps(ctx, pbc, sps);
1310 err = cbs_h265_replace_sps(ctx, unit);
1320 err = cbs_h265_write_pps(ctx, pbc, pps);
1324 err = cbs_h265_replace_pps(ctx, unit);
1349 err = cbs_h265_write_slice_segment_header(ctx, pbc, &slice->
header);
1367 err = cbs_h265_write_aud(ctx, pbc, unit->
content);
1376 err = cbs_h265_write_sei(ctx, pbc, unit->
content,
1386 "NAL unit type %"PRIu32
".\n", unit->
type);
1397 size_t max_size, dp,
sp;
1398 int err,
i, zero_run;
1400 for (i = 0; i < frag->
nb_units; i++) {
1406 for (i = 0; i < frag->
nb_units; i++) {
1416 for (i = 0; i < frag->
nb_units; i++) {
1420 if (i < frag->nb_units - 1)
1422 "unaligned padding on non-final NAL unit.\n");
1444 for (sp = 0; sp < unit->
data_size; sp++) {
1446 if (unit->
data[sp] == 0)
1451 if ((unit->
data[sp] & ~3) == 0) {
1455 zero_run = unit->
data[
sp] == 0;
1457 data[dp++] = unit->
data[
sp];
1514 .read_unit = &cbs_h264_read_nal_unit,
1542 for (i = 0; i < au->
nb_units; i++) {
1574 for (i = 0; i < au->
nb_units; i++) {
1604 av_assert0(position >= 0 && position < sei->payload_count);
1610 for (i = 0; i < au->
nb_units; i++) {
1611 if (&au->
units[i] == nal)
1620 memmove(sei->
payload + position,
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
int nb_units
Number of units in this fragment.
H265RawPPS * pps[HEVC_MAX_PPS_COUNT]
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
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)
union H264RawSEIPayload::@28 payload
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.
static void cbs_h265_free_slice(void *opaque, uint8_t *content)
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)
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)
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_h265_free_sps(void *opaque, uint8_t *content)
AVBufferRef * pps_ref[HEVC_MAX_PPS_COUNT]
H265RawExtensionData extension_data
#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.
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.
struct H265RawSEIPayload::@33::@34 other
static int get_bits_count(const GetBitContext *s)
H264RawSPS * sps[H264_MAX_SPS_COUNT]
#define AV_LOG_VERBOSE
Detailed information.
H265RawSEIPayload payload[H265_MAX_SEI_PAYLOADS]
static void cbs_h264_close(CodedBitstreamContext *ctx)
Coded bitstream unit structure.
static void cbs_h264_free_slice(void *opaque, uint8_t *content)
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.
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.
static int cbs_h265_payload_extension_present(GetBitContext *gbc, uint32_t payload_size, int cur_pos)
size_t data_size
The number of bytes in the bitstream.
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
H.264 common definitions.
int ff_cbs_h264_add_sei_message(CodedBitstreamContext *ctx, CodedBitstreamFragment *au, H264RawSEIPayload *payload)
Add an SEI message to an access unit.
static int get_bits_left(GetBitContext *gb)
#define i(width, name, range_min, range_max)
AVCodecID
Identify the syntax and semantics of the bitstream.
union H265RawSEIPayload::@33 payload
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 int put_bits_left(PutBitContext *s)
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
static void cbs_h265_free_pps(void *opaque, uint8_t *content)
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...
struct H264RawSEIPayload::@28::@29 other
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.
static void cbs_h265_free_vps(void *opaque, uint8_t *content)
H265RawExtensionData extension_data
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.
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
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.
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.
H265RawExtensionData extension_data
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)
registered user data as specified by Rec. ITU-T T.35
H264RawSEIPayload payload[H264_MAX_SEI_PAYLOADS]
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
static void cbs_h265_free_sei(void *opaque, uint8_t *content)
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.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static int ref[MAX_W *MAX_W]
static void cbs_h264_free_sei(void *opaque, uint8_t *content)
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.
static void cbs_h264_free_pps(void *opaque, uint8_t *content)
mastering display properties
H265RawExtensionData extension_data
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)
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)