box_reader.cc

// 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.

#include "packager/media/formats/mp4/box_reader.h"

#include <inttypes.h>

#include <limits>

#include "packager/base/logging.h"
#include "packager/base/memory/scoped_ptr.h"
#include "packager/base/strings/stringprintf.h"
#include "packager/media/formats/mp4/box.h"

namespace shaka {
namespace media {
namespace mp4 {

BoxReader::BoxReader(const uint8_t* buf, size_t size)
    : BufferReader(buf, size), type_(FOURCC_NULL), scanned_(false) {
  DCHECK(buf);
  DCHECK_LT(0u, size);
}

BoxReader::~BoxReader() {
  if (scanned_ && !children_.empty()) {
    for (ChildMap::iterator itr = children_.begin(); itr != children_.end();
         ++itr) {
      DVLOG(1) << "Skipping unknown box: " << FourCCToString(itr->first);
      delete itr->second;
    }
  }
}

// static
BoxReader* BoxReader::ReadBox(const uint8_t* buf,
                              const size_t buf_size,
                              bool* err) {
  scoped_ptr<BoxReader> reader(new BoxReader(buf, buf_size));
  if (!reader->ReadHeader(err))
    return NULL;

  // We don't require the complete box to be available for MDAT box.
  if (reader->type() == FOURCC_mdat)
    return reader.release();

  if (reader->size() <= buf_size)
    return reader.release();

  return NULL;
}

// static
bool BoxReader::StartBox(const uint8_t* buf,
                         const size_t buf_size,
                         FourCC* type,
                         uint64_t* box_size,
                         bool* err) {
  BoxReader reader(buf, buf_size);
  if (!reader.ReadHeader(err))
    return false;
  *type = reader.type();
  *box_size = reader.size();
  return true;
}

bool BoxReader::ScanChildren() {
  DCHECK(!scanned_);
  scanned_ = true;

  while (pos() < size()) {
    scoped_ptr<BoxReader> child(
        new BoxReader(&data()[pos()], size() - pos()));
    bool err;
    if (!child->ReadHeader(&err))
      return false;

    FourCC box_type = child->type();
    size_t box_size = child->size();
    children_.insert(std::pair<FourCC, BoxReader*>(box_type, child.release()));
    RCHECK(SkipBytes(box_size));
  }

  return true;
}

bool BoxReader::ReadChild(Box* child) {
  DCHECK(scanned_);
  FourCC child_type = child->BoxType();

  ChildMap::iterator itr = children_.find(child_type);
  RCHECK(itr != children_.end());
  DVLOG(2) << "Found a " << FourCCToString(child_type) << " box.";
  RCHECK(child->Parse(itr->second));
  delete itr->second;
  children_.erase(itr);
  return true;
}

bool BoxReader::ChildExist(Box* child) {
  return children_.count(child->BoxType()) > 0;
}

bool BoxReader::TryReadChild(Box* child) {
  if (!children_.count(child->BoxType()))
    return true;
  return ReadChild(child);
}

bool BoxReader::ReadHeader(bool* err) {
  uint64_t size = 0;
  *err = false;

  if (!ReadNBytesInto8(&size, sizeof(uint32_t)) || !ReadFourCC(&type_))
    return false;

  if (size == 0) {
    // Boxes that run to EOS are not supported.
    NOTIMPLEMENTED() << base::StringPrintf("Box '%s' run to EOS.",
                                           FourCCToString(type_).c_str());
    *err = true;
    return false;
  } else if (size == 1) {
    if (!Read8(&size))
      return false;
  }

  // The box should have at least the size of what have been parsed.
  if (size < pos()) {
    LOG(ERROR) << base::StringPrintf("Box '%s' with size (%" PRIu64
                                     ") is invalid.",
                                     FourCCToString(type_).c_str(),
                                     size);
    *err = true;
    return false;
  }

  // 'mdat' box could have a 64-bit size; other boxes should be very small.
  if (size > static_cast<uint64_t>(std::numeric_limits<int32_t>::max()) &&
      type_ != FOURCC_mdat) {
    LOG(ERROR) << base::StringPrintf("Box '%s' size (%" PRIu64
                                     ") is too large.",
                                     FourCCToString(type_).c_str(),
                                     size);
    *err = true;
    return false;
  }

  // Note that the pos_ head has advanced to the byte immediately after the
  // header, which is where we want it.
  set_size(size);
  return true;
}

}  // namespace mp4
}  // namespace media
}  // namespace shaka