H264Data.cpp

#include "H264Data.h"
 
#include <assert.h>
#include <stdio.h>
 
using namespace Cogs::Core;
 
void NALheader::print()
{
  printf("zero_bit %d nal_ref_idc %d nal_unit_type %d\n", forbidden_zero_bit, nal_ref_idc, nal_unit_type);
}
 
void SeqParameterSet::print()
{
  printf("\n");
  printf("seq_perameter_set_rbsp\n");
  printf("profile_idc %d\n", profile_idc);
  printf("constraint_set0_flag %d\n", constraint_set0_flag);
  printf("constraint_set1_flag %d\n", constraint_set1_flag);
  printf("constraint_set2_flag %d\n", constraint_set2_flag);
  printf("constraint_set3_flag %d\n", constraint_set3_flag);
  printf("constraint_set4_flag %d\n", constraint_set4_flag);
  printf("constraint_set5_flag %d\n", constraint_set5_flag);
  printf("level_idc %d\n", level_idc);
  printf("seq_parameter_set_id %d\n", seq_parameter_set_id);
 
  if(profile_idc == 66 && constraint_set1_flag) printf("Constrained Baseline profile\n");
  else if(profile_idc == 66) printf("Baseline profile\n");
  else if(profile_idc == 77) printf("Main profile\n");
  else if (profile_idc == 100) printf("High profile\n");
 
  printf("chroma_format_idc %d\n", chroma_format_idc);
  printf("separate_colour_plane_flag %d\n", separate_colour_plane_flag);
  uint32_t SubWidthC = (uint32_t)-1;
  uint32_t SubHeightC = (uint32_t)-1;
  if(chroma_format_idc == 1){
    SubWidthC = 2;
    SubHeightC = 2;
  }
  else if(chroma_format_idc == 2){
    SubWidthC = 2;
    SubHeightC = 1;
  }
  else if(chroma_format_idc == 3 && separate_colour_plane_flag == 0){
    SubWidthC = 1;
    SubHeightC = 1;
  }
  uint32_t MbWidthC = 16/SubWidthC;
  uint32_t MbHeightC = 16/SubHeightC;
  if(chroma_format_idc == 0)
    printf("Chroma Format: monochrome SubWidthC: - SubHeightC: -\n");
  else if(chroma_format_idc == 1)
    printf("Chroma Format: 4:2:0 SubWidthC: %d SubHeightC: %d MbWidthC %d MbHeightC %d\n", SubWidthC, SubHeightC, MbWidthC, MbHeightC);
  else if(chroma_format_idc == 2)
    printf("Chroma Format: 4:2:2 SubWidthC: %d SubHeightC: %d MbWidthC %d MbHeightC %d\n", SubWidthC, SubHeightC, MbWidthC, MbHeightC);
  else if(chroma_format_idc == 3 && separate_colour_plane_flag == 0)
    printf("Chroma Format: 4:4:4 SubWidthC: %d SubHeightC: %d MbWidthC %d MbHeightC %d\n", SubWidthC, SubHeightC, MbWidthC, MbHeightC);
  else if(chroma_format_idc == 3 && separate_colour_plane_flag == 1)
    printf("Chroma Format: 4:4:4 SubWidthC: - SubHeightC: -\n");
  printf("bit_depth_luma_minus8 %d (%d)\n", bit_depth_luma_minus8, bit_depth_luma_minus8+8);
  printf("bit_depth_chroma_minus8 %d (%d)\n", bit_depth_chroma_minus8, bit_depth_chroma_minus8+8);
  printf("qpprime_y_zero_transform_bypass_flag %d\n", qpprime_y_zero_transform_bypass_flag);
  printf("seq_scaling_matrix_present_flag %d\n", seq_scaling_matrix_present_flag);
  printf("log2_max_frame_num_minus4 %d (%d)\n",
         log2_max_frame_num_minus4,
         1<<(log2_max_frame_num_minus4+4));
  printf("pic_order_cnt_type %d\n", pic_order_cnt_type);
  if(pic_order_cnt_type == 0){
    printf("log2_max_pic_order_cnt_lsb_minus4 %d (%d)\n",
           log2_max_pic_order_cnt_lsb_minus4,
           1<<(log2_max_pic_order_cnt_lsb_minus4+4));
  }
  else if(pic_order_cnt_type == 1){
    assert(false);
  }
  printf("num_ref_frames %d\n", num_ref_frames);
  printf("gaps_in_frame_num_value_allowed_flag %d\n", gaps_in_frame_num_value_allowed_flag);
 
  uint32_t PicWidthInMbs = pic_width_in_mbs_minus1+1;
  uint32_t PicWidthInSamplesLuma = PicWidthInMbs*16;
  uint32_t PixWidthInSamplesChroma = PicWidthInMbs*MbWidthC;
  printf("pic_width_in_mbs_minus1 %d (%d Luma %d Chroma %d)\n", pic_width_in_mbs_minus1, PicWidthInMbs,
         PicWidthInSamplesLuma, PixWidthInSamplesChroma);
  uint32_t PicHeightInMapUnits = pic_height_in_map_units_minus1+1;
  uint32_t FrameHeightInMbs = (2-frame_mbs_only_flag)*PicHeightInMapUnits;
  printf("pic_height_in_map_units_minus1 %d (%d Size %d)\n", pic_height_in_map_units_minus1,
         PicHeightInMapUnits, FrameHeightInMbs*16);
 
  printf("frame_mbs_only_flag %d\n", frame_mbs_only_flag);
  if(!frame_mbs_only_flag)
    assert(false);
  printf("direct_8x8_inference_flag %d\n", direct_8x8_inference_flag);
  printf("frame_cropping_flag %d\n", frame_cropping_flag);
  if(frame_cropping_flag){
    printf("frame_crop_left_offset %d\n", frame_crop_left_offset);
    printf("frame_crop_right_offset %d\n", frame_crop_right_offset);
    printf("frame_crop_top_offset %d\n", frame_crop_top_offset);
    printf("frame_crop_bottom_offset %d\n", frame_crop_bottom_offset);
  }
  printf("vui_parameters_present_flag %d\n", vui_parameters_present_flag);
}
 
