/*
|
* 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_STREAM_MANAGER_H_
|
#define V4L2_CAMERA_HAL_STREAM_MANAGER_H_
|
|
#include "common.h"
|
#ifdef LOG_NDEBUG
|
#undef LOG_NDEBUG
|
#endif
|
|
#if DBG_STREAM_MANAGER
|
#undef NDEBUG
|
#define LOG_NDEBUG 0
|
#else
|
#define LOG_NDEBUG 1
|
#endif
|
|
#include <utils/StrongPointer.h>
|
#include <utils/Thread.h>
|
#include <utils/RefBase.h>
|
|
#include <array>
|
#include <condition_variable>
|
#include <functional>
|
#include <map>
|
#include <memory>
|
#include <queue>
|
#include <string>
|
#include <unordered_map>
|
|
#include "CameraMetadata.h"
|
#include "camera.h"
|
#include "metadata/metadata.h"
|
#include "v4l2_wrapper.h"
|
#include "v4l2_camera.h"
|
|
namespace v4l2_camera_hal {
|
class CameraStream;
|
class V4L2Camera;
|
|
typedef struct {
|
short refCnt;
|
int frameNum;
|
} FrameNumRef;
|
|
class StreamManager : public android::RefBase {
|
friend class CameraStream;
|
friend class V4L2Camera;
|
|
public:
|
static std::shared_ptr<StreamManager> NewStreamManager(
|
std::shared_ptr<V4L2Wrapper> device,
|
std::shared_ptr<V4L2Camera> camera);
|
CameraStream* createStream(STREAM_SERIAL ss,
|
uint32_t width,
|
uint32_t height,
|
int format,
|
uint32_t usage,
|
int isBlob,
|
bool mergeStreamFlag);
|
int configurateManager(STREAM_SERIAL ss);
|
int start(STREAM_SERIAL ss);
|
int stop(STREAM_SERIAL ss);
|
int resultCallback(uint32_t frameNumber, struct timeval ts);
|
int markFrameNumber(uint32_t frameNumber);
|
int request(uint32_t frameNumber);
|
|
~StreamManager();
|
|
protected:
|
class StreamYUVMEQ : public android::Thread {
|
public:
|
explicit StreamYUVMEQ(StreamManager* dev) :
|
Thread(false),
|
mStreamManager(dev),
|
mRequestExit(false) {}
|
|
void startThread() {
|
run("StreamYUVmainEnqueue", android::PRIORITY_URGENT_DISPLAY);
|
}
|
void stopThread() {
|
mRequestExit = true;
|
}
|
|
virtual bool threadLoop() {
|
if (mRequestExit) {
|
return false;
|
}
|
return mStreamManager->sYUVmainEnqueue();
|
}
|
|
protected:
|
StreamManager* mStreamManager;
|
bool mRequestExit;
|
};
|
|
class StreamYUVMDQ : public android::Thread {
|
public:
|
explicit StreamYUVMDQ(StreamManager* dev) :
|
Thread(false),
|
mStreamManager(dev),
|
mRequestExit(false) {}
|
|
void startThread() {
|
run("StreamYUVmainDequeue", android::PRIORITY_URGENT_DISPLAY);
|
}
|
|
void stopThread() {
|
mRequestExit = true;
|
}
|
|
virtual bool threadLoop() {
|
if (mRequestExit) {
|
return false;
|
}
|
return mStreamManager->sYUVmainDequeue();
|
}
|
|
protected:
|
StreamManager* mStreamManager;
|
bool mRequestExit;
|
const std::string mThreadName;
|
};
|
|
class StreamYUVSEQ : public android::Thread {
|
public:
|
explicit StreamYUVSEQ(StreamManager* dev) :
|
Thread(false),
|
mStreamManager(dev),
|
mRequestExit(false) {}
|
|
void startThread() {
|
run("StreamYUVsubEnqueue", android::PRIORITY_URGENT_DISPLAY);
|
}
|
|
void stopThread() {
|
mRequestExit = true;
|
}
|
|
virtual bool threadLoop() {
|
if (mRequestExit) {
|
return false;
|
}
|
return mStreamManager->sYUVsubEnqueue();
|
}
|
|
protected:
|
StreamManager* mStreamManager;
|
bool mRequestExit;
|
};
|
|
class StreamYUVSDQ : public android::Thread {
|
public:
|
explicit StreamYUVSDQ(StreamManager* dev) :
|
Thread(false),
|
mStreamManager(dev),
|
mRequestExit(false) {}
|
|
void startThread() {
|
run("StreamYUVsubDequeue", android::PRIORITY_URGENT_DISPLAY);
|
}
|
|
void stopThread() {
|
mRequestExit = true;
|
std::unique_lock<std::mutex> lock(stream_lock_);
|
}
|
|
virtual bool threadLoop() {
|
std::unique_lock<std::mutex> lock(stream_lock_);
|
if (mRequestExit) {
|
return false;
|
}
|
return mStreamManager->sYUVsubDequeue();
|
}
|
|
protected:
|
StreamManager* mStreamManager;
|
bool mRequestExit;
|
const std::string mThreadName;
|
std::mutex stream_lock_;
|
};
|
|
private:
|
StreamManager* instance;
|
int mDrop_main_buffers;
|
int mDrop_sub_buffers;
|
StreamManager(std::shared_ptr<V4L2Wrapper> device,
|
std::unique_ptr<V4L2Gralloc> gralloc,
|
std::shared_ptr<V4L2Camera> camera);
|
|
bool sYUVmainEnqueue();
|
bool sYUVmainDequeue();
|
bool sYUVsubEnqueue();
|
bool sYUVsubDequeue();
|
|
std::shared_ptr<V4L2Wrapper> device_;
|
std::unique_ptr<V4L2Gralloc> gralloc_;
|
std::shared_ptr<V4L2Camera> camera_;
|
std::unique_ptr<V4L2Wrapper::Connection> mConnection[MAX_STREAM];
|
std::shared_ptr<V4L2Stream> mStream[MAX_STREAM];
|
std::shared_ptr<CameraStream> mCameraStream[MAX_STREAM];
|
|
int64_t gtimemain;
|
int64_t gtimesub;
|
// Map frameNumber: refcnt about the buffer.
|
std::unordered_map<uint32_t, int> mMapFrameNumRef;
|
std::mutex frameNumber_lock_;
|
std::condition_variable frameNumber_condition_;
|
int merge_stream_flag;
|
|
/* Defines possible states of the stream thread.
|
*/
|
enum StreamStatus {
|
/* Do not open steam. */
|
STREAM_STATE_NULL,
|
/* Do not open steam. */
|
STREAM_STATE_PAUSED,
|
/* Start steam. */
|
STREAM_STATE_STARTED,
|
/* exit thread*/
|
STREAM_STATE_EXIT,
|
};
|
|
StreamStatus mYUVMEThreadState;
|
android::sp<StreamYUVMEQ> msYUVmainEnqueue;
|
std::mutex msYUVmainEnqueueMutex;
|
std::condition_variable msYUVmainEnqueueCond;
|
|
StreamStatus mYUVMDThreadState;
|
android::sp<StreamYUVMDQ> msYUVmainDequeue;
|
std::mutex msYUVmainDequeueMutex;
|
std::condition_variable msYUVmainDequeueCond;
|
|
StreamStatus mYUVSEThreadState;
|
android::sp<StreamYUVSEQ> msYUVsubEnqueue;
|
std::mutex msYUVsubEnqueueMutex;
|
std::condition_variable msYUVsubEnqueueCond;
|
|
StreamStatus mYUVSDThreadState;
|
android::sp<StreamYUVSDQ> msYUVsubDequeue;
|
std::mutex msYUVsubDequeueMutex;
|
std::condition_variable msYUVsubDequeueCond;
|
|
DISALLOW_COPY_AND_ASSIGN(StreamManager);
|
};
|
|
} // namespace v4l2_camera_hal
|
|
#endif // V4L2_CAMERA_HAL_V4L2_CAMERA_H_
|
