X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/c3ee7025523a7a0ac32bf4c807ae1276fd3bcc09..7198c3368055d88249a338eb33b21f051f674806:/src/dfb/bitmap.cpp

diff --git a/src/dfb/bitmap.cpp b/src/dfb/bitmap.cpp
index 6d4b5b0acb..9e472a0edd 100644
--- a/src/dfb/bitmap.cpp
+++ b/src/dfb/bitmap.cpp
@@ -28,9 +28,12 @@
 #include "wx/dfb/private.h"
 
 //-----------------------------------------------------------------------------
-// helpers
+// helpers for translating between wx and DFB pixel formats
 //-----------------------------------------------------------------------------
 
+namespace
+{
+
 // NB: Most of this conversion code is needed because of differences between
 //     wxImage and wxDFB's wxBitmap representations:
 //     (1) wxImage uses RGB order, while DirectFB uses BGR
@@ -40,11 +43,11 @@
 // pitch = stride = # of bytes between the start of N-th line and (N+1)-th line
 // {Src,Dst}PixSize = # of bytes used to represent one pixel
 template<int SrcPixSize, int DstPixSize>
-static void CopyPixelsAndSwapRGB(unsigned w, unsigned h,
-                                 const unsigned char *src,
-                                 unsigned src_pitch,
-                                 unsigned char *dst,
-                                 unsigned dst_pitch)
+void CopyPixelsAndSwapRGB(unsigned w, unsigned h,
+                          const unsigned char *src,
+                          unsigned src_pitch,
+                          unsigned char *dst,
+                          unsigned dst_pitch)
 {
     unsigned src_advance = src_pitch - SrcPixSize * w;
     unsigned dst_advance = dst_pitch - DstPixSize * w;
@@ -60,11 +63,10 @@ static void CopyPixelsAndSwapRGB(unsigned w, unsigned h,
     }
 }
 
-static void CopySurfaceToImage(const wxIDirectFBSurfacePtr& surface,
-                               wxImage& image)
+void CopySurfaceToImage(const wxIDirectFBSurfacePtr& surface, wxImage& image)
 {
     wxIDirectFBSurface::Locked locked(surface, DSLF_READ);
-    wxCHECK_RET( locked.ptr, _T("failed to lock surface") );
+    wxCHECK_RET( locked.ptr, "failed to lock surface" );
 
     const unsigned width = image.GetWidth();
     const unsigned height = image.GetHeight();
@@ -115,8 +117,8 @@ static void CopySurfaceToImage(const wxIDirectFBSurfacePtr& surface,
     }
 }
 
-static void CopyImageToSurface(const wxImage& image,
-                               const wxIDirectFBSurfacePtr& surface)
+void CopyImageToSurface(const wxImage& image,
+                        const wxIDirectFBSurfacePtr& surface)
 {
     wxIDirectFBSurface::Locked locked(surface, DSLF_WRITE);
     wxCHECK_RET( locked.ptr, "failed to lock surface" );
@@ -168,27 +170,33 @@ static void CopyImageToSurface(const wxImage& image,
     }
 }
 
-static wxIDirectFBSurfacePtr
+wxIDirectFBSurfacePtr
 CreateSurfaceWithFormat(int w, int h, DFBSurfacePixelFormat format)
 {
     DFBSurfaceDescription desc;
     desc.flags = (DFBSurfaceDescriptionFlags)
-        (DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT);
+        (DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT);
     desc.caps = DSCAPS_NONE;
     desc.width = w;
     desc.height = h;
-    desc.pixelformat = format;
+
+    if ( format != DSPF_UNKNOWN )
+    {
+        desc.flags = (DFBSurfaceDescriptionFlags)(
+                            desc.flags | DSDESC_PIXELFORMAT);
+        desc.pixelformat = format;
+    }
 
     return wxIDirectFB::Get()->CreateSurface(&desc);
 }
 
 // Creates a surface that will use wxImage's pixel data (RGB only)
-static wxIDirectFBSurfacePtr CreateSurfaceForImage(const wxImage& image)
+wxIDirectFBSurfacePtr CreateSurfaceForImage(const wxImage& image)
 {
-    wxCHECK_MSG( image.Ok(), NULL, _T("invalid image") );
+    wxCHECK_MSG( image.IsOk(), NULL, "invalid image" );
     // FIXME_DFB: implement alpha handling by merging alpha buffer with RGB
     //            into a temporary RGBA surface
-    wxCHECK_MSG( !image.HasAlpha(), NULL, _T("alpha channel not supported") );
+    wxCHECK_MSG( !image.HasAlpha(), NULL, "alpha channel not supported" );
 
     // NB: wxImage uses RGB order of bytes while DirectFB uses BGR, so we
     //     cannot use preallocated surface that shares data with wxImage, we
@@ -197,11 +205,150 @@ static wxIDirectFBSurfacePtr CreateSurfaceForImage(const wxImage& image)
                                    DSPF_RGB24);
 }
 
