133 lines
3.5 KiB
C++
133 lines
3.5 KiB
C++
/* 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 HAL_USB_FRAME_BUFFER_H_
|
|
#define HAL_USB_FRAME_BUFFER_H_
|
|
|
|
#include <cstdint>
|
|
#include <memory>
|
|
|
|
#include <base/files/scoped_file.h>
|
|
#include <base/synchronization/lock.h>
|
|
#include <hardware/gralloc.h>
|
|
|
|
namespace arc {
|
|
|
|
class FrameBuffer {
|
|
public:
|
|
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() const { return data_; }
|
|
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_; }
|
|
|
|
void SetFourcc(uint32_t fourcc) { fourcc_ = fourcc; }
|
|
virtual int SetDataSize(size_t data_size);
|
|
|
|
protected:
|
|
uint8_t* data_;
|
|
|
|
// 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_;
|
|
};
|
|
|
|
// AllocatedFrameBuffer is used for the buffer from hal malloc-ed. User should
|
|
// be aware to manage the memory.
|
|
class AllocatedFrameBuffer : public FrameBuffer {
|
|
public:
|
|
explicit AllocatedFrameBuffer(int buffer_size);
|
|
explicit AllocatedFrameBuffer(uint8_t* buffer, int buffer_size);
|
|
~AllocatedFrameBuffer() override;
|
|
|
|
// No-op for the two functions.
|
|
int Map() override { return 0; }
|
|
int Unmap() override { return 0; }
|
|
|
|
void SetWidth(uint32_t width) { width_ = width; }
|
|
void SetHeight(uint32_t height) { height_ = height; }
|
|
int SetDataSize(size_t data_size) override;
|
|
void Reset();
|
|
|
|
private:
|
|
std::unique_ptr<uint8_t[]> buffer_;
|
|
};
|
|
|
|
// 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 { 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 is used for the buffer from Android framework. Uses
|
|
// CameraBufferMapper to lock and unlock the buffer.
|
|
class GrallocFrameBuffer : public FrameBuffer {
|
|
public:
|
|
GrallocFrameBuffer(buffer_handle_t buffer, uint32_t width, uint32_t height,
|
|
uint32_t fourcc, uint32_t device_buffer_length,
|
|
uint32_t stream_usage);
|
|
~GrallocFrameBuffer();
|
|
|
|
int Map() override;
|
|
int Unmap() override;
|
|
|
|
private:
|
|
// The currently used buffer for |buffer_mapper_| operations.
|
|
buffer_handle_t buffer_;
|
|
|
|
// Used to import gralloc buffer.
|
|
const gralloc_module_t* gralloc_module_;
|
|
|
|
bool is_mapped_;
|
|
|
|
// Lock to guard |is_mapped_|.
|
|
base::Lock lock_;
|
|
|
|
// Camera stream and device buffer context.
|
|
uint32_t device_buffer_length_;
|
|
uint32_t stream_usage_;
|
|
};
|
|
|
|
} // namespace arc
|
|
|
|
#endif // HAL_USB_FRAME_BUFFER_H_
|