parset.c

JM 11.0 KTA 2.1 Source Code

  len+=ue_v ("SPS: pic_order_cnt_type",                      sps->pic_order_cnt_type,                        bitstream);
  
  if (sps->pic_order_cnt_type == 0)
    len+=ue_v ("SPS: log2_max_pic_order_cnt_lsb_minus4",     sps->log2_max_pic_order_cnt_lsb_minus4,         bitstream);
  else if (sps->pic_order_cnt_type == 1)
  {
    len+=u_1  ("SPS: delta_pic_order_always_zero_flag",        sps->delta_pic_order_always_zero_flag,          bitstream);
    len+=se_v ("SPS: offset_for_non_ref_pic",                  sps->offset_for_non_ref_pic,                    bitstream);
    len+=se_v ("SPS: offset_for_top_to_bottom_field",          sps->offset_for_top_to_bottom_field,            bitstream);
    len+=ue_v ("SPS: num_ref_frames_in_pic_order_cnt_cycle",   sps->num_ref_frames_in_pic_order_cnt_cycle,     bitstream);
    for (i=0; i<sps->num_ref_frames_in_pic_order_cnt_cycle; i++)
      len+=se_v ("SPS: offset_for_ref_frame",                  sps->offset_for_ref_frame[i],                      bitstream);
  }
  len+=ue_v ("SPS: num_ref_frames",                          sps->num_ref_frames,                            bitstream);
  len+=u_1  ("SPS: gaps_in_frame_num_value_allowed_flag",    sps->gaps_in_frame_num_value_allowed_flag,      bitstream);
  len+=ue_v ("SPS: pic_width_in_mbs_minus1",                 sps->pic_width_in_mbs_minus1,                   bitstream);
  len+=ue_v ("SPS: pic_height_in_map_units_minus1",          sps->pic_height_in_map_units_minus1,            bitstream);
  len+=u_1  ("SPS: frame_mbs_only_flag",                     sps->frame_mbs_only_flag,                       bitstream);
  if (!sps->frame_mbs_only_flag)
  {
    len+=u_1  ("SPS: mb_adaptive_frame_field_flag",            sps->mb_adaptive_frame_field_flag,              bitstream);
  }
  len+=u_1  ("SPS: direct_8x8_inference_flag",               sps->direct_8x8_inference_flag,                 bitstream);
  
  len+=u_1  ("SPS: frame_cropping_flag",                      sps->frame_cropping_flag,                       bitstream);
  if (sps->frame_cropping_flag)
  {
    len+=ue_v ("SPS: frame_cropping_rect_left_offset",          sps->frame_cropping_rect_left_offset,           bitstream);
    len+=ue_v ("SPS: frame_cropping_rect_right_offset",         sps->frame_cropping_rect_right_offset,          bitstream);
    len+=ue_v ("SPS: frame_cropping_rect_top_offset",           sps->frame_cropping_rect_top_offset,            bitstream);
    len+=ue_v ("SPS: frame_cropping_rect_bottom_offset",        sps->frame_cropping_rect_bottom_offset,         bitstream);
  }
  
  len+=u_1  ("SPS: vui_parameters_present_flag",             sps->vui_parameters_present_flag,               bitstream);
  
  if (sps->vui_parameters_present_flag)
    len+=GenerateVUISequenceParameters(bitstream);    // currently a dummy, asserting
  
  SODBtoRBSP(bitstream);     // copies the last couple of bits into the byte buffer
  
  LenInBytes=bitstream->byte_pos;
  
  free (bitstream);
  
  return LenInBytes;
}


/*! 
***********************************************************************************************
* \brief
*    int GeneratePic_parameter_set_rbsp (pic_parameter_set_rbsp_t *sps, char *rbsp);
*
* \param pps
*    picture parameter structure
* \param rbsp
*    buffer to be filled with the rbsp, size should be at least MAXIMUMPARSETRBSPSIZE
*
* \return
*    size of the RBSP in bytes, negative in case of an error
*
* \note
*    Picture Parameter VUI function is called, but the function implements
*    an exit (-1)
************************************************************************************************
*/

