Go to the documentation of this file.
35 const char *
name,
const int *subscripts,
37 uint32_t range_min, uint32_t range_max)
39 uint32_t leading_bits,
value;
40 int max_length, leading_zeroes;
47 if (leading_bits == 0) {
48 if (max_length >= 32) {
50 "%s: more than 31 zeroes.\n",
name);
54 "%s: bitstream ended.\n",
name);
59 leading_zeroes = max_length - 1 -
av_log2(leading_bits);
64 "%s: bitstream ended.\n",
name);
72 if (value < range_min || value > range_max) {
74 "%"PRIu32
", but must be in [%"PRIu32
",%"PRIu32
"].\n",
84 const char *
name,
const int *subscripts,
88 uint32_t leading_bits, unsigned_value;
89 int max_length, leading_zeroes;
97 if (leading_bits == 0) {
98 if (max_length >= 32) {
100 "%s: more than 31 zeroes.\n",
name);
104 "%s: bitstream ended.\n",
name);
109 leading_zeroes = max_length - 1 -
av_log2(leading_bits);
114 "%s: bitstream ended.\n",
name);
120 if (unsigned_value & 1)
123 value = unsigned_value / 2;
127 if (value < range_min || value > range_max) {
129 "%"PRId32
", but must be in [%"PRId32
",%"PRId32
"].\n",
139 const char *
name,
const int *subscripts,
141 uint32_t range_min, uint32_t range_max)
147 if (value < range_min || value > range_max) {
149 "%"PRIu32
", but must be in [%"PRIu32
",%"PRIu32
"].\n",
171 const char *
name,
const int *subscripts,
180 if (value < range_min || value > range_max) {
182 "%"PRId32
", but must be in [%"PRId32
",%"PRId32
"].\n",
191 uvalue = 2 * (uint32_t)
value - 1;
193 uvalue = 2 * (uint32_t)-
value;
215 int bits_left = payload_size * 8 - cur_pos;
220 #define HEADER(name) do { \
221 ff_cbs_trace_header(ctx, name); \
224 #define CHECK(call) do { \
230 #define FUNC_NAME2(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name
231 #define FUNC_NAME1(rw, codec, name) FUNC_NAME2(rw, codec, name)
232 #define FUNC_H264(name) FUNC_NAME1(READWRITE, h264, name)
233 #define FUNC_H265(name) FUNC_NAME1(READWRITE, h265, name)
234 #define FUNC_H266(name) FUNC_NAME1(READWRITE, h266, name)
235 #define FUNC_SEI(name) FUNC_NAME1(READWRITE, sei, name)
237 #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)
239 #define u(width, name, range_min, range_max) \
240 xu(width, name, current->name, range_min, range_max, 0, )
241 #define flag(name) ub(1, name)
242 #define ue(name, range_min, range_max) \
243 xue(name, current->name, range_min, range_max, 0, )
244 #define i(width, name, range_min, range_max) \
245 xi(width, name, current->name, range_min, range_max, 0, )
246 #define ib(width, name) \
247 xi(width, name, current->name, MIN_INT_BITS(width), MAX_INT_BITS(width), 0, )
248 #define se(name, range_min, range_max) \
249 xse(name, current->name, range_min, range_max, 0, )
251 #define us(width, name, range_min, range_max, subs, ...) \
252 xu(width, name, current->name, range_min, range_max, subs, __VA_ARGS__)
253 #define ubs(width, name, subs, ...) \
254 xu(width, name, current->name, 0, MAX_UINT_BITS(width), subs, __VA_ARGS__)
255 #define flags(name, subs, ...) \
256 xu(1, name, current->name, 0, 1, subs, __VA_ARGS__)
257 #define ues(name, range_min, range_max, subs, ...) \
258 xue(name, current->name, range_min, range_max, subs, __VA_ARGS__)
259 #define is(width, name, range_min, range_max, subs, ...) \
260 xi(width, name, current->name, range_min, range_max, subs, __VA_ARGS__)
261 #define ibs(width, name, subs, ...) \
262 xi(width, name, current->name, MIN_INT_BITS(width), MAX_INT_BITS(width), subs, __VA_ARGS__)
263 #define ses(name, range_min, range_max, subs, ...) \
264 xse(name, current->name, range_min, range_max, subs, __VA_ARGS__)
266 #define fixed(width, name, value) do { \
267 av_unused uint32_t fixed_value = value; \
268 xu(width, name, fixed_value, value, value, 0, ); \
273 #define READWRITE read
274 #define RWContext GetBitContext
276 #define ub(width, name) do { \
278 CHECK(ff_cbs_read_simple_unsigned(ctx, rw, width, #name, \
280 current->name = value; \
282 #define xu(width, name, var, range_min, range_max, subs, ...) do { \
284 CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
285 SUBSCRIPTS(subs, __VA_ARGS__), \
286 &value, range_min, range_max)); \
289 #define xue(name, var, range_min, range_max, subs, ...) do { \
291 CHECK(cbs_read_ue_golomb(ctx, rw, #name, \
292 SUBSCRIPTS(subs, __VA_ARGS__), \
293 &value, range_min, range_max)); \
296 #define xi(width, name, var, range_min, range_max, subs, ...) do { \
298 CHECK(ff_cbs_read_signed(ctx, rw, width, #name, \
299 SUBSCRIPTS(subs, __VA_ARGS__), \
300 &value, range_min, range_max)); \
303 #define xse(name, var, range_min, range_max, subs, ...) do { \
305 CHECK(cbs_read_se_golomb(ctx, rw, #name, \
306 SUBSCRIPTS(subs, __VA_ARGS__), \
307 &value, range_min, range_max)); \
312 #define infer(name, value) do { \
313 current->name = value; \
328 #define more_rbsp_data(var) ((var) = cbs_h2645_read_more_rbsp_data(rw))
330 #define bit_position(rw) (get_bits_count(rw))
331 #define byte_alignment(rw) (get_bits_count(rw) % 8)
333 #define allocate(name, size) do { \
334 name ## _ref = av_buffer_allocz(size + \
335 AV_INPUT_BUFFER_PADDING_SIZE); \
337 return AVERROR(ENOMEM); \
338 name = name ## _ref->data; \
341 #define FUNC(name) FUNC_SEI(name)
345 #define FUNC(name) FUNC_H264(name)
349 #define FUNC(name) FUNC_H265(name)
353 #define FUNC(name) FUNC_H266(name)
366 #undef more_rbsp_data
368 #undef byte_alignment
373 #define READWRITE write
374 #define RWContext PutBitContext
376 #define ub(width, name) do { \
377 uint32_t value = current->name; \
378 CHECK(ff_cbs_write_simple_unsigned(ctx, rw, width, #name, \
381 #define xu(width, name, var, range_min, range_max, subs, ...) do { \
382 uint32_t value = var; \
383 CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
384 SUBSCRIPTS(subs, __VA_ARGS__), \
385 value, range_min, range_max)); \
387 #define xue(name, var, range_min, range_max, subs, ...) do { \
388 uint32_t value = var; \
389 CHECK(cbs_write_ue_golomb(ctx, rw, #name, \
390 SUBSCRIPTS(subs, __VA_ARGS__), \
391 value, range_min, range_max)); \
393 #define xi(width, name, var, range_min, range_max, subs, ...) do { \
394 int32_t value = var; \
395 CHECK(ff_cbs_write_signed(ctx, rw, width, #name, \
396 SUBSCRIPTS(subs, __VA_ARGS__), \
397 value, range_min, range_max)); \
399 #define xse(name, var, range_min, range_max, subs, ...) do { \
400 int32_t value = var; \
401 CHECK(cbs_write_se_golomb(ctx, rw, #name, \
402 SUBSCRIPTS(subs, __VA_ARGS__), \
403 value, range_min, range_max)); \
406 #define infer(name, value) do { \
407 if (current->name != (value)) { \
408 av_log(ctx->log_ctx, AV_LOG_ERROR, \
409 "%s does not match inferred value: " \
410 "%"PRId64", but should be %"PRId64".\n", \
411 #name, (int64_t)current->name, (int64_t)(value)); \
412 return AVERROR_INVALIDDATA; \
416 #define more_rbsp_data(var) (var)
418 #define bit_position(rw) (put_bits_count(rw))
419 #define byte_alignment(rw) (put_bits_count(rw) % 8)
421 #define allocate(name, size) do { \
423 av_log(ctx->log_ctx, AV_LOG_ERROR, "%s must be set " \
424 "for writing.\n", #name); \
425 return AVERROR_INVALIDDATA; \
429 #define FUNC(name) FUNC_SEI(name)
433 #define FUNC(name) FUNC_H264(name)
437 #define FUNC(name) FUNC_H265(name)
441 #define FUNC(name) FUNC_H266(name)
459 #undef more_rbsp_data
461 #undef byte_alignment
515 size_t size, start, end;
525 version = bytestream2_get_byte(&gbc);
536 count = bytestream2_get_byte(&gbc) & 0x1f;
538 for (
i = 0;
i < count;
i++) {
541 size = bytestream2_get_be16(&gbc);
549 frag->
data + start, end - start,
560 count = bytestream2_get_byte(&gbc);
562 for (
i = 0;
i < count;
i++) {
565 size = bytestream2_get_be16(&gbc);
573 frag->
data + start, end - start,
590 size_t size, start, end;
591 int i, j, nb_arrays, nal_unit_type, nb_nals,
version;
600 version = bytestream2_get_byte(&gbc);
610 nb_arrays = bytestream2_get_byte(&gbc);
611 for (
i = 0;
i < nb_arrays;
i++) {
612 nal_unit_type = bytestream2_get_byte(&gbc) & 0x3f;
613 nb_nals = bytestream2_get_be16(&gbc);
616 for (j = 0; j < nb_nals; j++) {
619 size = bytestream2_get_be16(&gbc);
627 frag->
data + start, end - start,
631 "HVCC array %d (%d NAL units of type %d).\n",
632 i, nb_nals, nal_unit_type);
642 int ptl_present_flag, num_arrays;
649 b = bytestream2_get_byte(&gbc);
651 ptl_present_flag =
b & 1;
653 if(ptl_present_flag) {
654 int num_sublayers, num_bytes_constraint_info, num_sub_profiles;
655 num_sublayers = (bytestream2_get_be16u(&gbc) >> 4) & 7;
659 num_bytes_constraint_info = bytestream2_get_byte(&gbc) & 0x3f;
661 if(num_sublayers > 1) {
662 int count_present_flags = 0;
663 b = bytestream2_get_byte(&gbc);
664 for(
i = num_sublayers - 2;
i >= 0;
i--) {
665 if((
b >> (7 - (num_sublayers - 2 -
i))) & 0x01)
666 count_present_flags++;
670 num_sub_profiles = bytestream2_get_byte(&gbc);
677 num_arrays = bytestream2_get_byte(&gbc);
678 for(j = 0; j < num_arrays; j++) {
679 size_t start, end,
size;
680 int nal_unit_type = bytestream2_get_byte(&gbc) & 0x1f;
681 unsigned int num_nalus = 1;
683 num_nalus = bytestream2_get_be16(&gbc);
686 for(
i = 0;
i < num_nalus;
i++) {
687 size = bytestream2_get_be16(&gbc);
693 frag->
data + start, end - start,
697 "VVCC array %d (%d NAL units of type %d).\n",
698 i, num_nalus, nal_unit_type);
724 #define cbs_h2645_replace_ps(h26n, ps_name, ps_var, id_element) \
725 static int cbs_h26 ## h26n ## _replace_ ## ps_var(CodedBitstreamContext *ctx, \
726 CodedBitstreamUnit *unit) \
728 CodedBitstreamH26 ## h26n ## Context *priv = ctx->priv_data; \
729 H26 ## h26n ## Raw ## ps_name *ps_var = unit->content; \
730 unsigned int id = ps_var->id_element; \
731 int err = ff_cbs_make_unit_refcounted(ctx, unit); \
734 if (priv->ps_var[id] == priv->active_ ## ps_var) \
735 priv->active_ ## ps_var = NULL ; \
736 av_buffer_unref(&priv->ps_var ## _ref[id]); \
737 av_assert0(unit->content_ref); \
738 priv->ps_var ## _ref[id] = av_buffer_ref(unit->content_ref); \
739 if (!priv->ps_var ## _ref[id]) \
740 return AVERROR(ENOMEM); \
741 priv->ps_var[id] = (H26 ## h26n ## Raw ## ps_name *)priv->ps_var ## _ref[id]->data; \
751 #define cbs_h266_replace_ps(h26n, ps_name, ps_var, id_element) \
752 static int cbs_h26 ## h26n ## _replace_ ## ps_var(CodedBitstreamContext *ctx, \
753 CodedBitstreamUnit *unit) \
755 CodedBitstreamH26 ## h26n ## Context *priv = ctx->priv_data; \
756 H26 ## h26n ## Raw ## ps_name *ps_var = unit->content; \
757 unsigned int id = ps_var->id_element; \
758 int err = ff_cbs_make_unit_refcounted(ctx, unit); \
761 av_buffer_unref(&priv->ps_var ## _ref[id]); \
762 av_assert0(unit->content_ref); \
763 priv->ps_var ## _ref[id] = av_buffer_ref(unit->content_ref); \
764 if (!priv->ps_var ## _ref[id]) \
765 return AVERROR(ENOMEM); \
766 priv->ps_var[id] = (H26 ## h26n ## Raw ## ps_name *)priv->ps_var ## _ref[id]->data; \
806 switch (unit->
type) {
811 err = cbs_h264_read_sps(
ctx, &gbc,
sps);
815 err = cbs_h264_replace_sps(
ctx, unit);
823 err = cbs_h264_read_sps_extension(
ctx, &gbc, unit->
content);
833 err = cbs_h264_read_pps(
ctx, &gbc,
pps);
837 err = cbs_h264_replace_pps(
ctx, unit);
850 err = cbs_h264_read_slice_header(
ctx, &gbc, &slice->
header);
871 err = cbs_h264_read_aud(
ctx, &gbc, unit->
content);
879 err = cbs_h264_read_sei(
ctx, &gbc, unit->
content);
887 err = cbs_h264_read_filler(
ctx, &gbc, unit->
content);
897 cbs_h264_read_end_of_sequence :
898 cbs_h264_read_end_of_stream)(
ctx, &gbc, unit->
content);
925 switch (unit->
type) {
930 err = cbs_h265_read_vps(
ctx, &gbc,
vps);
934 err = cbs_h265_replace_vps(
ctx, unit);
943 err = cbs_h265_read_sps(
ctx, &gbc,
sps);
947 err = cbs_h265_replace_sps(
ctx, unit);
957 err = cbs_h265_read_pps(
ctx, &gbc,
pps);
961 err = cbs_h265_replace_pps(
ctx, unit);
987 err = cbs_h265_read_slice_segment_header(
ctx, &gbc, &slice->
header);
1008 err = cbs_h265_read_aud(
ctx, &gbc, unit->
content);
1017 err = cbs_h265_read_sei(
ctx, &gbc, unit->
content,
1046 switch (unit->
type) {
1049 err = cbs_h266_read_dci(
ctx, &gbc, unit->
content);
1057 err = cbs_h266_read_opi(
ctx, &gbc, unit->
content);
1067 err = cbs_h266_read_vps(
ctx, &gbc,
vps);
1071 err = cbs_h266_replace_vps(
ctx, unit);
1080 err = cbs_h266_read_sps(
ctx, &gbc,
sps);
1084 err = cbs_h266_replace_sps(
ctx, unit);
1094 err = cbs_h266_read_pps(
ctx, &gbc,
pps);
1098 err = cbs_h266_replace_pps(
ctx, unit);
1107 err = cbs_h266_read_aps(
ctx, &gbc, unit->
content,
1117 err = cbs_h266_read_ph(
ctx, &gbc,
ph);
1120 err = cbs_h266_replace_ph(
ctx, unit, &
ph->ph_picture_header);
1138 err = cbs_h266_read_slice_header(
ctx, &gbc, &slice->
header);
1165 err = cbs_h266_read_aud(
ctx, &gbc, unit->
content);
1174 err = cbs_h266_read_sei(
ctx, &gbc, unit->
content,
1190 size_t data_size,
int data_bit_start)
1192 size_t rest = data_size - (data_bit_start + 7) / 8;
1193 const uint8_t *
pos =
data + data_bit_start / 8;
1196 data_size > data_bit_start / 8);
1202 goto rbsp_stop_one_bit;
1207 if (data_bit_start % 8)
1208 put_bits(pbc, 8 - data_bit_start % 8,
1225 for (; rest > 4; rest -= 4,
pos += 4)
1228 for (; rest > 1; rest--,
pos++)
1237 i = rest ? (8 -
i) : (8 -
i - data_bit_start % 8);
1252 switch (unit->
type) {
1257 err = cbs_h264_write_sps(
ctx, pbc,
sps);
1261 err = cbs_h264_replace_sps(
ctx, unit);
1271 err = cbs_h264_write_sps_extension(
ctx, pbc, sps_ext);
1281 err = cbs_h264_write_pps(
ctx, pbc,
pps);
1285 err = cbs_h264_replace_pps(
ctx, unit);
1297 err = cbs_h264_write_slice_header(
ctx, pbc, &slice->
header);
1316 err = cbs_h264_write_aud(
ctx, pbc, unit->
content);
1324 err = cbs_h264_write_sei(
ctx, pbc, unit->
content);
1332 err = cbs_h264_write_filler(
ctx, pbc, unit->
content);
1340 err = cbs_h264_write_end_of_sequence(
ctx, pbc, unit->
content);
1348 err = cbs_h264_write_end_of_stream(
ctx, pbc, unit->
content);
1356 "NAL unit type %"PRIu32
".\n", unit->
type);
1369 switch (unit->
type) {
1374 err = cbs_h265_write_vps(
ctx, pbc,
vps);
1378 err = cbs_h265_replace_vps(
ctx, unit);
1388 err = cbs_h265_write_sps(
ctx, pbc,
sps);
1392 err = cbs_h265_replace_sps(
ctx, unit);
1402 err = cbs_h265_write_pps(
ctx, pbc,
pps);
1406 err = cbs_h265_replace_pps(
ctx, unit);
1431 err = cbs_h265_write_slice_segment_header(
ctx, pbc, &slice->
header);
1449 err = cbs_h265_write_aud(
ctx, pbc, unit->
content);
1458 err = cbs_h265_write_sei(
ctx, pbc, unit->
content,
1468 "NAL unit type %"PRIu32
".\n", unit->
type);
1481 int slice_type_i, slice_type_b, slice_type_si;
1501 "h264 nal unit header is null, missing decompose?\n");
1511 "h264 slice header is null, missing decompose?\n");
1536 switch (unit->
type) {
1571 "h265 slice header is null, missing decompose?\n");
1581 switch (unit->
type) {
1606 switch (unit->
type) {
1611 err = cbs_h266_write_dci(
ctx, pbc,
dci);
1620 err = cbs_h266_write_opi(
ctx, pbc,
opi);
1629 err = cbs_h266_write_vps(
ctx, pbc,
vps);
1633 err = cbs_h266_replace_vps(
ctx, unit);
1642 err = cbs_h266_write_sps(
ctx, pbc,
sps);
1646 err = cbs_h266_replace_sps(
ctx, unit);
1656 err = cbs_h266_write_pps(
ctx, pbc,
pps);
1660 err = cbs_h266_replace_pps(
ctx, unit);
1669 err = cbs_h266_write_aps(
ctx, pbc, unit->
content,
1678 err = cbs_h266_write_ph(
ctx, pbc,
ph);
1682 err = cbs_h266_replace_ph(
ctx, unit, &
ph->ph_picture_header);
1699 err = cbs_h266_write_slice_header(
ctx, pbc, &slice->
header);
1723 err = cbs_h266_write_aud(
ctx, pbc, unit->
content);
1732 err = cbs_h266_write_sei(
ctx, pbc, unit->
content,
1742 "NAL unit type %"PRIu32
".\n", unit->
type);
1754 if (nal_unit_index == 0) {
1771 size_t max_size, dp,
sp;
1772 int err,
i, zero_run;
1794 if (i < frag->nb_units - 1)
1796 "unaligned padding on non-final NAL unit.\n");
1818 if ((unit->
data[
sp] & ~3) == 0) {
1822 zero_run = unit->
data[
sp] == 0;
2250 switch (
ctx->codec->codec_id) {
@ SEI_TYPE_ALPHA_CHANNEL_INFO
H265RawVPS * vps[HEVC_MAX_VPS_COUNT]
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.
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.
AVBufferRef * pps_ref[HEVC_MAX_PPS_COUNT]
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
AVBufferRef * sps_ref[HEVC_MAX_SPS_COUNT]
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)
AVBufferRef * sps_ref[VVC_MAX_SPS_COUNT]
H264RawPPS * pps[H264_MAX_PPS_COUNT]
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]
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)
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
AVBufferRef * sps_ref[H264_MAX_SPS_COUNT]
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]
static void cbs_h265_flush(CodedBitstreamContext *ctx)
H266RawVPS * vps[VVC_MAX_VPS_COUNT]
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)
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 void cbs_h265_free_sei(void *opaque, uint8_t *content)
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)
#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)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
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 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
AVBufferRef * vps_ref[HEVC_MAX_VPS_COUNT]
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[]
AVBufferRef * pps_ref[H264_MAX_PPS_COUNT]
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 void cbs_h264_free_sei(void *opaque, uint8_t *content)
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)
H266RawSPS * sps[VVC_MAX_SPS_COUNT]
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 * vps_ref[VVC_MAX_VPS_COUNT]
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
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.
const H265RawSPS * active_sps
#define CBS_UNIT_TYPE_END_OF_LIST
AVBufferRef * content_ref
If content is reference counted, a reference to the buffer containing 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)
static void cbs_h264_close(CodedBitstreamContext *ctx)
H265RawPPS * pps[HEVC_MAX_PPS_COUNT]
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
@ H264_NAL_AUXILIARY_SLICE
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 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 void cbs_h266_free_sei(void *opaque, uint8_t *content)
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[]
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.
AVBufferRef * pps_ref[VVC_MAX_PPS_COUNT]
@ 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]
@ 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)
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()