}

void UpdatePanScanRectInfo()
{
  seiPanScanRectInfo.pan_scan_rect_id = 3;
  seiPanScanRectInfo.pan_scan_rect_left_offset = 10;
  seiPanScanRectInfo.pan_scan_rect_right_offset = 40;
  seiPanScanRectInfo.pan_scan_rect_top_offset = 20;
  seiPanScanRectInfo.pan_scan_rect_bottom_offset =32;
  seiHasPanScanRectInfo = TRUE;
}

void FinalizePanScanRectInfo()
{
  SyntaxElement sym;
  Bitstream *dest = seiPanScanRectInfo.data;


  sym.type = SE_HEADER;
  sym.mapping = ue_linfo;

  sym.value1 = seiPanScanRectInfo.pan_scan_rect_id;
  writeSyntaxElement2Buf_UVLC(&sym, dest);
  sym.value1 = seiPanScanRectInfo.pan_scan_rect_left_offset;
  writeSyntaxElement2Buf_UVLC(&sym, dest);
  sym.value1 = seiPanScanRectInfo.pan_scan_rect_right_offset;
  writeSyntaxElement2Buf_UVLC(&sym, dest);
  sym.value1 = seiPanScanRectInfo.pan_scan_rect_top_offset;
  writeSyntaxElement2Buf_UVLC(&sym, dest);
  sym.value1 = seiPanScanRectInfo.pan_scan_rect_bottom_offset;
  writeSyntaxElement2Buf_UVLC(&sym, dest);

// #define PRINT_PAN_SCAN_RECT
#ifdef PRINT_PAN_SCAN_RECT
  printf("Pan Scan Id %d Left %d Right %d Top %d Bottom %d \n", seiPanScanRectInfo.pan_scan_rect_id, seiPanScanRectInfo.pan_scan_rect_left_offset, seiPanScanRectInfo.pan_scan_rect_right_offset, seiPanScanRectInfo.pan_scan_rect_top_offset, seiPanScanRectInfo.pan_scan_rect_bottom_offset);
#endif
#ifdef PRINT_PAN_SCAN_RECT
#undef PRINT_PAN_SCAN_RECT
#endif
  // make sure the payload is byte aligned, stuff bits are 10..0
  if ( dest->bits_to_go != 8 )
  {
    (dest->byte_buf) <<= 1;
    dest->byte_buf |= 1;
    dest->bits_to_go--;
    if ( dest->bits_to_go != 0 ) (dest->byte_buf) <<= (dest->bits_to_go);
    dest->bits_to_go = 8;
    dest->streamBuffer[dest->byte_pos++]=dest->byte_buf;
    dest->byte_buf = 0;
  }
  seiPanScanRectInfo.payloadSize = dest->byte_pos;
}



void ClosePanScanRectInfo()
{
  if (seiPanScanRectInfo.data)
  {
    free(seiPanScanRectInfo.data->streamBuffer);
    free(seiPanScanRectInfo.data);
  }
  seiPanScanRectInfo.data = NULL;
}

/*
 **++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 *  \functions on arbitrary (unregistered) data
 *  \brief
 *      Based on FCD
 *  \author
 *      Shankar Regunathan                 <tian@cs.tut.fi>
 **++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 */
Boolean seiHasUser_data_unregistered_info;
user_data_unregistered_information_struct seiUser_data_unregistered;
void InitUser_data_unregistered()
{

  seiUser_data_unregistered.data = malloc( sizeof(Bitstream) );
  assert( seiUser_data_unregistered.data != NULL );
  seiUser_data_unregistered.data->streamBuffer = malloc(MAXRTPPAYLOADLEN);
  assert( seiUser_data_unregistered.data->streamBuffer != NULL );
  seiUser_data_unregistered.byte = malloc(MAXRTPPAYLOADLEN);
  assert( seiUser_data_unregistered.byte != NULL);
  ClearUser_data_unregistered();

}


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

  memset( seiUser_data_unregistered.byte, 0, MAXRTPPAYLOADLEN);
  seiUser_data_unregistered.total_byte = 0;

  seiHasUser_data_unregistered_info = TRUE;
}

void UpdateUser_data_unregistered()
{
  int i, temp_data;
  int total_byte;


  total_byte = 7;
  for(i = 0; i < total_byte; i++)
  {
    temp_data = i * 4;
    seiUser_data_unregistered.byte[i] = max(0, min(temp_data, 255));
  }
  seiUser_data_unregistered.total_byte = total_byte;
}

