Attachment #222921 for bug #308753




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 )




    gray scale images with alpha components are converted to 32-bit images
*/
BMGError ReadPNG( const char *filename,
        struct BMGImageStruct * volatile img )
{
    jmp_buf             err_jmp;
    int                 error;

    FILE * volatile     file = NULL;
    int                 BitDepth;
    int                 BitsPerPixel;
    int                 FixedBitDepth;

    int                 ImageChannels;
    int                 InterlaceType;
    unsigned char       signature[8];
    png_structp volatile png_ptr = NULL;
    png_infop   volatile info_ptr = NULL;
    png_infop   volatile end_info = NULL;
    png_colorp          PNGPalette = NULL;
    png_color_16       *ImageBackground = NULL;
    png_bytep           trns = NULL;
    int                 NumTrans = 0;
    int                 i, j, k;
    png_color_16p       TransColors = NULL;
    png_uint_32         Width, Height;

    unsigned char      *bits, *p, *q;
    unsigned char** volatile rows = NULL;
    int                 NumColors = 0;
    unsigned char       BgdRed = 0;
    unsigned char       BgdGreen = 0;


    /* error handler */
    error = setjmp( err_jmp );
    if (error != 0)
    {
        if (end_info != NULL)
            png_destroy_read_struct((png_structp *) &png_ptr, (png_infop *) &info_ptr, (png_infop *) &end_info);
        else if (info_ptr != NULL)
            png_destroy_read_struct((png_structp *) &png_ptr, (png_infop *) &info_ptr, NULL);
        else if (png_ptr != NULL)
            png_destroy_read_struct((png_structp *) &png_ptr, NULL, NULL);
        if (rows)
        {
            if (rows[0])
                free(rows[0]);
            free(rows);
        }
        if (img)
            FreeBMGImage(img);
        if (file)
            fclose(file);
        SetLastBMGError((BMGError) error);
        return (BMGError) error;
    }

    if ( img == NULL )

    if ( !png_ptr )
        longjmp( err_jmp, (int)errMemoryAllocation );

    /* create a pointer to the png info structure */
    info_ptr = png_create_info_struct( png_ptr );
    if ( !info_ptr )
        longjmp( err_jmp, (int)errMemoryAllocation );

    /* create a pointer to the png end-info structure */
    end_info = png_create_info_struct(png_ptr);
    if (!end_info)
        longjmp( err_jmp, (int)errMemoryAllocation );

    /* bamboozle the PNG longjmp buffer */
    /*generic PNG error handler*/
    /* error will always == 1 which == errLib */

    if ( error > 0 )
        longjmp( err_jmp, error );

    /* create a pointer to the png info structure */
    info_ptr = png_create_info_struct( png_ptr );
    if ( !info_ptr )
        longjmp( err_jmp, (int)errMemoryAllocation );

    /* attach file buffer to the png read pointer */
    png_init_io( png_ptr, file );



    /* extract the data we need to form the HBITMAP from the PNG header */
    png_get_IHDR( png_ptr, info_ptr, &Width, &Height, &BitDepth, &ColorType,
        &InterlaceType, NULL, NULL);

    img->width = Width;
    img->height = Height;

    free( rows[0] );
    free( rows );
    png_read_end( png_ptr, info_ptr );
    png_destroy_read_struct((png_structp *) &png_ptr, (png_infop *) &info_ptr, (png_infop *) &end_info);
    fclose( file );

