Pepper: Add External_OES texture target to PPB_VideoDecoder docs and example.

ppapi/examples/video_decode/video_decode.cc

 // Copyright (c) 2014 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 <stdio.h>
 #include <string.h>
 
 #include <iostream>
 #include <queue>
 #include <sstream>
@@ skipping 95 matching lines @@
     std::ostringstream stream_;
   };
 
   void InitializeDecoders();
 
   // GL-related functions.
   void InitGL();
   void CreateGLObjects();
   void Create2DProgramOnce();
   void CreateRectangleARBProgramOnce();
+  void CreateExternalOESProgramOnce();
   Shader CreateProgram(const char* vertex_shader, const char* fragment_shader);
   void CreateShader(GLuint program, GLenum type, const char* source, int size);
   void PaintNextPicture();
   void PaintFinished(int32_t result);
 
   pp::Size plugin_size_;
   bool is_painting_;
   // When decode outpaces render, we queue up decoded pictures for later
   // painting.
   typedef std::queue<PendingPicture> PendingPictureQueue;
@@ skipping 12 matching lines @@
 
   // Owned data.
   pp::Graphics3D* context_;
   typedef std::vector<Decoder*> DecoderList;
   DecoderList video_decoders_;
 
   // Shader program to draw GL_TEXTURE_2D target.
   Shader shader_2d_;
   // Shader program to draw GL_TEXTURE_RECTANGLE_ARB target.
   Shader shader_rectangle_arb_;
+  // Shader program to draw GL_TEXTURE_EXTERNAL_OES target.
+  Shader shader_external_oes_;
 };
 
 class Decoder {
  public:
   Decoder(MyInstance* instance, int id, const pp::Graphics3D& graphics_3d);
   ~Decoder();
 
   int id() const { return id_; }
   bool flushing() const { return flushing_; }
   bool resetting() const { return resetting_; }
@@ skipping 225 matching lines @@
 
 MyInstance::~MyInstance() {
   if (!context_)
     return;
 
   PP_Resource graphics_3d = context_->pp_resource();
   if (shader_2d_.program)
     gles2_if_->DeleteProgram(graphics_3d, shader_2d_.program);
   if (shader_rectangle_arb_.program)
     gles2_if_->DeleteProgram(graphics_3d, shader_rectangle_arb_.program);
+  if (shader_external_oes_.program)
+    gles2_if_->DeleteProgram(graphics_3d, shader_external_oes_.program);
 
   for (DecoderList::iterator it = video_decoders_.begin();
        it != video_decoders_.end();
        ++it)
     delete *it;
 
   delete context_;
 }
 
 void MyInstance::DidChangeView(const pp::Rect& position,
@@ skipping 68 matching lines @@
     x = half_width;
     y = half_height;
   }
 
   PP_Resource graphics_3d = context_->pp_resource();
   if (picture.texture_target == GL_TEXTURE_2D) {
     Create2DProgramOnce();
     gles2_if_->UseProgram(graphics_3d, shader_2d_.program);
     gles2_if_->Uniform2f(
         graphics_3d, shader_2d_.texcoord_scale_location, 1.0, 1.0);
-  } else {
-    assert(picture.texture_target == GL_TEXTURE_RECTANGLE_ARB);
+  } else if (picture.texture_target == GL_TEXTURE_RECTANGLE_ARB) {
     CreateRectangleARBProgramOnce();
     gles2_if_->UseProgram(graphics_3d, shader_rectangle_arb_.program);
     gles2_if_->Uniform2f(graphics_3d,
                          shader_rectangle_arb_.texcoord_scale_location,
                          picture.texture_size.width,
                          picture.texture_size.height);
+  } else {
+    assert(picture.texture_target == GL_TEXTURE_EXTERNAL_OES);
+    CreateExternalOESProgramOnce();
+    gles2_if_->UseProgram(graphics_3d, shader_external_oes_.program);
+    gles2_if_->Uniform2f(
+        graphics_3d, shader_external_oes_.texcoord_scale_location, 1.0, 1.0);
   }
 
   gles2_if_->Viewport(graphics_3d, x, y, half_width, half_height);
   gles2_if_->ActiveTexture(graphics_3d, GL_TEXTURE0);
   gles2_if_->BindTexture(
       graphics_3d, picture.texture_target, picture.texture_id);
   gles2_if_->DrawArrays(graphics_3d, GL_TRIANGLE_STRIP, 0, 4);
 
   gles2_if_->UseProgram(graphics_3d, 0);
 
@@ skipping 124 matching lines @@
       "#extension GL_ARB_texture_rectangle : require\n"
       "precision mediump float;            \n"
       "varying vec2 v_texCoord;            \n"
       "uniform sampler2DRect s_texture;    \n"
       "void main()                         \n"
       "{"
       "    gl_FragColor = texture2DRect(s_texture, v_texCoord).rgba; \n"
       "}";
   shader_rectangle_arb_ =
       CreateProgram(kVertexShader, kFragmentShaderRectangle);
+  assertNoGLError();
+}
+
+void MyInstance::CreateExternalOESProgramOnce() {
+  if (shader_external_oes_.program)
+    return;
+  static const char kFragmentShaderExternal[] =
+      "#extension GL_OES_EGL_image_external : require\n"
+      "precision mediump float;            \n"
+      "varying vec2 v_texCoord;            \n"
+      "uniform samplerExternalOES s_texture; \n"
+      "void main()                         \n"
+      "{"
+      "    gl_FragColor = texture2D(s_texture, v_texCoord); \n"
+      "}";
+  shader_external_oes_ = CreateProgram(kVertexShader, kFragmentShaderExternal);
+  assertNoGLError();
 }
 
 Shader MyInstance::CreateProgram(const char* vertex_shader,
                                  const char* fragment_shader) {
   Shader shader;
 
   // Create shader program.
   shader.program = gles2_if_->CreateProgram(context_->pp_resource());
   CreateShader(
       shader.program, GL_VERTEX_SHADER, vertex_shader, strlen(vertex_shader));
@@ skipping 61 matching lines @@
 };
 
 }  // anonymous namespace
 
 namespace pp {
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new MyModule();
 }
 }  // namespace pp