void FinalizeUser_data_unregistered()
{
  int i;
  SyntaxElement sym;
  Bitstream *dest = seiUser_data_unregistered.data;

  sym.type = SE_HEADER;
  sym.mapping = ue_linfo;

// #define PRINT_USER_DATA_UNREGISTERED_INFO
  for( i = 0; i < seiUser_data_unregistered.total_byte; i++)
  {
    sym.bitpattern = seiUser_data_unregistered.byte[i];
    sym.len = 8; // b (8)
    writeSyntaxElement2Buf_Fixed(&sym, dest);
#ifdef PRINT_USER_DATA_UNREGISTERED_INFO
    printf("Unreg data payload_byte = %d\n", seiUser_data_unregistered.byte[i]);
#endif
  }
#ifdef PRINT_USER_DATA_UNREGISTERED_INFO
#undef PRINT_USER_DATA_UNREGISTERED_INFO
#endif
  // make sure the payload is byte aligned, stuff bits are 10..0
  if ( dest->bits_to_go != 8 )
  {
    (dest->byte_buf) <<= 1;
    dest->byte_buf |= 1;
    dest->bits_to_go--;
    if ( dest->bits_to_go != 0 ) (dest->byte_buf) <<= (dest->bits_to_go);
    dest->bits_to_go = 8;
    dest->streamBuffer[dest->byte_pos++]=dest->byte_buf;
    dest->byte_buf = 0;
  }
  seiUser_data_unregistered.payloadSize = dest->byte_pos;
}

void CloseUser_data_unregistered()
{
  if (seiUser_data_unregistered.data)
  {
    free(seiUser_data_unregistered.data->streamBuffer);
    free(seiUser_data_unregistered.data);
  }
  seiUser_data_unregistered.data = NULL;
  if(seiUser_data_unregistered.byte)
  {
    free(seiUser_data_unregistered.byte);
  }
}


/*
 **++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 *  \functions on registered ITU_T_T35 user data
 *  \brief
 *      Based on FCD
 *  \author
 *      Shankar Regunathan                 <tian@cs.tut.fi>
 **++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 */
Boolean seiHasUser_data_registered_itu_t_t35_info;
user_data_registered_itu_t_t35_information_struct seiUser_data_registered_itu_t_t35;
void InitUser_data_registered_itu_t_t35()
{

  seiUser_data_registered_itu_t_t35.data = malloc( sizeof(Bitstream) );
  assert( seiUser_data_registered_itu_t_t35.data != NULL );
  seiUser_data_registered_itu_t_t35.data->streamBuffer = malloc(MAXRTPPAYLOADLEN);
  assert( seiUser_data_registered_itu_t_t35.data->streamBuffer != NULL );
  seiUser_data_registered_itu_t_t35.byte = malloc(MAXRTPPAYLOADLEN);
  assert( seiUser_data_registered_itu_t_t35.byte != NULL);
  ClearUser_data_registered_itu_t_t35();

}


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

  memset( seiUser_data_registered_itu_t_t35.byte, 0, MAXRTPPAYLOADLEN);
  seiUser_data_registered_itu_t_t35.total_byte = 0;
  seiUser_data_registered_itu_t_t35.itu_t_t35_country_code = 0;
  seiUser_data_registered_itu_t_t35.itu_t_t35_country_code_extension_byte = 0;

  seiHasUser_data_registered_itu_t_t35_info = TRUE;
}

void UpdateUser_data_registered_itu_t_t35()
{
  int i, temp_data;
  int total_byte;
  int country_code;

  country_code = 82; // Country_code for India

  if(country_code < 0xFF) 
  {
    seiUser_data_registered_itu_t_t35.itu_t_t35_country_code = country_code;
  }
  else 
  {
    seiUser_data_registered_itu_t_t35.itu_t_t35_country_code = 0xFF;
    seiUser_data_registered_itu_t_t35.itu_t_t35_country_code_extension_byte = country_code - 0xFF;
  }

  total_byte = 7;
  for(i = 0; i < total_byte; i++)
  {
    temp_data = i * 3;
    seiUser_data_registered_itu_t_t35.byte[i] = max(0, min(temp_data, 255));
  }
  seiUser_data_registered_itu_t_t35.total_byte = total_byte;
}

