home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
OS/2 Shareware BBS: 11 Util
/
11-Util.zip
/
CVTICO.ZIP
/
CVTICO.C
next >
Wrap
Text File
|
1990-10-11
|
12KB
|
411 lines
#include <stdio.h>
#include <stdlib.h>
#define INCL_GPIBITMAPS
#include <os2.h>
#include <pmbitmap.h>
typedef unsigned int WORD;
typedef unsigned long DWORD;
typedef struct winicohead
{
WORD icoReserved;
WORD icoResourceType;
WORD icoResourceCount;
} WinBitMapFileHeader;
typedef struct winbitmapinfo
{
BYTE Width;
BYTE Height;
BYTE ColorCount;
BYTE res1;
WORD res2;
WORD res3;
DWORD icoDIBSize;
DWORD icoDIBOffset;
} WinBitMapInfo;
typedef struct windib
{
DWORD size;
DWORD width;
DWORD height;
WORD planes;
WORD bitcount;
DWORD compress;
DWORD sizeimage;
DWORD xpelspermeter;
DWORD ypelspermeter;
DWORD colorused;
DWORD clrimportant;
} WinDIBHead;
typedef struct winrgb
{
BYTE blue;
BYTE green;
BYTE red;
BYTE res;
} wRGB;
void disp_wbmfh ( WinBitMapFileHeader * );
void disp_wbmi ( WinBitMapInfo * );
void disp_wdib ( WinDIBHead * );
void disp_rgb ( wRGB * );
void disp_colormap ( BYTE *, WinBitMapInfo * );
void disp_monomap ( BYTE *, WinBitMapInfo * );
void disp_byte ( BYTE );
int bitsperpel ( BYTE );
void write_mono_rgb ( FILE * );
void write_os2_rgb ( FILE *, wRGB *, int );
/* OS/2 structures */
BITMAPARRAYFILEHEADER bafh;
BITMAPFILEHEADER bfh;
RGB rgb;
void main
(
int argc,
char *argv []
)
{
FILE *fp;
FILE *ofp;
WinBitMapFileHeader wbmfh;
WinBitMapInfo wbmi;
WinDIBHead dibhead;
BYTE colormap [64 * 64];
BYTE monomap [64 * 64];
wRGB rgbtable [64];
int i;
int j;
int pels;
fpos_t curpos;
long last_bafh;
if ( argc != 3 )
{
fprintf ( stderr, "The correct call is:\n cvtico <infile> <outfile>" );
exit ( 1 );
}
if ( NULL == (fp = fopen ( argv [1], "rb" )) )
{
perror ( argv [1] );
exit ( 1 );
}
if ( NULL == (ofp = fopen ( argv [2], "w+b" )) )
{
perror ( argv [2]);
exit ( 1 );
}
fseek ( ofp, 0L, SEEK_SET );
fread ( &wbmfh, sizeof ( wbmfh ), 1, fp );
#if defined (DEBUG)
disp_wbmfh ( &wbmfh );
#endif
for ( i = 0; i < wbmfh. icoResourceCount; i++ )
{
fread ( &wbmi, sizeof ( wbmi ), 1, fp );
#if defined (DEBUG)
disp_wbmi ( &wbmi );
#endif
fgetpos ( fp, &curpos );
fseek ( fp, wbmi.icoDIBOffset, SEEK_SET );
pels = 8 / bitsperpel ( wbmi. ColorCount );
fread ( &dibhead, sizeof ( dibhead ), 1, fp );
#if defined (DEBUG)
disp_wdib ( &dibhead );
#endif
fread ( rgbtable, sizeof ( wRGB ), wbmi. ColorCount, fp );
#if defined (DEBUG)
for ( j = 0; j < wbmi. ColorCount; j++ )
disp_rgb ( &rgbtable [j] );
#endif
fread ( colormap, sizeof ( BYTE ), wbmi.Width * wbmi.Height / pels, fp );
#if defined (DEBUG)
disp_colormap ( colormap, &wbmi );
#endif
fread ( monomap, sizeof ( BYTE ), wbmi.Width * wbmi.Height / 8, fp );
#if defined (DEBUG)
disp_monomap ( monomap, &wbmi );
#endif
last_bafh = ftell ( ofp );
/* Write it out now */
bafh.usType = BFT_BITMAPARRAY;
bafh.cbSize = sizeof ( bafh );
bafh.offNext = 0L;
bafh.cxDisplay = 0;
bafh.cyDisplay = 0;
/* The first bfh is for the AndXor mask */
bafh.bfh.usType = BFT_COLORICON;
bafh.bfh.cbSize = sizeof ( bafh. bfh );
bafh.bfh.xHotspot = 0;
bafh.bfh.yHotspot = 0;
bafh.bfh.offBits = last_bafh +
sizeof ( bafh ) +
2 * 3 +
sizeof ( bfh ) +
wbmi. ColorCount * 3;
bafh.bfh.bmp.cbFix = sizeof ( bafh. bfh. bmp );
bafh.bfh.bmp.cx = wbmi.Width;
bafh.bfh.bmp.cy = wbmi.Height * 2;
bafh.bfh.bmp.cPlanes = 1;
bafh.bfh.bmp.cBitCount = 1;
/* The second bfh is for the Color mask */
bfh.usType = BFT_COLORICON;
bfh.cbSize = sizeof ( bafh. bfh );
bfh.xHotspot = 0;
bfh.yHotspot = 0;
bfh.offBits = last_bafh +
sizeof ( bafh ) +
2 * 3 +
sizeof ( bfh ) +
wbmi. ColorCount * 3 +
wbmi.Width * wbmi.Height / 4;
bfh.bmp.cbFix = sizeof ( bafh. bfh. bmp );
bfh.bmp.cx = wbmi.Width;
bfh.bmp.cy = wbmi.Height;
bfh.bmp.cPlanes = 1;
bfh.bmp.cBitCount = bitsperpel ( wbmi. ColorCount );
fwrite ( &bafh, sizeof ( bafh ), 1, ofp );
write_mono_rgb ( ofp );
fwrite ( &bfh, sizeof ( bfh ), 1, ofp );
write_os2_rgb ( ofp, rgbtable, wbmi. ColorCount );
fwrite ( monomap, sizeof ( BYTE ), wbmi.Width * wbmi.Height / 8, ofp );
fwrite ( monomap, sizeof ( BYTE ), wbmi.Width * wbmi.Height / 8, ofp );
fwrite ( colormap, sizeof ( BYTE ), wbmi.Width * wbmi.Height / pels, ofp );
fsetpos ( fp, &curpos );
}
fclose ( fp );
fclose ( ofp );
exit ( 0 );
}
/**/
/**************************************************************************************************/
void disp_wbmfh
(
WinBitMapFileHeader *wbmfh
)
{
printf ( "icoReserved = %x\n", wbmfh -> icoReserved );
printf ( "icoResourceType = %x\n", wbmfh -> icoResourceType );
printf ( "icoResourceCount = %x\n", wbmfh -> icoResourceCount );
}
/**/
/**************************************************************************************************/
void disp_wbmi
(
WinBitMapInfo *wbmi
)
{
printf ( "Width = %x\n", wbmi -> Width );
printf ( "Height = %x\n", wbmi -> Height );
printf ( "ColorCount = %x\n", wbmi -> ColorCount );
printf ( "res1 = %x\n", wbmi -> res1 );
printf ( "res2 = %x\n", wbmi -> res2 );
printf ( "res3 = %x\n", wbmi -> res3 );
printf ( "icoDIBSize = %lx\n", wbmi -> icoDIBSize );
printf ( "icoDIBOffset = %lx\n", wbmi -> icoDIBOffset );
}
/**/
/**************************************************************************************************/
void disp_wdib
(
WinDIBHead *dib
)
{
printf ( "size = %lx\n", dib -> size );
printf ( "width = %lx\n", dib -> width );
printf ( "height = %lx\n", dib -> height );
printf ( "planes = %x\n", dib -> planes );
printf ( "bitcount = %x\n", dib -> bitcount );
printf ( "compress = %lx\n", dib -> compress );
printf ( "sizeimage = %lx\n", dib -> sizeimage );
printf ( "xpelspermeter = %lx\n", dib -> xpelspermeter );
printf ( "ypelspermeter = %lx\n", dib -> ypelspermeter );
printf ( "colorused = %lx\n", dib -> colorused );
printf ( "clrimportant = %lx\n", dib -> clrimportant );
}
/**/
/**************************************************************************************************/
void disp_rgb
(
wRGB *rgb
)
{
printf ( "%02x %02x %02x %02x\n", rgb -> blue, rgb -> green, rgb -> red, rgb -> res );
}
/**/
/**************************************************************************************************/
int bitsperpel
(
BYTE colorcount
)
{
if ( colorcount == 2 )
return ( 1 );
else if ( colorcount == 8 )
return ( 3 );
else
return ( 4 );
}
/**/
/**************************************************************************************************/
void disp_colormap
(
BYTE *colormap,
WinBitMapInfo *wbmi
)
{
int w;
int h;
int width;
int height;
int pels;
width = wbmi -> Width;
height = wbmi -> Height;
pels = 8 / bitsperpel ( wbmi -> ColorCount );
for ( h = 0; h < height; h++ )
{
for ( w = 0; w < width / pels; w++ )
printf ( "%02x", colormap [ h * width / pels + w ] );
printf ( "\n" );
}
}
/**/
/**************************************************************************************************/
void disp_monomap
(
BYTE *monomap,
WinBitMapInfo *wbmi
)
{
int w;
int h;
int width;
int height;
width = wbmi -> Width;
height = wbmi -> Height;
for ( h = 0; h < height; h++ )
{
for ( w = 0; w < width / 8; w++ )
disp_byte ( monomap [ h * width / 8 + w ] );
printf ( "\n" );
}
}
/**/
/**************************************************************************************************/
void disp_byte
(
BYTE b
)
{
int i;
for ( i = 0; i < 8; i++ )
{
printf ( "%d", ( 0 == (b & 0x80) ) ? 0 : 1 );
b = b << 1;
}
}
/**/
/**************************************************************************************************/
char os2_rgb_defaults [] =
{
0x00, 0x00, 0x00,
0xff, 0xff, 0xff,
0xff, 0x00, 0x00,
0x00, 0x00, 0xff,
0xff, 0x00, 0xff,
0x00, 0xff, 0x00,
0xff, 0xff, 0x00,
0x00, 0xff, 0xff,
0x40, 0x40, 0x40,
0x80, 0x00, 0x00,
0x00, 0x00, 0x80,
0x80, 0x00, 0x80,
0x00, 0x80, 0x00,
0x80, 0x80, 0x00,
0x00, 0x34, 0x78,
0xc0, 0xc0, 0xc0
};
void write_os2_rgb
(
FILE *ofp,
wRGB *rgbtable,
int colorcount
)
{
int i;
for ( i = 0; i < colorcount; i++ )
{
fwrite ( &rgbtable [i].blue, sizeof ( BYTE ), 1, ofp );
fwrite ( &rgbtable [i].green, sizeof ( BYTE ), 1, ofp );
fwrite ( &rgbtable [i].red, sizeof ( BYTE ), 1, ofp );
}
// fwrite ( os2_rgb_defaults, sizeof ( os2_rgb_defaults ), 1, ofp );
}
/**/
/**************************************************************************************************/
char mono_rgb_defaults [] =
{
0x00, 0x00, 0x00,
0xff, 0xff, 0xff
};
void write_mono_rgb
(
FILE *ofp
)
{
fwrite ( mono_rgb_defaults, sizeof ( mono_rgb_defaults ), 1, ofp );
}