DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Mercurial (bffa34334d58)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
/* -*- 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