+bool ConvertSurfaceToFormat(wxIDirectFBSurfacePtr& surface,
+                            DFBSurfacePixelFormat format)
+{
+    if ( surface->GetPixelFormat() == format )
+        return true;
+
+    int w, h;
+    surface->GetSize(&w, &h);
+    wxIDirectFBSurfacePtr s = CreateSurfaceWithFormat(w, h, format);
+    if ( !s )
+        return false;
+
+    if ( !s->SetBlittingFlags(DSBLIT_NOFX) )
+        return false;
+    if ( !s->Blit(surface->GetRaw(), NULL, 0, 0) )
+        return false;
+
+    surface = s;
+    return true;
+}
+
+DFBSurfacePixelFormat DepthToFormat(int depth)
+{
+    switch ( depth )
+    {
+        case 24:
+            return DSPF_RGB24;
+        case 32:
+            // NB: we treat depth=32 as requesting ARGB for consistency with
+            //     other ports
+            return DSPF_ARGB;
+        default:
+            wxFAIL_MSG( "unsupported depth requested" );
+            // fall through
+        case -1:
+            return DSPF_UNKNOWN;
+    }
+}
+
+// ----------------------------------------------------------------------------
+// monochrome bitmap functions
+// ----------------------------------------------------------------------------
+
+// this function works with destination buffer of type T and not char (where T
+// is typically wxUint32 for RGB32, wxUint16 for RGB16 &c) as we don't need
+// access to the individual pixel components -- and so it's not suitable for
+// the pixel formats with pixel size not equal to 8, 16 or 32
+template <typename T, int White, int Black>
+void
+CopyBits(int width,
+         int height,
+         const unsigned char *src,
+         const wxIDirectFBSurface::Locked locked)
+{
+    static const int BITS_PER_BYTE = 8;
+
+    // extra padding to add to dst at the end of each row: this works on the
+    // assumption that all rows are aligned at multiples of T (and usually 4
+    // bytes) boundary so check for it (and change the code if this assert is
+    // ever triggered)
+    wxASSERT_MSG( !(locked.pitch % sizeof(T)), "image rows not aligned?" );
+    const int padDst = (locked.pitch - width*sizeof(T))/sizeof(T);
+
+    int x = 0; // position in the current bitmap row
+
+    // a single char in src corresponds to 8 destination pixels and the last
+    // char in the row contains padding if necessary, i.e. there is always an
+    // integer number of chars per row
+    const unsigned char * const
+        srcEnd = src + ((width + BITS_PER_BYTE - 1)/BITS_PER_BYTE)*height;
+
+    // we operate with sizeof(T), not 1, bytes at once
+    T *dst = static_cast<T *>(locked.ptr);
+    while ( src < srcEnd )
+    {
+        unsigned char val = *src++;
+
+        for ( int bit = 0; bit < BITS_PER_BYTE; bit++ )
+        {
+            *dst++ = val & 1 ? White : Black;
+            val >>= 1;
+            if ( ++x == width )
+            {
+                dst += padDst;
+                x = 0;
+                break;
+            }
+        }
+    }
+}
+
+bool
+CopyBitsToSurface(const unsigned char *bits,
+                  int width,
+                  int height,
+                  wxIDirectFBSurfacePtr& surface)
+{
+    wxIDirectFBSurface::Locked locked(surface, DSLF_WRITE);
+    wxCHECK_MSG( locked.ptr, false, "failed to lock surface" );
+
+    const DFBSurfacePixelFormat format = surface->GetPixelFormat();
+
+    switch ( format )
+    {
+        case DSPF_LUT8:
+            // we suppose that these indices correspond to the palette entries
+            // for white and black, respectively, but a better idea would be to
+            // use IDirectFBPalette::FindBestMatch() to determine them
+            CopyBits<wxUint8, 0xff, 0>(width, height, bits, locked);
+            break;
+
+        case DSPF_RGB16:
+            CopyBits<wxUint16, 0xffff, 0>(width, height, bits, locked);
+            break;
+
+        case DSPF_RGB32:
+            CopyBits<wxUint32, 0xffffffff, 0>(width, height, bits, locked);
+            break;
+
+        default:
+            // we don't really have time to implement efficient support for all
+            // the other formats so simply (and awfully slowly, of course...)
+            // convert everything else from RGB32
+            surface = CreateSurfaceWithFormat(width, height, DSPF_RGB32);
+            if ( !surface )
+                return false;
+
+            if ( !CopyBitsToSurface(bits, width, height, surface) )
+                return false;
+
+            if ( !ConvertSurfaceToFormat(surface, format) )
+                return false;
+    }
+
+    return true;
+}
+
+} // anonymous namespace
+
 //-----------------------------------------------------------------------------
 // wxBitmapRefData
 //-----------------------------------------------------------------------------
 
