fixed wxBitmap<->wxImage conversion to not exchange red and blue components

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@45233 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/dfb/wrapdfb.h

@@ -207,6 +207,9 @@ struct wxIDirectFBSurface : public wxDfbWrapper<IDirectFBSurface>
     bool GetPixelFormat(DFBSurfacePixelFormat *caps)
         { return Check(m_ptr->GetPixelFormat(m_ptr, caps)); }
 
+    // convenience version of GetPixelFormat, returns DSPF_UNKNOWN if fails
+    DFBSurfacePixelFormat GetPixelFormat();
+
     bool SetClip(const DFBRegion *clip)
         { return Check(m_ptr->SetClip(m_ptr, clip)); }
 
@@ -285,7 +288,6 @@ struct wxIDirectFBSurface : public wxDfbWrapper<IDirectFBSurface>
                                         source_rect, dest_rect));
     }
 
-
     /// Returns bit depth used by the surface or -1 on error
     int GetDepth();
 
@@ -315,6 +317,36 @@ struct wxIDirectFBSurface : public wxDfbWrapper<IDirectFBSurface>
     wxIDirectFBSurfacePtr CreateCompatible(const wxSize& size = wxDefaultSize,
                                            int flags = 0);
 
+    bool Lock(DFBSurfaceLockFlags flags, void **ret_ptr, int *ret_pitch)
+        { return Check(m_ptr->Lock(m_ptr, flags, ret_ptr, ret_pitch)); }
+
+    bool Unlock()
+        { return Check(m_ptr->Unlock(m_ptr)); }
+
+    /// Helper struct for safe locking & unlocking of surfaces
+    struct Locked
+    {
+        Locked(const wxIDirectFBSurfacePtr& surface, DFBSurfaceLockFlags flags)
+            : m_surface(surface)
+        {
+            if ( !surface->Lock(flags, &ptr, &pitch) )
+                ptr = NULL;
+        }
+
+        ~Locked()
+        {
+            if ( ptr )
+                m_surface->Unlock();
+        }
+
+        void *ptr;
+        int pitch;
+
+    private:
+        wxIDirectFBSurfacePtr m_surface;
+    };
+
+
 private:
     // this is private because we want user code to use FlipToFront()
     bool Flip(const DFBRegion *region, int flags);

src/dfb/bitmap.cpp

@@ -30,6 +30,55 @@
 // helpers
 //-----------------------------------------------------------------------------
 
