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

cc/output/gl_renderer.h

 // 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.
 
 #ifndef CC_OUTPUT_GL_RENDERER_H_
 #define CC_OUTPUT_GL_RENDERER_H_
 
 #include <deque>
 #include <vector>
 
 #include "base/cancelable_callback.h"
 #include "base/macros.h"
 #include "cc/base/cc_export.h"
 #include "cc/output/color_lut_cache.h"
 #include "cc/output/direct_renderer.h"
 #include "cc/output/gl_renderer_draw_cache.h"
 #include "cc/output/program_binding.h"
 #include "cc/output/renderer.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
+#include "cc/quads/y_video_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
 #include "ui/gfx/geometry/quad_f.h"
 
 class SkBitmap;
 
 namespace gpu {
 namespace gles2 {
 class GLES2Interface;
 }
 }
@@ skipping 179 matching lines @@
                          const gfx::Transform& device_transform,
                          const gfx::QuadF& aa_quad,
                          const gfx::QuadF* clip_region);
   void DrawContentQuadNoAA(const DrawingFrame* frame,
                            const ContentDrawQuadBase* quad,
                            ResourceId resource_id,
                            const gfx::QuadF* clip_region);
   void DrawYUVVideoQuad(const DrawingFrame* frame,
                         const YUVVideoDrawQuad* quad,
                         const gfx::QuadF* clip_region);
+  void DrawYVideoQuad(const DrawingFrame* frame,
+                      const YVideoDrawQuad* quad,
+                      const gfx::QuadF* clip_region);
   void DrawPictureQuad(const DrawingFrame* frame,
                        const PictureDrawQuad* quad,
                        const gfx::QuadF* clip_region);
 
   void SetShaderOpacity(float opacity, int alpha_location);
   void SetShaderQuadF(const gfx::QuadF& quad, int quad_location);
   void DrawQuadGeometryClippedByQuadF(const DrawingFrame* frame,
                                       const gfx::Transform& draw_transform,
                                       const gfx::RectF& quad_rect,
                                       const gfx::QuadF& clipping_region_quad,
@@ skipping 116 matching lines @@
       RenderPassColorMatrixProgramAA;
   typedef ProgramBinding<VertexShaderPosTexTransform,
                          FragmentShaderRGBATexAlphaMaskColorMatrix>
       RenderPassMaskColorMatrixProgram;
 
   // Video shaders.
   typedef ProgramBinding<VertexShaderVideoTransform, FragmentShaderRGBATex>
       VideoStreamTextureProgram;
   typedef ProgramBinding<VertexShaderPosTexYUVStretchOffset,
                          FragmentShaderYUVVideo> VideoYUVProgram;
+  typedef ProgramBinding<VertexShaderPosTexTransform, FragmentShaderYVideo>
+      VideoYProgram;
 
   // Special purpose / effects shaders.
   typedef ProgramBinding<VertexShaderPos, FragmentShaderColor>
       DebugBorderProgram;
   typedef ProgramBinding<VertexShaderQuad, FragmentShaderColor>
       SolidColorProgram;
   typedef ProgramBinding<VertexShaderQuadAA, FragmentShaderColorAA>
       SolidColorProgramAA;
 
   const TileProgram* GetTileProgram(
@@ skipping 50 matching lines @@
       SamplerType sampler);
   const NonPremultipliedTextureBackgroundProgram*
   GetNonPremultipliedTextureBackgroundProgram(TexCoordPrecision precision,
                                               SamplerType sampler);
 
   const VideoYUVProgram* GetVideoYUVProgram(TexCoordPrecision precision,
                                             SamplerType sampler,
                                             bool use_alpha_texture,
                                             bool use_nv12,
                                             bool use_color_lut);
+  const VideoYProgram* GetVideoYProgram(TexCoordPrecision precision,
+                                        SamplerType sampler);
   const VideoStreamTextureProgram* GetVideoStreamTextureProgram(
       TexCoordPrecision precision);
 
   const DebugBorderProgram* GetDebugBorderProgram();
   const SolidColorProgram* GetSolidColorProgram();
   const SolidColorProgramAA* GetSolidColorProgramAA();
 
   TileProgram
       tile_program_[LAST_TEX_COORD_PRECISION + 1][LAST_SAMPLER_TYPE + 1];
   TileProgramOpaque
@@ skipping 46 matching lines @@
                                             [LAST_BLEND_MODE + 1]
                                             [LAST_MASK_VALUE + 1];
   RenderPassMaskColorMatrixProgramAA
       render_pass_mask_color_matrix_program_aa_[LAST_TEX_COORD_PRECISION + 1]
                                                [LAST_SAMPLER_TYPE + 1]
                                                [LAST_BLEND_MODE + 1]
                                                [LAST_MASK_VALUE + 1];
 
   VideoYUVProgram video_yuv_program_[LAST_TEX_COORD_PRECISION + 1]
                                     [LAST_SAMPLER_TYPE + 1][2][2][2];
+  VideoYProgram video_y_program_[LAST_TEX_COORD_PRECISION + 1]
+                                [LAST_SAMPLER_TYPE + 1];
   VideoStreamTextureProgram
       video_stream_texture_program_[LAST_TEX_COORD_PRECISION + 1];
 
   DebugBorderProgram debug_border_program_;
   SolidColorProgram solid_color_program_;
   SolidColorProgramAA solid_color_program_aa_;
 
   gpu::gles2::GLES2Interface* gl_;
   gpu::ContextSupport* context_support_;
 
@@ skipping 44 matching lines @@
   bool force_drawing_frame_framebuffer_unflipped_ = false;
 
   BoundGeometry bound_geometry_;
   ColorLUTCache color_lut_cache_;
   DISALLOW_COPY_AND_ASSIGN(GLRenderer);
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_GL_RENDERER_H_