O2D: Fix graphical artifacting with transparent images caused by using non-pr...

core/cross/cairo/texture_cairo.cc

 /*
- * Copyright 2010, Google Inc.
+ * Copyright 2011, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
  * copyright notice, this list of conditions and the following disclaimer
@@ skipping 14 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 
 // Implementations of the abstract Texture2D.
 // Texture Class for handling Cairo Rendering Mode.
 
 #include "core/cross/cairo/texture_cairo.h"
+
+#include <string.h>
+
 #include "core/cross/cairo/renderer_cairo.h"
 
 namespace o3d {
 
 namespace {
 
 Texture::RGBASwizzleIndices g_gl_abgr32f_swizzle_indices = {0, 1, 2, 3};
 
 }  // anonymous namespace.
 
 namespace o2d {
 
 static int CairoFormatFromO3DFormat(
     Texture::Format format) {
   switch (format) {
     case Texture::ARGB8:
       return CAIRO_FORMAT_ARGB32;
     case Texture::XRGB8:
       return CAIRO_FORMAT_RGB24;
     default:
       return -1;
   }
   // Cairo also supports two other pure-alpha formats, but we don't expose those
   // capabilities.
 }
 
 TextureCairo::TextureCairo(ServiceLocator* service_locator,
                            cairo_surface_t* image_surface,
-                           cairo_t* image_surface_context,
                            Texture::Format format,
                            int levels,
                            int width,
                            int height,
                            bool enable_render_surfaces)
     : Texture2D(service_locator,
                 width,
                 height,
                 format,
                 levels,
                 enable_render_surfaces),
       renderer_(static_cast<RendererCairo*>(
           service_locator->GetService<Renderer>())),
-      image_surface_(image_surface),
-      image_surface_context_(image_surface_context) {
+      image_surface_(image_surface) {
   DLOG(INFO) << "Texture2D Construct";
   DCHECK_NE(format, Texture::UNKNOWN_FORMAT);
 }
 
 // Creates a new texture object from scratch.
 TextureCairo* TextureCairo::Create(ServiceLocator* service_locator,
                                    Texture::Format format,
                                    int levels,
                                    int width,
                                    int height,
                                    bool enable_render_surfaces) {
   int cairo_format = CairoFormatFromO3DFormat(format);
   cairo_surface_t* image_surface;
-  cairo_t* image_surface_context;
   cairo_status_t status;
   if (-1 == cairo_format) {
     DLOG(ERROR) << "Texture format " << format << " not supported by Cairo";
     goto fail0;
   }
   image_surface = cairo_image_surface_create(
       static_cast<cairo_format_t>(cairo_format),
       width,
       height);
   status = cairo_surface_status(image_surface);
   if (CAIRO_STATUS_SUCCESS != status) {
     DLOG(ERROR) << "Error creating Cairo image surface: " << status;
     goto fail1;
   }
-  image_surface_context = cairo_create(image_surface);
-  status = cairo_status(image_surface_context);
-  if (CAIRO_STATUS_SUCCESS != status) {
-    DLOG(ERROR) << "Error creating Cairo image surface draw context: "
-                << status;
-    goto fail2;
-  }
-
-  cairo_set_operator(image_surface_context, CAIRO_OPERATOR_SOURCE);
 
   return new TextureCairo(service_locator,
                           image_surface,
-                          image_surface_context,
                           format,
                           levels,
                           width,
                           height,
                           enable_render_surfaces);
 
- fail2:
-  cairo_destroy(image_surface_context);
  fail1:
   cairo_surface_destroy(image_surface);
  fail0:
   return NULL;
 }
 
 // In 2D: is not really used
 const Texture::RGBASwizzleIndices& TextureCairo::GetABGR32FSwizzleIndices() {
   NOTIMPLEMENTED();
   return g_gl_abgr32f_swizzle_indices;
 }
 
 TextureCairo::~TextureCairo() {
-  cairo_destroy(image_surface_context_);
   cairo_surface_destroy(image_surface_);
   renderer_ = NULL;
   DLOG(INFO) << "Texture2DCairo Destruct";
 }
 
 // Set the image data to the renderer
 void TextureCairo::SetRect(int level,
                            unsigned dst_left,
                            unsigned dst_top,
                            unsigned src_width,
                            unsigned src_height,
-                           const void* src_data,
+                           const void* src_data_void,
                            int src_pitch) {
   DLOG(INFO) << "Texture2DCairo SetRect";
 
   if (0 != level) {
     // Cairo does not support/need mip-maps.
     return;
   }
 
-  // Create image surface to represent the source.
-  cairo_surface_t* source_image_surface = cairo_image_surface_create_for_data(
-      const_cast<unsigned char*>(
-          static_cast<const unsigned char*>(src_data)),
-      cairo_image_surface_get_format(image_surface_),
-      src_width,
-      src_height,
-      src_pitch);
+  cairo_surface_flush(image_surface_);
 
-  // Set that surface as the source for paint operations to our texture.
-  cairo_set_source_surface(image_surface_context_,
-                           source_image_surface,
-                           dst_left,
-                           dst_top);
+  const unsigned char* src_data = reinterpret_cast<const unsigned char*>(
+      src_data_void);
 
-  // Paint to the texture. This copies the data.
-  cairo_paint(image_surface_context_);
+  unsigned char* dst_data = cairo_image_surface_get_data(image_surface_);
 
-  // Discard our reference to the source surface.
-  cairo_surface_destroy(source_image_surface);
+  int dst_pitch = cairo_image_surface_get_stride(image_surface_);
+
+  dst_data += dst_top * dst_pitch + dst_left * 4;
+  
+  if (ARGB8 == format()) {
+    // Cairo supports only premultiplied alpha, but we get the images as
+    // non-premultiplied alpha, so we have to convert.
+    for (unsigned i = 0; i < src_height; ++i) {
+      for (unsigned j = 0; j < src_width; ++j) {
+        // NOTE: This assumes a little-endian anchitecture (e.g., x86).

[fbarchard, 2011/01/26 00:32:48]

This works for RGBA or BGRA where alpha is in byte 3

[Tristan Schmelcher 2, 2011/01/26 01:12:02]

Done.

+        // Get alpha.
+        uint8 alpha = src_data[3];
+        // Convert each colour.
+        for (int i = 0; i < 3; i++) {
+          dst_data[i] = (src_data[i] * alpha + 128U) / 255U;

[fbarchard, 2011/01/25 23:19:22]

unroll loop
 dst_data[0] = (src_data[0] * alpha + 128U) / 255U;
 dst_data[1] = (src_data[1] * alpha + 128U) / 255U;
 dst_data[2] = (src_data[2] * alpha + 128U) / 255U;
add check for alpha = 0 or 255
if (alpha == 0 || alpha == 255)
 dst_data[0] = src_data[0];
 dst_data[1] = src_data[1];
 dst_data[2] = src_data[2];
else...
FYI for write combining to work, order of writes is important and you should not
mix sizes.
FYI looks like /255 is implemented as multiply.

+        }
+        // Copy alpha.
+        dst_data[3] = alpha;
+        src_data += 4;
+        dst_data += 4;
+      }
+      src_data += src_pitch - src_width * 4;
+      dst_data += dst_pitch - src_width * 4;
+    }
+  } else {
+    // Just copy the data.
+    for (unsigned i = 0; i < src_height; ++i) {
+      memcpy(dst_data, src_data, src_width * 4);
+      src_data += src_pitch;
+      dst_data += dst_pitch;
+    }
+  }
+
+  cairo_surface_mark_dirty(image_surface_);
 
   TextureUpdated();
 }
 
 // Locks the given mipmap level of this texture for loading from main memory,
 // and returns a pointer to the buffer.
 bool TextureCairo::PlatformSpecificLock(
     int level, void** data, int* pitch, Texture::AccessMode mode) {
   NOTIMPLEMENTED();
   return true;
@@ skipping 18 matching lines @@
 
 // Returns the implementation-specific texture handle for this texture.
 void* TextureCairo::GetTextureHandle() const {
   NOTIMPLEMENTED();
   return reinterpret_cast<void*>(NULL);
 }
 
 }  // namespace o2d
 
 }  // namespace o3d