Fix broken draw/upload paths from videos to 2D canvas and WebGL.

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 4897 matching lines @@
                                            GLint internalformat,
                                            GLenum format,
                                            GLenum type,
                                            HTMLImageElement* image,
                                            ExceptionState& exception_state) {
   TexImageHelperHTMLImageElement(kTexImage2D, target, level, internalformat,
                                  format, type, 0, 0, 0, image,
                                  SentinelEmptyRect(), 1, 0, exception_state);
 }
 
-bool WebGLRenderingContextBase::CanUseTexImageByGPU(GLenum type) {
+bool WebGLRenderingContextBase::CanUseTexImageByGPU(GLenum format,
+                                                    GLenum type) {
 #if OS(MACOSX)
   // RGB5_A1 is not color-renderable on NVIDIA Mac, see crbug.com/676209.
   // Though, glCopyTextureCHROMIUM can handle RGB5_A1 internalformat by doing a
   // fallback path, but it doesn't know the type info. So, we still cannot do
   // the fallback path in glCopyTextureCHROMIUM for
   // RGBA/RGBA/UNSIGNED_SHORT_5_5_5_1 format and type combination.
   if (type == GL_UNSIGNED_SHORT_5_5_5_1)
     return false;
 #endif
+  // TODO(kbr): bugs were observed when using CopyTextureCHROMIUM to
+  // copy hardware-accelerated video textures to red-channel textures.
+  // These bugs were seen on macOS but may indicate more general
+  // problems. Investigate the root cause of this and fix it.
+  // crbug.com/710673
+  if (format == GL_RED || format == GL_RED_INTEGER)
+    return false;
+
+#if OS(ANDROID)
+  // TODO(kbr): bugs were seen on Android devices with NVIDIA GPUs
+  // when copying hardware-accelerated video textures to
+  // floating-point textures. Investigate the root cause of this and
+  // fix it. crbug.com/710874
+  if (type == GL_FLOAT)
+    return false;
+#endif
+
   // OES_texture_half_float doesn't support HALF_FLOAT_OES type for
   // CopyTexImage/CopyTexSubImage. And OES_texture_half_float doesn't require
   // HALF_FLOAT_OES type texture to be renderable. So, HALF_FLOAT_OES type
   // texture cannot be copied to or drawn to by glCopyTextureCHROMIUM.
   if (type == GL_HALF_FLOAT_OES)
     return false;
 
   return true;
 }
 
@@ skipping 171 matching lines @@
           func_name, function_id, canvas, source_sub_rectangle, depth,
           unpack_image_height, &selecting_sub_rectangle)) {
     return;
   }
 
   if (function_id == kTexImage2D || function_id == kTexSubImage2D) {
     // texImageByGPU relies on copyTextureCHROMIUM which doesn't support
     // float/integer/sRGB internal format.
     // TODO(crbug.com/622958): relax the constrains if copyTextureCHROMIUM is
     // upgraded to handle more formats.
-    if (!canvas->IsAccelerated() || !CanUseTexImageByGPU(type)) {
+    if (!canvas->IsAccelerated() || !CanUseTexImageByGPU(format, type)) {
       // 2D canvas has only FrontBuffer.
       TexImageImpl(function_id, target, level, internalformat, xoffset, yoffset,
                    zoffset, format, type,
                    canvas
                        ->CopiedImage(kFrontBuffer, kPreferAcceleration,
                                      FunctionIDToSnapshotReason(function_id))
                        .Get(),
                    WebGLImageConversion::kHtmlDomCanvas, unpack_flip_y_,
                    unpack_premultiply_alpha_, source_sub_rectangle, 1, 0);
       return;
@@ skipping 91 matching lines @@
   if (!ValidateTexFunc(func_name, function_type, kSourceHTMLVideoElement,
                        target, level, internalformat, video->videoWidth(),
                        video->videoHeight(), 1, 0, format, type, xoffset,
                        yoffset, zoffset))
     return;
 
   bool source_image_rect_is_default =
       source_image_rect == SentinelEmptyRect() ||
       source_image_rect ==
           IntRect(0, 0, video->videoWidth(), video->videoHeight());
-  const bool use_copyTextureCHROMIUM =
-      function_id == kTexImage2D && source_image_rect_is_default &&
-      depth == 1 && GL_TEXTURE_2D == target && CanUseTexImageByGPU(type);
+  const bool use_copyTextureCHROMIUM = function_id == kTexImage2D &&
+                                       source_image_rect_is_default &&
+                                       depth == 1 && GL_TEXTURE_2D == target &&
+                                       CanUseTexImageByGPU(format, type);
   // Format of source video may be 16-bit format, e.g. Y16 format.
   // glCopyTextureCHROMIUM requires the source texture to be in 8-bit format.
   // Converting 16-bits formated source texture to 8-bits formated texture will
   // cause precision lost. So, uploading such video texture to half float or
   // float texture can not use GPU-GPU path.
   if (use_copyTextureCHROMIUM) {
     DCHECK_EQ(xoffset, 0);
     DCHECK_EQ(yoffset, 0);
     DCHECK_EQ(zoffset, 0);
     // 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.
 
-    // Note that neither
-    // HTMLVideoElement::copyVideoTextureToPlatformTexture nor
-    // ImageBuffer::copyToPlatformTexture allocate the destination texture
-    // any more.
-    TexImage2DBase(target, level, internalformat, video->videoWidth(),
-                   video->videoHeight(), 0, format, type, nullptr);
-
-    if (video->CopyVideoTextureToPlatformTexture(ContextGL(), texture->Object(),
-                                                 unpack_premultiply_alpha_,
-                                                 unpack_flip_y_)) {
+    if (video->CopyVideoTextureToPlatformTexture(
+            ContextGL(), texture->Object(), internalformat, format, type,
+            unpack_premultiply_alpha_, unpack_flip_y_)) {
       texture->UpdateLastUploadedVideo(video->GetWebMediaPlayer());
       return;
     }
   }
 
   if (source_image_rect_is_default) {
     // 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, unpack_flip_y_ || unpack_premultiply_alpha_);
@@ skipping 23 matching lines @@
         // 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(
             image_buffer->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.
 
+        // Note that copyToPlatformTexture no longer allocates the destination
+        // texture.
+        TexImage2DBase(target, level, internalformat, video->videoWidth(),
+                       video->videoHeight(), 0, format, type, nullptr);
+
         if (image_buffer->CopyToPlatformTexture(
                 FunctionIDToSnapshotReason(function_id), ContextGL(), target,
                 texture->Object(), unpack_premultiply_alpha_, unpack_flip_y_,
                 IntPoint(0, 0),
                 IntRect(0, 0, video->videoWidth(), video->videoHeight()))) {
           texture->UpdateLastUploadedVideo(video->GetWebMediaPlayer());
           return;
         }
       }
     }
@@ skipping 76 matching lines @@
   GLsizei width = source_sub_rect.Width();
   GLsizei height = source_sub_rect.Height();
   if (!ValidateTexFunc(func_name, function_type, kSourceImageBitmap, target,
                        level, internalformat, width, height, depth, 0, format,
                        type, xoffset, yoffset, zoffset))
     return;
   ASSERT(bitmap->BitmapImage());
 
   // TODO(kbr): make this work for sub-rectangles of ImageBitmaps.
   if (function_id != kTexSubImage3D && function_id != kTexImage3D &&
-      bitmap->IsAccelerated() && CanUseTexImageByGPU(type) &&
+      bitmap->IsAccelerated() && CanUseTexImageByGPU(format, type) &&
       !selecting_sub_rectangle) {
     if (function_id == kTexImage2D) {
       TexImage2DBase(target, level, internalformat, width, height, 0, format,
                      type, 0);
       TexImageByGPU(function_id, texture, target, level, 0, 0, 0, bitmap,
                     source_sub_rect);
     } else if (function_id == kTexSubImage2D) {
       TexImageByGPU(function_id, texture, target, level, xoffset, yoffset, 0,
                     bitmap, source_sub_rect);
     }
@@ skipping 2410 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(offscreenCanvas());
 }
 
 }  // namespace blink