-class wxBitmapRefData: public wxObjectRefData
+class wxBitmapRefData: public wxGDIRefData
 {
 public:
     wxBitmapRefData()
@@ -230,6 +377,8 @@ public:
 #endif
     }
 
+    virtual bool IsOk() const { return m_surface; }
+
     wxIDirectFBSurfacePtr m_surface;
     wxMask               *m_mask;
 #if wxUSE_PALETTE
@@ -243,19 +392,13 @@ public:
 // wxBitmap
 //-----------------------------------------------------------------------------
 
-IMPLEMENT_ABSTRACT_CLASS(wxBitmapHandler, wxBitmapHandlerBase)
 IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxBitmapBase)
 
-wxBitmap::wxBitmap(int width, int height, int depth)
-{
-    Create(width, height, depth);
-}
-
 bool wxBitmap::Create(const wxIDirectFBSurfacePtr& surface)
 {
     UnRef();
 
-    wxCHECK_MSG( surface, false, _T("invalid surface") );
+    wxCHECK_MSG( surface, false, "invalid surface" );
 
     m_refData = new wxBitmapRefData();
     M_BITMAP->m_surface = surface;
@@ -264,9 +407,7 @@ bool wxBitmap::Create(const wxIDirectFBSurfacePtr& surface)
 
 bool wxBitmap::Create(int width, int height, int depth)
 {
-    wxCHECK_MSG( depth == -1, false, wxT("only default depth supported now") );
-
-    return CreateWithFormat(width, height, -1);
+    return CreateWithFormat(width, height, DepthToFormat(depth));
 }
 
 bool wxBitmap::CreateWithFormat(int width, int height, int dfbFormat)
@@ -275,33 +416,29 @@ bool wxBitmap::CreateWithFormat(int width, int height, int dfbFormat)
 
     wxCHECK_MSG( width > 0 && height > 0, false, wxT("invalid bitmap size") );
 
-    DFBSurfaceDescription desc;
-    desc.flags = (DFBSurfaceDescriptionFlags)(
-                        DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT);
-    desc.caps = DSCAPS_NONE;
-    desc.width = width;
-    desc.height = height;
-
-    if ( dfbFormat != -1 )
-    {
-        desc.flags = (DFBSurfaceDescriptionFlags)(
-                            desc.flags | DSDESC_PIXELFORMAT);
-        desc.pixelformat = (DFBSurfacePixelFormat)dfbFormat;
-    }
-
-    return Create(wxIDirectFB::Get()->CreateSurface(&desc));
+    return Create(CreateSurfaceWithFormat(width, height,
+                                          DFBSurfacePixelFormat(dfbFormat)));
 }
 
 #if wxUSE_IMAGE
-wxBitmap::wxBitmap(const wxImage& image, int depth)
+wxBitmap::wxBitmap(const wxImage& imageOrig, int depth)
 {
-    wxCHECK_RET( image.Ok(), wxT("invalid image") );
-    wxCHECK_RET( depth == -1, wxT("only default depth supported now") );
+    wxCHECK_RET( imageOrig.IsOk(), wxT("invalid image") );
+
+    wxImage image(imageOrig);
+
+    // convert mask to alpha channel, because wxMask isn't implemented yet
+    // FIXME: don't do this, implement proper wxMask support
+    if ( image.HasMask() )
+        image.InitAlpha();
+
+    DFBSurfacePixelFormat format = DepthToFormat(depth);
+    if ( format == DSPF_UNKNOWN && image.HasAlpha() )
+        format = DSPF_ARGB;
 
     // create surface in screen's format (unless we need alpha channel,
     // in which case use ARGB):
-    if ( !CreateWithFormat(image.GetWidth(), image.GetHeight(),
-                           image.HasAlpha() ? DSPF_ARGB : -1) )
+    if ( !CreateWithFormat(image.GetWidth(), image.GetHeight(), format) )
         return;
 
     // then copy the image to it:
@@ -328,14 +465,11 @@ wxBitmap::wxBitmap(const wxImage& image, int depth)
                 return;
         }
     }
