diff options
Diffstat (limited to 'isoparser/src/main/java/com/googlecode/mp4parser/h264/model/.svn/text-base/SeqParameterSet.java.svn-base')
| -rw-r--r-- | isoparser/src/main/java/com/googlecode/mp4parser/h264/model/.svn/text-base/SeqParameterSet.java.svn-base | 556 |
1 files changed, 556 insertions, 0 deletions
diff --git a/isoparser/src/main/java/com/googlecode/mp4parser/h264/model/.svn/text-base/SeqParameterSet.java.svn-base b/isoparser/src/main/java/com/googlecode/mp4parser/h264/model/.svn/text-base/SeqParameterSet.java.svn-base new file mode 100644 index 0000000..4894df8 --- /dev/null +++ b/isoparser/src/main/java/com/googlecode/mp4parser/h264/model/.svn/text-base/SeqParameterSet.java.svn-base @@ -0,0 +1,556 @@ +/* +Copyright (c) 2011 Stanislav Vitvitskiy + +Permission is hereby granted, free of charge, to any person obtaining a copy of this +software and associated documentation files (the "Software"), to deal in the Software +without restriction, including without limitation the rights to use, copy, modify, +merge, publish, distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice shall be included in all copies or +substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +OR OTHER DEALINGS IN THE SOFTWARE. +*/ +package com.googlecode.mp4parser.h264.model; + +import com.googlecode.mp4parser.h264.read.CAVLCReader; +import com.googlecode.mp4parser.h264.write.CAVLCWriter; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; + +/** + * Sequence Parameter Set structure of h264 bitstream + * <p/> + * capable to serialize and deserialize with CAVLC bitstream + * + * @author Stanislav Vitvitskiy + */ +public class SeqParameterSet extends BitstreamElement { + public int pic_order_cnt_type; + public boolean field_pic_flag; + public boolean delta_pic_order_always_zero_flag; + public boolean weighted_pred_flag; + public int weighted_bipred_idc; + public boolean entropy_coding_mode_flag; + public boolean mb_adaptive_frame_field_flag; + public boolean direct_8x8_inference_flag; + public ChromaFormat chroma_format_idc; + public int log2_max_frame_num_minus4; + public int log2_max_pic_order_cnt_lsb_minus4; + public int pic_height_in_map_units_minus1; + public int pic_width_in_mbs_minus1; + public int bit_depth_luma_minus8; + public int bit_depth_chroma_minus8; + public boolean qpprime_y_zero_transform_bypass_flag; + public int profile_idc; + public boolean constraint_set_0_flag; + public boolean constraint_set_1_flag; + public boolean constraint_set_2_flag; + public boolean constraint_set_3_flag; + public int level_idc; + public int seq_parameter_set_id; + public boolean residual_color_transform_flag; + public int offset_for_non_ref_pic; + public int offset_for_top_to_bottom_field; + public int num_ref_frames; + public boolean gaps_in_frame_num_value_allowed_flag; + public boolean frame_mbs_only_flag; + public boolean frame_cropping_flag; + public int frame_crop_left_offset; + public int frame_crop_right_offset; + public int frame_crop_top_offset; + public int frame_crop_bottom_offset; + public int[] offsetForRefFrame; + public VUIParameters vuiParams; + public ScalingMatrix scalingMatrix; + public int num_ref_frames_in_pic_order_cnt_cycle; + + public static SeqParameterSet read(InputStream is) throws IOException { + CAVLCReader reader = new CAVLCReader(is); + SeqParameterSet sps = new SeqParameterSet(); + + sps.profile_idc = (int) reader.readNBit(8, "SPS: profile_idc"); + sps.constraint_set_0_flag = reader + .readBool("SPS: constraint_set_0_flag"); + sps.constraint_set_1_flag = reader + .readBool("SPS: constraint_set_1_flag"); + sps.constraint_set_2_flag = reader + .readBool("SPS: constraint_set_2_flag"); + sps.constraint_set_3_flag = reader + .readBool("SPS: constraint_set_3_flag"); + reader.readNBit(4, "SPS: reserved_zero_4bits"); + sps.level_idc = (int) reader.readNBit(8, "SPS: level_idc"); + sps.seq_parameter_set_id = reader.readUE("SPS: seq_parameter_set_id"); + + if (sps.profile_idc == 100 || sps.profile_idc == 110 + || sps.profile_idc == 122 || sps.profile_idc == 144) { + sps.chroma_format_idc = ChromaFormat.fromId(reader + .readUE("SPS: chroma_format_idc")); + if (sps.chroma_format_idc == ChromaFormat.YUV_444) { + sps.residual_color_transform_flag = reader + .readBool("SPS: residual_color_transform_flag"); + } + sps.bit_depth_luma_minus8 = reader + .readUE("SPS: bit_depth_luma_minus8"); + sps.bit_depth_chroma_minus8 = reader + .readUE("SPS: bit_depth_chroma_minus8"); + sps.qpprime_y_zero_transform_bypass_flag = reader + .readBool("SPS: qpprime_y_zero_transform_bypass_flag"); + boolean seqScalingMatrixPresent = reader + .readBool("SPS: seq_scaling_matrix_present_lag"); + if (seqScalingMatrixPresent) { + readScalingListMatrix(reader, sps); + } + } else { + sps.chroma_format_idc = ChromaFormat.YUV_420; + } + sps.log2_max_frame_num_minus4 = reader + .readUE("SPS: log2_max_frame_num_minus4"); + sps.pic_order_cnt_type = reader.readUE("SPS: pic_order_cnt_type"); + if (sps.pic_order_cnt_type == 0) { + sps.log2_max_pic_order_cnt_lsb_minus4 = reader + .readUE("SPS: log2_max_pic_order_cnt_lsb_minus4"); + } else if (sps.pic_order_cnt_type == 1) { + sps.delta_pic_order_always_zero_flag = reader + .readBool("SPS: delta_pic_order_always_zero_flag"); + sps.offset_for_non_ref_pic = reader + .readSE("SPS: offset_for_non_ref_pic"); + sps.offset_for_top_to_bottom_field = reader + .readSE("SPS: offset_for_top_to_bottom_field"); + sps.num_ref_frames_in_pic_order_cnt_cycle = reader + .readUE("SPS: num_ref_frames_in_pic_order_cnt_cycle"); + sps.offsetForRefFrame = new int[sps.num_ref_frames_in_pic_order_cnt_cycle]; + for (int i = 0; i < sps.num_ref_frames_in_pic_order_cnt_cycle; i++) { + sps.offsetForRefFrame[i] = reader + .readSE("SPS: offsetForRefFrame [" + i + "]"); + } + } + sps.num_ref_frames = reader.readUE("SPS: num_ref_frames"); + sps.gaps_in_frame_num_value_allowed_flag = reader + .readBool("SPS: gaps_in_frame_num_value_allowed_flag"); + sps.pic_width_in_mbs_minus1 = reader + .readUE("SPS: pic_width_in_mbs_minus1"); + sps.pic_height_in_map_units_minus1 = reader + .readUE("SPS: pic_height_in_map_units_minus1"); + sps.frame_mbs_only_flag = reader.readBool("SPS: frame_mbs_only_flag"); + if (!sps.frame_mbs_only_flag) { + sps.mb_adaptive_frame_field_flag = reader + .readBool("SPS: mb_adaptive_frame_field_flag"); + } + sps.direct_8x8_inference_flag = reader + .readBool("SPS: direct_8x8_inference_flag"); + sps.frame_cropping_flag = reader.readBool("SPS: frame_cropping_flag"); + if (sps.frame_cropping_flag) { + sps.frame_crop_left_offset = reader + .readUE("SPS: frame_crop_left_offset"); + sps.frame_crop_right_offset = reader + .readUE("SPS: frame_crop_right_offset"); + sps.frame_crop_top_offset = reader + .readUE("SPS: frame_crop_top_offset"); + sps.frame_crop_bottom_offset = reader + .readUE("SPS: frame_crop_bottom_offset"); + } + boolean vui_parameters_present_flag = reader + .readBool("SPS: vui_parameters_present_flag"); + if (vui_parameters_present_flag) + sps.vuiParams = ReadVUIParameters(reader); + + reader.readTrailingBits(); + + return sps; + } + + private static void readScalingListMatrix(CAVLCReader reader, + SeqParameterSet sps) throws IOException { + sps.scalingMatrix = new ScalingMatrix(); + for (int i = 0; i < 8; i++) { + boolean seqScalingListPresentFlag = reader + .readBool("SPS: seqScalingListPresentFlag"); + if (seqScalingListPresentFlag) { + sps.scalingMatrix.ScalingList4x4 = new ScalingList[8]; + sps.scalingMatrix.ScalingList8x8 = new ScalingList[8]; + if (i < 6) { + sps.scalingMatrix.ScalingList4x4[i] = ScalingList.read( + reader, 16); + } else { + sps.scalingMatrix.ScalingList8x8[i - 6] = ScalingList.read( + reader, 64); + } + } + } + } + + private static VUIParameters ReadVUIParameters(CAVLCReader reader) + throws IOException { + VUIParameters vuip = new VUIParameters(); + vuip.aspect_ratio_info_present_flag = reader + .readBool("VUI: aspect_ratio_info_present_flag"); + if (vuip.aspect_ratio_info_present_flag) { + vuip.aspect_ratio = AspectRatio.fromValue((int) reader.readNBit(8, + "VUI: aspect_ratio")); + if (vuip.aspect_ratio == AspectRatio.Extended_SAR) { + vuip.sar_width = (int) reader.readNBit(16, "VUI: sar_width"); + vuip.sar_height = (int) reader.readNBit(16, "VUI: sar_height"); + } + } + vuip.overscan_info_present_flag = reader + .readBool("VUI: overscan_info_present_flag"); + if (vuip.overscan_info_present_flag) { + vuip.overscan_appropriate_flag = reader + .readBool("VUI: overscan_appropriate_flag"); + } + vuip.video_signal_type_present_flag = reader + .readBool("VUI: video_signal_type_present_flag"); + if (vuip.video_signal_type_present_flag) { + vuip.video_format = (int) reader.readNBit(3, "VUI: video_format"); + vuip.video_full_range_flag = reader + .readBool("VUI: video_full_range_flag"); + vuip.colour_description_present_flag = reader + .readBool("VUI: colour_description_present_flag"); + if (vuip.colour_description_present_flag) { + vuip.colour_primaries = (int) reader.readNBit(8, + "VUI: colour_primaries"); + vuip.transfer_characteristics = (int) reader.readNBit(8, + "VUI: transfer_characteristics"); + vuip.matrix_coefficients = (int) reader.readNBit(8, + "VUI: matrix_coefficients"); + } + } + vuip.chroma_loc_info_present_flag = reader + .readBool("VUI: chroma_loc_info_present_flag"); + if (vuip.chroma_loc_info_present_flag) { + vuip.chroma_sample_loc_type_top_field = reader + .readUE("VUI chroma_sample_loc_type_top_field"); + vuip.chroma_sample_loc_type_bottom_field = reader + .readUE("VUI chroma_sample_loc_type_bottom_field"); + } + vuip.timing_info_present_flag = reader + .readBool("VUI: timing_info_present_flag"); + if (vuip.timing_info_present_flag) { + vuip.num_units_in_tick = (int) reader.readNBit(32, + "VUI: num_units_in_tick"); + vuip.time_scale = (int) reader.readNBit(32, "VUI: time_scale"); + vuip.fixed_frame_rate_flag = reader + .readBool("VUI: fixed_frame_rate_flag"); + } + boolean nal_hrd_parameters_present_flag = reader + .readBool("VUI: nal_hrd_parameters_present_flag"); + if (nal_hrd_parameters_present_flag) + vuip.nalHRDParams = readHRDParameters(reader); + boolean vcl_hrd_parameters_present_flag = reader + .readBool("VUI: vcl_hrd_parameters_present_flag"); + if (vcl_hrd_parameters_present_flag) + vuip.vclHRDParams = readHRDParameters(reader); + if (nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag) { + vuip.low_delay_hrd_flag = reader + .readBool("VUI: low_delay_hrd_flag"); + } + vuip.pic_struct_present_flag = reader + .readBool("VUI: pic_struct_present_flag"); + boolean bitstream_restriction_flag = reader + .readBool("VUI: bitstream_restriction_flag"); + if (bitstream_restriction_flag) { + vuip.bitstreamRestriction = new VUIParameters.BitstreamRestriction(); + vuip.bitstreamRestriction.motion_vectors_over_pic_boundaries_flag = reader + .readBool("VUI: motion_vectors_over_pic_boundaries_flag"); + vuip.bitstreamRestriction.max_bytes_per_pic_denom = reader + .readUE("VUI max_bytes_per_pic_denom"); + vuip.bitstreamRestriction.max_bits_per_mb_denom = reader + .readUE("VUI max_bits_per_mb_denom"); + vuip.bitstreamRestriction.log2_max_mv_length_horizontal = reader + .readUE("VUI log2_max_mv_length_horizontal"); + vuip.bitstreamRestriction.log2_max_mv_length_vertical = reader + .readUE("VUI log2_max_mv_length_vertical"); + vuip.bitstreamRestriction.num_reorder_frames = reader + .readUE("VUI num_reorder_frames"); + vuip.bitstreamRestriction.max_dec_frame_buffering = reader + .readUE("VUI max_dec_frame_buffering"); + } + + return vuip; + } + + private static HRDParameters readHRDParameters(CAVLCReader reader) + throws IOException { + HRDParameters hrd = new HRDParameters(); + hrd.cpb_cnt_minus1 = reader.readUE("SPS: cpb_cnt_minus1"); + hrd.bit_rate_scale = (int) reader.readNBit(4, "HRD: bit_rate_scale"); + hrd.cpb_size_scale = (int) reader.readNBit(4, "HRD: cpb_size_scale"); + hrd.bit_rate_value_minus1 = new int[hrd.cpb_cnt_minus1 + 1]; + hrd.cpb_size_value_minus1 = new int[hrd.cpb_cnt_minus1 + 1]; + hrd.cbr_flag = new boolean[hrd.cpb_cnt_minus1 + 1]; + + for (int SchedSelIdx = 0; SchedSelIdx <= hrd.cpb_cnt_minus1; SchedSelIdx++) { + hrd.bit_rate_value_minus1[SchedSelIdx] = reader + .readUE("HRD: bit_rate_value_minus1"); + hrd.cpb_size_value_minus1[SchedSelIdx] = reader + .readUE("HRD: cpb_size_value_minus1"); + hrd.cbr_flag[SchedSelIdx] = reader.readBool("HRD: cbr_flag"); + } + hrd.initial_cpb_removal_delay_length_minus1 = (int) reader.readNBit(5, + "HRD: initial_cpb_removal_delay_length_minus1"); + hrd.cpb_removal_delay_length_minus1 = (int) reader.readNBit(5, + "HRD: cpb_removal_delay_length_minus1"); + hrd.dpb_output_delay_length_minus1 = (int) reader.readNBit(5, + "HRD: dpb_output_delay_length_minus1"); + hrd.time_offset_length = (int) reader.readNBit(5, + "HRD: time_offset_length"); + return hrd; + } + + public void write(OutputStream out) throws IOException { + CAVLCWriter writer = new CAVLCWriter(out); + + writer.writeNBit(profile_idc, 8, "SPS: profile_idc"); + writer.writeBool(constraint_set_0_flag, "SPS: constraint_set_0_flag"); + writer.writeBool(constraint_set_1_flag, "SPS: constraint_set_1_flag"); + writer.writeBool(constraint_set_2_flag, "SPS: constraint_set_2_flag"); + writer.writeBool(constraint_set_3_flag, "SPS: constraint_set_3_flag"); + writer.writeNBit(0, 4, "SPS: reserved"); + writer.writeNBit(level_idc, 8, "SPS: level_idc"); + writer.writeUE(seq_parameter_set_id, "SPS: seq_parameter_set_id"); + + if (profile_idc == 100 || profile_idc == 110 || profile_idc == 122 + || profile_idc == 144) { + writer.writeUE(chroma_format_idc.getId(), "SPS: chroma_format_idc"); + if (chroma_format_idc == ChromaFormat.YUV_444) { + writer.writeBool(residual_color_transform_flag, + "SPS: residual_color_transform_flag"); + } + writer.writeUE(bit_depth_luma_minus8, "SPS: "); + writer.writeUE(bit_depth_chroma_minus8, "SPS: "); + writer.writeBool(qpprime_y_zero_transform_bypass_flag, + "SPS: qpprime_y_zero_transform_bypass_flag"); + writer.writeBool(scalingMatrix != null, "SPS: "); + if (scalingMatrix != null) { + for (int i = 0; i < 8; i++) { + if (i < 6) { + writer.writeBool( + scalingMatrix.ScalingList4x4[i] != null, + "SPS: "); + if (scalingMatrix.ScalingList4x4[i] != null) { + scalingMatrix.ScalingList4x4[i].write(writer); + } + } else { + writer.writeBool( + scalingMatrix.ScalingList8x8[i - 6] != null, + "SPS: "); + if (scalingMatrix.ScalingList8x8[i - 6] != null) { + scalingMatrix.ScalingList8x8[i - 6].write(writer); + } + } + } + } + } + writer.writeUE(log2_max_frame_num_minus4, + "SPS: log2_max_frame_num_minus4"); + writer.writeUE(pic_order_cnt_type, "SPS: pic_order_cnt_type"); + if (pic_order_cnt_type == 0) { + writer.writeUE(log2_max_pic_order_cnt_lsb_minus4, + "SPS: log2_max_pic_order_cnt_lsb_minus4"); + } else if (pic_order_cnt_type == 1) { + writer.writeBool(delta_pic_order_always_zero_flag, + "SPS: delta_pic_order_always_zero_flag"); + writer.writeSE(offset_for_non_ref_pic, + "SPS: offset_for_non_ref_pic"); + writer.writeSE(offset_for_top_to_bottom_field, + "SPS: offset_for_top_to_bottom_field"); + writer.writeUE(offsetForRefFrame.length, "SPS: "); + for (int i = 0; i < offsetForRefFrame.length; i++) + writer.writeSE(offsetForRefFrame[i], "SPS: "); + } + writer.writeUE(num_ref_frames, "SPS: num_ref_frames"); + writer.writeBool(gaps_in_frame_num_value_allowed_flag, + "SPS: gaps_in_frame_num_value_allowed_flag"); + writer.writeUE(pic_width_in_mbs_minus1, "SPS: pic_width_in_mbs_minus1"); + writer.writeUE(pic_height_in_map_units_minus1, + "SPS: pic_height_in_map_units_minus1"); + writer.writeBool(frame_mbs_only_flag, "SPS: frame_mbs_only_flag"); + if (!frame_mbs_only_flag) { + writer.writeBool(mb_adaptive_frame_field_flag, + "SPS: mb_adaptive_frame_field_flag"); + } + writer.writeBool(direct_8x8_inference_flag, + "SPS: direct_8x8_inference_flag"); + writer.writeBool(frame_cropping_flag, "SPS: frame_cropping_flag"); + if (frame_cropping_flag) { + writer.writeUE(frame_crop_left_offset, + "SPS: frame_crop_left_offset"); + writer.writeUE(frame_crop_right_offset, + "SPS: frame_crop_right_offset"); + writer.writeUE(frame_crop_top_offset, "SPS: frame_crop_top_offset"); + writer.writeUE(frame_crop_bottom_offset, + "SPS: frame_crop_bottom_offset"); + } + writer.writeBool(vuiParams != null, "SPS: "); + if (vuiParams != null) + writeVUIParameters(vuiParams, writer); + + writer.writeTrailingBits(); + } + + private void writeVUIParameters(VUIParameters vuip, CAVLCWriter writer) + throws IOException { + writer.writeBool(vuip.aspect_ratio_info_present_flag, + "VUI: aspect_ratio_info_present_flag"); + if (vuip.aspect_ratio_info_present_flag) { + writer.writeNBit(vuip.aspect_ratio.getValue(), 8, + "VUI: aspect_ratio"); + if (vuip.aspect_ratio == AspectRatio.Extended_SAR) { + writer.writeNBit(vuip.sar_width, 16, "VUI: sar_width"); + writer.writeNBit(vuip.sar_height, 16, "VUI: sar_height"); + } + } + writer.writeBool(vuip.overscan_info_present_flag, + "VUI: overscan_info_present_flag"); + if (vuip.overscan_info_present_flag) { + writer.writeBool(vuip.overscan_appropriate_flag, + "VUI: overscan_appropriate_flag"); + } + writer.writeBool(vuip.video_signal_type_present_flag, + "VUI: video_signal_type_present_flag"); + if (vuip.video_signal_type_present_flag) { + writer.writeNBit(vuip.video_format, 3, "VUI: video_format"); + writer.writeBool(vuip.video_full_range_flag, + "VUI: video_full_range_flag"); + writer.writeBool(vuip.colour_description_present_flag, + "VUI: colour_description_present_flag"); + if (vuip.colour_description_present_flag) { + writer.writeNBit(vuip.colour_primaries, 8, + "VUI: colour_primaries"); + writer.writeNBit(vuip.transfer_characteristics, 8, + "VUI: transfer_characteristics"); + writer.writeNBit(vuip.matrix_coefficients, 8, + "VUI: matrix_coefficients"); + } + } + writer.writeBool(vuip.chroma_loc_info_present_flag, + "VUI: chroma_loc_info_present_flag"); + if (vuip.chroma_loc_info_present_flag) { + writer.writeUE(vuip.chroma_sample_loc_type_top_field, + "VUI: chroma_sample_loc_type_top_field"); + writer.writeUE(vuip.chroma_sample_loc_type_bottom_field, + "VUI: chroma_sample_loc_type_bottom_field"); + } + writer.writeBool(vuip.timing_info_present_flag, + "VUI: timing_info_present_flag"); + if (vuip.timing_info_present_flag) { + writer.writeNBit(vuip.num_units_in_tick, 32, + "VUI: num_units_in_tick"); + writer.writeNBit(vuip.time_scale, 32, "VUI: time_scale"); + writer.writeBool(vuip.fixed_frame_rate_flag, + "VUI: fixed_frame_rate_flag"); + } + writer.writeBool(vuip.nalHRDParams != null, "VUI: "); + if (vuip.nalHRDParams != null) { + writeHRDParameters(vuip.nalHRDParams, writer); + } + writer.writeBool(vuip.vclHRDParams != null, "VUI: "); + if (vuip.vclHRDParams != null) { + writeHRDParameters(vuip.vclHRDParams, writer); + } + + if (vuip.nalHRDParams != null || vuip.vclHRDParams != null) { + writer + .writeBool(vuip.low_delay_hrd_flag, + "VUI: low_delay_hrd_flag"); + } + writer.writeBool(vuip.pic_struct_present_flag, + "VUI: pic_struct_present_flag"); + writer.writeBool(vuip.bitstreamRestriction != null, "VUI: "); + if (vuip.bitstreamRestriction != null) { + writer + .writeBool( + vuip.bitstreamRestriction.motion_vectors_over_pic_boundaries_flag, + "VUI: motion_vectors_over_pic_boundaries_flag"); + writer.writeUE(vuip.bitstreamRestriction.max_bytes_per_pic_denom, + "VUI: max_bytes_per_pic_denom"); + writer.writeUE(vuip.bitstreamRestriction.max_bits_per_mb_denom, + "VUI: max_bits_per_mb_denom"); + writer.writeUE( + vuip.bitstreamRestriction.log2_max_mv_length_horizontal, + "VUI: log2_max_mv_length_horizontal"); + writer.writeUE( + vuip.bitstreamRestriction.log2_max_mv_length_vertical, + "VUI: log2_max_mv_length_vertical"); + writer.writeUE(vuip.bitstreamRestriction.num_reorder_frames, + "VUI: num_reorder_frames"); + writer.writeUE(vuip.bitstreamRestriction.max_dec_frame_buffering, + "VUI: max_dec_frame_buffering"); + } + + } + + private void writeHRDParameters(HRDParameters hrd, CAVLCWriter writer) + throws IOException { + writer.writeUE(hrd.cpb_cnt_minus1, "HRD: cpb_cnt_minus1"); + writer.writeNBit(hrd.bit_rate_scale, 4, "HRD: bit_rate_scale"); + writer.writeNBit(hrd.cpb_size_scale, 4, "HRD: cpb_size_scale"); + + for (int SchedSelIdx = 0; SchedSelIdx <= hrd.cpb_cnt_minus1; SchedSelIdx++) { + writer.writeUE(hrd.bit_rate_value_minus1[SchedSelIdx], "HRD: "); + writer.writeUE(hrd.cpb_size_value_minus1[SchedSelIdx], "HRD: "); + writer.writeBool(hrd.cbr_flag[SchedSelIdx], "HRD: "); + } + writer.writeNBit(hrd.initial_cpb_removal_delay_length_minus1, 5, + "HRD: initial_cpb_removal_delay_length_minus1"); + writer.writeNBit(hrd.cpb_removal_delay_length_minus1, 5, + "HRD: cpb_removal_delay_length_minus1"); + writer.writeNBit(hrd.dpb_output_delay_length_minus1, 5, + "HRD: dpb_output_delay_length_minus1"); + writer.writeNBit(hrd.time_offset_length, 5, "HRD: time_offset_length"); + } + + @Override + public String toString() { + return "SeqParameterSet{ " + + "\n pic_order_cnt_type=" + pic_order_cnt_type + + ", \n field_pic_flag=" + field_pic_flag + + ", \n delta_pic_order_always_zero_flag=" + delta_pic_order_always_zero_flag + + ", \n weighted_pred_flag=" + weighted_pred_flag + + ", \n weighted_bipred_idc=" + weighted_bipred_idc + + ", \n entropy_coding_mode_flag=" + entropy_coding_mode_flag + + ", \n mb_adaptive_frame_field_flag=" + mb_adaptive_frame_field_flag + + ", \n direct_8x8_inference_flag=" + direct_8x8_inference_flag + + ", \n chroma_format_idc=" + chroma_format_idc + + ", \n log2_max_frame_num_minus4=" + log2_max_frame_num_minus4 + + ", \n log2_max_pic_order_cnt_lsb_minus4=" + log2_max_pic_order_cnt_lsb_minus4 + + ", \n pic_height_in_map_units_minus1=" + pic_height_in_map_units_minus1 + + ", \n pic_width_in_mbs_minus1=" + pic_width_in_mbs_minus1 + + ", \n bit_depth_luma_minus8=" + bit_depth_luma_minus8 + + ", \n bit_depth_chroma_minus8=" + bit_depth_chroma_minus8 + + ", \n qpprime_y_zero_transform_bypass_flag=" + qpprime_y_zero_transform_bypass_flag + + ", \n profile_idc=" + profile_idc + + ", \n constraint_set_0_flag=" + constraint_set_0_flag + + ", \n constraint_set_1_flag=" + constraint_set_1_flag + + ", \n constraint_set_2_flag=" + constraint_set_2_flag + + ", \n constraint_set_3_flag=" + constraint_set_3_flag + + ", \n level_idc=" + level_idc + + ", \n seq_parameter_set_id=" + seq_parameter_set_id + + ", \n residual_color_transform_flag=" + residual_color_transform_flag + + ", \n offset_for_non_ref_pic=" + offset_for_non_ref_pic + + ", \n offset_for_top_to_bottom_field=" + offset_for_top_to_bottom_field + + ", \n num_ref_frames=" + num_ref_frames + + ", \n gaps_in_frame_num_value_allowed_flag=" + gaps_in_frame_num_value_allowed_flag + + ", \n frame_mbs_only_flag=" + frame_mbs_only_flag + + ", \n frame_cropping_flag=" + frame_cropping_flag + + ", \n frame_crop_left_offset=" + frame_crop_left_offset + + ", \n frame_crop_right_offset=" + frame_crop_right_offset + + ", \n frame_crop_top_offset=" + frame_crop_top_offset + + ", \n frame_crop_bottom_offset=" + frame_crop_bottom_offset + + ", \n offsetForRefFrame=" + offsetForRefFrame + + ", \n vuiParams=" + vuiParams + + ", \n scalingMatrix=" + scalingMatrix + + ", \n num_ref_frames_in_pic_order_cnt_cycle=" + num_ref_frames_in_pic_order_cnt_cycle + + '}'; + } +}
\ No newline at end of file |