void PicParameterSet::print()
{
  printf("\n");
  printf("pic_perameter_set_rbsp\n");
  printf("pic_parameter_set_id %d\n", pic_parameter_set_id);
  printf("seq_parameter_set_id %d\n", seq_parameter_set_id);
  printf("entropy_coding_mode_flag %d\n", entropy_coding_mode_flag);
  printf("bottom_field_pic_order_in_frame_present_flag %d\n", bottom_field_pic_order_in_frame_present_flag);
  printf("num_slice_groups_minus1 %d\n", num_slice_groups_minus1);
  if(num_slice_groups_minus1 > 0){
    printf("slice_group_map_type %d\n", slice_group_map_type);
    if(slice_group_map_type == 0){
      assert(false);
    }
    else if(slice_group_map_type == 2){
      assert(false);
    }
    else if(slice_group_map_type == 3 ||
            slice_group_map_type == 4 ||
            slice_group_map_type == 5){
      assert(false);
    }
    else if(slice_group_map_type == 6){
      assert(false);
    }
  }
  printf("num_ref_idx_l0_default_active_minus1 %d\n", num_ref_idx_l0_default_active_minus1);
  printf("num_ref_idx_l1_default_active_minus1 %d\n", num_ref_idx_l1_default_active_minus1);
  printf("weighted_pred_flag %d\n", weighted_pred_flag);
  printf("weighted_bipred_idc %d\n", weighted_bipred_idc);
  printf("pic_init_qp_minus26 %d\n", pic_init_qp_minus26);
  printf("pic_init_sp_minus26 %d\n", pic_init_sp_minus26);
  printf("chroma_qp_index_offset %d\n", chroma_qp_index_offset);
  printf("deblocking_filter_control_present_flag %d\n", deblocking_filter_control_present_flag);
  printf("constrained_intra_pred_flag %d\n", constrained_intra_pred_flag);
  printf("redundant_pic_cnt_present_flag %d\n", redundant_pic_cnt_present_flag);
}
 
void SliceLayer::print()
{
  const char *slice_type_name[] = {"P", "B", "I", "SP", "SI", "P", "B", "I", "SP", "SI"};
  printf("\n");
  printf("slice\n");
  printf("first_mb_in_slice %d\n", first_mb_in_slice);
  printf("slice_type %d %s\n", slice_type, slice_type_name[slice_type]);
  printf("pic_parameter_set_id %d\n", pic_parameter_set_id);
  printf("colour_plane_id %d\n", colour_plane_id);
  printf("frame_num %d\n", frame_num);
  printf("field_pic_flag %d\n", field_pic_flag);
  printf("bottom_field_flag %d\n", bottom_field_flag);
  printf("idr_pic_id %d\n", idr_pic_id);
  printf("pic_order_cnt_lsb %d\n", pic_order_cnt_lsb);
  printf("delta_pic_order_cnt_bottom %d\n", delta_pic_order_cnt_bottom);
  printf("delta_pic_order_cnt[0] %d\n", delta_pic_order_cnt[0]);
  printf("delta_pic_order_cnt[1] %d\n", delta_pic_order_cnt[1]);
  printf("redundant_pic_cnt %d\n", redundant_pic_cnt);
  printf("direct_spatial_mv_pred_flag %d\n", direct_spatial_mv_pred_flag);
  printf("num_ref_idx_active_override_flag %d\n", num_ref_idx_active_override_flag);
  printf("num_ref_idx_l0_active_minus1 %d\n", num_ref_idx_l0_active_minus1);
  printf("num_ref_idx_l1_active_minus1 %d\n", num_ref_idx_l1_active_minus1);
  printf("cabac_init_idc %d\n", cabac_init_idc);
  printf("slice_qp_delta %d\n", slice_qp_delta);
  printf("sp_for_switch_flag %d\n", sp_for_switch_flag);
  printf("slice_qs_delta %d\n", slice_qs_delta);
  printf("disable_deblocking_filter_idc %d\n", disable_deblocking_filter_idc);
  printf("slice_alpha_c0_offset_div2 %d\n", slice_alpha_c0_offset_div2);
  printf("slice_beta_offset_div2 %d\n", slice_beta_offset_div2);
  printf("slice_group_change_cycle %d\n", slice_group_change_cycle);
}
 
