Allow DrawingBuffer to present to a bitmap.

Source/core/platform/graphics/GraphicsContext3D.cpp

 /*
  * Copyright (C) 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2010 Mozilla Corporation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 69 matching lines @@
 }
 
 } // anonymous namespace
 
 GraphicsContext3D::GraphicsContext3D(PassOwnPtr<WebKit::WebGraphicsContext3D> webContext, bool preserveDrawingBuffer)
     : m_impl(webContext.get())
     , m_ownedWebContext(webContext)
     , m_initializedAvailableExtensions(false)
     , m_layerComposited(false)
     , m_preserveDrawingBuffer(preserveDrawingBuffer)
+    , m_packAlignment(4)
     , m_resourceSafety(ResourceSafetyUnknown)
     , m_grContext(0)
 {
 }
 
 GraphicsContext3D::GraphicsContext3D(PassOwnPtr<WebKit::WebGraphicsContext3DProvider> provider, bool preserveDrawingBuffer)
     : m_provider(provider)
     , m_impl(m_provider->context3d())
     , m_initializedAvailableExtensions(false)
     , m_layerComposited(false)
     , m_preserveDrawingBuffer(preserveDrawingBuffer)
+    , m_packAlignment(4)
     , m_resourceSafety(ResourceSafetyUnknown)
     , m_grContext(m_provider->grContext())
 {
 }
 
 GraphicsContext3D::~GraphicsContext3D()
 {
     setContextLostCallback(nullptr);
     setErrorMessageCallback(nullptr);
 
@@ skipping 382 matching lines @@
 DELEGATE_TO_WEBCONTEXT_2(hint, GC3Denum, GC3Denum)
 DELEGATE_TO_WEBCONTEXT_1R(isBuffer, Platform3DObject, GC3Dboolean)
 DELEGATE_TO_WEBCONTEXT_1R(isEnabled, GC3Denum, GC3Dboolean)
 DELEGATE_TO_WEBCONTEXT_1R(isFramebuffer, Platform3DObject, GC3Dboolean)
 DELEGATE_TO_WEBCONTEXT_1R(isProgram, Platform3DObject, GC3Dboolean)
 DELEGATE_TO_WEBCONTEXT_1R(isRenderbuffer, Platform3DObject, GC3Dboolean)
 DELEGATE_TO_WEBCONTEXT_1R(isShader, Platform3DObject, GC3Dboolean)
 DELEGATE_TO_WEBCONTEXT_1R(isTexture, Platform3DObject, GC3Dboolean)
 DELEGATE_TO_WEBCONTEXT_1(lineWidth, GC3Dfloat)
 DELEGATE_TO_WEBCONTEXT_1(linkProgram, Platform3DObject)
-DELEGATE_TO_WEBCONTEXT_2(pixelStorei, GC3Denum, GC3Dint)
+
+void GraphicsContext3D::pixelStorei(GC3Denum pname, GC3Dint param)
+{
+    if (pname == PACK_ALIGNMENT)
+        m_packAlignment = param;
+    m_impl->pixelStorei(pname, param);
+}
+
 DELEGATE_TO_WEBCONTEXT_2(polygonOffset, GC3Dfloat, GC3Dfloat)
 
 DELEGATE_TO_WEBCONTEXT_7(readPixels, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Denum, GC3Denum, void*)
 
 DELEGATE_TO_WEBCONTEXT(releaseShaderCompiler)
 DELEGATE_TO_WEBCONTEXT_4(renderbufferStorage, GC3Denum, GC3Denum, GC3Dsizei, GC3Dsizei)
 DELEGATE_TO_WEBCONTEXT_2(sampleCoverage, GC3Dclampf, GC3Dboolean)
 DELEGATE_TO_WEBCONTEXT_4(scissor, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei)
 
 void GraphicsContext3D::shaderSource(Platform3DObject shader, const String& string)
@@ skipping 83 matching lines @@
 {
     if (getContextAttributes().premultipliedAlpha)
         return 0;
 
     Platform3DObject framebufferId;
     int width, height;
     getDrawingParameters(drawingBuffer, m_impl, &framebufferId, &width, &height);
 
     RefPtr<ImageData> imageData = ImageData::create(IntSize(width, height));
     unsigned char* pixels = imageData->data()->data();
-    size_t bufferSize = 4 * width * height;
 
-    m_impl->readBackFramebuffer(pixels, bufferSize, framebufferId, width, height);
-
-#if (SK_R32_SHIFT == 16) && !SK_B32_SHIFT
-    // If the implementation swapped the red and blue channels, un-swap them.
-    for (size_t i = 0; i < bufferSize; i += 4)
-        std::swap(pixels[i], pixels[i + 2]);
-#endif
+    m_impl->bindFramebuffer(FRAMEBUFFER, framebufferId);
+    readBackFramebuffer(pixels, width, height, ReadbackRGBA, AlphaDoNothing);
+    flipVertically(pixels, width, height);
 
     return imageData.release();
 }
 
+void GraphicsContext3D::readBackFramebuffer(unsigned char* pixels, int width, int height, ReadbackOrder readbackOrder, AlphaOp op)
+{
+    if (m_packAlignment > 4)
+        m_impl->pixelStorei(PACK_ALIGNMENT, 1);
+    m_impl->readPixels(0, 0, width, height, RGBA, UNSIGNED_BYTE, pixels);
+    if (m_packAlignment > 4)
+        m_impl->pixelStorei(PACK_ALIGNMENT, m_packAlignment);
+
+    size_t bufferSize = 4 * width * height;
+
+    if (readbackOrder == ReadbackSkia) {
+#if (SK_R32_SHIFT == 16) && !SK_B32_SHIFT
+        // Swizzle red and blue channels to match SkBitmap's byte ordering.
+        // TODO(kbr): expose GL_BGRA as extension.
+        for (size_t i = 0; i < bufferSize; i += 4) {
+            std::swap(pixels[i], pixels[i + 2]);
+        }
+#endif
+    }
+
+    if (op == AlphaDoPremultiply) {
+        for (size_t i = 0; i < bufferSize; i += 4) {
+            pixels[i + 0] = std::min(255, pixels[i + 0] * pixels[i + 3] / 255);
+            pixels[i + 1] = std::min(255, pixels[i + 1] * pixels[i + 3] / 255);
+            pixels[i + 2] = std::min(255, pixels[i + 2] * pixels[i + 3] / 255);
+        }
+    } else if (op != AlphaDoNothing) {
+        ASSERT_NOT_REACHED();
+    }
+}
+
 DELEGATE_TO_WEBCONTEXT_R(createBuffer, Platform3DObject)
 DELEGATE_TO_WEBCONTEXT_R(createFramebuffer, Platform3DObject)
 DELEGATE_TO_WEBCONTEXT_R(createProgram, Platform3DObject)
 DELEGATE_TO_WEBCONTEXT_R(createRenderbuffer, Platform3DObject)
 DELEGATE_TO_WEBCONTEXT_1R(createShader, GC3Denum, Platform3DObject)
 DELEGATE_TO_WEBCONTEXT_R(createTexture, Platform3DObject)
 
 DELEGATE_TO_WEBCONTEXT_1(deleteBuffer, Platform3DObject)
 DELEGATE_TO_WEBCONTEXT_1(deleteFramebuffer, Platform3DObject)
 DELEGATE_TO_WEBCONTEXT_1(deleteProgram, Platform3DObject)
@@ skipping 253 matching lines @@
     case GraphicsContext3D::DEPTH_STENCIL:
         return ChannelDepth | ChannelStencil;
     default:
         return 0;
     }
 }
 
 void GraphicsContext3D::paintFramebufferToCanvas(int framebuffer, int width, int height, bool premultiplyAlpha, ImageBuffer* imageBuffer)
 {
     unsigned char* pixels = 0;
-    size_t bufferSize = 4 * width * height;
 
     const SkBitmap* canvasBitmap = imageBuffer->context()->bitmap();
     const SkBitmap* readbackBitmap = 0;
     ASSERT(canvasBitmap->config() == SkBitmap::kARGB_8888_Config);
     if (canvasBitmap->width() == width && canvasBitmap->height() == height) {
         // This is the fastest and most common case. We read back
         // directly into the canvas's backing store.
         readbackBitmap = canvasBitmap;
         m_resizingBitmap.reset();
     } else {
         // We need to allocate a temporary bitmap for reading back the
         // pixel data. We will then use Skia to rescale this bitmap to
         // the size of the canvas's backing store.
         if (m_resizingBitmap.width() != width || m_resizingBitmap.height() != height) {
             m_resizingBitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
             if (!m_resizingBitmap.allocPixels())
                 return;
         }
         readbackBitmap = &m_resizingBitmap;
     }
 
     // Read back the frame buffer.
     SkAutoLockPixels bitmapLock(*readbackBitmap);
     pixels = static_cast<unsigned char*>(readbackBitmap->getPixels());
 
-    m_impl->readBackFramebuffer(pixels, 4 * width * height, framebuffer, width, height);
-
-    if (premultiplyAlpha) {
-        for (size_t i = 0; i < bufferSize; i += 4) {
-            pixels[i + 0] = std::min(255, pixels[i + 0] * pixels[i + 3] / 255);
-            pixels[i + 1] = std::min(255, pixels[i + 1] * pixels[i + 3] / 255);
-            pixels[i + 2] = std::min(255, pixels[i + 2] * pixels[i + 3] / 255);
-        }
-    }
+    m_impl->bindFramebuffer(FRAMEBUFFER, framebuffer);
+    readBackFramebuffer(pixels, width, height, ReadbackSkia, premultiplyAlpha ? AlphaDoPremultiply : AlphaDoNothing);
+    flipVertically(pixels, width, height);
 
     readbackBitmap->notifyPixelsChanged();
     if (m_resizingBitmap.readyToDraw()) {
         // We need to draw the resizing bitmap into the canvas's backing store.
         SkCanvas canvas(*canvasBitmap);
         SkRect dst;
         dst.set(SkIntToScalar(0), SkIntToScalar(0), SkIntToScalar(canvasBitmap->width()), SkIntToScalar(canvasBitmap->height()));
         canvas.drawBitmapRect(m_resizingBitmap, 0, dst);
     }
 }
@@ skipping 64 matching lines @@
     return m_enabledExtensions.contains(mappedName);
 }
 
 bool GraphicsContext3D::isExtensionEnabled(const String& name)
 {
     initializeExtensions();
     String mappedName = mapExtensionName(name);
     return m_enabledExtensions.contains(mappedName);
 }
 
+void GraphicsContext3D::flipVertically(uint8_t* framebuffer, int width, int height)
+{
+    m_scanline.resize(width * 4);
+    uint8* scanline = &m_scanline[0];
+    unsigned rowBytes = width * 4;
+    unsigned count = height / 2;
+    for (unsigned i = 0; i < count; i++) {
+        uint8* rowA = framebuffer + i * rowBytes;
+        uint8* rowB = framebuffer + (height - i - 1) * rowBytes;
+        memcpy(scanline, rowB, rowBytes);
+        memcpy(rowB, rowA, rowBytes);
+        memcpy(rowA, scanline, rowBytes);
+    }
+}
+
 } // namespace WebCore