steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/h264dec/ldecod/src/sei.c

2133 lines
72 KiB
C
Raw Blame History

/*!
************************************************************************
* \file sei.c
*
* \brief
* Functions to implement SEI messages
*
* \author
* Main contributors (see contributors.h for copyright, address and affiliation details)
* - Dong Tian <tian@cs.tut.fi>
* - Karsten Suehring <suehring@hhi.de>
************************************************************************
*/
#include "contributors.h"
#include <math.h>
#include "global.h"
#include "memalloc.h"
#include "sei.h"
#include "vlc.h"
#include "header.h"
#include "mbuffer.h"
#include "parset.h"
// #define PRINT_BUFFERING_PERIOD_INFO // uncomment to print buffering period SEI info
// #define PRINT_PCITURE_TIMING_INFO // uncomment to print picture timing SEI info
// #define WRITE_MAP_IMAGE // uncomment to write spare picture map
// #define PRINT_SUBSEQUENCE_INFO // uncomment to print sub-sequence SEI info
// #define PRINT_SUBSEQUENCE_LAYER_CHAR // uncomment to print sub-sequence layer characteristics SEI info
// #define PRINT_SUBSEQUENCE_CHAR // uncomment to print sub-sequence characteristics SEI info
// #define PRINT_SCENE_INFORMATION // uncomment to print scene information SEI info
// #define PRINT_PAN_SCAN_RECT // uncomment to print pan-scan rectangle SEI info
// #define PRINT_RECOVERY_POINT // uncomment to print random access point SEI info
// #define PRINT_FILLER_PAYLOAD_INFO // uncomment to print filler payload SEI info
// #define PRINT_DEC_REF_PIC_MARKING // uncomment to print decoded picture buffer management repetition SEI info
// #define PRINT_RESERVED_INFO // uncomment to print reserved SEI info
// #define PRINT_USER_DATA_UNREGISTERED_INFO // uncomment to print unregistered user data SEI info
// #define PRINT_USER_DATA_REGISTERED_ITU_T_T35_INFO // uncomment to print ITU-T T.35 user data SEI info
// #define PRINT_FULL_FRAME_FREEZE_INFO // uncomment to print full-frame freeze SEI info
// #define PRINT_FULL_FRAME_FREEZE_RELEASE_INFO // uncomment to print full-frame freeze release SEI info
// #define PRINT_FULL_FRAME_SNAPSHOT_INFO // uncomment to print full-frame snapshot SEI info
// #define PRINT_PROGRESSIVE_REFINEMENT_END_INFO // uncomment to print Progressive refinement segment start SEI info
// #define PRINT_PROGRESSIVE_REFINEMENT_END_INFO // uncomment to print Progressive refinement segment end SEI info
// #define PRINT_MOTION_CONST_SLICE_GROUP_SET_INFO // uncomment to print Motion-constrained slice group set SEI info
// #define PRINT_FILM_GRAIN_CHARACTERISTICS_INFO // uncomment to print Film grain characteristics SEI info
// #define PRINT_DEBLOCKING_FILTER_DISPLAY_PREFERENCE_INFO // uncomment to print deblocking filter display preference SEI info
// #define PRINT_STEREO_VIDEO_INFO_INFO // uncomment to print stero video SEI info
// #define PRINT_TONE_MAPPING // uncomment to print tone-mapping SEI info
// #define PRINT_POST_FILTER_HINT_INFO // uncomment to print post-filter hint SEI info
/*!
************************************************************************
* \brief
* Interpret the SEI rbsp
* \param msg
* a pointer that point to the sei message.
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void InterpretSEIMessage(byte* msg, int size, VideoParameters *p_Vid)
{
int payload_type = 0;
int payload_size = 0;
int offset = 1;
byte tmp_byte;
do
{
// sei_message();
payload_type = 0;
tmp_byte = msg[offset++];
while (tmp_byte == 0xFF)
{
payload_type += 255;
tmp_byte = msg[offset++];
}
payload_type += tmp_byte; // this is the last byte
payload_size = 0;
tmp_byte = msg[offset++];
while (tmp_byte == 0xFF)
{
payload_size += 255;
tmp_byte = msg[offset++];
}
payload_size += tmp_byte; // this is the last byte
switch ( payload_type ) // sei_payload( type, size );
{
case SEI_BUFFERING_PERIOD:
interpret_buffering_period_info( msg+offset, payload_size, p_Vid );
break;
case SEI_PIC_TIMING:
interpret_picture_timing_info( msg+offset, payload_size, p_Vid );
break;
case SEI_PAN_SCAN_RECT:
interpret_pan_scan_rect_info( msg+offset, payload_size, p_Vid );
break;
case SEI_FILLER_PAYLOAD:
interpret_filler_payload_info( msg+offset, payload_size, p_Vid );
break;
case SEI_USER_DATA_REGISTERED_ITU_T_T35:
interpret_user_data_registered_itu_t_t35_info( msg+offset, payload_size, p_Vid );
break;
case SEI_USER_DATA_UNREGISTERED:
interpret_user_data_unregistered_info( msg+offset, payload_size, p_Vid );
break;
case SEI_RECOVERY_POINT:
interpret_recovery_point_info( msg+offset, payload_size, p_Vid );
break;
case SEI_DEC_REF_PIC_MARKING_REPETITION:
interpret_dec_ref_pic_marking_repetition_info( msg+offset, payload_size, p_Vid );
break;
case SEI_SPARE_PIC:
interpret_spare_pic( msg+offset, payload_size, p_Vid );
break;
case SEI_SCENE_INFO:
interpret_scene_information( msg+offset, payload_size, p_Vid );
break;
case SEI_SUB_SEQ_INFO:
interpret_subsequence_info( msg+offset, payload_size, p_Vid );
break;
case SEI_SUB_SEQ_LAYER_CHARACTERISTICS:
interpret_subsequence_layer_characteristics_info( msg+offset, payload_size, p_Vid );
break;
case SEI_SUB_SEQ_CHARACTERISTICS:
interpret_subsequence_characteristics_info( msg+offset, payload_size, p_Vid );
break;
case SEI_FULL_FRAME_FREEZE:
interpret_full_frame_freeze_info( msg+offset, payload_size, p_Vid );
break;
case SEI_FULL_FRAME_FREEZE_RELEASE:
interpret_full_frame_freeze_release_info( msg+offset, payload_size, p_Vid );
break;
case SEI_FULL_FRAME_SNAPSHOT:
interpret_full_frame_snapshot_info( msg+offset, payload_size, p_Vid );
break;
case SEI_PROGRESSIVE_REFINEMENT_SEGMENT_START:
interpret_progressive_refinement_start_info( msg+offset, payload_size, p_Vid );
break;
case SEI_PROGRESSIVE_REFINEMENT_SEGMENT_END:
interpret_progressive_refinement_end_info( msg+offset, payload_size, p_Vid );
break;
case SEI_MOTION_CONSTRAINED_SLICE_GROUP_SET:
interpret_motion_constrained_slice_group_set_info( msg+offset, payload_size, p_Vid );
case SEI_FILM_GRAIN_CHARACTERISTICS:
interpret_film_grain_characteristics_info ( msg+offset, payload_size, p_Vid );
break;
case SEI_DEBLOCKING_FILTER_DISPLAY_PREFERENCE:
interpret_deblocking_filter_display_preference_info ( msg+offset, payload_size, p_Vid );
break;
case SEI_STEREO_VIDEO_INFO:
interpret_stereo_video_info_info ( msg+offset, payload_size, p_Vid );
break;
case SEI_TONE_MAPPING:
interpret_tone_mapping( msg+offset, payload_size, p_Vid );
break;
case SEI_POST_FILTER_HINTS:
interpret_post_filter_hints_info ( msg+offset, payload_size, p_Vid );
default:
interpret_reserved_info( msg+offset, payload_size, p_Vid );
break;
}
offset += payload_size;
} while( msg[offset] != 0x80 ); // more_rbsp_data() msg[offset] != 0x80
// ignore the trailing bits rbsp_trailing_bits();
assert(msg[offset] == 0x80); // this is the trailing bits
assert( offset+1 == size );
}
/*!
************************************************************************
* \brief
* Interpret the spare picture SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_spare_pic( byte* payload, int size, VideoParameters *p_Vid )
{
int i,x,y;
Bitstream* buf;
int bit0, bit1, bitc, no_bit0;
int target_frame_num = 0;
int num_spare_pics;
int delta_spare_frame_num, CandidateSpareFrameNum, SpareFrameNum = 0;
int ref_area_indicator;
int m, n, left, right, top, bottom,directx, directy;
byte ***map;
#ifdef WRITE_MAP_IMAGE
int symbol_size_in_bytes = p_Vid->pic_unit_bitsize_on_disk/8;
int j, k, i0, j0, tmp, kk;
char filename[20] = "map_dec.yuv";
FILE *fp;
imgpel** Y;
static int old_pn=-1;
static int first = 1;
printf("Spare picture SEI message\n");
#endif
assert( payload!=NULL);
assert( p_Vid!=NULL);
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
target_frame_num = ue_v("SEI: target_frame_num", buf);
#ifdef WRITE_MAP_IMAGE
printf( "target_frame_num is %d\n", target_frame_num );
#endif
num_spare_pics = 1 + ue_v("SEI: num_spare_pics_minus1", buf);
#ifdef WRITE_MAP_IMAGE
printf( "num_spare_pics is %d\n", num_spare_pics );
#endif
get_mem3D(&map, num_spare_pics, p_Vid->height >> 4, p_Vid->width >> 4);
for (i=0; i<num_spare_pics; i++)
{
if (i==0)
{
CandidateSpareFrameNum = target_frame_num - 1;
if ( CandidateSpareFrameNum < 0 ) CandidateSpareFrameNum = MAX_FN - 1;
}
else
CandidateSpareFrameNum = SpareFrameNum;
delta_spare_frame_num = ue_v("SEI: delta_spare_frame_num", buf);
SpareFrameNum = CandidateSpareFrameNum - delta_spare_frame_num;
if( SpareFrameNum < 0 )
SpareFrameNum = MAX_FN + SpareFrameNum;
ref_area_indicator = ue_v("SEI: ref_area_indicator", buf);
switch ( ref_area_indicator )
{
case 0: // The whole frame can serve as spare picture
for (y=0; y<p_Vid->height >> 4; y++)
for (x=0; x<p_Vid->width >> 4; x++)
map[i][y][x] = 0;
break;
case 1: // The map is not compressed
for (y=0; y<p_Vid->height >> 4; y++)
for (x=0; x<p_Vid->width >> 4; x++)
{
map[i][y][x] = (byte) u_1("SEI: ref_mb_indicator", buf);
}
break;
case 2: // The map is compressed
//!KS: could not check this function, description is unclear (as stated in Ed. Note)
bit0 = 0;
bit1 = 1;
bitc = bit0;
no_bit0 = -1;
x = ( (p_Vid->width >> 4) - 1 ) / 2;
y = ( (p_Vid->height >> 4) - 1 ) / 2;
left = right = x;
top = bottom = y;
directx = 0;
directy = 1;
for (m=0; m<p_Vid->height >> 4; m++)
for (n=0; n<p_Vid->width >> 4; n++)
{
if (no_bit0<0)
{
no_bit0 = ue_v("SEI: zero_run_length", buf);
}
if (no_bit0>0)
map[i][y][x] = (byte) bit0;
else
map[i][y][x] = (byte) bit1;
no_bit0--;
// go to the next mb:
if ( directx == -1 && directy == 0 )
{
if (x > left) x--;
else if (x == 0)
{
y = bottom + 1;
bottom++;
directx = 1;
directy = 0;
}
else if (x == left)
{
x--;
left--;
directx = 0;
directy = 1;
}
}
else if ( directx == 1 && directy == 0 )
{
if (x < right) x++;
else if (x == (p_Vid->width >> 4) - 1)
{
y = top - 1;
top--;
directx = -1;
directy = 0;
}
else if (x == right)
{
x++;
right++;
directx = 0;
directy = -1;
}
}
else if ( directx == 0 && directy == -1 )
{
if ( y > top) y--;
else if (y == 0)
{
x = left - 1;
left--;
directx = 0;
directy = 1;
}
else if (y == top)
{
y--;
top--;
directx = -1;
directy = 0;
}
}
else if ( directx == 0 && directy == 1 )
{
if (y < bottom) y++;
else if (y == (p_Vid->height >> 4) - 1)
{
x = right+1;
right++;
directx = 0;
directy = -1;
}
else if (y == bottom)
{
y++;
bottom++;
directx = 1;
directy = 0;
}
}
}
break;
default:
printf( "Wrong ref_area_indicator %d!\n", ref_area_indicator );
exit(0);
break;
}
} // end of num_spare_pics
#ifdef WRITE_MAP_IMAGE
// begin to write map seq
if ( old_pn != p_Vid->number )
{
old_pn = p_Vid->number;
get_mem2Dpel(&Y, p_Vid->height, p_Vid->width);
if (first)
{
fp = fopen( filename, "wb" );
first = 0;
}
else
fp = fopen( filename, "ab" );
assert( fp != NULL );
for (kk=0; kk<num_spare_pics; kk++)
{
for (i=0; i < p_Vid->height >> 4; i++)
for (j=0; j < p_Vid->width >> 4; j++)
{
tmp=map[kk][i][j]==0? p_Vid->max_pel_value_comp[0] : 0;
for (i0=0; i0<16; i0++)
for (j0=0; j0<16; j0++)
Y[i*16+i0][j*16+j0]=tmp;
}
// write the map image
for (i=0; i < p_Vid->height; i++)
for (j=0; j < p_Vid->width; j++)
fwrite(&(Y[i][j]), symbol_size_in_bytes, 1, p_out);
for (k=0; k < 2; k++)
for (i=0; i < p_Vid->height>>1; i++)
for (j=0; j < p_Vid->width>>1; j++)
fwrite(&(p_Vid->dc_pred_value_comp[1]), symbol_size_in_bytes, 1, p_out);
}
fclose( fp );
free_mem2Dpel( Y );
}
// end of writing map image
#undef WRITE_MAP_IMAGE
#endif
free_mem3D( map );
free(buf);
}
/*!
************************************************************************
* \brief
* Interpret the Sub-sequence information SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_subsequence_info( byte* payload, int size, VideoParameters *p_Vid )
{
Bitstream* buf;
int sub_seq_layer_num, sub_seq_id, first_ref_pic_flag, leading_non_ref_pic_flag, last_pic_flag,
sub_seq_frame_num_flag, sub_seq_frame_num;
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
sub_seq_layer_num = ue_v("SEI: sub_seq_layer_num" , buf);
sub_seq_id = ue_v("SEI: sub_seq_id" , buf);
first_ref_pic_flag = u_1 ("SEI: first_ref_pic_flag" , buf);
leading_non_ref_pic_flag = u_1 ("SEI: leading_non_ref_pic_flag", buf);
last_pic_flag = u_1 ("SEI: last_pic_flag" , buf);
sub_seq_frame_num_flag = u_1 ("SEI: sub_seq_frame_num_flag" , buf);
if (sub_seq_frame_num_flag)
{
sub_seq_frame_num = ue_v("SEI: sub_seq_frame_num" , buf);
}
#ifdef PRINT_SUBSEQUENCE_INFO
printf("Sub-sequence information SEI message\n");
printf("sub_seq_layer_num = %d\n", sub_seq_layer_num );
printf("sub_seq_id = %d\n", sub_seq_id);
printf("first_ref_pic_flag = %d\n", first_ref_pic_flag);
printf("leading_non_ref_pic_flag = %d\n", leading_non_ref_pic_flag);
printf("last_pic_flag = %d\n", last_pic_flag);
printf("sub_seq_frame_num_flag = %d\n", sub_seq_frame_num_flag);
if (sub_seq_frame_num_flag)
{
printf("sub_seq_frame_num = %d\n", sub_seq_frame_num);
}
#endif
free(buf);
#ifdef PRINT_SUBSEQUENCE_INFO
#undef PRINT_SUBSEQUENCE_INFO
#endif
}
/*!
************************************************************************
* \brief
* Interpret the Sub-sequence layer characteristics SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_subsequence_layer_characteristics_info( byte* payload, int size, VideoParameters *p_Vid )
{
Bitstream* buf;
long num_sub_layers, accurate_statistics_flag, average_bit_rate, average_frame_rate;
int i;
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
num_sub_layers = 1 + ue_v("SEI: num_sub_layers_minus1", buf);
#ifdef PRINT_SUBSEQUENCE_LAYER_CHAR
printf("Sub-sequence layer characteristics SEI message\n");
printf("num_sub_layers_minus1 = %d\n", num_sub_layers - 1);
#endif
for (i=0; i<num_sub_layers; i++)
{
accurate_statistics_flag = u_1( "SEI: accurate_statistics_flag", buf);
average_bit_rate = u_v(16,"SEI: average_bit_rate" , buf);
average_frame_rate = u_v(16,"SEI: average_frame_rate" , buf);
#ifdef PRINT_SUBSEQUENCE_LAYER_CHAR
printf("layer %d: accurate_statistics_flag = %ld \n", i, accurate_statistics_flag);
printf("layer %d: average_bit_rate = %ld \n", i, average_bit_rate);
printf("layer %d: average_frame_rate = %ld \n", i, average_frame_rate);
#endif
}
free (buf);
}
/*!
************************************************************************
* \brief
* Interpret the Sub-sequence characteristics SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_subsequence_characteristics_info( byte* payload, int size, VideoParameters *p_Vid )
{
Bitstream* buf;
int i;
int sub_seq_layer_num, sub_seq_id, duration_flag, average_rate_flag, accurate_statistics_flag;
unsigned long sub_seq_duration, average_bit_rate, average_frame_rate;
int num_referenced_subseqs, ref_sub_seq_layer_num, ref_sub_seq_id, ref_sub_seq_direction;
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
sub_seq_layer_num = ue_v("SEI: sub_seq_layer_num", buf);
sub_seq_id = ue_v("SEI: sub_seq_id", buf);
duration_flag = u_1 ("SEI: duration_flag", buf);
#ifdef PRINT_SUBSEQUENCE_CHAR
printf("Sub-sequence characteristics SEI message\n");
printf("sub_seq_layer_num = %d\n", sub_seq_layer_num );
printf("sub_seq_id = %d\n", sub_seq_id);
printf("duration_flag = %d\n", duration_flag);
#endif
if ( duration_flag )
{
sub_seq_duration = u_v (32, "SEI: duration_flag", buf);
#ifdef PRINT_SUBSEQUENCE_CHAR
printf("sub_seq_duration = %ld\n", sub_seq_duration);
#endif
}
average_rate_flag = u_1 ("SEI: average_rate_flag", buf);
#ifdef PRINT_SUBSEQUENCE_CHAR
printf("average_rate_flag = %d\n", average_rate_flag);
#endif
if ( average_rate_flag )
{
accurate_statistics_flag = u_1 ( "SEI: accurate_statistics_flag", buf);
average_bit_rate = u_v (16, "SEI: average_bit_rate", buf);
average_frame_rate = u_v (16, "SEI: average_frame_rate", buf);
#ifdef PRINT_SUBSEQUENCE_CHAR
printf("accurate_statistics_flag = %d\n", accurate_statistics_flag);
printf("average_bit_rate = %ld\n", average_bit_rate);
printf("average_frame_rate = %ld\n", average_frame_rate);
#endif
}
num_referenced_subseqs = ue_v("SEI: num_referenced_subseqs", buf);
#ifdef PRINT_SUBSEQUENCE_CHAR
printf("num_referenced_subseqs = %d\n", num_referenced_subseqs);
#endif
for (i=0; i<num_referenced_subseqs; i++)
{
ref_sub_seq_layer_num = ue_v("SEI: ref_sub_seq_layer_num", buf);
ref_sub_seq_id = ue_v("SEI: ref_sub_seq_id", buf);
ref_sub_seq_direction = u_1 ("SEI: ref_sub_seq_direction", buf);
#ifdef PRINT_SUBSEQUENCE_CHAR
printf("ref_sub_seq_layer_num = %d\n", ref_sub_seq_layer_num);
printf("ref_sub_seq_id = %d\n", ref_sub_seq_id);
printf("ref_sub_seq_direction = %d\n", ref_sub_seq_direction);
#endif
}
free( buf );
#ifdef PRINT_SUBSEQUENCE_CHAR
#undef PRINT_SUBSEQUENCE_CHAR
#endif
}
/*!
************************************************************************
* \brief
* Interpret the Scene information SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_scene_information( byte* payload, int size, VideoParameters *p_Vid )
{
Bitstream* buf;
int scene_id, scene_transition_type, second_scene_id;
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
scene_id = ue_v("SEI: scene_id" , buf);
scene_transition_type = ue_v("SEI: scene_transition_type", buf);
if ( scene_transition_type > 3 )
{
second_scene_id = ue_v("SEI: scene_transition_type", buf);;
}
#ifdef PRINT_SCENE_INFORMATION
printf("Scene information SEI message\n");
printf("scene_transition_type = %d\n", scene_transition_type);
printf("scene_id = %d\n", scene_id);
if ( scene_transition_type > 3 )
{
printf("second_scene_id = %d\n", second_scene_id);
}
#endif
free( buf );
#ifdef PRINT_SCENE_INFORMATION
#undef PRINT_SCENE_INFORMATION
#endif
}
/*!
************************************************************************
* \brief
* Interpret the Filler payload SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_filler_payload_info( byte* payload, int size, VideoParameters *p_Vid )
{
int payload_cnt = 0;
while (payload_cnt<size)
{
if (payload[payload_cnt] == 0xFF)
{
payload_cnt++;
}
}
#ifdef PRINT_FILLER_PAYLOAD_INFO
printf("Filler payload SEI message\n");
if (payload_cnt==size)
{
printf("read %d bytes of filler payload\n", payload_cnt);
}
else
{
printf("error reading filler payload: not all bytes are 0xFF (%d of %d)\n", payload_cnt, size);
}
#endif
#ifdef PRINT_FILLER_PAYLOAD_INFO
#undef PRINT_FILLER_PAYLOAD_INFO
#endif
}
/*!
************************************************************************
* \brief
* Interpret the User data unregistered SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_user_data_unregistered_info( byte* payload, int size, VideoParameters *p_Vid )
{
int offset = 0;
byte payload_byte;
#ifdef PRINT_USER_DATA_UNREGISTERED_INFO
printf("User data unregistered SEI message\n");
printf("uuid_iso_11578 = 0x");
#endif
assert (size>=16);
for (offset = 0; offset < 16; offset++)
{
#ifdef PRINT_USER_DATA_UNREGISTERED_INFO
printf("%02x",payload[offset]);
#endif
}
#ifdef PRINT_USER_DATA_UNREGISTERED_INFO
printf("\n");
#endif
while (offset < size)
{
payload_byte = payload[offset];
offset ++;
#ifdef PRINT_USER_DATA_UNREGISTERED_INFO
printf("Unreg data payload_byte = %d\n", payload_byte);
#endif
}
#ifdef PRINT_USER_DATA_UNREGISTERED_INFO
#undef PRINT_USER_DATA_UNREGISTERED_INFO
#endif
}
/*!
************************************************************************
* \brief
* Interpret the User data registered by ITU-T T.35 SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_user_data_registered_itu_t_t35_info( byte* payload, int size, VideoParameters *p_Vid )
{
int offset = 0;
byte itu_t_t35_country_code, itu_t_t35_country_code_extension_byte, payload_byte;
itu_t_t35_country_code = payload[offset];
offset++;
#ifdef PRINT_USER_DATA_REGISTERED_ITU_T_T35_INFO
printf("User data registered by ITU-T T.35 SEI message\n");
printf(" itu_t_t35_country_code = %d \n", itu_t_t35_country_code);
#endif
if(itu_t_t35_country_code == 0xFF)
{
itu_t_t35_country_code_extension_byte = payload[offset];
offset++;
#ifdef PRINT_USER_DATA_REGISTERED_ITU_T_T35_INFO
printf(" ITU_T_T35_COUNTRY_CODE_EXTENSION_BYTE %d \n", itu_t_t35_country_code_extension_byte);
#endif
}
while (offset < size)
{
payload_byte = payload[offset];
offset ++;
#ifdef PRINT_USER_DATA_REGISTERED_ITU_T_T35_INFO
printf("itu_t_t35 payload_byte = %d\n", payload_byte);
#endif
}
#ifdef PRINT_USER_DATA_REGISTERED_ITU_T_T35_INFO
#undef PRINT_USER_DATA_REGISTERED_ITU_T_T35_INFO
#endif
}
/*!
************************************************************************
* \brief
* Interpret the Pan scan rectangle SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_pan_scan_rect_info( byte* payload, int size, VideoParameters *p_Vid )
{
int pan_scan_rect_cancel_flag;
int pan_scan_cnt_minus1, i;
int pan_scan_rect_repetition_period;
int pan_scan_rect_id, pan_scan_rect_left_offset, pan_scan_rect_right_offset;
int pan_scan_rect_top_offset, pan_scan_rect_bottom_offset;
Bitstream* buf;
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
pan_scan_rect_id = ue_v("SEI: pan_scan_rect_id", buf);
pan_scan_rect_cancel_flag = u_1("SEI: pan_scan_rect_cancel_flag", buf);
if (!pan_scan_rect_cancel_flag)
{
pan_scan_cnt_minus1 = ue_v("SEI: pan_scan_cnt_minus1", buf);
for (i = 0; i <= pan_scan_cnt_minus1; i++)
{
pan_scan_rect_left_offset = se_v("SEI: pan_scan_rect_left_offset" , buf);
pan_scan_rect_right_offset = se_v("SEI: pan_scan_rect_right_offset" , buf);
pan_scan_rect_top_offset = se_v("SEI: pan_scan_rect_top_offset" , buf);
pan_scan_rect_bottom_offset = se_v("SEI: pan_scan_rect_bottom_offset", buf);
#ifdef PRINT_PAN_SCAN_RECT
printf("Pan scan rectangle SEI message %d/%d\n", i, pan_scan_cnt_minus1);
printf("pan_scan_rect_id = %d\n", pan_scan_rect_id);
printf("pan_scan_rect_left_offset = %d\n", pan_scan_rect_left_offset);
printf("pan_scan_rect_right_offset = %d\n", pan_scan_rect_right_offset);
printf("pan_scan_rect_top_offset = %d\n", pan_scan_rect_top_offset);
printf("pan_scan_rect_bottom_offset = %d\n", pan_scan_rect_bottom_offset);
#endif
}
pan_scan_rect_repetition_period = ue_v("SEI: pan_scan_rect_repetition_period", buf);
}
free (buf);
#ifdef PRINT_PAN_SCAN_RECT
#undef PRINT_PAN_SCAN_RECT
#endif
}
/*!
************************************************************************
* \brief
* Interpret the Random access point SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_recovery_point_info( byte* payload, int size, VideoParameters *p_Vid )
{
int recovery_frame_cnt, exact_match_flag, broken_link_flag, changing_slice_group_idc;
Bitstream* buf;
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
recovery_frame_cnt = ue_v( "SEI: recovery_frame_cnt" , buf);
exact_match_flag = u_1 ( "SEI: exact_match_flag" , buf);
broken_link_flag = u_1 ( "SEI: broken_link_flag" , buf);
changing_slice_group_idc = u_v ( 2, "SEI: changing_slice_group_idc", buf);
p_Vid->recovery_point = 1;
p_Vid->recovery_frame_cnt = recovery_frame_cnt;
#ifdef PRINT_RECOVERY_POINT
printf("Recovery point SEI message\n");
printf("recovery_frame_cnt = %d\n", recovery_frame_cnt);
printf("exact_match_flag = %d\n", exact_match_flag);
printf("broken_link_flag = %d\n", broken_link_flag);
printf("changing_slice_group_idc = %d\n", changing_slice_group_idc);
#endif
free (buf);
#ifdef PRINT_RECOVERY_POINT
#undef PRINT_RECOVERY_POINT
#endif
}
/*!
************************************************************************
* \brief
* Interpret the Decoded Picture Buffer Management Repetition SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_dec_ref_pic_marking_repetition_info( byte* payload, int size, VideoParameters *p_Vid )
{
int original_idr_flag, original_frame_num;
int original_field_pic_flag, original_bottom_field_flag;
DecRefPicMarking_t *tmp_drpm;
DecRefPicMarking_t *old_drpm;
int old_idr_flag , old_no_output_of_prior_pics_flag, old_long_term_reference_flag , old_adaptive_ref_pic_buffering_flag;
Bitstream* buf;
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
original_idr_flag = u_1 ( "SEI: original_idr_flag" , buf);
original_frame_num = ue_v( "SEI: original_frame_num" , buf);
if ( !p_Vid->active_sps->frame_mbs_only_flag )
{
original_field_pic_flag = u_1 ( "SEI: original_field_pic_flag", buf);
if ( original_field_pic_flag )
{
original_bottom_field_flag = u_1 ( "SEI: original_bottom_field_flag", buf);
}
}
#ifdef PRINT_DEC_REF_PIC_MARKING
printf("Decoded Picture Buffer Management Repetition SEI message\n");
printf("original_idr_flag = %d\n", original_idr_flag);
printf("original_frame_num = %d\n", original_frame_num);
if ( active_sps->frame_mbs_only_flag )
{
printf("original_field_pic_flag = %d\n", original_field_pic_flag);
if ( original_field_pic_flag )
{
printf("original_bottom_field_flag = %d\n", original_bottom_field_flag);
}
}
#endif
// we need to save everything that is probably overwritten in dec_ref_pic_marking()
old_drpm = p_Vid->dec_ref_pic_marking_buffer;
old_idr_flag = p_Vid->idr_flag;
old_no_output_of_prior_pics_flag = p_Vid->no_output_of_prior_pics_flag;
old_long_term_reference_flag = p_Vid->long_term_reference_flag;
old_adaptive_ref_pic_buffering_flag = p_Vid->adaptive_ref_pic_buffering_flag;
// set new initial values
p_Vid->idr_flag = original_idr_flag;
p_Vid->dec_ref_pic_marking_buffer = NULL;
dec_ref_pic_marking(p_Vid, buf);
// print out decoded values
#ifdef PRINT_DEC_REF_PIC_MARKING
if (p_Vid->idr_flag)
{
printf("no_output_of_prior_pics_flag = %d\n", p_Vid->no_output_of_prior_pics_flag);
printf("long_term_reference_flag = %d\n", p_Vid->long_term_reference_flag);
}
else
{
printf("adaptive_ref_pic_buffering_flag = %d\n", p_Vid->adaptive_ref_pic_buffering_flag);
if (p_Vid->adaptive_ref_pic_buffering_flag)
{
tmp_drpm=p_Vid->dec_ref_pic_marking_buffer;
while (tmp_drpm != NULL)
{
printf("memory_management_control_operation = %d\n", tmp_drpm->memory_management_control_operation);
if ((tmp_drpm->memory_management_control_operation==1)||(tmp_drpm->memory_management_control_operation==3))
{
printf("difference_of_pic_nums_minus1 = %d\n", tmp_drpm->difference_of_pic_nums_minus1);
}
if (tmp_drpm->memory_management_control_operation==2)
{
printf("long_term_pic_num = %d\n", tmp_drpm->long_term_pic_num);
}
if ((tmp_drpm->memory_management_control_operation==3)||(tmp_drpm->memory_management_control_operation==6))
{
printf("long_term_frame_idx = %d\n", tmp_drpm->long_term_frame_idx);
}
if (tmp_drpm->memory_management_control_operation==4)
{
printf("max_long_term_pic_idx_plus1 = %d\n", tmp_drpm->max_long_term_frame_idx_plus1);
}
tmp_drpm = tmp_drpm->Next;
}
}
}
#endif
while (p_Vid->dec_ref_pic_marking_buffer)
{
tmp_drpm=p_Vid->dec_ref_pic_marking_buffer;
p_Vid->dec_ref_pic_marking_buffer=tmp_drpm->Next;
free (tmp_drpm);
}
// restore old values in p_Vid
p_Vid->dec_ref_pic_marking_buffer = old_drpm;
p_Vid->idr_flag = old_idr_flag;
p_Vid->no_output_of_prior_pics_flag = old_no_output_of_prior_pics_flag;
p_Vid->long_term_reference_flag = old_long_term_reference_flag;
p_Vid->adaptive_ref_pic_buffering_flag = old_adaptive_ref_pic_buffering_flag;
free (buf);
#ifdef PRINT_DEC_REF_PIC_MARKING
#undef PRINT_DEC_REF_PIC_MARKING
#endif
}
/*!
************************************************************************
* \brief
* Interpret the Full-frame freeze SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_full_frame_freeze_info( byte* payload, int size, VideoParameters *p_Vid )
{
int full_frame_freeze_repetition_period;
Bitstream* buf;
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
full_frame_freeze_repetition_period = ue_v( "SEI: full_frame_freeze_repetition_period" , buf);
#ifdef PRINT_FULL_FRAME_FREEZE_INFO
printf("full_frame_freeze_repetition_period = %d\n", full_frame_freeze_repetition_period);
#endif
free (buf);
#ifdef PRINT_FULL_FRAME_FREEZE_INFO
#undef PRINT_FULL_FRAME_FREEZE_INFO
#endif
}
/*!
************************************************************************
* \brief
* Interpret the Full-frame freeze release SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_full_frame_freeze_release_info( byte* payload, int size, VideoParameters *p_Vid )
{
#ifdef PRINT_FULL_FRAME_FREEZE_RELEASE_INFO
printf("Full-frame freeze release SEI message\n");
if (size)
{
printf("payload size of this message should be zero, but is %d bytes.\n", size);
}
#endif
#ifdef PRINT_FULL_FRAME_FREEZE_RELEASE_INFO
#undef PRINT_FULL_FRAME_FREEZE_RELEASE_INFO
#endif
}
/*!
************************************************************************
* \brief
* Interpret the Full-frame snapshot SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_full_frame_snapshot_info( byte* payload, int size, VideoParameters *p_Vid )
{
int snapshot_id;
Bitstream* buf;
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
snapshot_id = ue_v("SEI: snapshot_id", buf);
#ifdef PRINT_FULL_FRAME_SNAPSHOT_INFO
printf("Full-frame snapshot SEI message\n");
printf("snapshot_id = %d\n", snapshot_id);
#endif
free (buf);
#ifdef PRINT_FULL_FRAME_SNAPSHOT_INFO
#undef PRINT_FULL_FRAME_SNAPSHOT_INFO
#endif
}
/*!
************************************************************************
* \brief
* Interpret the Progressive refinement segment start SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_progressive_refinement_start_info( byte* payload, int size, VideoParameters *p_Vid )
{
int progressive_refinement_id, num_refinement_steps_minus1;
Bitstream* buf;
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
progressive_refinement_id = ue_v("SEI: progressive_refinement_id" , buf);
num_refinement_steps_minus1 = ue_v("SEI: num_refinement_steps_minus1", buf);
#ifdef PRINT_PROGRESSIVE_REFINEMENT_START_INFO
printf("Progressive refinement segment start SEI message\n");
printf("progressive_refinement_id = %d\n", progressive_refinement_id);
printf("num_refinement_steps_minus1 = %d\n", num_refinement_steps_minus1);
#endif
free (buf);
#ifdef PRINT_PROGRESSIVE_REFINEMENT_START_INFO
#undef PRINT_PROGRESSIVE_REFINEMENT_START_INFO
#endif
}
/*!
************************************************************************
* \brief
* Interpret the Progressive refinement segment end SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_progressive_refinement_end_info( byte* payload, int size, VideoParameters *p_Vid )
{
int progressive_refinement_id;
Bitstream* buf;
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
progressive_refinement_id = ue_v("SEI: progressive_refinement_id" , buf);
#ifdef PRINT_PROGRESSIVE_REFINEMENT_END_INFO
printf("Progressive refinement segment end SEI message\n");
printf("progressive_refinement_id = %d\n", progressive_refinement_id);
#endif
free (buf);
#ifdef PRINT_PROGRESSIVE_REFINEMENT_END_INFO
#undef PRINT_PROGRESSIVE_REFINEMENT_END_INFO
#endif
}
/*!
************************************************************************
* \brief
* Interpret the Motion-constrained slice group set SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_motion_constrained_slice_group_set_info( byte* payload, int size, VideoParameters *p_Vid )
{
int num_slice_groups_minus1, slice_group_id, exact_match_flag, pan_scan_rect_flag, pan_scan_rect_id;
int i;
int sliceGroupSize;
Bitstream* buf;
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
num_slice_groups_minus1 = ue_v("SEI: num_slice_groups_minus1" , buf);
sliceGroupSize = CeilLog2( num_slice_groups_minus1 + 1 );
#ifdef PRINT_MOTION_CONST_SLICE_GROUP_SET_INFO
printf("Motion-constrained slice group set SEI message\n");
printf("num_slice_groups_minus1 = %d\n", num_slice_groups_minus1);
#endif
for (i=0; i<=num_slice_groups_minus1;i++)
{
slice_group_id = u_v (sliceGroupSize, "SEI: slice_group_id" , buf) ;
#ifdef PRINT_MOTION_CONST_SLICE_GROUP_SET_INFO
printf("slice_group_id = %d\n", slice_group_id);
#endif
}
exact_match_flag = u_1("SEI: exact_match_flag" , buf);
pan_scan_rect_flag = u_1("SEI: pan_scan_rect_flag" , buf);
#ifdef PRINT_MOTION_CONST_SLICE_GROUP_SET_INFO
printf("exact_match_flag = %d\n", exact_match_flag);
printf("pan_scan_rect_flag = %d\n", pan_scan_rect_flag);
#endif
if (pan_scan_rect_flag)
{
pan_scan_rect_id = ue_v("SEI: pan_scan_rect_id" , buf);
#ifdef PRINT_MOTION_CONST_SLICE_GROUP_SET_INFO
printf("pan_scan_rect_id = %d\n", pan_scan_rect_id);
#endif
}
free (buf);
#ifdef PRINT_MOTION_CONST_SLICE_GROUP_SET_INFO
#undef PRINT_MOTION_CONST_SLICE_GROUP_SET_INFO
#endif
}
/*!
************************************************************************
* \brief
* Interpret the film grain characteristics SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_film_grain_characteristics_info( byte* payload, int size, VideoParameters *p_Vid )
{
int film_grain_characteristics_cancel_flag;
int model_id, separate_colour_description_present_flag;
int film_grain_bit_depth_luma_minus8, film_grain_bit_depth_chroma_minus8, film_grain_full_range_flag, film_grain_colour_primaries, film_grain_transfer_characteristics, film_grain_matrix_coefficients;
int blending_mode_id, log2_scale_factor, comp_model_present_flag[3];
int num_intensity_intervals_minus1, num_model_values_minus1;
int intensity_interval_lower_bound, intensity_interval_upper_bound;
int comp_model_value;
int film_grain_characteristics_repetition_period;
int c, i, j;
Bitstream* buf;
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
film_grain_characteristics_cancel_flag = u_1("SEI: film_grain_characteristics_cancel_flag", buf);
#ifdef PRINT_FILM_GRAIN_CHARACTERISTICS_INFO
printf("film_grain_characteristics_cancel_flag = %d\n", film_grain_characteristics_cancel_flag);
#endif
if(!film_grain_characteristics_cancel_flag)
{
model_id = u_v(2, "SEI: model_id", buf);
separate_colour_description_present_flag = u_1("SEI: separate_colour_description_present_flag", buf);
#ifdef PRINT_FILM_GRAIN_CHARACTERISTICS_INFO
printf("model_id = %d\n", model_id);
printf("separate_colour_description_present_flag = %d\n", separate_colour_description_present_flag);
#endif
if (separate_colour_description_present_flag)
{
film_grain_bit_depth_luma_minus8 = u_v(3, "SEI: film_grain_bit_depth_luma_minus8", buf);
film_grain_bit_depth_chroma_minus8 = u_v(3, "SEI: film_grain_bit_depth_chroma_minus8", buf);
film_grain_full_range_flag = u_v(1, "SEI: film_grain_full_range_flag", buf);
film_grain_colour_primaries = u_v(8, "SEI: film_grain_colour_primaries", buf);
film_grain_transfer_characteristics = u_v(8, "SEI: film_grain_transfer_characteristics", buf);
film_grain_matrix_coefficients = u_v(8, "SEI: film_grain_matrix_coefficients", buf);
#ifdef PRINT_FILM_GRAIN_CHARACTERISTICS_INFO
printf("film_grain_bit_depth_luma_minus8 = %d\n", film_grain_bit_depth_luma_minus8);
printf("film_grain_bit_depth_chroma_minus8 = %d\n", film_grain_bit_depth_chroma_minus8);
printf("film_grain_full_range_flag = %d\n", film_grain_full_range_flag);
printf("film_grain_colour_primaries = %d\n", film_grain_colour_primaries);
printf("film_grain_transfer_characteristics = %d\n", film_grain_transfer_characteristics);
printf("film_grain_matrix_coefficients = %d\n", film_grain_matrix_coefficients);
#endif
}
blending_mode_id = u_v(2, "SEI: blending_mode_id", buf);
log2_scale_factor = u_v(4, "SEI: log2_scale_factor", buf);
#ifdef PRINT_FILM_GRAIN_CHARACTERISTICS_INFO
printf("blending_mode_id = %d\n", blending_mode_id);
printf("log2_scale_factor = %d\n", log2_scale_factor);
#endif
for (c = 0; c < 3; c ++)
{
comp_model_present_flag[c] = u_1("SEI: comp_model_present_flag", buf);
#ifdef PRINT_FILM_GRAIN_CHARACTERISTICS_INFO
printf("comp_model_present_flag = %d\n", comp_model_present_flag[c]);
#endif
}
for (c = 0; c < 3; c ++)
if (comp_model_present_flag[c])
{
num_intensity_intervals_minus1 = u_v(8, "SEI: num_intensity_intervals_minus1", buf);
num_model_values_minus1 = u_v(3, "SEI: num_model_values_minus1", buf);
#ifdef PRINT_FILM_GRAIN_CHARACTERISTICS_INFO
printf("num_intensity_intervals_minus1 = %d\n", num_intensity_intervals_minus1);
printf("num_model_values_minus1 = %d\n", num_model_values_minus1);
#endif
for (i = 0; i <= num_intensity_intervals_minus1; i ++)
{
intensity_interval_lower_bound = u_v(8, "SEI: intensity_interval_lower_bound", buf);
intensity_interval_upper_bound = u_v(8, "SEI: intensity_interval_upper_bound", buf);
#ifdef PRINT_FILM_GRAIN_CHARACTERISTICS_INFO
printf("intensity_interval_lower_bound = %d\n", intensity_interval_lower_bound);
printf("intensity_interval_upper_bound = %d\n", intensity_interval_upper_bound);
#endif
for (j = 0; j <= num_model_values_minus1; j++)
{
comp_model_value = se_v("SEI: comp_model_value", buf);
#ifdef PRINT_FILM_GRAIN_CHARACTERISTICS_INFO
printf("comp_model_value = %d\n", comp_model_value);
#endif
}
}
}
film_grain_characteristics_repetition_period = ue_v("SEI: film_grain_characteristics_repetition_period", buf);
#ifdef PRINT_FILM_GRAIN_CHARACTERISTICS_INFO
printf("film_grain_characteristics_repetition_period = %d\n", film_grain_characteristics_repetition_period);
#endif
}
free (buf);
#ifdef PRINT_FILM_GRAIN_CHARACTERISTICS_INFO
#undef PRINT_FILM_GRAIN_CHARACTERISTICS_INFO
#endif
}
/*!
************************************************************************
* \brief
* Interpret the deblocking filter display preference SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_deblocking_filter_display_preference_info( byte* payload, int size, VideoParameters *p_Vid )
{
int deblocking_display_preference_cancel_flag;
int display_prior_to_deblocking_preferred_flag, dec_frame_buffering_constraint_flag, deblocking_display_preference_repetition_period;
Bitstream* buf;
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
deblocking_display_preference_cancel_flag = u_1("SEI: deblocking_display_preference_cancel_flag", buf);
#ifdef PRINT_DEBLOCKING_FILTER_DISPLAY_PREFERENCE_INFO
printf("deblocking_display_preference_cancel_flag = %d\n", deblocking_display_preference_cancel_flag);
#endif
if(!deblocking_display_preference_cancel_flag)
{
display_prior_to_deblocking_preferred_flag = u_1("SEI: display_prior_to_deblocking_preferred_flag", buf);
dec_frame_buffering_constraint_flag = u_1("SEI: dec_frame_buffering_constraint_flag", buf);
deblocking_display_preference_repetition_period = ue_v("SEI: deblocking_display_preference_repetition_period", buf);
#ifdef PRINT_DEBLOCKING_FILTER_DISPLAY_PREFERENCE_INFO
printf("display_prior_to_deblocking_preferred_flag = %d\n", display_prior_to_deblocking_preferred_flag);
printf("dec_frame_buffering_constraint_flag = %d\n", dec_frame_buffering_constraint_flag);
printf("deblocking_display_preference_repetition_period = %d\n", deblocking_display_preference_repetition_period);
#endif
}
free (buf);
#ifdef PRINT_DEBLOCKING_FILTER_DISPLAY_PREFERENCE_INFO
#undef PRINT_DEBLOCKING_FILTER_DISPLAY_PREFERENCE_INFO
#endif
}
/*!
************************************************************************
* \brief
* Interpret the stereo video info SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_stereo_video_info_info( byte* payload, int size, VideoParameters *p_Vid )
{
int field_views_flags;
int top_field_is_left_view_flag, current_frame_is_left_view_flag, next_frame_is_second_view_flag;
int left_view_self_contained_flag;
int right_view_self_contained_flag;
Bitstream* buf;
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
field_views_flags = u_1("SEI: field_views_flags", buf);
#ifdef PRINT_STEREO_VIDEO_INFO_INFO
printf("field_views_flags = %d\n", field_views_flags);
#endif
if (field_views_flags)
{
top_field_is_left_view_flag = u_1("SEI: top_field_is_left_view_flag", buf);
#ifdef PRINT_STEREO_VIDEO_INFO_INFO
printf("top_field_is_left_view_flag = %d\n", top_field_is_left_view_flag);
#endif
}
else
{
current_frame_is_left_view_flag = u_1("SEI: current_frame_is_left_view_flag", buf);
next_frame_is_second_view_flag = u_1("SEI: next_frame_is_second_view_flag", buf);
#ifdef PRINT_STEREO_VIDEO_INFO_INFO
printf("current_frame_is_left_view_flag = %d\n", current_frame_is_left_view_flag);
printf("next_frame_is_second_view_flag = %d\n", next_frame_is_second_view_flag);
#endif
}
left_view_self_contained_flag = u_1("SEI: left_view_self_contained_flag", buf);
right_view_self_contained_flag = u_1("SEI: right_view_self_contained_flag", buf);
#ifdef PRINT_STEREO_VIDEO_INFO_INFO
printf("left_view_self_contained_flag = %d\n", left_view_self_contained_flag);
printf("right_view_self_contained_flag = %d\n", right_view_self_contained_flag);
#endif
free (buf);
#ifdef PRINT_STEREO_VIDEO_INFO_INFO
#undef PRINT_STEREO_VIDEO_INFO_INFO
#endif
}
/*!
************************************************************************
* \brief
* Interpret the Reserved SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_reserved_info( byte* payload, int size, VideoParameters *p_Vid )
{
int offset = 0;
byte payload_byte;
#ifdef PRINT_RESERVED_INFO
printf("Reserved SEI message\n");
#endif
while (offset < size)
{
payload_byte = payload[offset];
offset ++;
#ifdef PRINT_RESERVED_INFO
printf("reserved_sei_message_payload_byte = %d\n", payload_byte);
#endif
}
#ifdef PRINT_RESERVED_INFO
#undef PRINT_RESERVED_INFO
#endif
}
/*!
************************************************************************
* \brief
* Interpret the Buffering period SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_buffering_period_info( byte* payload, int size, VideoParameters *p_Vid )
{
int seq_parameter_set_id, initial_cpb_removal_delay, initial_cpb_removal_delay_offset;
unsigned int k;
Bitstream* buf;
seq_parameter_set_rbsp_t *sps;
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
seq_parameter_set_id = ue_v("SEI: seq_parameter_set_id" , buf);
sps = &p_Vid->SeqParSet[seq_parameter_set_id];
activate_sps(p_Vid, sps);
#ifdef PRINT_BUFFERING_PERIOD_INFO
printf("Buffering period SEI message\n");
printf("seq_parameter_set_id = %d\n", seq_parameter_set_id);
#endif
// Note: NalHrdBpPresentFlag and CpbDpbDelaysPresentFlag can also be set "by some means not specified in this Recommendation | International Standard"
if (sps->vui_parameters_present_flag)
{
if (sps->vui_seq_parameters.nal_hrd_parameters_present_flag)
{
for (k=0; k<sps->vui_seq_parameters.nal_hrd_parameters.cpb_cnt_minus1+1; k++)
{
initial_cpb_removal_delay = u_v(sps->vui_seq_parameters.nal_hrd_parameters.initial_cpb_removal_delay_length_minus1+1, "SEI: initial_cpb_removal_delay" , buf);
initial_cpb_removal_delay_offset = u_v(sps->vui_seq_parameters.nal_hrd_parameters.initial_cpb_removal_delay_length_minus1+1, "SEI: initial_cpb_removal_delay_offset" , buf);
#ifdef PRINT_BUFFERING_PERIOD_INFO
printf("nal initial_cpb_removal_delay[%d] = %d\n", k, initial_cpb_removal_delay);
printf("nal initial_cpb_removal_delay_offset[%d] = %d\n", k, initial_cpb_removal_delay_offset);
#endif
}
}
if (sps->vui_seq_parameters.vcl_hrd_parameters_present_flag)
{
for (k=0; k<sps->vui_seq_parameters.vcl_hrd_parameters.cpb_cnt_minus1+1; k++)
{
initial_cpb_removal_delay = u_v(sps->vui_seq_parameters.vcl_hrd_parameters.initial_cpb_removal_delay_length_minus1+1, "SEI: initial_cpb_removal_delay" , buf);
initial_cpb_removal_delay_offset = u_v(sps->vui_seq_parameters.vcl_hrd_parameters.initial_cpb_removal_delay_length_minus1+1, "SEI: initial_cpb_removal_delay_offset" , buf);
#ifdef PRINT_BUFFERING_PERIOD_INFO
printf("vcl initial_cpb_removal_delay[%d] = %d\n", k, initial_cpb_removal_delay);
printf("vcl initial_cpb_removal_delay_offset[%d] = %d\n", k, initial_cpb_removal_delay_offset);
#endif
}
}
}
free (buf);
#ifdef PRINT_BUFFERING_PERIOD_INFO
#undef PRINT_BUFFERING_PERIOD_INFO
#endif
}
/*!
************************************************************************
* \brief
* Interpret the Picture timing SEI message
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_picture_timing_info( byte* payload, int size, VideoParameters *p_Vid )
{
seq_parameter_set_rbsp_t *active_sps = p_Vid->active_sps;
int cpb_removal_delay, dpb_output_delay, picture_structure_present_flag, picture_structure;
int clock_time_stamp_flag;
int ct_type, nuit_field_based_flag, counting_type, full_timestamp_flag, discontinuity_flag, cnt_dropped_flag, nframes;
int seconds_value, minutes_value, hours_value, seconds_flag, minutes_flag, hours_flag, time_offset;
int NumClockTs = 0;
int i;
int cpb_removal_len = 24;
int dpb_output_len = 24;
Boolean CpbDpbDelaysPresentFlag;
Bitstream* buf;
if (NULL==active_sps)
{
fprintf (stderr, "Warning: no active SPS, timing SEI cannot be parsed\n");
return;
}
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
#ifdef PRINT_PCITURE_TIMING_INFO
printf("Picture timing SEI message\n");
#endif
// CpbDpbDelaysPresentFlag can also be set "by some means not specified in this Recommendation | International Standard"
CpbDpbDelaysPresentFlag = (Boolean) (active_sps->vui_parameters_present_flag
&& ( (active_sps->vui_seq_parameters.nal_hrd_parameters_present_flag != 0)
||(active_sps->vui_seq_parameters.vcl_hrd_parameters_present_flag != 0)));
if (CpbDpbDelaysPresentFlag )
{
if (active_sps->vui_parameters_present_flag)
{
if (active_sps->vui_seq_parameters.nal_hrd_parameters_present_flag)
{
cpb_removal_len = active_sps->vui_seq_parameters.nal_hrd_parameters.cpb_removal_delay_length_minus1 + 1;
dpb_output_len = active_sps->vui_seq_parameters.nal_hrd_parameters.dpb_output_delay_length_minus1 + 1;
}
else if (active_sps->vui_seq_parameters.vcl_hrd_parameters_present_flag)
{
cpb_removal_len = active_sps->vui_seq_parameters.vcl_hrd_parameters.cpb_removal_delay_length_minus1 + 1;
dpb_output_len = active_sps->vui_seq_parameters.vcl_hrd_parameters.dpb_output_delay_length_minus1 + 1;
}
}
if ((active_sps->vui_seq_parameters.nal_hrd_parameters_present_flag)||
(active_sps->vui_seq_parameters.vcl_hrd_parameters_present_flag))
{
cpb_removal_delay = u_v(cpb_removal_len, "SEI: cpb_removal_delay" , buf);
dpb_output_delay = u_v(dpb_output_len, "SEI: dpb_output_delay" , buf);
#ifdef PRINT_PCITURE_TIMING_INFO
printf("cpb_removal_delay = %d\n",cpb_removal_delay);
printf("dpb_output_delay = %d\n",dpb_output_delay);
#endif
}
}
if (!active_sps->vui_parameters_present_flag)
{
picture_structure_present_flag = 0;
}
else
{
picture_structure_present_flag = active_sps->vui_seq_parameters.pic_struct_present_flag;
}
if (picture_structure_present_flag)
{
picture_structure = u_v(4, "SEI: pic_struct" , buf);
#ifdef PRINT_PCITURE_TIMING_INFO
printf("picture_structure = %d\n",picture_structure);
#endif
switch (picture_structure)
{
case 0:
case 1:
case 2:
NumClockTs = 1;
break;
case 3:
case 4:
case 7:
NumClockTs = 2;
break;
case 5:
case 6:
case 8:
NumClockTs = 3;
break;
default:
error("reserved picture_structure used (can't determine NumClockTs)", 500);
}
for (i=0; i<NumClockTs; i++)
{
clock_time_stamp_flag = u_1("SEI: clock_time_stamp_flag" , buf);
#ifdef PRINT_PCITURE_TIMING_INFO
printf("clock_time_stamp_flag = %d\n",clock_time_stamp_flag);
#endif
if (clock_time_stamp_flag)
{
ct_type = u_v(2, "SEI: ct_type" , buf);
nuit_field_based_flag = u_1( "SEI: nuit_field_based_flag" , buf);
counting_type = u_v(5, "SEI: counting_type" , buf);
full_timestamp_flag = u_1( "SEI: full_timestamp_flag" , buf);
discontinuity_flag = u_1( "SEI: discontinuity_flag" , buf);
cnt_dropped_flag = u_1( "SEI: cnt_dropped_flag" , buf);
nframes = u_v(8, "SEI: nframes" , buf);
#ifdef PRINT_PCITURE_TIMING_INFO
printf("ct_type = %d\n",ct_type);
printf("nuit_field_based_flag = %d\n",nuit_field_based_flag);
printf("full_timestamp_flag = %d\n",full_timestamp_flag);
printf("discontinuity_flag = %d\n",discontinuity_flag);
printf("cnt_dropped_flag = %d\n",cnt_dropped_flag);
printf("nframes = %d\n",nframes);
#endif
if (full_timestamp_flag)
{
seconds_value = u_v(6, "SEI: seconds_value" , buf);
minutes_value = u_v(6, "SEI: minutes_value" , buf);
hours_value = u_v(5, "SEI: hours_value" , buf);
#ifdef PRINT_PCITURE_TIMING_INFO
printf("seconds_value = %d\n",seconds_value);
printf("minutes_value = %d\n",minutes_value);
printf("hours_value = %d\n",hours_value);
#endif
}
else
{
seconds_flag = u_1( "SEI: seconds_flag" , buf);
#ifdef PRINT_PCITURE_TIMING_INFO
printf("seconds_flag = %d\n",seconds_flag);
#endif
if (seconds_flag)
{
seconds_value = u_v(6, "SEI: seconds_value" , buf);
minutes_flag = u_1( "SEI: minutes_flag" , buf);
#ifdef PRINT_PCITURE_TIMING_INFO
printf("seconds_value = %d\n",seconds_value);
printf("minutes_flag = %d\n",minutes_flag);
#endif
if(minutes_flag)
{
minutes_value = u_v(6, "SEI: minutes_value" , buf);
hours_flag = u_1( "SEI: hours_flag" , buf);
#ifdef PRINT_PCITURE_TIMING_INFO
printf("minutes_value = %d\n",minutes_value);
printf("hours_flag = %d\n",hours_flag);
#endif
if(hours_flag)
{
hours_value = u_v(5, "SEI: hours_value" , buf);
#ifdef PRINT_PCITURE_TIMING_INFO
printf("hours_value = %d\n",hours_value);
#endif
}
}
}
}
{
int time_offset_length;
if (active_sps->vui_seq_parameters.vcl_hrd_parameters_present_flag)
time_offset_length = active_sps->vui_seq_parameters.vcl_hrd_parameters.time_offset_length;
else if (active_sps->vui_seq_parameters.nal_hrd_parameters_present_flag)
time_offset_length = active_sps->vui_seq_parameters.nal_hrd_parameters.time_offset_length;
else
time_offset_length = 24;
if (time_offset_length)
time_offset = i_v(time_offset_length, "SEI: time_offset" , buf);
else
time_offset = 0;
#ifdef PRINT_PCITURE_TIMING_INFO
printf("time_offset = %d\n",time_offset);
#endif
}
}
}
}
free (buf);
#ifdef PRINT_PCITURE_TIMING_INFO
#undef PRINT_PCITURE_TIMING_INFO
#endif
}
/*!
************************************************************************
* \brief
* Interpret the HDR tone-mapping SEI message (JVT-T060)
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
typedef struct
{
unsigned int tone_map_id;
unsigned char tone_map_cancel_flag;
unsigned int tone_map_repetition_period;
unsigned char coded_data_bit_depth;
unsigned char sei_bit_depth;
unsigned int model_id;
// variables for model 0
int min_value;
int max_value;
// variables for model 1
int sigmoid_midpoint;
int sigmoid_width;
// variables for model 2
int start_of_coded_interval[1<<MAX_SEI_BIT_DEPTH];
// variables for model 3
int num_pivots;
int coded_pivot_value[MAX_NUM_PIVOTS];
int sei_pivot_value[MAX_NUM_PIVOTS];
} tone_mapping_struct_tmp;
void interpret_tone_mapping( byte* payload, int size, VideoParameters *p_Vid )
{
tone_mapping_struct_tmp seiToneMappingTmp;
Bitstream* buf;
int i = 0, max_coded_num, max_output_num;
memset (&seiToneMappingTmp, 0, sizeof (tone_mapping_struct_tmp));
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
seiToneMappingTmp.tone_map_id = ue_v("SEI: tone_map_id", buf);
seiToneMappingTmp.tone_map_cancel_flag = (unsigned char) u_1("SEI: tone_map_cancel_flag", buf);
#ifdef PRINT_TONE_MAPPING
printf("Tone-mapping SEI message\n");
printf("tone_map_id = %d\n", seiToneMappingTmp.tone_map_id);
if (seiToneMappingTmp.tone_map_id != 0)
printf("WARNING! Tone_map_id != 0, print the SEI message info only. The tone mapping is actually applied only when Tone_map_id==0\n\n");
printf("tone_map_cancel_flag = %d\n", seiToneMappingTmp.tone_map_cancel_flag);
#endif
if (!seiToneMappingTmp.tone_map_cancel_flag)
{
seiToneMappingTmp.tone_map_repetition_period = ue_v( "SEI: tone_map_repetition_period", buf);
seiToneMappingTmp.coded_data_bit_depth = (unsigned char)u_v (8,"SEI: coded_data_bit_depth" , buf);
seiToneMappingTmp.sei_bit_depth = (unsigned char)u_v (8,"SEI: sei_bit_depth" , buf);
seiToneMappingTmp.model_id = ue_v( "SEI: model_id" , buf);
#ifdef PRINT_TONE_MAPPING
printf("tone_map_repetition_period = %d\n", seiToneMappingTmp.tone_map_repetition_period);
printf("coded_data_bit_depth = %d\n", seiToneMappingTmp.coded_data_bit_depth);
printf("sei_bit_depth = %d\n", seiToneMappingTmp.sei_bit_depth);
printf("model_id = %d\n", seiToneMappingTmp.model_id);
#endif
max_coded_num = 1<<seiToneMappingTmp.coded_data_bit_depth;
max_output_num = 1<<seiToneMappingTmp.sei_bit_depth;
if (seiToneMappingTmp.model_id == 0)
{ // linear mapping with clipping
seiToneMappingTmp.min_value = u_v (32,"SEI: min_value", buf);
seiToneMappingTmp.max_value = u_v (32,"SEI: min_value", buf);
#ifdef PRINT_TONE_MAPPING
printf("min_value = %d, max_value = %d\n", seiToneMappingTmp.min_value, seiToneMappingTmp.max_value);
#endif
}
else if (seiToneMappingTmp.model_id == 1)
{ // sigmoidal mapping
seiToneMappingTmp.sigmoid_midpoint = u_v (32,"SEI: sigmoid_midpoint", buf);
seiToneMappingTmp.sigmoid_width = u_v (32,"SEI: sigmoid_width", buf);
#ifdef PRINT_TONE_MAPPING
printf("sigmoid_midpoint = %d, sigmoid_width = %d\n", seiToneMappingTmp.sigmoid_midpoint, seiToneMappingTmp.sigmoid_width);
#endif
}
else if (seiToneMappingTmp.model_id == 2)
{ // user defined table mapping
for (i=0; i<max_output_num; i++)
{
seiToneMappingTmp.start_of_coded_interval[i] = u_v((((seiToneMappingTmp.coded_data_bit_depth+7)>>3)<<3), "SEI: start_of_coded_interval" , buf);
#ifdef PRINT_TONE_MAPPING // too long to print
//printf("start_of_coded_interval[%d] = %d\n", i, seiToneMappingTmp.start_of_coded_interval[i]);
#endif
}
}
else if (seiToneMappingTmp.model_id == 3)
{ // piece-wise linear mapping
seiToneMappingTmp.num_pivots = u_v (16,"SEI: num_pivots", buf);
#ifdef PRINT_TONE_MAPPING
printf("num_pivots = %d\n", seiToneMappingTmp.num_pivots);
#endif
seiToneMappingTmp.coded_pivot_value[0] = 0;
seiToneMappingTmp.sei_pivot_value[0] = 0;
seiToneMappingTmp.coded_pivot_value[seiToneMappingTmp.num_pivots+1] = max_coded_num-1;
seiToneMappingTmp.sei_pivot_value[seiToneMappingTmp.num_pivots+1] = max_output_num-1;
for (i=1; i < seiToneMappingTmp.num_pivots+1; i++)
{
seiToneMappingTmp.coded_pivot_value[i] = u_v( (((seiToneMappingTmp.coded_data_bit_depth+7)>>3)<<3), "SEI: coded_pivot_value", buf);
seiToneMappingTmp.sei_pivot_value[i] = u_v( (((seiToneMappingTmp.sei_bit_depth+7)>>3)<<3), "SEI: sei_pivot_value", buf);
#ifdef PRINT_TONE_MAPPING
printf("coded_pivot_value[%d] = %d, sei_pivot_value[%d] = %d\n", i, seiToneMappingTmp.coded_pivot_value[i], i, seiToneMappingTmp.sei_pivot_value[i]);
#endif
}
}
#if (ENABLE_OUTPUT_TONEMAPPING)
// Currently, only when the map_id == 0, the tone-mapping is actually applied.
if (seiToneMappingTmp.tone_map_id== 0)
{
int j;
p_Vid->seiToneMapping->seiHasTone_mapping = TRUE;
p_Vid->seiToneMapping->tone_map_repetition_period = seiToneMappingTmp.tone_map_repetition_period;
p_Vid->seiToneMapping->coded_data_bit_depth = seiToneMappingTmp.coded_data_bit_depth;
p_Vid->seiToneMapping->sei_bit_depth = seiToneMappingTmp.sei_bit_depth;
p_Vid->seiToneMapping->model_id = seiToneMappingTmp.model_id;
p_Vid->seiToneMapping->count = 0;
// generate the look up table of tone mapping
switch(seiToneMappingTmp.model_id)
{
case 0: // linear mapping with clipping
for (i=0; i<=seiToneMappingTmp.min_value; i++)
p_Vid->seiToneMapping->lut[i] = 0;
for (i=seiToneMappingTmp.min_value+1; i < seiToneMappingTmp.max_value; i++)
p_Vid->seiToneMapping->lut[i] = (imgpel) ((i-seiToneMappingTmp.min_value) * (max_output_num-1)/(seiToneMappingTmp.max_value- seiToneMappingTmp.min_value));
for (i=seiToneMappingTmp.max_value; i<max_coded_num; i++)
p_Vid->seiToneMapping->lut[i] =(imgpel) (max_output_num - 1);
break;
case 1: // sigmoid mapping
for (i=0; i < max_coded_num; i++)
{
#if 0
int j = (int)(1 + exp( -6*(double)(i-seiToneMappingTmp.sigmoid_midpoint)/seiToneMappingTmp.sigmoid_width));
p_Vid->seiToneMapping->lut[i] = ((max_output_num-1)+(j>>1)) / j;
#else
double tmp = 1.0 + exp( -6*(double)(i-seiToneMappingTmp.sigmoid_midpoint)/seiToneMappingTmp.sigmoid_width);
p_Vid->seiToneMapping->lut[i] = (imgpel)( (double)(max_output_num-1)/ tmp + 0.5);
#endif
}
break;
case 2: // user defined table
if (0 < max_output_num-1)
{
for (j=0; j<max_output_num-1; j++)
{
for (i=seiToneMappingTmp.start_of_coded_interval[j]; i<seiToneMappingTmp.start_of_coded_interval[j+1]; i++)
{
p_Vid->seiToneMapping->lut[i] = (imgpel) j;
}
}
p_Vid->seiToneMapping->lut[i] = (imgpel) (max_output_num - 1);
}
break;
case 3: // piecewise linear mapping
for (j=0; j<seiToneMappingTmp.num_pivots+1; j++)
{
#if 0
slope = ((seiToneMappingTmp.sei_pivot_value[j+1] - seiToneMappingTmp.sei_pivot_value[j])<<16)/(seiToneMappingTmp.coded_pivot_value[j+1]-seiToneMappingTmp.coded_pivot_value[j]);
for (i=seiToneMappingTmp.coded_pivot_value[j]; i <= seiToneMappingTmp.coded_pivot_value[j+1]; i++)
{
p_Vid->seiToneMapping->lut[i] = seiToneMappingTmp.sei_pivot_value[j] + (( (i - seiToneMappingTmp.coded_pivot_value[j]) * slope)>>16);
}
#else
double slope = (double)(seiToneMappingTmp.sei_pivot_value[j+1] - seiToneMappingTmp.sei_pivot_value[j])/(seiToneMappingTmp.coded_pivot_value[j+1]-seiToneMappingTmp.coded_pivot_value[j]);
for (i=seiToneMappingTmp.coded_pivot_value[j]; i <= seiToneMappingTmp.coded_pivot_value[j+1]; i++)
{
p_Vid->seiToneMapping->lut[i] = (imgpel) (seiToneMappingTmp.sei_pivot_value[j] + (int)(( (i - seiToneMappingTmp.coded_pivot_value[j]) * slope)));
}
#endif
}
break;
default:
break;
} // end switch
}
#endif
} // end !tone_map_cancel_flag
free (buf);
}
#if (ENABLE_OUTPUT_TONEMAPPING)
// tone map using the look-up-table generated according to SEI tone mapping message
void tone_map (imgpel** imgX, imgpel* lut, int size_x, int size_y)
{
int i, j;
for(i=0;i<size_y;i++)
{
for(j=0;j<size_x;j++)
{
imgX[i][j] = (imgpel)lut[imgX[i][j]];
}
}
}
void init_tone_mapping_sei(ToneMappingSEI *seiToneMapping)
{
seiToneMapping->seiHasTone_mapping = FALSE;
seiToneMapping->count = 0;
}
void update_tone_mapping_sei(ToneMappingSEI *seiToneMapping)
{
if(seiToneMapping->tone_map_repetition_period == 0)
{
seiToneMapping->seiHasTone_mapping = FALSE;
seiToneMapping->count = 0;
}
else if (seiToneMapping->tone_map_repetition_period>1)
{
seiToneMapping->count++;
if (seiToneMapping->count>=seiToneMapping->tone_map_repetition_period)
{
seiToneMapping->seiHasTone_mapping = FALSE;
seiToneMapping->count = 0;
}
}
}
#endif
/*!
************************************************************************
* \brief
* Interpret the post filter hints SEI message (JVT-U035)
* \param payload
* a pointer that point to the sei payload
* \param size
* the size of the sei message
* \param p_Vid
* the image pointer
*
************************************************************************
*/
void interpret_post_filter_hints_info( byte* payload, int size, VideoParameters *p_Vid )
{
Bitstream* buf;
unsigned int filter_hint_size_y, filter_hint_size_x, filter_hint_type, color_component, cx, cy, additional_extension_flag;
int ***filter_hint;
buf = malloc(sizeof(Bitstream));
buf->bitstream_length = size;
buf->streamBuffer = payload;
buf->frame_bitoffset = 0;
filter_hint_size_y = ue_v("SEI: filter_hint_size_y", buf); // interpret post-filter hint SEI here
filter_hint_size_x = ue_v("SEI: filter_hint_size_x", buf); // interpret post-filter hint SEI here
filter_hint_type = u_v(2, "SEI: filter_hint_type", buf); // interpret post-filter hint SEI here
get_mem3Dint (&filter_hint, 3, filter_hint_size_y, filter_hint_size_x);
for (color_component = 0; color_component < 3; color_component ++)
for (cy = 0; cy < filter_hint_size_y; cy ++)
for (cx = 0; cx < filter_hint_size_x; cx ++)
filter_hint[color_component][cy][cx] = se_v("SEI: filter_hint", buf); // interpret post-filter hint SEI here
additional_extension_flag = u_1("SEI: additional_extension_flag", buf); // interpret post-filter hint SEI here
#ifdef PRINT_POST_FILTER_HINT_INFO
printf(" Post-filter hint SEI message\n");
printf(" post_filter_hint_size_y %d \n", filter_hint_size_y);
printf(" post_filter_hint_size_x %d \n", filter_hint_size_x);
printf(" post_filter_hint_type %d \n", filter_hint_type);
for (color_component = 0; color_component < 3; color_component ++)
for (cy = 0; cy < filter_hint_size_y; cy ++)
for (cx = 0; cx < 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", additional_extension_flag);
#undef PRINT_POST_FILTER_HINT_INFO
#endif
free_mem3Dint (filter_hint);
free( buf );
}
Reference in New Issue View Git Blame Copy Permalink