dom/media/MediaSpan.h
author smolnar <smolnar@mozilla.com>
Thu, 29 Oct 2020 11:49:46 +0200
changeset 554999 3d5f376d44e0af99365a1372893c79ce5002711e
parent 483362 82c5bbd69b94982122235a17aa6dba1b6edcf55c
permissions -rw-r--r--
Merge autoland to mozilla-central. a=merge

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#if !defined(MediaSpan_h)
#  define MediaSpan_h

#  include "MediaData.h"
#  include "mozilla/RefPtr.h"
#  include "mozilla/Span.h"

namespace mozilla {

// A MediaSpan wraps a MediaByteBuffer and exposes a slice/span, or subregion,
// of the buffer. This allows you to slice off a logical subregion without
// needing to reallocate a new buffer to hold it. You can also append to a
// MediaSpan without affecting other MediaSpans referencing the same buffer
// (the MediaSpan receiving the append will allocate a new buffer to store its
// result if necessary, to ensure other MediaSpans referencing its original
// buffer are unaffected). Note there are no protections here that something
// other than MediaSpans doesn't modify the underlying MediaByteBuffer while
// a MediaSpan is alive.
class MediaSpan {
 public:
  ~MediaSpan() = default;

  explicit MediaSpan(const MediaSpan& aOther) = default;

  MediaSpan(MediaSpan&& aOther) = default;

  explicit MediaSpan(const RefPtr<MediaByteBuffer>& aBuffer)
      : mBuffer(aBuffer), mStart(0), mLength(aBuffer ? aBuffer->Length() : 0) {
    MOZ_DIAGNOSTIC_ASSERT(mBuffer);
  }

  explicit MediaSpan(MediaByteBuffer* aBuffer)
      : mBuffer(aBuffer), mStart(0), mLength(aBuffer ? aBuffer->Length() : 0) {
    MOZ_DIAGNOSTIC_ASSERT(mBuffer);
  }

  MediaSpan& operator=(const MediaSpan& aOther) = default;

  static MediaSpan WithCopyOf(const RefPtr<MediaByteBuffer>& aBuffer) {
    RefPtr<MediaByteBuffer> buffer = new MediaByteBuffer(aBuffer->Length());
    buffer->AppendElements(*aBuffer);
    return MediaSpan(buffer);
  }

  bool IsEmpty() const { return Length() == 0; }

  // Note: It's unsafe to store the pointer returned by this function, as an
  // append operation could cause the wrapped MediaByteBuffer to be
  // reallocated, invalidating pointers previously returned by this function.
  const uint8_t* Elements() const {
    MOZ_DIAGNOSTIC_ASSERT(mStart < mBuffer->Length());
    return mBuffer->Elements() + mStart;
  }

  size_t Length() const { return mLength; }

  uint8_t operator[](size_t aIndex) const {
    MOZ_DIAGNOSTIC_ASSERT(aIndex < Length());
    return (*mBuffer)[mStart + aIndex];
  }

  bool Append(const MediaSpan& aBuffer) { return Append(aBuffer.Buffer()); }

  bool Append(MediaByteBuffer* aBuffer) {
    if (!aBuffer) {
      return true;
    }
    if (mStart + mLength < mBuffer->Length()) {
      // This MediaSpan finishes before the end of its buffer. The buffer
      // could be shared with another MediaSpan. So we can't just append to
      // the underlying buffer without risking damaging other MediaSpans' data.
      // So we must reallocate a new buffer, copy our old data into it, and
      // append the new data into it.
      RefPtr<MediaByteBuffer> buffer =
          new MediaByteBuffer(mLength + aBuffer->Length());
      if (!buffer->AppendElements(Elements(), Length(), fallible) ||
          !buffer->AppendElements(*aBuffer, fallible)) {
        return false;
      }
      mBuffer = buffer;
      mLength += aBuffer->Length();
      return true;
    }
    if (!mBuffer->AppendElements(*aBuffer, fallible)) {
      return false;
    }
    mLength += aBuffer->Length();
    return true;
  }

  // Returns a new MediaSpan, spanning from the start of this span,
  // up until aEnd.
  MediaSpan To(size_t aEnd) const {
    MOZ_DIAGNOSTIC_ASSERT(aEnd <= Length());
    return MediaSpan(mBuffer, mStart, aEnd);
  }

  // Returns a new MediaSpan, spanning from aStart bytes offset from
  // the start of this span, until the end of this span.
  MediaSpan From(size_t aStart) const {
    MOZ_DIAGNOSTIC_ASSERT(aStart <= Length());
    return MediaSpan(mBuffer, mStart + aStart, Length() - aStart);
  }

  void RemoveFront(size_t aNumBytes) {
    MOZ_DIAGNOSTIC_ASSERT(aNumBytes <= Length());
    mStart += aNumBytes;
    mLength -= aNumBytes;
  }

  MediaByteBuffer* Buffer() const { return mBuffer; }

 private:
  MediaSpan(MediaByteBuffer* aBuffer, size_t aStart, size_t aLength)
      : mBuffer(aBuffer), mStart(aStart), mLength(aLength) {
    MOZ_DIAGNOSTIC_ASSERT(mStart + mLength <= mBuffer->Length());
  }

  RefPtr<MediaByteBuffer> mBuffer;
  size_t mStart = 0;
  size_t mLength = 0;
};

}  // namespace mozilla

#endif  // MediaSpan_h