int GeneratePic_parameter_set_rbsp (pic_parameter_set_rbsp_t *pps, unsigned char *rbsp)
{
  Bitstream *bitstream;
  int len = 0, LenInBytes;
  unsigned i;
  unsigned NumberBitsPerSliceGroupId;
  int profile_idc;
  
  assert (rbsp != NULL);
  
  if ((bitstream=calloc(1, sizeof(Bitstream)))==NULL) no_mem_exit("PicParameterSet:bitstream");
  
  // .. and use the rbsp provided (or allocated above) for the data
  bitstream->streamBuffer = rbsp;
  bitstream->bits_to_go = 8;
  
  pps->pic_order_present_flag = (Boolean)img->pic_order_present_flag;
  
  len+=ue_v ("PPS: pic_parameter_set_id",                    pps->pic_parameter_set_id,                      bitstream);
  len+=ue_v ("PPS: seq_parameter_set_id",                    pps->seq_parameter_set_id,                      bitstream);
  len+=u_1  ("PPS: entropy_coding_mode_flag",                pps->entropy_coding_mode_flag,                  bitstream);
#ifdef ADAPTIVE_FILTER  
  len+=u_1  ("PPS: adaptive_filter_flag",                     pps->adaptive_filter_flag,                       bitstream);
#endif  
  
#ifdef MV_COMPETITION
  {
    len += u_v  (1,"PPS: mv_competition_flag",           (int) (input->mv_competition/2),            bitstream);
    len += u_v  (1,"PPS: mv_competition_flag",           input->mv_competition % 2,            bitstream);
    
    if (input->mv_competition == 2)
    {
      for (i=1; i<MAX_MV_PREDICTOR + 1; i++)
        len += u_v (1, "PPS: predictors_for_skip_motion_vector", (int) input->predictors_skip[i]-48, bitstream);
      
      for (i=1; i<MAX_MV_PREDICTOR + 1; i++)
        len += u_v (1, "PPS: predictors_for_p_frames_motion_vector", (int) input->predictors_mvp[i]-48, bitstream);
      
      for (i=1; i<MAX_MV_PREDICTOR + 1; i++)
        len += u_v (1, "PPS: predictors_for_b_frames_motion_vector", (int) input->predictors_mvb[i]-48, bitstream);
    }
  }
#endif
  
  len+=u_1  ("PPS: pic_order_present_flag",                  pps->pic_order_present_flag,                    bitstream);
  len+=ue_v ("PPS: num_slice_groups_minus1",                 pps->num_slice_groups_minus1,                   bitstream);
  
  // FMO stuff
  if(pps->num_slice_groups_minus1 > 0 )
  {
    len+=ue_v ("PPS: slice_group_map_type",                 pps->slice_group_map_type,                   bitstream);
    if (pps->slice_group_map_type == 0)
      for (i=0; i<=pps->num_slice_groups_minus1; i++)
        len+=ue_v ("PPS: run_length_minus1[i]",                           pps->run_length_minus1[i],                             bitstream);
      else if (pps->slice_group_map_type==2)
        for (i=0; i<pps->num_slice_groups_minus1; i++)
        {
          
          len+=ue_v ("PPS: top_left[i]",                          pps->top_left[i],                           bitstream);
          len+=ue_v ("PPS: bottom_right[i]",                      pps->bottom_right[i],                       bitstream);
        }
        else if (pps->slice_group_map_type == 3 ||
          pps->slice_group_map_type == 4 ||
          pps->slice_group_map_type == 5) 
        {
          len+=u_1  ("PPS: slice_group_change_direction_flag",         pps->slice_group_change_direction_flag,         bitstream);
          len+=ue_v ("PPS: slice_group_change_rate_minus1",            pps->slice_group_change_rate_minus1,            bitstream);
        } 
        else if (pps->slice_group_map_type == 6)
        {
          if (pps->num_slice_groups_minus1>=4)
            NumberBitsPerSliceGroupId=3;
          else if (pps->num_slice_groups_minus1>=2)
            NumberBitsPerSliceGroupId=2;
          else if (pps->num_slice_groups_minus1>=1)
            NumberBitsPerSliceGroupId=1;
          else
            NumberBitsPerSliceGroupId=0;
          
          len+=ue_v ("PPS: pic_size_in_map_units_minus1",                       pps->pic_size_in_map_units_minus1,             bitstream);
          for(i=0; i<=pps->pic_size_in_map_units_minus1; i++)
            len+= u_v  (NumberBitsPerSliceGroupId, "PPS: >slice_group_id[i]",   pps->slice_group_id[i],                        bitstream);
        }
  }
  // End of FMO stuff
  
  len+=ue_v ("PPS: num_ref_idx_l0_active_minus1",             pps->num_ref_idx_l0_active_minus1,              bitstream);
  len+=ue_v ("PPS: num_ref_idx_l1_active_minus1",             pps->num_ref_idx_l1_active_minus1,              bitstream);
  len+=u_1  ("PPS: weighted_pred_flag",                       pps->weighted_pred_flag,                        bitstream);
  len+=u_v  (2, "PPS: weighted_bipred_idc",                   pps->weighted_bipred_idc,                       bitstream);
  len+=se_v ("PPS: pic_init_qp_minus26",                      pps->pic_init_qp_minus26,                       bitstream);
  len+=se_v ("PPS: pic_init_qs_minus26",                      pps->pic_init_qs_minus26,                       bitstream);
  
  profile_idc = IdentifyProfile();
  if((profile_idc==FREXT_HP) || 
    (profile_idc==FREXT_Hi10P) ||
    (profile_idc==FREXT_Hi422) ||
    (profile_idc==FREXT_Hi444))
    len+=se_v ("PPS: chroma_qp_index_offset",                 pps->cb_qp_index_offset,                        bitstream);
  else
    len+=se_v ("PPS: chroma_qp_index_offset",                 pps->chroma_qp_index_offset,                    bitstream);
  
  len+=u_1  ("PPS: deblocking_filter_control_present_flag",   pps->deblocking_filter_control_present_flag,    bitstream);
  len+=u_1  ("PPS: constrained_intra_pred_flag",              pps->constrained_intra_pred_flag,               bitstream);
  len+=u_1  ("PPS: redundant_pic_cnt_present_flag",           pps->redundant_pic_cnt_present_flag,            bitstream);
  
  // Fidelity Range Extensions stuff
  if((profile_idc==FREXT_HP) || 
    (profile_idc==FREXT_Hi10P) ||
    (profile_idc==FREXT_Hi422) ||
    (profile_idc==FREXT_Hi444))
  {
    len+=u_1  ("PPS: transform_8x8_mode_flag",                pps->transform_8x8_mode_flag,                   bitstream);
    
    len+=u_1  ("PPS: pic_scaling_matrix_present_flag",        pps->pic_scaling_matrix_present_flag,           bitstream);
    
    if(pps->pic_scaling_matrix_present_flag)
    {
      for(i=0; i<(6+((unsigned)pps->transform_8x8_mode_flag<<1)); i++)
      {
        len+=u_1  ("PPS: pic_scaling_list_present_flag",      pps->pic_scaling_list_present_flag[i],          bitstream);
        
        if(pps->pic_scaling_list_present_flag[i])
        {
          if(i<6)
            len+=Scaling_List(ScalingList4x4input[i], ScalingList4x4[i], 16, &UseDefaultScalingMatrix4x4Flag[i], bitstream);
          else
            len+=Scaling_List(ScalingList8x8input[i-6], ScalingList8x8[i-6], 64, &UseDefaultScalingMatrix8x8Flag[i-6], bitstream);
        }
      }
    }
#ifdef ADAPTIVE_QUANTIZATION
    else  // no scaling list
    {
      InitScalingList();
    }
#endif
    len+=se_v ("PPS: second_chroma_qp_index_offset",          pps->cr_qp_index_offset,                        bitstream);
  }
#ifdef ADAPTIVE_QUANTIZATION
  else  // no scaling list
  {
    InitScalingList();
  }
#endif
  
  
  SODBtoRBSP(bitstream);     // copies the last couple of bits into the byte buffer
  
  LenInBytes=bitstream->byte_pos;
  
  // Get rid of the helper structures
  free (bitstream);
  
  return LenInBytes;
}



