FreeCalypso > hg > fc-magnetite

view src/aci2/bmi/Icons/BMP/bmpToHex.c @ 624:012028896cfb

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
FFS dev.c, Leonardo target: Fujitsu MB84VF5F5F4J2 #if 0'ed out The FFS code we got from TI/Openmoko had a stanza for "Fujitsu MB84VF5F5F4J2 stacked device", using a fake device ID code that would need to be patched manually into cfgffs.c (suppressing and overriding autodetection) and using an FFS base address in the nCS2 bank, indicating that this FFS config was probably meant for the MCP version of Leonardo which allows for 16 MiB flash with a second bank on nCS2. We previously had this FFS config stanza conditionalized under CONFIG_TARGET_LEONARDO because the base address contained therein is invalid for other targets, but now that we actually have a Leonardo build target in FC Magnetite, I realize that the better approach is to #if 0 out this stanza altogether: it is already non-functional because it uses a fake device ID code, thus it is does not add support for more Leonardo board variants, instead it is just noise.
author Mychaela Falconia <falcon@freecalypso.org>
date Sun, 22 Dec 2019 21:24:29 +0000
parents 93999a60b835
children
line wrap: on
line source

#include <stdlib.h>
#include <stdio.h>

typedef unsigned char byte;
typedef unsigned char u8;
typedef signed char s8;
typedef signed short s16;
typedef unsigned short u16;
typedef signed long s32;
typedef unsigned long u32;

typedef FILE* FS_file_handle;

byte FS_fgetbyte(FS_file_handle file)
{
	return((byte)fgetc(file));
}

u16 FS_fget16(FS_file_handle file)
{
	u16 c;
	byte l=FS_fgetbyte(file);
	byte h=FS_fgetbyte(file);
	c=l|(h<<8);
	return(c);
}

u32 FS_fget32(FS_file_handle file)
{
	u32 c;
	u16 l=FS_fget16(file);
	u16 h=FS_fget16(file);
	c=l|(h<<16);
	return(c);
}

s32 FS_fseek(FS_file_handle file, s32 offset, s32 origin)
{
	return(fseek(file,offset,origin));
}

typedef struct	_bitmap_file_header
{	
	u16		file_type;
	u32		file_size;
	u16		reserved1;
	u16		reserved2;
	u32		bitmap_offset;

}	bitmap_file_header;

typedef struct	_bitmap_info_header
{	
	u32		header_size;
	u32		width;
	u32		height;
	u16		number_of_planes;
	u16		bits_per_pixel;
	u32		compression;
	u32		bitmap_size;
	u32		device_width;
	u32		device_height;
	u32		number_of_colors;
	u32		number_of_important_colors;

}	bitmap_info_header;

byte BMP_palette[256*3];