static void PrintHrdParameters(HrdParameters &param)
{
  printf("  - cpb_cnt_minus1 %u\n", param.cpb_cnt_minus1);
  printf("  - cpb_cnt_minus1 %u\n", param.cpb_cnt_minus1);
  printf("  - bit_rate_scale %u\n", param.bit_rate_scale);
  printf("  - cpb_size_scale %u\n", param.cpb_size_scale);
  for(size_t SchedSelIdx=0; SchedSelIdx<=param.cpb_cnt_minus1; SchedSelIdx++){
    printf("   - bit_rate_calue_minus1[%zu] %u\n", SchedSelIdx, param.bit_rate_calue_minus1[SchedSelIdx]);
    printf("   - cpb_size_value_minus1[%zu] %u\n", SchedSelIdx, param.cpb_size_value_minus1[SchedSelIdx]);
    printf("   - cbr_flag[%zu] %u\n", SchedSelIdx, param.cbr_flag[SchedSelIdx]);
  }
  printf("  - initial_sbp_removal_delay_length_minus1 %u\n", param.initial_cpb_removal_delay_length_minus1);
  printf("  - cpb_removal_delay_length_minus1 %u\n", param.cpb_removal_delay_length_minus1);
  printf("  - cpb_output_delay_length_minus1 %u\n", param.cpb_output_delay_length_minus1);
  printf("  - time_offset_length %u\n", param.time_offset_length);
}
 
void VuiParameters::print()
{
  printf("\n");
  printf("vui_parameters\n");
  printf(" - aspect_ratio_info_present %d\n", aspect_ratio_info_present);
  if(aspect_ratio_info_present){
    printf(" - Sample Aspect Ratio %d:%d\n", sar_width, sar_height);
  }
  printf(" - overscan_info_present_flag %d\n", overscan_info_present_flag);
  if(overscan_info_present_flag){
    printf(" - overscan_appropriate_flag %d\n", overscan_appropriate_flag);
  }
  printf(" - video_signal_type_present_flag %d\n", video_signal_type_present_flag);
  if(video_signal_type_present_flag){
    printf(" - video_format %d\n", video_format);
    printf(" - video_full_range_flag %d\n", video_full_range_flag);
    printf(" - colour_description_present_flag %d\n", colour_description_present_flag);
    if(colour_description_present_flag){
      printf(" - colour_primaries %d\n", colour_primaries);
      printf(" - transfer_characteristics %d\n", transfer_characteristics);
      printf(" - matrix_coefficients %d\n", matrix_coefficients);
    }
  }
  printf(" - chroma_loc_info_present_flag %d\n", chroma_loc_info_present_flag);
  if(chroma_loc_info_present_flag){
    printf(" - chroma_sample_loc_type_top_field %d\n", chroma_sample_loc_type_top_field);
    printf(" - chroma_sample_loc_type_bottom_field %d\n", chroma_sample_loc_type_bottom_field);
  }
  printf(" - timing_info_present_flag %d\n", timing_info_present_flag);
  if(timing_info_present_flag){
    printf(" - num_units_in_tick %d\n", num_units_in_tick);
    printf(" - time_scale %d\n", time_scale);
    printf(" - fixed_frame_rate_flag %d\n", fixed_frame_rate_flag);
  }
  printf(" - nal_hrd_parameters_present_flag %d\n", nal_hrd_parameters_present_flag);
  if(nal_hrd_parameters_present_flag){
    PrintHrdParameters(nal_hrd_parameters);
  }
  printf(" - vcl_hrd_parameters_present_flag %d\n", vcl_hrd_parameters_present_flag);
  if(vcl_hrd_parameters_present_flag){
    PrintHrdParameters(vcl_hrd_parameters);
  }
  if(nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag){
    printf(" - low_delay_hrd_flag %d\n", low_delay_hrd_flag);
  }
  printf(" - pic_struct_present_flag %d\n", pic_struct_present_flag);
  printf(" - bitstream_restriction_flag %d\n", bitstream_restriction_flag);
  if(bitstream_restriction_flag){
    printf(" - motion_vectors_over_pic_bondaries_flag %u\n", motion_vectors_over_pic_bondaries_flag);
    printf(" - max_bytes_per_pic_denom %u\n", max_bytes_per_pic_denom);
    printf(" - max_bits_per_pic_denom %u\n", max_bits_per_pic_denom);
    printf(" - log2_max_mv_length_horizontal %u\n", log2_max_mv_length_horizontal);
    printf(" - log2_max_mv_length_vertical %u\n", log2_max_mv_length_vertical);
    printf(" - max_num_reorder_frames %u\n", max_num_reorder_frames);
    printf(" - max_dec_frame_buffering %u\n", max_dec_frame_buffering);
  }
}