/*! 
*************************************************************************************
* \brief
*    Returns the Profile
*
* \return
*    Profile according to Annex A
*
* \note
*    Function is currently a dummy.  Should "calculate" the profile from those
*    config file parameters.  E.g.
*
*    Profile = Baseline;
*    if (CABAC Used || Interlace used) Profile=Main;
*    if (!Cabac Used) && (Bframes | SPframes) Profile = Streaming;
*
*************************************************************************************
*/
int IdentifyProfile(void)
{
  return input->ProfileIDC;
};

/*! 
*************************************************************************************
* \brief
*    Returns the Level
*
* \return
*    Level according to Annex A
*
* \note
*    This function is currently a dummy, but should calculate the level out of 
*    the config file parameters (primarily the picture size)
*************************************************************************************
*/
int IdentifyLevel(void)
{
  return input->LevelIDC;
};


/*! 
*************************************************************************************
* \brief
*    Function body for VUI Parameter generation (to be done)
*
* \return
*    exits with error message
*************************************************************************************
*/
static int GenerateVUISequenceParameters(Bitstream *bitstream)
{
  int len=0;
  
  // special case to signal the RGB format
  if(input->rgb_input_flag && input->yuv_format==3)
  { 
    //still pretty much a dummy VUI
    printf ("test: writing Sequence Parameter VUI to signal RGB format\n");
    len+=u_1 ("VUI: aspect_ratio_info_present_flag", 0, bitstream);
    len+=u_1 ("VUI: overscan_info_present_flag", 0, bitstream);
    len+=u_1 ("VUI: video_signal_type_present_flag", 1, bitstream);
    len+=u_v (3, "VUI: video format", 2, bitstream);
    len+=u_1 ("VUI: video_full_range_flag", 1, bitstream);
    len+=u_1 ("VUI: color_description_present_flag", 1, bitstream);
    len+=u_v (8, "VUI: colour primaries", 2, bitstream);
    len+=u_v (8, "VUI: transfer characteristics", 2, bitstream);
    len+=u_v (8, "VUI: matrix coefficients", 0, bitstream);
    len+=u_1 ("VUI: chroma_loc_info_present_flag", 0, bitstream);
    len+=u_1 ("VUI: timing_info_present_flag", 0, bitstream);
    len+=u_1 ("VUI: nal_hrd_parameters_present_flag", 0, bitstream);
    len+=u_1 ("VUI: vcl_hrd_parameters_present_flag", 0, bitstream);
    len+=u_1 ("VUI: pic_struc_present_flag", 0, bitstream);
    len+=u_1 ("VUI: bitstream_restriction_flag", 0, bitstream);
    
    return len;
  }
  else 
  {
    printf ("Sequence Parameter VUI not yet implemented, this should never happen, exit\n");
    exit (-1);
  }
}

#ifdef ADAPTIVE_QUANTIZATION
/*!
************************************************************************
* \brief
*    For generating pps again to set best pps codiguration
************************************************************************
*/
void ReGenerateParameterSets (int best_pic_id)
{
  if (input->GenerateMultiplePPS)
  {
    GeneratePictureParameterSet( PicParSet[3], active_sps, best_pic_id, active_pps->weighted_pred_flag, active_pps->weighted_bipred_idc, input->cb_qp_index_offset, input->cr_qp_index_offset);
  }
}
#endif