png_decoder.c

最新MTK手机软件源码

static void init_lcd_layer_window(void)
{
	lcd_layer_struct layer_data = {0};

	layer_data.source_key=0xFFFF;
	layer_data.source_key_enable=KAL_FALSE;
	layer_data.color_palette_enable=KAL_FALSE;
	layer_data.color_palette_select=0;
	layer_data.opacity_enable=KAL_FALSE;
	layer_data.opacity_value=10;
	layer_data.x_offset=0;
	layer_data.y_offset=0;
	layer_data.frame_buffer_address=(kal_uint32) lcd_buffer;
	layer_data.row_number=LCD_HEIGHT;
	layer_data.column_number=LCD_WIDTH;
	layer_data.rotate_value=0;
	layer_data.source_color_format = LCD_LAYER_SOURCE_COLOR_RGB565;
	config_lcd_layer_window(0,&layer_data);

}	/* init_lcd_layer_window() */
static void LCD_Init(void)
{
	lcd_init(MAIN_LCD,0xF800);
	init_lcd_layer_window();
	SET_LCD_ROI_WINDOW_OFFSET(0,0);
	SET_LCD_ROI_WINDOW_SIZE(LCD_WIDTH,LCD_HEIGHT);
	memset(lcd_buffer, 0x55, sizeof lcd_buffer);

}
static void LCDDisplay_adrs( kal_uint16 w, kal_uint16 h, kal_uint16 x, kal_uint16 y, void* adrs)
{
	lcd_frame_update_struct lcd_data;

	lcd_power_up();
	SET_LCD_LAYER0_WINDOW_SIZE(w,h);
	SET_LCD_LAYER0_WINDOW_OFFSET(x,y);
	
	REG_LCD_LAYER0_BUFF_ADDR = (kal_uint32) adrs;
	lcd_data.module_id=LCD_UPDATE_MODULE_MEDIA;
	lcd_data.lcd_id=MAIN_LCD;
	lcd_data.fb_update_mode=LCD_SW_TRIGGER_MODE;
	lcd_data.lcm_start_x=0;
	lcd_data.lcm_start_y=0;
	lcd_data.lcm_end_x=LCD_WIDTH-1;
	lcd_data.lcm_end_y=LCD_HEIGHT-1;
	lcd_data.roi_offset_x=0;
	lcd_data.roi_offset_y=0;
	lcd_data.update_layer=LCD_LAYER0_ENABLE;
	
	lcd_fb_update(&lcd_data);	
}
static void LCD_Display(void *adrs, kal_uint16 w, kal_uint16 h)
{
	LCDDisplay_adrs(w,h,0,0,adrs);
}


void png_callback(png_report_status_enum status)
{

	cb_status = status;
	kal_set_eg_events(my_Events,1,KAL_OR);

		
}

