/*
|
* x3a_image_process_center.cpp - 3a process center
|
*
|
* Copyright (c) 2014-2015 Intel 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.
|
*
|
* Author: Wind Yuan <feng.yuan@intel.com>
|
*/
|
#include "x3a_image_process_center.h"
|
|
namespace XCam {
|
|
X3aImageProcessCenter::X3aImageProcessCenter()
|
: _callback (NULL)
|
{
|
XCAM_LOG_DEBUG ("X3aImageProcessCenter construction");
|
}
|
|
X3aImageProcessCenter::~X3aImageProcessCenter()
|
{
|
stop ();
|
XCAM_LOG_DEBUG ("~X3aImageProcessCenter destruction");
|
}
|
|
bool
|
X3aImageProcessCenter::set_image_callback (ImageProcessCallback *callback)
|
{
|
XCAM_ASSERT (!_callback);
|
_callback = callback;
|
return true;
|
}
|
|
bool
|
X3aImageProcessCenter::insert_processor (SmartPtr<ImageProcessor> &processor)
|
{
|
_image_processors.push_back (processor);
|
XCAM_LOG_INFO ("Add processor(%s) into image processor center", XCAM_STR (processor->get_name()));
|
return true;
|
}
|
|
bool
|
X3aImageProcessCenter::has_processors ()
|
{
|
return !_image_processors.empty();
|
}
|
|
XCamReturn
|
X3aImageProcessCenter::start ()
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
|
if (_image_processors.empty()) {
|
XCAM_LOG_ERROR ("process center start failed, no processor found");
|
return XCAM_RETURN_ERROR_PARAM;
|
}
|
|
for (ImageProcessorList::iterator i_pro = _image_processors.begin ();
|
i_pro != _image_processors.end(); ++i_pro)
|
{
|
SmartPtr<ImageProcessor> &processor = *i_pro;
|
XCAM_ASSERT (processor.ptr());
|
processor->set_callback (this);
|
ret = processor->start ();
|
if (ret != XCAM_RETURN_NO_ERROR) {
|
XCAM_LOG_ERROR ("processor(%s) start failed", XCAM_STR(processor->get_name()));
|
break;
|
}
|
}
|
|
if (ret != XCAM_RETURN_NO_ERROR)
|
stop();
|
else {
|
XCAM_LOG_INFO ("3a process center started");
|
}
|
|
return ret;
|
}
|
|
XCamReturn
|
X3aImageProcessCenter::stop ()
|
{
|
for (ImageProcessorList::iterator i_pro = _image_processors.begin ();
|
i_pro != _image_processors.end(); ++i_pro)
|
{
|
SmartPtr<ImageProcessor> &processor = *i_pro;
|
XCAM_ASSERT (processor.ptr());
|
processor->stop ();
|
}
|
|
XCAM_LOG_INFO ("3a process center stopped");
|
|
_image_processors.clear();
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
bool
|
X3aImageProcessCenter::put_buffer (SmartPtr<VideoBuffer> &buf)
|
{
|
XCAM_ASSERT (!_image_processors.empty());
|
if (_image_processors.empty())
|
return false;
|
|
ImageProcessorList::iterator i_pro = _image_processors.begin ();
|
SmartPtr<ImageProcessor> &processor = *i_pro;
|
if (processor->push_buffer (buf) != XCAM_RETURN_NO_ERROR)
|
return false;
|
return true;
|
}
|
|
|
XCamReturn
|
X3aImageProcessCenter::put_3a_results (X3aResultList &results)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
|
XCAM_FAIL_RETURN (ERROR, !results.empty(), XCAM_RETURN_ERROR_PARAM, "results empty");
|
|
for (ImageProcessorIter i_pro = _image_processors.begin();
|
i_pro != _image_processors.end(); i_pro++) {
|
SmartPtr<ImageProcessor> &processor = *i_pro;
|
XCAM_ASSERT (processor.ptr());
|
ret = processor->push_3a_results (results);
|
if (ret != XCAM_RETURN_NO_ERROR && ret != XCAM_RETURN_BYPASS) {
|
XCAM_LOG_WARNING ("processor(%s) gailed on results", XCAM_STR(processor->get_name()));
|
break;
|
}
|
if (results.empty ()) {
|
XCAM_LOG_DEBUG ("results done");
|
return XCAM_RETURN_NO_ERROR;
|
}
|
}
|
|
if (!results.empty()) {
|
XCAM_LOG_DEBUG ("process center: results left without being processed");
|
return XCAM_RETURN_BYPASS;
|
}
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
|
XCamReturn
|
X3aImageProcessCenter::put_3a_result (SmartPtr<X3aResult> &result)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
|
XCAM_FAIL_RETURN (ERROR, !result.ptr(), XCAM_RETURN_ERROR_PARAM, "result empty");
|
|
for (ImageProcessorIter i_pro = _image_processors.begin();
|
i_pro != _image_processors.end(); i_pro++)
|
{
|
SmartPtr<ImageProcessor> &processor = *i_pro;
|
XCAM_ASSERT (processor.ptr());
|
ret = processor->push_3a_result (result);
|
|
if (ret == XCAM_RETURN_BYPASS)
|
continue;
|
|
if (ret == XCAM_RETURN_NO_ERROR)
|
return XCAM_RETURN_NO_ERROR;
|
|
XCAM_LOG_WARNING ("processor(%s) failed on result", XCAM_STR(processor->get_name()));
|
return ret;
|
}
|
|
if (ret == XCAM_RETURN_BYPASS) {
|
XCAM_LOG_WARNING ("processor center: no processor can handle result()");
|
}
|
|
return ret;
|
}
|
|
void
|
X3aImageProcessCenter::process_buffer_done (ImageProcessor *processor, const SmartPtr<VideoBuffer> &buf)
|
{
|
ImageProcessorIter i_pro = _image_processors.begin();
|
for (; i_pro != _image_processors.end(); ++i_pro)
|
{
|
SmartPtr<ImageProcessor> &cur_pro = *i_pro;
|
XCAM_ASSERT (cur_pro.ptr());
|
if (cur_pro.ptr() == processor)
|
break;
|
}
|
|
XCAM_ASSERT (i_pro != _image_processors.end());
|
if (i_pro == _image_processors.end()) {
|
XCAM_LOG_ERROR ("processor doesn't found from list of image center");
|
return;
|
}
|
|
if (++i_pro != _image_processors.end()) {
|
SmartPtr<ImageProcessor> &next_processor = *i_pro;
|
SmartPtr<VideoBuffer> cur_buf = buf;
|
XCAM_ASSERT (next_processor.ptr());
|
XCamReturn ret = next_processor->push_buffer (cur_buf);
|
if (ret != XCAM_RETURN_NO_ERROR) {
|
XCAM_LOG_ERROR ("processor(%s) failed in push_buffer", next_processor->get_name());
|
}
|
return;
|
}
|
|
//all processor done
|
if (_callback)
|
_callback->process_buffer_done (processor, buf);
|
else
|
ImageProcessCallback::process_buffer_done (processor, buf);
|
}
|
|
void
|
X3aImageProcessCenter::process_buffer_failed (ImageProcessor *processor, const SmartPtr<VideoBuffer> &buf)
|
{
|
if (_callback)
|
_callback->process_buffer_failed(processor, buf);
|
else
|
ImageProcessCallback::process_buffer_failed (processor, buf);
|
}
|
|
void
|
X3aImageProcessCenter::process_image_result_done (ImageProcessor *processor, const SmartPtr<X3aResult> &result)
|
{
|
if (_callback)
|
_callback->process_image_result_done(processor, result);
|
else
|
ImageProcessCallback::process_image_result_done (processor, result);
|
}
|
|
};
|