void FinalizeUser_data_registered_itu_t_t35()
{
  int i;
  SyntaxElement sym;
  Bitstream *dest = seiUser_data_registered_itu_t_t35.data;

  sym.type = SE_HEADER;
  sym.mapping = ue_linfo;

  sym.bitpattern = seiUser_data_registered_itu_t_t35.itu_t_t35_country_code;
  sym.len = 8;
  writeSyntaxElement2Buf_Fixed(&sym, dest);

// #define PRINT_USER_DATA_REGISTERED_ITU_T_T35_INFO
#ifdef PRINT_USER_DATA_REGISTERED_ITU_T_T35_INFO
  printf(" ITU_T_T35_COUNTRTY_CODE %d \n", seiUser_data_registered_itu_t_t35.itu_t_t35_country_code);
#endif

  if(seiUser_data_registered_itu_t_t35.itu_t_t35_country_code == 0xFF)
  {
    sym.bitpattern = seiUser_data_registered_itu_t_t35.itu_t_t35_country_code_extension_byte;
    sym.len = 8;
    writeSyntaxElement2Buf_Fixed(&sym, dest);
#ifdef PRINT_USER_DATA_REGISTERED_ITU_T_T35_INFO
    printf(" ITU_T_T35_COUNTRTY_CODE_EXTENSION_BYTE %d \n", seiUser_data_registered_itu_t_t35.itu_t_t35_country_code_extension_byte);
#endif
  }

  for( i = 0; i < seiUser_data_registered_itu_t_t35.total_byte; i++)
  {
    sym.bitpattern = seiUser_data_registered_itu_t_t35.byte[i];
    sym.len = 8; // b (8)
    writeSyntaxElement2Buf_Fixed(&sym, dest);
#ifdef PRINT_USER_DATA_REGISTERED_ITU_T_T35_INFO
    printf("itu_t_t35 payload_byte = %d\n", seiUser_data_registered_itu_t_t35.byte[i]);
#endif
  }
#ifdef PRINT_USER_DATA_REGISTERED_ITU_T_T35_INFO
#undef PRINT_USER_DATA_REGISTERED_ITU_T_T35_INFO
#endif
  // make sure the payload is byte aligned, stuff bits are 10..0
  if ( dest->bits_to_go != 8 )
  {
    (dest->byte_buf) <<= 1;
    dest->byte_buf |= 1;
    dest->bits_to_go--;
    if ( dest->bits_to_go != 0 ) (dest->byte_buf) <<= (dest->bits_to_go);
    dest->bits_to_go = 8;
    dest->streamBuffer[dest->byte_pos++]=dest->byte_buf;
    dest->byte_buf = 0;
  }
  seiUser_data_registered_itu_t_t35.payloadSize = dest->byte_pos;
}

void CloseUser_data_registered_itu_t_t35()
{
  if (seiUser_data_registered_itu_t_t35.data)
  {
    free(seiUser_data_registered_itu_t_t35.data->streamBuffer);
    free(seiUser_data_registered_itu_t_t35.data);
  }
  seiUser_data_registered_itu_t_t35.data = NULL;
  if(seiUser_data_registered_itu_t_t35.byte)
  {
    free(seiUser_data_registered_itu_t_t35.byte);
  }
}

/*
 **++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 *  \functions on random access message
 *  \brief
 *      Based on FCD
 *  \author
 *      Shankar Regunathan                 <tian@cs.tut.fi>
 **++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 */
Boolean seiHasRandomAccess_info;
randomaccess_information_struct seiRandomAccess;
void InitRandomAccess()
{

  seiRandomAccess.data = malloc( sizeof(Bitstream) );
  assert( seiRandomAccess.data != NULL );
  seiRandomAccess.data->streamBuffer = malloc(MAXRTPPAYLOADLEN);
  assert( seiRandomAccess.data->streamBuffer != NULL );
  ClearRandomAccess();

}


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

  seiRandomAccess.recovery_point_flag = 0;
  seiRandomAccess.broken_link_flag = 0;
  seiRandomAccess.exact_match_flag = 0;

  seiHasRandomAccess_info = FALSE;
}

void UpdateRandomAccess()
{

  if(img->type == I_SLICE)
  {
    seiRandomAccess.recovery_point_flag = 0;
    seiRandomAccess.exact_match_flag = 1;
    seiRandomAccess.broken_link_flag = 0;
    seiHasRandomAccess_info = TRUE;
  }
  else
  {
    seiHasRandomAccess_info = FALSE;
  }
}

void FinalizeRandomAccess()
{
  SyntaxElement sym;
  Bitstream *dest = seiRandomAccess.data;

  sym.type = SE_HEADER;
  sym.mapping = ue_linfo;

  sym.value1 = seiRandomAccess.recovery_point_flag;
  writeSyntaxElement2Buf_UVLC(&sym, dest);

  sym.bitpattern = seiRandomAccess.exact_match_flag;
  sym.len = 1;
  writeSyntaxElement2Buf_Fixed(&sym, dest);

  sym.bitpattern = seiRandomAccess.broken_link_flag;
  sym.len = 1;
  writeSyntaxElement2Buf_Fixed(&sym, dest);

// #define PRINT_RANDOM_ACCESS
#ifdef PRINT_RANDOM_ACCESS
  printf(" recovery_point_flag %d exact_match_flag %d broken_link_flag %d \n", seiRandomAccess.recovery_point_flag, seiRandomAccess.exact_match_flag, seiRandomAccess.broken_link_flag);
  printf(" %d %d \n", dest->byte_pos, dest->bits_to_go);
#endif
#ifdef PRINT_RANDOM_ACCESS
#undef PRINT_RANDOM_ACCESS
#endif
  // make sure the payload is byte aligned, stuff bits are 10..0
  if ( dest->bits_to_go != 8 )
  {
    (dest->byte_buf) <<= 1;
    dest->byte_buf |= 1;
    dest->bits_to_go--;
    if ( dest->bits_to_go != 0 ) (dest->byte_buf) <<= (dest->bits_to_go);
    dest->bits_to_go = 8;
    dest->streamBuffer[dest->byte_pos++]=dest->byte_buf;
    dest->byte_buf = 0;
  }
  seiRandomAccess.payloadSize = dest->byte_pos;
}

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