camera/hal/usb/frame_buffer.h

/* Copyright 2017 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 CAMERA_HAL_USB_FRAME_BUFFER_H_
#define CAMERA_HAL_USB_FRAME_BUFFER_H_

#include <stdint.h>

#include <memory>
#include <string>
#include <vector>

#include <base/files/scoped_file.h>
#include <base/memory/unsafe_shared_memory_region.h>
#include <base/synchronization/lock.h>
#include <camera/camera_metadata.h>

#include "cros-camera/camera_buffer_manager.h"

namespace cros {

class FrameBuffer {
 public:
  enum {
    YPLANE = 0,
    UPLANE = 1,
    VPLANE = 2,
  };

  FrameBuffer();
  virtual ~FrameBuffer();

  // If mapped successfully, the address will be assigned to |data_| and return
  // 0. Otherwise, returns -EINVAL.
  virtual int Map() = 0;

  // Unmaps the mapped address. Returns 0 for success.
  virtual int Unmap() = 0;

  uint8_t* GetData(size_t plane) const;
  uint8_t* GetData() const { return data_[0]; }
  size_t GetDataSize() const { return data_size_; }
  size_t GetBufferSize() const { return buffer_size_; }
  uint32_t GetWidth() const { return width_; }
  uint32_t GetHeight() const { return height_; }
  uint32_t GetFourcc() const { return fourcc_; }
  size_t GetStride(size_t plane) const;
  size_t GetStride() const { return stride_[0]; }
  size_t GetNumPlanes() const { return num_planes_; }

  virtual void SetFourcc(uint32_t fourcc);
  virtual int SetDataSize(size_t data_size);
  virtual int GetFd() const { return -1; }

  virtual buffer_handle_t GetBufferHandle() const { return nullptr; }

 protected:
  std::vector<uint8_t*> data_;
  std::vector<size_t> stride_;

  // The number of bytes used in the buffer.
  size_t data_size_;

  // The number of bytes allocated in the buffer.
  size_t buffer_size_;

  // Frame resolution.
  uint32_t width_;
  uint32_t height_;

  // This is V4L2_PIX_FMT_* in linux/videodev2.h.
  uint32_t fourcc_;

  // The number of planes.
  uint32_t num_planes_;
};

// SharedFrameBuffer is used for the buffer from base::SharedMemory.
class SharedFrameBuffer : public FrameBuffer {
 public:
  static bool Reallocate(uint32_t width,
                         uint32_t height,
                         uint32_t fourcc,
                         std::unique_ptr<SharedFrameBuffer>* frame);

  explicit SharedFrameBuffer(int buffer_size);
  ~SharedFrameBuffer() override;

  // No-op for the two functions.
  int Map() override { return 0; }
  int Unmap() override { return 0; }

  void SetWidth(uint32_t width);
  void SetHeight(uint32_t height);
  void SetFourcc(uint32_t fourcc) override;
  int SetDataSize(size_t data_size) override;
  int GetFd() const override { return shm_region_.GetPlatformHandle().fd; }

 private:
  void SetData();
  void SetStride();
  // base::UnsafeSharedMemoryRegion, instead of the Writable alternative, is
  // used to allow getting (and duplicating in
  // JpecDecodeAcceleratorImpl::IPCBridge::Decode) the fd.
  base::UnsafeSharedMemoryRegion shm_region_;
  base::WritableSharedMemoryMapping shm_mapping_;
};

// V4L2FrameBuffer is used for the buffer from V4L2CameraDevice. Maps the fd
// in constructor. Unmaps and closes the fd in destructor.
class V4L2FrameBuffer : public FrameBuffer {
 public:
  V4L2FrameBuffer(base::ScopedFD fd,
                  int buffer_size,
                  uint32_t width,
                  uint32_t height,
                  uint32_t fourcc);
  // Unmaps |data_| and closes |fd_|.
  ~V4L2FrameBuffer();

  int Map() override;
  int Unmap() override;
  int GetFd() const override { return fd_.get(); }

 private:
  // File descriptor of V4L2 frame buffer.
  base::ScopedFD fd_;

  bool is_mapped_;

  // Lock to guard |is_mapped_|.
  base::Lock lock_;
};

// GrallocFrameBuffer uses CameraBufferManager to manage the buffer.
class GrallocFrameBuffer : public FrameBuffer {
 public:
  static bool Reallocate(uint32_t width,
                         uint32_t height,
                         uint32_t fourcc,
                         std::unique_ptr<GrallocFrameBuffer>* frame);

  // Wraps external buffer from upper framework. Fill |width_| and |height_|
  // according to the parameters.
  GrallocFrameBuffer(buffer_handle_t buffer, uint32_t width, uint32_t height);
  // Allocate the buffer internally.
  GrallocFrameBuffer(uint32_t width, uint32_t height, uint32_t fourcc);
  ~GrallocFrameBuffer();

  // Fill |buffer_size_| and |data_|.
  int Map() override;
  int Unmap() override;

  buffer_handle_t GetBufferHandle() const override { return buffer_; }

 private:
  // The currently used buffer for |buffer_mapper_| operations.
  buffer_handle_t buffer_;

  // Used to import gralloc buffer.
  CameraBufferManager* buffer_manager_;

  // Whether the |buffer_| is allocated by this class.
  bool is_buffer_owner_;

  bool is_mapped_;

  // Lock to guard |is_mapped_|.
  base::Lock lock_;
};

}  // namespace cros

#endif  // CAMERA_HAL_USB_FRAME_BUFFER_H_