// file mode, multi frame, no partila input, no resizing
void test_case_1(void)
{
	png_config_struct *p = &png_config;
	png_report_status_enum status;
	kal_uint32 flag;


	sprintf(file_name, "c:\\png\\basn2c08.png");
	kal_wsprintf(file_name_w,(char*)file_name);
	p->decode_mode = PNG_DECODE_FILE;	
	p->file_handle = DRM_open_file(file_name_w,FS_READ_ONLY|FS_OPEN_NO_DIR,0);
	if(p->file_handle < 0 )
		ASSERT(0);
	
	DRM_file_size(p->file_handle, &file_size);
	p->in_buffer_adrs = (kal_uint32)in_buffer;
	p->in_buffer_size = sizeof in_buffer;
	p->output_buffer_adrs = (kal_uint32)lcd_buffer;
	p->output_buffer_size = sizeof lcd_buffer;

	p->hclen = png_buffers.hclen;
	p->hlen = png_buffers.hlen;
	p->hlit = png_buffers.hlit;
	p->hdist = png_buffers.hdist;
	p->buff0 = png_buffers.buff0;
	p->buff1 = png_buffers.buff1;
	p->LZ77 = png_buffers.LZ77;
	p->color_table = png_buffers.color_table;
	p->color_table_t = png_buffers.color_table_t;
	
	p->shadow_w = LCD_WIDTH;
	p->shadow_h = LCD_HEIGHT;
	p->clip_x1 = 0;
	p->clip_y1 = 0;
	p->clip_x2 = LCD_WIDTH;
	p->clip_y2 = LCD_HEIGHT;
	p->dest_x = 0;
	p->dest_y = 0;

	p->expect_w = LCD_WIDTH;
	p->expect_h = LCD_HEIGHT;
	
	p->clip_en = KAL_TRUE;
	p->out_format = RGB565;
	p->cb = png_callback;
	
	t1 = GPT3_GetCount();
	status = png_decode_start(p, &png_info);
	if(status ==  PNG_FORMAT_ERROR)
		goto end;		
	kal_retrieve_eg_events(my_Events,(1),KAL_OR_CONSUME,&flag,KAL_SUSPEND);			
	while(1)
	{
		if(cb_status == PNG_INPUT_EMPTY)
		{
			ASSERT(0);			
		}
		else if (cb_status == PNG_BLOCK_END)
		{
			if(!png_stop_now)
			{
				status = png_decode_resume();
				if(status == PNG_DECODING)
					kal_retrieve_eg_events(my_Events,(1),KAL_OR_CONSUME,&flag,KAL_SUSPEND);										
				else if(status == PNG_FINISH_IMAGE)
				{
					t2 = GPT3_TimeDiff(t1);
					dbg_print("\t period: %d",t2); 
					LCD_Display(lcd_buffer, LCD_WIDTH, LCD_HEIGHT);	
					goto end;
				}
				else
				{
					dbg_print("\n\r decode fail %d !", cb_status);
					goto end;
				}
			}
			else
			{
				png_decode_stop();
				goto end;
			}				
		}
		else if(cb_status == PNG_FINISH_IMAGE)
		{
			LCD_Display(lcd_buffer, LCD_WIDTH, LCD_HEIGHT);	
			goto end;
		}
		else	// PNG_DECODE_TIMEOUT, PNG_FORMAT_ERROR			
		{				
			png_decode_stop();
			dbg_print("\n\r decode fail %d !", cb_status);
			break;
		}				
	}

end:	
	DRM_close_file(p->file_handle);
	memset(lcd_buffer, 0x55, sizeof lcd_buffer);
	//LCD_Display(lcd_buffer, LCD_WIDTH, LCD_HEIGHT);	
}



