[mupen64plus-pandora.git] / source / rice_gles / src / liblinux / bmp.c

/*
//  source code for the ImageLib BMP functions
//
//  Copyright (C) 2001 M. Scott Heiman
//  All Rights Reserved
//
// You may use the software for any purpose you see fit. You may modify
// it, incorporate it in a commercial application, use it for school,
// even turn it in as homework. You must keep the Copyright in the
// header and source files. This software is not in the "Public Domain".
// You may use this software at your own risk. I have made a reasonable
// effort to verify that this software works in the manner I expect it to;
// however,...
//
// THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS" AND
// WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE, INCLUDING
// WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR FITNESS FOR A
// PARTICULAR PURPOSE. IN NO EVENT SHALL MICHAEL S. HEIMAN BE LIABLE TO
// YOU OR ANYONE ELSE FOR ANY DIRECT, SPECIAL, INCIDENTAL, INDIRECT OR
// CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING
// WITHOUT LIMITATION, LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE,
// OR THE CLAIMS OF THIRD PARTIES, WHETHER OR NOT MICHAEL S. HEIMAN HAS
// BEEN ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
// ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
// POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
*/

#include "BMGDLL.h"
#include "BMGUtils.h"
#include <stdio.h>
#include <stdlib.h>
#include <setjmp.h>

#ifndef _WIN32
#include <string.h>
#endif // _WIN32

static const unsigned short BMP_ID = 0x4D42;

/*
    ReadBMP - reads the image data from a BMP files and stores it in a
              BMGImageStruct.

    Inputs:
        filename    - the name of the file to be opened

    Outputs:
        img         - the BMGImageStruct containing the image data

    Returns:
        BMGError - if the file could not be read or a resource error occurred
        BMG_OK   - if the file was read and the data was stored in img

    Limitations:
        will not read BMP files using BI_RLE8, BI_RLE4, or BI_BITFIELDS
*/
BMGError ReadBMP( const char *filename,
              struct BMGImageStruct *img )
{
    FILE *file = NULL;
    int error;
    BMGError tmp;
    unsigned char *p, *q; /*, *q_end; */
/*    unsigned int cnt; */
    int i;
/*    int EOBMP; */

    BITMAPFILEHEADER bmfh;
    BITMAPINFOHEADER bmih;
/*
    unsigned int mask[3];
*/

    unsigned int DIBScanWidth;
    unsigned int bit_size, rawbit_size;
    unsigned char *rawbits = NULL;

    SetLastBMGError( BMG_OK );

    if ( img == NULL )
        { error = (int) errInvalidBMGImage; goto err_jmp; }


    file = fopen( filename, "rb" );
    if  ( file == NULL )
        { error = (int) errFileOpen; goto err_jmp; }

        /* read the file header */
    if ( fread( (void *)&bmfh, sizeof(BITMAPFILEHEADER), 1, file ) != 1 )
        { error = (int) errFileRead; goto err_jmp; }

    /* confirm that this is a BMP file */
    if ( bmfh.bfType != BMP_ID )
        { error = (int) errUnsupportedFileFormat; goto err_jmp; }

    /* read the bitmap info header */
    if ( fread( (void *)&bmih, sizeof(BITMAPINFOHEADER), 1, file ) != 1 )
        { error = (int) errFileRead; goto err_jmp; }

    /* abort if this is an unsupported format */
    if ( bmih.biCompression != BI_RGB )
        { printf("planes: %i  bits: %i  type: %i   ", bmih.biPlanes, bmih.biBitCount, bmih.biCompression); error = (int) errUnsupportedFileFormat; goto err_jmp; }

    img->bits_per_pixel = (unsigned char)bmih.biBitCount;
    img->width  = bmih.biWidth;
    img->height = bmih.biHeight;
    if ( img->bits_per_pixel <= 8 )
    {
        img->palette_size = (unsigned short)bmih.biClrUsed;
        img->bytes_per_palette_entry = 4U;
    }

    tmp = AllocateBMGImage( img );
    if ( tmp != BMG_OK )
        { error = (int) tmp; goto err_jmp; }

    /* read palette if necessary */
    if ( img->bits_per_pixel <= 8 )
    {
        if ( fread( (void *)img->palette, sizeof(RGBQUAD), img->palette_size,
                file ) != (unsigned int)img->palette_size )
        {
          error = (int) errFileRead;
          goto err_jmp;
        }
    }

