FacerecService.h

#ifndef __PBIO_API__PBIO__FACEREC_SERVICE_H_
#define __PBIO_API__PBIO__FACEREC_SERVICE_H_


#include <istream>
#include <stdexcept>
#include <utility>
#include <vector>
#include <facerec/libfacerec.h>

#ifdef ANDROID
#include <jni.h>
#endif

#include "stl_wraps_impls/WrapIStreamImpl.h"
#include "stl_wraps_impls/WrapOStreamImpl.h"


#include "AgeGenderEstimator.h"
#include "CameraCalibrator.h"
#include "Capturer.h"
#include "ComplexObject.h"
#include "DepthLivenessEstimator.h"
#include "IRLivenessEstimator.h"
#include "ActiveLiveness.h"
#include "Liveness2DEstimator.h"
#include "FaceAttributesEstimator.h"
#include "EmotionsEstimator.h"
#include "Error.h"
#include "ExceptionCheck.h"
#include "FaceQualityEstimator.h"
#include "LivenessEstimator.h"
#include "QualityEstimator.h"
#include "RawSample.h"
#include "Recognizer.h"
#include "SmartPtr.h"
#include "Template.h"
#include "VideoWorker.h"
#include "StructStorage.h"
#include "Config.h"
#include "ProcessingUnit.h"

#ifndef WITHOUT_PROCESSING_BLOCK
#include "Context.h"
#include "ProcessingBlock.h"
#endif

namespace pbio
{

class FacerecService : ComplexObject
{
public:

    typedef LightSmartPtr<FacerecService>::tPtr Ptr;

    typedef pbio::Config Config;

    struct License
    {
        const std::string license_body;

        License(std::string license_body) : license_body(license_body) { }
    };

    struct LicenseState
    {
        struct CounterState
        {
            std::string name;

            int64_t max_value;

            int64_t value;
        };

        bool online;


        std::string android_app_id;

        std::string android_serial;

        std::string ios_app_id;

        std::string hardware_reg;

        std::vector<CounterState> counters;
    };

    static FacerecService::Ptr createService(
        const std::string dll_path,
        std::string facerec_conf_dir,
        const std::string license_dir = std::string());

    static FacerecService::Ptr createService(
        const std::string dll_path,
        std::string facerec_conf_dir,
        const pbio::FacerecService::License license);


    // internal usage only
    static FacerecService::Ptr createService(
        void* const ae_ptr,
        const std::string dll_path,
        std::string facerec_conf_dir,
        const std::string license,
        const bool is_license_dir);



    std::string getVersion() const;

    void forceOnlineLicenseUpdate() const;

    Capturer::Ptr createCapturer(const pbio::FacerecService::Config config) const;

    AgeGenderEstimator::Ptr createAgeGenderEstimator(const std::string ini_file) const;

    QualityEstimator::Ptr createQualityEstimator(const std::string ini_file) const;

    FaceQualityEstimator::Ptr createFaceQualityEstimator(const std::string ini_file) const;

    LivenessEstimator::Ptr createLivenessEstimator() const;

    EmotionsEstimator::Ptr createEmotionsEstimator(const std::string ini_file) const;

    Recognizer::Ptr createRecognizer(
        const char* ini_file,
        const bool processing = true,
        const bool matching = true,
        const bool processing_less_memory_consumption = false) const;


#ifndef WITHOUT_PROCESSING_BLOCK
    DynamicTemplateIndex::Ptr createDynamicTemplateIndex(
        const std::vector<pbio::ContextTemplate::Ptr>& templates,
        const std::vector<std::string>& uuids,
        const Context& config) const;

    DynamicTemplateIndex::Ptr createDynamicTemplateIndex(const Context& config) const;

    ContextTemplate::Ptr loadContextTemplate(std::istream& stream) const;

    ContextTemplate::Ptr loadContextTemplate(pbio::stl_wraps::WrapIStream &stream) const;

    ContextTemplate::Ptr convertTemplate(const pbio::Context& templateContext) const;
#endif

    Recognizer::Ptr createRecognizer(
        const pbio::FacerecService::Config recognizer_config,
        const bool processing = true,
        const bool matching = true,
        const bool processing_less_memory_consumption = false) const;

    VideoWorker::Ptr createVideoWorker(
        const pbio::VideoWorker::Params params) const;


    VideoWorker::Ptr createVideoWorker(
        const pbio::FacerecService::Config video_worker_config,
        const char* recognizer_ini_file,
        const int streams_count,
        const int processing_threads_count,
        const int matching_threads_count) const;


    VideoWorker::Ptr createVideoWorker(
        const pbio::FacerecService::Config video_worker_config,
        const pbio::FacerecService::Config recognizer_config,
        const int streams_count,
        const int processing_threads_count,
        const int matching_threads_count) const;



    RawSample::Ptr loadRawSample(std::istream &binary_stream) const;

    RawSample::Ptr loadRawSample(pbio::stl_wraps::WrapIStream &binary_stream) const;


    RawSample::Ptr loadRawSampleWithoutImage(
        pbio::stl_wraps::WrapIStream &binary_stream,
        const RawImage image,
        const double space_translation_x = 0,
        const double space_translation_y = 0,
        const double space_scale = 1) const;

