sei.c

H.264编码实现

}

void FinalizeRandomAccess()
{
  Bitstream *bitstream = seiRecoveryPoint.data;

  ue_v(   "SEI: recovery_frame_cnt",       seiRecoveryPoint.recovery_frame_cnt,       bitstream);
  u_1 (   "SEI: exact_match_flag",         seiRecoveryPoint.exact_match_flag,         bitstream);
  u_1 (   "SEI: broken_link_flag",         seiRecoveryPoint.broken_link_flag,         bitstream);
  u_v (2, "SEI: changing_slice_group_idc", seiRecoveryPoint.changing_slice_group_idc, bitstream);


// #define PRINT_RECOVERY_POINT
#ifdef PRINT_RECOVERY_POINT
  printf(" recovery_frame_cnt %d \n",       seiRecoveryPoint.recovery_frame_cnt);
  printf(" exact_match_flag %d \n",         seiRecoveryPoint.exact_match_flag);
  printf(" broken_link_flag %d \n",         seiRecoveryPoint.broken_link_flag);
  printf(" changing_slice_group_idc %d \n", seiRecoveryPoint.changing_slice_group_idc);
  printf(" %d %d \n", bitstream->byte_pos, bitstream->bits_to_go);

#undef PRINT_RECOVERY_POINT
#endif
  // make sure the payload is byte aligned, stuff bits are 10..0
  if ( bitstream->bits_to_go != 8 )
  {
    (bitstream->byte_buf) <<= 1;
    bitstream->byte_buf |= 1;
    bitstream->bits_to_go--;
    if ( bitstream->bits_to_go != 0 )
      (bitstream->byte_buf) <<= (bitstream->bits_to_go);
    bitstream->bits_to_go = 8;
    bitstream->streamBuffer[bitstream->byte_pos++]=bitstream->byte_buf;
    bitstream->byte_buf = 0;
  }
  seiRecoveryPoint.payloadSize = bitstream->byte_pos;
}

void CloseRandomAccess()
{
  if (seiRecoveryPoint.data)
  {
    free(seiRecoveryPoint.data->streamBuffer);
    free(seiRecoveryPoint.data);
  }
  seiRecoveryPoint.data = NULL;
}

/*
 **++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 *  \functions on HDR tone-mapping messages
 *  \brief
 *      Based on JVT-T060
 *  \author
 *      Jane Zhao, sharp labs of america
 **++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 */
tone_mapping_struct seiToneMapping;

int ParseToneMappingConfigFile(tone_mapping_struct* pSeiToneMapping)
{
  int i;
  FILE* fp;
  char buf[1024];
  unsigned int tmp;

  printf ("Parsing Tone mapping cfg file %s ..........\n\n", params->ToneMappingFile);
  if ((fp = fopen(params->ToneMappingFile, "r")) == NULL) 
  {
    fprintf(stderr, "Tone mapping config file %s is not found, disable tone mapping SEI\n", params->ToneMappingFile);
    seiHasTone_mapping=FALSE;

    return 1;
  }

  //read the tone mapping config file
  while (fscanf(fp, "%s", buf)!=EOF) 
  {
    if (strcmp(buf, "tone_map_id")==0) 
    {
      fscanf(fp, " = %ud\n", &(pSeiToneMapping->tone_map_id));
    }
    else if (strcmp(buf, "tone_map_cancel_flag")==0) 
    {
      fscanf(fp, " = %ud\n", &tmp);
      pSeiToneMapping->tone_map_cancel_flag = tmp ? 1 : 0;
    }
    else if (strcmp(buf, "tone_map_repetition_period")==0) 
    {
      fscanf(fp, " = %ud\n", &(pSeiToneMapping->tone_map_repetition_period));
    }
    else if (strcmp(buf, "coded_data_bit_depth")==0) 
    {
      fscanf(fp, " = %ud\n", &tmp);
      pSeiToneMapping->coded_data_bit_depth = (unsigned char) tmp;
    }
    else if (strcmp(buf, "sei_bit_depth")==0) 
    {
      fscanf(fp, " = %ud\n", &tmp);
      pSeiToneMapping->sei_bit_depth =  (unsigned char) tmp;
    }
    else if (strcmp(buf, "model_id")==0) 
    {
      fscanf(fp, " = %ud\n", &(pSeiToneMapping->model_id));
    }
    //else if (model_id ==0) 
    else if (strcmp(buf, "min_value")==0) 
    {
      fscanf(fp, " = %d\n", &(pSeiToneMapping->min_value));
    }
    else if (strcmp(buf, "max_value")==0) 
    {
      fscanf(fp, " = %d\n", &(pSeiToneMapping->max_value));
    }
    //(model_id == 1)
    else if (strcmp(buf, "sigmoid_midpoint")==0) 
    {
      fscanf(fp, " = %d\n", &(pSeiToneMapping->sigmoid_midpoint));
    }
    else if (strcmp(buf, "sigmoid_width")==0) 
    {
      fscanf(fp, " = %d\n", &(pSeiToneMapping->sigmoid_width));
    }
    // (model_id == 2) 
    else if (strcmp(buf, "start_of_coded_interval")==0) 
    {
      int max_output_num = 1<<(pSeiToneMapping->sei_bit_depth);
      fscanf(fp, " = ");
      for (i=0; i < max_output_num; i++)
        fscanf(fp, "%d\n", &(pSeiToneMapping->start_of_coded_interval[i]));
    }
    //(model_id == 3)
    else if (strcmp(buf, "num_pivots")==0) 
    {
      fscanf(fp, " = %d\n", &(pSeiToneMapping->num_pivots));
    }

    else if (strcmp(buf, "coded_pivot_value")==0) 
    {
      fscanf(fp, " = ");
      for (i=0; i < pSeiToneMapping->num_pivots; i++)
        fscanf(fp, "%d\n", &(pSeiToneMapping->coded_pivot_value[i]));
    }
    else if (strcmp(buf, "sei_pivot_value")==0) 
    {
      fscanf(fp, " = ");
      for (i=0; i < pSeiToneMapping->num_pivots; i++)
        fscanf(fp, "%d\n", &(pSeiToneMapping->sei_pivot_value[i]));
    }
    else
    {
      // read till the line end 
      fgets(buf, sizeof(buf), fp);
    }
  }

  fclose(fp);

  return 0;
}