// memory mode, no partila input, no resizing
void test_case_2(void)
{
	png_config_struct *p = &png_config;
	png_report_status_enum status;
	kal_uint32 flag,bytes;


	sprintf(file_name, "c:\\png\\OI2N2C16.PNG");
	kal_wsprintf(file_name_w,(char*)file_name);
	p->decode_mode = PNG_DECODE_MEMORY;	
	p->file_handle = DRM_open_file(file_name_w,FS_READ_ONLY|FS_OPEN_NO_DIR,0);
	if(p->file_handle < 0 )
		ASSERT(0);
	
	DRM_file_size(p->file_handle, &file_size);
	if(file_size > sizeof in_buffer)
	{
			p->decode_mode = PNG_DECODE_FILE;
	}
	else
	{
		if(DRM_read_file(p->file_handle,in_buffer, file_size, &bytes) < 0)
			while(1);
	}
	
	p->in_buffer_adrs = (kal_uint32)in_buffer;
	p->in_buffer_size = file_size;
	p->output_buffer_adrs = (kal_uint32)lcd_buffer;
	p->output_buffer_size = sizeof lcd_buffer;

	p->hclen = png_buffers.hclen;
	p->hlen = png_buffers.hlen;
	p->hlit = png_buffers.hlit;
	p->hdist = png_buffers.hdist;
	p->buff0 = png_buffers.buff0;
	p->buff1 = png_buffers.buff1;
	p->LZ77 = png_buffers.LZ77;
	p->color_table = png_buffers.color_table;
	p->color_table_t = png_buffers.color_table_t;
	
	p->shadow_w = LCD_WIDTH;
	p->shadow_h = LCD_HEIGHT;
	p->clip_x1 = 0;
	p->clip_y1 = 0;
	p->clip_x2 = LCD_WIDTH;
	p->clip_y2 = LCD_HEIGHT;
	p->dest_x = 0;
	p->dest_y = 0;

	p->expect_w = LCD_WIDTH;
	p->expect_h = LCD_HEIGHT;
	
	p->clip_en = KAL_TRUE;
	p->out_format = RGB565;
	p->cb = png_callback;
	
	t1 = GPT3_GetCount();
	status = png_decode_start(p, &png_info);
	if(status ==  PNG_FORMAT_ERROR)
		goto end;		
	kal_retrieve_eg_events(my_Events,(1),KAL_OR_CONSUME,&flag,KAL_SUSPEND);			
	while(1)
	{
		if (cb_status == PNG_BLOCK_END)
		{
			if(!png_stop_now)
			{
				status = png_decode_resume();
				if(status == PNG_DECODING)
					kal_retrieve_eg_events(my_Events,(1),KAL_OR_CONSUME,&flag,KAL_SUSPEND);										
				else if(status == PNG_FINISH_IMAGE)
				{
					t2 = GPT3_TimeDiff(t1);
					dbg_print("\t period: %d",t2); 					
					LCD_Display(lcd_buffer, LCD_WIDTH, LCD_HEIGHT);	
					goto end;
				}
				else
				{
					dbg_print("\n\r decode fail %d !", cb_status);
					goto end;
				}
			}
			else
			{
				png_decode_stop();
				goto end;
			}				
		}
		else if(cb_status == PNG_INPUT_EMPTY)
		{
			ASSERT(0);
		}
		else if(cb_status == PNG_FINISH_IMAGE)
		{
			ASSERT(0);
			LCD_Display(lcd_buffer, LCD_WIDTH, LCD_HEIGHT);	
			goto end;
		}
		else	// PNG_DECODE_TIMEOUT, PNG_FORMAT_ERROR			
		{				
			png_decode_stop();
			dbg_print("\n\r decode fail %d !", cb_status);
			break;
		}				
	}

end:	
	DRM_close_file(p->file_handle);
	memset(lcd_buffer, 0x55, sizeof lcd_buffer);
	//LCD_Display(lcd_buffer, LCD_WIDTH, LCD_HEIGHT);	
}

