X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/e2badebb8fad5ee453fada24f336c275df9f216b..e93523680ba3c83cdae75b511214c82f28a2d853:/src/dfb/bitmap.cpp

diff --git a/src/dfb/bitmap.cpp b/src/dfb/bitmap.cpp
index 6c759fafb4..e6a8b26dc9 100644
--- a/src/dfb/bitmap.cpp
+++ b/src/dfb/bitmap.cpp
@@ -23,6 +23,7 @@
 #include "wx/bitmap.h"
 #include "wx/colour.h"
 #include "wx/image.h"
+#include "wx/rawbmp.h"
 
 #include "wx/dfb/private.h"
 
@@ -167,6 +168,26 @@ static void CopyImageToSurface(const wxImage& image,
     }
 }
 
+static wxIDirectFBSurfacePtr
+CreateSurfaceWithFormat(int w, int h, DFBSurfacePixelFormat format)
+{
+    DFBSurfaceDescription desc;
+    desc.flags = (DFBSurfaceDescriptionFlags)
+        (DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT);
+    desc.caps = DSCAPS_NONE;
+    desc.width = w;
+    desc.height = h;
+
+    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)
 {
@@ -178,15 +199,47 @@ static wxIDirectFBSurfacePtr CreateSurfaceForImage(const wxImage& image)
     // NB: wxImage uses RGB order of bytes while DirectFB uses BGR, so we
     //     cannot use preallocated surface that shares data with wxImage, we
     //     have to copy the data to temporary surface instead
-    DFBSurfaceDescription desc;
-    desc.flags = (DFBSurfaceDescriptionFlags)
-        (DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT);
-    desc.caps = DSCAPS_NONE;
-    desc.width = image.GetWidth();
-    desc.height = image.GetHeight();
-    desc.pixelformat = DSPF_RGB24;
+    return CreateSurfaceWithFormat(image.GetWidth(), image.GetHeight(),
+                                   DSPF_RGB24);
+}
 
-    return wxIDirectFB::Get()->CreateSurface(&desc);
+static 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;
+}
+
+static 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;
+    }
 }
 
 //-----------------------------------------------------------------------------
@@ -256,9 +309,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)
@@ -267,33 +318,22 @@ 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)
 {
     wxCHECK_RET( image.Ok(), wxT("invalid image") );
-    wxCHECK_RET( depth == -1, wxT("only default depth supported now") );
+
+    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:
@@ -361,6 +401,51 @@ wxImage wxBitmap::ConvertToImage() const
 }
 #endif // wxUSE_IMAGE
 
+void *wxBitmap::GetRawData(wxPixelDataBase& data, int bpp)
+{
+    wxCHECK_MSG( Ok(), NULL, "invalid bitmap" );
+
+    AllocExclusive();
+
+    DFBSurfacePixelFormat format;
+    if ( bpp == 32 )
+        format = DSPF_ARGB;
+    else
+        format = DSPF_RGB24;
+
+    // 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;
+    if ( !M_BITMAP->m_surface->Lock
+                               (
+                                 (DFBSurfaceLockFlags)(DSLF_READ | DSLF_WRITE),
+                                 &bits,
+                                 &data.m_stride
+                               ) )
+        return NULL;
+
+    M_BITMAP->m_surface->GetSize(&data.m_width, &data.m_height);
+
+    return bits;
+}
+
+void wxBitmap::UngetRawData(wxPixelDataBase& WXUNUSED(data))
+{
+    M_BITMAP->m_surface->Unlock();
+}
+
+bool wxBitmap::HasAlpha() const
+{
+    wxCHECK_MSG( Ok(), false, "invalid bitmap" );
+
+    return M_BITMAP->m_surface->GetPixelFormat() == DSPF_ARGB;
+}
+
 wxBitmap::wxBitmap(const wxString &filename, wxBitmapType type)
 {
     LoadFile(filename, type);
@@ -533,9 +618,23 @@ void wxBitmap::SetWidth(int width)
 
 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