/*
|
* Copyright (c) 2021 by Allwinnertech Co., Ltd.
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
#ifndef V4L2_CAMERA_HAL_V4L2_WRAPPER_H_
|
#define V4L2_CAMERA_HAL_V4L2_WRAPPER_H_
|
|
#include "common.h"
|
#ifdef LOG_NDEBUG
|
#undef LOG_NDEBUG
|
#endif
|
|
#if DBG_V4L2_WRAPPER
|
#undef NDEBUG
|
#define LOG_NDEBUG 0
|
#else
|
#define LOG_NDEBUG 1
|
#endif
|
|
#include <android-base/unique_fd.h>
|
|
#include <array>
|
#include <memory>
|
#include <mutex>
|
#include <queue>
|
#include <set>
|
#include <string>
|
#include <unordered_map>
|
#include <utility>
|
#include <vector>
|
|
#include "camera_config.h"
|
#include "stream_format.h"
|
#include "v4l2_stream.h"
|
#include "vencoder.h"
|
#ifdef USE_ISP
|
#include "AWIspApi.h"
|
#endif
|
|
namespace v4l2_camera_hal {
|
class V4L2Stream;
|
class ConnectionStream;
|
|
class V4L2Wrapper {
|
public:
|
// Use this method to create V4L2Wrapper objects. Functionally equivalent
|
// to "new V4L2Wrapper", except that it may return nullptr in case of failure.
|
static V4L2Wrapper* NewV4L2Wrapper(const int id,
|
std::shared_ptr<CCameraConfig> pCameraCfg);
|
std::shared_ptr<V4L2Stream> getStream(STREAM_SERIAL ss);
|
|
virtual ~V4L2Wrapper();
|
|
// Helper class to ensure all opened connections are closed.
|
class Connection {
|
public:
|
Connection(std::shared_ptr<V4L2Wrapper> device,
|
STREAM_SERIAL ss,
|
int merge_status)
|
: device_(std::move(device)),
|
ss_(std::move(ss)),
|
connect_result_(device_->Connect(ss, merge_status)) {}
|
~Connection() {
|
if (connect_result_ == 0) {
|
device_->Disconnect(ss_);
|
}
|
}
|
// Check whether the connection succeeded or not.
|
inline int status() const { return connect_result_; }
|
|
private:
|
std::shared_ptr<V4L2Wrapper> device_;
|
STREAM_SERIAL ss_;
|
const int connect_result_;
|
};
|
|
// Tools.
|
int GetDeviceId() {return device_id_;}
|
|
private:
|
std::shared_ptr<CCameraConfig> mCameraConfig;
|
// Constructor is private to allow failing on bad input.
|
// Use NewV4L2Wrapper instead.
|
V4L2Wrapper(const int id, std::shared_ptr<CCameraConfig> pCameraCfg);
|
|
// Connect or disconnect to the device. Access by creating/destroying
|
// a V4L2Wrapper::Connection object.
|
int Connect(STREAM_SERIAL ss, int merge_status);
|
void Disconnect(STREAM_SERIAL ss);
|
|
std::unordered_map<std::string, android::base::unique_fd> map_stream_fd_;
|
std::unordered_map<STREAM_SERIAL,
|
std::shared_ptr<V4L2Stream>> map_stream_obj_;
|
std::shared_ptr<V4L2Stream> array_stream_obj[MAX_STREAM];
|
std::shared_ptr<ConnectionStream> stream_connection[MAX_STREAM];
|
|
inline bool connected(STREAM_SERIAL ss) {
|
if (array_stream_obj[ss] == nullptr) {
|
return false;
|
}
|
return true;
|
}
|
|
// The camera device path. For example, /dev/video0.
|
const std::string device_path_;
|
// The opened device fd.
|
android::base::unique_fd device_fd_[MAX_STREAM];
|
|
// The open camera facing.
|
const int device_id_;
|
// The underlying gralloc module.
|
std::unique_ptr<V4L2Gralloc> gralloc_;
|
// Whether or not the device supports the extended control query.
|
bool extended_query_supported_;
|
// The format this device is set up for.
|
std::unique_ptr<StreamFormat> format_;
|
bool has_StreamOn;
|
enum {
|
BUFFER_UNINIT,
|
BUFFER_PREPARE,
|
BUFFER_QUEUE,
|
BUFFER_DEQUEUE
|
} buffer_state_;
|
// Map indecies to buffer status. True if the index is in-flight.
|
// |buffers_.size()| will always be the maximum number of buffers this device
|
// can handle in its current format.
|
std::vector<bool> buffers_pstream_;
|
|
// Map indecies to buffer status. True if the index is in-flight.
|
// |buffers_.size()| will always be the maximum number of buffers this device
|
// can handle in its current format.
|
std::vector<bool> buffers_;
|
|
// Lock protecting use of the buffer tracker.
|
std::mutex buffer_queue_lock_;
|
std::queue<int>buffers_num_;
|
std::condition_variable buffer_availabl_queue_;
|
|
// Buffer manager.
|
std::mutex cmd_queue_lock_;
|
int buffer_cnt_inflight_;
|
// Lock protecting use of the device.
|
std::mutex device_lock_;
|
// Lock protecting connecting/disconnecting the device.
|
std::mutex connection_lock_;
|
// Reference count connections.
|
int connection_count_[MAX_STREAM];
|
|
// Debug tools for save buffers.
|
void * buffers_addr[MAX_BUFFER_NUM];
|
int buffers_fd[MAX_BUFFER_NUM];
|
|
#ifdef USE_ISP
|
android::AWIspApi *mAWIspApi;
|
int mIspId;
|
#endif
|
bool isTakePicure;
|
|
friend class Connection;
|
friend class V4L2WrapperMock;
|
#ifdef USE_ISP
|
friend class android::AWIspApi;
|
#endif
|
|
DISALLOW_COPY_AND_ASSIGN(V4L2Wrapper);
|
};
|
|
} // namespace v4l2_camera_hal
|
|
#endif // V4L2_CAMERA_HAL_V4L2_WRAPPER_H_
|
