Go to the documentation of this file.
36 const char *
name,
const int *subscripts,
38 uint32_t range_min, uint32_t range_max)
40 uint32_t leading_bits,
value;
41 int max_length, leading_zeroes;
48 if (leading_bits == 0) {
49 if (max_length >= 32) {
51 "%s: more than 31 zeroes.\n",
name);
55 "%s: bitstream ended.\n",
name);
60 leading_zeroes = max_length - 1 -
av_log2(leading_bits);
65 "%s: bitstream ended.\n",
name);
73 if (value < range_min || value > range_max) {
75 "%"PRIu32
", but must be in [%"PRIu32
",%"PRIu32
"].\n",
85 const char *
name,
const int *subscripts,
89 uint32_t leading_bits, unsigned_value;
90 int max_length, leading_zeroes;
98 if (leading_bits == 0) {
99 if (max_length >= 32) {
101 "%s: more than 31 zeroes.\n",
name);
105 "%s: bitstream ended.\n",
name);
110 leading_zeroes = max_length - 1 -
av_log2(leading_bits);
115 "%s: bitstream ended.\n",
name);
121 if (unsigned_value & 1)
124 value = unsigned_value / 2;
128 if (value < range_min || value > range_max) {
130 "%"PRId32
", but must be in [%"PRId32
",%"PRId32
"].\n",
140 const char *
name,
const int *subscripts,
142 uint32_t range_min, uint32_t range_max)
148 if (value < range_min || value > range_max) {
150 "%"PRIu32
", but must be in [%"PRIu32
",%"PRIu32
"].\n",
172 const char *
name,
const int *subscripts,
181 if (value < range_min || value > range_max) {
183 "%"PRId32
", but must be in [%"PRId32
",%"PRId32
"].\n",
192 uvalue = 2 * (uint32_t)
value - 1;
194 uvalue = 2 * (uint32_t)-
value;
216 int bits_left = payload_size * 8 - cur_pos;
221 #define HEADER(name) do { \
222 ff_cbs_trace_header(ctx, name); \
225 #define CHECK(call) do { \
231 #define FUNC_NAME2(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name
232 #define FUNC_NAME1(rw, codec, name) FUNC_NAME2(rw, codec, name)
233 #define FUNC_H264(name) FUNC_NAME1(READWRITE, h264, name)
234 #define FUNC_H265(name) FUNC_NAME1(READWRITE, h265, name)
235 #define FUNC_H266(name) FUNC_NAME1(READWRITE, h266, name)
236 #define FUNC_SEI(name) FUNC_NAME1(READWRITE, sei, name)
238 #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)
240 #define u(width, name, range_min, range_max) \
241 xu(width, name, current->name, range_min, range_max, 0, )
242 #define flag(name) ub(1, name)
243 #define ue(name, range_min, range_max) \
244 xue(name, current->name, range_min, range_max, 0, )
245 #define i(width, name, range_min, range_max) \
246 xi(width, name, current->name, range_min, range_max, 0, )
247 #define ib(width, name) \
248 xi(width, name, current->name, MIN_INT_BITS(width), MAX_INT_BITS(width), 0, )
249 #define se(name, range_min, range_max) \
250 xse(name, current->name, range_min, range_max, 0, )
252 #define us(width, name, range_min, range_max, subs, ...) \
253 xu(width, name, current->name, range_min, range_max, subs, __VA_ARGS__)
254 #define ubs(width, name, subs, ...) \
255 xu(width, name, current->name, 0, MAX_UINT_BITS(width), subs, __VA_ARGS__)
256 #define flags(name, subs, ...) \
257 xu(1, name, current->name, 0, 1, subs, __VA_ARGS__)
258 #define ues(name, range_min, range_max, subs, ...) \
259 xue(name, current->name, range_min, range_max, subs, __VA_ARGS__)
260 #define is(width, name, range_min, range_max, subs, ...) \
261 xi(width, name, current->name, range_min, range_max, subs, __VA_ARGS__)
262 #define ibs(width, name, subs, ...) \
263 xi(width, name, current->name, MIN_INT_BITS(width), MAX_INT_BITS(width), subs, __VA_ARGS__)
264 #define ses(name, range_min, range_max, subs, ...) \
265 xse(name, current->name, range_min, range_max, subs, __VA_ARGS__)
267 #define fixed(width, name, value) do { \
268 av_unused uint32_t fixed_value = value; \
269 xu(width, name, fixed_value, value, value, 0, ); \
274 #define READWRITE read
275 #define RWContext GetBitContext
277 #define ub(width, name) do { \
279 CHECK(ff_cbs_read_simple_unsigned(ctx, rw, width, #name, \
281 current->name = value; \
283 #define xu(width, name, var, range_min, range_max, subs, ...) do { \
285 CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
286 SUBSCRIPTS(subs, __VA_ARGS__), \
287 &value, range_min, range_max)); \
290 #define xue(name, var, range_min, range_max, subs, ...) do { \
292 CHECK(cbs_read_ue_golomb(ctx, rw, #name, \
293 SUBSCRIPTS(subs, __VA_ARGS__), \
294 &value, range_min, range_max)); \
297 #define xi(width, name, var, range_min, range_max, subs, ...) do { \
299 CHECK(ff_cbs_read_signed(ctx, rw, width, #name, \
300 SUBSCRIPTS(subs, __VA_ARGS__), \
301 &value, range_min, range_max)); \
304 #define xse(name, var, range_min, range_max, subs, ...) do { \
306 CHECK(cbs_read_se_golomb(ctx, rw, #name, \
307 SUBSCRIPTS(subs, __VA_ARGS__), \
308 &value, range_min, range_max)); \
313 #define infer(name, value) do { \
314 current->name = value; \
329 #define more_rbsp_data(var) ((var) = cbs_h2645_read_more_rbsp_data(rw))
331 #define bit_position(rw) (get_bits_count(rw))
332 #define byte_alignment(rw) (get_bits_count(rw) % 8)
336 #define allocate(name, size) do { \
337 name = ff_refstruct_allocz(size + \
338 AV_INPUT_BUFFER_PADDING_SIZE); \
340 return AVERROR(ENOMEM); \
343 #define FUNC(name) FUNC_SEI(name)
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(name)
363 #define FUNC(name) FUNC_H265(name)
367 #define FUNC(name) FUNC_H266(name)
380 #undef more_rbsp_data
382 #undef byte_alignment
387 #define READWRITE write
388 #define RWContext PutBitContext
390 #define ub(width, name) do { \
391 uint32_t value = current->name; \
392 CHECK(ff_cbs_write_simple_unsigned(ctx, rw, width, #name, \
395 #define xu(width, name, var, range_min, range_max, subs, ...) do { \
396 uint32_t value = var; \
397 CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
398 SUBSCRIPTS(subs, __VA_ARGS__), \
399 value, range_min, range_max)); \
401 #define xue(name, var, range_min, range_max, subs, ...) do { \
402 uint32_t value = var; \
403 CHECK(cbs_write_ue_golomb(ctx, rw, #name, \
404 SUBSCRIPTS(subs, __VA_ARGS__), \
405 value, range_min, range_max)); \
407 #define xi(width, name, var, range_min, range_max, subs, ...) do { \
408 int32_t value = var; \
409 CHECK(ff_cbs_write_signed(ctx, rw, width, #name, \
410 SUBSCRIPTS(subs, __VA_ARGS__), \
411 value, range_min, range_max)); \
413 #define xse(name, var, range_min, range_max, subs, ...) do { \
414 int32_t value = var; \
415 CHECK(cbs_write_se_golomb(ctx, rw, #name, \
416 SUBSCRIPTS(subs, __VA_ARGS__), \
417 value, range_min, range_max)); \
420 #define infer(name, value) do { \
421 if (current->name != (value)) { \
422 av_log(ctx->log_ctx, AV_LOG_ERROR, \
423 "%s does not match inferred value: " \
424 "%"PRId64", but should be %"PRId64".\n", \
425 #name, (int64_t)current->name, (int64_t)(value)); \
426 return AVERROR_INVALIDDATA; \
430 #define more_rbsp_data(var) (var)
432 #define bit_position(rw) (put_bits_count(rw))
433 #define byte_alignment(rw) (put_bits_count(rw) % 8)
435 #define allocate(name, size) do { \
437 av_log(ctx->log_ctx, AV_LOG_ERROR, "%s must be set " \
438 "for writing.\n", #name); \
439 return AVERROR_INVALIDDATA; \
443 #define FUNC(name) FUNC_SEI(name)
447 #define FUNC(name) FUNC_H264(name)
451 #define FUNC(name) FUNC_H265(name)
455 #define FUNC(name) FUNC_H266(name)
473 #undef more_rbsp_data
475 #undef byte_alignment
503 :
packet->rbsp.rbsp_buffer_ref;
529 size_t size, start, end;
539 version = bytestream2_get_byte(&gbc);
550 count = bytestream2_get_byte(&gbc) & 0x1f;
552 for (
i = 0;
i < count;
i++) {
555 size = bytestream2_get_be16(&gbc);
563 frag->
data + start, end - start,
574 count = bytestream2_get_byte(&gbc);
576 for (
i = 0;
i < count;
i++) {
579 size = bytestream2_get_be16(&gbc);
587 frag->
data + start, end - start,
604 size_t size, start, end;
605 int i, j, nb_arrays, nal_unit_type, nb_nals,
version;
614 version = bytestream2_get_byte(&gbc);
624 nb_arrays = bytestream2_get_byte(&gbc);
625 for (
i = 0;
i < nb_arrays;
i++) {
626 nal_unit_type = bytestream2_get_byte(&gbc) & 0x3f;
627 nb_nals = bytestream2_get_be16(&gbc);
630 for (j = 0; j < nb_nals; j++) {
633 size = bytestream2_get_be16(&gbc);
641 frag->
data + start, end - start,
645 "HVCC array %d (%d NAL units of type %d).\n",
646 i, nb_nals, nal_unit_type);
656 int ptl_present_flag, num_arrays;
663 b = bytestream2_get_byte(&gbc);
665 ptl_present_flag =
b & 1;
667 if(ptl_present_flag) {
668 int num_sublayers, num_bytes_constraint_info, num_sub_profiles;
669 num_sublayers = (bytestream2_get_be16u(&gbc) >> 4) & 7;
673 num_bytes_constraint_info = bytestream2_get_byte(&gbc) & 0x3f;
675 if(num_sublayers > 1) {
676 int count_present_flags = 0;
677 b = bytestream2_get_byte(&gbc);
678 for(
i = num_sublayers - 2;
i >= 0;
i--) {
679 if((
b >> (7 - (num_sublayers - 2 -
i))) & 0x01)
680 count_present_flags++;
684 num_sub_profiles = bytestream2_get_byte(&gbc);
691 num_arrays = bytestream2_get_byte(&gbc);
692 for(j = 0; j < num_arrays; j++) {
693 size_t start, end,
size;
694 int nal_unit_type = bytestream2_get_byte(&gbc) & 0x1f;
695 unsigned int num_nalus = 1;
697 num_nalus = bytestream2_get_be16(&gbc);
700 for(
i = 0;
i < num_nalus;
i++) {
701 size = bytestream2_get_be16(&gbc);
707 frag->
data + start, end - start,
711 "VVCC array %d (%d NAL units of type %d).\n",
712 i, num_nalus, nal_unit_type);
738 #define cbs_h2645_replace_ps(h26n, ps_name, ps_var, id_element) \
739 static int cbs_h26 ## h26n ## _replace_ ## ps_var(CodedBitstreamContext *ctx, \
740 CodedBitstreamUnit *unit) \
742 CodedBitstreamH26 ## h26n ## Context *priv = ctx->priv_data; \
743 H26 ## h26n ## Raw ## ps_name *ps_var = unit->content; \
744 unsigned int id = ps_var->id_element; \
745 int err = ff_cbs_make_unit_refcounted(ctx, unit); \
748 if (priv->ps_var[id] == priv->active_ ## ps_var) \
749 priv->active_ ## ps_var = NULL ; \
750 av_assert0(unit->content_ref); \
751 ff_refstruct_replace(&priv->ps_var[id], unit->content_ref); \
761 #define cbs_h266_replace_ps(h26n, ps_name, ps_var, id_element) \
762 static int cbs_h26 ## h26n ## _replace_ ## ps_var(CodedBitstreamContext *ctx, \
763 CodedBitstreamUnit *unit) \
765 CodedBitstreamH26 ## h26n ## Context *priv = ctx->priv_data; \
766 H26 ## h26n ## Raw ## ps_name *ps_var = unit->content; \
767 unsigned int id = ps_var->id_element; \
768 int err = ff_cbs_make_unit_refcounted(ctx, unit); \
771 av_assert0(unit->content_ref); \
772 ff_refstruct_replace(&priv->ps_var[id], unit->content_ref); \
810 switch (unit->
type) {
815 err = cbs_h264_read_sps(
ctx, &gbc,
sps);
819 err = cbs_h264_replace_sps(
ctx, unit);
827 err = cbs_h264_read_sps_extension(
ctx, &gbc, unit->
content);
837 err = cbs_h264_read_pps(
ctx, &gbc,
pps);
841 err = cbs_h264_replace_pps(
ctx, unit);
854 err = cbs_h264_read_slice_header(
ctx, &gbc, &slice->
header);
875 err = cbs_h264_read_aud(
ctx, &gbc, unit->
content);
883 err = cbs_h264_read_sei(
ctx, &gbc, unit->
content);
891 err = cbs_h264_read_filler(
ctx, &gbc, unit->
content);
901 cbs_h264_read_end_of_sequence :
902 cbs_h264_read_end_of_stream)(
ctx, &gbc, unit->
content);
929 switch (unit->
type) {
934 err = cbs_h265_read_vps(
ctx, &gbc,
vps);
938 err = cbs_h265_replace_vps(
ctx, unit);
947 err = cbs_h265_read_sps(
ctx, &gbc,
sps);
951 err = cbs_h265_replace_sps(
ctx, unit);
961 err = cbs_h265_read_pps(
ctx, &gbc,
pps);
965 err = cbs_h265_replace_pps(
ctx, unit);
991 err = cbs_h265_read_slice_segment_header(
ctx, &gbc, &slice->
header);
1012 err = cbs_h265_read_aud(
ctx, &gbc, unit->
content);
1021 err = cbs_h265_read_sei(
ctx, &gbc, unit->
content,
1050 switch (unit->
type) {
1053 err = cbs_h266_read_dci(
ctx, &gbc, unit->
content);
1061 err = cbs_h266_read_opi(
ctx, &gbc, unit->
content);
1071 err = cbs_h266_read_vps(
ctx, &gbc,
vps);
1075 err = cbs_h266_replace_vps(
ctx, unit);
1084 err = cbs_h266_read_sps(
ctx, &gbc,
sps);
1088 err = cbs_h266_replace_sps(
ctx, unit);
1098 err = cbs_h266_read_pps(
ctx, &gbc,
pps);
1102 err = cbs_h266_replace_pps(
ctx, unit);
1111 err = cbs_h266_read_aps(
ctx, &gbc, unit->
content,
1121 err = cbs_h266_read_ph(
ctx, &gbc,
ph);
1124 err = cbs_h266_replace_ph(
ctx, unit, &
ph->ph_picture_header);
1142 err = cbs_h266_read_slice_header(
ctx, &gbc, &slice->
header);
1169 err = cbs_h266_read_aud(
ctx, &gbc, unit->
content);
1178 err = cbs_h266_read_sei(
ctx, &gbc, unit->
content,
1194 size_t data_size,
int data_bit_start)
1196 size_t rest = data_size - (data_bit_start + 7) / 8;
1197 const uint8_t *
pos =
data + data_bit_start / 8;
1200 data_size > data_bit_start / 8);
1206 goto rbsp_stop_one_bit;
1211 if (data_bit_start % 8)
1212 put_bits(pbc, 8 - data_bit_start % 8,
1229 for (; rest > 4; rest -= 4,
pos += 4)
1232 for (; rest > 1; rest--,
pos++)
1241 i = rest ? (8 -
i) : (8 -
i - data_bit_start % 8);
1256 switch (unit->
type) {
1261 err = cbs_h264_write_sps(
ctx, pbc,
sps);
1265 err = cbs_h264_replace_sps(
ctx, unit);
1275 err = cbs_h264_write_sps_extension(
ctx, pbc, sps_ext);
1285 err = cbs_h264_write_pps(
ctx, pbc,
pps);
1289 err = cbs_h264_replace_pps(
ctx, unit);
1301 err = cbs_h264_write_slice_header(
ctx, pbc, &slice->
header);
1320 err = cbs_h264_write_aud(
ctx, pbc, unit->
content);
1328 err = cbs_h264_write_sei(
ctx, pbc, unit->
content);
1336 err = cbs_h264_write_filler(
ctx, pbc, unit->
content);
1344 err = cbs_h264_write_end_of_sequence(
ctx, pbc, unit->
content);
1352 err = cbs_h264_write_end_of_stream(
ctx, pbc, unit->
content);
1360 "NAL unit type %"PRIu32
".\n", unit->
type);
1373 switch (unit->
type) {
1378 err = cbs_h265_write_vps(
ctx, pbc,
vps);
1382 err = cbs_h265_replace_vps(
ctx, unit);
1392 err = cbs_h265_write_sps(
ctx, pbc,
sps);
1396 err = cbs_h265_replace_sps(
ctx, unit);
1406 err = cbs_h265_write_pps(
ctx, pbc,
pps);
1410 err = cbs_h265_replace_pps(
ctx, unit);
1435 err = cbs_h265_write_slice_segment_header(
ctx, pbc, &slice->
header);
1453 err = cbs_h265_write_aud(
ctx, pbc, unit->
content);
1462 err = cbs_h265_write_sei(
ctx, pbc, unit->
content,
1472 "NAL unit type %"PRIu32
".\n", unit->
type);
1485 int slice_type_i, slice_type_b, slice_type_si;
1505 "h264 nal unit header is null, missing decompose?\n");
1515 "h264 slice header is null, missing decompose?\n");
1540 switch (unit->
type) {
1575 "h265 slice header is null, missing decompose?\n");
1585 switch (unit->
type) {
1610 switch (unit->
type) {
1615 err = cbs_h266_write_dci(
ctx, pbc,
dci);
1624 err = cbs_h266_write_opi(
ctx, pbc,
opi);
1633 err = cbs_h266_write_vps(
ctx, pbc,
vps);
1637 err = cbs_h266_replace_vps(
ctx, unit);
1646 err = cbs_h266_write_sps(
ctx, pbc,
sps);
1650 err = cbs_h266_replace_sps(
ctx, unit);
1660 err = cbs_h266_write_pps(
ctx, pbc,
pps);
1664 err = cbs_h266_replace_pps(
ctx, unit);
1673 err = cbs_h266_write_aps(
ctx, pbc, unit->
content,
1682 err = cbs_h266_write_ph(
ctx, pbc,
ph);
1686 err = cbs_h266_replace_ph(
ctx, unit, &
ph->ph_picture_header);
1703 err = cbs_h266_write_slice_header(
ctx, pbc, &slice->
header);
1727 err = cbs_h266_write_aud(
ctx, pbc, unit->
content);
1736 err = cbs_h266_write_sei(
ctx, pbc, unit->
content,
1746 "NAL unit type %"PRIu32
".\n", unit->
type);
1758 if (nal_unit_index == 0) {
1775 size_t max_size, dp,
sp;
1776 int err,
i, zero_run;
1798 if (i < frag->nb_units - 1)
1800 "unaligned padding on non-final NAL unit.\n");
1822 if ((unit->
data[
sp] & ~3) == 0) {
1826 zero_run = unit->
data[
sp] == 0;
2243 switch (
ctx->codec->codec_id) {
@ SEI_TYPE_ALPHA_CHANNEL_INFO
H265RawVPS * vps[HEVC_MAX_VPS_COUNT]
RefStruct references.
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
void * content_ref
If content is reference counted, a RefStruct reference backing content.
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
#define CBS_UNIT_TYPE_COMPLEX(type, structure, free_func)
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
static int FUNC() filler_payload(CodedBitstreamContext *ctx, RWContext *rw, SEIRawFillerPayload *current, SEIMessageState *state)
static int get_bits_left(GetBitContext *gb)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
CodedBitstreamH2645Context common
#define cbs_h266_replace_ps(h26n, ps_name, ps_var, id_element)
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
void * content
Pointer to the decomposed form of this unit.
H265RawSliceHeader header
static int get_bits_count(const GetBitContext *s)
H264RawPPS * pps[H264_MAX_PPS_COUNT]
RefStruct references.
static int FUNC() ph(CodedBitstreamContext *ctx, RWContext *rw, H266RawPH *current)
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
static const CodedBitstreamUnitTypeDescriptor cbs_h266_unit_types[]
H265RawSPS * sps[HEVC_MAX_SPS_COUNT]
RefStruct references.
Context structure for coded bitstream operations.
void ff_h2645_packet_uninit(H2645Packet *pkt)
Free all the allocated memory in the packet.
#define AV_LOG_VERBOSE
Detailed information.
CodedBitstreamUnitType type
Codec-specific type of this unit.
static int cbs_h2645_split_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int header)
static int FUNC() ambient_viewing_environment(CodedBitstreamContext *ctx, RWContext *rw, SEIRawAmbientViewingEnvironment *current, SEIMessageState *state)
RefStruct is an API for creating reference-counted objects with minimal overhead.
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
CodedBitstreamH2645Context common
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
static int cbs_h2645_unit_requires_zero_byte(enum AVCodecID codec_id, CodedBitstreamUnitType type, int nal_unit_index)
Coded bitstream unit structure.
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
H266RawPPS * pps[VVC_MAX_PPS_COUNT]
RefStruct references.
static void cbs_h265_flush(CodedBitstreamContext *ctx)
H266RawVPS * vps[VVC_MAX_VPS_COUNT]
RefStruct references.
static const SEIMessageTypeDescriptor cbs_sei_h265_types[]
const H264RawSPS * active_sps
static int cbs_h2645_fragment_add_nals(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const H2645Packet *packet)
#define CBS_UNIT_TYPE_INTERNAL_REF(type, structure, ref_field)
static void cbs_h264_flush(CodedBitstreamContext *ctx)
@ CBS_CONTENT_TYPE_INTERNAL_REFS
static int put_bits_left(PutBitContext *s)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
@ SEI_TYPE_AMBIENT_VIEWING_ENVIRONMENT
uint8_t * data
Pointer to the directly-parsable bitstream form of this unit.
static int FUNC() alternative_transfer_characteristics(CodedBitstreamContext *ctx, RWContext *rw, SEIRawAlternativeTransferCharacteristics *current, SEIMessageState *state)
static int FUNC() mastering_display_colour_volume(CodedBitstreamContext *ctx, RWContext *rw, SEIRawMasteringDisplayColourVolume *current, SEIMessageState *state)
@ SEI_TYPE_FILLER_PAYLOAD
static const SEIMessageTypeDescriptor cbs_sei_common_types[]
CodedBitstreamUnit * units
Pointer to an array of units of length nb_units_allocated.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static int FUNC() extension_data(CodedBitstreamContext *ctx, RWContext *rw, H265RawExtensionData *current)
#define FF_ARRAY_ELEMS(a)
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
static int FUNC() sei_alpha_channel_info(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIAlphaChannelInfo *current, SEIMessageState *sei)
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)
Coded bitstream fragment structure, combining one or more units.
size_t data_size
The number of bytes in the bitstream.
static const SEIMessageTypeDescriptor cbs_sei_h266_types[]
#define SEI_MESSAGE_RW(codec, name)
static void cbs_h265_free_sei(FFRefStructOpaque unused, void *content)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define SEI_MESSAGE_TYPE_END
@ SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35
int ff_cbs_append_unit_data(CodedBitstreamFragment *frag, CodedBitstreamUnitType type, uint8_t *data, size_t data_size, AVBufferRef *data_buf)
Add a new unit to a fragment with the given data bitstream.
#define cbs_h2645_replace_ps(h26n, ps_name, ps_var, id_element)
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
#define MAX_UINT_BITS(length)
static int FUNC() sei_display_orientation(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIDisplayOrientation *current, SEIMessageState *sei)
@ AVDISCARD_BIDIR
discard all bidirectional frames
#define CBS_TRACE_WRITE_END()
static int cbs_h265_payload_extension_present(GetBitContext *gbc, uint32_t payload_size, int cur_pos)
@ AVDISCARD_ALL
discard all
static int cbs_h266_read_nal_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
H266RawExtensionData extension_data
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static int FUNC() film_grain_characteristics(CodedBitstreamContext *ctx, RWContext *rw, H264RawFilmGrainCharacteristics *current, SEIMessageState *state)
static int FUNC() sei_decoded_picture_hash(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIDecodedPictureHash *current, SEIMessageState *sei)
static int cbs_h265_write_nal_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
static int FUNC() user_data_unregistered(CodedBitstreamContext *ctx, RWContext *rw, SEIRawUserDataUnregistered *current, SEIMessageState *state)
static void cbs_h266_close(CodedBitstreamContext *ctx)
size_t data_size
The number of bytes in the bitstream (including any padding bits in the final byte).
static int FUNC() opi(CodedBitstreamContext *ctx, RWContext *rw, H266RawOPI *current)
CodedBitstreamH2645Context common
#define CBS_UNIT_RANGE_INTERNAL_REF(range_start, range_end, structure, ref_field)
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
static const CodedBitstreamUnitTypeDescriptor cbs_h264_unit_types[]
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
AVCodecID
Identify the syntax and semantics of the bitstream.
static av_always_inline int bytestream2_tell(GetByteContext *g)
@ AVDISCARD_NONKEY
discard all frames except keyframes
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
@ AVDISCARD_DEFAULT
discard useless packets like 0 size packets in avi
const FFCodec * codec_list[]
H266RawPictureHeader * ph
uint8_t * data
Pointer to the bitstream form of this fragment.
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
static const uint8_t header[24]
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.
@ SEI_TYPE_MASTERING_DISPLAY_COLOUR_VOLUME
#define CBS_UNIT_TYPE_POD(type_, structure)
static int FUNC() sei_active_parameter_sets(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEIActiveParameterSets *current, SEIMessageState *sei)
@ SEI_TYPE_ALTERNATIVE_TRANSFER_CHARACTERISTICS
static int cbs_h264_discarded_nal_unit(CodedBitstreamContext *ctx, const CodedBitstreamUnit *unit, enum AVDiscard skip)
static void cbs_h265_close(CodedBitstreamContext *ctx)
const H264RawPPS * active_pps
static int FUNC() sei_time_code(CodedBitstreamContext *ctx, RWContext *rw, H265RawSEITimeCode *current, SEIMessageState *sei)
const SEIMessageTypeDescriptor * ff_cbs_sei_find_type(CodedBitstreamContext *ctx, int payload_type)
Find the type descriptor for the given payload type.
H264RawSliceHeader header
uint8_t last_slice_nal_unit_type
@ AVDISCARD_NONINTRA
discard all non intra frames
AVBufferRef * data_ref
A reference to the buffer containing data.
#define i(width, name, range_min, range_max)
static int put_bits_count(PutBitContext *s)
#define CBS_UNIT_TYPES_COMPLEX(types, structure, free_func)
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
static void cbs_h266_flush(CodedBitstreamContext *ctx)
@ H264_NAL_AUXILIARY_SLICE
H266RawSPS * sps[VVC_MAX_SPS_COUNT]
RefStruct references.
enum AVPacketSideDataType packet
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
@ SEI_TYPE_DISPLAY_ORIENTATION
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_make_unit_refcounted(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Make the content of a unit refcounted.
const H265RawSPS * active_sps
#define CBS_UNIT_TYPE_END_OF_LIST
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)
static void cbs_h264_close(CodedBitstreamContext *ctx)
static void cbs_h264_free_sei(FFRefStructOpaque unused, void *content)
H265RawPPS * pps[HEVC_MAX_PPS_COUNT]
RefStruct references.
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
void ff_refstruct_replace(void *dstp, const void *src)
Ensure *dstp refers to the same object as src.
H266RawSliceHeader header
int ff_cbs_alloc_unit_content(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Allocate a new internal content buffer matching the type of the unit.
#define AV_INPUT_BUFFER_PADDING_SIZE
const H265RawPPS * active_pps
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
@ SEI_TYPE_BUFFERING_PERIOD
uint32_t CodedBitstreamUnitType
The codec-specific type of a bitstream unit.
@ SEI_TYPE_USER_DATA_UNREGISTERED
static int FUNC() sei_pan_scan_rect(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIPanScanRect *current, SEIMessageState *sei)
static void skip_put_bytes(PutBitContext *s, int n)
Skip the given number of bytes.
const H265RawVPS * active_vps
static int ref[MAX_W *MAX_W]
static int FUNC() content_light_level_info(CodedBitstreamContext *ctx, RWContext *rw, SEIRawContentLightLevelInfo *current, SEIMessageState *state)
static void cbs_h266_free_sei(FFRefStructOpaque unused, void *content)
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)
static int FUNC() sei_buffering_period(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIBufferingPeriod *current, SEIMessageState *sei)
@ SEI_TYPE_RECOVERY_POINT
static int FUNC() dci(CodedBitstreamContext *ctx, RWContext *rw, H266RawDCI *current)
@ SEI_TYPE_DECODED_PICTURE_HASH
static int cbs_h265_discarded_nal_unit(CodedBitstreamContext *ctx, const CodedBitstreamUnit *unit, enum AVDiscard skip)
void(* flush)(AVBSFContext *ctx)
A reference to a data buffer.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
const CodedBitstreamType ff_cbs_type_h266
static int cbs_h265_read_nal_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
#define CBS_UNIT_TYPES_INTERNAL_REF(types, structure, ref_field)
static int cbs_h2645_write_slice_data(CodedBitstreamContext *ctx, PutBitContext *pbc, const uint8_t *data, size_t data_size, int data_bit_start)
static const CodedBitstreamUnitTypeDescriptor cbs_h265_unit_types[]
void * ph_ref
RefStruct reference backing ph above.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
static int FUNC() sei_recovery_point(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIRecoveryPoint *current, SEIMessageState *sei)
const CodedBitstreamType ff_cbs_type_h264
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
@ SEI_TYPE_CONTENT_LIGHT_LEVEL_INFO
AVBufferRef * data_ref
A reference to the buffer containing data.
static int cbs_h264_read_nal_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
void ff_cbs_sei_free_message_list(SEIRawMessageList *list)
Free all SEI messages in a message list.
@ AVDISCARD_NONREF
discard all non reference
static int FUNC() sei_pic_timing(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEIPicTiming *current, SEIMessageState *sei)
H264RawSPS * sps[H264_MAX_SPS_COUNT]
RefStruct references.
@ SEI_TYPE_FILM_GRAIN_CHARACTERISTICS
const CodedBitstreamType ff_cbs_type_h265
#define CBS_TRACE_READ_START()
@ SEI_TYPE_ACTIVE_PARAMETER_SETS
void * priv_data
Format private data.
static int cbs_h264_write_nal_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
static const SEIMessageTypeDescriptor cbs_sei_h264_types[]
static int cbs_h2645_assemble_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
int nb_units
Number of units in this fragment.
static int cbs_h2645_read_more_rbsp_data(GetBitContext *gbc)
static int FUNC() user_data_registered(CodedBitstreamContext *ctx, RWContext *rw, SEIRawUserDataRegistered *current, SEIMessageState *state)
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
static int cbs_h266_write_nal_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
#define CBS_TRACE_READ_END()
#define CBS_TRACE_WRITE_START()