    RawSample::Ptr loadRawSampleWithoutImage(
        std::istream &binary_stream,
        const RawImage image,
        const double space_translation_x = 0,
        const double space_translation_y = 0,
        const double space_scale = 1) const;

    RawSample::Ptr loadRawSampleWithoutImage(
        pbio::stl_wraps::WrapIStream &binary_stream,
        const unsigned char *image_data,
        int image_data_size,
        const double space_translation_x = 0,
        const double space_translation_y = 0,
        const double space_scale = 1) const;

    RawSample::Ptr loadRawSampleWithoutImage(
        std::istream &binary_stream,
        const unsigned char *image_data,
        int image_data_size,
        const double space_translation_x = 0,
        const double space_translation_y = 0,
        const double space_scale = 1) const;


    CameraCalibrator::Ptr createCameraCalibrator() const;


    DepthLivenessEstimator::Ptr createDepthLivenessEstimator(
        const std::string ini_file) const;


    DepthLivenessEstimator::Ptr createDepthLivenessEstimator(
        const pbio::FacerecService::Config config) const;


    IRLivenessEstimator::Ptr createIRLivenessEstimator(
        const std::string ini_file) const;


    IRLivenessEstimator::Ptr createIRLivenessEstimator(
        const pbio::FacerecService::Config config) const;


    Liveness2DEstimator::Ptr createLiveness2DEstimator(
        const std::string ini_file) const;


    Liveness2DEstimator::Ptr createLiveness2DEstimator(
        const pbio::FacerecService::Config config) const;

    FaceAttributesEstimator::Ptr createFaceAttributesEstimator(
        const std::string ini_file) const;


    ProcessingUnit::Ptr createProcessingUnit(
        const int block_type,
        const char* serializedConfig) const;

#ifndef WITHOUT_PROCESSING_BLOCK

    Context createContext() const;

    Context createContextFromEncodedImage(const uint8_t* data, uint64_t dataSize) const;

    Context createContextFromEncodedImage(const std::vector<uint8_t>& data) const;

    Context createContextFromEncodedImage(const std::string& data) const;

    Context createContextFromEncodedImage(const std::vector<char>& data) const;

    Context createContextFromFrame(uint8_t* data, int32_t width, int32_t height, Context::Format format = Context::Format::FORMAT_BGR, int32_t baseAngle = 0) const;

    Context createContextFromJsonFile(const char* path);

    Context createContextFromJsonFile(std::string path);

    ProcessingBlock createProcessingBlock(const Context& config) const;
#endif


    LicenseState getLicenseState() const;


    void keepAlgorithmsCache() const;

    void freeAlgorithmsCache() const;


    InternalImageBuffer::Ptr createInternalImageBuffer(
        const int width,
        const int height,
        const RawImage::Format format);


#ifdef ANDROID

    InternalImageBuffer::Ptr createInternalImageBuffer(
        JNIEnv *env,
        jobject android_media_image);
#endif  // ifdef ANDROID


    void convertYUV2ARGB(
        const RawImage image,
        const bool downscale_x2,
        void* const result_buffer);


    void convertYUV2RGB(
        const RawImage image,
        const bool downscale_x2,
        const int base_angle,
        void* const result_buffer);


    void convertBGRA88882RGB(
        const RawImage image,
        const bool downscale_x2,
        const int base_angle,
        void* const result_buffer);


private:

    const std::string _facerec_conf_dir;

    friend class object_with_ref_counter<FacerecService>;
protected:
    FacerecService(
        const DHPtr &dll_handle,
        const std::string &facerec_conf_dir,
        void* impl);
};

}  // pbio namespace