    /* dimensions */
    DIBScanWidth = ( img->bits_per_pixel * img->width + 7 ) / 8;
    if ( DIBScanWidth %4 )
        DIBScanWidth += 4 - DIBScanWidth % 4;

    bit_size = img->scan_width * img->height;

    /* allocate memory for the raw bits */
    if ( bmih.biCompression != BI_RGB )
        rawbit_size = bmfh.bfSize - bmfh.bfOffBits;
    else
        rawbit_size = DIBScanWidth * img->height;

    rawbits = (unsigned char *)calloc( rawbit_size, 1 );
    if ( rawbits == NULL )
        { error = (int) errMemoryAllocation; goto err_jmp; }

    if ( fread( (void *)rawbits, sizeof(unsigned char), rawbit_size, file )
                   != rawbit_size )
    {
        error = (int) errFileRead;
        goto err_jmp;
    }

    if ( bmih.biCompression == BI_RGB )
    {
        p = rawbits;
        for ( q = img->bits; q < img->bits + bit_size;
                         q += img->scan_width, p += DIBScanWidth )
        {
            memcpy( (void *)q, (void *)p, img->scan_width );
        }
    }

    /* swap rows if necessary */
    if ( bmih.biHeight < 0 )
    {
        for ( i = 0; i < (int)(img->height) / 2; i++ )
        {
            p = img->bits + i * img->scan_width;
            q = img->bits + ((img->height) - i - 1 ) * img->scan_width;
            memcpy( (void *)rawbits, (void *)p, img->scan_width );
            memcpy( (void *)p, (void *)q, img->scan_width );
            memcpy( (void *)q, (void *)rawbits, img->scan_width );
        }
    }

    fclose( file );
    free( rawbits );
    return BMG_OK;

  /* error handler */
err_jmp:
    if ( file != NULL )
        fclose( file );
    if ( rawbits != NULL )
        free( rawbits );
    FreeBMGImage( img );
    SetLastBMGError( (BMGError)error );
    return (BMGError)error;

}

/*
    WriteBMP - writes the contents of an BMGImageStruct to a bmp file.

    Inputs:
        filename    - the name of the file to be opened
        img         - the BMGImageStruct containing the image data

    Returns:
        BMGError - if a write error or a resource error occurred
        BMG_OK   - if the data was successfilly stored in filename

    Limitations:
        will not write BMP files using BI_RLE8, BI_RLE4, or BI_BITFIELDS
*/
BMGError WriteBMP( const char *filename,
                   struct BMGImageStruct img )
{
    FILE * volatile file = NULL;
    jmp_buf err_jmp;
    int error;

    unsigned char * volatile bits = NULL;
    unsigned int DIBScanWidth;
    unsigned int BitsPerPixel;
    unsigned int bit_size; /*, new_bit_size; */
/*    unsigned int rawbit_size; */
    unsigned char *p, *q, *r, *t;
/*    unsigned int cnt;  */
    unsigned char * volatile pColor = NULL;

    BITMAPFILEHEADER bmfh;
    BITMAPINFOHEADER bmih;

    SetLastBMGError( BMG_OK );

    /* error handler */
    error = setjmp(err_jmp);
    if (error != 0)
    {
        if (file != NULL)
            fclose(file);
        if (bits != NULL)
            free(bits);
        if (pColor != NULL)
            free(pColor);
        SetLastBMGError((BMGError)error);
        return (BMGError) error;
    }

    if ( img.bits == NULL )
        longjmp( err_jmp, (int)errInvalidBMGImage );

    file = fopen( filename, "wb" );
    if ( file == NULL )
        longjmp( err_jmp, (int)errFileOpen );

    /* abort if we do not support the data */
    if ( img.palette != NULL && img.bytes_per_palette_entry < 3 )
        longjmp( err_jmp, (int)errInvalidBMGImage );

    /* calculate dimensions */
    BitsPerPixel = img.bits_per_pixel < 32 ? img.bits_per_pixel : 24U;
    DIBScanWidth = ( BitsPerPixel * img.width + 7 ) / 8;
    if ( DIBScanWidth % 4 )
        DIBScanWidth += 4 - DIBScanWidth % 4;
    bit_size = DIBScanWidth * img.height;
/*    rawbit_size = BITScanWidth * img.height; */

    /* allocate memory for bit array - assume that compression will
    // actually compress the bitmap */
    bits = (unsigned char *)calloc( bit_size, 1 );
    if ( bits == NULL )
        longjmp( err_jmp, (int)errMemoryAllocation );

