406 lines
9.5 KiB
C
406 lines
9.5 KiB
C
#include "file_cache.h"
|
|
#include "sdram_addr_map.h"
|
|
#include "lcd_base_display.h"
|
|
|
|
static uint32_t const sdram_cache_buffer_address = SDRAM_BUF_CACHE_ADDRESS;
|
|
|
|
uint8_t sector[512];
|
|
uint32_t BytesRead;
|
|
|
|
unsigned int load_file_to_sdramcache(const TCHAR* path, unsigned int cache_buffer_address, int *pState)
|
|
{
|
|
uint32_t index = 0, file_size = 0, size = 0, i1 = 0;
|
|
uint32_t BmpAddress;
|
|
uint32_t Address = cache_buffer_address;
|
|
FIL F1;
|
|
|
|
if(pState != 0)return 0;
|
|
|
|
if(f_open (&F1, path, FA_READ)){
|
|
/* Set the Text Color */
|
|
set_font_color(0xFFFF0000, 0xFFFFFFFF);
|
|
|
|
*pState = -1;
|
|
return 0;
|
|
}
|
|
|
|
file_size = F1.obj.objsize;
|
|
size = file_size;
|
|
if(0 == size){
|
|
*pState = -2;
|
|
return 0;
|
|
}
|
|
|
|
do{
|
|
//256*2
|
|
if (size < 512){
|
|
i1 = size;
|
|
}else{
|
|
i1 = 512;//256*2
|
|
}
|
|
size -= i1;
|
|
|
|
f_read (&F1, sector, i1, &BytesRead);
|
|
|
|
for (index = 0; index < i1; index++){
|
|
*(__IO uint8_t*) (Address) = *(__IO uint8_t *)BmpAddress;
|
|
|
|
BmpAddress++;
|
|
Address++;
|
|
}
|
|
|
|
BmpAddress = (uint32_t)sector;
|
|
}while (size > 0);
|
|
|
|
f_close (&F1);
|
|
*pState =0;
|
|
return file_size;
|
|
}
|
|
|
|
void load_bmpfile_to_sdramcache(const TCHAR* path,uint32_t cache_buffer_address)
|
|
{
|
|
uint32_t index = 0, size = 0, i1 = 0;
|
|
uint32_t BmpAddress;
|
|
uint32_t Address = cache_buffer_address;
|
|
FIL F1;
|
|
|
|
if(f_open (&F1, path, FA_READ))
|
|
{
|
|
set_font_color(0xFFFF0000, 0xFFFFFFFF);
|
|
|
|
LCD_ShowString(20,360,400,24,24,"File type or name not supported!");
|
|
|
|
while(1);
|
|
}
|
|
f_read (&F1, sector, 32, &BytesRead);
|
|
|
|
BmpAddress = (uint32_t)sector;
|
|
|
|
/* Read bitmap size */
|
|
size = *(uint16_t *) (BmpAddress + 2);
|
|
size |= (*(uint16_t *) (BmpAddress + 4)) << 16;
|
|
|
|
/* Get bitmap data address offset */
|
|
index = *(uint16_t *) (BmpAddress + 10);
|
|
index |= (*(uint16_t *) (BmpAddress + 12)) << 16;
|
|
|
|
f_close (&F1);
|
|
|
|
f_open (&F1, path, FA_READ);
|
|
|
|
do
|
|
{
|
|
if (size < 512)//256*2
|
|
{
|
|
i1 = size;
|
|
}
|
|
else
|
|
{
|
|
i1 = 512;//256*2
|
|
}
|
|
size -= i1;
|
|
|
|
f_read (&F1, sector, i1, &BytesRead);
|
|
|
|
for (index = 0; index < i1; index++)
|
|
{
|
|
*(__IO uint8_t*) (Address) = *(__IO uint8_t *)BmpAddress;
|
|
|
|
BmpAddress++;
|
|
Address++;
|
|
}
|
|
|
|
BmpAddress = (uint32_t)sector;
|
|
}
|
|
while (size > 0);
|
|
|
|
f_close (&F1);
|
|
}
|
|
|
|
void load_bmpfile_sdramcache_to_sdramaddress(uint32_t BmpCacheAddress,Bmp_Parameter_TypeDef* bmp_parameter)//24bit bmp
|
|
{
|
|
uint16_t temp_rg;
|
|
uint16_t temp_b;
|
|
uint32_t temp;
|
|
|
|
uint16_t temp_r;
|
|
uint16_t temp_g;
|
|
|
|
uint32_t index = 0, size = 0, width = 0, height = 0, bit_pixel = 0;
|
|
uint32_t Address;
|
|
uint32_t currentline = 0, linenumber = 0;
|
|
|
|
uint32_t read_width = 0;
|
|
uint32_t index_width = 0;
|
|
uint32_t index_height = 0;
|
|
|
|
uint32_t fifo_32bit = 0;
|
|
uint32_t point_32bit_data = 0;
|
|
uint32_t bit1_index = 0;
|
|
uint32_t bit1_size = 0;
|
|
uint32_t bit4_index = 0;
|
|
uint32_t bit4_size = 0;
|
|
uint32_t Bmp4BitColor = 0;
|
|
uint32_t read_width_index = 0;
|
|
uint32_t max_value = 0;
|
|
uint32_t i = 0;
|
|
|
|
Address = bmp_parameter->start_address;
|
|
|
|
/* Read bitmap size */
|
|
size = *(__IO uint16_t *) (BmpCacheAddress + 2);
|
|
size |= (*(__IO uint16_t *) (BmpCacheAddress + 4)) << 16;
|
|
|
|
/* Get bitmap data address offset */
|
|
index = *(__IO uint16_t *) (BmpCacheAddress + 10);
|
|
index |= (*(__IO uint16_t *) (BmpCacheAddress + 12)) << 16;
|
|
|
|
/* Read bitmap width */
|
|
width = *(uint16_t *) (BmpCacheAddress + 18);
|
|
width |= (*(uint16_t *) (BmpCacheAddress + 20)) << 16;
|
|
|
|
/* Read bitmap height */
|
|
height = *(uint16_t *) (BmpCacheAddress + 22);
|
|
height |= (*(uint16_t *) (BmpCacheAddress + 24)) << 16;
|
|
|
|
bmp_parameter->pic_width = width;
|
|
bmp_parameter->pic_height= height;
|
|
|
|
/* Read bit/pixel */
|
|
bit_pixel = *(uint16_t *) (BmpCacheAddress + 28);
|
|
|
|
/* compute the real size of the picture (without the header)) */
|
|
size = (size - index);
|
|
|
|
/* bypass the bitmap header */
|
|
BmpCacheAddress += index;
|
|
|
|
//16bit bmp
|
|
if(16 == bit_pixel)
|
|
{
|
|
if(width & 0x01)
|
|
{
|
|
read_width = width + 1;// 2 byte
|
|
}
|
|
else
|
|
{
|
|
read_width = width + 0;
|
|
}
|
|
size = read_width*height*2;
|
|
BmpCacheAddress+=(size-(read_width*2));
|
|
|
|
for(index_height = 0; index_height < height; index_height++)
|
|
{
|
|
for(index_width = 0; index_width < width; index_width++)
|
|
{
|
|
temp = *(__IO uint16_t *)BmpCacheAddress;
|
|
temp_r = (temp&0x7C00)>>7;
|
|
temp_g = (temp&0x03E0)>>2;
|
|
temp_b = (temp&0x001F)<<3;
|
|
temp = temp_r;
|
|
temp<<=8;
|
|
temp|=temp_g;
|
|
temp<<=8;
|
|
temp|=temp_b;
|
|
*(__IO uint32_t*) (Address) = (temp | 0xFF000000);
|
|
//jump on point pixel
|
|
BmpCacheAddress+=2;
|
|
Address+=4;
|
|
}
|
|
BmpCacheAddress-=((read_width + width)*2);
|
|
}
|
|
}
|
|
|
|
//24bit bmp
|
|
else if(24 == bit_pixel)
|
|
{
|
|
if((width * 3) & 0x03)
|
|
{
|
|
read_width = (((width * 3)>>2) + 1)<<2;// 4 byte
|
|
}
|
|
else
|
|
{
|
|
read_width = width * 3;
|
|
}
|
|
size = read_width*height;
|
|
BmpCacheAddress+=(size-read_width);
|
|
|
|
for(index_height = 0; index_height < height; index_height++)
|
|
{
|
|
for(index_width = 0; index_width < width; index_width++)
|
|
{
|
|
temp_b = *(__IO uint8_t *)BmpCacheAddress;
|
|
BmpCacheAddress++;
|
|
temp_g = *(__IO uint8_t *)BmpCacheAddress;
|
|
BmpCacheAddress++;
|
|
temp_r = *(__IO uint8_t *)BmpCacheAddress;
|
|
BmpCacheAddress++;
|
|
temp = temp_r;
|
|
temp<<=8;
|
|
temp|=temp_g;
|
|
temp<<=8;
|
|
temp|=temp_b;
|
|
*(__IO uint32_t*) (Address) = (temp | 0xFF000000);
|
|
//jump on point pixel
|
|
Address+=4;
|
|
}
|
|
BmpCacheAddress-=(read_width + width * 3);
|
|
}
|
|
}
|
|
|
|
//4bit bmp
|
|
else if(4 == bit_pixel)
|
|
{
|
|
if(width & 0x07)
|
|
{
|
|
read_width = (width>>3) + 1;//read length 32bit
|
|
}
|
|
else
|
|
{
|
|
read_width = (width>>3) + 0;
|
|
}
|
|
size = read_width * height * 4;// 4 byte
|
|
BmpCacheAddress +=(size - (read_width * 4));//from bottom to top
|
|
bit4_size = width * height;//total 4bit size
|
|
index_height = height;
|
|
read_width_index = read_width;
|
|
do
|
|
{
|
|
point_32bit_data = (*(__IO uint8_t *)BmpCacheAddress);
|
|
BmpCacheAddress++;
|
|
point_32bit_data = (point_32bit_data<<8) | (*(__IO uint8_t *)BmpCacheAddress);
|
|
BmpCacheAddress++;
|
|
point_32bit_data = (point_32bit_data<<8) | (*(__IO uint8_t *)BmpCacheAddress);
|
|
BmpCacheAddress++;
|
|
point_32bit_data = (point_32bit_data<<8) | (*(__IO uint8_t *)BmpCacheAddress);
|
|
BmpCacheAddress++;
|
|
|
|
read_width_index--;
|
|
if(0 == read_width_index)
|
|
{
|
|
max_value = width - ((read_width-1)<<3);
|
|
read_width_index = read_width;
|
|
index_height--;
|
|
BmpCacheAddress -=(read_width * 4 * 2);//read from bottom address to top address
|
|
if(0 == index_height)
|
|
{
|
|
;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
max_value = 8;
|
|
}
|
|
|
|
for(i = 0;i < max_value;i++)
|
|
{
|
|
switch((point_32bit_data & 0xF0000000)>>28){
|
|
case 0 : *(__IO uint32_t*)(Address) = 0xFF000000;break;
|
|
case 1 : *(__IO uint32_t*)(Address) = 0xFF800000;break;
|
|
case 2 : *(__IO uint32_t*)(Address) = 0xFF008000;break;
|
|
case 3 : *(__IO uint32_t*)(Address) = 0xFF808000;break;
|
|
case 4 : *(__IO uint32_t*)(Address) = 0xFF000080;break;
|
|
case 5 : *(__IO uint32_t*)(Address) = 0xFF800080;break;
|
|
case 6 : *(__IO uint32_t*)(Address) = 0xFF008080;break;
|
|
case 7 : *(__IO uint32_t*)(Address) = 0xFF808080;break;
|
|
case 8 : *(__IO uint32_t*)(Address) = 0xFFC0C0C0;break;
|
|
case 9 : *(__IO uint32_t*)(Address) = 0xFFFF0000;break;
|
|
case 10: *(__IO uint32_t*)(Address) = 0xFF00FF00;break;
|
|
case 11: *(__IO uint32_t*)(Address) = 0xFFFFFF00;break;
|
|
case 12: *(__IO uint32_t*)(Address) = 0xFF0000FF;break;
|
|
case 13: *(__IO uint32_t*)(Address) = 0xFFFF00FF;break;
|
|
case 14: *(__IO uint32_t*)(Address) = 0xFF00FFFF;break;
|
|
case 15: *(__IO uint32_t*)(Address) = 0xFFFFFFFF;break;
|
|
default : break;
|
|
}
|
|
point_32bit_data<<=4;
|
|
bit4_index++;
|
|
Address+=4;
|
|
if(bit4_index == bit4_size)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}while(bit4_index < bit4_size);
|
|
}
|
|
|
|
//1bit bmp
|
|
else if(1 == bit_pixel)
|
|
{
|
|
if(width & 0x1F)
|
|
{
|
|
read_width = (width>>5) + 1;//read length 32bit
|
|
}
|
|
else
|
|
{
|
|
read_width = (width>>5) + 0;
|
|
}
|
|
size = read_width * height * 4;// 4 byte
|
|
BmpCacheAddress +=(size - (read_width * 4));//from bottom to top
|
|
bit1_size = width * height;//total bit size
|
|
index_height = height;
|
|
read_width_index = read_width;
|
|
do
|
|
{
|
|
point_32bit_data = (*(__IO uint8_t *)BmpCacheAddress);
|
|
BmpCacheAddress++;
|
|
point_32bit_data = (point_32bit_data<<8) | (*(__IO uint8_t *)BmpCacheAddress);
|
|
BmpCacheAddress++;
|
|
point_32bit_data = (point_32bit_data<<8) | (*(__IO uint8_t *)BmpCacheAddress);
|
|
BmpCacheAddress++;
|
|
point_32bit_data = (point_32bit_data<<8) | (*(__IO uint8_t *)BmpCacheAddress);
|
|
BmpCacheAddress++;
|
|
|
|
read_width_index--;
|
|
if(0 == read_width_index)
|
|
{
|
|
max_value = width - ((read_width-1)<<5);
|
|
read_width_index = read_width;
|
|
index_height--;
|
|
BmpCacheAddress -=(read_width * 4 * 2);//read from bottom address to top address
|
|
if(0 == index_height)
|
|
{
|
|
;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
max_value = 32;
|
|
}
|
|
|
|
for(i = 0;i < max_value;i++)
|
|
{
|
|
fifo_32bit<<=1;
|
|
if(point_32bit_data & 0x80000000)
|
|
{
|
|
fifo_32bit|=0x01;
|
|
}
|
|
else
|
|
{
|
|
fifo_32bit&=~0x01;
|
|
}
|
|
point_32bit_data<<=1;
|
|
bit1_index++;
|
|
if(!(bit1_index & 0x1f))
|
|
{
|
|
*(__IO uint32_t*)(Address) = fifo_32bit;
|
|
Address+=4;
|
|
}
|
|
else if(bit1_index == bit1_size)
|
|
{
|
|
fifo_32bit<<=(32-(bit1_index & 0x1F));
|
|
*(__IO uint32_t*)(Address) = fifo_32bit;
|
|
Address+=4;
|
|
break;
|
|
}
|
|
}
|
|
}while(bit1_index < bit1_size);
|
|
}
|
|
}
|
|
|
|
void load_bmpfile_to_sdram(Bmp_Parameter_TypeDef* BmpFileParameter)
|
|
{
|
|
load_bmpfile_to_sdramcache((const char *)BmpFileParameter->name_str,sdram_cache_buffer_address);
|
|
load_bmpfile_sdramcache_to_sdramaddress(sdram_cache_buffer_address,BmpFileParameter);
|
|
}
|