+// pitch = stride = # of bytes between the start of N-th line and (N+1)-th line
+static void CopyPixelsAndSwapRGB(unsigned w, unsigned h,
+                                 const unsigned char *src,
+                                 unsigned src_pitch,
+                                 unsigned char *dst,
+                                 unsigned dst_pitch)
+{
+    unsigned src_advance = src_pitch - 3 * w;
+    unsigned dst_advance = dst_pitch - 3 * w;
+    for ( unsigned y = 0; y < h; y++, src += src_advance, dst += dst_advance )
+    {
+        for ( unsigned x = 0; x < w; x++, src += 3, dst += 3 )
+        {
+            // copy with RGB -> BGR translation:
+            dst[0] = src[2];
+            dst[1] = src[1];
+            dst[2] = src[0];
+        }
+    }
+}
+
+static void CopySurfaceToImage(const wxIDirectFBSurfacePtr& surface,
+                               const wxImage& image)
+{
+    wxCHECK_RET( surface->GetPixelFormat() == DSPF_RGB24,
+                 _T("unexpected pixel format") );
+
+    wxIDirectFBSurface::Locked locked(surface, DSLF_READ);
+    wxCHECK_RET( locked.ptr, _T("failed to lock surface") );
+
+    CopyPixelsAndSwapRGB(image.GetWidth(), image.GetHeight(),
+                         (unsigned char*)locked.ptr, locked.pitch,
+                         image.GetData(), image.GetWidth() * 3);
+}
+
+static void CopyImageToSurface(const wxImage& image,
+                               const wxIDirectFBSurfacePtr& surface)
+{
+    wxCHECK_RET( surface->GetPixelFormat() == DSPF_RGB24,
+                 _T("unexpected pixel format") );
+
+    wxIDirectFBSurface::Locked locked(surface, DSLF_WRITE);
+    wxCHECK_RET( locked.ptr, _T("failed to lock surface") );
+
+    CopyPixelsAndSwapRGB(image.GetWidth(), image.GetHeight(),
+                         image.GetData(), image.GetWidth() * 3,
+                         (unsigned char*)locked.ptr, locked.pitch);
+}
+
 // Creates a surface that will use wxImage's pixel data (RGB only)
 static wxIDirectFBSurfacePtr CreateSurfaceForImage(const wxImage& image)
 {
@@ -38,16 +87,16 @@ static wxIDirectFBSurfacePtr CreateSurfaceForImage(const wxImage& image)
     //            into a temporary RGBA surface
     wxCHECK_MSG( !image.HasAlpha(), NULL, _T("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
+    //     have to copy the data to temporary surface instead
     DFBSurfaceDescription desc;
     desc.flags = (DFBSurfaceDescriptionFlags)
-        (DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT |
-         DSDESC_PREALLOCATED);
+        (DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT);
     desc.caps = DSCAPS_NONE;
     desc.width = image.GetWidth();
     desc.height = image.GetHeight();
     desc.pixelformat = DSPF_RGB24;
-    desc.preallocated[0].data = image.GetData();
-    desc.preallocated[0].pitch = 3 * desc.width;
 
     return wxIDirectFB::Get()->CreateSurface(&desc);
 }
@@ -144,13 +193,24 @@ wxBitmap::wxBitmap(const wxImage& image, int depth)
         return;
 
     // then copy the image to it:
-    wxIDirectFBSurfacePtr src(CreateSurfaceForImage(image));
     wxIDirectFBSurfacePtr dst = M_BITMAP->m_surface;
 
-    if ( !dst->SetBlittingFlags(DSBLIT_NOFX) )
-        return;
-    if ( !dst->Blit(src->GetRaw(), NULL, 0, 0) )
-        return;
+    if ( dst->GetPixelFormat() == DSPF_RGB24 )
+    {
+        CopyImageToSurface(image, dst);
+    }
+    else
+    {
+        // wxBitmap uses different pixel format, so we have to use a temporary
+        // surface and blit to the bitmap via it:
+        wxIDirectFBSurfacePtr src(CreateSurfaceForImage(image));
+        CopyImageToSurface(image, src);
+
+        if ( !dst->SetBlittingFlags(DSBLIT_NOFX) )
+            return;
+        if ( !dst->Blit(src->GetRaw(), NULL, 0, 0) )
+            return;
+    }
 
     // FIXME: implement mask creation from image's mask (or alpha channel?)
     wxASSERT_MSG( !image.HasMask(), _T("image masks are ignored for now") );
@@ -161,13 +221,25 @@ wxImage wxBitmap::ConvertToImage() const
     wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
 
     wxImage img(GetWidth(), GetHeight());
-    wxIDirectFBSurfacePtr dst(CreateSurfaceForImage(img));
     wxIDirectFBSurfacePtr src = M_BITMAP->m_surface;
 
-    if ( !dst->SetBlittingFlags(DSBLIT_NOFX) )
-        return wxNullImage;
-    if ( !dst->Blit(src->GetRaw(), NULL, 0, 0) )
-        return wxNullImage;
+    if ( src->GetPixelFormat() == DSPF_RGB24 )
+    {
+        CopySurfaceToImage(src, img);
+    }
+    else
+    {
+        // wxBitmap uses different pixel format, so we have to use a temporary
+        // surface and blit to the bitmap via it:
+        wxIDirectFBSurfacePtr dst(CreateSurfaceForImage(img));
+
+        if ( !dst->SetBlittingFlags(DSBLIT_NOFX) )
+            return wxNullImage;
+        if ( !dst->Blit(src->GetRaw(), NULL, 0, 0) )
+            return wxNullImage;
+
+        CopySurfaceToImage(dst, img);
+    }
 
     // FIXME: implement mask setting in the image
     wxASSERT_MSG( GetMask() == NULL, _T("bitmap masks are ignored for now") );

src/dfb/wrapdfb.cpp

@@ -113,6 +113,13 @@ wxIDirectFBSurfacePtr wxIDirectFB::GetPrimarySurface()
 // wxIDirectFBSurface
 //-----------------------------------------------------------------------------
 
+DFBSurfacePixelFormat wxIDirectFBSurface::GetPixelFormat()
+{
+    DFBSurfacePixelFormat format = DSPF_UNKNOWN;
+    GetPixelFormat(&format);
+    return format;
+}
+
 int wxIDirectFBSurface::GetDepth()
 {
     DFBSurfacePixelFormat format = DSPF_UNKNOWN;