Home | History | Annotate | Download | only in media 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/renderer/media/renderer_gpu_video_accelerator_factories.h"
      6 
      7 #include <GLES2/gl2.h>
      8 #include <GLES2/gl2ext.h>
      9 
     10 #include "base/bind.h"
     11 #include "content/child/child_thread.h"
     12 #include "content/common/gpu/client/context_provider_command_buffer.h"
     13 #include "content/common/gpu/client/gpu_channel_host.h"
     14 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
     15 #include "content/renderer/render_thread_impl.h"
     16 #include "gpu/command_buffer/client/gles2_implementation.h"
     17 #include "media/video/video_decode_accelerator.h"
     18 #include "media/video/video_encode_accelerator.h"
     19 #include "third_party/skia/include/core/SkBitmap.h"
     20 #include "third_party/skia/include/core/SkPixelRef.h"
     21 
     22 namespace content {
     23 
     24 // static
     25 scoped_refptr<RendererGpuVideoAcceleratorFactories>
     26 RendererGpuVideoAcceleratorFactories::Create(
     27     GpuChannelHost* gpu_channel_host,
     28     const scoped_refptr<base::MessageLoopProxy>& message_loop_proxy,
     29     const scoped_refptr<ContextProviderCommandBuffer>& context_provider) {
     30   scoped_refptr<RendererGpuVideoAcceleratorFactories> factories =
     31       new RendererGpuVideoAcceleratorFactories(
     32           gpu_channel_host, message_loop_proxy, context_provider);
     33   // Post task from outside constructor, since AddRef()/Release() is unsafe from
     34   // within.
     35   message_loop_proxy->PostTask(
     36       FROM_HERE,
     37       base::Bind(&RendererGpuVideoAcceleratorFactories::BindContext,
     38                  factories));
     39   return factories;
     40 }
     41 
     42 RendererGpuVideoAcceleratorFactories::RendererGpuVideoAcceleratorFactories(
     43     GpuChannelHost* gpu_channel_host,
     44     const scoped_refptr<base::MessageLoopProxy>& message_loop_proxy,
     45     const scoped_refptr<ContextProviderCommandBuffer>& context_provider)
     46     : task_runner_(message_loop_proxy),
     47       gpu_channel_host_(gpu_channel_host),
     48       context_provider_(context_provider),
     49       thread_safe_sender_(ChildThread::current()->thread_safe_sender()) {}
     50 
     51 RendererGpuVideoAcceleratorFactories::~RendererGpuVideoAcceleratorFactories() {}
     52 
     53 void RendererGpuVideoAcceleratorFactories::BindContext() {
     54   DCHECK(task_runner_->BelongsToCurrentThread());
     55   if (!context_provider_->BindToCurrentThread())
     56     context_provider_ = NULL;
     57 }
     58 
     59 WebGraphicsContext3DCommandBufferImpl*
     60 RendererGpuVideoAcceleratorFactories::GetContext3d() {
     61   DCHECK(task_runner_->BelongsToCurrentThread());
     62   if (!context_provider_)
     63     return NULL;
     64   if (context_provider_->IsContextLost()) {
     65     context_provider_->VerifyContexts();
     66     context_provider_ = NULL;
     67     return NULL;
     68   }
     69   return context_provider_->WebContext3D();
     70 }
     71 
     72 scoped_ptr<media::VideoDecodeAccelerator>
     73 RendererGpuVideoAcceleratorFactories::CreateVideoDecodeAccelerator() {
     74   DCHECK(task_runner_->BelongsToCurrentThread());
     75 
     76   WebGraphicsContext3DCommandBufferImpl* context = GetContext3d();
     77   if (context && context->GetCommandBufferProxy()) {
     78     return gpu_channel_host_->CreateVideoDecoder(
     79         context->GetCommandBufferProxy()->GetRouteID());
     80   }
     81 
     82   return scoped_ptr<media::VideoDecodeAccelerator>();
     83 }
     84 
     85 scoped_ptr<media::VideoEncodeAccelerator>
     86 RendererGpuVideoAcceleratorFactories::CreateVideoEncodeAccelerator() {
     87   DCHECK(task_runner_->BelongsToCurrentThread());
     88 
     89   WebGraphicsContext3DCommandBufferImpl* context = GetContext3d();
     90   if (context && context->GetCommandBufferProxy()) {
     91     return gpu_channel_host_->CreateVideoEncoder(
     92         context->GetCommandBufferProxy()->GetRouteID());
     93   }
     94 
     95   return scoped_ptr<media::VideoEncodeAccelerator>();
     96 }
     97 
     98 bool RendererGpuVideoAcceleratorFactories::CreateTextures(
     99     int32 count,
    100     const gfx::Size& size,
    101     std::vector<uint32>* texture_ids,
    102     std::vector<gpu::Mailbox>* texture_mailboxes,
    103     uint32 texture_target) {
    104   DCHECK(task_runner_->BelongsToCurrentThread());
    105   DCHECK(texture_target);
    106 
    107   WebGraphicsContext3DCommandBufferImpl* context = GetContext3d();
    108   if (!context)
    109     return false;
    110 
    111   gpu::gles2::GLES2Implementation* gles2 = context->GetImplementation();
    112   texture_ids->resize(count);
    113   texture_mailboxes->resize(count);
    114   gles2->GenTextures(count, &texture_ids->at(0));
    115   for (int i = 0; i < count; ++i) {
    116     gles2->ActiveTexture(GL_TEXTURE0);
    117     uint32 texture_id = texture_ids->at(i);
    118     gles2->BindTexture(texture_target, texture_id);
    119     gles2->TexParameteri(texture_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    120     gles2->TexParameteri(texture_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    121     gles2->TexParameteri(texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    122     gles2->TexParameteri(texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    123     if (texture_target == GL_TEXTURE_2D) {
    124       gles2->TexImage2D(texture_target,
    125                         0,
    126                         GL_RGBA,
    127                         size.width(),
    128                         size.height(),
    129                         0,
    130                         GL_RGBA,
    131                         GL_UNSIGNED_BYTE,
    132                         NULL);
    133     }
    134     gles2->GenMailboxCHROMIUM(texture_mailboxes->at(i).name);
    135     gles2->ProduceTextureCHROMIUM(texture_target,
    136                                   texture_mailboxes->at(i).name);
    137   }
    138 
    139   // We need ShallowFlushCHROMIUM() here to order the command buffer commands
    140   // with respect to IPC to the GPU process, to guarantee that the decoder in
    141   // the GPU process can use these textures as soon as it receives IPC
    142   // notification of them.
    143   gles2->ShallowFlushCHROMIUM();
    144   DCHECK_EQ(gles2->GetError(), static_cast<GLenum>(GL_NO_ERROR));
    145   return true;
    146 }
    147 
    148 void RendererGpuVideoAcceleratorFactories::DeleteTexture(uint32 texture_id) {
    149   DCHECK(task_runner_->BelongsToCurrentThread());
    150 
    151   WebGraphicsContext3DCommandBufferImpl* context = GetContext3d();
    152   if (!context)
    153     return;
    154 
    155   gpu::gles2::GLES2Implementation* gles2 = context->GetImplementation();
    156   gles2->DeleteTextures(1, &texture_id);
    157   DCHECK_EQ(gles2->GetError(), static_cast<GLenum>(GL_NO_ERROR));
    158 }
    159 
    160 void RendererGpuVideoAcceleratorFactories::WaitSyncPoint(uint32 sync_point) {
    161   DCHECK(task_runner_->BelongsToCurrentThread());
    162 
    163   WebGraphicsContext3DCommandBufferImpl* context = GetContext3d();
    164   if (!context)
    165     return;
    166 
    167   gpu::gles2::GLES2Implementation* gles2 = context->GetImplementation();
    168   gles2->WaitSyncPointCHROMIUM(sync_point);
    169 
    170   // Callers expect the WaitSyncPoint to affect the next IPCs. Make sure to
    171   // flush the command buffers to ensure that.
    172   gles2->ShallowFlushCHROMIUM();
    173 }
    174 
    175 void RendererGpuVideoAcceleratorFactories::ReadPixels(
    176     uint32 texture_id,
    177     const gfx::Rect& visible_rect,
    178     const SkBitmap& pixels) {
    179   DCHECK(task_runner_->BelongsToCurrentThread());
    180 
    181   WebGraphicsContext3DCommandBufferImpl* context = GetContext3d();
    182   if (!context)
    183     return;
    184 
    185   gpu::gles2::GLES2Implementation* gles2 = context->GetImplementation();
    186 
    187   GLuint tmp_texture;
    188   gles2->GenTextures(1, &tmp_texture);
    189   gles2->BindTexture(GL_TEXTURE_2D, tmp_texture);
    190   gles2->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    191   gles2->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    192   gles2->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    193   gles2->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    194   context->copyTextureCHROMIUM(
    195       GL_TEXTURE_2D, texture_id, tmp_texture, 0, GL_RGBA, GL_UNSIGNED_BYTE);
    196 
    197   GLuint fb;
    198   gles2->GenFramebuffers(1, &fb);
    199   gles2->BindFramebuffer(GL_FRAMEBUFFER, fb);
    200   gles2->FramebufferTexture2D(
    201       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tmp_texture, 0);
    202   gles2->PixelStorei(GL_PACK_ALIGNMENT, 4);
    203 
    204 #if SK_B32_SHIFT == 0 && SK_G32_SHIFT == 8 && SK_R32_SHIFT == 16 && \
    205     SK_A32_SHIFT == 24
    206   GLenum skia_format = GL_BGRA_EXT;
    207   GLenum read_format = GL_BGRA_EXT;
    208   GLint supported_format = 0;
    209   GLint supported_type = 0;
    210   gles2->GetIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &supported_format);
    211   gles2->GetIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &supported_type);
    212   if (supported_format != GL_BGRA_EXT || supported_type != GL_UNSIGNED_BYTE) {
    213     read_format = GL_RGBA;
    214   }
    215 #elif SK_R32_SHIFT == 0 && SK_G32_SHIFT == 8 && SK_B32_SHIFT == 16 && \
    216     SK_A32_SHIFT == 24
    217   GLenum skia_format = GL_RGBA;
    218   GLenum read_format = GL_RGBA;
    219 #else
    220 #error Unexpected Skia ARGB_8888 layout!
    221 #endif
    222   gles2->ReadPixels(visible_rect.x(),
    223                     visible_rect.y(),
    224                     visible_rect.width(),
    225                     visible_rect.height(),
    226                     read_format,
    227                     GL_UNSIGNED_BYTE,
    228                     pixels.pixelRef()->pixels());
    229   gles2->DeleteFramebuffers(1, &fb);
    230   gles2->DeleteTextures(1, &tmp_texture);
    231 
    232   if (skia_format != read_format) {
    233     DCHECK(read_format == GL_RGBA);
    234     int pixel_count = visible_rect.width() * visible_rect.height();
    235     uint32_t* pixels_ptr = static_cast<uint32_t*>(pixels.pixelRef()->pixels());
    236     for (int i = 0; i < pixel_count; ++i) {
    237         uint32_t r = pixels_ptr[i] & 0xFF;
    238         uint32_t g = (pixels_ptr[i] >> 8) & 0xFF;
    239         uint32_t b = (pixels_ptr[i] >> 16) & 0xFF;
    240         uint32_t a = (pixels_ptr[i] >> 24) & 0xFF;
    241         pixels_ptr[i] = (r << SK_R32_SHIFT) |
    242                         (g << SK_G32_SHIFT) |
    243                         (b << SK_B32_SHIFT) |
    244                         (a << SK_A32_SHIFT);
    245     }
    246   }
    247 
    248   DCHECK_EQ(gles2->GetError(), static_cast<GLenum>(GL_NO_ERROR));
    249 }
    250 
    251 base::SharedMemory* RendererGpuVideoAcceleratorFactories::CreateSharedMemory(
    252     size_t size) {
    253   DCHECK(task_runner_->BelongsToCurrentThread());
    254   return ChildThread::AllocateSharedMemory(size, thread_safe_sender_.get());
    255 }
    256 
    257 scoped_refptr<base::SingleThreadTaskRunner>
    258 RendererGpuVideoAcceleratorFactories::GetTaskRunner() {
    259   return task_runner_;
    260 }
    261 
    262 }  // namespace content
    263