void InitToneMapping() 
{
  if (params->ToneMappingSEIPresentFlag == 0)
  {
    seiHasTone_mapping = FALSE;
    return;
  }
  else
    seiHasTone_mapping = TRUE;

  seiToneMapping.data = malloc( sizeof(Bitstream) );
  if( seiToneMapping.data == NULL ) no_mem_exit("InitToneMapping: seiToneMapping.data");
  seiToneMapping.data->streamBuffer = malloc(MAXRTPPAYLOADLEN);
  if( seiToneMapping.data->streamBuffer == NULL ) no_mem_exit("InitToneMapping: seiToneMapping.data->streamBuffer");
  memset( seiToneMapping.data->streamBuffer, 0, MAXRTPPAYLOADLEN);
  seiToneMapping.data->bits_to_go  = 8;
  seiToneMapping.data->byte_pos    = 0;
  seiToneMapping.data->byte_buf    = 0;
  seiToneMapping.payloadSize       = 0;

  // read tone mapping config from file
  ParseToneMappingConfigFile(&seiToneMapping);
}

void FinalizeToneMapping()
{
  Bitstream *bitstream = seiToneMapping.data;  
  int i;

  ue_v("SEI: tone_map_id"               , seiToneMapping.tone_map_id,             bitstream);
  u_1("SEI: tone_map_cancel_flag"       , seiToneMapping.tone_map_cancel_flag,    bitstream);

#ifdef PRINT_TONE_MAPPING
  printf("frame %d: Tone-mapping SEI message\n", img->frame_num);
  printf("tone_map_id = %d\n", seiToneMapping.tone_map_id);
  printf("tone_map_cancel_flag = %d\n", seiToneMapping.tone_map_cancel_flag);
#endif
  if (!seiToneMapping.tone_map_cancel_flag) 
  {
    ue_v(  "SEI: tone_map_repetition_period", seiToneMapping.tone_map_repetition_period, bitstream);
    u_v (8,"SEI: coded_data_bit_depth"      , seiToneMapping.coded_data_bit_depth,       bitstream);
    u_v (8,"SEI: sei_bit_depth"             , seiToneMapping.sei_bit_depth,              bitstream);
    ue_v(  "SEI: model_id"                  , seiToneMapping.model_id,                   bitstream);

#ifdef PRINT_TONE_MAPPING
    printf("tone_map_repetition_period = %d\n", seiToneMapping.tone_map_repetition_period);
    printf("coded_data_bit_depth = %d\n", seiToneMapping.coded_data_bit_depth);
    printf("sei_bit_depth = %d\n", seiToneMapping.sei_bit_depth);
    printf("model_id = %d\n", seiToneMapping.model_id);
#endif
    if (seiToneMapping.model_id == 0) 
    { // linear mapping
      u_v (32,"SEI: min_value", seiToneMapping.min_value, bitstream);
      u_v (32,"SEI: min_value", seiToneMapping.max_value, bitstream);
#ifdef PRINT_TONE_MAPPING
      printf("min_value = %d, max_value = %d\n", seiToneMapping.min_value, seiToneMapping.max_value);
#endif
    }
    else if (seiToneMapping.model_id == 1) 
    { // sigmoidal mapping
      u_v (32,"SEI: sigmoid_midpoint", seiToneMapping.sigmoid_midpoint,   bitstream);
      u_v (32,"SEI: sigmoid_width", seiToneMapping.sigmoid_width,         bitstream);
#ifdef PRINT_TONE_MAPPING
      printf("sigmoid_midpoint = %d, sigmoid_width = %d\n", seiToneMapping.sigmoid_midpoint, seiToneMapping.sigmoid_width);
#endif
    }
    else if (seiToneMapping.model_id == 2) 
    { // user defined table mapping
      int bit_depth_val = 1<<seiToneMapping.sei_bit_depth;
      for (i=0; i<bit_depth_val; i++) 
      {
        u_v((((seiToneMapping.coded_data_bit_depth+7)>>3)<<3), "SEI: start_of_coded_interval", seiToneMapping.start_of_coded_interval[i], bitstream);
#ifdef PRINT_TONE_MAPPING
        //printf("start_of_coded_interval[%d] = %d\n", i, seiToneMapping.start_of_coded_interval[i]);
#endif
      }
    }
    else if (seiToneMapping.model_id == 3) 
    {  // piece-wise linear mapping
      u_v (16,"SEI: num_pivots", seiToneMapping.num_pivots, bitstream);
#ifdef PRINT_TONE_MAPPING
      printf("num_pivots = %d\n", seiToneMapping.num_pivots);
#endif
      for (i=0; i < seiToneMapping.num_pivots; i++) 
      {
        u_v( (((seiToneMapping.coded_data_bit_depth+7)>>3)<<3), "SEI: coded_pivot_value",  seiToneMapping.coded_pivot_value[i], bitstream);
        u_v( (((seiToneMapping.sei_bit_depth+7)>>3)<<3), "SEI: sei_pivot_value",           seiToneMapping.sei_pivot_value[i],   bitstream);
#ifdef PRINT_TONE_MAPPING
        printf("coded_pivot_value[%d] = %d, sei_pivot_value[%d] = %d\n", i, seiToneMapping.coded_pivot_value[i], i, seiToneMapping.sei_pivot_value[i]);
#endif
      }
    }
  } // end !tone_map_cancel_flag

  // make sure the payload is byte aligned, stuff bits are 10..0
  if ( bitstream->bits_to_go != 8 )
  {
    (bitstream->byte_buf) <<= 1;
    bitstream->byte_buf |= 1;
    bitstream->bits_to_go--;
    if ( bitstream->bits_to_go != 0 ) 
      (bitstream->byte_buf) <<= (bitstream->bits_to_go);
    bitstream->bits_to_go = 8;
    bitstream->streamBuffer[bitstream->byte_pos++]=bitstream->byte_buf;
    bitstream->byte_buf = 0;
  }
  seiToneMapping.payloadSize = bitstream->byte_pos;
}


