FreeCalypso > hg > fc-magnetite

view src/aci2/bmi/Icons/BMP/bmpToHex.c @ 549:69e52afc01d5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
configs/* except classic: rebuild tif_na7_db_{fl,ir} from source The purpose of this change is to allow a TRACEMASK_IN_FFS=1 setting given on the configure line to have effect; all configs except classic are included because this feature setting is orthogonal to the choice of G23M PS version and other config choices. (The classic config is an exception because its very purpose is to preserve a reference config with all of the original blobs.) Note that even though we are switching these TIF libraries from blobs to recompilation from source in all configs, our source for these libs compiles into a perfect match to the original blobs in the current default TRACEMASK_IN_FFS=0 configuration, hence there is no effective change beyond the unfortunate small increase in compilation times.
author Mychaela Falconia <falcon@freecalypso.org>
date Sun, 18 Nov 2018 08:33:30 +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);
}