Home | History | Annotate | Download | only in gpu 
      1 // Copyright (c) 2012 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/gpu/mailbox_output_surface.h"
      6 
      7 #include "base/logging.h"
      8 #include "cc/output/compositor_frame.h"
      9 #include "cc/output/compositor_frame_ack.h"
     10 #include "cc/output/gl_frame_data.h"
     11 #include "cc/resources/resource_provider.h"
     12 #include "content/renderer/gpu/frame_swap_message_queue.h"
     13 #include "gpu/command_buffer/client/gles2_interface.h"
     14 #include "third_party/khronos/GLES2/gl2.h"
     15 #include "third_party/khronos/GLES2/gl2ext.h"
     16 
     17 using cc::CompositorFrame;
     18 using cc::GLFrameData;
     19 using cc::ResourceProvider;
     20 using gpu::Mailbox;
     21 using gpu::gles2::GLES2Interface;
     22 
     23 namespace content {
     24 
     25 MailboxOutputSurface::MailboxOutputSurface(
     26     int32 routing_id,
     27     uint32 output_surface_id,
     28     const scoped_refptr<ContextProviderCommandBuffer>& context_provider,
     29     scoped_ptr<cc::SoftwareOutputDevice> software_device,
     30     scoped_refptr<FrameSwapMessageQueue> swap_frame_message_queue,
     31     cc::ResourceFormat format)
     32     : CompositorOutputSurface(routing_id,
     33                               output_surface_id,
     34                               context_provider,
     35                               software_device.Pass(),
     36                               swap_frame_message_queue,
     37                               true),
     38       fbo_(0),
     39       is_backbuffer_discarded_(false),
     40       format_(format) {
     41   pending_textures_.push_back(TransferableFrame());
     42   capabilities_.max_frames_pending = 1;
     43   capabilities_.uses_default_gl_framebuffer = false;
     44 }
     45 
     46 MailboxOutputSurface::~MailboxOutputSurface() {
     47   DiscardBackbuffer();
     48   while (!pending_textures_.empty()) {
     49     if (pending_textures_.front().texture_id) {
     50       context_provider_->ContextGL()->DeleteTextures(
     51           1, &pending_textures_.front().texture_id);
     52     }
     53     pending_textures_.pop_front();
     54   }
     55 }
     56 
     57 void MailboxOutputSurface::EnsureBackbuffer() {
     58   is_backbuffer_discarded_ = false;
     59 
     60   GLES2Interface* gl = context_provider_->ContextGL();
     61 
     62   if (!current_backing_.texture_id) {
     63     // Find a texture of matching size to recycle.
     64     while (!returned_textures_.empty()) {
     65       TransferableFrame& texture = returned_textures_.front();
     66       if (texture.size == surface_size_) {
     67         current_backing_ = texture;
     68         if (current_backing_.sync_point)
     69           gl->WaitSyncPointCHROMIUM(current_backing_.sync_point);
     70         returned_textures_.pop();
     71         break;
     72       }
     73 
     74       gl->DeleteTextures(1, &texture.texture_id);
     75       returned_textures_.pop();
     76     }
     77 
     78     if (!current_backing_.texture_id) {
     79       gl->GenTextures(1, &current_backing_.texture_id);
     80       current_backing_.size = surface_size_;
     81       gl->BindTexture(GL_TEXTURE_2D, current_backing_.texture_id);
     82       gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     83       gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     84       gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     85       gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     86       gl->TexImage2D(GL_TEXTURE_2D,
     87                      0,
     88                      GLInternalFormat(format_),
     89                      surface_size_.width(),
     90                      surface_size_.height(),
     91                      0,
     92                      GLDataFormat(format_),
     93                      GLDataType(format_),
     94                      NULL);
     95       gl->GenMailboxCHROMIUM(current_backing_.mailbox.name);
     96       gl->ProduceTextureCHROMIUM(GL_TEXTURE_2D, current_backing_.mailbox.name);
     97     }
     98   }
     99 }
    100 
    101 void MailboxOutputSurface::DiscardBackbuffer() {
    102   is_backbuffer_discarded_ = true;
    103 
    104   GLES2Interface* gl = context_provider_->ContextGL();
    105 
    106   if (current_backing_.texture_id) {
    107     gl->DeleteTextures(1, &current_backing_.texture_id);
    108     current_backing_ = TransferableFrame();
    109   }
    110 
    111   while (!returned_textures_.empty()) {
    112     const TransferableFrame& frame = returned_textures_.front();
    113     gl->DeleteTextures(1, &frame.texture_id);
    114     returned_textures_.pop();
    115   }
    116 
    117   if (fbo_) {
    118     gl->BindFramebuffer(GL_FRAMEBUFFER, fbo_);
    119     gl->DeleteFramebuffers(1, &fbo_);
    120     fbo_ = 0;
    121   }
    122 }
    123 
    124 void MailboxOutputSurface::Reshape(const gfx::Size& size, float scale_factor) {
    125   if (size == surface_size_)
    126     return;
    127 
    128   surface_size_ = size;
    129   device_scale_factor_ = scale_factor;
    130   DiscardBackbuffer();
    131   EnsureBackbuffer();
    132 }
    133 
    134 void MailboxOutputSurface::BindFramebuffer() {
    135   EnsureBackbuffer();
    136   DCHECK(current_backing_.texture_id);
    137 
    138   GLES2Interface* gl = context_provider_->ContextGL();
    139 
    140   if (!fbo_)
    141     gl->GenFramebuffers(1, &fbo_);
    142   gl->BindFramebuffer(GL_FRAMEBUFFER, fbo_);
    143   gl->FramebufferTexture2D(GL_FRAMEBUFFER,
    144                            GL_COLOR_ATTACHMENT0,
    145                            GL_TEXTURE_2D,
    146                            current_backing_.texture_id,
    147                            0);
    148 }
    149 
    150 void MailboxOutputSurface::OnSwapAck(uint32 output_surface_id,
    151                                      const cc::CompositorFrameAck& ack) {
    152   // Ignore message if it's a stale one coming from a different output surface
    153   // (e.g. after a lost context).
    154   if (output_surface_id != output_surface_id_) {
    155     CompositorOutputSurface::OnSwapAck(output_surface_id, ack);
    156     return;
    157   }
    158   if (!ack.gl_frame_data->mailbox.IsZero()) {
    159     DCHECK(!ack.gl_frame_data->size.IsEmpty());
    160     // The browser could be returning the oldest or any other pending texture
    161     // if it decided to skip a frame.
    162     std::deque<TransferableFrame>::iterator it;
    163     for (it = pending_textures_.begin(); it != pending_textures_.end(); it++) {
    164       DCHECK(!it->mailbox.IsZero());
    165       if (!memcmp(it->mailbox.name,
    166                   ack.gl_frame_data->mailbox.name,
    167                   sizeof(it->mailbox.name))) {
    168         DCHECK(it->size == ack.gl_frame_data->size);
    169         break;
    170       }
    171     }
    172     DCHECK(it != pending_textures_.end());
    173     it->sync_point = ack.gl_frame_data->sync_point;
    174 
    175     if (!is_backbuffer_discarded_) {
    176       returned_textures_.push(*it);
    177     } else {
    178       context_provider_->ContextGL()->DeleteTextures(1, &it->texture_id);
    179     }
    180 
    181     pending_textures_.erase(it);
    182   } else {
    183     DCHECK(!pending_textures_.empty());
    184     // The browser always keeps one texture as the frontbuffer.
    185     // If it does not return a mailbox, it discarded the frontbuffer which is
    186     // the oldest texture we sent.
    187     uint32 texture_id = pending_textures_.front().texture_id;
    188     if (texture_id)
    189       context_provider_->ContextGL()->DeleteTextures(1, &texture_id);
    190     pending_textures_.pop_front();
    191   }
    192   CompositorOutputSurface::OnSwapAck(output_surface_id, ack);
    193 }
    194 
    195 void MailboxOutputSurface::SwapBuffers(cc::CompositorFrame* frame) {
    196   DCHECK(frame->gl_frame_data);
    197   DCHECK(!surface_size_.IsEmpty());
    198   DCHECK(surface_size_ == current_backing_.size);
    199   DCHECK(frame->gl_frame_data->size == current_backing_.size);
    200   DCHECK(!current_backing_.mailbox.IsZero() ||
    201          context_provider_->IsContextLost());
    202 
    203   frame->gl_frame_data->mailbox = current_backing_.mailbox;
    204   context_provider_->ContextGL()->Flush();
    205   frame->gl_frame_data->sync_point =
    206       context_provider_->ContextGL()->InsertSyncPointCHROMIUM();
    207   CompositorOutputSurface::SwapBuffers(frame);
    208 
    209   pending_textures_.push_back(current_backing_);
    210   current_backing_ = TransferableFrame();
    211 }
    212 
    213 size_t MailboxOutputSurface::GetNumAcksPending() {
    214   DCHECK(pending_textures_.size());
    215   return pending_textures_.size() - 1;
    216 }
    217 
    218 }  // namespace content
    219