box_buffer.h

// Copyright 2014 Google LLC. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file or at
// https://developers.google.com/open-source/licenses/bsd
 
#ifndef PACKAGER_MEDIA_FORMATS_MP4_BOX_BUFFER_H_
#define PACKAGER_MEDIA_FORMATS_MP4_BOX_BUFFER_H_
 
#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>
 
#include <absl/log/check.h>
 
#include <packager/macros/classes.h>
#include <packager/media/base/buffer_writer.h>
#include <packager/media/base/fourccs.h>
#include <packager/media/formats/mp4/box.h>
#include <packager/media/formats/mp4/box_reader.h>
 
namespace shaka {
namespace media {
namespace mp4 {
 
class BoxBuffer {
 public:
  explicit BoxBuffer(BoxReader* reader) : reader_(reader), writer_(NULL) {
    DCHECK(reader);
  }
  explicit BoxBuffer(BufferWriter* writer) : reader_(NULL), writer_(writer) {
    DCHECK(writer);
  }
  ~BoxBuffer() {}
 
  bool Reading() const { return reader_ != NULL; }
 
  size_t Pos() const {
    if (reader_)
      return reader_->pos();
    return writer_->Size();
  }
 
  size_t Size() const {
    if (reader_)
      return reader_->size();
    return writer_->Size();
  }
 
  size_t BytesLeft() const {
    if (reader_)
      return reader_->size() - reader_->pos();
    return 0;
  }
 
  bool ReadWriteUInt8(uint8_t* v) {
    if (reader_)
      return reader_->Read1(v);
    writer_->AppendInt(*v);
    return true;
  }
  bool ReadWriteUInt16(uint16_t* v) {
    if (reader_)
      return reader_->Read2(v);
    writer_->AppendInt(*v);
    return true;
  }
  bool ReadWriteUInt32(uint32_t* v) {
    if (reader_)
      return reader_->Read4(v);
    writer_->AppendInt(*v);
    return true;
  }
  bool ReadWriteUInt64(uint64_t* v) {
    if (reader_)
      return reader_->Read8(v);
    writer_->AppendInt(*v);
    return true;
  }
  bool ReadWriteInt16(int16_t* v) {
    if (reader_)
      return reader_->Read2s(v);
    writer_->AppendInt(*v);
    return true;
  }
  bool ReadWriteInt32(int32_t* v) {
    if (reader_)
      return reader_->Read4s(v);
    writer_->AppendInt(*v);
    return true;
  }
  bool ReadWriteInt64(int64_t* v) {
    if (reader_)
      return reader_->Read8s(v);
    writer_->AppendInt(*v);
    return true;
  }
 
  bool ReadWriteUInt64NBytes(uint64_t* v, size_t num_bytes) {
    if (reader_)
      return reader_->ReadNBytesInto8(v, num_bytes);
    writer_->AppendNBytes(*v, num_bytes);
    return true;
  }
  bool ReadWriteInt64NBytes(int64_t* v, size_t num_bytes) {
    if (reader_)
      return reader_->ReadNBytesInto8s(v, num_bytes);
    writer_->AppendNBytes(*v, num_bytes);
    return true;
  }
  bool ReadWriteVector(std::vector<uint8_t>* vector, size_t count) {
    if (reader_)
      return reader_->ReadToVector(vector, count);
    DCHECK_EQ(vector->size(), count);
    writer_->AppendArray(vector->data(), count);
    return true;
  }
 
  bool ReadWriteString(std::string* str, size_t size) {
    if (reader_)
      return reader_->ReadToString(str, size);
    DCHECK_EQ(str->size(), size);
    writer_->AppendArray(reinterpret_cast<const uint8_t*>(str->data()),
                         str->size());
    return true;
  }
 
  bool ReadWriteCString(std::string* str) {
    if (reader_)
      return reader_->ReadCString(str);
    // Cannot contain embedded nulls.
    DCHECK_EQ(str->find('\0'), std::string::npos);
    writer_->AppendString(*str);
    writer_->AppendInt(static_cast<uint8_t>('\0'));
    return true;
  }
 
  bool ReadWriteFourCC(FourCC* fourcc) {
    if (reader_)
      return reader_->ReadFourCC(fourcc);
    writer_->AppendInt(static_cast<uint32_t>(*fourcc));
    return true;
  }
 
  bool PrepareChildren() {
    if (reader_)
      return reader_->ScanChildren();
    // NOP in write mode.
    return true;
  }
 
  bool ReadWriteChild(Box* box) {
    if (reader_)
      return reader_->ReadChild(box);
    // The box is mandatory, i.e. the box size should not be 0.
    DCHECK_NE(0u, box->box_size());
    CHECK(box->ReadWriteInternal(this));
    return true;
  }
 
  bool TryReadWriteChild(Box* box) {
    if (reader_)
      return reader_->TryReadChild(box);
    // The box is optional, i.e. it can be skipped if the box size is 0.
    if (box->box_size() != 0)
      CHECK(box->ReadWriteInternal(this));
    return true;
  }
 
  bool IgnoreBytes(size_t num_bytes) {
    if (reader_)
      return reader_->SkipBytes(num_bytes);
    std::vector<uint8_t> vector(num_bytes, 0);
    writer_->AppendVector(vector);
    return true;
  }
 
  BoxReader* reader() { return reader_; }
  BufferWriter* writer() { return writer_; }
 
 private:
  BoxReader* reader_;
  BufferWriter* writer_;
 
  DISALLOW_COPY_AND_ASSIGN(BoxBuffer);
};
 
}  // namespace mp4
}  // namespace media
}  // namespace shaka
 
#endif  // PACKAGER_MEDIA_FORMATS_MP4_BOX_BUFFER_H_