namespace pbio
{


// static
inline
FacerecService::Ptr FacerecService::createService(
    const std::string dll_path,
    std::string facerec_conf_dir,
    const std::string license_dir)
{
    return createService(NULL, dll_path, facerec_conf_dir, license_dir, true);
}

// static
inline
FacerecService::Ptr FacerecService::createService(
    const std::string dll_path,
    std::string facerec_conf_dir,
    const pbio::FacerecService::License license)
{
    return createService(NULL, dll_path, facerec_conf_dir, license.license_body, false);
}

// static
inline
FacerecService::Ptr FacerecService::createService(
    void* const ae_ptr,
    const std::string dll_path,
    std::string facerec_conf_dir,
    const std::string license,
    const bool is_license_dir)
{

#ifdef __STATIC_LIBFACEREC_BUILD__
    (void) dll_path;

    const DHPtr dll_handle( DHPtr::make() );
#else
    const DHPtr dll_handle( DHPtr::make(dll_path.c_str()) );
#endif

    if(facerec_conf_dir.empty())
    {
        facerec_conf_dir = "./";
    }
    else if(facerec_conf_dir[facerec_conf_dir.length() - 1] != '/')
    {
        facerec_conf_dir += '/';
    }

    void* exception = NULL;

    void* the_impl;

    if (is_license_dir)
    {
        the_impl = dll_handle->FacerecService_constructor3(
            ae_ptr,
            facerec_conf_dir.c_str(),
            license.empty() ?
                NULL :
                license.c_str(),
            dll_path.c_str(),
            &exception);
    }else
    {
        the_impl = dll_handle->FacerecService_constructor5(
            ae_ptr,
            facerec_conf_dir.c_str(),
            license.c_str(),
            dll_path.c_str(),
            &exception);
    }

    checkException(exception, *dll_handle);

    return FacerecService::Ptr::make(
        dll_handle,
        facerec_conf_dir,
        the_impl);
}


inline
FacerecService::FacerecService(
    const DHPtr &dll_handle,
    const std::string &facerec_conf_dir,
    void* impl):
ComplexObject(dll_handle, impl),
_facerec_conf_dir(facerec_conf_dir)
{
    std::string lib_version = getVersion();

    if (LIBFACEREC_VERSION != lib_version)
        std::cerr << "WARNING: The version in the header does not match the version in the library. Header version: "
            << LIBFACEREC_VERSION << ", library version: " << lib_version << std::endl;
}


inline
std::string FacerecService::getVersion() const
{
    std::ostringstream version_stream;
    pbio::stl_wraps::WrapOStreamImpl version_stream_wrap(version_stream);

    void* exception = NULL;

    _dll_handle->get_version(
        &version_stream_wrap,
        pbio::stl_wraps::WrapOStream::write_func,
        &exception);

    checkException(exception, *_dll_handle);

    return version_stream.str();
}


inline
void FacerecService::forceOnlineLicenseUpdate() const
{
    void* exception = NULL;

    _dll_handle->FacerecService_forceOnlineLicenseUpdate(
        _impl,
        &exception);

    checkException(exception, *_dll_handle);
}

inline
Capturer::Ptr FacerecService::createCapturer(
    const pbio::FacerecService::Config config) const
{
    const std::string file_path = _facerec_conf_dir + config.config_filepath;

    std::vector<char const*> overridden_keys;
    std::vector<double> overridden_values;

    config.prepare(overridden_keys, overridden_values);

    void* exception = NULL;

    pbio::facerec::CapturerImpl* const capturer_impl =
        _dll_handle->FacerecService_createCapturerE(
            _impl,
            file_path.c_str(),
            overridden_keys.size(),
            overridden_keys.empty() ? NULL : &(overridden_keys[0]),
            overridden_values.empty() ? NULL : &(overridden_values[0]),
            &exception);

    checkException(exception, *_dll_handle);

    return Capturer::Ptr::make(_dll_handle, capturer_impl);
}

inline
AgeGenderEstimator::Ptr FacerecService::createAgeGenderEstimator(const std::string ini_file) const
{
    const std::string file_path = _facerec_conf_dir + ini_file;

    void* exception = NULL;

    pbio::facerec::AgeGenderEstimatorImpl* const the_impl =
        _dll_handle->FacerecService_createAgeGenderEstimator(
            _impl,
            file_path.c_str(),
            &exception);

    checkException(exception, *_dll_handle);

    return AgeGenderEstimator::Ptr::make(_dll_handle, the_impl);
}


inline
QualityEstimator::Ptr FacerecService::createQualityEstimator(const std::string ini_file) const
{
    const std::string file_path = _facerec_conf_dir + ini_file;

    void* exception = NULL;

    pbio::facerec::QualityEstimatorImpl* const the_impl =
        _dll_handle->FacerecService_createQualityEstimator(
            _impl,
            file_path.c_str(),
            &exception);

    checkException(exception, *_dll_handle);

    return QualityEstimator::Ptr::make(_dll_handle, the_impl);
}


inline
FaceQualityEstimator::Ptr FacerecService::createFaceQualityEstimator(const std::string ini_file) const
{
    const std::string file_path = _facerec_conf_dir + ini_file;

    void* exception = NULL;

    pbio::facerec::FaceQualityEstimatorImpl* const the_impl =
        _dll_handle->FacerecService_createFaceQualityEstimator(
            _impl,
            file_path.c_str(),
            &exception);

    checkException(exception, *_dll_handle);

    return FaceQualityEstimator::Ptr::make(_dll_handle, the_impl);
}

inline
LivenessEstimator::Ptr FacerecService::createLivenessEstimator() const
{
    void* exception = NULL;

    pbio::facerec::LivenessEstimatorImpl* const the_impl =
        _dll_handle->FacerecService_createLivenessEstimator(
            _impl,
            &exception);

    checkException(exception, *_dll_handle);

    return LivenessEstimator::Ptr::make(_dll_handle, the_impl);
}


inline
EmotionsEstimator::Ptr FacerecService::createEmotionsEstimator(
    const std::string ini_file) const
{
    const std::string file_path = _facerec_conf_dir + ini_file;

    void* exception = NULL;

    pbio::facerec::EmotionsEstimatorImpl* const the_impl =
        _dll_handle->FacerecService_createEmotionsEstimator(
            _impl,
            file_path.c_str(),
            &exception);

    checkException(exception, *_dll_handle);

    return EmotionsEstimator::Ptr::make(_dll_handle, the_impl);
}


inline
Recognizer::Ptr FacerecService::createRecognizer(
    const char* ini_file,
    const bool processing,
    const bool matching,
    const bool processing_less_memory_consumption) const
{
    const std::string file_path = _facerec_conf_dir + ini_file;

    void* exception = NULL;

    pbio::facerec::RecognizerImpl* const recognizer_impl =
        _dll_handle->FacerecService_createRecognizer2(
            _impl,
            file_path.c_str(),
            0,
            NULL,
            NULL,
            (int) processing,
            (int) matching,
            (int) processing_less_memory_consumption,
            &exception);

    checkException(exception, *_dll_handle);

    return Recognizer::Ptr::make(_dll_handle, recognizer_impl);
}

#ifndef WITHOUT_PROCESSING_BLOCK
inline DynamicTemplateIndex::Ptr FacerecService::createDynamicTemplateIndex(
    const std::vector<pbio::ContextTemplate::Ptr>& templates,
    const std::vector<std::string>& uuids,
    const Context& config
) const
{
    void* exception = nullptr;

    std::vector<const void*> tempTemplates;
    std::vector<const char*> tempUuids;

    tempTemplates.reserve(templates.size());
    tempUuids.reserve(uuids.size());

    std::transform
    (
        templates.begin(), templates.end(), std::back_inserter(tempTemplates),
        [](pbio::ContextTemplate::Ptr templ) { return templ->_impl; }
    );
    std::transform(uuids.begin(), uuids.end(), std::back_inserter(tempUuids), [](const std::string& uuid) { return uuid.data(); });

    void* indexImplementation = _dll_handle->FacerecService_createDynamicTemplateIndex_1
    (
        _impl,
        tempTemplates.data(),
        tempUuids.data(),
        templates.size(),
        config.getHandle(),
        &exception
    );

    checkException(exception, *_dll_handle);

    return DynamicTemplateIndex::Ptr::make(_dll_handle, indexImplementation);
}

inline DynamicTemplateIndex::Ptr FacerecService::createDynamicTemplateIndex(const Context& config) const
{
    void* exception = nullptr;

    void* indexImplementation = _dll_handle->FacerecService_createDynamicTemplateIndex_2(_impl, config.getHandle(), &exception);

    checkException(exception, *_dll_handle);

    return DynamicTemplateIndex::Ptr::make(_dll_handle, indexImplementation);
}

inline ContextTemplate::Ptr FacerecService::loadContextTemplate(std::istream& stream) const
{
    pbio::stl_wraps::WrapIStreamImpl streamWrap(stream);
    return loadContextTemplate(streamWrap);
}

inline ContextTemplate::Ptr FacerecService::loadContextTemplate(pbio::stl_wraps::WrapIStream& stream) const
{
    void* exception = nullptr;
    void* templateImplementation = _dll_handle->ContextTemplate_loadTemplate(&stream, pbio::stl_wraps::WrapIStream::read_func, &exception);

    checkException(exception, *_dll_handle);

    return ContextTemplate::Ptr::make(_dll_handle, templateImplementation);
}

inline ContextTemplate::Ptr FacerecService::convertTemplate(const pbio::Context& templateContext) const
{
    void* exception = nullptr;
    void* templateImplementation = _dll_handle->ContextTemplate_convert(templateContext.handle_, &exception);

    checkException(exception, *_dll_handle);

    return ContextTemplate::Ptr::make(_dll_handle, templateImplementation);
}
#endif

inline
Recognizer::Ptr FacerecService::createRecognizer(
    const pbio::FacerecService::Config recognizer_config,
    const bool processing,
    const bool matching,
    const bool processing_less_memory_consumption) const
{
    const std::string file_path = _facerec_conf_dir + recognizer_config.config_filepath;

    std::vector<char const*> overridden_keys;
    std::vector<double> overridden_values;

    recognizer_config.prepare(overridden_keys, overridden_values);

    void* exception = NULL;

    pbio::facerec::RecognizerImpl* const recognizer_impl =
        _dll_handle->FacerecService_createRecognizer2(
            _impl,
            file_path.c_str(),
            overridden_keys.size(),
            overridden_keys.empty() ? NULL : &(overridden_keys[0]),
            overridden_values.empty() ? NULL : &(overridden_values[0]),
            (int) processing,
            (int) matching,
            (int) processing_less_memory_consumption,
            &exception);

    checkException(exception, *_dll_handle);

    return Recognizer::Ptr::make(_dll_handle, recognizer_impl);
}



inline
VideoWorker::Ptr FacerecService::createVideoWorker(
    const pbio::FacerecService::Config video_worker_ini_file,
    const char* recognizer_ini_file,
    const int streams_count,
    const int processing_threads_count,
    const int matching_threads_count) const
{
    return createVideoWorker(
        VideoWorker::Params()
            .video_worker_config(video_worker_ini_file)
            .recognizer_ini_file(recognizer_ini_file)
            .streams_count(streams_count)
            .processing_threads_count(processing_threads_count)
            .matching_threads_count(matching_threads_count)
        );
}

inline
VideoWorker::Ptr FacerecService::createVideoWorker(
    const pbio::FacerecService::Config video_worker_ini_file,
    const pbio::FacerecService::Config recognizer_config,
    const int streams_count,
    const int processing_threads_count,
    const int matching_threads_count) const
{
    return createVideoWorker(
        VideoWorker::Params()
            .video_worker_config(video_worker_ini_file)
            .recognizer_config(recognizer_config)
            .streams_count(streams_count)
            .processing_threads_count(processing_threads_count)
            .matching_threads_count(matching_threads_count)
        );
}

inline
VideoWorker::Ptr FacerecService::createVideoWorker(
    const VideoWorker::Params params) const
{
    std::vector<char const*> vw_overridden_keys;
    std::vector<double> vw_overridden_values;

    params._video_worker_config.prepare(vw_overridden_keys, vw_overridden_values);
    std::vector<std::string> extra_over_params;

    if(!params._active_liveness_checks_order.empty()){
        bool is_unique = true;
        for (auto it = params._active_liveness_checks_order.begin(); it != params._active_liveness_checks_order.end(); ++it)
            if (std::find(it + 1, params._active_liveness_checks_order.end(), *it) != params._active_liveness_checks_order.end()) {
                is_unique = false;
                break;
            }
        if(!is_unique)
            throw pbio::Error(0x3302330e,
                "Error 0x3302330e: Set a unique order of `active_liveness_checks_order` for Active Liveness.");
        for (size_t i = 0; i < params._active_liveness_checks_order.size(); i++){
            ActiveLiveness::CheckType check = params._active_liveness_checks_order[i];
            std::string check_str = ActiveLiveness::CheckTypeToString(check);
            extra_over_params.push_back("active_liveness.check_" + check_str);
            vw_overridden_keys.push_back(extra_over_params.back().c_str());
            vw_overridden_values.push_back(-(double)(i+1));
        }
    }


    if (!params._recognizer_ini_file.empty() && !params._recognizer_config.config_filepath.empty())
        throw pbio::Error(0xb3fe4d07, "Error: 0xed877a99 You must use either recognizer_config or recognizer_ini_file.");

    pbio::FacerecService::Config recognizer_config =
        params._recognizer_ini_file.empty() ?
            params._recognizer_config :
            pbio::FacerecService::Config(params._recognizer_ini_file);

    std::vector<char const*> rec_overridden_keys;
    std::vector<double> rec_overridden_values;

    recognizer_config.prepare(rec_overridden_keys, rec_overridden_values);

    void* exception = NULL;

    pbio::facerec::VideoWorkerImpl* const vw_impl =
        _dll_handle->FacerecService_createVideoWorker_sti_age_gender_emotions(
            _impl,

            VideoWorker::STrackingCallback,
            VideoWorker::STemplateCreatedCallback,
            VideoWorker::SMatchFoundCallback,
            VideoWorker::STrackingLostCallback,
            VideoWorker::SStiPersonOutdatedCallback,

            (_facerec_conf_dir + params._video_worker_config.config_filepath).c_str(),
            vw_overridden_keys.size(),
            vw_overridden_keys.empty() ? NULL : &(vw_overridden_keys[0]),
            vw_overridden_values.empty() ? NULL : &(vw_overridden_values[0]),

            (_facerec_conf_dir + recognizer_config.config_filepath).c_str(),
            rec_overridden_keys.size(),
            rec_overridden_keys.empty() ? NULL : &(rec_overridden_keys[0]),
            rec_overridden_values.empty() ? NULL : &(rec_overridden_values[0]),

            params._streams_count,
            params._processing_threads_count,
            params._matching_threads_count,
            params._short_time_identification_enabled,
            params._short_time_identification_distance_threshold,
            params._short_time_identification_outdate_time_seconds,
            params._age_gender_estimation_threads_count,
            params._emotions_estimation_threads_count,
            &exception);

    checkException(exception, *_dll_handle);

    return VideoWorker::Ptr::make(_dll_handle, vw_impl);
}


inline
RawSample::Ptr FacerecService::loadRawSample(std::istream &binary_stream) const
{
    pbio::stl_wraps::WrapIStreamImpl binary_stream_wrap(binary_stream);

    return loadRawSample(binary_stream_wrap);
}

inline
RawSample::Ptr FacerecService::loadRawSample(pbio::stl_wraps::WrapIStream &binary_stream) const
{
    void* exception = NULL;

    pbio::facerec::RawSampleImpl* const raw_sampl_impl =
        _dll_handle->FacerecService_loadRawSample(
            _impl,
            &binary_stream,
            pbio::stl_wraps::WrapIStream::read_func,
            &exception);

    checkException(exception, *_dll_handle);

    return RawSample::Ptr::make(_dll_handle, raw_sampl_impl);
}

inline
RawSample::Ptr FacerecService::loadRawSampleWithoutImage(
        pbio::stl_wraps::WrapIStream &binary_stream,
        const RawImage image,
        const double space_translation_x,
        const double space_translation_y,
        const double space_scale) const
{
    void* exception = NULL;

    const RawImage::CapiData cdata = image.makeCapiData();

    pbio::facerec::RawSampleImpl* const raw_sampl_impl =
        _dll_handle->FacerecService_loadRawSampleWithoutImage_raw_image(
            _impl,
            &binary_stream,
            pbio::stl_wraps::WrapIStream::read_func,

            cdata.data,
            cdata.width,
            cdata.height,
            cdata.format,
            cdata.with_crop,
            cdata.crop_info_offset_x,
            cdata.crop_info_offset_y,
            cdata.crop_info_data_image_width,
            cdata.crop_info_data_image_height,

            space_translation_x,
            space_translation_y,
            space_scale,

            &exception);

    checkException(exception, *_dll_handle);

    return RawSample::Ptr::make(_dll_handle, raw_sampl_impl);
}

inline
RawSample::Ptr FacerecService::loadRawSampleWithoutImage(
        std::istream &binary_stream,
        const RawImage image,
        const double space_translation_x,
        const double space_translation_y,
        const double space_scale) const
{
    pbio::stl_wraps::WrapIStreamImpl binary_stream_wrap(binary_stream);

    return loadRawSampleWithoutImage(
        binary_stream_wrap,
        image,
        space_translation_x,
        space_translation_y,
        space_scale);
}

inline
RawSample::Ptr FacerecService::loadRawSampleWithoutImage(
        pbio::stl_wraps::WrapIStream &binary_stream,
        const unsigned char *image_data,
        int image_data_size,
        const double space_translation_x,
        const double space_translation_y,
        const double space_scale) const
{
    void* exception = NULL;

    pbio::facerec::RawSampleImpl* const raw_sampl_impl =
        _dll_handle->FacerecService_loadRawSampleWithoutImage_encoded_image(
            _impl,
            &binary_stream,
            pbio::stl_wraps::WrapIStream::read_func,

            image_data,
            image_data_size,

            space_translation_x,
            space_translation_y,
            space_scale,

            &exception);

    checkException(exception, *_dll_handle);

    return RawSample::Ptr::make(_dll_handle, raw_sampl_impl);
}

inline
RawSample::Ptr FacerecService::loadRawSampleWithoutImage(
        std::istream &binary_stream,
        const unsigned char *image_data,
        int image_data_size,
        const double space_translation_x,
        const double space_translation_y,
        const double space_scale) const
{
    pbio::stl_wraps::WrapIStreamImpl binary_stream_wrap(binary_stream);


    return loadRawSampleWithoutImage(
        binary_stream_wrap,
        image_data,
        image_data_size,
        space_translation_x,
        space_translation_y,
        space_scale);
}


inline
CameraCalibrator::Ptr FacerecService::createCameraCalibrator() const
{
    void* exception = NULL;

    pbio::facerec::CameraCalibratorImpl* const calibrator_impl =
        _dll_handle->FacerecService_createCameraCalibrator(
            _impl,
            &exception);

    checkException(exception, *_dll_handle);

    return CameraCalibrator::Ptr::make(_dll_handle, calibrator_impl);
}



inline
DepthLivenessEstimator::Ptr FacerecService::createDepthLivenessEstimator(
    const std::string ini_file) const
{
    const std::string file_path = _facerec_conf_dir + ini_file;

    void* exception = NULL;

    pbio::facerec::DepthLivenessEstimatorImpl* const the_impl =
        _dll_handle->FacerecService_createDepthLivenessEstimatorE(
            _impl,
            file_path.c_str(),
            0,     // overridden keys size
            NULL,  // overridden keys
            NULL,  // overriden values
            &exception);

    checkException(exception, *_dll_handle);

    return DepthLivenessEstimator::Ptr::make(_dll_handle, the_impl);
}


inline
DepthLivenessEstimator::Ptr FacerecService::createDepthLivenessEstimator(
    const pbio::FacerecService::Config config) const
{
    const std::string file_path = _facerec_conf_dir + config.config_filepath;

    std::vector<char const*> overridden_keys;
    std::vector<double> overridden_values;

    config.prepare(overridden_keys, overridden_values);

    void* exception = NULL;

    pbio::facerec::DepthLivenessEstimatorImpl* const the_impl =
        _dll_handle->FacerecService_createDepthLivenessEstimatorE(
            _impl,
            file_path.c_str(),
            overridden_keys.size(),
            overridden_keys.empty() ? NULL : &(overridden_keys[0]),
            overridden_values.empty() ? NULL : &(overridden_values[0]),
            &exception);

    checkException(exception, *_dll_handle);

    return DepthLivenessEstimator::Ptr::make(_dll_handle, the_impl);
}

inline
IRLivenessEstimator::Ptr FacerecService::createIRLivenessEstimator(
    const std::string ini_file) const
{
    const std::string file_path = _facerec_conf_dir + ini_file;

    void* exception = NULL;

    pbio::facerec::IRLivenessEstimatorImpl* const the_impl =
        _dll_handle->FacerecService_createIRLivenessEstimatorE(
            _impl,
            file_path.c_str(),
            0,     // overridden keys size
            NULL,  // overridden keys
            NULL,  // overriden values
            &exception);

    checkException(exception, *_dll_handle);

    return IRLivenessEstimator::Ptr::make(_dll_handle, the_impl);
}

inline
IRLivenessEstimator::Ptr FacerecService::createIRLivenessEstimator(
    const pbio::FacerecService::Config config) const
{
    const std::string file_path = _facerec_conf_dir + config.config_filepath;

    std::vector<char const*> overridden_keys;
    std::vector<double> overridden_values;

    config.prepare(overridden_keys, overridden_values);

    void* exception = NULL;

    pbio::facerec::IRLivenessEstimatorImpl* const the_impl =
        _dll_handle->FacerecService_createIRLivenessEstimatorE(
            _impl,
            file_path.c_str(),
            overridden_keys.size(),
            overridden_keys.empty() ? NULL : &(overridden_keys[0]),
            overridden_values.empty() ? NULL : &(overridden_values[0]),
            &exception);

    checkException(exception, *_dll_handle);

    return IRLivenessEstimator::Ptr::make(_dll_handle, the_impl);
}

inline
Liveness2DEstimator::Ptr FacerecService::createLiveness2DEstimator(
    const std::string ini_file) const
{
    const std::string file_path = _facerec_conf_dir + ini_file;

    void* exception = NULL;

    pbio::facerec::Liveness2DEstimatorImpl* const the_impl =
        _dll_handle->FacerecService_createLiveness2DEstimatorE(
            _impl,
            file_path.c_str(),
            0,     // overridden keys size
            NULL,  // overridden keys
            NULL,  // overriden values
            &exception);

    checkException(exception, *_dll_handle);

    return Liveness2DEstimator::Ptr::make(_dll_handle, the_impl);
}

inline
Liveness2DEstimator::Ptr FacerecService::createLiveness2DEstimator(
    const pbio::FacerecService::Config config) const
{
    const std::string file_path = _facerec_conf_dir + config.config_filepath;

    std::vector<char const*> overridden_keys;
    std::vector<double> overridden_values;

    config.prepare(overridden_keys, overridden_values);

    void* exception = NULL;

    pbio::facerec::Liveness2DEstimatorImpl* const the_impl =
        _dll_handle->FacerecService_createLiveness2DEstimatorE(
            _impl,
            file_path.c_str(),
            overridden_keys.size(),
            overridden_keys.empty() ? NULL : &(overridden_keys[0]),
            overridden_values.empty() ? NULL : &(overridden_values[0]),
            &exception);

    checkException(exception, *_dll_handle);

    return Liveness2DEstimator::Ptr::make(_dll_handle, the_impl);
}

inline
FaceAttributesEstimator::Ptr FacerecService::createFaceAttributesEstimator(
    const std::string ini_file) const
{
    const std::string file_path = _facerec_conf_dir + ini_file;

    void* exception = NULL;

    pbio::facerec::FaceAttributesEstimatorImpl* const the_impl =
        _dll_handle->FacerecService_createFaceAttributesEstimator(
            _impl,
            file_path.c_str(),
            0,     // overridden keys size
            NULL,  // overridden keys
            NULL,  // overriden values
            &exception);

    checkException(exception, *_dll_handle);

    return FaceAttributesEstimator::Ptr::make(_dll_handle, the_impl);
}


inline
ProcessingUnit::Ptr FacerecService::createProcessingUnit(
    const int block_type,
    const char* serializedConfig) const
{
    return ProcessingUnit::Ptr::make(_dll_handle, block_type, serializedConfig);
}

#ifndef WITHOUT_PROCESSING_BLOCK
inline Context FacerecService::createContext() const
{
    return Context(_dll_handle);
}

inline Context FacerecService::createContextFromEncodedImage(const uint8_t* data, uint64_t dataSize) const
{
    return Context(_dll_handle, data, dataSize);
}

inline Context FacerecService::createContextFromEncodedImage(const std::vector<uint8_t>& data) const
{
    return Context(_dll_handle, data.data(), data.size());
}

inline Context FacerecService::createContextFromEncodedImage(const std::string& data) const
{
    return Context(_dll_handle, reinterpret_cast<const uint8_t*>(data.data()), data.size());
}

inline Context FacerecService::createContextFromEncodedImage(const std::vector<char>& data) const
{
    return Context(_dll_handle, reinterpret_cast<const uint8_t*>(data.data()), data.size());
}

inline Context FacerecService::createContextFromFrame(uint8_t* data, int32_t width, int32_t height, Context::Format format, int32_t baseAngle) const
{
    return Context(_dll_handle, data, width, height, format, baseAngle);
}

inline Context FacerecService::createContextFromJsonFile(const char* path)
{
    return Context(_dll_handle, path);
}

inline Context FacerecService::createContextFromJsonFile(std::string path)
{
    return Context(_dll_handle, path.c_str());
}

inline ProcessingBlock FacerecService::createProcessingBlock(const Context& config) const
{
    return ProcessingBlock(_impl, _dll_handle, config);
}
#endif


inline
FacerecService::LicenseState FacerecService::getLicenseState() const
{
    void* exception = NULL;

    void* struct_storage_impl = _dll_handle->FacerecService_getLicenseState(_impl, &exception);

    checkException(exception, *_dll_handle);

    const StructStorage struct_storage(_dll_handle, struct_storage_impl);

    LicenseState result;

    result.online = struct_storage.get_int64(StructStorageFields::license_state_online_t);

    result.android_app_id = (char const*) struct_storage.get_pointer(StructStorageFields::license_state_android_app_id_t);
    result.android_serial = (char const*) struct_storage.get_pointer(StructStorageFields::license_state_android_serial_t);
    result.ios_app_id     = (char const*) struct_storage.get_pointer(StructStorageFields::license_state_ios_app_id_t);
    result.hardware_reg   = (char const*) struct_storage.get_pointer(StructStorageFields::license_state_hardware_reg_t);

    result.counters.resize( struct_storage.get_int64(
        StructStorageFields::license_state_licenses_count_t) );

    for(size_t i = 0; i < result.counters.size(); ++i)
    {
        result.counters[i].name = (char const*) struct_storage.get_pointer(
            (i << 16) | size_t(StructStorageFields::license_state_licenses_names_int16_t) );

        result.counters[i].max_value = struct_storage.get_int64(
            (i << 16) | size_t(StructStorageFields::license_state_licenses_total_counts_int16_t) );

        result.counters[i].value = struct_storage.get_int64(
            (i << 16) | size_t(StructStorageFields::license_state_licenses_in_use_counts_int16_t) );
    }

    return result;
}


inline
void FacerecService::keepAlgorithmsCache() const
{
    void* exception = NULL;

    _dll_handle->FacerecService_toggleAlgorithmsCacheKepp(1, &exception);

    checkException(exception, *_dll_handle);
}

inline
void FacerecService::freeAlgorithmsCache() const
{
    void* exception = NULL;

    _dll_handle->FacerecService_toggleAlgorithmsCacheKepp(0, &exception);

    checkException(exception, *_dll_handle);
}



inline
InternalImageBuffer::Ptr FacerecService::createInternalImageBuffer(
    const int width,
    const int height,
    const RawImage::Format format)
{
    void* exception = NULL;

    int32_t data_size;
    void* data_ptr;
    void* imagetptr_ptr;

    void* const the_impl = _dll_handle->InternalImageBuffer_constructor(
        width,
        height,
        format,
        &data_size,
        &data_ptr,
        &imagetptr_ptr,
        &exception);

    checkException(exception, *_dll_handle);

    return InternalImageBuffer::Ptr::make(
        _dll_handle,
        the_impl,
        (unsigned char*) data_ptr,
        data_size,
        width,
        height,
        format,
        imagetptr_ptr);
}


#ifdef ANDROID
inline
InternalImageBuffer::Ptr FacerecService::createInternalImageBuffer(
    JNIEnv *env,
    jobject android_media_image)
{
    void* exception = NULL;

    int32_t width;
    int32_t height;
    int32_t format;
    int32_t data_size;
    void* data_ptr;
    void* imagetptr_ptr;

    void* const the_impl = _dll_handle->InternalImageBuffer_constructor_from_android_image(
        env,
        android_media_image,
        &width,
        &height,
        &format,
        &data_size,
        &data_ptr,
        &imagetptr_ptr,
        &exception);

    checkException(exception, *_dll_handle);

    return InternalImageBuffer::Ptr::make(
        _dll_handle,
        the_impl,
        (unsigned char*) data_ptr,
        data_size,
        width,
        height,
        (InternalImageBuffer::Format) format,
        imagetptr_ptr);
}
#endif

inline
void FacerecService::convertYUV2ARGB(
    const RawImage image,
    const bool downscale_x2,
    void* const result_buffer)
{
    void* exception = NULL;

    const RawImage::CapiData cdata = image.makeCapiData();

    _dll_handle->RawImage_convertYUV2ARGB(
        cdata.data,
        cdata.width,
        cdata.height,
        cdata.format,
        cdata.with_crop,
        cdata.crop_info_offset_x,
        cdata.crop_info_offset_y,
        cdata.crop_info_data_image_width,
        cdata.crop_info_data_image_height,
        downscale_x2,
        result_buffer,
        &exception);

    checkException(exception, *_dll_handle);
}

inline
void FacerecService::convertYUV2RGB(
    const RawImage image,
    const bool downscale_x2,
    const int base_angle,
    void* const result_buffer)
{
    void* exception = NULL;

    const RawImage::CapiData cdata = image.makeCapiData();

    _dll_handle->RawImage_convertYUV2RGB(
        cdata.data,
        cdata.width,
        cdata.height,
        cdata.format,
        cdata.with_crop,
        cdata.crop_info_offset_x,
        cdata.crop_info_offset_y,
        cdata.crop_info_data_image_width,
        cdata.crop_info_data_image_height,
        downscale_x2,
        base_angle,
        result_buffer,
        &exception);

    checkException(exception, *_dll_handle);
}

inline
void FacerecService::convertBGRA88882RGB(
        const RawImage image,
        const bool downscale_x2,
        const int base_angle,
        void* const result_buffer)
{
    void* exception = NULL;

    const RawImage::CapiData cdata = image.makeCapiData();

    _dll_handle->RawImage_convertYUV2RGB(
        cdata.data,
        cdata.width,
        cdata.height,
        cdata.format,
        cdata.with_crop,
        cdata.crop_info_offset_x,
        cdata.crop_info_offset_y,
        cdata.crop_info_data_image_width,
        cdata.crop_info_data_image_height,
        downscale_x2,
        base_angle,
        result_buffer,
        &exception);

    checkException(exception, *_dll_handle);
}

}  // pbio namespace





#endif  // __PBIO_API__PBIO__FACEREC_SERVICE_H_