media/cdm/ppapi/cdm_helpers.h

   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 #ifndef MEDIA_CDM_PPAPI_CDM_HELPERS_H_
   6 #define MEDIA_CDM_PPAPI_CDM_HELPERS_H_
   7
   8 #include <map>
   9 #include <utility>
  10
  11 #include "base/basictypes.h"
  12 #include "base/compiler_specific.h"
  13 #include "build/build_config.h"
  14 #include "media/cdm/ppapi/api/content_decryption_module.h"
  15 #include "ppapi/c/pp_errors.h"
  16 #include "ppapi/c/pp_stdint.h"
  17 #include "ppapi/cpp/dev/buffer_dev.h"
  18 #include "ppapi/cpp/instance.h"
  19 #include "ppapi/cpp/logging.h"
  20
  21 namespace media {
  22
  23 // cdm::Buffer implementation that provides access to memory owned by a
  24 // pp::Buffer_Dev.
  25 // This class holds a reference to the Buffer_Dev throughout its lifetime.
  26 // TODO(xhwang): Find a better name. It's confusing to have PpbBuffer,
  27 // pp::Buffer_Dev and PPB_Buffer_Dev.
  28 class PpbBuffer : public cdm::Buffer {
  29  public:
  30   static PpbBuffer* Create(const pp::Buffer_Dev& buffer, uint32_t buffer_id) {
  31     PP_DCHECK(buffer.data());
  32     PP_DCHECK(buffer.size());
  33     PP_DCHECK(buffer_id);
  34     return new PpbBuffer(buffer, buffer_id);
  35   }
  36
  37   // cdm::Buffer implementation.
  38   virtual void Destroy() OVERRIDE { delete this; }
  39
  40   virtual uint32_t Capacity() const OVERRIDE { return buffer_.size(); }
  41
  42   virtual uint8_t* Data() OVERRIDE {
  43     return static_cast<uint8_t*>(buffer_.data());
  44   }
  45
  46   virtual void SetSize(uint32_t size) OVERRIDE {
  47     PP_DCHECK(size <= Capacity());
  48     if (size > Capacity()) {
  49       size_ = 0;
  50       return;
  51     }
  52
  53     size_ = size;
  54   }
  55
  56   virtual uint32_t Size() const OVERRIDE { return size_; }
  57
  58   pp::Buffer_Dev buffer_dev() const { return buffer_; }
  59
  60   uint32_t buffer_id() const { return buffer_id_; }
  61
  62  private:
  63   PpbBuffer(pp::Buffer_Dev buffer, uint32_t buffer_id)
  64       : buffer_(buffer),
  65         buffer_id_(buffer_id),
  66         size_(0) {}
  67   virtual ~PpbBuffer() {}
  68
  69   pp::Buffer_Dev buffer_;
  70   uint32_t buffer_id_;
  71   uint32_t size_;
  72
  73   DISALLOW_COPY_AND_ASSIGN(PpbBuffer);
  74 };
  75
  76 class PpbBufferAllocator {
  77  public:
  78   explicit PpbBufferAllocator(pp::Instance* instance)
  79       : instance_(instance),
  80         next_buffer_id_(1) {}
  81   ~PpbBufferAllocator() {}
  82
  83   cdm::Buffer* Allocate(uint32_t capacity);
  84
  85   // Releases the buffer with |buffer_id|. A buffer can be recycled after
  86   // it is released.
  87   void Release(uint32_t buffer_id);
  88
  89  private:
  90   typedef std::map<uint32_t, pp::Buffer_Dev> AllocatedBufferMap;
  91   typedef std::multimap<uint32_t, std::pair<uint32_t, pp::Buffer_Dev> >
  92       FreeBufferMap;
  93
  94   pp::Buffer_Dev AllocateNewBuffer(uint32_t capacity);
  95
  96   pp::Instance* const instance_;
  97   uint32_t next_buffer_id_;
  98   AllocatedBufferMap allocated_buffers_;
  99   FreeBufferMap free_buffers_;
 100
 101   DISALLOW_COPY_AND_ASSIGN(PpbBufferAllocator);
 102 };
 103
 104 class DecryptedBlockImpl : public cdm::DecryptedBlock {
 105  public:
 106   DecryptedBlockImpl() : buffer_(NULL), timestamp_(0) {}
 107   virtual ~DecryptedBlockImpl() { if (buffer_) buffer_->Destroy(); }
 108
 109   virtual void SetDecryptedBuffer(cdm::Buffer* buffer) OVERRIDE {
 110     buffer_ = static_cast<PpbBuffer*>(buffer);
 111   }
 112   virtual cdm::Buffer* DecryptedBuffer() OVERRIDE { return buffer_; }
 113
 114   virtual void SetTimestamp(int64_t timestamp) OVERRIDE {
 115     timestamp_ = timestamp;
 116   }
 117   virtual int64_t Timestamp() const OVERRIDE { return timestamp_; }
 118
 119  private:
 120   PpbBuffer* buffer_;
 121   int64_t timestamp_;
 122
 123   DISALLOW_COPY_AND_ASSIGN(DecryptedBlockImpl);
 124 };
 125
 126 class VideoFrameImpl : public cdm::VideoFrame {
 127  public:
 128   VideoFrameImpl();
 129   virtual ~VideoFrameImpl();
 130
 131   virtual void SetFormat(cdm::VideoFormat format) OVERRIDE {
 132     format_ = format;
 133   }
 134   virtual cdm::VideoFormat Format() const OVERRIDE { return format_; }
 135
 136   virtual void SetSize(cdm::Size size) OVERRIDE { size_ = size; }
 137   virtual cdm::Size Size() const OVERRIDE { return size_; }
 138
 139   virtual void SetFrameBuffer(cdm::Buffer* frame_buffer) OVERRIDE {
 140     frame_buffer_ = static_cast<PpbBuffer*>(frame_buffer);
 141   }
 142   virtual cdm::Buffer* FrameBuffer() OVERRIDE { return frame_buffer_; }
 143
 144   virtual void SetPlaneOffset(cdm::VideoFrame::VideoPlane plane,
 145                               uint32_t offset) OVERRIDE {
 146     PP_DCHECK(plane < kMaxPlanes);
 147     plane_offsets_[plane] = offset;
 148   }
 149   virtual uint32_t PlaneOffset(VideoPlane plane) OVERRIDE {
 150     PP_DCHECK(plane < kMaxPlanes);
 151     return plane_offsets_[plane];
 152   }
 153
 154   virtual void SetStride(VideoPlane plane, uint32_t stride) OVERRIDE {
 155     PP_DCHECK(plane < kMaxPlanes);
 156     strides_[plane] = stride;
 157   }
 158   virtual uint32_t Stride(VideoPlane plane) OVERRIDE {
 159     PP_DCHECK(plane < kMaxPlanes);
 160     return strides_[plane];
 161   }
 162
 163   virtual void SetTimestamp(int64_t timestamp) OVERRIDE {
 164     timestamp_ = timestamp;
 165   }
 166   virtual int64_t Timestamp() const OVERRIDE { return timestamp_; }
 167
 168  private:
 169   // The video buffer format.
 170   cdm::VideoFormat format_;
 171
 172   // Width and height of the video frame.
 173   cdm::Size size_;
 174
 175   // The video frame buffer.
 176   PpbBuffer* frame_buffer_;
 177
 178   // Array of data pointers to each plane in the video frame buffer.
 179   uint32_t plane_offsets_[kMaxPlanes];
 180
 181   // Array of strides for each plane, typically greater or equal to the width
 182   // of the surface divided by the horizontal sampling period.  Note that
 183   // strides can be negative.
 184   uint32_t strides_[kMaxPlanes];
 185
 186   // Presentation timestamp in microseconds.
 187   int64_t timestamp_;
 188
 189   DISALLOW_COPY_AND_ASSIGN(VideoFrameImpl);
 190 };
 191
 192 class AudioFramesImpl : public cdm::AudioFrames_1,
 193                         public cdm::AudioFrames_2 {
 194  public:
 195   AudioFramesImpl() : buffer_(NULL), format_(cdm::kUnknownAudioFormat) {}
 196   virtual ~AudioFramesImpl() {
 197     if (buffer_)
 198       buffer_->Destroy();
 199   }
 200
 201   // AudioFrames implementation.
 202   virtual void SetFrameBuffer(cdm::Buffer* buffer) OVERRIDE {
 203     buffer_ = static_cast<PpbBuffer*>(buffer);
 204   }
 205   virtual cdm::Buffer* FrameBuffer() OVERRIDE {
 206     return buffer_;
 207   }
 208   virtual void SetFormat(cdm::AudioFormat format) OVERRIDE {
 209     format_ = format;
 210   }
 211   virtual cdm::AudioFormat Format() const OVERRIDE {
 212     return format_;
 213   }
 214
 215   cdm::Buffer* PassFrameBuffer() {
 216     PpbBuffer* temp_buffer = buffer_;
 217     buffer_ = NULL;
 218     return temp_buffer;
 219   }
 220
 221  private:
 222   PpbBuffer* buffer_;
 223   cdm::AudioFormat format_;
 224
 225   DISALLOW_COPY_AND_ASSIGN(AudioFramesImpl);
 226 };
 227
 228 }  // namespace media
 229
 230 #endif  // MEDIA_CDM_PPAPI_CDM_HELPERS_H_