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

cc/output/gl_renderer.cc

 // Copyright 2010 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 "cc/output/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 599 matching lines @@
       EnqueueTextureQuad(frame, TextureDrawQuad::MaterialCast(quad),
                          clip_region);
       break;
     case DrawQuad::TILED_CONTENT:
       DrawTileQuad(frame, TileDrawQuad::MaterialCast(quad), clip_region);
       break;
     case DrawQuad::YUV_VIDEO_CONTENT:
       DrawYUVVideoQuad(frame, YUVVideoDrawQuad::MaterialCast(quad),
                        clip_region);
       break;
+    case DrawQuad::Y_VIDEO_CONTENT:
+      DrawYVideoQuad(frame, YVideoDrawQuad::MaterialCast(quad), clip_region);
+      break;
   }
 }
 
 // This function does not handle 3D sorting right now, since the debug border
 // quads are just drawn as their original quads and not in split pieces. This
 // results in some debug border quads drawing over foreground quads.
 void GLRenderer::DrawDebugBorderQuad(const DrawingFrame* frame,
                                      const DebugBorderDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
@@ skipping 1821 matching lines @@
     GetScaledUVs(quad->visible_rect, clip_region, uvs);
     gfx::QuadF region_quad = *clip_region;
     region_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());
     region_quad -= gfx::Vector2dF(0.5f, 0.5f);
     DrawQuadGeometryClippedByQuadF(
         frame, quad->shared_quad_state->quad_to_target_transform, tile_rect,
         region_quad, matrix_location, uvs);
   }
 }
 
+void GLRenderer::DrawYVideoQuad(const DrawingFrame* frame,
+                                const YVideoDrawQuad* quad,
+                                const gfx::QuadF* clip_region) {
+  SetBlendEnabled(quad->ShouldDrawWithBlending());
+  TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
+      gl_, &highp_threshold_cache_, highp_threshold_min_,
+      quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
+
+  ResourceProvider::ScopedReadLockGL lock(resource_provider_,
+                                          quad->resource_id());
+  const SamplerType sampler = SamplerTypeFromTextureTarget(lock.target());
+  DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
+  gl_->BindTexture(lock.target(), lock.texture_id());
+
+  const VideoYProgram* program = GetVideoYProgram(tex_coord_precision, sampler);
+  DCHECK(program && (program->initialized() || IsContextLost()));
+  SetUseProgram(program->program());
+
+  // Set the uv-transform.
+  Float4 uv_transform = {{0.0f, 0.0f, 1.0f, 1.0f}};
+  if (!clip_region) {
+    gfx::PointF uv0 = quad->uv_top_left;
+    gfx::PointF uv1 = quad->uv_bottom_right;
+    uv_transform = {{uv0.x(), uv0.y(), uv1.x() - uv0.x(), uv1.y() - uv0.y()}};
+  }
+  gfx::Size texture_size = lock.size();
+  if (sampler == SAMPLER_TYPE_2D_RECT) {
+    // Un-normalize the texture coordiantes for rectangle targets.
+    uv_transform.data[0] *= texture_size.width();
+    uv_transform.data[2] *= texture_size.width();
+    uv_transform.data[1] *= texture_size.height();
+    uv_transform.data[3] *= texture_size.height();
+  }
+  gl_->Uniform4fv(program->vertex_shader().tex_transform_location(), 1,
+                  uv_transform.data);
+  gl_->Uniform1i(program->fragment_shader().sampler_location(), 0);
+  gl_->Uniform1f(program->fragment_shader().x_derivative_location(),
+                 1.f / (float)texture_size.width());
+  gl_->Uniform1f(program->fragment_shader().y_derivative_location(),
+                 1.f / (float)texture_size.height());
+
+  if (!clip_region) {
+    DrawQuadGeometry(frame->projection_matrix,
+                     quad->shared_quad_state->quad_to_target_transform,
+                     gfx::RectF(quad->rect),
+                     program->vertex_shader().matrix_location());
+  } else {
+    gfx::QuadF region_quad(*clip_region);
+    region_quad.Scale(1.0f / quad->rect.width(), 1.0f / quad->rect.height());
+    region_quad -= gfx::Vector2dF(0.5f, 0.5f);
+    float uvs[8] = {0};
+    GetScaledUVs(quad->visible_rect, clip_region, uvs);
+    DrawQuadGeometryClippedByQuadF(
+        frame, quad->shared_quad_state->quad_to_target_transform,
+        gfx::RectF(quad->rect), region_quad,
+        program->vertex_shader().matrix_location(), uvs);
+  }
+}
+
 void GLRenderer::DrawStreamVideoQuad(const DrawingFrame* frame,
                                      const StreamVideoDrawQuad* quad,
                                      const gfx::QuadF* clip_region) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   static float gl_matrix[16];
 
   DCHECK(capabilities_.using_egl_image);
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
@@ skipping 1206 matching lines @@
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::videoYUVProgram::initialize");
     program->mutable_fragment_shader()->SetFeatures(use_alpha_plane, use_nv12,
                                                     use_color_lut);
     program->Initialize(output_surface_->context_provider(), precision,
                         sampler);
   }
   return program;
 }
 