void BMP_write_line(s32 x,s32 y,s32 width,FS_file_handle file,byte *data,s32 pad_bytes,s32 in_color_depth,s32 out_color_depth)
{	s32		i,j,xx,offset=0;
	s32		color_index;
	s32		w,dd,ii;
	byte	color;
	u16		*data16;
	u16		color16;
	byte	R,G,B;

	switch(out_color_depth)
	{	case 8:		switch(in_color_depth)
					{	case 8:     for(i=0;i<width;i++)
									{
#if(0)
										data[offset]=FS_fgetbyte(file);
										offset++;
#else
										color_index=FS_fgetbyte(file);
										R=BMP_palette[color_index*3+0];
										G=BMP_palette[color_index*3+1];
										B=BMP_palette[color_index*3+2];
										color=R&0xe0;
										color|=(G>>3)&0x1c;
										color|=(B>>6)&0x03;
										data[offset]=color;
										offset++;
#endif
									}
									break;
					}
					break;
#if(0)
		case 16:	data16=(u16*)data;
					switch(in_color_depth)
					{	case 1:		w=(width>>3);
            						if(width&7) w++;
            						for(i=0;i<w;i++)
			        				{	dd=FS_fgetbyte(file);
										for(j=0;j<8;j++)
										{   ii=(i<<3)+j;
											if(ii>=width) break;
											xx=x+ii;
											if((xx>=GFX_clip_x1) && (xx<=GFX_clip_x2))	
                            				{	if(dd & (1<<(7-j))) color16=0xffff;
                            					else color16=0;
                            					data16[offset]=color16;
											}
											offset++;
										}
            						}
									break;

						case 4:		w=(width>>1);
            						if(width&1) w++;
            						for(i=0;i<w;i++)
			        				{   dd=FS_fgetbyte(file);
                        				for(j=0;j<2;j++)
                        				{   ii=(i<<1)+j;
											if(ii>=width) break;
											xx=x+ii;
											if((xx>=GFX_clip_x1) && (xx<=GFX_clip_x2))	
                            				{	color_index=((dd>>((1-j)<<2))&0xf)*3;
												PC_READ_PALETTE(BMP_palette,color_index,R,G,B);
												PC_RGB_TO_D16(color16,R,G,B);
												data16[offset]=color16;
											}
											offset++;
										}
        							}
									break;

						case 8:		for(i=0;i<width;i++)
			        				{	xx=x+i;
										if((xx>=GFX_clip_x1) && (xx<=GFX_clip_x2))
										{	color_index=FS_fgetbyte(file)*3;
											PC_READ_PALETTE(BMP_palette,color_index,R,G,B);
											PC_RGB_TO_D16(color16,R,G,B);
											data16[offset]=color16;
										}
										else
										{	FS_fgetbyte(file);
										}
										offset++;
            						}
									break;

						case 24:	for(i=0;i<width;i++)
        							{	xx=x+i;
										if((xx>=GFX_clip_x1) && (xx<=GFX_clip_x2))
										{	B=FS_fgetbyte(file);
            								G=FS_fgetbyte(file);
											R=FS_fgetbyte(file);
											PC_RGB_TO_D16(color16,R,G,B);
											data16[offset]=color16;
										}
										else
										{	FS_fgetbyte(file);
											FS_fgetbyte(file);
											FS_fgetbyte(file);
										}
										offset++;
            						}
									break;
					}
					break;

		case 24:	switch(in_color_depth)
					{	case 1:		w=(width>>3);
            						if(width&7) w++;
            						for(i=0;i<w;i++)
			        				{	dd=FS_fgetbyte(file);
										for(j=0;j<8;j++)
										{   ii=(i<<3)+j;
											if(ii>=width) break;
											xx=x+ii;
											if((xx>=GFX_clip_x1) && (xx<=GFX_clip_x2))	
                            				{	if(dd & (1<<(7-j))) color=255;
                            					else color=0;
                            					data[offset+2]=color;
                            					data[offset+1]=color;
                            					data[offset+0]=color;
											}
											offset+=3;
										}
            						}
									break;

						case 4:		w=(width>>1);
            						if(width&1) w++;
            						for(i=0;i<w;i++)
			        				{   dd=FS_fgetbyte(file);
                        				for(j=0;j<2;j++)
                        				{   ii=(i<<1)+j;
											if(ii>=width) break;
											xx=x+ii;
											if((xx>=GFX_clip_x1) && (xx<=GFX_clip_x2))	
                            				{	color_index=((dd>>((1-j)<<2))&0xf)*3;
												PC_READ_PALETTE(BMP_palette,color_index,R,G,B);
												PC_WRITE_RGB(data,offset,R,G,B);
											}
											offset+=3;
										}
        							}
									break;

						case 8:		for(i=0;i<width;i++)
			        				{	xx=x+i;
										if((xx>=GFX_clip_x1) && (xx<=GFX_clip_x2))
										{	color_index=FS_fgetbyte(file)*3;
											PC_READ_PALETTE(BMP_palette,color_index,R,G,B);
											PC_WRITE_RGB(data,offset,R,G,B);
										}
										else
										{
											FS_fgetbyte(file);
										}
										offset+=3;
            						}
									break;

						case 24:	for(i=0;i<width;i++)
        							{	xx=x+i;
										if((xx>=GFX_clip_x1) && (xx<=GFX_clip_x2))
										{	B=FS_fgetbyte(file);
            								G=FS_fgetbyte(file);
											R=FS_fgetbyte(file);
											PC_WRITE_RGB(data,offset,R,G,B);
										}
										else
										{	FS_fgetbyte(file);
											FS_fgetbyte(file);
											FS_fgetbyte(file);
										}
										offset+=3;
            						}
									break;
					}
					break;

		case 32:	switch(in_color_depth)
					{	case 1:		w=(width>>3);
            						if(width&7) w++;
            						for(i=0;i<w;i++)
			        				{	dd=FS_fgetbyte(file);
										for(j=0;j<8;j++)
										{   ii=(i<<3)+j;
											if(ii>=width) break;
											xx=x+ii;
											if((xx>=GFX_clip_x1) && (xx<=GFX_clip_x2))	
                            				{	if(dd & (1<<(7-j))) color=255;
                            					else color=0;
                            					data[offset+2]=color;
                            					data[offset+1]=color;
                            					data[offset+0]=color;
											}
											offset+=4;
										}
            						}
									break;

						case 4:		w=(width>>1);
            						if(width&1) w++;
            						for(i=0;i<w;i++)
			        				{   dd=FS_fgetbyte(file);
                        				for(j=0;j<2;j++)
                        				{   ii=(i<<1)+j;
											if(ii>=width) break;
											xx=x+ii;
											if((xx>=GFX_clip_x1) && (xx<=GFX_clip_x2))	
                            				{	color_index=((dd>>((1-j)<<2))&0xf)*3;
												PC_READ_PALETTE(BMP_palette,color_index,R,G,B);
												PC_WRITE_RGB(data,offset,R,G,B);
											}
											offset+=4;
										}
        							}
									break;

						case 8:		for(i=0;i<width;i++)
			        				{	xx=x+i;
										if((xx>=GFX_clip_x1) && (xx<=GFX_clip_x2))
										{	color_index=FS_fgetbyte(file)*3;
											PC_READ_PALETTE(BMP_palette,color_index,R,G,B);
												PC_WRITE_RGB(data,offset,R,G,B);
										}
										else
										{	FS_fgetbyte(file);
										}
										offset+=4;
            						}
									break;

						case 24:	for(i=0;i<width;i++)
        							{	xx=x+i;
										if((xx>=GFX_clip_x1) && (xx<=GFX_clip_x2))
										{	B=FS_fgetbyte(file);
            								G=FS_fgetbyte(file);
											R=FS_fgetbyte(file);
											PC_WRITE_RGB(data,offset,R,G,B);
										}
										else
										{	FS_fgetbyte(file);
											FS_fgetbyte(file);
											FS_fgetbyte(file);
										}
										offset+=4;
            						}
									break;
					}
					break;
#endif
	}
	for(i=0;i<pad_bytes;i++)
	{	FS_fgetbyte(file);
	}
}

