16 bpp video stream capture, render and WebGL usage - Realsense R200 & SR300 support.

third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.cpp

 /*
  * Copyright (C) 2009 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 496 matching lines @@
 
     ~ScopedFramebufferRestorer()
     {
         m_context->restoreCurrentFramebuffer();
     }
 
 private:
     Member<WebGLRenderingContextBase> m_context;
 };
 
+class ScopedUnpackParametersResetRestore {
+    STACK_ALLOCATED();
+
+public:
+    explicit ScopedUnpackParametersResetRestore(WebGLRenderingContextBase* context, bool enabled = true)
+        : m_context(context)
+        , m_enabled(enabled)
+    {
+        if (enabled)
+            m_context->resetUnpackParameters();
+    }
+
+    ~ScopedUnpackParametersResetRestore()
+    {
+        if (m_enabled)
+            m_context->restoreUnpackParameters();
+    }
+
+private:
+    Member<WebGLRenderingContextBase> m_context;
+    bool m_enabled;
+};
+
 static void formatWebGLStatusString(const String& glInfo, const String& infostring, String& statusMessage)
 {
     if (!infostring.isEmpty())
         statusMessage.append(", " + glInfo + " = " + infostring);
 }
 
 static String extractWebGLContextCreationError(const Platform::GraphicsInfo& info)
 {
     String statusMessage("Could not create a WebGL context");
     formatWebGLStatusString("VENDOR", info.vendorId ? String::format("0x%04x", info.vendorId).utf8().data() : "0xffff", statusMessage);
@@ skipping 3490 matching lines @@
     bool needConversion = true;
     if (type == GL_UNSIGNED_BYTE && sourceDataFormat == WebGLImageConversion::DataFormatRGBA8 && format == GL_RGBA && alphaOp == WebGLImageConversion::AlphaDoNothing && !flipY) {
         needConversion = false;
     } else {
         if (!WebGLImageConversion::packImageData(image, imagePixelData, format, type, flipY, alphaOp, sourceDataFormat, imageExtractor.imageWidth(), imageExtractor.imageHeight(), imageExtractor.imageSourceUnpackAlignment(), data)) {
             synthesizeGLError(GL_INVALID_VALUE, funcName, "packImage error");
             return;
         }
     }
 
-    resetUnpackParameters();
+    ScopedUnpackParametersResetRestore temporaryResetUnpack(this);
     if (functionID == TexImage2D) {
         texImage2DBase(target, level, internalformat, imageExtractor.imageWidth(), imageExtractor.imageHeight(), 0, format, type, needConversion ? data.data() : imagePixelData);
     } else if (functionID == TexSubImage2D) {
         contextGL()->TexSubImage2D(target, level, xoffset, yoffset, imageExtractor.imageWidth(), imageExtractor.imageHeight(), format, type,  needConversion ? data.data() : imagePixelData);
     } else {
         DCHECK_EQ(functionID, TexSubImage3D);
         contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset, imageExtractor.imageWidth(), imageExtractor.imageHeight(), 1, format, type, needConversion ? data.data() : imagePixelData);
     }
-    restoreUnpackParameters();
 }
 
 bool WebGLRenderingContextBase::validateTexFunc(const char* functionName, TexImageFunctionType functionType, TexFuncValidationSourceType sourceType, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, GLint xoffset, GLint yoffset, GLint zoffset)
 {
     if (!validateTexFuncLevel(functionName, target, level))
         return false;
 
     if (!validateTexFuncParameters(functionName, functionType, target, level, internalformat, width, height, depth, border, format, type))
         return false;
 
@@ skipping 121 matching lines @@
     // FIXME: implement flipY and premultiplyAlpha for tex(Sub)3D.
     if (functionID == TexImage3D) {
         contextGL()->TexImage3D(target, level, convertTexInternalFormat(internalformat, type), width, height, depth, border, format, type, data);
         return;
     }
     if (functionID == TexSubImage3D) {
         contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
         return;
     }
 
-    if (changeUnpackAlignment)
-        resetUnpackParameters();
+    ScopedUnpackParametersResetRestore temporaryResetUnpack(this, changeUnpackAlignment);
     if (functionID == TexImage2D)
         texImage2DBase(target, level, internalformat, width, height, border, format, type, data);
     else if (functionID == TexSubImage2D)
         contextGL()->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, data);
-    if (changeUnpackAlignment)
-        restoreUnpackParameters();
 }
 
 void WebGLRenderingContextBase::texImage2D(GLenum target, GLint level, GLint internalformat,
     GLsizei width, GLsizei height, GLint border,
     GLenum format, GLenum type, DOMArrayBufferView* pixels)
 {
     texImageHelperDOMArrayBufferView(TexImage2D, target, level, internalformat, width, height, border, format, type, 1, 0, 0, 0, pixels);
 }
 
 void WebGLRenderingContextBase::texImageHelperImageData(TexImageFunctionID functionID,
@@ skipping 29 matching lines @@
     } else {
         if (type == GL_UNSIGNED_INT_10F_11F_11F_REV) {
             // The UNSIGNED_INT_10F_11F_11F_REV type pack/unpack isn't implemented.
             type = GL_FLOAT;
         }
         if (!WebGLImageConversion::extractImageData(pixels->data()->data(), WebGLImageConversion::DataFormat::DataFormatRGBA8, pixels->size(), format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {
             synthesizeGLError(GL_INVALID_VALUE, funcName, "bad image data");
             return;
         }
     }
-    resetUnpackParameters();
+    ScopedUnpackParametersResetRestore temporaryResetUnpack(this);
     if (functionID == TexImage2D) {
         texImage2DBase(target, level, internalformat, pixels->width(), pixels->height(), border, format, type, needConversion ? data.data() : pixels->data()->data());
     } else if (functionID == TexSubImage2D) {
         contextGL()->TexSubImage2D(target, level, xoffset, yoffset, pixels->width(), pixels->height(), format, type, needConversion ? data.data() : pixels->data()->data());
     } else {
         DCHECK_EQ(functionID, TexSubImage3D);
         contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset, pixels->width(), pixels->height(), depth, format, type, needConversion ? data.data() : pixels->data()->data());
     }
-    restoreUnpackParameters();
 }
 
 void WebGLRenderingContextBase::texImage2D(GLenum target, GLint level, GLint internalformat,
     GLenum format, GLenum type, ImageData* pixels)
 {
     texImageHelperImageData(TexImage2D, target, level, internalformat, 0, format, type, 1, 0, 0, 0, pixels);
 }
 
 void WebGLRenderingContextBase::texImageHelperHTMLImageElement(TexImageFunctionID functionID,
     GLenum target, GLint level, GLint internalformat, GLenum format, GLenum type, GLint xoffset,
@@ skipping 217 matching lines @@
                     // This is a straight GPU-GPU copy, any necessary color space conversion was handled in the paintCurrentFrameInContext() call.
                     if (imageBuffer->copyToPlatformTexture(contextGL(), texture->object(), internalformat, type,
                         level, m_unpackPremultiplyAlpha, m_unpackFlipY)) {
                         return;
                     }
                 }
             }
         }
     }
 
+    {
+        ScopedUnpackParametersResetRestore(this, m_unpackFlipY || m_unpackPremultiplyAlpha);
+        if (video->texImageImpl(getTexImageFunctionName(functionID), target, contextGL(), level, internalformat, format, type, xoffset, yoffset, zoffset,
+            m_unpackFlipY, m_unpackPremultiplyAlpha && m_unpackColorspaceConversion == GL_NONE))
+            return;
+    }
+
     RefPtr<Image> image = videoFrameToImage(video);
     if (!image)
         return;
     texImageImpl(functionID, target, level, internalformat, xoffset, yoffset, zoffset, format, type, image.get(), WebGLImageConversion::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha);
 }
 
 void WebGLRenderingContextBase::texImageBitmapByGPU(ImageBitmap* bitmap, GLuint targetTexture, GLenum targetInternalformat, GLenum targetType, GLint targetLevel, bool flipY)
 {
     bitmap->bitmapImage()->copyToTexture(drawingBuffer()->contextProvider(), targetTexture, targetInternalformat, targetType, flipY);
 }
@@ skipping 60 matching lines @@
             type = GL_FLOAT;
         }
         // In the case of ImageBitmap, we do not need to apply flipY or premultiplyAlpha.
         bool isPixelDataBGRA = pixmap.colorType() == SkColorType::kBGRA_8888_SkColorType;
         if ((isPixelDataBGRA && !WebGLImageConversion::extractImageData(pixelDataPtr, WebGLImageConversion::DataFormat::DataFormatBGRA8, bitmap->size(), format, type, false, false, data))
             || (isPixelDataRGBA && !WebGLImageConversion::extractImageData(pixelDataPtr, WebGLImageConversion::DataFormat::DataFormatRGBA8, bitmap->size(), format, type, false, false, data))) {
             synthesizeGLError(GL_INVALID_VALUE, funcName, "bad image data");
             return;
         }
     }
-    resetUnpackParameters();
+    ScopedUnpackParametersResetRestore temporaryResetUnpack(this);
     if (functionID == TexImage2D) {
         texImage2DBase(target, level, internalformat, bitmap->width(), bitmap->height(), 0, format, type, needConversion ? data.data() : pixelDataPtr);
     } else if (functionID == TexSubImage2D) {
         contextGL()->TexSubImage2D(target, level, xoffset, yoffset, bitmap->width(), bitmap->height(), format, type, needConversion ? data.data() : pixelDataPtr);
     } else {
         DCHECK_EQ(functionID, TexSubImage3D);
         contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset, bitmap->width(), bitmap->height(), 1, format, type, needConversion ? data.data() : pixelDataPtr);
     }
-    restoreUnpackParameters();
 }
 
 void WebGLRenderingContextBase::texImage2D(GLenum target, GLint level, GLint internalformat,
     GLenum format, GLenum type, ImageBitmap* bitmap, ExceptionState& exceptionState)
 {
     texImageHelperImageBitmap(TexImage2D, target, level, internalformat, format, type, 0, 0, 0, bitmap, exceptionState);
 }
 
 void WebGLRenderingContextBase::texParameter(GLenum target, GLenum pname, GLfloat paramf, GLint parami, bool isFloat)
 {
@@ skipping 1901 matching lines @@
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
 }
 
 void WebGLRenderingContextBase::restoreUnpackParameters()
 {
     if (m_unpackAlignment != 1)
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 } // namespace blink