+const GLRenderer::VideoYProgram* GLRenderer::GetVideoYProgram(
+    TexCoordPrecision precision,
+    SamplerType sampler) {
+  DCHECK_GE(precision, 0);
+  DCHECK_LE(precision, LAST_TEX_COORD_PRECISION);
+  DCHECK_GE(sampler, 0);
+  DCHECK_LE(sampler, LAST_SAMPLER_TYPE);
+  VideoYProgram* program = &video_y_program_[precision][sampler];
+  if (!program->initialized()) {
+    TRACE_EVENT0("cc", "GLRenderer::videoYProgram::initialize");
+    program->Initialize(output_surface_->context_provider(), precision,
+                        sampler);
+  }
+  return program;
+}
+
 const GLRenderer::VideoStreamTextureProgram*
 GLRenderer::GetVideoStreamTextureProgram(TexCoordPrecision precision) {
   DCHECK_GE(precision, 0);
   DCHECK_LE(precision, LAST_TEX_COORD_PRECISION);
   VideoStreamTextureProgram* program =
       &video_stream_texture_program_[precision];
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::streamTextureProgram::initialize");
     program->Initialize(output_surface_->context_provider(), precision,
                         SAMPLER_TYPE_EXTERNAL_OES);
@@ skipping 35 matching lines @@
       render_pass_program_aa_[i][j].Cleanup(gl_);
       render_pass_color_matrix_program_[i][j].Cleanup(gl_);
       render_pass_color_matrix_program_aa_[i][j].Cleanup(gl_);
     }
 
     for (int j = 0; j <= LAST_SAMPLER_TYPE; ++j) {
       texture_program_[i][j].Cleanup(gl_);
       nonpremultiplied_texture_program_[i][j].Cleanup(gl_);
       texture_background_program_[i][j].Cleanup(gl_);
       nonpremultiplied_texture_background_program_[i][j].Cleanup(gl_);
+      video_y_program_[i][j].Cleanup(gl_);
     }
 
     video_stream_texture_program_[i].Cleanup(gl_);
   }
 
   debug_border_program_.Cleanup(gl_);
   solid_color_program_.Cleanup(gl_);
   solid_color_program_aa_.Cleanup(gl_);
 
   if (offscreen_framebuffer_id_)
@@ skipping 321 matching lines @@
 
   gl_->ScheduleCALayerSharedStateCHROMIUM(
       ca_layer_overlay->shared_state->opacity, is_clipped, clip_rect,
       sorting_context_id, gl_transform);
   gl_->ScheduleCALayerCHROMIUM(
       texture_id, contents_rect, ca_layer_overlay->background_color,
       ca_layer_overlay->edge_aa_mask, bounds_rect, filter);
 }
 
 }  // namespace cc