void BMP_load_file_header(bitmap_file_header *h,FS_file_handle file)
{	
	h->file_type=FS_fget16(file);
	h->file_size=FS_fget32(file);
	h->reserved1=FS_fget16(file);
	h->reserved2=FS_fget16(file);
	h->bitmap_offset=FS_fget32(file);
}

void BMP_load_info_header(bitmap_info_header *h,FS_file_handle file)
{	
	h->header_size=FS_fget32(file);
	h->width=FS_fget32(file);
	h->height=FS_fget32(file);
	h->number_of_planes=FS_fget16(file);
	h->bits_per_pixel=FS_fget16(file);
	h->compression=FS_fget32(file);
	h->bitmap_size=FS_fget32(file);
	h->device_width=FS_fget32(file);
	h->device_height=FS_fget32(file);
	h->number_of_colors=FS_fget32(file);
	h->number_of_important_colors=FS_fget32(file);
}

byte *b_data;
byte *b_palette;
s32 b_color_depth=8;
s32 b_row_bytes;
s32 b_width;
s32 b_height;
s32 b_size;

byte BMP_load(s32 x,s32 y,FS_file_handle file)
{   bitmap_file_header	file_header;
	bitmap_info_header	info_header;
	s32					ncolors,i,j,k,width,height,offset;
    s32					bitmap_size,row_bytes,used_row_bytes,total_bits;
    s32					dest_row_bytes,pad_bytes;

	FS_fseek(file,0,SEEK_SET);
	BMP_load_file_header(&file_header,file);

	if((file_header.file_type&0xff)!='B')	return(0);
	if((file_header.file_type>>8)!='M')		return(0);
	
	BMP_load_info_header(&info_header,file);
	width=info_header.width;
	height=info_header.height;
	ncolors=1<<info_header.bits_per_pixel;

	if(info_header.bits_per_pixel==24)
	{	used_row_bytes=width*3;
	}
	else
	{	total_bits=width*info_header.bits_per_pixel;
		used_row_bytes=total_bits>>3;				/*total_bits/8	*/
		if((total_bits%8)>0) used_row_bytes+=1;     /*	total_bits%8	*/
	}
	
	if((used_row_bytes%4)>0) row_bytes=used_row_bytes+(4-(used_row_bytes%4));
	else row_bytes=used_row_bytes;
    if(b_color_depth<=8)
    {	dest_row_bytes=width/(8/b_color_depth);
	    if((width%(8/b_color_depth))>0) dest_row_bytes++;
	}
    else
    {	dest_row_bytes=width*(b_color_depth/8);
    }
	bitmap_size=dest_row_bytes*height;
	b_width=width;
	b_height=height;
	b_size=bitmap_size;
	b_data=(byte*)malloc(b_size);
	b_palette=(byte*)malloc(256*3);
	b_row_bytes=dest_row_bytes;
	memset(b_data,0,b_size);
    if(b_color_depth<=8)
    {	if(b_palette==NULL) return(0);
    }
    if(b_data==NULL)
    {   return(0);
    }
	if(info_header.bits_per_pixel<=8)
	{	k=0;
		if(b_color_depth<=8)
		{	
			for(i=0;i<ncolors;i++)
			{	BMP_palette[k+2]=b_palette[k+2]=FS_fgetbyte(file);
				BMP_palette[k+1]=b_palette[k+1]=FS_fgetbyte(file);
				BMP_palette[k+0]=b_palette[k+0]=FS_fgetbyte(file);
				k+=3;
				FS_fgetbyte(file);
			}
		}
		else
		{	for(i=0;i<ncolors;i++)
			{	BMP_palette[k+2]=FS_fgetbyte(file);
				BMP_palette[k+1]=FS_fgetbyte(file);
				BMP_palette[k+0]=FS_fgetbyte(file);
				k+=3;
				FS_fgetbyte(file);
			}
		}
	}
	FS_fseek(file,file_header.bitmap_offset,SEEK_SET);
	offset=(y+height-1)*b_row_bytes+x;
	pad_bytes=row_bytes-used_row_bytes;
	
	for(j=height-1;j>=0;j--)
	{
		BMP_write_line(x,(y+j),width,file,&b_data[offset],pad_bytes,info_header.bits_per_pixel,b_color_depth);
		
		offset-=b_row_bytes;
	}
	
	return(1);
}

