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 497 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 StringView& glInfo, const StringView& infoString, StringBuilder& builder)
 {
     if (infoString.isEmpty())
         return;
     builder.append(", ");
     builder.append(glInfo);
     builder.append(" = ");
     builder.append(infoString);
 }
 
@@ skipping 3503 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 35 matching lines @@
     // TODO(crbug.com/622958): Implement GPU-to-GPU path for WebGL 2 and more internal formats.
     if (functionID == TexSubImage2D && (isWebGL2OrHigher() || extensionEnabled(OESTextureFloatName) || extensionEnabled(OESTextureHalfFloatName) || extensionEnabled(EXTsRGBName)))
         return false;
     return true;
 }
 
 void WebGLRenderingContextBase::texImageCanvasByGPU(HTMLCanvasElement* canvas, GLuint targetTexture, GLenum targetInternalformat, GLenum targetType, GLint targetLevel)
 {
     if (!canvas->is3D()) {
         ImageBuffer* buffer = canvas->buffer();
-        if (!buffer->copyToPlatformTexture(contextGL(), targetTexture, targetInternalformat, targetType,
-            targetLevel, m_unpackPremultiplyAlpha, m_unpackFlipY)) {
+        if (extensionsUtil()->canUseCopyTextureCHROMIUM(targetTexture, targetInternalformat, targetType, targetLevel) && !buffer->copyToPlatformTexture(contextGL(), targetTexture, targetInternalformat, targetType, targetLevel, m_unpackPremultiplyAlpha, m_unpackFlipY)) {
             NOTREACHED();
         }
     } else {
         WebGLRenderingContextBase* gl = toWebGLRenderingContextBase(canvas->renderingContext());
         ScopedTexture2DRestorer restorer(gl);
         if (!gl->drawingBuffer()->copyToPlatformTexture(contextGL(), targetTexture, targetInternalformat, targetType,
             targetLevel, m_unpackPremultiplyAlpha, !m_unpackFlipY, BackBuffer)) {
             NOTREACHED();
         }
     }
 }
 
 void WebGLRenderingContextBase::texImageByGPU(TexImageByGPUType functionType, WebGLTexture* texture, GLenum target,
     GLint level, GLint internalformat, GLenum type, GLint xoffset, GLint yoffset, GLint zoffset, CanvasImageSource* image)
 {
     DCHECK(image->isCanvasElement() || image->isImageBitmap());
     int width = image->sourceWidth();
     int height = image->sourceHeight();
 
     ScopedTexture2DRestorer restorer(this);
 
     GLuint targetTexture = texture->object();
     GLenum targetType = type;
     GLenum targetInternalformat = internalformat;
     GLint targetLevel = level;
     bool possibleDirectCopy = false;
     if (functionType == TexImage2DByGPU) {
-        possibleDirectCopy = Extensions3DUtil::canUseCopyTextureCHROMIUM(target, internalformat, type, level);
+        possibleDirectCopy = extensionsUtil()->canUseCopyTextureCHROMIUM(target, internalformat, type, level);
     }
 
     // if direct copy is not possible, create a temporary texture and then copy from canvas to temporary texture to target texture.
     if (!possibleDirectCopy) {
         targetLevel = 0;
         targetInternalformat = GL_RGBA;
         targetType = GL_UNSIGNED_BYTE;
         contextGL()->GenTextures(1, &targetTexture);
         contextGL()->BindTexture(GL_TEXTURE_2D, targetTexture);
         contextGL()->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
@@ skipping 103 matching lines @@
     if (!texture)
         return;
     TexImageFunctionType functionType;
     if (functionID == TexImage2D)
         functionType = TexImage;
     else
         functionType = TexSubImage;
     if (!validateTexFunc(funcName, functionType, SourceHTMLVideoElement, target, level, internalformat, video->videoWidth(), video->videoHeight(), 1, 0, format, type, xoffset, yoffset, zoffset))
         return;
 
-    if (functionID == TexImage2D) {
+    if (functionID == TexImage2D && GL_TEXTURE_2D == target && extensionsUtil()->canUseCopyTextureCHROMIUM(target, internalformat, type, level)) {
         // Go through the fast path doing a GPU-GPU textures copy without a readback to system memory if possible.
         // Otherwise, it will fall back to the normal SW path.
-        if (GL_TEXTURE_2D == target) {
-            if (Extensions3DUtil::canUseCopyTextureCHROMIUM(target, internalformat, type, level)
-                && video->copyVideoTextureToPlatformTexture(contextGL(), texture->object(), internalformat, type, m_unpackPremultiplyAlpha, m_unpackFlipY)) {
-                return;
-            }
+        if (video->copyVideoTextureToPlatformTexture(contextGL(), texture->object(), internalformat, type, m_unpackPremultiplyAlpha, m_unpackFlipY)) {
+            return;
+        }
+    }
 
-            // Try using an accelerated image buffer, this allows YUV conversion to be done on the GPU.
-            std::unique_ptr<ImageBufferSurface> surface = wrapUnique(new AcceleratedImageBufferSurface(IntSize(video->videoWidth(), video->videoHeight())));
-            if (surface->isValid()) {
-                std::unique_ptr<ImageBuffer> imageBuffer(ImageBuffer::create(std::move(surface)));
-                if (imageBuffer) {
-                    // The video element paints an RGBA frame into our surface here. By using an AcceleratedImageBufferSurface,
-                    // we enable the WebMediaPlayer implementation to do any necessary color space conversion on the GPU (though it
-                    // may still do a CPU conversion and upload the results).
-                    video->paintCurrentFrame(imageBuffer->canvas(), IntRect(0, 0, video->videoWidth(), video->videoHeight()), nullptr);
+    {
+        // Try using optimized CPU-GPU path for some formats: e.g. Y16 and Y8. It leaves early for other formats or if frame is stored on GPU.
+        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;
+    }
 
-                    // 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,
+    if (functionID == TexImage2D && GL_TEXTURE_2D == target && extensionsUtil()->canUseCopyTextureCHROMIUM(target, internalformat, type, level)) {
+        // Try using an accelerated image buffer, this allows YUV conversion to be done on the GPU.
+        std::unique_ptr<ImageBufferSurface> surface = wrapUnique(new AcceleratedImageBufferSurface(IntSize(video->videoWidth(), video->videoHeight())));
+        if (surface->isValid()) {
+            std::unique_ptr<ImageBuffer> imageBuffer(ImageBuffer::create(std::move(surface)));
+            if (imageBuffer) {
+                // The video element paints an RGBA frame into our surface here. By using an AcceleratedImageBufferSurface,
+                // we enable the WebMediaPlayer implementation to do any necessary color space conversion on the GPU (though it
+                // may still do a CPU conversion and upload the results).
+                video->paintCurrentFrame(imageBuffer->canvas(), IntRect(0, 0, video->videoWidth(), video->videoHeight()), nullptr);
+
+                // 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;
-                    }
+                    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);
 }
@@ skipping 64 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 1909 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(HTMLCanvasElementOrOffscreenCanvas& result) const
 {
     if (canvas())
         result.setHTMLCanvasElement(canvas());
     else
         result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 } // namespace blink