Go to the documentation of this file.
37 const char *
name,
const int *subscripts,
39 uint32_t range_min, uint32_t range_max)
41 uint32_t leading_bits,
value;
42 int max_length, leading_zeroes;
49 if (leading_bits == 0) {
50 if (max_length >= 32) {
52 "%s: more than 31 zeroes.\n",
name);
56 "%s: bitstream ended.\n",
name);
61 leading_zeroes = max_length - 1 -
av_log2(leading_bits);
66 "%s: bitstream ended.\n",
name);
74 if (value < range_min || value > range_max) {
76 "%"PRIu32
", but must be in [%"PRIu32
",%"PRIu32
"].\n",
86 const char *
name,
const int *subscripts,
90 uint32_t leading_bits, unsigned_value;
91 int max_length, leading_zeroes;
99 if (leading_bits == 0) {
100 if (max_length >= 32) {
102 "%s: more than 31 zeroes.\n",
name);
106 "%s: bitstream ended.\n",
name);
111 leading_zeroes = max_length - 1 -
av_log2(leading_bits);
116 "%s: bitstream ended.\n",
name);
122 if (unsigned_value & 1)
125 value = unsigned_value / 2;
129 if (value < range_min || value > range_max) {
131 "%"PRId32
", but must be in [%"PRId32
",%"PRId32
"].\n",
141 const char *
name,
const int *subscripts,
143 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",
173 const char *
name,
const int *subscripts,
182 if (value < range_min || value > range_max) {
184 "%"PRId32
", but must be in [%"PRId32
",%"PRId32
"].\n",
193 uvalue = 2 * (uint32_t)
value - 1;
195 uvalue = 2 * (uint32_t)-
value;
217 int bits_left = payload_size * 8 - cur_pos;
222 #define HEADER(name) do { \
223 ff_cbs_trace_header(ctx, name); \
226 #define CHECK(call) do { \
232 #define FUNC_NAME2(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name
233 #define FUNC_NAME1(rw, codec, name) FUNC_NAME2(rw, codec, name)
234 #define FUNC_H264(name) FUNC_NAME1(READWRITE, h264, name)
235 #define FUNC_H265(name) FUNC_NAME1(READWRITE, h265, name)
236 #define FUNC_H266(name) FUNC_NAME1(READWRITE, h266, name)
237 #define FUNC_SEI(name) FUNC_NAME1(READWRITE, sei, name)
239 #define SEI_FUNC(name, args) \
240 static int FUNC(name) args; \
241 static int FUNC(name ## _internal)(CodedBitstreamContext *ctx, \
242 RWContext *rw, void *cur, \
243 SEIMessageState *state) \
245 return FUNC(name)(ctx, rw, cur, state); \
247 static int FUNC(name) args
249 #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)
251 #define u(width, name, range_min, range_max) \
252 xu(width, name, current->name, range_min, range_max, 0, )
253 #define flag(name) ub(1, name)
254 #define ue(name, range_min, range_max) \
255 xue(name, current->name, range_min, range_max, 0, )
256 #define i(width, name, range_min, range_max) \
257 xi(width, name, current->name, range_min, range_max, 0, )
258 #define ib(width, name) \
259 xi(width, name, current->name, MIN_INT_BITS(width), MAX_INT_BITS(width), 0, )
260 #define se(name, range_min, range_max) \
261 xse(name, current->name, range_min, range_max, 0, )
263 #define us(width, name, range_min, range_max, subs, ...) \
264 xu(width, name, current->name, range_min, range_max, subs, __VA_ARGS__)
265 #define ubs(width, name, subs, ...) \
266 xu(width, name, current->name, 0, MAX_UINT_BITS(width), subs, __VA_ARGS__)
267 #define flags(name, subs, ...) \
268 xu(1, name, current->name, 0, 1, subs, __VA_ARGS__)
269 #define ues(name, range_min, range_max, subs, ...) \
270 xue(name, current->name, range_min, range_max, subs, __VA_ARGS__)
271 #define is(width, name, range_min, range_max, subs, ...) \
272 xi(width, name, current->name, range_min, range_max, subs, __VA_ARGS__)
273 #define ibs(width, name, subs, ...) \
274 xi(width, name, current->name, MIN_INT_BITS(width), MAX_INT_BITS(width), subs, __VA_ARGS__)
275 #define ses(name, range_min, range_max, subs, ...) \
276 xse(name, current->name, range_min, range_max, subs, __VA_ARGS__)
278 #define fixed(width, name, value) do { \
279 av_unused uint32_t fixed_value = value; \
280 xu(width, name, fixed_value, value, value, 0, ); \
285 #define READWRITE read
286 #define RWContext GetBitContext
288 #define ub(width, name) do { \
290 CHECK(ff_cbs_read_simple_unsigned(ctx, rw, width, #name, \
292 current->name = value; \
294 #define xu(width, name, var, range_min, range_max, subs, ...) do { \
296 CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
297 SUBSCRIPTS(subs, __VA_ARGS__), \
298 &value, range_min, range_max)); \
301 #define xue(name, var, range_min, range_max, subs, ...) do { \
303 CHECK(cbs_read_ue_golomb(ctx, rw, #name, \
304 SUBSCRIPTS(subs, __VA_ARGS__), \
305 &value, range_min, range_max)); \
308 #define xi(width, name, var, range_min, range_max, subs, ...) do { \
310 CHECK(ff_cbs_read_signed(ctx, rw, width, #name, \
311 SUBSCRIPTS(subs, __VA_ARGS__), \
312 &value, range_min, range_max)); \
315 #define xse(name, var, range_min, range_max, subs, ...) do { \
317 CHECK(cbs_read_se_golomb(ctx, rw, #name, \
318 SUBSCRIPTS(subs, __VA_ARGS__), \
319 &value, range_min, range_max)); \
324 #define infer(name, value) do { \
325 current->name = value; \
340 #define more_rbsp_data(var) ((var) = cbs_h2645_read_more_rbsp_data(rw))
342 #define bit_position(rw) (get_bits_count(rw))
343 #define byte_alignment(rw) (get_bits_count(rw) % 8)
347 #define allocate(name, size) do { \
348 name = ff_refstruct_allocz(size + \
349 AV_INPUT_BUFFER_PADDING_SIZE); \
351 return AVERROR(ENOMEM); \
354 #define FUNC(name) FUNC_SEI(name)
362 #define allocate(name, size) do { \
363 name ## _ref = av_buffer_allocz(size + \
364 AV_INPUT_BUFFER_PADDING_SIZE); \
366 return AVERROR(ENOMEM); \
367 name = name ## _ref->data; \
370 #define FUNC(name) FUNC_H264(name)
374 #define FUNC(name) FUNC_H265(name)
378 #define FUNC(name) FUNC_H266(name)
391 #undef more_rbsp_data
393 #undef byte_alignment
398 #define READWRITE write
399 #define RWContext PutBitContext
401 #define ub(width, name) do { \
402 uint32_t value = current->name; \
403 CHECK(ff_cbs_write_simple_unsigned(ctx, rw, width, #name, \
406 #define xu(width, name, var, range_min, range_max, subs, ...) do { \
407 uint32_t value = var; \
408 CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
409 SUBSCRIPTS(subs, __VA_ARGS__), \
410 value, range_min, range_max)); \
412 #define xue(name, var, range_min, range_max, subs, ...) do { \
413 uint32_t value = var; \
414 CHECK(cbs_write_ue_golomb(ctx, rw, #name, \
415 SUBSCRIPTS(subs, __VA_ARGS__), \
416 value, range_min, range_max)); \
418 #define xi(width, name, var, range_min, range_max, subs, ...) do { \
419 int32_t value = var; \
420 CHECK(ff_cbs_write_signed(ctx, rw, width, #name, \
421 SUBSCRIPTS(subs, __VA_ARGS__), \
422 value, range_min, range_max)); \
424 #define xse(name, var, range_min, range_max, subs, ...) do { \
425 int32_t value = var; \
426 CHECK(cbs_write_se_golomb(ctx, rw, #name, \
427 SUBSCRIPTS(subs, __VA_ARGS__), \
428 value, range_min, range_max)); \
431 #define infer(name, value) do { \
432 if (current->name != (value)) { \
433 av_log(ctx->log_ctx, AV_LOG_ERROR, \
434 "%s does not match inferred value: " \
435 "%"PRId64", but should be %"PRId64".\n", \
436 #name, (int64_t)current->name, (int64_t)(value)); \
437 return AVERROR_INVALIDDATA; \
441 #define more_rbsp_data(var) (var)
443 #define bit_position(rw) (put_bits_count(rw))
444 #define byte_alignment(rw) (put_bits_count(rw) % 8)
446 #define allocate(name, size) do { \
448 av_log(ctx->log_ctx, AV_LOG_ERROR, "%s must be set " \
449 "for writing.\n", #name); \
450 return AVERROR_INVALIDDATA; \
454 #define FUNC(name) FUNC_SEI(name)
458 #define FUNC(name) FUNC_H264(name)
462 #define FUNC(name) FUNC_H265(name)
466 #define FUNC(name) FUNC_H266(name)
484 #undef more_rbsp_data
486 #undef byte_alignment
541 size_t size, start, end;
551 version = bytestream2_get_byte(&gbc);
562 count = bytestream2_get_byte(&gbc) & 0x1f;
564 for (
i = 0;
i < count;
i++) {
567 size = bytestream2_get_be16(&gbc);
575 frag->
data + start, end - start,
587 count = bytestream2_get_byte(&gbc);
589 for (
i = 0;
i < count;
i++) {
592 size = bytestream2_get_be16(&gbc);
600 frag->
data + start, end - start,
618 size_t size, start, end;
619 int i, j, nb_arrays, nal_unit_type, nb_nals,
version;
628 version = bytestream2_get_byte(&gbc);
638 nb_arrays = bytestream2_get_byte(&gbc);
639 for (
i = 0;
i < nb_arrays;
i++) {
640 nal_unit_type = bytestream2_get_byte(&gbc) & 0x3f;
641 nb_nals = bytestream2_get_be16(&gbc);
644 for (j = 0; j < nb_nals; j++) {
647 size = bytestream2_get_be16(&gbc);
655 frag->
data + start, end - start,
660 "HVCC array %d (%d NAL units of type %d).\n",
661 i, nb_nals, nal_unit_type);
671 int ptl_present_flag, num_arrays;
678 b = bytestream2_get_byte(&gbc);
680 ptl_present_flag =
b & 1;
682 if(ptl_present_flag) {
683 int num_sublayers, num_bytes_constraint_info, num_sub_profiles;
684 num_sublayers = (bytestream2_get_be16u(&gbc) >> 4) & 7;
688 num_bytes_constraint_info = bytestream2_get_byte(&gbc) & 0x3f;
690 if(num_sublayers > 1) {
691 int count_present_flags = 0;
692 b = bytestream2_get_byte(&gbc);
693 for(
i = num_sublayers - 2;
i >= 0;
i--) {
694 if((
b >> (7 - (num_sublayers - 2 -
i))) & 0x01)
695 count_present_flags++;
699 num_sub_profiles = bytestream2_get_byte(&gbc);
706 num_arrays = bytestream2_get_byte(&gbc);
707 for(j = 0; j < num_arrays; j++) {
708 size_t start, end,
size;
709 int nal_unit_type = bytestream2_get_byte(&gbc) & 0x1f;
710 unsigned int num_nalus = 1;
712 num_nalus = bytestream2_get_be16(&gbc);
715 for(
i = 0;
i < num_nalus;
i++) {
718 size = bytestream2_get_be16(&gbc);
726 frag->
data + start, end - start,
731 "VVCC array %d (%d NAL units of type %d).\n",
732 i, num_nalus, nal_unit_type);
759 #define cbs_h2645_replace_ps(h26n, ps_name, ps_var, id_element) \
760 static int cbs_h26 ## h26n ## _replace_ ## ps_var(CodedBitstreamContext *ctx, \
761 CodedBitstreamUnit *unit) \
763 CodedBitstreamH26 ## h26n ## Context *priv = ctx->priv_data; \
764 H26 ## h26n ## Raw ## ps_name *ps_var = unit->content; \
765 unsigned int id = ps_var->id_element; \
766 int err = ff_cbs_make_unit_refcounted(ctx, unit); \
769 if (priv->ps_var[id] == priv->active_ ## ps_var) \
770 priv->active_ ## ps_var = NULL ; \
771 av_assert0(unit->content_ref); \
772 ff_refstruct_replace(&priv->ps_var[id], unit->content_ref); \
782 #define cbs_h266_replace_ps(h26n, ps_name, ps_var, id_element) \
783 static int cbs_h26 ## h26n ## _replace_ ## ps_var(CodedBitstreamContext *ctx, \
784 CodedBitstreamUnit *unit) \
786 CodedBitstreamH26 ## h26n ## Context *priv = ctx->priv_data; \
787 H26 ## h26n ## Raw ## ps_name *ps_var = unit->content; \
788 unsigned int id = ps_var->id_element; \
789 int err = ff_cbs_make_unit_refcounted(ctx, unit); \
792 av_assert0(unit->content_ref); \
793 ff_refstruct_replace(&priv->ps_var[id], unit->content_ref); \
805 unsigned int id =
sps->sps_seq_parameter_set_id;
850 switch (unit->
type) {
855 err = cbs_h264_read_sps(
ctx, &gbc,
sps);
859 err = cbs_h264_replace_sps(
ctx, unit);
867 err = cbs_h264_read_sps_extension(
ctx, &gbc, unit->
content);
877 err = cbs_h264_read_pps(
ctx, &gbc,
pps);
881 err = cbs_h264_replace_pps(
ctx, unit);
894 err = cbs_h264_read_slice_header(
ctx, &gbc, &slice->
header);
915 err = cbs_h264_read_aud(
ctx, &gbc, unit->
content);
923 err = cbs_h264_read_sei(
ctx, &gbc, unit->
content);
931 err = cbs_h264_read_filler(
ctx, &gbc, unit->
content);
941 cbs_h264_read_end_of_sequence :
942 cbs_h264_read_end_of_stream)(
ctx, &gbc, unit->
content);
969 switch (unit->
type) {
974 err = cbs_h265_read_vps(
ctx, &gbc,
vps);
978 err = cbs_h265_replace_vps(
ctx, unit);
987 err = cbs_h265_read_sps(
ctx, &gbc,
sps);
991 err = cbs_h265_replace_sps(
ctx, unit);
1001 err = cbs_h265_read_pps(
ctx, &gbc,
pps);
1005 err = cbs_h265_replace_pps(
ctx, unit);
1031 err = cbs_h265_read_slice_segment_header(
ctx, &gbc, &slice->
header);
1052 err = cbs_h265_read_aud(
ctx, &gbc, unit->
content);
1060 err = cbs_h265_read_filler(
ctx, &gbc, unit->
content);
1069 err = cbs_h265_read_sei(
ctx, &gbc, unit->
content,
1098 switch (unit->
type) {
1101 err = cbs_h266_read_dci(
ctx, &gbc, unit->
content);
1109 err = cbs_h266_read_opi(
ctx, &gbc, unit->
content);
1119 err = cbs_h266_read_vps(
ctx, &gbc,
vps);
1123 err = cbs_h266_replace_vps(
ctx, unit);
1132 err = cbs_h266_read_sps(
ctx, &gbc,
sps);
1136 err = cbs_h266_replace_sps(
ctx, unit);
1146 err = cbs_h266_read_pps(
ctx, &gbc,
pps);
1150 err = cbs_h266_replace_pps(
ctx, unit);
1159 err = cbs_h266_read_aps(
ctx, &gbc, unit->
content,
1169 err = cbs_h266_read_ph(
ctx, &gbc,
ph);
1190 err = cbs_h266_read_slice_header(
ctx, &gbc, &slice->
header);
1218 err = cbs_h266_read_aud(
ctx, &gbc, unit->
content);
1227 err = cbs_h266_read_sei(
ctx, &gbc, unit->
content,
1243 size_t data_size,
int data_bit_start)
1245 size_t rest = data_size - (data_bit_start + 7) / 8;
1246 const uint8_t *
pos =
data + data_bit_start / 8;
1249 data_size > data_bit_start / 8);
1255 goto rbsp_stop_one_bit;
1260 if (data_bit_start % 8)
1261 put_bits(pbc, 8 - data_bit_start % 8,
1278 for (; rest > 4; rest -= 4,
pos += 4)
1281 for (; rest > 1; rest--,
pos++)
1290 i = rest ? (8 -
i) : (8 -
i - data_bit_start % 8);
1305 switch (unit->
type) {
1310 err = cbs_h264_write_sps(
ctx, pbc,
sps);
1314 err = cbs_h264_replace_sps(
ctx, unit);
1324 err = cbs_h264_write_sps_extension(
ctx, pbc, sps_ext);
1334 err = cbs_h264_write_pps(
ctx, pbc,
pps);
1338 err = cbs_h264_replace_pps(
ctx, unit);
1350 err = cbs_h264_write_slice_header(
ctx, pbc, &slice->
header);
1369 err = cbs_h264_write_aud(
ctx, pbc, unit->
content);
1377 err = cbs_h264_write_sei(
ctx, pbc, unit->
content);
1385 err = cbs_h264_write_filler(
ctx, pbc, unit->
content);
1393 err = cbs_h264_write_end_of_sequence(
ctx, pbc, unit->
content);
1401 err = cbs_h264_write_end_of_stream(
ctx, pbc, unit->
content);
1409 "NAL unit type %"PRIu32
".\n", unit->
type);
1422 switch (unit->
type) {
1427 err = cbs_h265_write_vps(
ctx, pbc,
vps);
1431 err = cbs_h265_replace_vps(
ctx, unit);
1441 err = cbs_h265_write_sps(
ctx, pbc,
sps);
1445 err = cbs_h265_replace_sps(
ctx, unit);
1455 err = cbs_h265_write_pps(
ctx, pbc,
pps);
1459 err = cbs_h265_replace_pps(
ctx, unit);
1484 err = cbs_h265_write_slice_segment_header(
ctx, pbc, &slice->
header);
1502 err = cbs_h265_write_aud(
ctx, pbc, unit->
content);
1510 err = cbs_h265_write_filler(
ctx, pbc, unit->
content);
1519 err = cbs_h265_write_sei(
ctx, pbc, unit->
content,
1529 "NAL unit type %"PRIu32
".\n", unit->
type);
1542 int slice_type_i, slice_type_b, slice_type_si;
1562 "h264 nal unit header is null, missing decompose?\n");
1572 "h264 slice header is null, missing decompose?\n");
1597 switch (unit->
type) {
1632 "h265 slice header is null, missing decompose?\n");
1642 switch (unit->
type) {
1667 switch (unit->
type) {
1672 err = cbs_h266_write_dci(
ctx, pbc,
dci);
1681 err = cbs_h266_write_opi(
ctx, pbc,
opi);
1690 err = cbs_h266_write_vps(
ctx, pbc,
vps);
1694 err = cbs_h266_replace_vps(
ctx, unit);
1703 err = cbs_h266_write_sps(
ctx, pbc,
sps);
1707 err = cbs_h266_replace_sps(
ctx, unit);
1717 err = cbs_h266_write_pps(
ctx, pbc,
pps);
1721 err = cbs_h266_replace_pps(
ctx, unit);
1730 err = cbs_h266_write_aps(
ctx, pbc, unit->
content,
1739 err = cbs_h266_write_ph(
ctx, pbc,
ph);
1760 err = cbs_h266_write_slice_header(
ctx, pbc, &slice->
header);
1784 err = cbs_h266_write_aud(
ctx, pbc, unit->
content);
1793 err = cbs_h266_write_sei(
ctx, pbc, unit->
content,
1803 "NAL unit type %"PRIu32
".\n", unit->
type);
1815 if (nal_unit_index == 0) {
1832 size_t max_size, dp, sp;
1833 int err,
i, zero_run;
1855 if (i < frag->nb_units - 1)
1857 "unaligned padding on non-final NAL unit.\n");
1872 for (sp = 0; sp < unit->
data_size; sp++) {
1874 if (unit->
data[sp] == 0)
1879 if ((unit->
data[sp] & ~3) == 0) {
1883 zero_run = unit->
data[sp] == 0;
2131 #define SEI_MESSAGE_RW(codec, name) \
2132 .read = cbs_ ## codec ## _read_ ## name ## _internal, \
2133 .write = cbs_ ## codec ## _write_ ## name ## _internal
2319 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 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.
static int cbs_h266_replace_ph(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, H266RawPictureHeader *ph)
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)
RefStruct is an API for creating reference-counted objects with minimal overhead.
uint8_t pps_seq_parameter_set_id
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
CodedBitstreamH2645Context common
@ SEI_TYPE_THREE_DIMENSIONAL_REFERENCE_DISPLAYS_INFO
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.
@ 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 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.
@ SEI_TYPE_FRAME_PACKING_ARRANGEMENT
static const SEIMessageTypeDescriptor cbs_sei_h266_types[]
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)
@ 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 cbs_h265_write_nal_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
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).
void(* flush)(AVBSFContext *ctx)
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.
@ H264_NAL_AUXILIARY_SLICE
static av_always_inline int bytestream2_tell(GetByteContext *g)
@ H2645_FLAG_SMALL_PADDING
@ AVDISCARD_NONKEY
discard all frames except keyframes
@ 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]
@ SEI_TYPE_MASTERING_DISPLAY_COLOUR_VOLUME
#define CBS_UNIT_TYPE_POD(type_, structure)
@ 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
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)
H266RawSPS * sps[VVC_MAX_SPS_COUNT]
RefStruct references.
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
AVBufferRef * rbsp_buffer_ref
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.
#define SEI_MESSAGE_RW(codec, name)
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)
#define flags(name, subs,...)
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 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 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)
@ 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)
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)
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.
int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length, void *logctx, int nal_length_size, enum AVCodecID codec_id, int flags)
Split an input packet into NAL units.
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
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)
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()