X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/4b1f929cc3421e43409f7d62260bf9ba0ffc75ab..bae3be5d736c3a53cd3ce904d4cdd2e6c74bfd73:/src/msw/dib.cpp diff --git a/src/msw/dib.cpp b/src/msw/dib.cpp index 92db7b427d..f56dae0b1f 100644 --- a/src/msw/dib.cpp +++ b/src/msw/dib.cpp @@ -12,8 +12,7 @@ /* TODO: support for palettes is very incomplete, several functions simply ignore them (we should select and realize the palette, if any, before - caling GetDIBits() in the DC we use with it and we shouldn't use - GetBitmapBits() at all because we can't do it with it) + caling GetDIBits() in the DC we use with it. */ // ============================================================================ @@ -36,6 +35,8 @@ #include "wx/log.h" #endif //WX_PRECOMP +#if wxUSE_WXDIB + #include "wx/bitmap.h" #include "wx/intl.h" #include "wx/file.h" @@ -44,27 +45,38 @@ #include #if !defined(__MWERKS__) && !defined(__SALFORDC__) -#include -#endif - -#ifdef __GNUWIN32_OLD__ - #include "wx/msw/gnuwin32/extra.h" + #include #endif #include "wx/image.h" #include "wx/msw/dib.h" +#ifdef __WXWINCE__ + #include // for SHLoadDIBitmap() +#endif + // ---------------------------------------------------------------------------- // private functions // ---------------------------------------------------------------------------- // calculate the number of palette entries needed for the bitmap with this // number of bits per pixel -static WORD wxGetNumOfBitmapColors(WORD bitsPerPixel) +static inline WORD GetNumberOfColours(WORD bitsPerPixel) { // only 1, 4 and 8bpp bitmaps use palettes (well, they could be used with // 24bpp ones too but we don't support this as I think it's quite uncommon) - return bitsPerPixel <= 8 ? 1 << bitsPerPixel : 0; + return (WORD)(bitsPerPixel <= 8 ? 1 << bitsPerPixel : 0); +} + +// wrapper around ::GetObject() for DIB sections +static inline bool GetDIBSection(HBITMAP hbmp, DIBSECTION *ds) +{ + // note that at least under Win9x (this doesn't seem to happen under Win2K + // but this doesn't mean anything, of course), GetObject() may return + // sizeof(DIBSECTION) for a bitmap which is *not* a DIB section and the way + // to check for it is by looking at the bits pointer + return ::GetObject(hbmp, sizeof(DIBSECTION), ds) == sizeof(DIBSECTION) && + ds->dsBm.bmBits; } // ============================================================================ @@ -77,18 +89,21 @@ static WORD wxGetNumOfBitmapColors(WORD bitsPerPixel) bool wxDIB::Create(int width, int height, int depth) { - // we don't handle the palette yet - wxASSERT_MSG( depth == 24 || depth == 32, - _T("unsupported image depth in wxDIB::Create()") ); + // we don't support formats using palettes right now so we only create + // either 24bpp (RGB) or 32bpp (RGBA) bitmaps + wxASSERT_MSG( depth, _T("invalid image depth in wxDIB::Create()") ); + if ( depth < 24 ) + depth = 24; - static const int infosize = sizeof(BITMAPINFOHEADER); + // allocate memory for bitmap structures + static const int sizeHeader = sizeof(BITMAPINFOHEADER); - BITMAPINFO *info = (BITMAPINFO *)malloc(infosize); - wxCHECK_MSG( info, NULL, _T("malloc(BITMAPINFO) failed") ); + BITMAPINFO *info = (BITMAPINFO *)malloc(sizeHeader); + wxCHECK_MSG( info, false, _T("malloc(BITMAPINFO) failed") ); - memset(info, 0, infosize); + memset(info, 0, sizeHeader); - info->bmiHeader.biSize = infosize; + info->bmiHeader.biSize = sizeHeader; info->bmiHeader.biWidth = width; // we use positive height here which corresponds to a DIB with normal, i.e. @@ -99,7 +114,7 @@ bool wxDIB::Create(int width, int height, int depth) info->bmiHeader.biHeight = height; info->bmiHeader.biPlanes = 1; - info->bmiHeader.biBitCount = depth; + info->bmiHeader.biBitCount = (WORD)depth; info->bmiHeader.biSizeImage = GetLineSize(width, depth)*height; m_handle = ::CreateDIBSection @@ -132,37 +147,142 @@ bool wxDIB::Create(const wxBitmap& bmp) { wxCHECK_MSG( bmp.Ok(), false, _T("wxDIB::Create(): invalid bitmap") ); - const int w = bmp.GetWidth(); - const int h = bmp.GetHeight(); - int d = bmp.GetDepth(); - if ( d == -1 ) - d = wxDisplayDepth(); + if ( !Create(GetHbitmapOf(bmp)) ) + return false; + + m_hasAlpha = bmp.HasAlpha(); + + return true; +} + +bool wxDIB::Create(HBITMAP hbmp) +{ + // this bitmap could already be a DIB section in which case we don't need + // to convert it to DIB + DIBSECTION ds; + if ( GetDIBSection(hbmp, &ds) ) + { + m_handle = hbmp; + + // wxBitmap will free it, not we + m_ownsHandle = false; + + // copy all the bitmap parameters too as we have them now anyhow + m_width = ds.dsBm.bmWidth; + m_height = ds.dsBm.bmHeight; + m_depth = ds.dsBm.bmBitsPixel; + + m_data = ds.dsBm.bmBits; + } + else // no, it's a DDB -- convert it to DIB + { + // prepare all the info we need + BITMAP bm; + if ( !::GetObject(hbmp, sizeof(bm), &bm) ) + { + wxLogLastError(wxT("GetObject(bitmap)")); + + return false; + } + + int d = bm.bmBitsPixel; + if ( d <= 0 ) + d = wxDisplayDepth(); + + if ( !Create(bm.bmWidth, bm.bmHeight, d) || !CopyFromDDB(hbmp) ) + return false; + } - if ( !Create(w, h, d) ) + return true; +} + +// Windows CE doesn't have GetDIBits() so use an alternative implementation +// for it +// +// in fact I'm not sure if GetDIBits() is really much better than using +// BitBlt() like this -- it should be faster but I didn't do any tests, if +// anybody has time to do them and by chance finds that GetDIBits() is not +// much faster than BitBlt(), we could always use the Win CE version here +#ifdef __WXWINCE__ + +bool wxDIB::CopyFromDDB(HBITMAP hbmp) +{ + MemoryHDC hdcSrc; + if ( !hdcSrc ) + return false; + + SelectInHDC selectSrc(hdcSrc, hbmp); + if ( !selectSrc ) return false; - // we could have used GetDIBits() too but GetBitmapBits() is simpler - if ( !::GetBitmapBits + MemoryHDC hdcDst; + if ( !hdcDst ) + return false; + + SelectInHDC selectDst(hdcDst, m_handle); + if ( !selectDst ) + return false; + + + if ( !::BitBlt( + hdcDst, + 0, 0, m_width, m_height, + hdcSrc, + 0, 0, + SRCCOPY + ) ) + { + wxLogLastError(_T("BitBlt(DDB -> DIB)")); + + return false; + } + + return true; +} + +#else // !__WXWINCE__ + +bool wxDIB::CopyFromDDB(HBITMAP hbmp) +{ + DIBSECTION ds; + if ( !GetDIBSection(m_handle, &ds) ) + { + // we're sure that our handle is a DIB section, so this should work + wxFAIL_MSG( _T("GetObject(DIBSECTION) unexpectedly failed") ); + + return false; + } + + if ( !::GetDIBits ( - GetHbitmapOf(bmp), // the source DDB - GetLineSize(w, d)*h, // the number of bytes to copy - m_data // the pixels will be copied here + ScreenHDC(), // the DC to use + hbmp, // the source DDB + 0, // first scan line + m_height, // number of lines to copy + ds.dsBm.bmBits, // pointer to the buffer + (BITMAPINFO *)&ds.dsBmih, // bitmap header + DIB_RGB_COLORS // and not DIB_PAL_COLORS ) ) { wxLogLastError(wxT("GetDIBits()")); - return 0; + return false; } return true; } +#endif // __WXWINCE__/!__WXWINCE__ + // ---------------------------------------------------------------------------- // Loading/saving the DIBs // ---------------------------------------------------------------------------- bool wxDIB::Load(const wxString& filename) { +#ifdef __WXWINCE__ + m_handle = SHLoadDIBitmap(filename); +#else // !__WXWINCE__ m_handle = (HBITMAP)::LoadImage ( wxGetInstance(), @@ -171,9 +291,11 @@ bool wxDIB::Load(const wxString& filename) 0, 0, // don't specify the size LR_CREATEDIBSECTION | LR_LOADFROMFILE ); +#endif // __WXWINCE__ + if ( !m_handle ) { - wxLogLastError(_T("LoadImage(LR_CREATEDIBSECTION | LR_LOADFROMFILE)")); + wxLogLastError(_T("Loading DIB from file")); return false; } @@ -190,7 +312,7 @@ bool wxDIB::Save(const wxString& filename) if ( ok ) { DIBSECTION ds; - if ( !::GetObject(m_handle, sizeof(ds), &ds) ) + if ( !GetDIBSection(m_handle, &ds) ) { wxLogLastError(_T("GetObject(hDIB)")); } @@ -239,7 +361,7 @@ void wxDIB::DoGetObject() const // check for this now rather than trying to find out why it doesn't // work later DIBSECTION ds; - if ( !::GetObject(m_handle, sizeof(ds), &ds) ) + if ( !GetDIBSection(m_handle, &ds) ) { wxLogLastError(_T("GetObject(hDIB)")); return; @@ -258,19 +380,45 @@ void wxDIB::DoGetObject() const // DDB <-> DIB conversions // ---------------------------------------------------------------------------- +#ifndef __WXWINCE__ + HBITMAP wxDIB::CreateDDB(HDC hdc) const { wxCHECK_MSG( m_handle, 0, _T("wxDIB::CreateDDB(): invalid object") ); DIBSECTION ds; - if ( !::GetObject(m_handle, sizeof(ds), &ds) ) + if ( !GetDIBSection(m_handle, &ds) ) { wxLogLastError(_T("GetObject(hDIB)")); return 0; } - return ConvertToBitmap((BITMAPINFO *)&ds.dsBmih, hdc, ds.dsBm.bmBits); + // how many colours are we going to have in the palette? + DWORD biClrUsed = ds.dsBmih.biClrUsed; + if ( !biClrUsed ) + { + // biClrUsed field might not be set + biClrUsed = GetNumberOfColours(ds.dsBmih.biBitCount); + } + + if ( !biClrUsed ) + { + return ConvertToBitmap((BITMAPINFO *)&ds.dsBmih, hdc, ds.dsBm.bmBits); + } + else + { + // fake a BITMAPINFO w/o bits, just the palette info + wxCharBuffer bmi(sizeof(BITMAPINFO) + (biClrUsed - 1)*sizeof(RGBQUAD)); + BITMAPINFO *pBmi = (BITMAPINFO *)bmi.data(); + MemoryHDC hDC; + // get the colour table + SelectInHDC sDC(hDC, m_handle); + ::GetDIBColorTable(hDC, 0, biClrUsed, pBmi->bmiColors); + memcpy(&pBmi->bmiHeader, &ds.dsBmih, ds.dsBmih.biSize); + + return ConvertToBitmap(pBmi, hdc, ds.dsBm.bmBits); + } } /* static */ @@ -288,13 +436,31 @@ HBITMAP wxDIB::ConvertToBitmap(const BITMAPINFO *pbmi, HDC hdc, void *bits) if ( !bits ) { // we must skip over the colour table to get to the image data - - // biClrUsed has the number of colors but it may be not initialized at - // all - int numColors = pbmih->biClrUsed; - if ( !numColors ) + // + // colour table either has the real colour data in which case its + // number of entries is given by biClrUsed or is used for masks to be + // used for extracting colour information from true colour bitmaps in + // which case it always have exactly 3 DWORDs + int numColors; + switch ( pbmih->biCompression ) { - numColors = wxGetNumOfBitmapColors(pbmih->biBitCount); + case BI_BITFIELDS: + numColors = 3; + break; + + case BI_RGB: + // biClrUsed has the number of colors but it may be not initialized at + // all + numColors = pbmih->biClrUsed; + if ( !numColors ) + { + numColors = GetNumberOfColours(pbmih->biBitCount); + } + break; + + default: + // no idea how it should be calculated for the other cases + numColors = 0; } bits = (char *)pbmih + sizeof(*pbmih) + numColors*sizeof(RGBQUAD); @@ -354,7 +520,7 @@ size_t wxDIB::ConvertFromBitmap(BITMAPINFO *pbi, HBITMAP hbmp) bi.biBitCount = bm.bmBitsPixel; // memory we need for BITMAPINFO only - DWORD dwLen = bi.biSize + wxGetNumOfBitmapColors(bm.bmBitsPixel) * sizeof(RGBQUAD); + DWORD dwLen = bi.biSize + GetNumberOfColours(bm.bmBitsPixel) * sizeof(RGBQUAD); // get either just the image size or the image bits if ( !::GetDIBits @@ -400,7 +566,7 @@ HGLOBAL wxDIB::ConvertFromBitmap(HBITMAP hbmp) return NULL; } - if ( !ConvertFromBitmap((BITMAPINFO *)GlobalHandle(hDIB), hbmp) ) + if ( !ConvertFromBitmap((BITMAPINFO *)(void *)GlobalPtr(hDIB), hbmp) ) { // this really shouldn't happen... it worked the first time, why not // now? @@ -412,6 +578,8 @@ HGLOBAL wxDIB::ConvertFromBitmap(HBITMAP hbmp) return hDIB; } +#endif // __WXWINCE__ + // ---------------------------------------------------------------------------- // palette support // ---------------------------------------------------------------------------- @@ -420,10 +588,14 @@ HGLOBAL wxDIB::ConvertFromBitmap(HBITMAP hbmp) wxPalette *wxDIB::CreatePalette() const { + // GetDIBColorTable not available in eVC3 +#if defined(_WIN32_WCE) && _WIN32_WCE < 400 + return NULL; +#else wxCHECK_MSG( m_handle, NULL, _T("wxDIB::CreatePalette(): invalid object") ); DIBSECTION ds; - if ( !::GetObject(m_handle, sizeof(ds), &ds) ) + if ( !GetDIBSection(m_handle, &ds) ) { wxLogLastError(_T("GetObject(hDIB)")); @@ -435,7 +607,7 @@ wxPalette *wxDIB::CreatePalette() const if ( !biClrUsed ) { // biClrUsed field might not be set - biClrUsed = wxGetNumOfBitmapColors(ds.dsBmih.biBitCount); + biClrUsed = GetNumberOfColours(ds.dsBmih.biBitCount); } if ( !biClrUsed ) @@ -447,6 +619,8 @@ wxPalette *wxDIB::CreatePalette() const return NULL; } + MemoryHDC hDC; + // LOGPALETTE struct has only 1 element in palPalEntry array, we're // going to have biClrUsed of them so add necessary space LOGPALETTE *pPalette = (LOGPALETTE *) @@ -455,10 +629,13 @@ wxPalette *wxDIB::CreatePalette() const // initialize the palette header pPalette->palVersion = 0x300; // magic number, not in docs but works - pPalette->palNumEntries = biClrUsed; + pPalette->palNumEntries = (WORD)biClrUsed; - // and the colour table (it starts right after the end of the header) - const RGBQUAD *pRGB = (RGBQUAD *)((char *)&ds.dsBmih + ds.dsBmih.biSize); + // and the colour table + wxCharBuffer rgb(sizeof(RGBQUAD) * biClrUsed); + RGBQUAD *pRGB = (RGBQUAD*)rgb.data(); + SelectInHDC(hDC, m_handle); + ::GetDIBColorTable(hDC, 0, biClrUsed, pRGB); for ( DWORD i = 0; i < biClrUsed; i++, pRGB++ ) { pPalette->palPalEntry[i].peRed = pRGB->rgbRed; @@ -482,6 +659,7 @@ wxPalette *wxDIB::CreatePalette() const palette->SetHPALETTE((WXHPALETTE)hPalette); return palette; +#endif } #endif // wxUSE_PALETTE @@ -501,8 +679,8 @@ bool wxDIB::Create(const wxImage& image) // if we have alpha channel, we need to create a 32bpp RGBA DIB, otherwise // a 24bpp RGB is sufficient - const bool hasAlpha = image.HasAlpha(); - const int bpp = hasAlpha ? 32 : 24; + m_hasAlpha = image.HasAlpha(); + const int bpp = m_hasAlpha ? 32 : 24; if ( !Create(w, h, bpp) ) return false; @@ -512,23 +690,37 @@ bool wxDIB::Create(const wxImage& image) const int srcBytesPerLine = w * 3; const int dstBytesPerLine = GetLineSize(w, bpp); const unsigned char *src = image.GetData() + ((h - 1) * srcBytesPerLine); - const unsigned char *alpha = hasAlpha ? image.GetAlpha() + (h - 1)*w : NULL; + const unsigned char *alpha = m_hasAlpha ? image.GetAlpha() + (h - 1)*w + : NULL; unsigned char *dstLineStart = (unsigned char *)m_data; for ( int y = 0; y < h; y++ ) { // copy one DIB line unsigned char *dst = dstLineStart; - for ( int x = 0; x < w; x++ ) + if ( alpha ) { - // also, the order of RGB is inversed for DIBs - *dst++ = src[2]; - *dst++ = src[1]; - *dst++ = src[0]; - - src += 3; - - if ( alpha ) - *dst++ = *alpha++; + for ( int x = 0; x < w; x++ ) + { + // RGB order is reversed, and we need to premultiply + // all channels by alpha value for use with ::AlphaBlend. + const unsigned char a = *alpha++; + *dst++ = (unsigned char)((src[2] * a + 127) / 255); + *dst++ = (unsigned char)((src[1] * a + 127) / 255); + *dst++ = (unsigned char)((src[0] * a + 127) / 255); + *dst++ = a; + src += 3; + } + } + else // no alpha channel + { + for ( int x = 0; x < w; x++ ) + { + // RGB order is reversed. + *dst++ = src[2]; + *dst++ = src[1]; + *dst++ = src[0]; + src += 3; + } } // pass to the previous line in the image @@ -543,5 +735,69 @@ bool wxDIB::Create(const wxImage& image) return true; } +wxImage wxDIB::ConvertToImage() const +{ + wxCHECK_MSG( IsOk(), wxNullImage, + wxT("can't convert invalid DIB to wxImage") ); + + // create the wxImage object + const int w = GetWidth(); + const int h = GetHeight(); + wxImage image(w, h, false /* don't bother clearing memory */); + if ( !image.Ok() ) + { + wxFAIL_MSG( wxT("could not allocate data for image") ); + return wxNullImage; + } + + if ( m_hasAlpha ) + { + image.SetAlpha(); + } + + // this is the same loop as in Create() just above but with copy direction + // reversed + const int bpp = GetDepth(); + const int dstBytesPerLine = w * 3; + const int srcBytesPerLine = GetLineSize(w, bpp); + unsigned char *dst = image.GetData() + ((h - 1) * dstBytesPerLine); + unsigned char *alpha = image.HasAlpha() ? image.GetAlpha() + (h - 1)*w + : NULL; + const bool is32bit = bpp == 32; + const unsigned char *srcLineStart = (unsigned char *)GetData(); + for ( int y = 0; y < h; y++ ) + { + // copy one DIB line + const unsigned char *src = srcLineStart; + for ( int x = 0; x < w; x++ ) + { + dst[2] = *src++; + dst[1] = *src++; + dst[0] = *src++; + + dst += 3; + + if ( is32bit ) + { + if ( alpha ) + *alpha++ = *src; + src++; + } + } + + // pass to the previous line in the image + dst -= 2*dstBytesPerLine; + if ( alpha ) + alpha -= 2*w; + + // and to the next one in the DIB + srcLineStart += srcBytesPerLine; + } + + return image; +} + #endif // wxUSE_IMAGE +#endif // wxUSE_WXDIB +