third_party/chromium/media/base/decoder_buffer.h - cobalt - Git at Google

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #ifndef MEDIA_BASE_DECODER_BUFFER_H_
 #define MEDIA_BASE_DECODER_BUFFER_H_

 #include <stddef.h>
 #include <stdint.h>

 #include <memory>
 #include <string>
 #include <utility>

 #include "base/check.h"
 #include "base/macros.h"
 #include "base/memory/read_only_shared_memory_region.h"
 #include "base/memory/ref_counted.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/media_export.h"
 #include "media/base/timestamp_constants.h"
 #if defined(STARBOARD)
 #include "starboard/media.h"
 #else  // defined(STARBOARD)
 #include "media/base/unaligned_shared_memory.h"
 #endif  // defined(STARBOARD)

 namespace media {

 // A specialized buffer for interfacing with audio / video decoders.
 //
 // Also includes decoder specific functionality for decryption.
 //
 // NOTE: It is illegal to call any method when end_of_stream() is true.
 class MEDIA_EXPORT DecoderBuffer
     : public base::RefCountedThreadSafe<DecoderBuffer> {
  public:
   enum {
     kPaddingSize = 64,
 #if defined(ARCH_CPU_ARM_FAMILY)
     kAlignmentSize = 16
 #else
     kAlignmentSize = 32
 #endif
   };

 #if defined(STARBOARD)
   class Allocator {
    public:
     static Allocator* GetInstance();

     // The function should never return nullptr.  It may terminate the app on
     // allocation failure.
     virtual void* Allocate(size_t size, size_t alignment) = 0;
     virtual void Free(void* p, size_t size) = 0;

     virtual int GetAudioBufferBudget() const = 0;
     virtual int GetBufferAlignment() const = 0;
     virtual int GetBufferPadding() const = 0;
     virtual SbTime GetBufferGarbageCollectionDurationThreshold() const = 0;
     virtual int GetProgressiveBufferBudget(SbMediaVideoCodec codec,
                                            int resolution_width,
                                            int resolution_height,
                                            int bits_per_pixel) const = 0;
     virtual int GetVideoBufferBudget(SbMediaVideoCodec codec,
                                      int resolution_width,
                                      int resolution_height,
                                      int bits_per_pixel) const = 0;

    protected:
     ~Allocator() {}

     static void Set(Allocator* allocator);
   };
 #endif  // defined(STARBOARD)

   // Allocates buffer with |size| >= 0. |is_key_frame_| will default to false.
   explicit DecoderBuffer(size_t size);

   // Create a DecoderBuffer whose |data_| is copied from |data|. |data| must not
   // be NULL and |size| >= 0. The buffer's |is_key_frame_| will default to
   // false.
   static scoped_refptr<DecoderBuffer> CopyFrom(const uint8_t* data,
                                                size_t size);

   // Create a DecoderBuffer whose |data_| is copied from |data| and |side_data_|
   // is copied from |side_data|. Data pointers must not be NULL and sizes must
   // be >= 0. The buffer's |is_key_frame_| will default to false.
   static scoped_refptr<DecoderBuffer> CopyFrom(const uint8_t* data,
                                                size_t size,
                                                const uint8_t* side_data,
                                                size_t side_data_size);

 #if !defined(STARBOARD)
   // Create a DecoderBuffer where data() of |size| bytes resides within the heap
   // as byte array. The buffer's |is_key_frame_| will default to false.
   //
   // Ownership of |data| is transferred to the buffer.
   static scoped_refptr<DecoderBuffer> FromArray(std::unique_ptr<uint8_t[]> data,
                                                 size_t size);

   // Create a DecoderBuffer where data() of |size| bytes resides within the
   // memory referred to by |region| at non-negative offset |offset|. The
   // buffer's |is_key_frame_| will default to false.
   //
   // The shared memory will be mapped read-only.
   //
   // If mapping fails, nullptr will be returned.
   static scoped_refptr<DecoderBuffer> FromSharedMemoryRegion(
       base::subtle::PlatformSharedMemoryRegion region,
       off_t offset,
       size_t size);

   // Create a DecoderBuffer where data() of |size| bytes resides within the
   // ReadOnlySharedMemoryRegion referred to by |mapping| at non-negative offset
   // |offset|. The buffer's |is_key_frame_| will default to false.
   //
   // Ownership of |region| is transferred to the buffer.
   static scoped_refptr<DecoderBuffer> FromSharedMemoryRegion(
       base::ReadOnlySharedMemoryRegion region,
       off_t offset,
       size_t size);
 #endif  // !defined(STARBOARD)

   // Create a DecoderBuffer indicating we've reached end of stream.
   //
   // Calling any method other than end_of_stream() on the resulting buffer
   // is disallowed.
   static scoped_refptr<DecoderBuffer> CreateEOSBuffer();

   base::TimeDelta timestamp() const {
     DCHECK(!end_of_stream());
     return timestamp_;
   }

   // TODO(dalecurtis): This should be renamed at some point, but to avoid a yak
   // shave keep as a virtual with hacker_style() for now.
   virtual void set_timestamp(base::TimeDelta timestamp);

   base::TimeDelta duration() const {
     DCHECK(!end_of_stream());
     return duration_;
   }

   void set_duration(base::TimeDelta duration) {
     DCHECK(!end_of_stream());
     DCHECK(duration == kNoTimestamp ||
            (duration >= base::TimeDelta() && duration != kInfiniteDuration))
         << duration.InSecondsF();
     duration_ = duration;
   }

   const uint8_t* data() const {
     DCHECK(!end_of_stream());

 #if defined(STARBOARD)
     return data_;
 #else  // defined(STARBOARD)
     if (shared_mem_mapping_ && shared_mem_mapping_->IsValid())
       return static_cast<const uint8_t*>(shared_mem_mapping_->memory());
     if (shm_)
       return static_cast<uint8_t*>(shm_->memory());
     return data_.get();
 #endif  // defined(STARBOARD)
   }

   // TODO(sandersd): Remove writable_data(). https://crbug.com/834088
   uint8_t* writable_data() const {
     DCHECK(!end_of_stream());

 #if defined(STARBOARD)
     return data_;
 #else  // defined(STARBOARD)
     DCHECK(!shm_);
     DCHECK(!shared_mem_mapping_);
     return data_.get();
 #endif  // defined(STARBOARD)
   }

   size_t data_size() const {
     DCHECK(!end_of_stream());
     return size_;
   }

   const uint8_t* side_data() const {
     DCHECK(!end_of_stream());
     return side_data_.get();
   }

   size_t side_data_size() const {
     DCHECK(!end_of_stream());
     return side_data_size_;
   }

   typedef std::pair<base::TimeDelta, base::TimeDelta> DiscardPadding;
   const DiscardPadding& discard_padding() const {
     DCHECK(!end_of_stream());
     return discard_padding_;
   }

   void set_discard_padding(const DiscardPadding& discard_padding) {
     DCHECK(!end_of_stream());
     discard_padding_ = discard_padding;
   }

   // Returns DecryptConfig associated with |this|. Returns null iff |this| is
   // not encrypted.
   const DecryptConfig* decrypt_config() const {
     DCHECK(!end_of_stream());
     return decrypt_config_.get();
   }

   void set_decrypt_config(std::unique_ptr<DecryptConfig> decrypt_config) {
     DCHECK(!end_of_stream());
     decrypt_config_ = std::move(decrypt_config);
   }

   // If there's no data in this buffer, it represents end of stream.
 #if defined(STARBOARD)
   bool end_of_stream() const { return !data_; }
   void shrink_to(size_t size) { DCHECK_LE(size, size_); size_ = size; }
 #else  // defined(STARBOARD)
   bool end_of_stream() const { return !shared_mem_mapping_ && !shm_ && !data_; }
 #endif  // defined(STARBOARD)

   bool is_key_frame() const {
     DCHECK(!end_of_stream());
     return is_key_frame_;
   }

   void set_is_key_frame(bool is_key_frame) {
     DCHECK(!end_of_stream());
     is_key_frame_ = is_key_frame;
   }

   // Returns true if all fields in |buffer| matches this buffer
   // including |data_| and |side_data_|.
   bool MatchesForTesting(const DecoderBuffer& buffer) const;

   // Returns a human-readable string describing |*this|.
   std::string AsHumanReadableString(bool verbose = false) const;

   // Replaces any existing side data with data copied from |side_data|.
   void CopySideDataFrom(const uint8_t* side_data, size_t side_data_size);

  protected:
   friend class base::RefCountedThreadSafe<DecoderBuffer>;

   // Allocates a buffer of size |size| >= 0 and copies |data| into it. If |data|
   // is NULL then |data_| is set to NULL and |buffer_size_| to 0.
   // |is_key_frame_| will default to false.
   DecoderBuffer(const uint8_t* data,
                 size_t size,
                 const uint8_t* side_data,
                 size_t side_data_size);

 #if !defined(STARBOARD)
   DecoderBuffer(std::unique_ptr<uint8_t[]> data, size_t size);

   DecoderBuffer(std::unique_ptr<UnalignedSharedMemory> shm, size_t size);

   DecoderBuffer(std::unique_ptr<ReadOnlyUnalignedMapping> shared_mem_mapping,
                 size_t size);
 #endif  // !defined(STARBOARD)

   virtual ~DecoderBuffer();

 #if defined(STARBOARD)
   // Encoded data, allocated from DecoderBuffer::Allocator.
   uint8_t* data_ = nullptr;
   size_t allocated_size_ = 0;
 #else  // defined(STARBOARD)
   // Encoded data, if it is stored on the heap.
   std::unique_ptr<uint8_t[]> data_;
 #endif  // defined(STARBOARD)

  private:
   // Presentation time of the frame.
   base::TimeDelta timestamp_;
   // Presentation duration of the frame.
   base::TimeDelta duration_;

   // Size of the encoded data.
   size_t size_;

   // Side data. Used for alpha channel in VPx, and for text cues.
   size_t side_data_size_;
   std::unique_ptr<uint8_t[]> side_data_;

 #if !defined(STARBOARD)
   // Encoded data, if it is stored in a shared memory mapping.
   std::unique_ptr<ReadOnlyUnalignedMapping> shared_mem_mapping_;

   // Encoded data, if it is stored in SHM.
   std::unique_ptr<UnalignedSharedMemory> shm_;
 #endif  // !defined(STARBOARD)

   // Encryption parameters for the encoded data.
   std::unique_ptr<DecryptConfig> decrypt_config_;

   // Duration of (audio) samples from the beginning and end of this frame which
   // should be discarded after decoding. A value of kInfiniteDuration for the
   // first value indicates the entire frame should be discarded; the second
   // value must be base::TimeDelta() in this case.
   DiscardPadding discard_padding_;

   // Whether the frame was marked as a keyframe in the container.
   bool is_key_frame_;

   // Constructor helper method for memory allocations.
   void Initialize();

   DISALLOW_COPY_AND_ASSIGN(DecoderBuffer);
 };

 }  // namespace media

 #endif  // MEDIA_BASE_DECODER_BUFFER_H_
	// Copyright (c) 2012 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#ifndef MEDIA_BASE_DECODER_BUFFER_H_
	#define MEDIA_BASE_DECODER_BUFFER_H_

	#include <stddef.h>
	#include <stdint.h>

	#include <memory>
	#include <string>
	#include <utility>

	#include "base/check.h"
	#include "base/macros.h"
	#include "base/memory/read_only_shared_memory_region.h"
	#include "base/memory/ref_counted.h"
	#include "base/time/time.h"
	#include "build/build_config.h"
	#include "media/base/decrypt_config.h"
	#include "media/base/media_export.h"
	#include "media/base/timestamp_constants.h"
	#if defined(STARBOARD)
	#include "starboard/media.h"
	#else // defined(STARBOARD)
	#include "media/base/unaligned_shared_memory.h"
	#endif // defined(STARBOARD)

	namespace media {

	// A specialized buffer for interfacing with audio / video decoders.
	//
	// Also includes decoder specific functionality for decryption.
	//
	// NOTE: It is illegal to call any method when end_of_stream() is true.
	class MEDIA_EXPORT DecoderBuffer
	: public base::RefCountedThreadSafe<DecoderBuffer> {
	public:
	enum {
	kPaddingSize = 64,
	#if defined(ARCH_CPU_ARM_FAMILY)
	kAlignmentSize = 16
	#else
	kAlignmentSize = 32
	#endif
	};

	#if defined(STARBOARD)
	class Allocator {
	public:
	static Allocator* GetInstance();

	// The function should never return nullptr. It may terminate the app on
	// allocation failure.
	virtual void* Allocate(size_t size, size_t alignment) = 0;
	virtual void Free(void* p, size_t size) = 0;

	virtual int GetAudioBufferBudget() const = 0;
	virtual int GetBufferAlignment() const = 0;
	virtual int GetBufferPadding() const = 0;
	virtual SbTime GetBufferGarbageCollectionDurationThreshold() const = 0;
	virtual int GetProgressiveBufferBudget(SbMediaVideoCodec codec,
	int resolution_width,
	int resolution_height,
	int bits_per_pixel) const = 0;
	virtual int GetVideoBufferBudget(SbMediaVideoCodec codec,
	int resolution_width,
	int resolution_height,
	int bits_per_pixel) const = 0;

	protected:
	~Allocator() {}

	static void Set(Allocator* allocator);
	};
	#endif // defined(STARBOARD)

	// Allocates buffer with \|size\| >= 0. \|is_key_frame_\| will default to false.
	explicit DecoderBuffer(size_t size);

	// Create a DecoderBuffer whose \|data_\| is copied from \|data\|. \|data\| must not
	// be NULL and \|size\| >= 0. The buffer's \|is_key_frame_\| will default to
	// false.
	static scoped_refptr<DecoderBuffer> CopyFrom(const uint8_t* data,
	size_t size);

	// Create a DecoderBuffer whose \|data_\| is copied from \|data\| and \|side_data_\|
	// is copied from \|side_data\|. Data pointers must not be NULL and sizes must
	// be >= 0. The buffer's \|is_key_frame_\| will default to false.
	static scoped_refptr<DecoderBuffer> CopyFrom(const uint8_t* data,
	size_t size,
	const uint8_t* side_data,
	size_t side_data_size);

	#if !defined(STARBOARD)
	// Create a DecoderBuffer where data() of \|size\| bytes resides within the heap
	// as byte array. The buffer's \|is_key_frame_\| will default to false.
	//
	// Ownership of \|data\| is transferred to the buffer.
	static scoped_refptr<DecoderBuffer> FromArray(std::unique_ptr<uint8_t[]> data,
	size_t size);

	// Create a DecoderBuffer where data() of \|size\| bytes resides within the
	// memory referred to by \|region\| at non-negative offset \|offset\|. The
	// buffer's \|is_key_frame_\| will default to false.
	//
	// The shared memory will be mapped read-only.
	//
	// If mapping fails, nullptr will be returned.
	static scoped_refptr<DecoderBuffer> FromSharedMemoryRegion(
	base::subtle::PlatformSharedMemoryRegion region,
	off_t offset,
	size_t size);

	// Create a DecoderBuffer where data() of \|size\| bytes resides within the
	// ReadOnlySharedMemoryRegion referred to by \|mapping\| at non-negative offset
	// \|offset\|. The buffer's \|is_key_frame_\| will default to false.
	//
	// Ownership of \|region\| is transferred to the buffer.
	static scoped_refptr<DecoderBuffer> FromSharedMemoryRegion(
	base::ReadOnlySharedMemoryRegion region,
	off_t offset,
	size_t size);
	#endif // !defined(STARBOARD)

	// Create a DecoderBuffer indicating we've reached end of stream.
	//
	// Calling any method other than end_of_stream() on the resulting buffer
	// is disallowed.
	static scoped_refptr<DecoderBuffer> CreateEOSBuffer();

	base::TimeDelta timestamp() const {
	DCHECK(!end_of_stream());
	return timestamp_;
	}

	// TODO(dalecurtis): This should be renamed at some point, but to avoid a yak
	// shave keep as a virtual with hacker_style() for now.
	virtual void set_timestamp(base::TimeDelta timestamp);

	base::TimeDelta duration() const {
	DCHECK(!end_of_stream());
	return duration_;
	}

	void set_duration(base::TimeDelta duration) {
	DCHECK(!end_of_stream());
	DCHECK(duration == kNoTimestamp \|\|
	(duration >= base::TimeDelta() && duration != kInfiniteDuration))
	<< duration.InSecondsF();
	duration_ = duration;
	}

	const uint8_t* data() const {
	DCHECK(!end_of_stream());

	#if defined(STARBOARD)
	return data_;
	#else // defined(STARBOARD)
	if (shared_mem_mapping_ && shared_mem_mapping_->IsValid())
	return static_cast<const uint8_t*>(shared_mem_mapping_->memory());
	if (shm_)
	return static_cast<uint8_t*>(shm_->memory());
	return data_.get();
	#endif // defined(STARBOARD)
	}

	// TODO(sandersd): Remove writable_data(). https://crbug.com/834088
	uint8_t* writable_data() const {
	DCHECK(!end_of_stream());

	#if defined(STARBOARD)
	return data_;
	#else // defined(STARBOARD)
	DCHECK(!shm_);
	DCHECK(!shared_mem_mapping_);
	return data_.get();
	#endif // defined(STARBOARD)
	}

	size_t data_size() const {
	DCHECK(!end_of_stream());
	return size_;
	}

	const uint8_t* side_data() const {
	DCHECK(!end_of_stream());
	return side_data_.get();
	}

	size_t side_data_size() const {
	DCHECK(!end_of_stream());
	return side_data_size_;
	}

	typedef std::pair<base::TimeDelta, base::TimeDelta> DiscardPadding;
	const DiscardPadding& discard_padding() const {
	DCHECK(!end_of_stream());
	return discard_padding_;
	}

	void set_discard_padding(const DiscardPadding& discard_padding) {
	DCHECK(!end_of_stream());
	discard_padding_ = discard_padding;
	}

	// Returns DecryptConfig associated with \|this\|. Returns null iff \|this\| is
	// not encrypted.
	const DecryptConfig* decrypt_config() const {
	DCHECK(!end_of_stream());
	return decrypt_config_.get();
	}

	void set_decrypt_config(std::unique_ptr<DecryptConfig> decrypt_config) {
	DCHECK(!end_of_stream());
	decrypt_config_ = std::move(decrypt_config);
	}

	// If there's no data in this buffer, it represents end of stream.
	#if defined(STARBOARD)
	bool end_of_stream() const { return !data_; }
	void shrink_to(size_t size) { DCHECK_LE(size, size_); size_ = size; }
	#else // defined(STARBOARD)
	bool end_of_stream() const { return !shared_mem_mapping_ && !shm_ && !data_; }
	#endif // defined(STARBOARD)

	bool is_key_frame() const {
	DCHECK(!end_of_stream());
	return is_key_frame_;
	}

	void set_is_key_frame(bool is_key_frame) {
	DCHECK(!end_of_stream());
	is_key_frame_ = is_key_frame;
	}

	// Returns true if all fields in \|buffer\| matches this buffer
	// including \|data_\| and \|side_data_\|.
	bool MatchesForTesting(const DecoderBuffer& buffer) const;

	// Returns a human-readable string describing \|*this\|.
	std::string AsHumanReadableString(bool verbose = false) const;

	// Replaces any existing side data with data copied from \|side_data\|.
	void CopySideDataFrom(const uint8_t* side_data, size_t side_data_size);

	protected:
	friend class base::RefCountedThreadSafe<DecoderBuffer>;

	// Allocates a buffer of size \|size\| >= 0 and copies \|data\| into it. If \|data\|
	// is NULL then \|data_\| is set to NULL and \|buffer_size_\| to 0.
	// \|is_key_frame_\| will default to false.
	DecoderBuffer(const uint8_t* data,
	size_t size,
	const uint8_t* side_data,
	size_t side_data_size);

	#if !defined(STARBOARD)
	DecoderBuffer(std::unique_ptr<uint8_t[]> data, size_t size);

	DecoderBuffer(std::unique_ptr<UnalignedSharedMemory> shm, size_t size);

	DecoderBuffer(std::unique_ptr<ReadOnlyUnalignedMapping> shared_mem_mapping,
	size_t size);
	#endif // !defined(STARBOARD)

	virtual ~DecoderBuffer();

	#if defined(STARBOARD)
	// Encoded data, allocated from DecoderBuffer::Allocator.
	uint8_t* data_ = nullptr;
	size_t allocated_size_ = 0;
	#else // defined(STARBOARD)
	// Encoded data, if it is stored on the heap.
	std::unique_ptr<uint8_t[]> data_;
	#endif // defined(STARBOARD)

	private:
	// Presentation time of the frame.
	base::TimeDelta timestamp_;
	// Presentation duration of the frame.
	base::TimeDelta duration_;

	// Size of the encoded data.
	size_t size_;

	// Side data. Used for alpha channel in VPx, and for text cues.
	size_t side_data_size_;
	std::unique_ptr<uint8_t[]> side_data_;

	#if !defined(STARBOARD)
	// Encoded data, if it is stored in a shared memory mapping.
	std::unique_ptr<ReadOnlyUnalignedMapping> shared_mem_mapping_;

	// Encoded data, if it is stored in SHM.
	std::unique_ptr<UnalignedSharedMemory> shm_;
	#endif // !defined(STARBOARD)

	// Encryption parameters for the encoded data.
	std::unique_ptr<DecryptConfig> decrypt_config_;

	// Duration of (audio) samples from the beginning and end of this frame which
	// should be discarded after decoding. A value of kInfiniteDuration for the
	// first value indicates the entire frame should be discarded; the second
	// value must be base::TimeDelta() in this case.
	DiscardPadding discard_padding_;

	// Whether the frame was marked as a keyframe in the container.
	bool is_key_frame_;

	// Constructor helper method for memory allocations.
	void Initialize();

	DISALLOW_COPY_AND_ASSIGN(DecoderBuffer);
	};

	} // namespace media

	#endif // MEDIA_BASE_DECODER_BUFFER_H_