void UpdateToneMapping() 
{
  // return;

  // you may manually generate some test case here
}

void ClearToneMapping() 
{
  memset( seiToneMapping.data->streamBuffer, 0, MAXRTPPAYLOADLEN);
  seiToneMapping.data->bits_to_go  = 8;
  seiToneMapping.data->byte_pos    = 0;
  seiToneMapping.data->byte_buf    = 0;
  seiToneMapping.payloadSize       = 0;

  seiHasTone_mapping=FALSE;
}

void CloseToneMapping() 
{

  if (seiToneMapping.data)
  {
    free(seiToneMapping.data->streamBuffer);
    free(seiToneMapping.data);
  }
  seiToneMapping.data = NULL;
  seiHasTone_mapping = FALSE;
}

/*
 ************************************************************************
 *  \functions on post-filter message
 *  \brief
 *      Based on JVT-U035
 *  \author
 *      Steffen Wittmann <[e-mail]>
 ************************************************************************
 */
post_filter_information_struct seiPostFilterHints;

void InitPostFilterHints()
{
  seiPostFilterHints.data = malloc( sizeof(Bitstream) );
  if( seiPostFilterHints.data == NULL ) no_mem_exit("InitPostFilterHints: seiPostFilterHints.data");
  seiPostFilterHints.data->streamBuffer = malloc(MAXRTPPAYLOADLEN);
  if( seiPostFilterHints.data->streamBuffer == NULL ) no_mem_exit("InitPostFilterHints: seiPostFilterHints.data->streamBuffer");
  ClearPostFilterHints();
}

