/*
|
* image_handler.h - image image handler class
|
*
|
* Copyright (c) 2017 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>
|
*/
|
|
#ifndef XCAM_IMAGE_HANDLER_H
|
#define XCAM_IMAGE_HANDLER_H
|
|
#include <xcam_std.h>
|
#include <meta_data.h>
|
#include <buffer_pool.h>
|
#include <worker.h>
|
|
#define DECLARE_HANDLER_CALLBACK(CbClass, Next, mem_func) \
|
class CbClass : public ::XCam::ImageHandler::Callback { \
|
private: ::XCam::SmartPtr<Next> _h; \
|
public: CbClass (const ::XCam::SmartPtr<Next> &h) { _h = h;} \
|
protected: void execute_status ( \
|
const ::XCam::SmartPtr<::XCam::ImageHandler> &handler, \
|
const ::XCam::SmartPtr<::XCam::ImageHandler::Parameters> ¶ms, \
|
const XCamReturn error) { \
|
_h->mem_func (handler, params, error); } \
|
}
|
|
namespace XCam {
|
|
class ImageHandler;
|
|
class ImageHandler
|
: public RefObj
|
{
|
public:
|
struct Parameters {
|
SmartPtr<VideoBuffer> in_buf;
|
SmartPtr<VideoBuffer> out_buf;
|
|
Parameters (const SmartPtr<VideoBuffer> &in = NULL, const SmartPtr<VideoBuffer> &out = NULL)
|
: in_buf (in), out_buf (out)
|
{}
|
virtual ~Parameters() {}
|
bool add_meta (const SmartPtr<MetaBase> &meta);
|
template <typename MType> SmartPtr<MType> find_meta ();
|
|
private:
|
MetaBaseList _metas;
|
};
|
|
class Callback {
|
public:
|
Callback () {}
|
virtual ~Callback () {}
|
virtual void execute_status (
|
const SmartPtr<ImageHandler> &handler, const SmartPtr<Parameters> ¶ms, const XCamReturn error) = 0;
|
|
private:
|
XCAM_DEAD_COPY (Callback);
|
};
|
|
public:
|
explicit ImageHandler (const char* name);
|
virtual ~ImageHandler ();
|
|
bool set_callback (SmartPtr<Callback> cb) {
|
_callback = cb;
|
return true;
|
}
|
const SmartPtr<Callback> & get_callback () const {
|
return _callback;
|
}
|
const char *get_name () const {
|
return _name;
|
}
|
|
// virtual functions
|
// execute_buffer params should NOT be const
|
virtual XCamReturn execute_buffer (const SmartPtr<Parameters> ¶ms, bool sync) = 0;
|
virtual XCamReturn finish ();
|
virtual XCamReturn terminate ();
|
|
protected:
|
virtual void execute_status_check (const SmartPtr<Parameters> ¶ms, const XCamReturn error);
|
|
bool set_allocator (const SmartPtr<BufferPool> &allocator);
|
const SmartPtr<BufferPool> &get_allocator () const {
|
return _allocator;
|
}
|
XCamReturn reserve_buffers (const VideoBufferInfo &info, uint32_t count);
|
SmartPtr<VideoBuffer> get_free_buf ();
|
|
private:
|
XCAM_DEAD_COPY (ImageHandler);
|
|
private:
|
SmartPtr<Callback> _callback;
|
SmartPtr<BufferPool> _allocator;
|
char *_name;
|
};
|
|
inline bool
|
ImageHandler::Parameters::add_meta (const SmartPtr<MetaBase> &meta)
|
{
|
if (!meta.ptr ())
|
return false;
|
|
_metas.push_back (meta);
|
return true;
|
}
|
|
template <typename MType>
|
SmartPtr<MType>
|
ImageHandler::Parameters::find_meta ()
|
{
|
for (MetaBaseList::iterator i = _metas.begin (); i != _metas.end (); ++i) {
|
SmartPtr<MType> m = (*i).dynamic_cast_ptr<MType> ();
|
if (m.ptr ())
|
return m;
|
}
|
return NULL;
|
}
|
|
};
|
|
#endif //XCAM_IMAGE_HANDLER_H
|
