X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/c96ea65713a8dd58ae40b10718723b5c92a303e3..06acc7d9a6cf41c4f80230773cc0bdd2c95cec28:/src/common/imagbmp.cpp diff --git a/src/common/imagbmp.cpp b/src/common/imagbmp.cpp index 9f92b3c8fc..2b77f5aa93 100644 --- a/src/common/imagbmp.cpp +++ b/src/common/imagbmp.cpp @@ -31,6 +31,7 @@ #include "wx/wfstream.h" #include "wx/intl.h" #include "wx/module.h" +#include "wx/quantize.h" // For memcpy #include @@ -46,7 +47,7 @@ #endif //----------------------------------------------------------------------------- -// wxBMPHandler +// wxBMPHandler & wxICOHandler //----------------------------------------------------------------------------- IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler,wxImageHandler) @@ -55,9 +56,224 @@ IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler,wxImageHandler) #if wxUSE_STREAMS +#ifndef BI_RGB +#define BI_RGB 0 +#define BI_RLE8 1 +#define BI_RLE4 2 +#endif + +#ifndef BI_BITFIELDS +#define BI_BITFIELDS 3 +#endif + +#define poffset (line * width * 3 + column * 3) + + + +struct ICONDIRENTRY + { + wxUint8 bWidth; // Width of the image + wxUint8 bHeight; // Height of the image (times 2) + wxUint8 bColorCount; // Number of colors in image (0 if >=8bpp) + wxUint8 bReserved; // Reserved + wxUint16 wPlanes; // Color Planes + wxUint16 wBitCount; // Bits per pixel + wxUint32 dwBytesInRes; // how many bytes in this resource? + wxUint32 dwImageOffset; // where in the file is this image +} ; + + +struct ICONDIR +{ + wxUint16 idReserved; // Reserved + wxUint16 idType; // resource type (1 for icons) + wxUint16 idCount; // how many images? +} ; + +bool wxICOHandler::SaveFile(wxImage *image, + wxOutputStream& stream, + bool verbose) + +{ + bool bResult = FALSE ; + //sanity check; icon must be less than 127 pixels high and 255 wide + if (image -> GetHeight () > 127 ) + { + if (verbose) + wxLogError( _("ICO: Error Image too tall for an icon.") ); + return FALSE; + } + if (image -> GetWidth () > 255 ) + { + if (verbose) + wxLogError( _("ICO: Error Image too wide for an icon.") ); + return FALSE; + } + + // only generate one image + int m_images = 1 ; + + // write a header, (ICONDIR) + // Calculate the header size + wxUint32 m_offset = 3 * sizeof(wxUint16); + + ICONDIR m_IconDir ; + m_IconDir.idReserved = 0 ; + m_IconDir.idType = wxUINT16_SWAP_ON_BE (1); + m_IconDir.idCount = wxUINT16_SWAP_ON_BE (m_images); + stream.Write(&m_IconDir.idReserved, sizeof(m_IconDir.idReserved)); + stream.Write(&m_IconDir.idType, sizeof(m_IconDir.idType)); + stream.Write(&m_IconDir.idCount, sizeof(m_IconDir.idCount)); + if ( !stream.IsOk () ) + { + if (verbose) + wxLogError( _("ICO: Error writing ICONDIR header.") ); + return FALSE; + } + + // for each iamage write a description ICONDIRENTRY + ICONDIRENTRY m_icondirentry ; + int i ; + for ( i = 0; i < m_images; i++ ) + { + wxImage mask ; + if (image->HasMask()) + { + //make another image with black/white + mask = image -> ConvertToMono (image->GetMaskRed(), image->GetMaskGreen(), image->GetMaskBlue() ); + //now we need to change the masked regions to black + unsigned char r = image -> GetMaskRed() ; + unsigned char g = image -> GetMaskGreen() ; + unsigned char b = image -> GetMaskBlue() ; + if ((r != 0) || (g != 0) || (b != 0) ) + { + //Go round and apply black to the masked bits + int i,j; + for (i=0; i < mask.GetWidth(); i++) + for (j=0; j < mask.GetHeight(); j++) + { + if ((r == mask.GetRed(i, j)) && + (g == mask.GetGreen(i, j) ) && + (b == mask.GetBlue(i, j)) ) + image -> SetRGB ( i, j, 0, 0, 0 ); + } + + } + } + else + { + // just make a black mask all over + mask = image -> Copy (); + int i,j; + for (i=0; i < mask.GetWidth(); i++) + for (j=0; j < mask.GetHeight(); j++) + mask.SetRGB ( i, j, 0, 0, 0 ); + } + //Set the formats for image and mask + // windows never saves with more than 8 colors + image -> SetOption (wxBMP_FORMAT, wxBMP_8BPP); + // monochome bitmap + mask . SetOption (wxBMP_FORMAT, wxBMP_1BPP_BW); + bool IsBmp = FALSE ; + bool IsMask = FALSE ; + + //calculate size and offset of image and mask + wxCountingOutputStream cStream ; + bResult = SaveDib ( image, cStream, verbose, IsBmp, IsMask ) ; + if (!bResult) + { + if (verbose) + wxLogError( _("ICO: Error calculating size of XOR DIB .") ); + return FALSE; + } + IsMask = TRUE ; + bResult = SaveDib ( &mask, cStream, verbose, IsBmp, IsMask ) ; + if (!bResult) + { + if (verbose) + wxLogError( _("ICO: Error calculating size of Mask DIB .") ); + return FALSE; + } + wxUint32 m_Size = cStream.GetSize(); + + // wxCountingOutputStream::Ok() always returns TRUE for now and this + // "if" provokes VC++ warnings in optimized build +#if 0 + if (!cStream.Ok()) + { + if (verbose) + wxLogError( _("ICO: Error calculating size of DIB .") ); + return FALSE; + } +#endif // 0 + + m_offset = m_offset + sizeof(ICONDIRENTRY) ; + + m_icondirentry. bWidth = image -> GetWidth () ; + m_icondirentry. bHeight = 2 * image -> GetHeight () ; + m_icondirentry. bColorCount = 0 ; + m_icondirentry. bReserved = 0 ; + m_icondirentry. wPlanes = wxUINT16_SWAP_ON_BE(1); + m_icondirentry. wBitCount = wxUINT16_SWAP_ON_BE(wxBMP_8BPP) ; + m_icondirentry. dwBytesInRes = wxUINT32_SWAP_ON_BE(m_Size); + m_icondirentry. dwImageOffset = wxUINT32_SWAP_ON_BE(m_offset); + + //increase size to allow for the data wriitten + m_offset = m_offset + m_Size ; + + //write to stream + stream.Write(&m_icondirentry. bWidth, sizeof(m_icondirentry. bWidth) ); + stream.Write(&m_icondirentry. bHeight, sizeof(m_icondirentry. bHeight) ); + stream.Write(&m_icondirentry. bColorCount, sizeof(m_icondirentry. bColorCount) ); + stream.Write(&m_icondirentry. bReserved, sizeof(m_icondirentry. bReserved) ); + stream.Write(&m_icondirentry. wPlanes, sizeof(m_icondirentry. wPlanes) ); + stream.Write(&m_icondirentry. wBitCount, sizeof(m_icondirentry. wBitCount) ); + stream.Write(&m_icondirentry. dwBytesInRes, sizeof(m_icondirentry. dwBytesInRes) ); + stream.Write(&m_icondirentry. dwImageOffset, sizeof(m_icondirentry. dwImageOffset) ); + if ( !stream.IsOk () ) + { + if (verbose) + wxLogError( _("ICO: Error writing ICONDIRENTRY header.") ); + return FALSE; + } + //actually save it + IsMask = FALSE ; + bResult = SaveDib ( image, stream, verbose, IsBmp, IsMask ) ; + if (!bResult) + { + if (verbose) + wxLogError( _("ICO: Error writing XOR DIB .") ); + return FALSE; + } + IsMask = TRUE ; + bResult = SaveDib ( &mask, stream, verbose, IsBmp, IsMask ) ; + if (!bResult) + { + if (verbose) + wxLogError( _("ICO: Error writing Mask DIB .") ); + return FALSE; + } + + } // end of for loop + return TRUE ; +} + + bool wxBMPHandler::SaveFile(wxImage *image, wxOutputStream& stream, bool verbose) +{ + bool IsBmp = TRUE; + bool IsMask = FALSE ; + return SaveDib( image, stream, verbose, IsBmp, IsMask ) ; +} + +bool wxBMPHandler::SaveDib(wxImage *image, + wxOutputStream& stream, + bool verbose, + bool IsBmp, + bool IsMask) + { wxCHECK_MSG( image, FALSE, _T("invalid pointer in wxBMPHandler::SaveFile") ); @@ -67,10 +283,53 @@ bool wxBMPHandler::SaveFile(wxImage *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_width = width * 3 + - (((width % 4) == 0) ? 0 : (4 - (width * 3) % 4)); - // each row must be aligned to dwords + 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: @@ -78,7 +337,7 @@ bool wxBMPHandler::SaveFile(wxImage *image, 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 @@ -90,34 +349,52 @@ bool wxBMPHandler::SaveFile(wxImage *image, 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 + - row_width * image->GetHeight() - ); + 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); - + 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()); + if (IsBmp) + { hdr.height = wxUINT32_SWAP_ON_BE(image->GetHeight()); + } + else + { + hdr.height = wxUINT32_SWAP_ON_BE(2 * image->GetHeight()); + } hdr.planes = wxUINT16_SWAP_ON_BE(1); // always 1 plane - hdr.bpp = wxUINT16_SWAP_ON_BE(24); // always TrueColor + 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 = 0; // maximal possible = 2^24 - hdr.num_signif_clrs = 0; // all colors are significant + 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 (IsBmp) + { 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.data_offset, 4) + ) + { + if (verbose) + wxLogError(_("BMP: Couldn't write the file (Bitmap) header.")); + return FALSE; + } + } + if (!IsMask) + { + if ( !stream.Write(&hdr.bih_size, 4) || !stream.Write(&hdr.width, 4) || !stream.Write(&hdr.height, 4) || @@ -129,38 +406,229 @@ bool wxBMPHandler::SaveFile(wxImage *image, !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.")); + wxLogError(_("BMP: Couldn't write the file (BitmapInfo) 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 (!IsMask) + { + 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]; - wxUint8 tmpvar; memset(buffer, 0, row_width); int y; unsigned x; + long int pixel; for (y = image->GetHeight() -1 ; y >= 0; y--) { - memcpy(buffer, data + y * 3 * width, 3 * width); - for (x = 0; x < width; x++) + if (format == wxBMP_24BPP) // 3 bytes per pixel red,green,blue { - tmpvar = buffer[3 * x + 0]; - buffer[3 * x + 0] = buffer[3 * x + 2]; - buffer[3 * x + 2] = tmpvar; + 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; } @@ -168,123 +636,51 @@ bool wxBMPHandler::SaveFile(wxImage *image, -#ifndef BI_RGB -#define BI_RGB 0 -#define BI_RLE8 1 -#define BI_RLE4 2 -#endif - -#ifndef BI_BITFIELDS -#define BI_BITFIELDS 3 -#endif - -#define poffset (line * width * 3 + column * 3) +bool wxBMPHandler::DoLoadDib (wxImage * image, int width, int height, int bpp, int ncolors, int comp, + off_t bmpOffset, wxInputStream& stream, + bool verbose, bool IsBmp, bool hasPalette ) + { -bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose, int WXUNUSED(index) ) -{ + wxInt32 aDword, rmask = 0, gmask = 0, bmask = 0; int rshift = 0, gshift = 0, bshift = 0; + wxInt32 dbuf[4]; + wxInt8 bbuf[4]; wxUint8 aByte; wxUint16 aWord; - wxInt32 dbuf[4], 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(); - - /* - * Read the BMP header - */ - - 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); - int width = (int)wxINT32_SWAP_ON_BE( dbuf[0] ); - int height = (int)wxINT32_SWAP_ON_BE( dbuf[1] ); - if (width > 32767) - { - if (verbose) - wxLogError( _("BMP: Image width > 32767 pixels for file.") ); - return FALSE; - } - if (height > 32767) - { - if (verbose) - wxLogError( _("BMP: Image height > 32767 pixels for file.") ); - return FALSE; - } - stream.Read( &aWord, 2 ); -/* - TODO - int planes = (int)wxUINT16_SWAP_ON_BE( aWord ); -*/ - stream.Read( &aWord, 2 ); - int bpp = (int)wxUINT16_SWAP_ON_BE( aWord ); - if (bpp != 1 && bpp != 4 && bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32) - { - 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) + // allocate space for palette if needed + struct _cmap { - if (verbose) - wxLogError( _("BMP: Unknown encoding in file.") ); - return FALSE; + unsigned char r, g, b; } + *cmap = NULL; - 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 (verbose) - wxLogError( _("BMP: Encoding doesn't match bitdepth.") ); - return FALSE; - } if (bpp < 16) { cmap = (struct _cmap *)malloc(sizeof(struct _cmap) * ncolors); if (!cmap) { if (verbose) - wxLogError( _("BMP: Couldn't allocate memory.") ); + wxLogError( _("Loading DIB : Couldn't allocate memory.") ); return FALSE; } } else cmap = NULL; + // destroy existing here instead of + image->Destroy(); image->Create( width, height ); unsigned char *ptr = image->GetData(); if (!ptr) { if (verbose) - wxLogError( _("BMP: Couldn't allocate memory.") ); + wxLogError( _("Loading DIB : Couldn't allocate memory.") ); if (cmap) free(cmap); return FALSE; } - /* * Reading the palette, if it exists. */ @@ -295,6 +691,8 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose unsigned char* b = new unsigned char[ncolors]; for (int j = 0; j < ncolors; j++) { + if (hasPalette) + { stream.Read( bbuf, 4 ); cmap[j].b = bbuf[0]; cmap[j].g = bbuf[1]; @@ -304,8 +702,19 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose g[j] = cmap[j].g; b[j] = cmap[j].b; } + else + { + //used in reading .ico file mask + r[j] = cmap[j].r = j * 255; + g[j] = cmap[j].g = j * 255; + b[j] = cmap[j].b = j * 255; + } + } + +#if wxUSE_PALETTE // Set the palette for the wxImage image->SetPalette(wxPalette(ncolors, r, g, b)); +#endif // wxUSE_PALETTE delete[] r; delete[] g; @@ -354,7 +763,8 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose /* * Reading the image data */ - stream.SeekI( start_offset + offset ); + if ( IsBmp ) stream.SeekI( bmpOffset ); // else icon, just carry on + unsigned char *data = ptr; /* set the whole image to the background color */ @@ -401,7 +811,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose if (comp == BI_RLE4) { if (verbose) - wxLogError( _("BMP: Cannot deal with 4bit encoded yet.") ); + wxLogError( _("DIB Header: Cannot deal with 4bit encoded yet.") ); image->Destroy(); free(cmap); return FALSE; @@ -487,7 +897,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose } 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]; @@ -536,18 +946,197 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose image->SetMask( FALSE ); + return stream.IsOk(); +} + + +bool wxBMPHandler::LoadDib( wxImage *image, wxInputStream& stream, bool verbose, bool IsBmp ) +{ + wxUint16 aWord; + wxInt32 dbuf[4]; + wxInt8 bbuf[4]; + off_t offset; + + offset = 0; // keep gcc quiet + if ( IsBmp ) + { + // read the header off the .BMP format file + + offset = stream.TellI(); + if (offset == wxInvalidOffset) offset = 0; + + stream.Read( bbuf, 2 ); + + stream.Read( dbuf, 16 ); + } + else + { + stream.Read( dbuf, 4 ); + } + #if 0 // unused + wxInt32 size = wxINT32_SWAP_ON_BE( dbuf[0] ); + #endif + offset = offset + wxINT32_SWAP_ON_BE( dbuf[2] ); + + stream.Read(dbuf, 4 * 2); + int width = (int)wxINT32_SWAP_ON_BE( dbuf[0] ); + int height = (int)wxINT32_SWAP_ON_BE( dbuf[1] ); + if ( !IsBmp ) height = height / 2; // for icons divide by 2 + + if (width > 32767) + { + if (verbose) + wxLogError( _("DIB Header: Image width > 32767 pixels for file.") ); + return FALSE; + } + if (height > 32767) + { + if (verbose) + wxLogError( _("DIB Header: Image height > 32767 pixels for file.") ); + return FALSE; + } + + stream.Read( &aWord, 2 ); + /* + TODO + int planes = (int)wxUINT16_SWAP_ON_BE( aWord ); + */ + stream.Read( &aWord, 2 ); + int bpp = (int)wxUINT16_SWAP_ON_BE( aWord ); + if (bpp != 1 && bpp != 4 && bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32) + { + if (verbose) + wxLogError( _("DIB Header: 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) + { + if (verbose) + wxLogError( _("DIB Header: 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 (verbose) + wxLogError( _("DIB Header: Encoding doesn't match bitdepth.") ); + return FALSE; + } + + //read DIB; this is the BMP image or the XOR part of an icon image + if (!DoLoadDib (image, width, height, bpp, ncolors, comp, offset, stream, + verbose, IsBmp, TRUE ) ) + { + if (verbose) + wxLogError( _("Error in reading image DIB .") ); + return FALSE; + } + + if ( !IsBmp ) + { + //read Icon mask which is monochrome + //there is no palette, so we will create one + wxImage mask; + if (!DoLoadDib (&mask, width, height, 1, 2, BI_RGB, offset, stream, + verbose, IsBmp, FALSE ) ) + { + if (verbose) + wxLogError( _("ICO: Error in reading mask DIB.") ); + return FALSE; + } + image->SetMaskFromImage(mask, 255, 255, 255); + + } return TRUE; } + +bool wxBMPHandler::LoadFile ( wxImage *image, wxInputStream& stream, bool verbose, int WXUNUSED(index) ) +{ + bool IsBmp = TRUE; + //Read a single DIB fom the file + return LoadDib ( image, stream, verbose, IsBmp ) ; +} + + + +bool wxICOHandler::LoadFile ( wxImage *image, wxInputStream& stream, bool verbose, int WXUNUSED(index) ) +{ + bool bResult = FALSE ; + bool IsBmp = FALSE; + + ICONDIR m_IconDir ; + stream.Read (&m_IconDir, sizeof(m_IconDir)); + wxUint16 nIcons = wxUINT16_SWAP_ON_BE ( m_IconDir.idCount ) ; + + //loop round the icons and choose the best one + ICONDIRENTRY * pIconDirEntry = new ICONDIRENTRY [nIcons]; + ICONDIRENTRY * pCurrentEntry = pIconDirEntry ; + int i ; + int wMax = 0 ; + int colmax = 0 ; + int iSel = wxNOT_FOUND ; + for (i=0; i < nIcons ; i++ ) + { + stream.Read(pCurrentEntry, sizeof(ICONDIRENTRY)); + //bHeight and bColorCount are wxUint8 + if (pCurrentEntry->bWidth >= wMax ) + { + // see if we have more colors, ==0 indicates > 8bpp + if (pCurrentEntry->bColorCount == 0 ) pCurrentEntry->bColorCount = 255 ; + if (pCurrentEntry->bColorCount >= colmax) + { + iSel = i ; + wMax = pCurrentEntry->bWidth ; + colmax = pCurrentEntry->bColorCount ; + } + } + pCurrentEntry ++ ; + } + if (iSel == wxNOT_FOUND) + { + bResult = FALSE; + } + else + { + //seek to selected icon + pCurrentEntry = pIconDirEntry + iSel ; + stream.SeekI (wxUINT32_SWAP_ON_BE ( pCurrentEntry -> dwImageOffset ), wxFromStart ) ; + bResult = LoadDib ( image, stream, TRUE, IsBmp ); + } + delete [] pIconDirEntry ; + return bResult ; +} + + bool wxBMPHandler::DoCanRead( wxInputStream& stream ) { unsigned char hdr[2]; - stream.Read(&hdr, 2); + stream.Read(hdr, 2); stream.SeekI(-2, wxFromCurrent); return (hdr[0] == 'B' && hdr[1] == 'M'); } +bool wxICOHandler::DoCanRead( wxInputStream& stream ) +{ + unsigned char hdr[4]; + + stream.Read(hdr, 4); + stream.SeekI(-4, wxFromCurrent); + return (hdr[0] == '\0' && hdr[1] == '\0' && hdr[2] == '\1' && hdr[3] == '\0'); +} + #endif // wxUSE_STREAMS #endif // wxUSE_IMAGE