void ClearPostFilterHints()
{
  memset( seiPostFilterHints.data->streamBuffer, 0, MAXRTPPAYLOADLEN);
  seiPostFilterHints.data->bits_to_go  = 8;
  seiPostFilterHints.data->byte_pos    = 0;
  seiPostFilterHints.data->byte_buf    = 0;
  seiPostFilterHints.payloadSize       = 0;

  seiPostFilterHints.filter_hint_size_y        = 0;
  seiPostFilterHints.filter_hint_size_x        = 0;
  seiPostFilterHints.filter_hint_type          = 0;
  seiPostFilterHints.additional_extension_flag = 0;
}

void UpdatePostFilterHints()
{
  unsigned int color_component, cx, cy;
  seiPostFilterHints.filter_hint_type = 0; //define filter_hint_type here
  seiPostFilterHints.filter_hint_size_y = seiPostFilterHints.filter_hint_size_x = 5; //define filter_hint_size here
  get_mem3Dint(&seiPostFilterHints.filter_hint, 3, seiPostFilterHints.filter_hint_size_y, seiPostFilterHints.filter_hint_size_x);

  for (color_component = 0; color_component < 3; color_component ++)
    for (cy = 0; cy < seiPostFilterHints.filter_hint_size_y; cy ++)
      for (cx = 0; cx < seiPostFilterHints.filter_hint_size_x; cx ++)
        seiPostFilterHints.filter_hint[color_component][cy][cx] = 1; //define filter_hint here

  seiPostFilterHints.additional_extension_flag = 0;
}

void FinalizePostFilterHints()
{
  Bitstream *bitstream = seiPostFilterHints.data;
  unsigned int color_component, cx, cy;

  ue_v(  "SEI: post_filter_hint_size_y", seiPostFilterHints.filter_hint_size_y, bitstream);
  ue_v(  "SEI: post_filter_hint_size_x", seiPostFilterHints.filter_hint_size_x, bitstream);
  u_v (2,"SEI: post_filter_hint_type",   seiPostFilterHints.filter_hint_type,   bitstream);

  for (color_component = 0; color_component < 3; color_component ++)
    for (cy = 0; cy < seiPostFilterHints.filter_hint_size_y; cy ++)
      for (cx = 0; cx < seiPostFilterHints.filter_hint_size_x; cx ++)
        se_v("SEI: post_filter_hints", seiPostFilterHints.filter_hint[color_component][cy][cx], bitstream);

  u_1 ("SEI: post_filter_additional_extension_flag", seiPostFilterHints.additional_extension_flag, bitstream);

// #define PRINT_POST_FILTER_HINTS
#ifdef PRINT_POST_FILTER_HINTS
  printf(" post_filter_hint_size_y %d \n", seiPostFilterHints.filter_hint_size_y);
  printf(" post_filter_hint_size_x %d \n", seiPostFilterHints.filter_hint_size_x);
  printf(" post_filter_hint_type %d \n",   seiPostFilterHints.filter_hint_type);
  for (color_component = 0; color_component < 3; color_component ++)
    for (cy = 0; cy < seiPostFilterHints.filter_hint_size_y; cy ++)
      for (cx = 0; cx < seiPostFilterHints.filter_hint_size_x; cx ++)
        printf(" post_filter_hint[%d][%d][%d] %d \n", color_component, cy, cx, filter_hint[color_component][cy][cx]);

  printf(" additional_extension_flag %d \n", seiPostFilterHints.additional_extension_flag);

#undef PRINT_POST_FILTER_HINTS
#endif
  // make sure the payload is byte aligned, stuff bits are 10..0
  if ( bitstream->bits_to_go != 8 )
  {
    (bitstream->byte_buf) <<= 1;
    bitstream->byte_buf |= 1;
    bitstream->bits_to_go--;
    if ( bitstream->bits_to_go != 0 ) 
      (bitstream->byte_buf) <<= (bitstream->bits_to_go);
    bitstream->bits_to_go = 8;
    bitstream->streamBuffer[bitstream->byte_pos++]=bitstream->byte_buf;
    bitstream->byte_buf = 0;
  }
  seiPostFilterHints.payloadSize = bitstream->byte_pos;
}

void ClosePostFilterHints()
{
  if (seiPostFilterHints.data)
  {
    free(seiPostFilterHints.data->streamBuffer);
    free(seiPostFilterHints.data);  
    if (seiPostFilterHints.fi