void write_buffer(FILE *file_handle)
{
#if(1)
	s32 i;
	fprintf(file_handle,"\n{");
	for(i=0;i<b_size;i++)
	{
		if((i%32)==0) fprintf(file_handle,"\n");
		fprintf(file_handle,"0x%02X,",b_data[i]);
		
	}
	fprintf(file_handle,"\n};");
#else
	s32 i,j,offset;
	char outchars[]={'.','*','#','.','*','#','+','-'};

	for(j=0;j<b_height;j++)
	{
		fprintf(file_handle,"\n");
		for(i=0;i<b_width;i++)
		{
			offset=j*b_width+i;
			fprintf(file_handle,"%c",outchars[b_data[offset]%8]);
		}
	}
#endif
}

int main(int argc,char *argv[])
{
	FILE *input_file_handle;
	FILE *output_file_handle;
	
	if(argc<3)
	{
		printf("\nUsage: converter <input-file> <output-file>");
		exit(0);
	}
	input_file_handle=fopen(argv[1],"rb");
	if(input_file_handle==NULL) 
	{
		printf("\nInput file %s not found",argv[1]);
		exit(0);
	}
	BMP_load(0,0,input_file_handle);
	fclose(input_file_handle);
	output_file_handle=fopen(argv[2],"wb");
	if(output_file_handle==NULL)
	{
		printf("\nUnable to create output file %s",argv[2]);
		exit(0);
	}

	write_buffer(output_file_handle);
	fclose(output_file_handle);
	free(b_data);
	free(b_palette);
	printf("\nWrote bitmap width=%d, height=%d, total=%d bytes",b_width,b_height,b_size);
}