android13/external/camera_engine_rkaiq/hal_interface2.0/interface/common/MessageQueue.h

232 lines
7.0 KiB
C++
Executable File

/*
* Copyright (C) 2011-2017 Intel Corporation
* Copyright (c) 2017, Fuzhou Rockchip Electronics 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 CAMERA3_MESSAGE_QUEUE_H_
#define CAMERA3_MESSAGE_QUEUE_H_
#include <utils/Errors.h>
//#include <Utils.h>
#include <list>
#include <vector>
#include <mutex>
#include <condition_variable>
#include <base/xcam_log.h>
#include <chrono>
// By default MessageQueue::receive() waits infinitely for a new message
#define MESSAGE_QUEUE_RECEIVE_TIMEOUT_MSEC_INFINITE 0
NAMESPACE_DECLARATION {
template <class MessageType, class MessageId>
class MessageQueue {
// constructor / destructor
public:
MessageQueue(const char*name,
int numReply):
mName(name)
,mNumReply(numReply)
,mReplyMutex(nullptr)
,mReplyCondition(nullptr)
,mReplyStatus(nullptr)
{
if (mNumReply > 0) {
mReplyMutex = new std::mutex[numReply];
mReplyCondition = new std::condition_variable[numReply];
mReplyStatus = new status_t[numReply];
}
}
~MessageQueue()
{
if (size() > 0) {
// The last message a thread should receive is EXIT.
// If for some reason a thread is sent a message after
// the thread has exited then there is a race condition
// or design issue.
LOGE("Camera_MessageQueue error: %s queue should be empty. Find the bug.", mName);
}
if (mNumReply > 0) {
delete [] mReplyMutex;
mReplyMutex = nullptr;
delete [] mReplyCondition;
mReplyCondition = nullptr;
delete [] mReplyStatus;
mReplyStatus = nullptr;
}
}
// public methods
public:
// Push a message onto the queue. If replyId is not -1 function will block until
// the caller is signalled with a reply. Caller is unblocked when reply method is
// called with the corresponding message id.
status_t send(MessageType *msg, MessageId replyId)
{
status_t status = NO_ERROR;
bool notDefReplyId = (replyId != (MessageId)-1);
// someone is misusing the API. replies have not been enabled
if (notDefReplyId && mNumReply == 0) {
LOGE("Camera_MessageQueue error: %s replies not enabled\n", mName);
return BAD_VALUE;
}
if (replyId < -1 || replyId >= mNumReply) {
LOGE("Camera_MessageQueue error: incorrect replyId: %d\n", replyId);
return BAD_VALUE;
}
{
std::lock_guard<std::mutex> l(mQueueMutex);
MessageType data = *msg;
mList.push_front(data);
if (notDefReplyId) {
mReplyStatus[replyId] = WOULD_BLOCK;
}
mQueueCondition.notify_one();
}
if (notDefReplyId && replyId >= 0) {
std::unique_lock<std::mutex> lk(mReplyMutex[replyId]);
while (mReplyStatus[replyId] == WOULD_BLOCK) {
mReplyCondition[replyId].wait(lk);
// wait() should never complete without a new status having
// been set, but for diagnostic purposes let's check it.
if (mReplyStatus[replyId] == WOULD_BLOCK) {
LOGE("Camera_MessageQueue - woke with WOULD_BLOCK\n");
}
}
status = mReplyStatus[replyId];
}
return status;
}
status_t remove(MessageId id, std::vector<MessageType> *vect = nullptr)
{
status_t status = NO_ERROR;
if(isEmpty())
return status;
{
std::lock_guard<std::mutex> l(mQueueMutex);
typename std::list<MessageType>::iterator it = mList.begin();
while (it != mList.end()) {
MessageType msg = *it;
if (msg.id == id) {
if (vect) {
vect->push_back(msg);
}
it = mList.erase(it); // returns pointer to next item in list
} else {
it++;
}
}
}
// unblock caller if waiting
if (mNumReply > 0) {
reply(id, INVALID_OPERATION);
}
return status;
}
// Pop a message from the queue
status_t receive(MessageType *msg,
unsigned int timeout_ms = MESSAGE_QUEUE_RECEIVE_TIMEOUT_MSEC_INFINITE)
{
status_t status = NO_ERROR;
std::unique_lock<std::mutex> l(mQueueMutex);
while (isEmptyLocked()) {
if (timeout_ms) {
mQueueCondition.wait_for(l, std::chrono::milliseconds(timeout_ms));
} else {
mQueueCondition.wait(l);
}
if (isEmptyLocked()) {
LOGE("Camera_MessageQueue - woke with mCount == 0\n");
}
}
*msg = *(--mList.end());
mList.erase(--mList.end());
return status;
}
// Unblock the caller of send and indicate the status of the received message
void reply(MessageId replyId, status_t status)
{
if (replyId < 0 || replyId > mNumReply) {
LOGE("Camera_MessageQueue error: incorrect replyId\n");
return;
}
std::lock_guard<std::mutex> l(mReplyMutex[replyId]);
mReplyStatus[replyId] = status;
mReplyCondition[replyId].notify_one();
}
// Return true if the queue is empty
bool isEmpty()
{
std::lock_guard<std::mutex> l(mQueueMutex);
return isEmptyLocked();
}
int size()
{
std::lock_guard<std::mutex> l(mQueueMutex);
return sizeLocked();
}
private:
// prevent copy constructor and assignment operator
MessageQueue(const MessageQueue& other);
MessageQueue& operator=(const MessageQueue& other);
// Return true if the queue is empty, must be called
// with mQueueMutex taken
inline bool isEmptyLocked() { return sizeLocked() == 0; }
inline int sizeLocked() { return mList.size(); }
const char *mName;
std::mutex mQueueMutex; /* protects mList */
std::condition_variable mQueueCondition;
std::list<MessageType> mList;
const int mNumReply;
std::mutex *mReplyMutex; /* protects mReplayStatus */
std::condition_variable* mReplyCondition;
status_t *mReplyStatus;
}; // class MessageQueue
} NAMESPACE_DECLARATION_END
//#include "MessageQueue.cpp"
#endif // _MESSAGE_QUEUE