// verify using 2D special case
void test_case_4(void)
{
	png_config_struct *p = &png_config;
	png_report_status_enum status;
	kal_uint32 flag;


	sprintf(file_name, "c:\\png\\cos-email.png");
	kal_wsprintf(file_name_w,(char*)file_name);
	p->decode_mode = PNG_DECODE_FILE;	
	p->file_handle = DRM_open_file(file_name_w,FS_READ_ONLY|FS_OPEN_NO_DIR,0);
	if(p->file_handle < 0 )
		ASSERT(0);
	
	DRM_file_size(p->file_handle, &file_size);
	p->in_buffer_adrs = (kal_uint32)in_buffer;
	p->in_buffer_size = sizeof in_buffer;
	p->output_buffer_adrs = (kal_uint32)lcd_buffer;
	p->output_buffer_size = sizeof lcd_buffer;

	p->hclen = png_buffers.hclen;
	p->hlen = png_buffers.hlen;
	p->hlit = png_buffers.hlit;
	p->hdist = png_buffers.hdist;
	p->buff0 = png_buffers.buff0;
	p->buff1 = png_buffers.buff1;
	p->LZ77 = png_buffers.LZ77;
	p->color_table = png_buffers.color_table;
	p->color_table_t = png_buffers.color_table_t;
	
	p->shadow_w = LCD_WIDTH;
	p->shadow_h = LCD_HEIGHT;
	p->clip_x1 = 0;
	p->clip_y1 = 0;
	p->clip_x2 = LCD_WIDTH;
	p->clip_y2 = LCD_HEIGHT;
	p->dest_x = 0;
	p->dest_y = 0;

	p->expect_w = LCD_WIDTH;
	p->expect_h = LCD_HEIGHT;
	
	p->clip_en = KAL_TRUE;
	p->out_format = RGB565;
	p->cb = png_callback;
	
	t1 = GPT3_GetCount();
	status = png_decode_start(p, &png_info);
	if(status ==  PNG_FORMAT_ERROR)
		goto end;
	kal_retrieve_eg_events(my_Events,(1),KAL_OR_CONSUME,&flag,KAL_SUSPEND);			
	while(1)
	{
		if(cb_status == PNG_INPUT_EMPTY)
		{
			ASSERT(0);			
		}
		else if (cb_status == PNG_BLOCK_END)
		{
			if(!png_stop_now)
			{
				status = png_decode_resume();
				if(status == PNG_DECODING)
					kal_retrieve_eg_events(my_Events,(1),KAL_OR_CONSUME,&flag,KAL_SUSPEND);										
				else if(status == PNG_FINISH_IMAGE)
				{
					t2 = GPT3_TimeDiff(t1);
					dbg_print("\t period: %d",t2); 
					LCD_Display(lcd_buffer, LCD_WIDTH, LCD_HEIGHT);	
					goto end;
				}
				else
				{
					dbg_print("\n\r decode fail %d !", cb_status);
					goto end;
				}
			}
			else
			{
				png_decode_stop();
				goto end;
			}				
		}
		else if(cb_status == PNG_FINISH_IMAGE)
		{
			LCD_Display(lcd_buffer, LCD_WIDTH, LCD_HEIGHT);	
			goto end;
		}
		else if(cb_status == PNG_USE_G2D)
		{
			p->output_buffer_adrs = (kal_uint32)lcd_buffer;
			status = png_decode_resume();
			if(status == PNG_DECODING)
				kal_retrieve_eg_events(my_Events,(1),KAL_OR_CONSUME,&flag,KAL_SUSPEND);										
			else if(status == PNG_FINISH_IMAGE)
			{
				LCD_Display(lcd_buffer, LCD_WIDTH, LCD_HEIGHT);	
				goto end;
			}
			else
			{
				dbg_print("\n\r decode fail %d !", cb_status);
				goto end;
			}			
		}
		else	// PNG_DECODE_TIMEOUT, PNG_FORMAT_ERROR			
		{				
			png_decode_stop();
			dbg_print("\n\r decode fail %d !", cb_status);
			break;
		}				
	}

end:	
	LCD_Display(png_work_buffer, png_dcb.info.img_w, png_dcb.info.img_h);
	DRM_close_file(p->file_handle);
	memset(lcd_buffer, 0x55, sizeof lcd_buffer);
	//LCD_Display(lcd_buffer, LCD_WIDTH, LCD_HEIGHT);	
}
void test_case_all(void)
{
	kal_int32 s, file_count;
	FS_HANDLE handle;
	RTFDOSDirEntry de;
	png_config_struct *p = &png_config;
	png_report_status_enum status;
	static kal_bool is_first = KAL_TRUE;		
	kal_uint32 flag;

	file_count = 0;
	if(RTFSetCurrentDir(L"c:\\png\\") < 0)
		while(1);
	while(1)
	{		
		kal_uint32 bytes;		
		
		if(is_first)
		{
			handle = RTFFindFirstEx(L"*.png", 0, 0, &de, file_name_w, 256);
			ASSERT(handle > 0);
			is_first = KAL_FALSE;
		}
		else
		{
			status = RTFFindNextEx(handle,&de,file_name_w, 256);
		}
		if(status != RTF_NO_ERROR)
			break;
		file_count++;
		kal_dchar2char(file_name_w,(char*)file_name);
		kal_wsprintf(file_name_w,(char*)file_name);
		p->file_handle = DRM_open_file(file_name_w,FS_READ_ONLY|FS_OPEN_NO_DIR,0);
		if(p->file_handle < 0 )
			ASSERT(0);
		DRM_file_size(p->file_handle, &file_size);	
		dbg_print("\r\n[%d] File: %s\t, size: %d\t",file_count, file_name, file_size);
		if(file_size > sizeof in_buffer)
			p->decode_mode = PNG_DECODE_FILE;	
		else
			p->decode_mode = PNG_DECODE_MEMORY;	
		if(p->decode_mode == PNG_DECODE_MEMORY)
		{
			p->in_buffer_size = file_size;
			if(DRM_read_file(p->file_handle,in_buffer, file_size, &bytes) < 0)
				while(1);
		}		
		else
		{
			p->in_buffer_size = sizeof in_buffer;
		}		

		p->in_buffer_adrs = (kal_uint32)in_buffer;
		p->output_buffer_adrs = (kal_uint32)lcd_buffer;
		p->output_buffer_size = sizeof lcd_buffer;

		p->hclen = png_buffers.hclen;
		p->hlen = png_buffers.hlen;
		p->hlit = png_buffers.hlit;
		p->hdist = png_buffers.hdist;
		p->buff0 = png_buffers.buff0;
		p->buff1 = png_buffers.buff1;
		p->LZ77 = png_buffers.LZ77;
		p->color_table = png_buffers.color_table;
		p->color_table_t = png_buffers.color_table_t;
		
		p->shadow_w = LCD_WIDTH;
		p->shadow_h = LCD_HEIGHT;
		p->clip_x1 = 0;
		p->clip_y1 = 0;
		p->clip_x2 = LCD_WIDTH;
		p->clip_y2 = LCD_HEIGHT;
		p->dest_x = 0;
		p->dest_y = 0;

		p->expect_w = LCD_WIDTH;
		p->expect_h = LCD_HEIGHT;
		
		p->clip_en = KAL_TRUE;
		p->out_format = RGB565;
		p->cb = png_callback;

		t1 = GPT3_GetCount();
		status = png_decode_start(p, &png_info);
		if(status == PNG_DECODING)
			kal_retrieve_eg_events(my_Events,(1),KAL_OR_CONSUME,&flag,KAL_SUSPEND);		
		else
		{			
			dbg_print("\n\r decode fail %d !", status);
			goto end;		
		}
			
		while(1)
		{
			if (cb_status == PNG_BLOCK_END)
			{
				if(!png_stop_now)
				{
					status = png_decode_resume();
					if(status == PNG_DECODING)
						kal_retrieve_eg_events(my_Events,(1),KAL_OR_CONSUME,&flag,KAL_SUSPEND);										
					else if(status == PNG_FINISH_IMAGE)
					{				
						t2 = GPT3_TimeDiff(t1);
						dbg_print("\t period: %d",t2); 												
						dbg_print(" decode pass !");
						LCD_Display(lcd_buffer, LCD_WIDTH, LCD_HEIGHT);	
						goto end;
					}
					else
					{
						dbg_print("\n\r decode fail %d !", cb_status);
						goto end;
					}
				}
				else
				{
					png_decode_stop();
					goto end;
				}				
			}
			else if(cb_status == PNG_FINISH_IMAGE)
			{
				ASSERT(0);
			}
			else	// PNG_DECODE_TIMEOUT, PNG_FORMAT_ERROR			
			{				
				png_decode_stop();
				dbg_print("\n\r decode fail %d !", cb_status);
				break;
			}				
		}

end:	

	DRM_close_file(p->file_handle);
	memset(lcd_buffer, 0x55, sizeof lcd_buffer);
	}
	RTFFindClose(handle);
	is_first = KAL_TRUE;
}

// verify the function of png_get_gray_scale
void test_case_3(void)
{
	kal_uint32 i,j;
	kal_uint8 bit[] = {1,2,4,8,16};

	for(i=0;i<sizeof bit;i++)
	{
		dbg_print("bit depth = %d\r\n", bit[i]);
		for(j=0;j<(1<<bit[i]);j++)
		{
			kal_uint32 value;

			value = png_get_gray_scale(bit[i], j);
			dbg_print("gray: %x => %x \t", j, value);
		}
		dbg_print("\r\n");
	}
}
void png_test_main(void)
{
	my_Events = kal_create_event_group("my Events");
	GPT3_Init_my();
	LCD_Init();
	SD_Initialize();
	png_init();
	g2d_init();

	while(1)
	{
		test_case_1();
		test_case_all();
	}
	
}
#endif	// PNG_UNIT_TEST