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