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

#ifndef ARC_VM_LIBVDA_DECODE_WRAPPER_H_
#define ARC_VM_LIBVDA_DECODE_WRAPPER_H_

#include <stdint.h>

#include <memory>

#include <base/macros.h>

#include "arc/vm/libvda/event_pipe.h"
#include "arc/vm/libvda/libvda_decode.h"

namespace arc {

// VdaContext is the decode session context created by VdaImpl.
// Implementations should be able to handle method invocations on any thread.
class VdaContext {
 public:
  VdaContext();
  VdaContext(const VdaContext&) = delete;
  VdaContext& operator=(const VdaContext&) = delete;

  virtual ~VdaContext();

  // Decodes the frame pointed to by |fd|. |offset| and |bytes_used|
  // is the buffer offset and the size of the frame.
  virtual vda_result_t Decode(int32_t bitstream_id,
                              base::ScopedFD fd,
                              uint32_t offset,
                              uint32_t bytes_used) = 0;

  // Sets the number of expected output buffers to |num_output_buffers|.
  virtual vda_result_t SetOutputBufferCount(size_t num_output_buffers) = 0;

  // Provides an output buffer |fd| for decoded frames in decode session context
  // |ctx| where |format| is the output pixel format and |planes| is a pointer
  // to an array of |num_planes| objects.
  virtual vda_result_t UseOutputBuffer(int32_t picture_buffer_id,
                                       vda_pixel_format_t format,
                                       base::ScopedFD fd,
                                       size_t num_planes,
                                       video_frame_plane_t* planes) = 0;

  // Returns the output buffer with id |picture_buffer_id| for reuse.
  virtual vda_result_t ReuseOutputBuffer(int32_t picture_buffer_id) = 0;

  // Requests to reset the decode session, clearing all pending decodes.
  virtual vda_result_t Reset() = 0;

  // Requests to flush the decode session.
  virtual vda_result_t Flush() = 0;

  // Returns the read-only endpoint of the event pipe file descriptor.
  int GetEventFd();

 protected:
  // Dispatch a PROVIDE_PICTURE_BUFFERS event to the event pipe.
  void 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);

  // Dispatch a PICTURE_READY event to the event pipe.
  void DispatchPictureReady(int32_t picture_buffer_id,
                            int32_t bitstream_id,
                            int crop_left,
                            int crop_top,
                            int crop_right,
                            int crop_bottom);

  // Dispatch a NOTIFY_END_OF_BITSTREAM_BUFFER event to the event pipe.
  void DispatchNotifyEndOfBitstreamBuffer(int32_t bitstream_id);

  // Dispatch a NOTIFY_ERROR event to the event pipe.
  void DispatchNotifyError(vda_result_t result);

  // Dispatch a RESET_RESPONSE event to the event pipe.
  void DispatchResetResponse(vda_result_t result);

  // Dispatch a FLUSH_RESPONSE event to the event pipe.
  void DispatchFlushResponse(vda_result_t result);

 private:
  void WriteEvent(const vda_event_t& event);

  EventPipe event_pipe_;
};

// VdaImpl encapsulates a vda implementation that can be used to create decode
// sessions.
class VdaImpl {
 public:
  VdaImpl();
  VdaImpl(const VdaImpl&) = delete;
  VdaImpl& operator=(const VdaImpl&) = delete;

  virtual ~VdaImpl();

  // Returns the decoding capabilities of this implementation.
  // The returned vda_capabilities_t object is owned by VdaImpl.
  virtual const vda_capabilities_t* const GetCapabilities();

  // Initializes a new decode session and returns a new decode session context.
  virtual VdaContext* InitDecodeSession(vda_profile_t profile) = 0;

  // Closes an open decode session.
  virtual void CloseDecodeSession(VdaContext* ctx) = 0;

 protected:
  vda_capabilities_t capabilities_;
};

}  // namespace arc

#endif  // ARC_VM_LIBVDA_DECODE_WRAPPER_H_