camera/hal/mediatek/mtkcam/ipc/client/Mediatek3AClient.cpp - mirrors/cros/chromiumos/platform2 - Git at Google

 /*
  * Copyright (C) 2019 Mediatek Corporation.
  *
  * 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.
  */

 #define LOG_TAG "Mediatek3AClient"
 #include <fcntl.h>
 #include <memory>
 #include <string>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <vector>

 #include <mtkcam/ipc/client/Mediatek3AClient.h>
 #include <mtkcam/utils/std/Mojo.h>

 #include "Hal3AIpcAdapter.h"

 Mediatek3AClient* Mediatek3AClient::getInstance() {
   static Mediatek3AClient* ipc_3a_client = nullptr;
   static std::mutex ipc_3a_client_mutex;
   std::lock_guard<std::mutex> lock(ipc_3a_client_mutex);

   if (ipc_3a_client == nullptr)
     ipc_3a_client = new Mediatek3AClient();

   return ipc_3a_client;
 }

 Mediatek3AClient::Mediatek3AClient()
     : mErrCb(nullptr), mIPCStatus(true), mInitialized(false) {
   LOG1("@%s", __FUNCTION__);

   mCallback =
       base::Bind(&Mediatek3AClient::callbackHandler, base::Unretained(this));
   Mediatek3AClient::return_callback = returnCallback;

   mNotifyCallback =
       base::Bind(&Mediatek3AClient::notifyHandler, base::Unretained(this));
   Mediatek3AClient::notify = notifyCallback;

   mBridge = cros::CameraAlgorithmBridge::CreateInstance(
       cros::CameraAlgorithmBackend::kVendorCpu,
       NSCam::Utils::getMojoManagerToken());

   CheckError(!mBridge, VOID_VALUE, "@%s, mBridge is nullptr", __FUNCTION__);
   CheckError((mBridge->Initialize(this) != 0), VOID_VALUE,
              "@%s, call mBridge->Initialize fail", __FUNCTION__);

   for (int i = 0; i < IPC_GROUP_NUM; i++) {
     mRunner[i] = std::unique_ptr<Runner>(
         new Runner(static_cast<IPC_GROUP>(i), mBridge.get()));
   }

   mInitialized = true;
 }

 Mediatek3AClient::~Mediatek3AClient() {
   LOG1("@%s", __FUNCTION__);
 }

 void Mediatek3AClient::tryReconnectBridge() {
   LOG1("@%s", __FUNCTION__);

   mBridge.reset(nullptr);
   for (int i = 0; i < IPC_GROUP_NUM; i++)
     mRunner[i].reset(nullptr);

   mInitialized = false;

   mCallback =
       base::Bind(&Mediatek3AClient::callbackHandler, base::Unretained(this));
   Mediatek3AClient::return_callback = returnCallback;

   mNotifyCallback =
       base::Bind(&Mediatek3AClient::notifyHandler, base::Unretained(this));
   Mediatek3AClient::notify = notifyCallback;

   mBridge = cros::CameraAlgorithmBridge::CreateInstance(
       cros::CameraAlgorithmBackend::kVendorCpu,
       NSCam::Utils::getMojoManagerToken());
   CheckError(!mBridge, VOID_VALUE, "@%s, mBridge is nullptr", __FUNCTION__);
   CheckError((mBridge->Initialize(this) != 0), VOID_VALUE,
              "@%s, call mBridge->Initialize fail", __FUNCTION__);

   for (int i = 0; i < IPC_GROUP_NUM; i++)
     mRunner[i] = std::unique_ptr<Runner>(
         new Runner(static_cast<IPC_GROUP>(i), mBridge.get()));

   mInitialized = true;
   mIPCStatus = true;
   mErrCb = nullptr;
 }

 bool Mediatek3AClient::isInitialized() {
   LOG1("@%s, mInitialized:%d", __FUNCTION__, mInitialized);

   return mInitialized;
 }

 bool Mediatek3AClient::isIPCFine() {
   std::lock_guard<std::mutex> l(mIPCStatusMutex);
   LOG1("@%s, mIPCStatus:%d", __FUNCTION__, mIPCStatus);

   return mIPCStatus;
 }

 void Mediatek3AClient::registerErrorCallback(IErrorCallback* errCb) {
   LOG1("@%s, errCb:%p", __FUNCTION__, errCb);

   std::lock_guard<std::mutex> l(mIPCStatusMutex);
   mErrCb = errCb;

   if (!mIPCStatus && mErrCb) {
     mErrCb->deviceError();
   }
 }

 int Mediatek3AClient::allocateShmMem(std::string const& name,
                                      int size,
                                      int* fd,
                                      void** addr) {
   LOG1("@%s, name:%s, size:%d", __FUNCTION__, name.c_str(), size);

   *fd = -1;
   *addr = nullptr;
   int shmFd = -1;
   void* shmAddr = nullptr;

   shmFd = shm_open(name.c_str(), O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
   CheckError((shmFd == -1), UNKNOWN_ERROR, "@%s, call shm_open fail",
              __FUNCTION__);

   int ret = fcntl(shmFd, F_GETFD);
   CheckError((ret == -1), UNKNOWN_ERROR, "@%s, call fcntl fail", __FUNCTION__);

   ret = ftruncate(shmFd, size);
   CheckError((ret == -1), UNKNOWN_ERROR, "@%s, call ftruncate fail",
              __FUNCTION__);

   struct stat sb;
   ret = fstat(shmFd, &sb);
   CheckError((ret == -1), UNKNOWN_ERROR, "@%s, call fstat fail", __FUNCTION__);
   CheckError((sb.st_size != size), UNKNOWN_ERROR, "@%s, sb.st_size:%jd",
              __FUNCTION__, (intmax_t)sb.st_size);

   shmAddr = mmap(0, sb.st_size, PROT_WRITE, MAP_SHARED, shmFd, 0);
   CheckError((!shmAddr), UNKNOWN_ERROR, "@%s, call mmap fail", __FUNCTION__);

   *fd = shmFd;
   *addr = shmAddr;

   return OK;
 }

 void Mediatek3AClient::releaseShmMem(std::string const& name,
                                      int size,
                                      int fd,
                                      void* addr) {
   LOG1("@%s, name:%s, size:%d, fd:%d, addr:%p", __FUNCTION__, name.c_str(),
        size, fd, addr);

   munmap(addr, size);
   close(fd);
   shm_unlink(name.c_str());
 }

 int Mediatek3AClient::requestSync(IPC_CMD cmd,
                                   int32_t bufferHandle,
                                   int32_t group) {
   CheckError(!mInitialized, UNKNOWN_ERROR, "@%s, mInitialized is false",
              __FUNCTION__);
   CheckError(!isIPCFine(), UNKNOWN_ERROR, "@%s, IPC error happens",
              __FUNCTION__);

   return mRunner[group]->requestSync(cmd, bufferHandle, group);
 }

 int Mediatek3AClient::requestSync(IPC_CMD cmd, int32_t bufferHandle) {
   return requestSync(cmd, bufferHandle, 0);
 }

 int Mediatek3AClient::requestSync(IPC_CMD cmd) {
   return requestSync(cmd, -1, 0);
 }

 int32_t Mediatek3AClient::registerBuffer(int bufferFd) {
   LOG1("@%s, bufferFd:%d, mInitialized:%d", __FUNCTION__, bufferFd,
        mInitialized);
   CheckError(!mInitialized, -1, "@%s, mInitialized is false", __FUNCTION__);
   CheckError(!isIPCFine(), -1, "@%s, IPC error happens", __FUNCTION__);

   return mBridge->RegisterBuffer(bufferFd);
 }

 void Mediatek3AClient::deregisterBuffer(int32_t bufferHandle) {
   LOG1("@%s, bufferHandle:%d, mInitialized:%d", __FUNCTION__, bufferHandle,
        mInitialized);
   CheckError(!mInitialized, VOID_VALUE, "@%s, mInitialized is false",
              __FUNCTION__);
   CheckError(!isIPCFine(), VOID_VALUE, "@%s, IPC error happens", __FUNCTION__);

   std::vector<int32_t> handles({bufferHandle});
   mBridge->DeregisterBuffers(handles);
 }

 void Mediatek3AClient::callbackHandler(uint32_t req_id,
                                        uint32_t status,
                                        int32_t buffer_handle) {
   LOG1("@%s, req_id:%d, status:%d, buffer_handle:%d", __FUNCTION__, req_id,
        status, buffer_handle);

   IPC_GROUP group = Mediatek3AIpcCmdToGroup(static_cast<IPC_CMD>(req_id));
   mRunner[group]->callbackHandler(req_id, status, buffer_handle);
 }

 void Mediatek3AClient::notifyHandler(uint32_t msg) {
   LOG1("@%s, msg:%d", __FUNCTION__, msg);

   if (msg != CAMERA_ALGORITHM_MSG_IPC_ERROR) {
     IPC_LOGE("@%s, receive msg:%d, not CAMERA_ALGORITHM_MSG_IPC_ERROR",
              __FUNCTION__, msg);
     return;
   }

   std::lock_guard<std::mutex> l(mIPCStatusMutex);
   mIPCStatus = false;
   if (mErrCb) {
     mErrCb->deviceError();
   } else {
     IPC_LOGE("@%s, mErrCb is nullptr, no device error is sent out",
              __FUNCTION__);
   }
   IPC_LOGE("@%s, receive CAMERA_ALGORITHM_MSG_IPC_ERROR", __FUNCTION__);
 }

 void Mediatek3AClient::returnCallback(
     const camera_algorithm_callback_ops_t* callback_ops,
     uint32_t req_id,
     uint32_t status,
     int32_t buffer_handle) {
   LOG1("@%s cmd:%d", __FUNCTION__, req_id);
   CheckError(!callback_ops, VOID_VALUE, "@%s, callback_ops is nullptr",
              __FUNCTION__);

   auto s = const_cast<Mediatek3AClient*>(
       static_cast<const Mediatek3AClient*>(callback_ops));
   s->mCallback.Run(req_id, status, buffer_handle);
 }

 void Mediatek3AClient::notifyCallback(
     const struct camera_algorithm_callback_ops* callback_ops,
     camera_algorithm_error_msg_code_t msg) {
   LOG1("@%s", __FUNCTION__);
   CheckError(!callback_ops, VOID_VALUE, "@%s, callback_ops is nullptr",
              __FUNCTION__);

   auto s = const_cast<Mediatek3AClient*>(
       static_cast<const Mediatek3AClient*>(callback_ops));
   s->mNotifyCallback.Run((uint32_t)msg);
 }

 Mediatek3AClient::Runner::Runner(IPC_GROUP group,
                                  cros::CameraAlgorithmBridge* bridge)
     : mGroup(group),
       mBridge(bridge),
       mIsCallbacked(false),
       mCbResult(true),
       mInitialized(false) {
   LOG1("@%s, group:%d", __FUNCTION__, mGroup);

   pthread_condattr_t attr;
   int ret = pthread_condattr_init(&attr);
   if (ret != 0) {
     IPC_LOGE("@%s, call pthread_condattr_init fails, ret:%d", __FUNCTION__,
              ret);
     pthread_condattr_destroy(&attr);
     return;
   }

   ret = pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
   if (ret != 0) {
     IPC_LOGE("@%s, call pthread_condattr_setclock fails, ret:%d", __FUNCTION__,
              ret);
     pthread_condattr_destroy(&attr);
     return;
   }

   ret = pthread_cond_init(&mCbCond, &attr);
   if (ret != 0) {
     IPC_LOGE("@%s, call pthread_cond_init fails, ret:%d", __FUNCTION__, ret);
     pthread_condattr_destroy(&attr);
     return;
   }

   pthread_condattr_destroy(&attr);

   ret = pthread_mutex_init(&mCbLock, nullptr);
   CheckError(ret != 0, VOID_VALUE, "@%s, call pthread_mutex_init fails, ret:%d",
              __FUNCTION__, ret);

   mInitialized = true;
 }

 Mediatek3AClient::Runner::~Runner() {
   LOG1("@%s, group:%d", __FUNCTION__, mGroup);

   int ret = pthread_cond_destroy(&mCbCond);
   if (ret != 0) {
     IPC_LOGE("@%s, call pthread_cond_destroy fails, ret:%d", __FUNCTION__, ret);
   }

   ret = pthread_mutex_destroy(&mCbLock);
   if (ret != 0) {
     IPC_LOGE("@%s, call pthread_mutex_destroy fails, ret:%d", __FUNCTION__,
              ret);
   }
 }

 int Mediatek3AClient::Runner::requestSync(IPC_CMD cmd,
                                           int32_t bufferHandle,
                                           int servGroup) {
   std::lock_guard<std::mutex> lck(mMutex);

   LOG1("@%s, cmd:%d, group:%d, bufferHandle:%d, mInitialized:%d, servGroup:%d",
        __FUNCTION__, cmd, mGroup, bufferHandle, mInitialized, servGroup);
   CheckError(!mInitialized, UNKNOWN_ERROR, "@%s, mInitialized is false",
              __FUNCTION__);

   std::vector<uint8_t> reqHeader(IPC_REQUEST_HEADER_USED_NUM);
   reqHeader[0] = IPC_MATCHING_KEY;
   reqHeader[1] = servGroup;

   // cmd is for request id, no duplicate command will be issued at any given
   // time.
   mBridge->Request(cmd, reqHeader, bufferHandle);
   int ret = waitCallback();
   CheckError((ret != OK), UNKNOWN_ERROR, "@%s, cmd:%d call waitCallback fail",
              __FUNCTION__, cmd);

   LOG1("@%s, cmd:%d, group:%d, mCbResult:%d, done!", __FUNCTION__, cmd, mGroup,
        mCbResult);

   // check callback result
   CheckError((mCbResult != true), UNKNOWN_ERROR, "@%s, %s(%d) callback fail",
              __FUNCTION__, Mediatek3AIpcCmdToString(cmd).c_str(), cmd);

   return OK;
 }

 void Mediatek3AClient::Runner::callbackHandler(uint32_t req_id,
                                                uint32_t status,
                                                int32_t buffer_handle) {
   LOG1("@%s, req_id:%d, status:%d, buffer_handle:%d", __FUNCTION__, req_id,
        status, buffer_handle);

   if (req_id == IPC_HAL3A_NOTIFY_CB) {
     int sensorIdx = buffer_handle;
     NS3Av3::Hal3AIpcAdapter* ipc_3a_adapter =
         dynamic_cast<NS3Av3::Hal3AIpcAdapter*>(
             NS3Av3::Hal3AIpcAdapter::getInstance(sensorIdx, "ipc_callback"));
     ipc_3a_adapter->runCallback(buffer_handle);
     ipc_3a_adapter->destroyInstance("ipc_callback");
   } else {
     mCbResult = status != 0 ? false : true;
     pthread_mutex_lock(&mCbLock);
     mIsCallbacked = true;
     int ret = pthread_cond_signal(&mCbCond);
     pthread_mutex_unlock(&mCbLock);

     CheckError(ret != 0, VOID_VALUE,
                "@%s, call pthread_cond_signal fails, ret:%d", __FUNCTION__,
                ret);
   }
 }

 int Mediatek3AClient::Runner::waitCallback() {
   LOG1("@%s, group:%d", __FUNCTION__, mGroup);

   pthread_mutex_lock(&mCbLock);
   if (!mIsCallbacked) {
     int ret = 0;
     struct timespec ts = {0, 0};
     clock_gettime(CLOCK_MONOTONIC, &ts);
     ts.tv_sec += 5;  // 5s timeout

     while (!mIsCallbacked && !ret) {
       ret = pthread_cond_timedwait(&mCbCond, &mCbLock, &ts);
     }
     if (ret != 0) {
       IPC_LOGE(
           "@%s, group:%d, call pthread_cond_timedwait fail, ret:%d, it takes "
           "%d ms",
           __FUNCTION__, mGroup, ret, 5000);
       pthread_mutex_unlock(&mCbLock);
       return UNKNOWN_ERROR;
     }
   }
   mIsCallbacked = false;
   pthread_mutex_unlock(&mCbLock);

   LOG1("@%s: group:%d, it takes %d ms", __FUNCTION__, mGroup, 1);

   return OK;
 }
	/*
	* Copyright (C) 2019 Mediatek Corporation.
	*
	* 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.
	*/

	#define LOG_TAG "Mediatek3AClient"
	#include <fcntl.h>
	#include <memory>
	#include <string>
	#include <sys/mman.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <vector>

	#include <mtkcam/ipc/client/Mediatek3AClient.h>
	#include <mtkcam/utils/std/Mojo.h>

	#include "Hal3AIpcAdapter.h"

	Mediatek3AClient* Mediatek3AClient::getInstance() {
	static Mediatek3AClient* ipc_3a_client = nullptr;
	static std::mutex ipc_3a_client_mutex;
	std::lock_guard<std::mutex> lock(ipc_3a_client_mutex);

	if (ipc_3a_client == nullptr)
	ipc_3a_client = new Mediatek3AClient();

	return ipc_3a_client;
	}

	Mediatek3AClient::Mediatek3AClient()
	: mErrCb(nullptr), mIPCStatus(true), mInitialized(false) {
	LOG1("@%s", __FUNCTION__);

	mCallback =
	base::Bind(&Mediatek3AClient::callbackHandler, base::Unretained(this));
	Mediatek3AClient::return_callback = returnCallback;

	mNotifyCallback =
	base::Bind(&Mediatek3AClient::notifyHandler, base::Unretained(this));
	Mediatek3AClient::notify = notifyCallback;

	mBridge = cros::CameraAlgorithmBridge::CreateInstance(
	cros::CameraAlgorithmBackend::kVendorCpu,
	NSCam::Utils::getMojoManagerToken());

	CheckError(!mBridge, VOID_VALUE, "@%s, mBridge is nullptr", __FUNCTION__);
	CheckError((mBridge->Initialize(this) != 0), VOID_VALUE,
	"@%s, call mBridge->Initialize fail", __FUNCTION__);

	for (int i = 0; i < IPC_GROUP_NUM; i++) {
	mRunner[i] = std::unique_ptr<Runner>(
	new Runner(static_cast<IPC_GROUP>(i), mBridge.get()));
	}

	mInitialized = true;
	}

	Mediatek3AClient::~Mediatek3AClient() {
	LOG1("@%s", __FUNCTION__);
	}

	void Mediatek3AClient::tryReconnectBridge() {
	LOG1("@%s", __FUNCTION__);

	mBridge.reset(nullptr);
	for (int i = 0; i < IPC_GROUP_NUM; i++)
	mRunner[i].reset(nullptr);

	mInitialized = false;

	mCallback =
	base::Bind(&Mediatek3AClient::callbackHandler, base::Unretained(this));
	Mediatek3AClient::return_callback = returnCallback;

	mNotifyCallback =
	base::Bind(&Mediatek3AClient::notifyHandler, base::Unretained(this));
	Mediatek3AClient::notify = notifyCallback;

	mBridge = cros::CameraAlgorithmBridge::CreateInstance(
	cros::CameraAlgorithmBackend::kVendorCpu,
	NSCam::Utils::getMojoManagerToken());
	CheckError(!mBridge, VOID_VALUE, "@%s, mBridge is nullptr", __FUNCTION__);
	CheckError((mBridge->Initialize(this) != 0), VOID_VALUE,
	"@%s, call mBridge->Initialize fail", __FUNCTION__);

	for (int i = 0; i < IPC_GROUP_NUM; i++)
	mRunner[i] = std::unique_ptr<Runner>(
	new Runner(static_cast<IPC_GROUP>(i), mBridge.get()));

	mInitialized = true;
	mIPCStatus = true;
	mErrCb = nullptr;
	}

	bool Mediatek3AClient::isInitialized() {
	LOG1("@%s, mInitialized:%d", __FUNCTION__, mInitialized);

	return mInitialized;
	}

	bool Mediatek3AClient::isIPCFine() {
	std::lock_guard<std::mutex> l(mIPCStatusMutex);
	LOG1("@%s, mIPCStatus:%d", __FUNCTION__, mIPCStatus);

	return mIPCStatus;
	}

	void Mediatek3AClient::registerErrorCallback(IErrorCallback* errCb) {
	LOG1("@%s, errCb:%p", __FUNCTION__, errCb);

	std::lock_guard<std::mutex> l(mIPCStatusMutex);
	mErrCb = errCb;

	if (!mIPCStatus && mErrCb) {
	mErrCb->deviceError();
	}
	}

	int Mediatek3AClient::allocateShmMem(std::string const& name,
	int size,
	int* fd,
	void** addr) {
	LOG1("@%s, name:%s, size:%d", __FUNCTION__, name.c_str(), size);

	*fd = -1;
	*addr = nullptr;
	int shmFd = -1;
	void* shmAddr = nullptr;

	shmFd = shm_open(name.c_str(), O_CREAT \| O_RDWR, S_IRUSR \| S_IWUSR);
	CheckError((shmFd == -1), UNKNOWN_ERROR, "@%s, call shm_open fail",
	__FUNCTION__);

	int ret = fcntl(shmFd, F_GETFD);
	CheckError((ret == -1), UNKNOWN_ERROR, "@%s, call fcntl fail", __FUNCTION__);

	ret = ftruncate(shmFd, size);
	CheckError((ret == -1), UNKNOWN_ERROR, "@%s, call ftruncate fail",
	__FUNCTION__);

	struct stat sb;
	ret = fstat(shmFd, &sb);
	CheckError((ret == -1), UNKNOWN_ERROR, "@%s, call fstat fail", __FUNCTION__);
	CheckError((sb.st_size != size), UNKNOWN_ERROR, "@%s, sb.st_size:%jd",
	__FUNCTION__, (intmax_t)sb.st_size);

	shmAddr = mmap(0, sb.st_size, PROT_WRITE, MAP_SHARED, shmFd, 0);
	CheckError((!shmAddr), UNKNOWN_ERROR, "@%s, call mmap fail", __FUNCTION__);

	*fd = shmFd;
	*addr = shmAddr;

	return OK;
	}

	void Mediatek3AClient::releaseShmMem(std::string const& name,
	int size,
	int fd,
	void* addr) {
	LOG1("@%s, name:%s, size:%d, fd:%d, addr:%p", __FUNCTION__, name.c_str(),
	size, fd, addr);

	munmap(addr, size);
	close(fd);
	shm_unlink(name.c_str());
	}

	int Mediatek3AClient::requestSync(IPC_CMD cmd,
	int32_t bufferHandle,
	int32_t group) {
	CheckError(!mInitialized, UNKNOWN_ERROR, "@%s, mInitialized is false",
	__FUNCTION__);
	CheckError(!isIPCFine(), UNKNOWN_ERROR, "@%s, IPC error happens",
	__FUNCTION__);

	return mRunner[group]->requestSync(cmd, bufferHandle, group);
	}

	int Mediatek3AClient::requestSync(IPC_CMD cmd, int32_t bufferHandle) {
	return requestSync(cmd, bufferHandle, 0);
	}

	int Mediatek3AClient::requestSync(IPC_CMD cmd) {
	return requestSync(cmd, -1, 0);
	}

	int32_t Mediatek3AClient::registerBuffer(int bufferFd) {
	LOG1("@%s, bufferFd:%d, mInitialized:%d", __FUNCTION__, bufferFd,
	mInitialized);
	CheckError(!mInitialized, -1, "@%s, mInitialized is false", __FUNCTION__);
	CheckError(!isIPCFine(), -1, "@%s, IPC error happens", __FUNCTION__);

	return mBridge->RegisterBuffer(bufferFd);
	}

	void Mediatek3AClient::deregisterBuffer(int32_t bufferHandle) {
	LOG1("@%s, bufferHandle:%d, mInitialized:%d", __FUNCTION__, bufferHandle,
	mInitialized);
	CheckError(!mInitialized, VOID_VALUE, "@%s, mInitialized is false",
	__FUNCTION__);
	CheckError(!isIPCFine(), VOID_VALUE, "@%s, IPC error happens", __FUNCTION__);

	std::vector<int32_t> handles({bufferHandle});
	mBridge->DeregisterBuffers(handles);
	}

	void Mediatek3AClient::callbackHandler(uint32_t req_id,
	uint32_t status,
	int32_t buffer_handle) {
	LOG1("@%s, req_id:%d, status:%d, buffer_handle:%d", __FUNCTION__, req_id,
	status, buffer_handle);

	IPC_GROUP group = Mediatek3AIpcCmdToGroup(static_cast<IPC_CMD>(req_id));
	mRunner[group]->callbackHandler(req_id, status, buffer_handle);
	}

	void Mediatek3AClient::notifyHandler(uint32_t msg) {
	LOG1("@%s, msg:%d", __FUNCTION__, msg);

	if (msg != CAMERA_ALGORITHM_MSG_IPC_ERROR) {
	IPC_LOGE("@%s, receive msg:%d, not CAMERA_ALGORITHM_MSG_IPC_ERROR",
	__FUNCTION__, msg);
	return;
	}

	std::lock_guard<std::mutex> l(mIPCStatusMutex);
	mIPCStatus = false;
	if (mErrCb) {
	mErrCb->deviceError();
	} else {
	IPC_LOGE("@%s, mErrCb is nullptr, no device error is sent out",
	__FUNCTION__);
	}
	IPC_LOGE("@%s, receive CAMERA_ALGORITHM_MSG_IPC_ERROR", __FUNCTION__);
	}

	void Mediatek3AClient::returnCallback(
	const camera_algorithm_callback_ops_t* callback_ops,
	uint32_t req_id,
	uint32_t status,
	int32_t buffer_handle) {
	LOG1("@%s cmd:%d", __FUNCTION__, req_id);
	CheckError(!callback_ops, VOID_VALUE, "@%s, callback_ops is nullptr",
	__FUNCTION__);

	auto s = const_cast<Mediatek3AClient*>(
	static_cast<const Mediatek3AClient*>(callback_ops));
	s->mCallback.Run(req_id, status, buffer_handle);
	}

	void Mediatek3AClient::notifyCallback(
	const struct camera_algorithm_callback_ops* callback_ops,
	camera_algorithm_error_msg_code_t msg) {
	LOG1("@%s", __FUNCTION__);
	CheckError(!callback_ops, VOID_VALUE, "@%s, callback_ops is nullptr",
	__FUNCTION__);

	auto s = const_cast<Mediatek3AClient*>(
	static_cast<const Mediatek3AClient*>(callback_ops));
	s->mNotifyCallback.Run((uint32_t)msg);
	}

	Mediatek3AClient::Runner::Runner(IPC_GROUP group,
	cros::CameraAlgorithmBridge* bridge)
	: mGroup(group),
	mBridge(bridge),
	mIsCallbacked(false),
	mCbResult(true),
	mInitialized(false) {
	LOG1("@%s, group:%d", __FUNCTION__, mGroup);

	pthread_condattr_t attr;
	int ret = pthread_condattr_init(&attr);
	if (ret != 0) {
	IPC_LOGE("@%s, call pthread_condattr_init fails, ret:%d", __FUNCTION__,
	ret);
	pthread_condattr_destroy(&attr);
	return;
	}

	ret = pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
	if (ret != 0) {
	IPC_LOGE("@%s, call pthread_condattr_setclock fails, ret:%d", __FUNCTION__,
	ret);
	pthread_condattr_destroy(&attr);
	return;
	}

	ret = pthread_cond_init(&mCbCond, &attr);
	if (ret != 0) {
	IPC_LOGE("@%s, call pthread_cond_init fails, ret:%d", __FUNCTION__, ret);
	pthread_condattr_destroy(&attr);
	return;
	}

	pthread_condattr_destroy(&attr);

	ret = pthread_mutex_init(&mCbLock, nullptr);
	CheckError(ret != 0, VOID_VALUE, "@%s, call pthread_mutex_init fails, ret:%d",
	__FUNCTION__, ret);

	mInitialized = true;
	}

	Mediatek3AClient::Runner::~Runner() {
	LOG1("@%s, group:%d", __FUNCTION__, mGroup);

	int ret = pthread_cond_destroy(&mCbCond);
	if (ret != 0) {
	IPC_LOGE("@%s, call pthread_cond_destroy fails, ret:%d", __FUNCTION__, ret);
	}

	ret = pthread_mutex_destroy(&mCbLock);
	if (ret != 0) {
	IPC_LOGE("@%s, call pthread_mutex_destroy fails, ret:%d", __FUNCTION__,
	ret);
	}
	}

	int Mediatek3AClient::Runner::requestSync(IPC_CMD cmd,
	int32_t bufferHandle,
	int servGroup) {
	std::lock_guard<std::mutex> lck(mMutex);

	LOG1("@%s, cmd:%d, group:%d, bufferHandle:%d, mInitialized:%d, servGroup:%d",
	__FUNCTION__, cmd, mGroup, bufferHandle, mInitialized, servGroup);
	CheckError(!mInitialized, UNKNOWN_ERROR, "@%s, mInitialized is false",
	__FUNCTION__);

	std::vector<uint8_t> reqHeader(IPC_REQUEST_HEADER_USED_NUM);
	reqHeader[0] = IPC_MATCHING_KEY;
	reqHeader[1] = servGroup;

	// cmd is for request id, no duplicate command will be issued at any given
	// time.
	mBridge->Request(cmd, reqHeader, bufferHandle);
	int ret = waitCallback();
	CheckError((ret != OK), UNKNOWN_ERROR, "@%s, cmd:%d call waitCallback fail",
	__FUNCTION__, cmd);

	LOG1("@%s, cmd:%d, group:%d, mCbResult:%d, done!", __FUNCTION__, cmd, mGroup,
	mCbResult);

	// check callback result
	CheckError((mCbResult != true), UNKNOWN_ERROR, "@%s, %s(%d) callback fail",
	__FUNCTION__, Mediatek3AIpcCmdToString(cmd).c_str(), cmd);

	return OK;
	}

	void Mediatek3AClient::Runner::callbackHandler(uint32_t req_id,
	uint32_t status,
	int32_t buffer_handle) {
	LOG1("@%s, req_id:%d, status:%d, buffer_handle:%d", __FUNCTION__, req_id,
	status, buffer_handle);

	if (req_id == IPC_HAL3A_NOTIFY_CB) {
	int sensorIdx = buffer_handle;
	NS3Av3::Hal3AIpcAdapter* ipc_3a_adapter =
	dynamic_cast<NS3Av3::Hal3AIpcAdapter*>(
	NS3Av3::Hal3AIpcAdapter::getInstance(sensorIdx, "ipc_callback"));
	ipc_3a_adapter->runCallback(buffer_handle);
	ipc_3a_adapter->destroyInstance("ipc_callback");
	} else {
	mCbResult = status != 0 ? false : true;
	pthread_mutex_lock(&mCbLock);
	mIsCallbacked = true;
	int ret = pthread_cond_signal(&mCbCond);
	pthread_mutex_unlock(&mCbLock);

	CheckError(ret != 0, VOID_VALUE,
	"@%s, call pthread_cond_signal fails, ret:%d", __FUNCTION__,
	ret);
	}
	}

	int Mediatek3AClient::Runner::waitCallback() {
	LOG1("@%s, group:%d", __FUNCTION__, mGroup);

	pthread_mutex_lock(&mCbLock);
	if (!mIsCallbacked) {
	int ret = 0;
	struct timespec ts = {0, 0};
	clock_gettime(CLOCK_MONOTONIC, &ts);
	ts.tv_sec += 5; // 5s timeout

	while (!mIsCallbacked && !ret) {
	ret = pthread_cond_timedwait(&mCbCond, &mCbLock, &ts);
	}
	if (ret != 0) {
	IPC_LOGE(
	"@%s, group:%d, call pthread_cond_timedwait fail, ret:%d, it takes "
	"%d ms",
	__FUNCTION__, mGroup, ret, 5000);
	pthread_mutex_unlock(&mCbLock);
	return UNKNOWN_ERROR;
	}
	}
	mIsCallbacked = false;
	pthread_mutex_unlock(&mCbLock);

	LOG1("@%s: group:%d, it takes %d ms", __FUNCTION__, mGroup, 1);

	return OK;
	}