X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/e65ed37acbf64415b66ce91ddae2ad23e93aab78..594f0f5bf1355fb8d58f403d3ebacc1c1767c429:/src/common/imagbmp.cpp diff --git a/src/common/imagbmp.cpp b/src/common/imagbmp.cpp index 05796710b4..6a09a824fa 100644 --- a/src/common/imagbmp.cpp +++ b/src/common/imagbmp.cpp @@ -7,10 +7,9 @@ // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -/* - We don't put pragma implement in this file because it is already present in - src/common/image.cpp -*/ +#ifdef __GNUG__ +#pragma implementation "imagbmp.h" +#endif // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -19,7 +18,11 @@ #pragma hdrstop #endif -#include "wx/image.h" +#include "wx/defs.h" + +#if wxUSE_IMAGE + +#include "wx/imagbmp.h" #include "wx/bitmap.h" #include "wx/debug.h" #include "wx/log.h" @@ -28,6 +31,7 @@ #include "wx/wfstream.h" #include "wx/intl.h" #include "wx/module.h" +#include "wx/quantize.h" // For memcpy #include @@ -46,12 +50,353 @@ // wxBMPHandler //----------------------------------------------------------------------------- -#if !USE_SHARED_LIBRARIES IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler,wxImageHandler) -#endif + #if wxUSE_STREAMS + +bool wxBMPHandler::SaveFile(wxImage *image, + wxOutputStream& stream, + bool verbose) +{ + wxCHECK_MSG( image, FALSE, _T("invalid pointer in wxBMPHandler::SaveFile") ); + + if (!image->Ok()) + { + if (verbose) wxLogError(_("BMP: Couldn't save invalid image.")); + return FALSE; + } + + // get the format of the BMP file to save, else use 24bpp + unsigned format = wxBMP_24BPP; + if (image->HasOption(wxBMP_FORMAT)) + format = image->GetOptionInt(wxBMP_FORMAT); + + unsigned bpp; // # of bits per pixel + int palette_size; // # of color map entries, ie. 2^bpp colors + + // set the bpp and appropriate palette_size, and do additional checks + if ((format == wxBMP_1BPP) || (format == wxBMP_1BPP_BW)) + { + bpp = 1; + palette_size = 2; + } + else if (format == wxBMP_4BPP) + { + bpp = 4; + palette_size = 16; + } + else if ((format == wxBMP_8BPP) || (format == wxBMP_8BPP_GREY) || + (format == wxBMP_8BPP_RED) || (format == wxBMP_8BPP_PALETTE)) + { + // need to set a wxPalette to use this, HOW TO CHECK IF VALID, SIZE? + if ((format == wxBMP_8BPP_PALETTE) +#if wxUSE_PALETTE + && !image->HasPalette() +#endif // wxUSE_PALETTE + ) + { + if (verbose) + wxLogError(_("BMP: wImage doesn't have own wxPalette.")); + return FALSE; + } + bpp = 8; + palette_size = 256; + } + else // you get 24bpp + { + format = wxBMP_24BPP; + bpp = 24; + palette_size = 0; + } + + unsigned width = image->GetWidth(); + unsigned row_padding = (4 - int(width*bpp/8.0) % 4) % 4; // # bytes to pad to dword + unsigned row_width = int(width * bpp/8.0) + row_padding; // # of bytes per row + + struct + { + // BitmapHeader: + wxUint16 magic; // format magic, always 'BM' + wxUint32 filesize; // total file size, inc. headers + wxUint32 reserved; // for future use + wxUint32 data_offset; // image data offset in the file + + // BitmapInfoHeader: + wxUint32 bih_size; // 2nd part's size + wxUint32 width, height; // bitmap's dimensions + wxUint16 planes; // num of planes + wxUint16 bpp; // bits per pixel + wxUint32 compression; // compression method + wxUint32 size_of_bmp; // size of the bitmap + wxUint32 h_res, v_res; // image resolution in dpi + wxUint32 num_clrs; // number of colors used + wxUint32 num_signif_clrs;// number of significant colors + } hdr; + + wxUint32 hdr_size = 14/*BitmapHeader*/ + 40/*BitmapInfoHeader*/; + + hdr.magic = wxUINT16_SWAP_ON_BE(0x4D42/*'BM'*/); + hdr.filesize = wxUINT32_SWAP_ON_BE( hdr_size + palette_size*4 + + row_width * image->GetHeight() ); + hdr.reserved = 0; + hdr.data_offset = wxUINT32_SWAP_ON_BE(hdr_size + palette_size*4); + + hdr.bih_size = wxUINT32_SWAP_ON_BE(hdr_size - 14); + hdr.width = wxUINT32_SWAP_ON_BE(image->GetWidth()); + hdr.height = wxUINT32_SWAP_ON_BE(image->GetHeight()); + hdr.planes = wxUINT16_SWAP_ON_BE(1); // always 1 plane + hdr.bpp = wxUINT16_SWAP_ON_BE(bpp); + hdr.compression = 0; // RGB uncompressed + hdr.size_of_bmp = wxUINT32_SWAP_ON_BE(row_width * image->GetHeight()); + hdr.h_res = hdr.v_res = wxUINT32_SWAP_ON_BE(72); // 72dpi is standard + hdr.num_clrs = wxUINT32_SWAP_ON_BE(palette_size); // # colors in colormap + hdr.num_signif_clrs = 0; // all colors are significant + + if (// VS: looks ugly but compilers tend to do ugly things with structs, + // like aligning hdr.filesize's ofset to dword :( + // VZ: we should add padding then... + !stream.Write(&hdr.magic, 2) || + !stream.Write(&hdr.filesize, 4) || + !stream.Write(&hdr.reserved, 4) || + !stream.Write(&hdr.data_offset, 4) || + !stream.Write(&hdr.bih_size, 4) || + !stream.Write(&hdr.width, 4) || + !stream.Write(&hdr.height, 4) || + !stream.Write(&hdr.planes, 2) || + !stream.Write(&hdr.bpp, 2) || + !stream.Write(&hdr.compression, 4) || + !stream.Write(&hdr.size_of_bmp, 4) || + !stream.Write(&hdr.h_res, 4) || + !stream.Write(&hdr.v_res, 4) || + !stream.Write(&hdr.num_clrs, 4) || + !stream.Write(&hdr.num_signif_clrs, 4) + ) + { + if (verbose) + wxLogError(_("BMP: Couldn't write the file header.")); + return FALSE; + } + + wxPalette *palette = NULL; // entries for quantized images + wxUint8 *rgbquad = NULL; // for the RGBQUAD bytes for the colormap + wxImage *q_image = NULL; // destination for quantized image + + // if <24bpp use quantization to reduce colors for *some* of the formats + if ( (format == wxBMP_1BPP) || (format == wxBMP_4BPP) || + (format == wxBMP_8BPP) || (format == wxBMP_8BPP_PALETTE)) + { + // make a new palette and quantize the image + if (format != wxBMP_8BPP_PALETTE) + { + q_image = new wxImage(); + + // I get a delete error using Quantize when desired colors > 236 + int quantize = ((palette_size > 236) ? 236 : palette_size); + // fill the destination too, it gives much nicer 4bpp images + wxQuantize::Quantize( *image, *q_image, &palette, quantize, 0, + wxQUANTIZE_FILL_DESTINATION_IMAGE ); + } + else + { +#if wxUSE_PALETTE + palette = new wxPalette(image->GetPalette()); +#endif // wxUSE_PALETTE + } + + int i; + unsigned char r, g, b; + rgbquad = new wxUint8 [palette_size*4]; + + for (i=0; iGetRGB( i, &r, &g, &b )) +#endif // wxUSE_PALETTE + r = g = b = 0; + + rgbquad[i*4] = b; + rgbquad[i*4+1] = g; + rgbquad[i*4+2] = r; + rgbquad[i*4+3] = 0; + } + } + // make a 256 entry greyscale colormap or 2 entry black & white + else if ((format == wxBMP_8BPP_GREY) || (format == wxBMP_8BPP_RED) || + (format == wxBMP_1BPP_BW)) + { + int i; + rgbquad = new wxUint8 [palette_size*4]; + + for (i=0; i 0) && (format == wxBMP_1BPP_BW)) i = 255; + rgbquad[i*4] = i; + rgbquad[i*4+1] = i; + rgbquad[i*4+2] = i; + rgbquad[i*4+3] = 0; + } + } + + // if the colormap was made, then it needs to be written + if (rgbquad) + { + if (!stream.Write(rgbquad, palette_size*4)) + { + if (verbose) + wxLogError(_("BMP: Couldn't write RGB color map.")); + delete [] rgbquad; +#if wxUSE_PALETTE + delete palette; +#endif // wxUSE_PALETTE + delete q_image; + return FALSE; + } + delete []rgbquad; + } + + // pointer to the image data, use quantized if available + wxUint8 *data = (wxUint8*) image->GetData(); + if (q_image) if (q_image->Ok()) data = (wxUint8*) q_image->GetData(); + + wxUint8 *buffer = new wxUint8[row_width]; + memset(buffer, 0, row_width); + int y; unsigned x; + long int pixel; + + for (y = image->GetHeight() -1 ; y >= 0; y--) + { + if (format == wxBMP_24BPP) // 3 bytes per pixel red,green,blue + { + for (x = 0; x < width; x++) + { + pixel = 3*(y*width + x); + + buffer[3*x ] = data[pixel+2]; + buffer[3*x + 1] = data[pixel+1]; + buffer[3*x + 2] = data[pixel]; + } + } + else if ((format == wxBMP_8BPP) || // 1 byte per pixel in color + (format == wxBMP_8BPP_PALETTE)) + { + for (x = 0; x < width; x++) + { + pixel = 3*(y*width + x); +#if wxUSE_PALETTE + buffer[x] = palette->GetPixel( data[pixel], + data[pixel+1], + data[pixel+2] ); +#else + // FIXME: what should this be? use some std palette maybe? + buffer[x] = 0; +#endif // wxUSE_PALETTE + } + } + else if (format == wxBMP_8BPP_GREY) // 1 byte per pix, rgb ave to grey + { + for (x = 0; x < width; x++) + { + pixel = 3*(y*width + x); + buffer[x] = (wxUint8)(.299*data[pixel] + + .587*data[pixel+1] + + .114*data[pixel+2]); + } + } + else if (format == wxBMP_8BPP_RED) // 1 byte per pixel, red as greys + { + for (x = 0; x < width; x++) + { + buffer[x] = (wxUint8)data[3*(y*width + x)]; + } + } + else if (format == wxBMP_4BPP) // 4 bpp in color + { + for (x = 0; x < width; x+=2) + { + pixel = 3*(y*width + x); + + // fill buffer, ignore if > width +#if wxUSE_PALETTE + buffer[x/2] = + ((wxUint8)palette->GetPixel(data[pixel], + data[pixel+1], + data[pixel+2]) << 4) | + (((x+1) > width) + ? 0 + : ((wxUint8)palette->GetPixel(data[pixel+3], + data[pixel+4], + data[pixel+5]) )); +#else + // FIXME: what should this be? use some std palette maybe? + buffer[x/2] = 0; +#endif // wxUSE_PALETTE + } + } + else if (format == wxBMP_1BPP) // 1 bpp in "color" + { + for (x = 0; x < width; x+=8) + { + pixel = 3*(y*width + x); + +#if wxUSE_PALETTE + buffer[x/8] = ((wxUint8)palette->GetPixel(data[pixel], data[pixel+1], data[pixel+2]) << 7) | + (((x+1) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+3], data[pixel+4], data[pixel+5]) << 6)) | + (((x+2) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+6], data[pixel+7], data[pixel+8]) << 5)) | + (((x+3) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+9], data[pixel+10], data[pixel+11]) << 4)) | + (((x+4) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+12], data[pixel+13], data[pixel+14]) << 3)) | + (((x+5) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+15], data[pixel+16], data[pixel+17]) << 2)) | + (((x+6) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+18], data[pixel+19], data[pixel+20]) << 1)) | + (((x+7) > width) ? 0 : ((wxUint8)palette->GetPixel(data[pixel+21], data[pixel+22], data[pixel+23]) )); +#else + // FIXME: what should this be? use some std palette maybe? + buffer[x/8] = 0; +#endif // wxUSE_PALETTE + } + } + else if (format == wxBMP_1BPP_BW) // 1 bpp B&W colormap from red color ONLY + { + for (x = 0; x < width; x+=8) + { + pixel = 3*(y*width + x); + + buffer[x/8] = + (((wxUint8)(data[pixel] /128.)) << 7) | + ( ((x+1) > width) ? 0 : (((wxUint8)(data[pixel+3] /128.)) << 6)) | + ( ((x+2) > width) ? 0 : (((wxUint8)(data[pixel+6] /128.)) << 5)) | + ( ((x+3) > width) ? 0 : (((wxUint8)(data[pixel+9] /128.)) << 4)) | + ( ((x+4) > width) ? 0 : (((wxUint8)(data[pixel+12]/128.)) << 3)) | + ( ((x+5) > width) ? 0 : (((wxUint8)(data[pixel+15]/128.)) << 2)) | + ( ((x+6) > width) ? 0 : (((wxUint8)(data[pixel+18]/128.)) << 1)) | + ( ((x+7) > width) ? 0 : (((wxUint8)(data[pixel+21]/128.)) )); + } + } + + if (!stream.Write(buffer, row_width)) + { + if (verbose) + wxLogError(_("BMP: Couldn't write data.")); + delete[] buffer; +#if wxUSE_PALETTE + delete palette; +#endif // wxUSE_PALETTE + delete q_image; + return FALSE; + } + } + delete[] buffer; +#if wxUSE_PALETTE + delete palette; +#endif // wxUSE_PALETTE + delete q_image; + + return TRUE; +} + + + #ifndef BI_RGB #define BI_RGB 0 #define BI_RLE8 1 @@ -64,19 +409,20 @@ IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler,wxImageHandler) #define poffset (line * width * 3 + column * 3) -bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream ) +bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose, int WXUNUSED(index) ) { int rshift = 0, gshift = 0, bshift = 0; wxUint8 aByte; wxUint16 aWord; - wxInt32 dbuf[4], aDword, - rmask = 0, gmask = 0, bmask = 0; + wxInt32 dbuf[4]; + wxInt32 aDword, rmask = 0, gmask = 0, bmask = 0; wxInt8 bbuf[4]; struct _cmap { unsigned char r, g, b; } *cmap = NULL; - + off_t start_offset = stream.TellI(); + if (start_offset == wxInvalidOffset) start_offset = 0; image->Destroy(); @@ -84,10 +430,12 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream ) * Read the BMP header */ - stream.Read( &bbuf, 2 ); + stream.Read( bbuf, 2 ); stream.Read( dbuf, 4 * 4 ); +#if 0 // unused wxInt32 size = wxINT32_SWAP_ON_BE( dbuf[0] ); +#endif wxInt32 offset = wxINT32_SWAP_ON_BE( dbuf[2] ); stream.Read(dbuf, 4 * 2); @@ -95,15 +443,17 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream ) int height = (int)wxINT32_SWAP_ON_BE( dbuf[1] ); if (width > 32767) { - wxLogError( _T("Image width > 32767 pixels for file.") ); + if (verbose) + wxLogError( _("BMP: Image width > 32767 pixels for file.") ); return FALSE; } if (height > 32767) { - wxLogError( _T("Image height > 32767 pixels for file.") ); + if (verbose) + wxLogError( _("BMP: Image height > 32767 pixels for file.") ); return FALSE; } - + stream.Read( &aWord, 2 ); /* TODO @@ -113,28 +463,31 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream ) int bpp = (int)wxUINT16_SWAP_ON_BE( aWord ); if (bpp != 1 && bpp != 4 && bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32) { - wxLogError( _T("unknown bitdepth in file.") ); + if (verbose) + wxLogError( _("BMP: Unknown bitdepth in file.") ); return FALSE; } - + stream.Read( dbuf, 4 * 4 ); int comp = (int)wxINT32_SWAP_ON_BE( dbuf[0] ); if (comp != BI_RGB && comp != BI_RLE4 && comp != BI_RLE8 && comp != BI_BITFIELDS) { - wxLogError( _T("unknown encoding in Windows BMP file.") ); + if (verbose) + wxLogError( _("BMP: Unknown encoding in file.") ); return FALSE; } - + stream.Read( dbuf, 4 * 2 ); int ncolors = (int)wxINT32_SWAP_ON_BE( dbuf[0] ); if (ncolors == 0) ncolors = 1 << bpp; /* some more sanity checks */ - if (((comp == BI_RLE4) && (bpp != 4)) || - ((comp == BI_RLE8) && (bpp != 8)) || - ((comp == BI_BITFIELDS) && (bpp != 16 && bpp != 32))) + if (((comp == BI_RLE4) && (bpp != 4)) || + ((comp == BI_RLE8) && (bpp != 8)) || + ((comp == BI_BITFIELDS) && (bpp != 16 && bpp != 32))) { - wxLogError( _T("encoding of BMP doesn't match bitdepth.") ); + if (verbose) + wxLogError( _("BMP: Encoding doesn't match bitdepth.") ); return FALSE; } if (bpp < 16) @@ -142,7 +495,8 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream ) cmap = (struct _cmap *)malloc(sizeof(struct _cmap) * ncolors); if (!cmap) { - wxLogError( _T("Cannot allocate RAM for color map in BMP file.") ); + if (verbose) + wxLogError( _("BMP: Couldn't allocate memory.") ); return FALSE; } } @@ -153,7 +507,8 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream ) unsigned char *ptr = image->GetData(); if (!ptr) { - wxLogError( _T("Cannot allocate RAM for RGB data in file.") ); + if (verbose) + wxLogError( _("BMP: Couldn't allocate memory.") ); if (cmap) free(cmap); return FALSE; @@ -164,13 +519,29 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream ) */ if (bpp < 16 && ncolors != 0) { + unsigned char* r = new unsigned char[ncolors]; + unsigned char* g = new unsigned char[ncolors]; + unsigned char* b = new unsigned char[ncolors]; for (int j = 0; j < ncolors; j++) { stream.Read( bbuf, 4 ); cmap[j].b = bbuf[0]; cmap[j].g = bbuf[1]; cmap[j].r = bbuf[2]; + + r[j] = cmap[j].r; + g[j] = cmap[j].g; + b[j] = cmap[j].b; } + +#if wxUSE_PALETTE + // Set the palette for the wxImage + image->SetPalette(wxPalette(ncolors, r, g, b)); +#endif // wxUSE_PALETTE + + delete[] r; + delete[] g; + delete[] b; } else if (bpp == 16 || bpp == 32) { @@ -229,13 +600,13 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream ) } ptr = data; } - + int line = 0; int column = 0; int linesize = ((width * bpp + 31) / 32) * 4; /* BMPs are stored upside down */ - for (line = (height - 1); line >= 0; line--) + for (line = (height - 1); line >= 0; line--) { int linepos = 0; for (column = 0; column < width;) @@ -248,7 +619,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream ) if (bpp == 1) { int bit = 0; - for (bit = 0; bit < 8; bit++) + for (bit = 0; bit < 8 && column < width; bit++) { index = ((aByte & (0x80 >> bit)) ? 1 : 0); ptr[poffset] = cmap[index].r; @@ -261,7 +632,8 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream ) { if (comp == BI_RLE4) { - wxLogError( _T("Can't deal with 4bit encoded yet.") ); + if (verbose) + wxLogError( _("BMP: Cannot deal with 4bit encoded yet.") ); image->Destroy(); free(cmap); return FALSE; @@ -269,7 +641,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream ) else { int nibble = 0; - for (nibble = 0; nibble < 2; nibble++) + for (nibble = 0; nibble < 2 && column < width; nibble++) { index = ((aByte & (0xF0 >> nibble * 4)) >> (!nibble * 4)); if (index >= 16) @@ -325,7 +697,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream ) } else { - for (int l = 0; l < first; l++) + for (int l = 0; l < first && column < width; l++) { ptr[poffset ] = cmap[aByte].r; ptr[poffset + 1] = cmap[aByte].g; @@ -341,13 +713,13 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream ) ptr[poffset + 1] = cmap[aByte].g; ptr[poffset + 2] = cmap[aByte].b; column++; - linepos += size; + // linepos += size; seems to be wrong, RR } } } else if (bpp == 24) { - stream.Read( &bbuf, 3 ); + stream.Read( bbuf, 3 ); linepos += 3; ptr[poffset ] = (unsigned char)bbuf[2]; ptr[poffset + 1] = (unsigned char)bbuf[1]; @@ -358,13 +730,13 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream ) { unsigned char temp; stream.Read( &aWord, 2 ); - aWord = wxUINT16_SWAP_ON_BE( aWord ); + aWord = wxUINT16_SWAP_ON_BE( aWord ); linepos += 2; temp = (aWord & rmask) >> rshift; ptr[poffset] = temp; temp = (aWord & gmask) >> gshift; ptr[poffset + 1] = temp; - temp = (aWord & bmask) >> gshift; + temp = (aWord & bmask) >> bshift; ptr[poffset + 2] = temp; column++; } @@ -372,7 +744,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream ) { unsigned char temp; stream.Read( &aDword, 4 ); - aDword = wxINT32_SWAP_ON_BE( aDword ); + aDword = wxINT32_SWAP_ON_BE( aDword ); linepos += 4; temp = (aDword & rmask) >> rshift; ptr[poffset] = temp; @@ -391,7 +763,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream ) break; } } - if (cmap) + if (cmap) free(cmap); image->SetMask( FALSE ); @@ -399,6 +771,15 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream ) return TRUE; } -#endif // wxUSE_STREAMS +bool wxBMPHandler::DoCanRead( wxInputStream& stream ) +{ + unsigned char hdr[2]; + stream.Read(hdr, 2); + stream.SeekI(-2, wxFromCurrent); + return (hdr[0] == 'B' && hdr[1] == 'M'); +} + +#endif // wxUSE_STREAMS +#endif // wxUSE_IMAGE