Line data    Source code

       1             : /* This Source Code Form is subject to the terms of the Mozilla Public
       2             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       3             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
       4             : 
       5             : #include "mp4_demuxer/BufferStream.h"
       6             : #include "MediaData.h"
       7             : #include "MediaResource.h"
       8             : #include <algorithm>
       9             : 
      10             : using namespace mozilla;
      11             : 
      12             : namespace mp4_demuxer {
      13             : 
      14           0 : BufferStream::BufferStream()
      15             :   : mStartOffset(0)
      16           0 :   , mData(new mozilla::MediaByteBuffer)
      17             : {
      18           0 : }
      19             : 
      20           0 : BufferStream::BufferStream(mozilla::MediaByteBuffer* aBuffer)
      21             :   : mStartOffset(0)
      22           0 :   , mData(aBuffer)
      23             : {
      24           0 : }
      25             : 
      26           0 : BufferStream::~BufferStream()
      27             : {
      28           0 : }
      29             : 
      30             : /*virtual*/ bool
      31           0 : BufferStream::ReadAt(int64_t aOffset, void* aData, size_t aLength,
      32             :                      size_t* aBytesRead)
      33             : {
      34           0 :   if (aOffset < mStartOffset || aOffset > mStartOffset + mData->Length()) {
      35           0 :     return false;
      36             :   }
      37           0 :   *aBytesRead =
      38           0 :     std::min(aLength, size_t(mStartOffset + mData->Length() - aOffset));
      39           0 :   memcpy(aData, mData->Elements() + aOffset - mStartOffset, *aBytesRead);
      40           0 :   return true;
      41             : }
      42             : 
      43             : /*virtual*/ bool
      44           0 : BufferStream::CachedReadAt(int64_t aOffset, void* aData, size_t aLength,
      45             :                            size_t* aBytesRead)
      46             : {
      47           0 :   return ReadAt(aOffset, aData, aLength, aBytesRead);
      48             : }
      49             : 
      50             : /*virtual*/ bool
      51           0 : BufferStream::Length(int64_t* aLength)
      52             : {
      53           0 :   *aLength = mStartOffset + mData->Length();
      54           0 :   return true;
      55             : }
      56             : 
      57             : /* virtual */ void
      58           0 : BufferStream::DiscardBefore(int64_t aOffset)
      59             : {
      60           0 :   if (aOffset > mStartOffset) {
      61           0 :     mData->RemoveElementsAt(0, aOffset - mStartOffset);
      62           0 :     mStartOffset = aOffset;
      63             :   }
      64           0 : }
      65             : 
      66             : bool
      67           0 : BufferStream::AppendBytes(const uint8_t* aData, size_t aLength)
      68             : {
      69           0 :   return mData->AppendElements(aData, aLength, fallible);
      70             : }
      71             : 
      72             : MediaByteRange
      73           0 : BufferStream::GetByteRange()
      74             : {
      75           0 :   return MediaByteRange(mStartOffset, mStartOffset + mData->Length());
      76             : }
      77             : }