WebGL & 16-bit video stream: upload to FLOAT texture.

content/renderer/media/webmediaplayer_ms.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/webmediaplayer_ms.h"
 
 #include <stddef.h>
 #include <limits>
 #include <string>
 #include <utility>
@@ skipping 582 matching lines @@
   // GPU Process crashed.
   if (!provider)
     return false;
   context_3d = media::Context3D(provider->ContextGL(), provider->GrContext());
   DCHECK(context_3d.gl);
   return video_renderer_.CopyVideoFrameTexturesToGLTexture(
       context_3d, gl, video_frame.get(), texture, internal_format, type,
       premultiply_alpha, flip_y);
 }
 
+bool WebMediaPlayerMS::texImageImpl(TexImageFunctionID functionID,
+                                    unsigned target,
+                                    gpu::gles2::GLES2Interface* gl,
+                                    int level,
+                                    int internalformat,
+                                    unsigned format,
+                                    unsigned type,
+                                    int xoffset,
+                                    int yoffset,
+                                    int zoffset,
+                                    bool flip_y,
+                                    bool premultiply_alpha) {
+  TRACE_EVENT0("media", "WebMediaPlayerMS:texImageImpl");
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  const scoped_refptr<media::VideoFrame> video_frame =
+      compositor_->GetCurrentFrameWithoutUpdatingStatistics();
+  if (!video_frame || !video_frame->IsMappable() ||
+      video_frame->HasTextures() ||
+      media::VideoFrame::NumPlanes(video_frame->format()) != 1) {

[emircan, 2016/12/01 23:23:37]

Should you just check for PIXEL_FORMAT_Y16 format here? There are 9 formats that
have single plane.
https://cs.chromium.org/chromium/src/media/base/video_frame.cc?rcl=0&l=503

[aleksandar.stojiljkovic, 2016/12/02 20:23:41]

Done.
The idea is to use this to optimize for Y8 too, and maybe other. In follow up
patches, plan to add more code to SkCanvasVideoRenderer::Tex(Sub)Image2D/3D
methods. This code is already prototyped at crrev.com/2121043002/. So, the
format check is deferred to SkCanvasVideoRenderer to keep the check on one place
and avoid the need to change the code here. Anyway, your point is valid so using
Y16 check now as you suggested and will change it when adding more formats.  
 
Related to other single plane formats,... when no flip_y is supplied, this
approach saves at least one memcpy and a swizzle compared to fallback path at
the bottom of void WebGLRenderingContextBase::texImageHelperHTMLVideoElement.
So, it is potentially applicable for RGB based formats too.

[emircan, 2016/12/02 20:33:34]

Thanks for the explanation. For media streams, we usually receive texture-HW
decode- or I420 frames.

+    return false;
+  }
+
+  if (functionID == TexImage2D) {
+    return media::SkCanvasVideoRenderer::TexImage2D(
+        target, gl, video_frame.get(), level, internalformat, format, type,
+        flip_y, premultiply_alpha);
+  } else if (functionID == TexSubImage2D) {
+    return media::SkCanvasVideoRenderer::TexSubImage2D(
+        target, gl, video_frame.get(), level, format, type, xoffset, yoffset,
+        flip_y, premultiply_alpha);
+  }

[emircan, 2016/12/01 23:23:37]

nit: If you don't expect this function to be called with any other |functionID|,
you can add NOTREACHED() here to make that clear.

[aleksandar.stojiljkovic, 2016/12/02 20:23:41]

Other parameter values are expected too, we just don't handle teximage3D in this
patch yet) - adding it when the tests gets added. Anyway, as defined returning
false when call is not handled and no need for NOTREACHED.

+  return false;
+}
+
 void WebMediaPlayerMS::OnFirstFrameReceived(media::VideoRotation video_rotation,
                                             bool is_opaque) {
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   video_rotation_ = video_rotation;
   SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
   SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
 
   video_weblayer_.reset(new cc_blink::WebLayerImpl(
       cc::VideoLayer::Create(compositor_.get(), video_rotation_)));
@@ skipping 42 matching lines @@
 void WebMediaPlayerMS::ResetCanvasCache() {
   DCHECK(thread_checker_.CalledOnValidThread());
   video_renderer_.ResetCache();
 }
 
 void WebMediaPlayerMS::TriggerResize() {
   get_client()->sizeChanged();
 }
 
 }  // namespace content