?? sei.c
字號(hào):
seiHasPanScanRectInfo = TRUE;
}
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) );
if( seiUser_data_unregistered.data == NULL ) no_mem_exit("InitUser_data_unregistered: seiUser_data_unregistered.data");
seiUser_data_unregistered.data->streamBuffer = malloc(MAXRTPPAYLOADLEN);
if( seiUser_data_unregistered.data->streamBuffer == NULL ) no_mem_exit("InitUser_data_unregistered: seiUser_data_unregistered.data->streamBuffer");
seiUser_data_unregistered.byte = malloc(MAXRTPPAYLOADLEN);
if( seiUser_data_unregistered.byte == NULL ) no_mem_exit("InitUser_data_unregistered: seiUser_data_unregistered.byte");
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) );
if( seiUser_data_registered_itu_t_t35.data == NULL ) no_mem_exit("InitUser_data_unregistered: seiUser_data_registered_itu_t_t35.data");
seiUser_data_registered_itu_t_t35.data->streamBuffer = malloc(MAXRTPPAYLOADLEN);
if( seiUser_data_registered_itu_t_t35.data->streamBuffer == NULL ) no_mem_exit("InitUser_data_unregistered: seiUser_data_registered_itu_t_t35.data->streamBuffer");
seiUser_data_registered_itu_t_t35.byte = malloc(MAXRTPPAYLOADLEN);
if( seiUser_data_registered_itu_t_t35.data == NULL ) no_mem_exit("InitUser_data_unregistered: seiUser_data_registered_itu_t_t35.byte");
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) );
if( seiRandomAccess.data == NULL ) no_mem_exit("InitRandomAccess: seiRandomAccess.data");
seiRandomAccess.data->streamBuffer = malloc(MAXRTPPAYLOADLEN);
if( seiRandomAccess.data->streamBuffer == NULL ) no_mem_exit("InitRandomAccess: seiRandomAccess.data->streamBuffer");
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;
}
?? 快捷鍵說(shuō)明
復(fù)制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號(hào)
Ctrl + =
減小字號(hào)
Ctrl + -