// Copyright 2016 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 "media/mojo/common/mojo_shared_buffer_video_frame.h"

#include <utility>
#include <vector>

#include "base/bind.h"
#include "base/callback.h"
#include "base/compiler_specific.h"
#include "base/logging.h"
#include "base/numerics/safe_conversions.h"
#include "base/numerics/safe_math.h"
#include "mojo/public/cpp/system/platform_handle.h"

namespace media {

// static
scoped_refptr<MojoSharedBufferVideoFrame>
MojoSharedBufferVideoFrame::CreateDefaultForTesting(
    const VideoPixelFormat format,
    const gfx::Size& dimensions,
    base::TimeDelta timestamp) {
  DCHECK(format == PIXEL_FORMAT_I420 || format == PIXEL_FORMAT_NV12);
  const gfx::Rect visible_rect(dimensions);

  // Since we're allocating memory for the new frame, pad the requested
  // size if necessary so that the requested size does line up on sample
  // boundaries. See related discussion in VideoFrame::CreateFrameInternal().
  const gfx::Size coded_size = DetermineAlignedSize(format, dimensions);
  if (!IsValidConfig(format, STORAGE_MOJO_SHARED_BUFFER, coded_size,
                     visible_rect, dimensions)) {
    LOG(DFATAL) << __func__ << " Invalid config. "
                << ConfigToString(format, STORAGE_MOJO_SHARED_BUFFER,
                                  dimensions, visible_rect, dimensions);
    return nullptr;
  }

  // Allocate a shared memory buffer big enough to hold the desired frame.
  const size_t allocation_size = VideoFrame::AllocationSize(format, coded_size);
  mojo::ScopedSharedBufferHandle handle =
      mojo::SharedBufferHandle::Create(allocation_size);
  if (!handle.is_valid()) {
    DLOG(ERROR) << __func__ << " Unable to allocate memory.";
    return nullptr;
  }

  // As both formats are 4:2:0, the U and V (or UV plane) have samples for each
  // 2x2 block.
  DCHECK((coded_size.width() % 2 == 0) && (coded_size.height() % 2 == 0));

  if (format == PIXEL_FORMAT_I420) {
    // Create and initialize the frame. As this is I420 format, the U and V
    // planes have samples for each 2x2 block. The memory is laid out as
    // follows:
    //  - Yplane, full size (each element represents a 1x1 block)
    //  - Uplane, quarter size (each element represents a 2x2 block)
    //  - Vplane, quarter size (each element represents a 2x2 block)
    return Create(
        format, coded_size, visible_rect, dimensions, std::move(handle),
        allocation_size,
        {0 /* y_offset */, static_cast<uint32_t>(coded_size.GetArea()),
         static_cast<uint32_t>(coded_size.GetArea() * 5 / 4)},
        {coded_size.width(), coded_size.width() / 2, coded_size.width() / 2},
        timestamp);
  } else {
    // |format| is PIXEL_FORMAT_NV12.
    // Create and initialize the frame. As this is NV12 format, the UV plane
    // has interleaved U & V samples for each 2x2 block. The memory is laid out
    // as follows:
    //  - Yplane, full size (each element represents a 1x1 block)
    //  - UVplane, full width, half height (each pair represents a 2x2 block)
    return Create(
        format, coded_size, visible_rect, dimensions, std::move(handle),
        allocation_size,
        {0 /* y_offset */, static_cast<uint32_t>(coded_size.GetArea())},
        {coded_size.width(), coded_size.width()}, timestamp);
  }
}

scoped_refptr<MojoSharedBufferVideoFrame>
MojoSharedBufferVideoFrame::CreateFromYUVFrame(VideoFrame& frame) {
  size_t num_planes = VideoFrame::NumPlanes(frame.format());
  DCHECK_LE(num_planes, 3u);
  DCHECK_GE(num_planes, 2u);

  std::vector<uint32_t> offsets(num_planes);
  std::vector<int32_t> strides(num_planes);
  std::vector<size_t> sizes(num_planes);
  size_t aggregate_size = 0;
  for (size_t i = 0; i < num_planes; ++i) {
    strides[i] = frame.stride(i);
    offsets[i] = aggregate_size;
    sizes[i] =
        VideoFrame::Rows(i, frame.format(), frame.coded_size().height()) *
        strides[i];
    aggregate_size += sizes[i];
  }

  mojo::ScopedSharedBufferHandle handle =
      mojo::SharedBufferHandle::Create(aggregate_size);
  if (!handle->is_valid()) {
    DLOG(ERROR) << "Can't create new frame backing memory";
    return nullptr;
  }
  mojo::ScopedSharedBufferMapping dst_mapping = handle->Map(aggregate_size);

  // The data from |frame| may not be consecutive between planes. Copy data into
  // a shared memory buffer which is tightly packed. Padding inside each planes
  // are preserved.
  scoped_refptr<MojoSharedBufferVideoFrame> mojo_frame =
      MojoSharedBufferVideoFrame::Create(
          frame.format(), frame.coded_size(), frame.visible_rect(),
          frame.natural_size(), std::move(handle), aggregate_size,
          offsets /* don't move, we use it again */, std::move(strides),
          frame.timestamp());
  CHECK(!!mojo_frame);

  // If the source memory region is a shared memory region we must map it too.
  base::WritableSharedMemoryMapping src_mapping;
  if (frame.storage_type() == VideoFrame::STORAGE_SHMEM) {
    if (!frame.shm_region()->IsValid()) {
      DLOG(ERROR) << "Invalid source shared memory region";
      return nullptr;
    }
    src_mapping = frame.shm_region()->Map();
    if (!src_mapping.IsValid()) {
      DLOG(ERROR) << "Can't map source shared memory region";
      return nullptr;
    }
  }

  // Copy plane data while mappings are in scope.
  for (size_t i = 0; i < num_planes; ++i) {
    memcpy(mojo_frame->shared_buffer_data() + offsets[i],
           static_cast<const void*>(frame.data(i)), sizes[i]);
  }

  // TODO(xingliu): Maybe also copy the alpha plane in
  // |MojoSharedBufferVideoFrame|. The alpha plane is ignored here, but
  // the |shared_memory| should contain the space for alpha plane.

  return mojo_frame;
}

// static
scoped_refptr<MojoSharedBufferVideoFrame> MojoSharedBufferVideoFrame::Create(
    VideoPixelFormat format,
    const gfx::Size& coded_size,
    const gfx::Rect& visible_rect,
    const gfx::Size& natural_size,
    mojo::ScopedSharedBufferHandle handle,
    size_t data_size,
    std::vector<uint32_t> offsets,
    std::vector<int32_t> strides,
    base::TimeDelta timestamp) {
  if (!IsValidConfig(format, STORAGE_MOJO_SHARED_BUFFER, coded_size,
                     visible_rect, natural_size)) {
    LOG(DFATAL) << __func__ << " Invalid config. "
                << ConfigToString(format, STORAGE_MOJO_SHARED_BUFFER,
                                  coded_size, visible_rect, natural_size);
    return nullptr;
  }

  // Validate that the format has the proper plane count and that it matches the
  // offsets/strides array sizes passed in.
  size_t num_planes = NumPlanes(format);
  if (num_planes != 3 && num_planes != 2) {
    DLOG(ERROR) << __func__ << " " << VideoPixelFormatToString(format)
                << " is not supported; only bi/tri-planar formats are allowed";
    return nullptr;
  }
  if (num_planes != offsets.size() || num_planes != strides.size()) {
    DLOG(ERROR) << __func__ << " offsets and strides length must match number "
                << "of planes";
    return nullptr;
  }

  // Validate that the offsets and strides fit in the buffer.
  //
  // We can rely on coded_size.GetArea() being relatively small (compared to the
  // range of an int) due to the IsValidConfig() check above.
  //
  // TODO(sandersd): Allow non-sequential formats.
  std::vector<ColorPlaneLayout> planes(num_planes);
  for (size_t i = 0; i < num_planes; ++i) {
    if (strides[i] < 0) {
      DLOG(ERROR) << __func__ << " Invalid stride";
      return nullptr;
    }

    // Compute the number of bytes needed on each row.
    const size_t row_bytes = RowBytes(i, format, coded_size.width());

    // Safe given sizeof(size_t) >= sizeof(int32_t).
    size_t stride_size_t = strides[i];
    if (stride_size_t < row_bytes) {
      DLOG(ERROR) << __func__ << " Invalid stride";
      return nullptr;
    }
    const size_t rows = Rows(i, format, coded_size.height());

    // The last row only needs RowBytes() and not a full stride. This is to
    // avoid problems if the U and V data is interleaved (where |stride| is
    // double the number of bytes actually needed).
    base::CheckedNumeric<size_t> bound = base::CheckAdd(
        offsets[i], base::CheckMul(base::CheckSub(rows, 1), stride_size_t),
        row_bytes);
    if (!bound.IsValid() || bound.ValueOrDie() > data_size) {
      DLOG(ERROR) << __func__ << " Invalid offset";
      return nullptr;
    }

    planes[i].stride = strides[i];
    planes[i].offset = offsets[i];
    planes[i].size = i + 1 < num_planes ? offsets[i + 1] - offsets[i]
                                        : data_size - offsets.back();
  }

  auto layout =
      VideoFrameLayout::CreateWithPlanes(format, coded_size, std::move(planes));
  if (!layout) {
    return nullptr;
  }
  // Now allocate the frame and initialize it.
  scoped_refptr<MojoSharedBufferVideoFrame> frame(
      new MojoSharedBufferVideoFrame(*layout, visible_rect, natural_size,
                                     std::move(handle), data_size, timestamp));
  if (!frame->Init(std::move(offsets))) {
    DLOG(ERROR) << __func__ << " MojoSharedBufferVideoFrame::Init failed.";
    return nullptr;
  }

  return frame;
}

MojoSharedBufferVideoFrame::MojoSharedBufferVideoFrame(
    const VideoFrameLayout& layout,
    const gfx::Rect& visible_rect,
    const gfx::Size& natural_size,
    mojo::ScopedSharedBufferHandle handle,
    size_t mapped_size,
    base::TimeDelta timestamp)
    : VideoFrame(layout,
                 STORAGE_MOJO_SHARED_BUFFER,
                 visible_rect,
                 natural_size,
                 timestamp),
      shared_buffer_handle_(std::move(handle)),
      shared_buffer_size_(mapped_size) {
  DCHECK(shared_buffer_handle_.is_valid());
}

bool MojoSharedBufferVideoFrame::Init(std::vector<uint32_t> offsets) {
  DCHECK(!shared_buffer_mapping_);
  shared_buffer_mapping_ = shared_buffer_handle_->Map(shared_buffer_size_);
  if (!shared_buffer_mapping_)
    return false;
  const size_t num_planes = NumPlanes(format());
  DCHECK_EQ(offsets.size(), num_planes);
  for (size_t i = 0; i < num_planes; ++i) {
    offsets_[i] = offsets[i];
    set_data(i, shared_buffer_data() + offsets[i]);
  }
  return true;
}

MojoSharedBufferVideoFrame::~MojoSharedBufferVideoFrame() {
  // Call |mojo_shared_buffer_done_cb_| to take ownership of
  // |shared_buffer_handle_|.
  if (mojo_shared_buffer_done_cb_) {
    std::move(mojo_shared_buffer_done_cb_)
        .Run(std::move(shared_buffer_handle_), shared_buffer_size_);
  }
}

size_t MojoSharedBufferVideoFrame::PlaneOffset(size_t plane) const {
  DCHECK(IsValidPlane(format(), plane));
  return offsets_[plane];
}

void MojoSharedBufferVideoFrame::SetMojoSharedBufferDoneCB(
    MojoSharedBufferDoneCB mojo_shared_buffer_done_cb) {
  mojo_shared_buffer_done_cb_ = std::move(mojo_shared_buffer_done_cb);
}

const mojo::SharedBufferHandle& MojoSharedBufferVideoFrame::Handle() const {
  return shared_buffer_handle_.get();
}

size_t MojoSharedBufferVideoFrame::MappedSize() const {
  return shared_buffer_size_;
}

}  // namespace media