/*
- * This file is part of Libav.
+ * This file is part of FFmpeg.
*
- * Libav is free software; you can redistribute it and/or
+ * FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
- * Libav is distributed in the hope that it will be useful,
+ * FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with Libav; if not, write to the Free Software
+ * License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
static int FUNC(rbsp_trailing_bits)(CodedBitstreamContext *ctx, RWContext *rw)
{
int err;
- av_unused int one = 1, zero = 0;
- xu(1, rbsp_stop_one_bit, one, 1, 1);
+
+ fixed(1, rbsp_stop_one_bit, 1);
while (byte_alignment(rw) != 0)
- xu(1, rbsp_alignment_zero_bit, zero, 0, 0);
+ fixed(1, rbsp_alignment_zero_bit, 0);
return 0;
}
scale = 8;
for (i = 0; i < size_of_scaling_list; i++) {
- xse(delta_scale, current->delta_scale[i], -128, +127);
+ ses(delta_scale[i], -128, +127, 1, i);
scale = (scale + current->delta_scale[i] + 256) % 256;
if (scale == 0)
break;
u(4, cpb_size_scale, 0, 15);
for (i = 0; i <= current->cpb_cnt_minus1; i++) {
- ue(bit_rate_value_minus1[i], 0, UINT32_MAX - 1);
- ue(cpb_size_value_minus1[i], 0, UINT32_MAX - 1);
- flag(cbr_flag[i]);
+ ues(bit_rate_value_minus1[i], 0, UINT32_MAX - 1, 1, i);
+ ues(cpb_size_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);
flag(seq_scaling_matrix_present_flag);
if (current->seq_scaling_matrix_present_flag) {
for (i = 0; i < ((current->chroma_format_idc != 3) ? 8 : 12); i++) {
- flag(seq_scaling_list_present_flag[i]);
+ flags(seq_scaling_list_present_flag[i], 1, i);
if (current->seq_scaling_list_present_flag[i]) {
if (i < 6)
CHECK(FUNC(scaling_list)(ctx, rw,
ue(num_ref_frames_in_pic_order_cnt_cycle, 0, 255);
for (i = 0; i < current->num_ref_frames_in_pic_order_cnt_cycle; i++)
- se(offset_for_ref_frame[i], INT32_MIN + 1, INT32_MAX);
+ ses(offset_for_ref_frame[i], INT32_MIN + 1, INT32_MAX, 1, i);
}
ue(max_num_ref_frames, 0, H264_MAX_DPB_FRAMES);
flag(alpha_incr_flag);
bits = current->bit_depth_aux_minus8 + 9;
- u(bits, alpha_opaque_value, 0, (1 << bits) - 1);
- u(bits, alpha_transparent_value, 0, (1 << bits) - 1);
+ u(bits, alpha_opaque_value, 0, MAX_UINT_BITS(bits));
+ u(bits, alpha_transparent_value, 0, MAX_UINT_BITS(bits));
}
flag(additional_extension_flag);
if (current->slice_group_map_type == 0) {
for (iGroup = 0; iGroup <= current->num_slice_groups_minus1; iGroup++)
- ue(run_length_minus1[iGroup], 0, pic_size - 1);
+ ues(run_length_minus1[iGroup], 0, pic_size - 1, 1, iGroup);
} else if (current->slice_group_map_type == 2) {
for (iGroup = 0; iGroup < current->num_slice_groups_minus1; iGroup++) {
- ue(top_left[iGroup], 0, pic_size - 1);
- ue(bottom_right[iGroup], current->top_left[iGroup], pic_size - 1);
+ ues(top_left[iGroup], 0, pic_size - 1, 1, iGroup);
+ ues(bottom_right[iGroup],
+ current->top_left[iGroup], pic_size - 1, 1, iGroup);
}
} else if (current->slice_group_map_type == 3 ||
current->slice_group_map_type == 4 ||
allocate(current->slice_group_id,
current->pic_size_in_map_units_minus1 + 1);
for (i = 0; i <= current->pic_size_in_map_units_minus1; i++)
- u(av_log2(2 * current->num_slice_groups_minus1 + 1),
- slice_group_id[i], 0, current->num_slice_groups_minus1);
+ us(av_log2(2 * current->num_slice_groups_minus1 + 1),
+ slice_group_id[i], 0, current->num_slice_groups_minus1, 1, i);
}
}
if (current->pic_scaling_matrix_present_flag) {
for (i = 0; i < 6 + (((sps->chroma_format_idc != 3) ? 2 : 6) *
current->transform_8x8_mode_flag); i++) {
- flag(pic_scaling_list_present_flag[i]);
+ flags(pic_scaling_list_present_flag[i], 1, i);
if (current->pic_scaling_list_present_flag[i]) {
if (i < 6)
CHECK(FUNC(scaling_list)(ctx, rw,
length = sps->vui.nal_hrd_parameters.initial_cpb_removal_delay_length_minus1 + 1;
xu(length, initial_cpb_removal_delay[SchedSelIdx],
current->nal.initial_cpb_removal_delay[i],
- 0, (1 << (uint64_t)length) - 1);
+ 1, MAX_UINT_BITS(length), 1, i);
xu(length, initial_cpb_removal_delay_offset[SchedSelIdx],
current->nal.initial_cpb_removal_delay_offset[i],
- 0, (1 << (uint64_t)length) - 1);
+ 0, MAX_UINT_BITS(length), 1, i);
}
}
length = sps->vui.vcl_hrd_parameters.initial_cpb_removal_delay_length_minus1 + 1;
xu(length, initial_cpb_removal_delay[SchedSelIdx],
current->vcl.initial_cpb_removal_delay[i],
- 0, (1 << (uint64_t)length) - 1);
+ 1, MAX_UINT_BITS(length), 1, i);
xu(length, initial_cpb_removal_delay_offset[SchedSelIdx],
current->vcl.initial_cpb_removal_delay_offset[i],
- 0, (1 << (uint64_t)length) - 1);
+ 0, MAX_UINT_BITS(length), 1, i);
}
}
if (time_offset_length > 0)
u(time_offset_length, time_offset,
- 0, (1 << (uint64_t)time_offset_length) - 1);
+ 0, MAX_UINT_BITS(time_offset_length));
else
infer(time_offset, 0);
}
u(hrd->cpb_removal_delay_length_minus1 + 1, cpb_removal_delay,
- 0, (1 << (uint64_t)hrd->cpb_removal_delay_length_minus1) + 1);
+ 0, MAX_UINT_BITS(hrd->cpb_removal_delay_length_minus1 + 1));
u(hrd->dpb_output_delay_length_minus1 + 1, dpb_output_delay,
- 0, (1 << (uint64_t)hrd->dpb_output_delay_length_minus1) + 1);
+ 0, MAX_UINT_BITS(hrd->dpb_output_delay_length_minus1 + 1));
}
if (sps->vui.pic_struct_present_flag) {
return AVERROR_INVALIDDATA;
for (i = 0; i < num_clock_ts[current->pic_struct]; i++) {
- flag(clock_timestamp_flag[i]);
+ flags(clock_timestamp_flag[i], 1, i);
if (current->clock_timestamp_flag[i])
CHECK(FUNC(sei_pic_timestamp)(ctx, rw, ¤t->timestamp[i]));
}
return 0;
}
+static int FUNC(sei_pan_scan_rect)(CodedBitstreamContext *ctx, RWContext *rw,
+ H264RawSEIPanScanRect *current)
+{
+ int err, i;
+
+ ue(pan_scan_rect_id, 0, UINT32_MAX - 1);
+ flag(pan_scan_rect_cancel_flag);
+
+ if (!current->pan_scan_rect_cancel_flag) {
+ ue(pan_scan_cnt_minus1, 0, 2);
+
+ for (i = 0; i <= current->pan_scan_cnt_minus1; i++) {
+ ses(pan_scan_rect_left_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
+ ses(pan_scan_rect_right_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
+ ses(pan_scan_rect_top_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
+ ses(pan_scan_rect_bottom_offset[i], INT32_MIN + 1, INT32_MAX, 1, i);
+ }
+
+ ue(pan_scan_rect_repetition_period, 0, 16384);
+ }
+
+ return 0;
+}
+
static int FUNC(sei_user_data_registered)(CodedBitstreamContext *ctx, RWContext *rw,
H264RawSEIUserDataRegistered *current,
uint32_t *payload_size)
allocate(current->data, current->data_length);
for (j = 0; j < current->data_length; j++)
- xu(8, itu_t_t35_payload_byte, current->data[j], 0x00, 0xff);
+ xu(8, itu_t_t35_payload_byte[i], current->data[j], 0x00, 0xff, 1, i + j);
return 0;
}
*payload_size = 16 + current->data_length;
#endif
- for (i = 0; i < 16; i++) {
- xu(8, uuid_iso_iec_11578,
- current->uuid_iso_iec_11578[i], 0x00, 0xff);
- }
+ for (i = 0; i < 16; i++)
+ us(8, uuid_iso_iec_11578[i], 0x00, 0xff, 1, i);
allocate(current->data, current->data_length);
for (i = 0; i < current->data_length; i++)
- xu(8, user_data_payload_byte, current->data[i], 0x00, 0xff);
+ xu(8, user_data_payload_byte[i], current->data[i], 0x00, 0xff, 1, i);
return 0;
}
return 0;
}
+static int FUNC(sei_mastering_display_colour_volume)(CodedBitstreamContext *ctx, RWContext *rw,
+ H264RawSEIMasteringDisplayColourVolume *current)
+{
+ int err, c;
+
+ 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);
+ }
+
+ u(16, white_point_x, 0, 50000);
+ u(16, white_point_y, 0, 50000);
+
+ u(32, max_display_mastering_luminance, 1, MAX_UINT_BITS(32));
+ u(32, min_display_mastering_luminance, 0, current->max_display_mastering_luminance - 1);
+
+ return 0;
+}
+
static int FUNC(sei_payload)(CodedBitstreamContext *ctx, RWContext *rw,
H264RawSEIPayload *current)
{
int start_position, end_position;
#ifdef READ
- start_position = bitstream_tell(rw);
+ start_position = get_bits_count(rw);
#else
start_position = put_bits_count(rw);
#endif
CHECK(FUNC(sei_pic_timing)
(ctx, rw, ¤t->payload.pic_timing));
break;
+ case H264_SEI_TYPE_PAN_SCAN_RECT:
+ CHECK(FUNC(sei_pan_scan_rect)
+ (ctx, rw, ¤t->payload.pan_scan_rect));
+ break;
case H264_SEI_TYPE_FILLER_PAYLOAD:
{
- av_unused int ff_byte = 0xff;
for (i = 0; i < current->payload_size; i++)
- xu(8, ff_byte, ff_byte, 0xff, 0xff);
+ fixed(8, ff_byte, 0xff);
}
break;
case H264_SEI_TYPE_USER_DATA_REGISTERED:
CHECK(FUNC(sei_display_orientation)
(ctx, rw, ¤t->payload.display_orientation));
break;
+ case H264_SEI_TYPE_MASTERING_DISPLAY_COLOUR_VOLUME:
+ CHECK(FUNC(sei_mastering_display_colour_volume)
+ (ctx, rw, ¤t->payload.mastering_display_colour_volume));
+ break;
default:
{
- allocate(current->payload.other.data, current->payload_size);
- for (i = 0; i < current->payload_size; i++)
- xu(8, payload_byte, current->payload.other.data[i], 0, 255);
+#ifdef READ
+ current->payload.other.data_length = current->payload_size;
+#endif
+ allocate(current->payload.other.data, current->payload.other.data_length);
+ for (i = 0; i < current->payload.other.data_length; i++)
+ xu(8, payload_byte[i], current->payload.other.data[i], 0, 255, 1, i);
}
}
if (byte_alignment(rw)) {
- av_unused int one = 1, zero = 0;
- xu(1, bit_equal_to_one, one, 1, 1);
+ fixed(1, bit_equal_to_one, 1);
while (byte_alignment(rw))
- xu(1, bit_equal_to_zero, zero, 0, 0);
+ fixed(1, bit_equal_to_zero, 0);
}
#ifdef READ
- end_position = bitstream_tell(rw);
+ end_position = get_bits_count(rw);
if (end_position < start_position + 8 * current->payload_size) {
av_log(ctx->log_ctx, AV_LOG_ERROR, "Incorrect SEI payload length: "
- "header %d bits, actually %d bits.\n",
+ "header %"PRIu32" bits, actually %d bits.\n",
8 * current->payload_size,
end_position - start_position);
return AVERROR_INVALIDDATA;
uint32_t payload_size = 0;
uint32_t tmp;
- while (bitstream_peek(rw, 8) == 0xff) {
- xu(8, ff_byte, tmp, 0xff, 0xff);
+ while (show_bits(rw, 8) == 0xff) {
+ fixed(8, ff_byte, 0xff);
payload_type += 255;
}
- xu(8, last_payload_type_byte, tmp, 0, 254);
+ xu(8, last_payload_type_byte, tmp, 0, 254, 0);
payload_type += tmp;
- while (bitstream_peek(rw, 8) == 0xff) {
- xu(8, ff_byte, tmp, 0xff, 0xff);
+ while (show_bits(rw, 8) == 0xff) {
+ fixed(8, ff_byte, 0xff);
payload_size += 255;
}
- xu(8, last_payload_size_byte, tmp, 0, 254);
+ xu(8, last_payload_size_byte, tmp, 0, 254, 0);
payload_size += tmp;
current->payload[k].payload_type = payload_type;
tmp = current->payload[k].payload_type;
while (tmp >= 255) {
- xu(8, ff_byte, 0xff, 0xff, 0xff);
+ fixed(8, ff_byte, 0xff);
tmp -= 255;
}
- xu(8, last_payload_type_byte, tmp, 0, 254);
+ xu(8, last_payload_type_byte, tmp, 0, 254, 0);
tmp = current->payload[k].payload_size;
while (tmp >= 255) {
- xu(8, ff_byte, 0xff, 0xff, 0xff);
+ fixed(8, ff_byte, 0xff);
tmp -= 255;
}
- xu(8, last_payload_size_byte, tmp, 0, 254);
+ xu(8, last_payload_size_byte, tmp, 0, 254, 0);
CHECK(FUNC(sei_payload)(ctx, rw, ¤t->payload[k]));
}
if (current->ref_pic_list_modification_flag_l0) {
for (i = 0; i < H264_MAX_RPLM_COUNT; i++) {
xue(modification_of_pic_nums_idc,
- current->rplm_l0[i].modification_of_pic_nums_idc, 0, 3);
+ current->rplm_l0[i].modification_of_pic_nums_idc, 0, 3, 0);
mopn = current->rplm_l0[i].modification_of_pic_nums_idc;
if (mopn == 3)
xue(abs_diff_pic_num_minus1,
current->rplm_l0[i].abs_diff_pic_num_minus1,
0, (1 + current->field_pic_flag) *
- (1 << (sps->log2_max_frame_num_minus4 + 4)));
+ (1 << (sps->log2_max_frame_num_minus4 + 4)), 0);
else if (mopn == 2)
xue(long_term_pic_num,
current->rplm_l0[i].long_term_pic_num,
- 0, sps->max_num_ref_frames - 1);
+ 0, sps->max_num_ref_frames - 1, 0);
}
}
}
if (current->ref_pic_list_modification_flag_l1) {
for (i = 0; i < H264_MAX_RPLM_COUNT; i++) {
xue(modification_of_pic_nums_idc,
- current->rplm_l1[i].modification_of_pic_nums_idc, 0, 3);
+ current->rplm_l1[i].modification_of_pic_nums_idc, 0, 3, 0);
mopn = current->rplm_l1[i].modification_of_pic_nums_idc;
if (mopn == 3)
xue(abs_diff_pic_num_minus1,
current->rplm_l1[i].abs_diff_pic_num_minus1,
0, (1 + current->field_pic_flag) *
- (1 << (sps->log2_max_frame_num_minus4 + 4)));
+ (1 << (sps->log2_max_frame_num_minus4 + 4)), 0);
else if (mopn == 2)
xue(long_term_pic_num,
current->rplm_l1[i].long_term_pic_num,
- 0, sps->max_num_ref_frames - 1);
+ 0, sps->max_num_ref_frames - 1, 0);
}
}
}
ue(chroma_log2_weight_denom, 0, 7);
for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++) {
- flag(luma_weight_l0_flag[i]);
+ flags(luma_weight_l0_flag[i], 1, i);
if (current->luma_weight_l0_flag[i]) {
- se(luma_weight_l0[i], -128, +127);
- se(luma_offset_l0[i], -128, +127);
+ ses(luma_weight_l0[i], -128, +127, 1, i);
+ ses(luma_offset_l0[i], -128, +127, 1, i);
}
if (chroma) {
- flag(chroma_weight_l0_flag[i]);
+ flags(chroma_weight_l0_flag[i], 1, i);
if (current->chroma_weight_l0_flag[i]) {
for (j = 0; j < 2; j++) {
- se(chroma_weight_l0[i][j], -128, +127);
- se(chroma_offset_l0[i][j], -128, +127);
+ ses(chroma_weight_l0[i][j], -128, +127, 2, i, j);
+ ses(chroma_offset_l0[i][j], -128, +127, 2, i, j);
}
}
}
if (current->slice_type % 5 == 1) {
for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++) {
- flag(luma_weight_l1_flag[i]);
+ flags(luma_weight_l1_flag[i], 1, i);
if (current->luma_weight_l1_flag[i]) {
- se(luma_weight_l1[i], -128, +127);
- se(luma_offset_l1[i], -128, +127);
+ ses(luma_weight_l1[i], -128, +127, 1, i);
+ ses(luma_offset_l1[i], -128, +127, 1, i);
}
if (chroma) {
- flag(chroma_weight_l1_flag[i]);
+ flags(chroma_weight_l1_flag[i], 1, i);
if (current->chroma_weight_l1_flag[i]) {
for (j = 0; j < 2; j++) {
- se(chroma_weight_l1[i][j], -128, +127);
- se(chroma_offset_l1[i][j], -128, +127);
+ ses(chroma_weight_l1[i][j], -128, +127, 2, i, j);
+ ses(chroma_offset_l1[i][j], -128, +127, 2, i, j);
}
}
}
for (i = 0; i < H264_MAX_MMCO_COUNT; i++) {
xue(memory_management_control_operation,
current->mmco[i].memory_management_control_operation,
- 0, 6);
+ 0, 6, 0);
mmco = current->mmco[i].memory_management_control_operation;
if (mmco == 0)
if (mmco == 1 || mmco == 3)
xue(difference_of_pic_nums_minus1,
current->mmco[i].difference_of_pic_nums_minus1,
- 0, INT32_MAX);
+ 0, INT32_MAX, 0);
if (mmco == 2)
xue(long_term_pic_num,
current->mmco[i].long_term_pic_num,
- 0, sps->max_num_ref_frames - 1);
+ 0, sps->max_num_ref_frames - 1, 0);
if (mmco == 3 || mmco == 6)
xue(long_term_frame_idx,
current->mmco[i].long_term_frame_idx,
- 0, sps->max_num_ref_frames - 1);
+ 0, sps->max_num_ref_frames - 1, 0);
if (mmco == 4)
xue(max_long_term_frame_idx_plus1,
current->mmco[i].max_long_term_frame_idx_plus1,
- 0, sps->max_num_ref_frames);
+ 0, sps->max_num_ref_frames, 0);
}
if (i == H264_MAX_MMCO_COUNT) {
av_log(ctx->log_ctx, AV_LOG_ERROR, "Too many "
u(2, colour_plane_id, 0, 2);
u(sps->log2_max_frame_num_minus4 + 4, frame_num,
- 0, (1 << (sps->log2_max_frame_num_minus4 + 4)) - 1);
+ 0, MAX_UINT_BITS(sps->log2_max_frame_num_minus4 + 4));
if (!sps->frame_mbs_only_flag) {
flag(field_pic_flag);
if (sps->pic_order_cnt_type == 0) {
u(sps->log2_max_pic_order_cnt_lsb_minus4 + 4, pic_order_cnt_lsb,
- 0, (1 << (sps->log2_max_pic_order_cnt_lsb_minus4 + 4)) - 1);
+ 0, MAX_UINT_BITS(sps->log2_max_pic_order_cnt_lsb_minus4 + 4));
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->entropy_coding_mode_flag) {
- av_unused int one = 1;
while (byte_alignment(rw))
- xu(1, cabac_alignment_one_bit, one, 1, 1);
+ fixed(1, cabac_alignment_one_bit, 1);
}
return 0;
static int FUNC(filler)(CodedBitstreamContext *ctx, RWContext *rw,
H264RawFiller *current)
{
- av_unused int ff_byte = 0xff;
int err;
HEADER("Filler Data");
1 << H264_NAL_FILLER_DATA));
#ifdef READ
- while (bitstream_peek(rw, 8) == 0xff) {
- xu(8, ff_byte, ff_byte, 0xff, 0xff);
+ while (show_bits(rw, 8) == 0xff) {
+ fixed(8, ff_byte, 0xff);
++current->filler_size;
}
#else
{
uint32_t i;
for (i = 0; i < current->filler_size; i++)
- xu(8, ff_byte, ff_byte, 0xff, 0xff);
+ fixed(8, ff_byte, 0xff);
}
#endif
projects / ffmpeg / blobdiff