// Copyright 2019 The Chromium OS 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 "arc/vm/libvda/decode_wrapper.h"

#include <utility>

#include <base/logging.h>

#include "arc/vm/libvda/decode/fake/fake_vda_impl.h"
#include "arc/vm/libvda/decode/gpu/gpu_vda_impl.h"
#include "arc/vm/libvda/gpu/vaf_connection.h"

namespace arc {

VdaImpl::VdaImpl() {
  capabilities_.num_input_formats = 0;
  capabilities_.input_formats = nullptr;
  capabilities_.num_output_formats = 0;
  capabilities_.output_formats = nullptr;
}

VdaImpl::~VdaImpl() = default;

const vda_capabilities_t* const VdaImpl::GetCapabilities() {
  return &capabilities_;
}

VdaContext::VdaContext() = default;

VdaContext::~VdaContext() = default;

int VdaContext::GetEventFd() {
  return event_pipe_.GetReadFd();
}

void VdaContext::WriteEvent(const vda_event_t& event) {
  event_pipe_.WriteVdaEvent(event);
}

void VdaContext::DispatchProvidePictureBuffers(uint32_t min_num_buffers,
                                               int32_t width,
                                               int32_t height,
                                               int32_t visible_rect_left,
                                               int32_t visible_rect_top,
                                               int32_t visible_rect_right,
                                               int32_t visible_rect_bottom) {
  vda_event_t event;
  event.event_type = PROVIDE_PICTURE_BUFFERS;
  event.event_data.provide_picture_buffers.min_num_buffers = min_num_buffers;
  event.event_data.provide_picture_buffers.width = width;
  event.event_data.provide_picture_buffers.height = height;
  event.event_data.provide_picture_buffers.visible_rect_left =
      visible_rect_left;
  event.event_data.provide_picture_buffers.visible_rect_top = visible_rect_top;
  event.event_data.provide_picture_buffers.visible_rect_right =
      visible_rect_right;
  event.event_data.provide_picture_buffers.visible_rect_bottom =
      visible_rect_bottom;
  WriteEvent(event);
}

void VdaContext::DispatchPictureReady(int32_t picture_buffer_id,
                                      int32_t bitstream_id,
                                      int crop_left,
                                      int crop_top,
                                      int crop_right,
                                      int crop_bottom) {
  vda_event_t event;
  event.event_type = PICTURE_READY;
  event.event_data.picture_ready.picture_buffer_id = picture_buffer_id;
  event.event_data.picture_ready.bitstream_id = bitstream_id;
  event.event_data.picture_ready.crop_left = crop_left;
  event.event_data.picture_ready.crop_top = crop_top;
  event.event_data.picture_ready.crop_right = crop_right;
  event.event_data.picture_ready.crop_bottom = crop_bottom;
  WriteEvent(event);
}

void VdaContext::DispatchNotifyEndOfBitstreamBuffer(int32_t bitstream_id) {
  vda_event_t event;
  event.event_type = NOTIFY_END_OF_BITSTREAM_BUFFER;
  event.event_data.bitstream_id = bitstream_id;
  WriteEvent(event);
}

void VdaContext::DispatchNotifyError(vda_result_t result) {
  vda_event_t event;
  event.event_type = NOTIFY_ERROR;
  event.event_data.result = result;
  WriteEvent(event);
}

void VdaContext::DispatchResetResponse(vda_result_t result) {
  vda_event_t event;
  event.event_type = RESET_RESPONSE;
  event.event_data.result = result;
  WriteEvent(event);
}

void VdaContext::DispatchFlushResponse(vda_result_t result) {
  vda_event_t event;
  event.event_type = FLUSH_RESPONSE;
  event.event_data.result = result;
  WriteEvent(event);
}

}  // namespace arc

void* initialize(vda_impl_type_t impl_type) {
  switch (impl_type) {
    case FAKE:
      return arc::FakeVdaImpl::Create();
    case GAVDA: {
      arc::VafConnection* conn = arc::VafConnection::Get();
      if (conn == nullptr) {
        LOG(ERROR) << "Failed to retrieve VAF connection.";
        return nullptr;
      }
      return arc::GpuVdaImpl::Create(conn);
    }
    default:
      LOG(ERROR) << "Unknown impl type " << impl_type;
      return nullptr;
  }
}

void deinitialize(void* impl) {
  arc::VdaImpl* cast_impl = static_cast<arc::VdaImpl*>(impl);
  delete cast_impl;
}

const vda_capabilities_t* get_vda_capabilities(void* impl) {
  return static_cast<arc::VdaImpl*>(impl)->GetCapabilities();
}

vda_session_info_t* init_decode_session(void* impl, vda_profile_t profile) {
  arc::VdaContext* context =
      static_cast<arc::VdaImpl*>(impl)->InitDecodeSession(profile);
  if (!context)
    return nullptr;
  vda_session_info_t* session_info = new vda_session_info_t();
  session_info->ctx = context;
  session_info->event_pipe_fd = context->GetEventFd();
  return session_info;
}

void close_decode_session(void* impl, vda_session_info_t* session_info) {
  static_cast<arc::VdaImpl*>(impl)->CloseDecodeSession(
      static_cast<arc::VdaContext*>(session_info->ctx));
  delete session_info;
}

vda_result_t vda_decode(void* ctx,
                        int32_t bitstream_id,
                        int fd,
                        uint32_t offset,
                        uint32_t bytes_used) {
  return static_cast<arc::VdaContext*>(ctx)->Decode(
      bitstream_id, base::ScopedFD(fd), offset, bytes_used);
}

vda_result_t vda_set_output_buffer_count(void* ctx, size_t num_output_buffers) {
  return static_cast<arc::VdaContext*>(ctx)->SetOutputBufferCount(
      num_output_buffers);
}

vda_result_t vda_use_output_buffer(void* ctx,
                                   int32_t picture_buffer_id,
                                   vda_pixel_format_t format,
                                   int fd,
                                   size_t num_planes,
                                   video_frame_plane_t* planes) {
  return static_cast<arc::VdaContext*>(ctx)->UseOutputBuffer(
      picture_buffer_id, format, base::ScopedFD(fd), num_planes, planes);
}

vda_result_t vda_reuse_output_buffer(void* ctx, int32_t picture_buffer_id) {
  return static_cast<arc::VdaContext*>(ctx)->ReuseOutputBuffer(
      picture_buffer_id);
}

vda_result vda_reset(void* ctx) {
  return static_cast<arc::VdaContext*>(ctx)->Reset();
}

vda_result vda_flush(void* ctx) {
  return static_cast<arc::VdaContext*>(ctx)->Flush();
}