-
-    // FIXME: implement mask creation from image's mask (or alpha channel?)
-    wxASSERT_MSG( !image.HasMask(), _T("image masks are ignored for now") );
 }
 
 wxImage wxBitmap::ConvertToImage() const
 {
-    wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
+    wxCHECK_MSG( IsOk(), wxNullImage, wxT("invalid bitmap") );
 
     wxImage img(GetWidth(), GetHeight());
     wxIDirectFBSurfacePtr src = M_BITMAP->m_surface;
@@ -363,7 +497,7 @@ wxImage wxBitmap::ConvertToImage() const
     }
 
     // FIXME: implement mask setting in the image
-    wxASSERT_MSG( GetMask() == NULL, _T("bitmap masks are ignored for now") );
+    wxASSERT_MSG( GetMask() == NULL, "bitmap masks are ignored for now" );
 
     return img;
 }
@@ -371,7 +505,7 @@ wxImage wxBitmap::ConvertToImage() const
 
 void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
 {
-    wxCHECK_MSG( Ok(), NULL, "invalid bitmap" );
+    wxCHECK_MSG( IsOk(), NULL, "invalid bitmap" );
 
     AllocExclusive();
 
@@ -381,8 +515,11 @@ void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
     else
         format = DSPF_RGB24;
 
-    // requested format is not what this bitmap uses
-    if ( format != M_BITMAP->m_surface->GetPixelFormat() )
+    // convert the bitmap into format compatible with requested raw access;
+    // note that we don't bother converting the bitmap back in UngetRawData(),
+    // as unpacked formats (RGB24, RGB32) are the common case and converting
+    // between them while blitting is fast enough (FIXME?)
+    if ( !ConvertSurfaceToFormat(M_BITMAP->m_surface, format) )
         return NULL;
 
     void *bits = NULL;
@@ -406,7 +543,7 @@ void wxBitmap::UngetRawData(wxPixelDataBase& WXUNUSED(data))
 
 bool wxBitmap::HasAlpha() const
 {
-    wxCHECK_MSG( Ok(), false, "invalid bitmap" );
+    wxCHECK_MSG( IsOk(), false, "invalid bitmap" );
 
     return M_BITMAP->m_surface->GetPixelFormat() == DSPF_ARGB;
 }
@@ -420,17 +557,18 @@ wxBitmap::wxBitmap(const char bits[], int width, int height, int depth)
 {
     wxCHECK_RET( depth == 1, wxT("can only create mono bitmap from XBM data") );
 
-    wxFAIL_MSG( _T("not implemented") );
-}
+    // create bitmap in the device-dependent format
+    if ( !CreateWithFormat(width, height, DSPF_UNKNOWN) )
+        return;
 
-bool wxBitmap::IsOk() const
-{
-    return (m_refData != NULL && M_BITMAP->m_surface);
+    if ( !CopyBitsToSurface((const unsigned char *)bits,
+                            width, height, M_BITMAP->m_surface) )
+        UnRef();
 }
 
 int wxBitmap::GetHeight() const
 {
-    wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
+    wxCHECK_MSG( IsOk(), -1, wxT("invalid bitmap") );
 
     int h = -1;
     M_BITMAP->m_surface->GetSize(NULL, &h);
@@ -439,7 +577,7 @@ int wxBitmap::GetHeight() const
 
 int wxBitmap::GetWidth() const
 {
-    wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
+    wxCHECK_MSG( IsOk(), -1, wxT("invalid bitmap") );
 
     int w = -1;
     M_BITMAP->m_surface->GetSize(&w, NULL);
@@ -448,21 +586,21 @@ int wxBitmap::GetWidth() const
 
 int wxBitmap::GetDepth() const
 {
-    wxCHECK_MSG( Ok(), -1, wxT("invalid bitmap") );
+    wxCHECK_MSG( IsOk(), -1, wxT("invalid bitmap") );
 
     return M_BITMAP->m_surface->GetDepth();
 }
 
 wxMask *wxBitmap::GetMask() const
 {
-    wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
+    wxCHECK_MSG( IsOk(), NULL, wxT("invalid bitmap") );
 
     return M_BITMAP->m_mask;
 }
 
 void wxBitmap::SetMask(wxMask *mask)
 {
-    wxCHECK_RET( Ok(), wxT("invalid bitmap") );
+    wxCHECK_RET( IsOk(), wxT("invalid bitmap") );
 
     AllocExclusive();
     delete M_BITMAP->m_mask;
@@ -477,7 +615,7 @@ bool wxBitmap::CopyFromIcon(const wxIcon& icon)
 
 wxBitmap wxBitmap::GetSubBitmap(const wxRect& rect) const
 {
-    wxCHECK_MSG( Ok() &&
+    wxCHECK_MSG( IsOk() &&
                  rect.x >= 0 && rect.y >= 0 &&
                  rect.x+rect.width <= GetWidth() &&
                  rect.y+rect.height <= GetHeight(),
@@ -500,7 +638,7 @@ bool wxBitmap::LoadFile(const wxString &name, wxBitmapType type)
     if ( handler == NULL )
     {
         wxImage image;
-        if ( !image.LoadFile(name, type) || !image.Ok() )
+        if ( !image.LoadFile(name, type) || !image.IsOk() )
         {
             wxLogError(_("No bitmap handler for type %d defined."), type);
             return false;
@@ -520,7 +658,7 @@ bool wxBitmap::LoadFile(const wxString &name, wxBitmapType type)
 #warning "to common code"
 bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type, const wxPalette *palette) const
 {
-    wxCHECK_MSG( Ok(), false, wxT("invalid bitmap") );
+    wxCHECK_MSG( IsOk(), false, wxT("invalid bitmap") );
 
     wxBitmapHandler *handler = FindHandler(type);
 
@@ -532,7 +670,7 @@ bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type, const wxPal
             image.SetPalette(*palette);
 #endif // wxUSE_PALETTE
 
-        if ( image.Ok() )
+        if ( image.IsOk() )
             return image.SaveFile(filename, type);
         else
         {
@@ -547,21 +685,20 @@ bool wxBitmap::SaveFile(const wxString& filename, wxBitmapType type, const wxPal
 #if wxUSE_PALETTE
 wxPalette *wxBitmap::GetPalette() const
 {
-    wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
+    wxCHECK_MSG( IsOk(), NULL, wxT("invalid bitmap") );
 
     return M_BITMAP->m_palette;
 }
 
 void wxBitmap::SetPalette(const wxPalette& palette)
 {
-    wxCHECK_RET( Ok(), wxT("invalid bitmap") );
+    wxCHECK_RET( IsOk(), wxT("invalid bitmap") );
     wxCHECK_RET( GetDepth() > 1 && GetDepth() <= 8, wxT("cannot set palette for bitmap of this depth") );
 
     AllocExclusive();
-    delete M_BITMAP->m_palette;
-    M_BITMAP->m_palette = NULL;
+    wxDELETE(M_BITMAP->m_palette);
 
-    if ( !palette.Ok() ) return;
+    if ( !palette.IsOk() ) return;
 
     M_BITMAP->m_palette = new wxPalette(palette);
 }
@@ -571,36 +708,50 @@ void wxBitmap::SetHeight(int height)
 {
     AllocExclusive();
 
-    wxFAIL_MSG( _T("SetHeight not implemented") );
+    wxFAIL_MSG( "SetHeight not implemented" );
 }
 
 void wxBitmap::SetWidth(int width)
 {
     AllocExclusive();
 
-    wxFAIL_MSG( _T("SetWidth not implemented") );
+    wxFAIL_MSG( "SetWidth not implemented" );
 }
 
 void wxBitmap::SetDepth(int depth)
 {
+    DFBSurfacePixelFormat format = DepthToFormat(depth);
+    if ( M_BITMAP->m_surface->GetPixelFormat() == format )
+        return;
+
     AllocExclusive();
 
-    wxFAIL_MSG( _T("SetDepth not implemented") );
+    int w, h;
+    M_BITMAP->m_surface->GetSize(&w, &h);
+    wxIDirectFBSurfacePtr s = CreateSurfaceWithFormat(w, h, format);
+    if ( !s )
+        return;
+    if ( !s->SetBlittingFlags(DSBLIT_NOFX) )
+        return;
+    if ( !s->Blit(M_BITMAP->m_surface->GetRaw(), NULL, 0, 0) )
+        return;
+
+    M_BITMAP->m_surface = s;
 }
 
 wxIDirectFBSurfacePtr wxBitmap::GetDirectFBSurface() const
 {
-    wxCHECK_MSG( Ok(), NULL, wxT("invalid bitmap") );
+    wxCHECK_MSG( IsOk(), NULL, wxT("invalid bitmap") );
 
     return M_BITMAP->m_surface;
 }
 
-wxObjectRefData *wxBitmap::CreateRefData() const
+wxGDIRefData *wxBitmap::CreateGDIRefData() const
 {
     return new wxBitmapRefData;
 }
 
-wxObjectRefData *wxBitmap::CloneRefData(const wxObjectRefData *data) const
+wxGDIRefData *wxBitmap::CloneGDIRefData(const wxGDIRefData *data) const
 {
     return new wxBitmapRefData(*(wxBitmapRefData *)data);
 }