Support reading pixels from HW-decoded video textures into canvas/webgl.

content/renderer/media/renderer_gpu_video_decoder_factories.cc

 // Copyright (c) 2012 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/renderer_gpu_video_decoder_factories.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 
 #include "base/bind.h"
@@ skipping 103 matching lines @@
   }
   gpu::gles2::GLES2Implementation* gles2 = context_->GetImplementation();
   texture_ids->resize(count);
   gles2->GenTextures(count, &texture_ids->at(0));
   for (int i = 0; i < count; ++i) {
     gles2->ActiveTexture(GL_TEXTURE0);
     uint32 texture_id = texture_ids->at(i);
     gles2->BindTexture(texture_target, texture_id);
     gles2->TexParameteri(texture_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     gles2->TexParameteri(texture_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    gles2->TexParameterf(texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    gles2->TexParameterf(texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    gles2->TexParameteri(texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    gles2->TexParameteri(texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     if (texture_target == GL_TEXTURE_2D) {
       gles2->TexImage2D(texture_target, 0, GL_RGBA, size.width(), size.height(),
                         0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
     }
   }
   // We need a glFlush here to guarantee the decoder (in the GPU process) can
   // use the texture ids we return here.  Since textures are expected to be
   // reused, this should not be unacceptably expensive.
   gles2->Flush();
   DCHECK_EQ(gles2->GetError(), static_cast<GLenum>(GL_NO_ERROR));
   *success = true;
   waiter->Signal();
 }
 
 void RendererGpuVideoDecoderFactories::DeleteTexture(uint32 texture_id) {
   DCHECK(!message_loop_->BelongsToCurrentThread());
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &RendererGpuVideoDecoderFactories::AsyncDeleteTexture, this, texture_id));
 }
 
 void RendererGpuVideoDecoderFactories::AsyncDeleteTexture(uint32 texture_id) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   if (!context_)
     return;
   gpu::gles2::GLES2Implementation* gles2 = context_->GetImplementation();
   gles2->DeleteTextures(1, &texture_id);
   DCHECK_EQ(gles2->GetError(), static_cast<GLenum>(GL_NO_ERROR));
 }
 
+void RendererGpuVideoDecoderFactories::ReadPixels(
+    uint32 texture_id, uint32 texture_target, const gfx::Size& size,
+    void* pixels) {
+  base::WaitableEvent waiter(false, false);
+  if (!message_loop_->BelongsToCurrentThread()) {
+    message_loop_->PostTask(FROM_HERE, base::Bind(
+        &RendererGpuVideoDecoderFactories::AsyncReadPixels, this,
+        texture_id, texture_target, size, pixels, &waiter));
+    waiter.Wait();
+  } else {
+    AsyncReadPixels(texture_id, texture_target, size, pixels, &waiter);
+  }
+}
+
+void RendererGpuVideoDecoderFactories::AsyncReadPixels(
+    uint32 texture_id, uint32 texture_target, const gfx::Size& size,
+    void* pixels, base::WaitableEvent* waiter) {
+  DCHECK(message_loop_->BelongsToCurrentThread());
+  if (!context_)
+    return;
+
+  gpu::gles2::GLES2Implementation* gles2 = context_->GetImplementation();
+
+  gles2->ActiveTexture(GL_TEXTURE0);
+  gles2->BindTexture(texture_target, texture_id);
+  gles2->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  gles2->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  gles2->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  gles2->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+  GLuint fb;
+  gles2->GenFramebuffers(1, &fb);
+  gles2->BindFramebuffer(GL_FRAMEBUFFER, fb);
+  gles2->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                              texture_target, texture_id, 0);
+  gles2->ReadPixels(0, 0, size.width(), size.height(), GL_RGBA,

[Ken Russell (switch to Gerrit), 2012/10/01 17:56:16]

Depending on who uses this context (just HW video decode? the compositor as
well?) it may be worth calling glPixelStorei(GL_PACK_ALIGNMENT, 4); before doing
the glReadPixels, to make sure that someone else didn't set it to 8-byte
alignment.

[Ami GONE FROM CHROMIUM, 2012/10/01 18:16:12]

Only HW decode uses it.
Done.

+                    GL_UNSIGNED_BYTE, pixels);
+  gles2->DeleteFramebuffers(1, &fb);
+  DCHECK_EQ(gles2->GetError(), static_cast<GLenum>(GL_NO_ERROR));
+  waiter->Signal();
+}
+
 base::SharedMemory* RendererGpuVideoDecoderFactories::CreateSharedMemory(
     size_t size) {
   DCHECK_NE(MessageLoop::current(), ChildThread::current()->message_loop());
   base::SharedMemory* shm = NULL;
   base::WaitableEvent waiter(false, false);
   ChildThread::current()->message_loop()->PostTask(FROM_HERE, base::Bind(
       &RendererGpuVideoDecoderFactories::AsyncCreateSharedMemory, this,
       size, &shm, &waiter));
   waiter.Wait();
   return shm;
 }
 
 void RendererGpuVideoDecoderFactories::AsyncCreateSharedMemory(
     size_t size, base::SharedMemory** shm, base::WaitableEvent* waiter) {
   DCHECK_EQ(MessageLoop::current(), ChildThread::current()->message_loop());
   *shm = ChildThread::current()->AllocateSharedMemory(size);
   waiter->Signal();
 }