ppapi/shared_impl/media_stream_buffer_manager.cc

   1 // Copyright 2014 The Chromium Authors
   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 "ppapi/shared_impl/media_stream_buffer_manager.h"
   6
   7 #include <stddef.h>
   8
   9 #include <utility>
  10
  11 #include "base/check_op.h"
  12 #include "base/logging.h"
  13 #include "ppapi/c/pp_errors.h"
  14 #include "ppapi/shared_impl/media_stream_buffer.h"
  15
  16 namespace ppapi {
  17
  18 MediaStreamBufferManager::Delegate::~Delegate() {}
  19
  20 void MediaStreamBufferManager::Delegate::OnNewBufferEnqueued() {}
  21
  22 MediaStreamBufferManager::MediaStreamBufferManager(Delegate* delegate)
  23     : delegate_(delegate), buffer_size_(0), number_of_buffers_(0) {
  24   DCHECK(delegate_);
  25 }
  26
  27 MediaStreamBufferManager::~MediaStreamBufferManager() {}
  28
  29 bool MediaStreamBufferManager::SetBuffers(int32_t number_of_buffers,
  30                                           int32_t buffer_size,
  31                                           base::UnsafeSharedMemoryRegion region,
  32                                           bool enqueue_all_buffers) {
  33   DCHECK(region.IsValid());
  34   DCHECK_GT(number_of_buffers, 0);
  35   DCHECK_GT(buffer_size,
  36             static_cast<int32_t>(sizeof(MediaStreamBuffer::Header)));
  37   DCHECK_EQ(buffer_size & 0x3, 0);
  38
  39   number_of_buffers_ = number_of_buffers;
  40   buffer_size_ = buffer_size;
  41
  42   size_t size = number_of_buffers_ * buffer_size;
  43   region_ = std::move(region);
  44   mapping_ = region_.MapAt(0, size);
  45   if (!mapping_.IsValid())
  46     return false;
  47
  48   buffer_queue_.clear();
  49   buffers_.clear();
  50   uint8_t* p = mapping_.GetMemoryAsSpan<uint8_t>().data();
  51   for (int32_t i = 0; i < number_of_buffers; ++i) {
  52     if (enqueue_all_buffers)
  53       buffer_queue_.push_back(i);
  54     buffers_.push_back(reinterpret_cast<MediaStreamBuffer*>(p));
  55     p += buffer_size_;
  56   }
  57   return true;
  58 }
  59
  60 int32_t MediaStreamBufferManager::DequeueBuffer() {
  61   if (buffer_queue_.empty()) {
  62     LOG(ERROR) << "Buffer queue is empty";
  63     return PP_ERROR_FAILED;
  64   }
  65   int32_t buffer = buffer_queue_.front();
  66   buffer_queue_.pop_front();
  67   return buffer;
  68 }
  69
  70 std::vector<int32_t> MediaStreamBufferManager::DequeueBuffers() {
  71   std::vector<int32_t> buffers(buffer_queue_.begin(), buffer_queue_.end());
  72   buffer_queue_.clear();
  73   return buffers;
  74 }
  75
  76 void MediaStreamBufferManager::EnqueueBuffer(int32_t index) {
  77   CHECK_GE(index, 0) << "Invalid buffer index";
  78   CHECK_LT(index, number_of_buffers_) << "Invalid buffer index";
  79   buffer_queue_.push_back(index);
  80   delegate_->OnNewBufferEnqueued();
  81 }
  82
  83 bool MediaStreamBufferManager::HasAvailableBuffer() {
  84   return !buffer_queue_.empty();
  85 }
  86
  87 MediaStreamBuffer* MediaStreamBufferManager::GetBufferPointer(int32_t index) {
  88   if (index < 0 || index >= number_of_buffers_)
  89     return NULL;
  90   return buffers_[index];
  91 }
  92
  93 }  // namespace ppapi