    /* some initialization */
    memset( (void *)&bmih, 0, sizeof(BITMAPINFOHEADER) );
    bmih.biSize = sizeof(BITMAPINFOHEADER);
    bmih.biWidth = img.width;
    bmih.biHeight = img.height;
    bmih.biPlanes = 1;
    /* 32-bit images will be stored as 24-bit images to save space.  The BMP
       format does not use the high word and I do not want to store alpha
       components in an image format that does not recognize it */
    bmih.biBitCount = BitsPerPixel;
    bmih.biCompression = BI_RGB; // assumed
    bmih.biSizeImage = bit_size; // assumed
    bmih.biClrUsed = img.palette == NULL ? 0 : img.palette_size;
    bmih.biClrImportant = img.palette == NULL ? 0 : img.palette_size;

    /* if we are not compressed then copy the raw bits to bits */
    if ( bmih.biCompression == BI_RGB )
    {
        p = img.bits;
        /* simple memcpy's for images containing < 32-bits per pixel */
        if ( img.bits_per_pixel < 32 )
        {
            for ( q = bits; q < bits + bit_size; q += DIBScanWidth,
                                                 p += img.scan_width )
            {
                memcpy( (void *)q, (void *)p, img.scan_width );
            }
        }
        /* store 32-bit images as 24-bit images to save space. alpha terms
           are lost */
        else
        {
            DIBScanWidth = 3 * img.width;
            if ( DIBScanWidth % 4 )
                DIBScanWidth += 4 - DIBScanWidth % 4;

            for ( q = bits; q < bits + bit_size; q += DIBScanWidth,
                                                 p += img.scan_width )
            {
                t = p;
                for ( r = q; r < q + DIBScanWidth; r += 3, t += 4 )
                    memcpy( (void *)r, (void *)t, 3 );
            }
        }
    }

    /* create the palette if necessary */
    if ( img.palette != NULL )
    {
        pColor = (unsigned char *)calloc( img.palette_size, sizeof(RGBQUAD) );
        if ( pColor == NULL )
            longjmp( err_jmp, (int)errMemoryAllocation );

        if ( img.bytes_per_palette_entry == 3 )
        {
            p = img.palette;
            for ( q = pColor + 1; q < pColor +img.palette_size*sizeof(RGBQUAD);
                            q += sizeof(RGBQUAD), p += 3 )
            {
                memcpy( (void *)pColor, (void *)p, 3 );
            }
        }
        else /* img.bytes_per_palette_entry == 4 */
        {
            memcpy( (void *)pColor, (void *)img.palette,
                img.palette_size * sizeof(RGBQUAD) );
        }
    }

    /* now that we know how big everything is let's write the file */
    memset( (void *)&bmfh, 0, sizeof(BITMAPFILEHEADER) );
    bmfh.bfType = BMP_ID;
    bmfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) +
                     img.palette_size * sizeof(RGBQUAD);
    bmfh.bfSize = bmfh.bfOffBits + bit_size;

    if ( fwrite( (void *)&bmfh, sizeof(BITMAPFILEHEADER), 1, file ) != 1 )
        longjmp( err_jmp, (int)errFileWrite );

    if ( fwrite( (void *)&bmih, sizeof(BITMAPINFOHEADER), 1, file ) != 1 )
        longjmp( err_jmp, (int)errFileWrite );

    if ( pColor != NULL )
    {
        if ( fwrite( (void *)pColor, sizeof(RGBQUAD), img.palette_size, file )
                              != (unsigned int)img.palette_size )
        {
            longjmp( err_jmp, (int)errFileWrite );
        }
    }

    if ( fwrite( (void *)bits, sizeof(unsigned char), bit_size, file )
                    != bit_size )
    {
        longjmp( err_jmp, (int)errFileWrite );
    }

    fclose( file );
    free( bits );
    if ( pColor != NULL )
        free( pColor );
    return BMG_OK;
}