    return BMG_OK;

Return to bug 308753

Lines 205-222 err_jmp: Link Here

(-)a/rice_video/liblinux/bmp.c (-13 / +13 lines)
205	BMGError WriteBMP( const char *filename,	205	BMGError WriteBMP( const char *filename,
206	struct BMGImageStruct img )	206	struct BMGImageStruct img )
207	{	207	{
208	FILE *file = NULL;	208	FILE * volatile file = NULL;
209	jmp_buf err_jmp;	209	jmp_buf err_jmp;
210	int error;	210	int error;
211		211
212	unsigned char *bits = NULL;	212	unsigned char * volatile bits = NULL;
213	unsigned int DIBScanWidth;	213	unsigned int DIBScanWidth;
214	unsigned int BitsPerPixel;	214	unsigned int BitsPerPixel;
215	unsigned int bit_size; /, new_bit_size; /	215	unsigned int bit_size; /, new_bit_size; /
216	/* unsigned int rawbit_size; */	216	/* unsigned int rawbit_size; */
217	unsigned char p, q, r, t;	217	unsigned char p, q, r, t;
218	/* unsigned int cnt; */	218	/* unsigned int cnt; */
219	unsigned char *pColor = NULL;	219	unsigned char * volatile pColor = NULL;
220		220
221	BITMAPFILEHEADER bmfh;	221	BITMAPFILEHEADER bmfh;
222	BITMAPINFOHEADER bmih;	222	BITMAPINFOHEADER bmih;
Lines 224-240 BMGError WriteBMP( const char *filename, Link Here
224	SetLastBMGError( BMG_OK );	224	SetLastBMGError( BMG_OK );
225		225
226	/* error handler */	226	/* error handler */
227	error = setjmp( err_jmp );	227	error = setjmp(err_jmp);
228	if ( error != 0 )	228	if (error != 0)
229	{	229	{
230	if ( file != NULL )	230	if (file != NULL)
231	fclose( file );	231	fclose(file);
232	if ( bits != NULL )	232	if (bits != NULL)
233	free( bits );	233	free(bits);
234	if ( pColor != NULL )	234	if (pColor != NULL)
235	free( pColor );	235	free(pColor);
236	SetLastBMGError( (BMGError)error );	236	SetLastBMGError((BMGError)error);
237	return (BMGError)error;	237	return (BMGError) error;
238	}	238	}
239		239
240	if ( img.bits == NULL )	240	if ( img.bits == NULL )

Lines 94-105 Comments: Link Here

(-)a/rice_video/liblinux/pngrw.c (-24 / +36 lines)
94	gray scale images with alpha components are converted to 32-bit images	94	gray scale images with alpha components are converted to 32-bit images
95	*/	95	*/
96	BMGError ReadPNG( const char *filename,	96	BMGError ReadPNG( const char *filename,
97	struct BMGImageStruct *img )	97	struct BMGImageStruct * volatile img )
98	{	98	{
99	jmp_buf err_jmp;	99	jmp_buf err_jmp;
100	int error;	100	int error;
101		101
102	FILE *file = NULL;	102	FILE * volatile file = NULL;
103	int BitDepth;	103	int BitDepth;
104	int BitsPerPixel;	104	int BitsPerPixel;
105	int FixedBitDepth;	105	int FixedBitDepth;
Lines 107-124 BMGError ReadPNG( const char *filename, Link Here
107	int ImageChannels;	107	int ImageChannels;
108	int InterlaceType;	108	int InterlaceType;
109	unsigned char signature[8];	109	unsigned char signature[8];
110	png_structp png_ptr = NULL;	110	png_structp volatile png_ptr = NULL;
111	png_infop info_ptr = NULL;	111	png_infop volatile info_ptr = NULL;
		112	png_infop volatile end_info = NULL;
112	png_colorp PNGPalette = NULL;	113	png_colorp PNGPalette = NULL;
113	png_color_16 *ImageBackground = NULL;	114	png_color_16 *ImageBackground = NULL;
114	png_bytep trns = NULL;	115	png_bytep trns = NULL;
115	int NumTrans = 0;	116	int NumTrans = 0;
116	int i, j, k;	117	int i, j, k;
117	png_color_16p TransColors = NULL;	118	png_color_16p TransColors = NULL;
118	unsigned int Width, Height;	119	png_uint_32 Width, Height;
119		120
120	unsigned char bits, p, *q;	121	unsigned char bits, p, *q;
121	unsigned char** rows = NULL;	122	unsigned char** volatile rows = NULL;
122	int NumColors = 0;	123	int NumColors = 0;
123	unsigned char BgdRed = 0;	124	unsigned char BgdRed = 0;
124	unsigned char BgdGreen = 0;	125	unsigned char BgdGreen = 0;
Lines 130-149 BMGError ReadPNG( const char *filename, Link Here
130		131
131	/* error handler */	132	/* error handler */
132	error = setjmp( err_jmp );	133	error = setjmp( err_jmp );
133	if ( error != 0 )	134	if (error != 0)
134	{	135	{
135	if ( png_ptr != NULL )	136	if (end_info != NULL)
136	png_destroy_read_struct( &png_ptr, NULL, NULL );	137	png_destroy_read_struct((png_structp ) &png_ptr, (png_infop ) &info_ptr, (png_infop *) &end_info);
137	if ( rows )	138	else if (info_ptr != NULL)
		139	png_destroy_read_struct((png_structp ) &png_ptr, (png_infop ) &info_ptr, NULL);
		140	else if (png_ptr != NULL)
		141	png_destroy_read_struct((png_structp *) &png_ptr, NULL, NULL);
		142	if (rows)
138	{	143	{
139	if ( rows[0] )	144	if (rows[0])
140	free( rows[0] );	145	free(rows[0]);
141	free( rows );	146	free(rows);
142	}	147	}
143	FreeBMGImage( img );	148	if (img)
144	fclose( file );	149	FreeBMGImage(img);
145	SetLastBMGError( (BMGError)error );	150	if (file)
146	return (BMGError)error;	151	fclose(file);
		152	SetLastBMGError((BMGError) error);
		153	return (BMGError) error;
147	}	154	}
148		155
149	if ( img == NULL )	156	if ( img == NULL )
Lines 163-168 BMGError ReadPNG( const char *filename, Link Here
163	if ( !png_ptr )	170	if ( !png_ptr )
164	longjmp( err_jmp, (int)errMemoryAllocation );	171	longjmp( err_jmp, (int)errMemoryAllocation );
165		172
		173	/* create a pointer to the png info structure */
		174	info_ptr = png_create_info_struct( png_ptr );
		175	if ( !info_ptr )
		176	longjmp( err_jmp, (int)errMemoryAllocation );
		177
		178	/* create a pointer to the png end-info structure */
		179	end_info = png_create_info_struct(png_ptr);
		180	if (!end_info)
		181	longjmp( err_jmp, (int)errMemoryAllocation );
		182
166	/* bamboozle the PNG longjmp buffer */	183	/* bamboozle the PNG longjmp buffer */
167	/generic PNG error handler/	184	/generic PNG error handler/
168	/* error will always == 1 which == errLib */	185	/* error will always == 1 which == errLib */
Lines 171-181 BMGError ReadPNG( const char *filename, Link Here
171	if ( error > 0 )	188	if ( error > 0 )
172	longjmp( err_jmp, error );	189	longjmp( err_jmp, error );
173		190
174	/* create a pointer to the png info structure */
175	info_ptr = png_create_info_struct( png_ptr );
176	if ( !info_ptr )
177	longjmp( err_jmp, (int)errMemoryAllocation );
178
179	/* attach file buffer to the png read pointer */	191	/* attach file buffer to the png read pointer */
180	png_init_io( png_ptr, file );	192	png_init_io( png_ptr, file );
181		193
Lines 187-193 BMGError ReadPNG( const char *filename, Link Here
187		199
188	/* extract the data we need to form the HBITMAP from the PNG header */	200	/* extract the data we need to form the HBITMAP from the PNG header */
189	png_get_IHDR( png_ptr, info_ptr, &Width, &Height, &BitDepth, &ColorType,	201	png_get_IHDR( png_ptr, info_ptr, &Width, &Height, &BitDepth, &ColorType,
190	&InterlaceType, NULL, NULL );	202	&InterlaceType, NULL, NULL);
191		203
192	img->width = Width;	204	img->width = Width;
193	img->height = Height;	205	img->height = Height;
Lines 475-481 BMGError ReadPNG( const char *filename, Link Here
475	free( rows[0] );	487	free( rows[0] );
476	free( rows );	488	free( rows );
477	png_read_end( png_ptr, info_ptr );	489	png_read_end( png_ptr, info_ptr );
478	png_destroy_read_struct( &png_ptr, &info_ptr, NULL );	490	png_destroy_read_struct((png_structp ) &png_ptr, (png_infop ) &info_ptr, (png_infop *) &end_info);
479	fclose( file );	491	fclose( file );
480		492
481	return BMG_OK;	493	return BMG_OK;