// Copyright 2015 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 "mojo/public/cpp/environment/logging.h"
#include "mojo/services/media/common/cpp/mapped_shared_buffer.h"

namespace mojo {
namespace media {

MappedSharedBuffer::MappedSharedBuffer() {}

MappedSharedBuffer::~MappedSharedBuffer() {}

void MappedSharedBuffer::InitNew(uint64_t size) {
  MOJO_DCHECK(size > 0);

  buffer_.reset(new SharedBuffer(size));
  handle_.reset();

  InitInternal(buffer_->handle, size);
}

void MappedSharedBuffer::InitFromHandle(
    ScopedSharedBufferHandle handle,
    uint64_t size) {
  MOJO_DCHECK(handle.is_valid());
  MOJO_DCHECK(size > 0);

  buffer_.reset();
  handle_ = handle.Pass();

  InitInternal(handle_, size);
}

void MappedSharedBuffer::InitInternal(
    ScopedSharedBufferHandle& handle,
    uint64_t size) {
  MOJO_DCHECK(handle.is_valid());
  MOJO_DCHECK(size > 0);

  size_ = size;
  buffer_ptr_.reset();

  void* ptr;
  auto result = MapBuffer(
      handle.get(),
      0, // offset
      size,
      &ptr,
      MOJO_MAP_BUFFER_FLAG_NONE);
  MOJO_DCHECK(result == MOJO_RESULT_OK);
  MOJO_DCHECK(ptr);

  buffer_ptr_.reset(reinterpret_cast<uint8_t*>(ptr));

  OnInit();
}

bool MappedSharedBuffer::initialized() const {
  return buffer_ptr_ != nullptr;
}

uint64_t MappedSharedBuffer::size() const {
  return size_;
}

ScopedSharedBufferHandle MappedSharedBuffer::GetDuplicateHandle() const {
  MOJO_DCHECK(initialized());
  ScopedSharedBufferHandle handle;
  if (buffer_) {
    DuplicateBuffer(buffer_->handle.get(), nullptr, &handle);
  } else {
    MOJO_DCHECK(handle_.is_valid());
    DuplicateBuffer(handle_.get(), nullptr, &handle);
  }
  return handle.Pass();
}

void* MappedSharedBuffer::PtrFromOffset(uint64_t offset) const {
  MOJO_DCHECK(buffer_ptr_);

  if (offset == FifoAllocator::kNullOffset) {
    return nullptr;
  }

  MOJO_DCHECK(offset < size_);
  return buffer_ptr_.get() + offset;
}

uint64_t MappedSharedBuffer::OffsetFromPtr(void *ptr) const {
  MOJO_DCHECK(buffer_ptr_);
  if (ptr == nullptr) {
    return FifoAllocator::kNullOffset;
  }
  uint64_t offset = reinterpret_cast<uint8_t*>(ptr) - buffer_ptr_.get();
  MOJO_DCHECK(offset < size_);
  return offset;
}

void MappedSharedBuffer::OnInit() {}

} // namespace media
} // namespace mojo