#ifdef _NEVER_DEFINE_THIS_DEF_
/* following code is not tested.  I keep it here in case I ever find a BMP
  file that is compressed and I want to test it */
    else if ( bmih.biCompression == BI_RLE8 )
    {
        bmih.biCompression = BI_RGB;
        bmih.biSizeImage = DIBScanWidth * img.height;
        p = rawbits;
        q = img.bits;
        EOBMP = 1;
        while ( q < img.bits + bit_size && p < rawbits + rawbit_size && EOBMP )
        {
            cnt = (unsigned int)*p;
            p++;

            /* encoded mode */
            if ( cnt == 0 )
            {
                cnt = (unsigned int)*p;
                if ( cnt < 3U )
                {
                    p++;
                    /* EOL */
                    if ( *p == 0 )
                        p++;
                    /* end of bitmap */
                    else if ( *p == 1 )
                        EOBMP = 0;
                    /* delta */
                    else if ( *p == 2 )
                    {
                        p++;
                        q += *p;  /* columns */
                        p++;
                        q += (*p)*BITScanWidth; /* rows */
                        p++;
                    }
                }
                /* copy *p duplicates of *(p++) into the bit array */
                else
                {
                    cnt = (unsigned int)*p;
                    p++;
                    q_end = q + cnt;
                    while ( q < q_end )
                        *q++ = *p;
                    p++;
                }
            }
            /* absolute mode */
            else
            {
                q_end = q + cnt;
                while ( q < q_end )
                    *q++ = *p++;
            }
        }
    }

    /* if compression is desired && possible then attempt compression.  The
    // following logic will try to compress the data.  If the compressed data
    // requires more space than the uncompressed data then the bits will be
    // stored in an uncompressed format */
    if ( try_compression != 0 && img.bits_per_pixel == 8 )
    {
        p = rawbits;
        r = bits;
        new_bit_size = 0;
        cnt = 0;
        while ( p < rawbits + rawbit_size && new_bit_size < bit_size )
        {
            q = p;
            while ( q < p + BITScanWidth )
            {
                t = q;
                while ( t < q + 255 && t < p + BITScanWidth )
                {
                    /* look for non-repeats - absolute mode */
                    if ( *t != *(t+1) )
                    {
                        while ( *t != *(t+1) &&
                                cnt < 255 &&
                                t < p + BITScanWidth )
                        {
                            t++;
                            cnt++;
                        }
                        cnt++;
                        *r++ = (unsigned char)cnt;
                        memcpy( (void *)r, (void *)q, cnt );
                        r += cnt;
                        q += cnt;
                        new_bit_size += 1 + cnt;
                        cnt = 0;
                    }
                    /* else look for repeats */
                    else
                    {
                        while ( *t == *(t+1) &&
                                cnt < 255 &&
                                t < p + BITScanWidth )
                        {
                            t++;
                            cnt++;
                        }
                        cnt++;
                        if ( cnt > 2 )
                        {
                            *r++ = 0;
                            *r++ = (unsigned char)cnt;
                            *r++ = *(t-1);
                            new_bit_size += 3;
                            q = t;
                            cnt = 0;
                        }
                        /* use absolute mode if we have reached the EOL &&
                        // cnt <= 2 */
                        else if ( t >= p + BITScanWidth )
                        {
                            *r++ = (unsigned char)cnt;
                            memcpy( (void *)r, (void *)q, cnt );
                            r += cnt;
                            q += cnt;
                            new_bit_size += 1 + cnt;
                            cnt = 0;
                        }
                    }
                }

                /* put an EOL marker here */
                *r++ = 0;
                *r++ = 0;
                new_bit_size += 2;
                cnt = 0;
            }

            p += BITScanWidth;
        }

        /* put the EOB marker here */
        if ( new_bit_size < bit_size - 2 )
        {
            *r++ = 0;
            *r = 1;
            new_bit_size += 2;
        }
        else
            new_bit_size = bit_size + 1;

        /* if the compressed image will take less space then use it */
        if ( new_bit_size < bit_size )
        {
            bmih.biCompression = BI_RLE8;
            bmih.biSizeImage = bit_size = new_bit_size;
        }
    }

