content/browser/renderer_host/media/video_capture_buffer_pool.cc

   1 // Copyright (c) 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/browser/renderer_host/media/video_capture_buffer_pool.h"
   6
   7 #include "base/bind.h"
   8 #include "base/callback.h"
   9 #include "base/logging.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/stl_util.h"
  12 #include "media/base/video_frame.h"
  13 #include "media/base/video_util.h"
  14
  15 namespace content {
  16
  17 const int VideoCaptureBufferPool::kInvalidId = -1;
  18
  19 VideoCaptureBufferPool::VideoCaptureBufferPool(int count)
  20     : count_(count),
  21       next_buffer_id_(0) {
  22   DCHECK_GT(count, 0);
  23 }
  24
  25 VideoCaptureBufferPool::~VideoCaptureBufferPool() {
  26   STLDeleteValues(&buffers_);
  27 }
  28
  29 base::SharedMemoryHandle VideoCaptureBufferPool::ShareToProcess(
  30     int buffer_id,
  31     base::ProcessHandle process_handle,
  32     size_t* memory_size) {
  33   base::AutoLock lock(lock_);
  34
  35   Buffer* buffer = GetBuffer(buffer_id);
  36   if (!buffer) {
  37     NOTREACHED() << "Invalid buffer_id.";
  38     return base::SharedMemory::NULLHandle();
  39   }
  40   base::SharedMemoryHandle remote_handle;
  41   buffer->shared_memory.ShareToProcess(process_handle, &remote_handle);
  42   *memory_size = buffer->shared_memory.requested_size();
  43   return remote_handle;
  44 }
  45
  46 bool VideoCaptureBufferPool::GetBufferInfo(int buffer_id,
  47                                            void** memory,
  48                                            size_t* size) {
  49   base::AutoLock lock(lock_);
  50
  51   Buffer* buffer = GetBuffer(buffer_id);
  52   if (!buffer) {
  53     NOTREACHED() << "Invalid buffer_id.";
  54     return false;
  55   }
  56
  57   DCHECK(buffer->held_by_producer);
  58   *memory = buffer->shared_memory.memory();
  59   *size = buffer->shared_memory.mapped_size();
  60   return true;
  61 }
  62
  63 int VideoCaptureBufferPool::ReserveForProducer(size_t size,
  64                                                int* buffer_id_to_drop) {
  65   base::AutoLock lock(lock_);
  66   return ReserveForProducerInternal(size, buffer_id_to_drop);
  67 }
  68
  69 void VideoCaptureBufferPool::RelinquishProducerReservation(int buffer_id) {
  70   base::AutoLock lock(lock_);
  71   Buffer* buffer = GetBuffer(buffer_id);
  72   if (!buffer) {
  73     NOTREACHED() << "Invalid buffer_id.";
  74     return;
  75   }
  76   DCHECK(buffer->held_by_producer);
  77   buffer->held_by_producer = false;
  78 }
  79
  80 void VideoCaptureBufferPool::HoldForConsumers(
  81     int buffer_id,
  82     int num_clients) {
  83   base::AutoLock lock(lock_);
  84   Buffer* buffer = GetBuffer(buffer_id);
  85   if (!buffer) {
  86     NOTREACHED() << "Invalid buffer_id.";
  87     return;
  88   }
  89   DCHECK(buffer->held_by_producer);
  90   DCHECK(!buffer->consumer_hold_count);
  91
  92   buffer->consumer_hold_count = num_clients;
  93   // Note: |held_by_producer| will stay true until
  94   // RelinquishProducerReservation() (usually called by destructor of the object
  95   // wrapping this buffer, e.g. a media::VideoFrame).
  96 }
  97
  98 void VideoCaptureBufferPool::RelinquishConsumerHold(int buffer_id,
  99                                                     int num_clients) {
 100   base::AutoLock lock(lock_);
 101   Buffer* buffer = GetBuffer(buffer_id);
 102   if (!buffer) {
 103     NOTREACHED() << "Invalid buffer_id.";
 104     return;
 105   }
 106   DCHECK_GE(buffer->consumer_hold_count, num_clients);
 107
 108   buffer->consumer_hold_count -= num_clients;
 109 }
 110
 111 VideoCaptureBufferPool::Buffer::Buffer()
 112     : held_by_producer(false), consumer_hold_count(0) {}
 113
 114 int VideoCaptureBufferPool::ReserveForProducerInternal(size_t size,
 115                                                        int* buffer_id_to_drop) {
 116   lock_.AssertAcquired();
 117
 118   // Look for a buffer that's allocated, big enough, and not in use. Track the
 119   // largest one that's not big enough, in case we have to reallocate a buffer.
 120   *buffer_id_to_drop = kInvalidId;
 121   size_t realloc_size = 0;
 122   BufferMap::iterator realloc = buffers_.end();
 123   for (BufferMap::iterator it = buffers_.begin(); it != buffers_.end(); ++it) {
 124     Buffer* buffer = it->second;
 125     if (!buffer->consumer_hold_count && !buffer->held_by_producer) {
 126       if (buffer->shared_memory.requested_size() >= size) {
 127         // Existing buffer is big enough. Reuse it.
 128         buffer->held_by_producer = true;
 129         return it->first;
 130       }
 131       if (buffer->shared_memory.requested_size() > realloc_size) {
 132         realloc_size = buffer->shared_memory.requested_size();
 133         realloc = it;
 134       }
 135     }
 136   }
 137
 138   // Preferentially grow the pool by creating a new buffer. If we're at maximum
 139   // size, then reallocate by deleting an existing one instead.
 140   if (buffers_.size() == static_cast<size_t>(count_)) {
 141     if (realloc == buffers_.end()) {
 142       // We're out of space, and can't find an unused buffer to reallocate.
 143       return kInvalidId;
 144     }
 145     *buffer_id_to_drop = realloc->first;
 146     delete realloc->second;
 147     buffers_.erase(realloc);
 148   }
 149
 150   // Create the new buffer.
 151   int buffer_id = next_buffer_id_++;
 152   scoped_ptr<Buffer> buffer(new Buffer());
 153   if (size) {
 154     // |size| can be 0 for buffers that do not require memory backing.
 155     if (!buffer->shared_memory.CreateAndMapAnonymous(size))
 156       return kInvalidId;
 157   }
 158   buffer->held_by_producer = true;
 159   buffers_[buffer_id] = buffer.release();
 160   return buffer_id;
 161 }
 162
 163 VideoCaptureBufferPool::Buffer* VideoCaptureBufferPool::GetBuffer(
 164     int buffer_id) {
 165   BufferMap::iterator it = buffers_.find(buffer_id);
 166   if (it == buffers_.end())
 167     return NULL;
 168   return it->second;
 169 }
 170
 171 }  // namespace content