{
int err;
- u(1, forbidden_zero_bit, 0, 0);
- u(2, nal_ref_idc, 0, 3);
- u(5, nal_unit_type, 0, 31);
+ fixed(1, forbidden_zero_bit, 0);
+ ub(2, nal_ref_idc);
+ ub(5, nal_unit_type);
if (!(1 << current->nal_unit_type & valid_type_mask)) {
av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid NAL unit type %d.\n",
int err, i;
ue(cpb_cnt_minus1, 0, 31);
- u(4, bit_rate_scale, 0, 15);
- u(4, cpb_size_scale, 0, 15);
+ ub(4, bit_rate_scale);
+ ub(4, cpb_size_scale);
for (i = 0; i <= current->cpb_cnt_minus1; i++) {
ues(bit_rate_value_minus1[i], 0, UINT32_MAX - 1, 1, i);
flags(cbr_flag[i], 1, i);
}
- u(5, initial_cpb_removal_delay_length_minus1, 0, 31);
- u(5, cpb_removal_delay_length_minus1, 0, 31);
- u(5, dpb_output_delay_length_minus1, 0, 31);
- u(5, time_offset_length, 0, 31);
+ ub(5, initial_cpb_removal_delay_length_minus1);
+ ub(5, cpb_removal_delay_length_minus1);
+ ub(5, dpb_output_delay_length_minus1);
+ ub(5, time_offset_length);
return 0;
}
flag(aspect_ratio_info_present_flag);
if (current->aspect_ratio_info_present_flag) {
- u(8, aspect_ratio_idc, 0, 255);
+ ub(8, aspect_ratio_idc);
if (current->aspect_ratio_idc == 255) {
- u(16, sar_width, 0, 65535);
- u(16, sar_height, 0, 65535);
+ ub(16, sar_width);
+ ub(16, sar_height);
}
} else {
infer(aspect_ratio_idc, 0);
flag(video_signal_type_present_flag);
if (current->video_signal_type_present_flag) {
- u(3, video_format, 0, 7);
+ ub(3, video_format);
flag(video_full_range_flag);
flag(colour_description_present_flag);
if (current->colour_description_present_flag) {
- u(8, colour_primaries, 0, 255);
- u(8, transfer_characteristics, 0, 255);
- u(8, matrix_coefficients, 0, 255);
+ ub(8, colour_primaries);
+ ub(8, transfer_characteristics);
+ ub(8, matrix_coefficients);
+ } else {
+ infer(colour_primaries, 2);
+ infer(transfer_characteristics, 2);
+ infer(matrix_coefficients, 2);
}
} else {
infer(video_format, 5);
CHECK(FUNC(nal_unit_header)(ctx, rw, ¤t->nal_unit_header,
1 << H264_NAL_SPS));
- u(8, profile_idc, 0, 255);
+ ub(8, profile_idc);
flag(constraint_set0_flag);
flag(constraint_set1_flag);
u(2, reserved_zero_2bits, 0, 0);
- u(8, level_idc, 0, 255);
+ ub(8, level_idc);
ue(seq_parameter_set_id, 0, 31);
flag(alpha_incr_flag);
bits = current->bit_depth_aux_minus8 + 9;
- u(bits, alpha_opaque_value, 0, MAX_UINT_BITS(bits));
- u(bits, alpha_transparent_value, 0, MAX_UINT_BITS(bits));
+ ub(bits, alpha_opaque_value);
+ ub(bits, alpha_transparent_value);
}
flag(additional_extension_flag);
const H264RawSPS *sps;
int err, i, length;
+ HEADER("Buffering Period");
+
ue(seq_parameter_set_id, 0, 31);
sps = h264->sps[current->seq_parameter_set_id];
flag(full_timestamp_flag);
flag(discontinuity_flag);
flag(cnt_dropped_flag);
- u(8, n_frames, 0, 255);
+ ub(8, n_frames);
if (current->full_timestamp_flag) {
u(6, seconds_value, 0, 59);
u(6, minutes_value, 0, 59);
time_offset_length = 24;
if (time_offset_length > 0)
- u(time_offset_length, time_offset,
- 0, MAX_UINT_BITS(time_offset_length));
+ ib(time_offset_length, time_offset);
else
infer(time_offset, 0);
const H264RawSPS *sps;
int err;
+ HEADER("Picture Timing");
+
sps = h264->active_sps;
if (!sps) {
// If there is exactly one possible SPS but it is not yet active
return AVERROR_INVALIDDATA;
}
- u(hrd->cpb_removal_delay_length_minus1 + 1, cpb_removal_delay,
- 0, MAX_UINT_BITS(hrd->cpb_removal_delay_length_minus1 + 1));
- u(hrd->dpb_output_delay_length_minus1 + 1, dpb_output_delay,
- 0, MAX_UINT_BITS(hrd->dpb_output_delay_length_minus1 + 1));
+ ub(hrd->cpb_removal_delay_length_minus1 + 1, cpb_removal_delay);
+ ub(hrd->dpb_output_delay_length_minus1 + 1, dpb_output_delay);
}
if (sps->vui.pic_struct_present_flag) {
- static const int num_clock_ts[9] = {
+ static const uint8_t num_clock_ts[9] = {
1, 1, 1, 2, 2, 3, 3, 2, 3
};
int i;
{
int err, i;
+ HEADER("Pan-Scan Rectangle");
+
ue(pan_scan_rect_id, 0, UINT32_MAX - 1);
flag(pan_scan_rect_cancel_flag);
{
int err, i, j;
+ HEADER("User Data Registered ITU-T T.35");
+
u(8, itu_t_t35_country_code, 0x00, 0xff);
if (current->itu_t_t35_country_code != 0xff)
i = 1;
{
int err, i;
+ HEADER("User Data Unregistered");
+
#ifdef READ
if (*payload_size < 16) {
av_log(ctx->log_ctx, AV_LOG_ERROR,
{
int err;
+ HEADER("Recovery Point");
+
ue(recovery_frame_cnt, 0, 65535);
flag(exact_match_flag);
flag(broken_link_flag);
{
int err;
+ HEADER("Display Orientation");
+
flag(display_orientation_cancel_flag);
if (!current->display_orientation_cancel_flag) {
flag(hor_flip);
flag(ver_flip);
- u(16, anticlockwise_rotation, 0, 65535);
+ ub(16, anticlockwise_rotation);
ue(display_orientation_repetition_period, 0, 16384);
flag(display_orientation_extension_flag);
}
{
int err, c;
+ HEADER("Mastering Display Colour Volume");
+
for (c = 0; c < 3; c++) {
us(16, display_primaries_x[c], 0, 50000, 1, c);
us(16, display_primaries_y[c], 0, 50000, 1, c);
return 0;
}
+static int FUNC(sei_alternative_transfer_characteristics)(CodedBitstreamContext *ctx,
+ RWContext *rw,
+ H264RawSEIAlternativeTransferCharacteristics *current)
+{
+ int err;
+
+ HEADER("Alternative Transfer Characteristics");
+
+ ub(8, preferred_transfer_characteristics);
+
+ return 0;
+}
+
static int FUNC(sei_payload)(CodedBitstreamContext *ctx, RWContext *rw,
H264RawSEIPayload *current)
{
CHECK(FUNC(sei_mastering_display_colour_volume)
(ctx, rw, ¤t->payload.mastering_display_colour_volume));
break;
+ case H264_SEI_TYPE_ALTERNATIVE_TRANSFER:
+ CHECK(FUNC(sei_alternative_transfer_characteristics)
+ (ctx, rw, ¤t->payload.alternative_transfer_characteristics));
+ break;
default:
{
#ifdef READ
current->payload[k].payload_type = payload_type;
current->payload[k].payload_size = payload_size;
+ current->payload_count++;
CHECK(FUNC(sei_payload)(ctx, rw, ¤t->payload[k]));
if (!cbs_h2645_read_more_rbsp_data(rw))
"SEI message: found %d.\n", k);
return AVERROR_INVALIDDATA;
}
- current->payload_count = k + 1;
#else
for (k = 0; k < current->payload_count; k++) {
PutBitContext start_state;
CHECK(FUNC(nal_unit_header)(ctx, rw, ¤t->nal_unit_header,
1 << H264_NAL_AUD));
- u(3, primary_pic_type, 0, 7);
+ ub(3, primary_pic_type);
CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
"in the same access unit.\n");
return AVERROR_INVALIDDATA;
}
+ idr_pic_flag = h264->last_slice_nal_unit_type == H264_NAL_IDR_SLICE;
} else {
- h264->last_slice_nal_unit_type =
- current->nal_unit_header.nal_unit_type;
+ idr_pic_flag = current->nal_unit_header.nal_unit_type == H264_NAL_IDR_SLICE;
}
- idr_pic_flag = h264->last_slice_nal_unit_type == H264_NAL_IDR_SLICE;
ue(first_mb_in_slice, 0, H264_MAX_MB_PIC_SIZE - 1);
ue(slice_type, 0, 9);
if (sps->separate_colour_plane_flag)
u(2, colour_plane_id, 0, 2);
- u(sps->log2_max_frame_num_minus4 + 4, frame_num,
- 0, MAX_UINT_BITS(sps->log2_max_frame_num_minus4 + 4));
+ ub(sps->log2_max_frame_num_minus4 + 4, frame_num);
if (!sps->frame_mbs_only_flag) {
flag(field_pic_flag);
ue(idr_pic_id, 0, 65535);
if (sps->pic_order_cnt_type == 0) {
- u(sps->log2_max_pic_order_cnt_lsb_minus4 + 4, pic_order_cnt_lsb,
- 0, MAX_UINT_BITS(sps->log2_max_pic_order_cnt_lsb_minus4 + 4));
+ ub(sps->log2_max_pic_order_cnt_lsb_minus4 + 4, pic_order_cnt_lsb);
if (pps->bottom_field_pic_order_in_frame_present_flag &&
!current->field_pic_flag)
se(delta_pic_order_cnt_bottom, INT32_MIN + 1, INT32_MAX);
if (pps->redundant_pic_cnt_present_flag)
ue(redundant_pic_cnt, 0, 127);
+ else
+ infer(redundant_pic_cnt, 0);
+
+ if (current->nal_unit_header.nal_unit_type != H264_NAL_AUXILIARY_SLICE
+ && !current->redundant_pic_cnt)
+ h264->last_slice_nal_unit_type =
+ current->nal_unit_header.nal_unit_type;
if (slice_type_b)
flag(direct_spatial_mv_pred_flag);
(sps->pic_height_in_map_units_minus1 + 1);
max = (pic_size + pps->slice_group_change_rate_minus1) /
(pps->slice_group_change_rate_minus1 + 1);
- bits = av_log2(2 * max - 1);
+ bits = av_ceil_log2(max + 1);
u(bits, slice_group_change_cycle, 0, max);
}
projects / ffmpeg / blobdiff