Mirror/libcamera
1
0
Fork 0
mirror of https://git.libcamera.org/libcamera/libcamera.git synced 2025-07-13 07:19:45 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

android: post_processor: Make post processing async

Browse source 
Introduce a dedicated worker class derived from libcamera::Thread.
The worker class maintains a queue for post-processing requests
and waits for a post-processing request to become available.
It will process them as per FIFO before de-queuing it from the
queue.

The entire post-processing handling iteration is locked under
streamsProcessMutex_ which helps us to queue all the post-processing
request at once, before any of the post-processing completion slot
(streamProcessingComplete()) is allowed to run for post-processing
requests completing in parallel. This helps us to manage both
synchronous and asynchronous errors encountered during the entire
post processing operation. Since a post-processing operation can
even complete after CameraDevice::requestComplete() has returned,
we need to check and complete the descriptor from
streamProcessingComplete() running in the PostProcessorWorker's
thread.

This patch also implements a flush() for the PostProcessorWorker
class which is responsible to purge post-processing requests
queued up while a camera is stopping/flushing. It is hooked with
CameraStream::flush(), which isn't used currently but will be
used when we handle flush/stop scenarios in greater detail
subsequently (in a different patchset).

The libcamera request completion handler CameraDevice::requestComplete()
assumes that the request that has just completed is at the front of the
queue. Now that the post-processor runs asynchronously, this isn't true
anymore, a request being post-processed will stay in the queue and a new
libcamera request may complete. Remove that assumption, and use the
request cookie to obtain the Camera3RequestDescriptor.

Signed-off-by: Umang Jain <umang.jain@ideasonboard.com>
Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Reviewed-by: Hirokazu Honda <hiroh@chromium.org>
Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
This commit is contained in:
Umang Jain 2021-10-26 12:51:48 +05:30
parent 05862a7e35
commit b1cefe38f3
3 changed files with 153 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

48
src/android/camera_device.cpp
View file

@ -1027,29 +1027,8 @@ int CameraDevice::processCaptureRequest(camera3_capture_request_t *camera3Reques
void CameraDevice::requestComplete(Request *request)
{
Camera3RequestDescriptor *descriptor;
{
MutexLocker descriptorsLock(descriptorsMutex_);
ASSERT(!descriptors_.empty());
descriptor = descriptors_.front().get();
}
if (descriptor->request_->cookie() != request->cookie()) {
/*
* \todo Clarify if the Camera has to be closed on
* ERROR_DEVICE.
*/
LOG(HAL, Error)
<< "Out-of-order completion for request "
<< utils::hex(request->cookie());
MutexLocker descriptorsLock(descriptorsMutex_);
descriptors_.pop();
notifyError(0, nullptr, CAMERA3_MSG_ERROR_DEVICE);
return;
}
Camera3RequestDescriptor *descriptor =
reinterpret_cast<Camera3RequestDescriptor *>(request->cookie());
/*
* Prepare the capture result for the Android camera stack.
@ -1124,9 +1103,13 @@ void CameraDevice::requestComplete(Request *request)
}
/* Handle post-processing. */
MutexLocker locker(descriptor->streamsProcessMutex_);
/*
* \todo Protect the loop below with streamsProcessMutex_ when post
* processor runs asynchronously.
* Queue all the post-processing streams request at once. The completion
* slot streamProcessingComplete() can only execute when we are out
* this critical section. This helps to handle synchronous errors here
* itself.
*/
auto iter = descriptor->pendingStreamsToProcess_.begin();
while (iter != descriptor->pendingStreamsToProcess_.end()) {
@ -1158,8 +1141,10 @@ void CameraDevice::requestComplete(Request *request)
}
}
if (descriptor->pendingStreamsToProcess_.empty())
if (descriptor->pendingStreamsToProcess_.empty()) {
locker.unlock();
completeDescriptor(descriptor);
}
}
void CameraDevice::completeDescriptor(Camera3RequestDescriptor *descriptor)
@ -1242,9 +1227,16 @@ void CameraDevice::streamProcessingComplete(Camera3RequestDescriptor::StreamBuff
streamBuffer->stream->putBuffer(streamBuffer->internalBuffer);
Camera3RequestDescriptor *request = streamBuffer->request;
MutexLocker locker(request->streamsProcessMutex_);
request->pendingStreamsToProcess_.erase(streamBuffer->stream);
{
MutexLocker locker(request->streamsProcessMutex_);
request->pendingStreamsToProcess_.erase(streamBuffer->stream);
if (!request->pendingStreamsToProcess_.empty())
return;
}
completeDescriptor(streamBuffer->request);
}
std::string CameraDevice::logPrefix() const