#endif
Commit	Line	Data
d07c171f	1	/*
	2	// source code for the ImageLib BMP functions
	3	//
	4	// Copyright (C) 2001 M. Scott Heiman
	5	// All Rights Reserved
	6	//
	7	// You may use the software for any purpose you see fit. You may modify
	8	// it, incorporate it in a commercial application, use it for school,
	9	// even turn it in as homework. You must keep the Copyright in the
	10	// header and source files. This software is not in the "Public Domain".
	11	// You may use this software at your own risk. I have made a reasonable
	12	// effort to verify that this software works in the manner I expect it to;
	13	// however,...
	14	//
	15	// THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS" AND
	16	// WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE, INCLUDING
	17	// WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR FITNESS FOR A
	18	// PARTICULAR PURPOSE. IN NO EVENT SHALL MICHAEL S. HEIMAN BE LIABLE TO
	19	// YOU OR ANYONE ELSE FOR ANY DIRECT, SPECIAL, INCIDENTAL, INDIRECT OR
	20	// CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING
	21	// WITHOUT LIMITATION, LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE,
	22	// OR THE CLAIMS OF THIRD PARTIES, WHETHER OR NOT MICHAEL S. HEIMAN HAS
	23	// BEEN ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
	24	// ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
	25	// POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
	26	*/
	27
	28	#include "BMGDLL.h"
	29	#include "BMGUtils.h"
	30	#include <stdio.h>
	31	#include <stdlib.h>
	32	#include <setjmp.h>
	33
	34	#ifndef _WIN32
	35	#include <string.h>
	36	#endif // _WIN32
	37
	38	static const unsigned short BMP_ID = 0x4D42;
	39
	40	/*
	41	ReadBMP - reads the image data from a BMP files and stores it in a
	42	BMGImageStruct.
	43
	44	Inputs:
	45	filename - the name of the file to be opened
	46
	47	Outputs:
	48	img - the BMGImageStruct containing the image data
	49
	50	Returns:
	51	BMGError - if the file could not be read or a resource error occurred
	52	BMG_OK - if the file was read and the data was stored in img
	53
	54	Limitations:
	55	will not read BMP files using BI_RLE8, BI_RLE4, or BI_BITFIELDS
	56	*/
	57	BMGError ReadBMP( const char *filename,
	58	struct BMGImageStruct *img )
	59	{
	60	FILE *file = NULL;
	61	int error;
	62	BMGError tmp;
	63	unsigned char p, q; /, q_end; */
	64	/* unsigned int cnt; */
65	int i;
66	/* int EOBMP; */
67
68	BITMAPFILEHEADER bmfh;
69	BITMAPINFOHEADER bmih;
70	/*
71	unsigned int mask[3];
72	*/
73
74	unsigned int DIBScanWidth;
75	unsigned int bit_size, rawbit_size;
76	unsigned char *rawbits = NULL;
77
78	SetLastBMGError( BMG_OK );
79
80	if ( img == NULL )
81	{ error = (int) errInvalidBMGImage; goto err_jmp; }
82
83
84	file = fopen( filename, "rb" );
85	if ( file == NULL )
86	{ error = (int) errFileOpen; goto err_jmp; }
87
88	/* read the file header */
89	if ( fread( (void *)&bmfh, sizeof(BITMAPFILEHEADER), 1, file ) != 1 )
90	{ error = (int) errFileRead; goto err_jmp; }
91
92	/* confirm that this is a BMP file */
93	if ( bmfh.bfType != BMP_ID )
94	{ error = (int) errUnsupportedFileFormat; goto err_jmp; }
95
96	/* read the bitmap info header */
97	if ( fread( (void *)&bmih, sizeof(BITMAPINFOHEADER), 1, file ) != 1 )
98	{ error = (int) errFileRead; goto err_jmp; }
99
100	/* abort if this is an unsupported format */
101	if ( bmih.biCompression != BI_RGB )
102	{ printf("planes: %i bits: %i type: %i ", bmih.biPlanes, bmih.biBitCount, bmih.biCompression); error = (int) errUnsupportedFileFormat; goto err_jmp; }
103
104	img->bits_per_pixel = (unsigned char)bmih.biBitCount;
105	img->width = bmih.biWidth;
106	img->height = bmih.biHeight;
107	if ( img->bits_per_pixel <= 8 )
108	{
109	img->palette_size = (unsigned short)bmih.biClrUsed;
110	img->bytes_per_palette_entry = 4U;
111	}
112
113	tmp = AllocateBMGImage( img );
114	if ( tmp != BMG_OK )
115	{ error = (int) tmp; goto err_jmp; }
116
117	/* read palette if necessary */
118	if ( img->bits_per_pixel <= 8 )
119	{
120	if ( fread( (void *)img->palette, sizeof(RGBQUAD), img->palette_size,
121	file ) != (unsigned int)img->palette_size )
122	{
123	error = (int) errFileRead;
124	goto err_jmp;
125	}
126	}
127
128	/* dimensions */
129	DIBScanWidth = ( img->bits_per_pixel * img->width + 7 ) / 8;
130	if ( DIBScanWidth %4 )
131	DIBScanWidth += 4 - DIBScanWidth % 4;
132
133	bit_size = img->scan_width * img->height;
134
135	/* allocate memory for the raw bits */
136	if ( bmih.biCompression != BI_RGB )
137	rawbit_size = bmfh.bfSize - bmfh.bfOffBits;
138	else
139	rawbit_size = DIBScanWidth * img->height;
140
141	rawbits = (unsigned char *)calloc( rawbit_size, 1 );
142	if ( rawbits == NULL )
143	{ error = (int) errMemoryAllocation; goto err_jmp; }
144
145	if ( fread( (void *)rawbits, sizeof(unsigned char), rawbit_size, file )
146	!= rawbit_size )
147	{
148	error = (int) errFileRead;
149	goto err_jmp;
150	}
151
152	if ( bmih.biCompression == BI_RGB )
153	{
154	p = rawbits;
155	for ( q = img->bits; q < img->bits + bit_size;
156	q += img->scan_width, p += DIBScanWidth )
157	{
158	memcpy( (void )q, (void )p, img->scan_width );
159	}
160	}
161
162	/* swap rows if necessary */
163	if ( bmih.biHeight < 0 )
164	{
165	for ( i = 0; i < (int)(img->height) / 2; i++ )
166	{
167	p = img->bits + i * img->scan_width;
168	q = img->bits + ((img->height) - i - 1 ) * img->scan_width;
169	memcpy( (void )rawbits, (void )p, img->scan_width );
170	memcpy( (void )p, (void )q, img->scan_width );
171	memcpy( (void )q, (void )rawbits, img->scan_width );
172	}
173	}
174
175	fclose( file );
176	free( rawbits );
177	return BMG_OK;
178
179	/* error handler */
180	err_jmp:
181	if ( file != NULL )
182	fclose( file );
183	if ( rawbits != NULL )
184	free( rawbits );
185	FreeBMGImage( img );
186	SetLastBMGError( (BMGError)error );
187	return (BMGError)error;
188
189	}
190
191	/*
192	WriteBMP - writes the contents of an BMGImageStruct to a bmp file.
193
194	Inputs:
195	filename - the name of the file to be opened
196	img - the BMGImageStruct containing the image data
197
198	Returns:
199	BMGError - if a write error or a resource error occurred
200	BMG_OK - if the data was successfilly stored in filename
201
202	Limitations:
203	will not write BMP files using BI_RLE8, BI_RLE4, or BI_BITFIELDS
204	*/
205	BMGError WriteBMP( const char *filename,
206	struct BMGImageStruct img )
207	{
208	FILE * volatile file = NULL;
209	jmp_buf err_jmp;
210	int error;
211
212	unsigned char * volatile bits = NULL;
213	unsigned int DIBScanWidth;
214	unsigned int BitsPerPixel;
215	unsigned int bit_size; /, new_bit_size; /
216	/* unsigned int rawbit_size; */
217	unsigned char p, q, r, t;
218	/* unsigned int cnt; */
219	unsigned char * volatile pColor = NULL;
220
221	BITMAPFILEHEADER bmfh;
222	BITMAPINFOHEADER bmih;
223
224	SetLastBMGError( BMG_OK );
225
226	/* error handler */
227	error = setjmp(err_jmp);
228	if (error != 0)
229	{
230	if (file != NULL)
231	fclose(file);
232	if (bits != NULL)
233	free(bits);
234	if (pColor != NULL)
235	free(pColor);
236	SetLastBMGError((BMGError)error);
237	return (BMGError) error;
238	}
239
240	if ( img.bits == NULL )
241	longjmp( err_jmp, (int)errInvalidBMGImage );
242
243	file = fopen( filename, "wb" );
244	if ( file == NULL )
245	longjmp( err_jmp, (int)errFileOpen );
246
247	/* abort if we do not support the data */
248	if ( img.palette != NULL && img.bytes_per_palette_entry < 3 )
249	longjmp( err_jmp, (int)errInvalidBMGImage );
250
251	/* calculate dimensions */
252	BitsPerPixel = img.bits_per_pixel < 32 ? img.bits_per_pixel : 24U;
253	DIBScanWidth = ( BitsPerPixel * img.width + 7 ) / 8;
254	if ( DIBScanWidth % 4 )
255	DIBScanWidth += 4 - DIBScanWidth % 4;
256	bit_size = DIBScanWidth * img.height;
257	/* rawbit_size = BITScanWidth * img.height; */
258
259	/* allocate memory for bit array - assume that compression will
260	// actually compress the bitmap */
261	bits = (unsigned char *)calloc( bit_size, 1 );
262	if ( bits == NULL )
263	longjmp( err_jmp, (int)errMemoryAllocation );
264
265	/* some initialization */
266	memset( (void *)&bmih, 0, sizeof(BITMAPINFOHEADER) );
267	bmih.biSize = sizeof(BITMAPINFOHEADER);
268	bmih.biWidth = img.width;
269	bmih.biHeight = img.height;
270	bmih.biPlanes = 1;
271	/* 32-bit images will be stored as 24-bit images to save space. The BMP
272	format does not use the high word and I do not want to store alpha
273	components in an image format that does not recognize it */
274	bmih.biBitCount = BitsPerPixel;
275	bmih.biCompression = BI_RGB; // assumed
276	bmih.biSizeImage = bit_size; // assumed
277	bmih.biClrUsed = img.palette == NULL ? 0 : img.palette_size;
278	bmih.biClrImportant = img.palette == NULL ? 0 : img.palette_size;
279
280	/* if we are not compressed then copy the raw bits to bits */
281	if ( bmih.biCompression == BI_RGB )
282	{
283	p = img.bits;
284	/* simple memcpy's for images containing < 32-bits per pixel */
285	if ( img.bits_per_pixel < 32 )
286	{
287	for ( q = bits; q < bits + bit_size; q += DIBScanWidth,
288	p += img.scan_width )
289	{
290	memcpy( (void )q, (void )p, img.scan_width );
291	}
292	}
293	/* store 32-bit images as 24-bit images to save space. alpha terms
294	are lost */
295	else
296	{
297	DIBScanWidth = 3 * img.width;
298	if ( DIBScanWidth % 4 )
299	DIBScanWidth += 4 - DIBScanWidth % 4;
300
301	for ( q = bits; q < bits + bit_size; q += DIBScanWidth,
302	p += img.scan_width )
303	{
304	t = p;
305	for ( r = q; r < q + DIBScanWidth; r += 3, t += 4 )
306	memcpy( (void )r, (void )t, 3 );
307	}
308	}
309	}
310
311	/* create the palette if necessary */
312	if ( img.palette != NULL )
313	{
314	pColor = (unsigned char *)calloc( img.palette_size, sizeof(RGBQUAD) );
315	if ( pColor == NULL )
316	longjmp( err_jmp, (int)errMemoryAllocation );
317
318	if ( img.bytes_per_palette_entry == 3 )
319	{
320	p = img.palette;
321	for ( q = pColor + 1; q < pColor +img.palette_size*sizeof(RGBQUAD);
322	q += sizeof(RGBQUAD), p += 3 )
323	{
324	memcpy( (void )pColor, (void )p, 3 );
325	}
326	}
327	else /* img.bytes_per_palette_entry == 4 */
328	{
329	memcpy( (void )pColor, (void )img.palette,
330	img.palette_size * sizeof(RGBQUAD) );
331	}
332	}
333
334	/* now that we know how big everything is let's write the file */
335	memset( (void *)&bmfh, 0, sizeof(BITMAPFILEHEADER) );
336	bmfh.bfType = BMP_ID;
337	bmfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) +
338	img.palette_size * sizeof(RGBQUAD);
339	bmfh.bfSize = bmfh.bfOffBits + bit_size;
340
341	if ( fwrite( (void *)&bmfh, sizeof(BITMAPFILEHEADER), 1, file ) != 1 )
342	longjmp( err_jmp, (int)errFileWrite );
343
344	if ( fwrite( (void *)&bmih, sizeof(BITMAPINFOHEADER), 1, file ) != 1 )
345	longjmp( err_jmp, (int)errFileWrite );
346
347	if ( pColor != NULL )
348	{
349	if ( fwrite( (void *)pColor, sizeof(RGBQUAD), img.palette_size, file )
350	!= (unsigned int)img.palette_size )
351	{
352	longjmp( err_jmp, (int)errFileWrite );
353	}
354	}
355
356	if ( fwrite( (void *)bits, sizeof(unsigned char), bit_size, file )
357	!= bit_size )
358	{
359	longjmp( err_jmp, (int)errFileWrite );
360	}
361
362	fclose( file );
363	free( bits );
364	if ( pColor != NULL )
365	free( pColor );
366	return BMG_OK;
367	}
368
369	#ifdef _NEVER_DEFINE_THIS_DEF_
370	/* following code is not tested. I keep it here in case I ever find a BMP
371	file that is compressed and I want to test it */
372	else if ( bmih.biCompression == BI_RLE8 )
373	{
374	bmih.biCompression = BI_RGB;
375	bmih.biSizeImage = DIBScanWidth * img.height;
376	p = rawbits;
377	q = img.bits;
378	EOBMP = 1;
379	while ( q < img.bits + bit_size && p < rawbits + rawbit_size && EOBMP )
380	{
381	cnt = (unsigned int)*p;
382	p++;
383
384	/* encoded mode */
385	if ( cnt == 0 )
386	{
387	cnt = (unsigned int)*p;
388	if ( cnt < 3U )
389	{
390	p++;
391	/* EOL */
392	if ( *p == 0 )
393	p++;
394	/* end of bitmap */
395	else if ( *p == 1 )
396	EOBMP = 0;
397	/* delta */
398	else if ( *p == 2 )
399	{
400	p++;
401	q += p; / columns */
402	p++;
403	q += (p)BITScanWidth; /* rows */
404	p++;
405	}
406	}
407	/* copy p duplicates of (p++) into the bit array */
408	else
409	{
410	cnt = (unsigned int)*p;
411	p++;
412	q_end = q + cnt;
413	while ( q < q_end )
414	q++ = p;
415	p++;
416	}
417	}
418	/* absolute mode */
419	else
420	{
421	q_end = q + cnt;
422	while ( q < q_end )
423	q++ = p++;
424	}
425	}
426	}
427
428	/* if compression is desired && possible then attempt compression. The
429	// following logic will try to compress the data. If the compressed data
430	// requires more space than the uncompressed data then the bits will be
431	// stored in an uncompressed format */
432	if ( try_compression != 0 && img.bits_per_pixel == 8 )
433	{
434	p = rawbits;
435	r = bits;
436	new_bit_size = 0;
437	cnt = 0;
438	while ( p < rawbits + rawbit_size && new_bit_size < bit_size )
439	{
440	q = p;
441	while ( q < p + BITScanWidth )
442	{
443	t = q;
444	while ( t < q + 255 && t < p + BITScanWidth )
445	{
446	/* look for non-repeats - absolute mode */
447	if ( t != (t+1) )
448	{
449	while ( t != (t+1) &&
450	cnt < 255 &&
451	t < p + BITScanWidth )
452	{
453	t++;
454	cnt++;
455	}
456	cnt++;
457	*r++ = (unsigned char)cnt;
458	memcpy( (void )r, (void )q, cnt );
459	r += cnt;
460	q += cnt;
461	new_bit_size += 1 + cnt;
462	cnt = 0;
463	}
464	/* else look for repeats */
465	else
466	{
467	while ( t == (t+1) &&
468	cnt < 255 &&
469	t < p + BITScanWidth )
470	{
471	t++;
472	cnt++;
473	}
474	cnt++;
475	if ( cnt > 2 )
476	{
477	*r++ = 0;
478	*r++ = (unsigned char)cnt;
479	r++ = (t-1);
480	new_bit_size += 3;
481	q = t;
482	cnt = 0;
483	}
484	/* use absolute mode if we have reached the EOL &&
485	// cnt <= 2 */
486	else if ( t >= p + BITScanWidth )
487	{
488	*r++ = (unsigned char)cnt;
489	memcpy( (void )r, (void )q, cnt );
490	r += cnt;
491	q += cnt;
492	new_bit_size += 1 + cnt;
493	cnt = 0;
494	}
495	}
496	}
497
498	/* put an EOL marker here */
499	*r++ = 0;
500	*r++ = 0;
501	new_bit_size += 2;
502	cnt = 0;
503	}
504
505	p += BITScanWidth;
506	}
507
508	/* put the EOB marker here */
509	if ( new_bit_size < bit_size - 2 )
510	{
511	*r++ = 0;
512	*r = 1;
513	new_bit_size += 2;
514	}
515	else
516	new_bit_size = bit_size + 1;
517
518	/* if the compressed image will take less space then use it */
519	if ( new_bit_size < bit_size )
520	{
521	bmih.biCompression = BI_RLE8;
522	bmih.biSizeImage = bit_size = new_bit_size;
523	}
524	}
525
526	#endif
527