VideoWorker.h

#ifndef __PBIO_API__PBIO__VIDEOWORKER_H_
#define __PBIO_API__PBIO__VIDEOWORKER_H_


#include <iostream>
#include <istream>
#include <sstream>
#include <vector>
#include <stdexcept>



#include "ComplexObject.h"
#include "deprecated_macro.h"
#include "Error.h"
#include "ExceptionCheck.h"
#include "RawSample.h"
#include "Recognizer.h"
#include "SmartPtr.h"
#include "stl_wraps_impls/WrapIStreamBufferImpl.h"
#include "stl_wraps_impls/WrapIStreamImpl.h"
#include "stl_wraps_impls/WrapOStreamImpl.h"
#include "AgeGenderEstimator.h"
#include "EmotionsEstimator.h"
#include "Template.h"
#include "DepthLivenessEstimator.h"
#include "DepthMapRaw.h"
#include "IRLivenessEstimator.h"
#include "IRFrameRaw.h"
#include "StructStorageFields.h"
#include "SampleCheckStatus.h"
#include "Config.h"
#include "ActiveLiveness.h"
#include "util693bcd72/util.h"

namespace pbio
{

class FacerecService;

class VideoWorker : public ComplexObject
{
public:

    typedef LightSmartPtr<VideoWorker>::tPtr Ptr;

    static const uint64_t MATCH_NOT_FOUND_ID = (uint64_t) (-1);


    struct Params
    {
        Params();

        def_param_field_693bcd72(Params, pbio::Config                , video_worker_config);

        def_param_field_693bcd72(Params, std::string                 , recognizer_ini_file);

        def_param_field_693bcd72(Params, pbio::Config                , recognizer_config);

        def_param_field_693bcd72(Params, int                         , streams_count);

        def_param_field_693bcd72(Params, int                         , processing_threads_count);

        def_param_field_693bcd72(Params, int                         , matching_threads_count);

        def_param_field_693bcd72(Params, int                         , age_gender_estimation_threads_count);

        def_param_field_693bcd72(Params, int                         , emotions_estimation_threads_count);

        def_param_field_693bcd72(Params, bool                        , short_time_identification_enabled);

        def_param_field_693bcd72(Params, float                       , short_time_identification_distance_threshold);

        def_param_field_693bcd72(Params, float                       , short_time_identification_outdate_time_seconds);

        def_param_field_693bcd72(Params, std::vector<ActiveLiveness::CheckType> , active_liveness_checks_order);

    };


    struct SearchResult
    {
        uint64_t person_id;
        
        uint64_t element_id;

        Recognizer::MatchResult match_result;
    };


    typedef
        void (*TrackingCallbackFunc)(
            const int stream_id,
            const int frame_id,
            const std::vector<RawSample::Ptr> &samples,
            const std::vector<bool> &samples_weak,
            const std::vector<float> &samples_quality,
            void* const userdata);

    struct TrackingCallbackData
    {
        int64_t stream_id;

        int64_t frame_id;

        std::vector<RawSample::Ptr> samples;

        std::vector<int> samples_track_id;

        std::vector<bool> samples_weak;

        std::vector<float> samples_quality;

        std::vector<SampleCheckStatus::Verdict> samples_good_light_and_blur;

        std::vector<SampleCheckStatus::Verdict> samples_good_angles;

        std::vector<SampleCheckStatus::Verdict> samples_good_face_size;

        std::vector<SampleCheckStatus::Verdict> samples_detector_confirmed;

        std::vector<DepthLivenessEstimator::Liveness> samples_depth_liveness_confirmed;

        std::vector<IRLivenessEstimator::Liveness> samples_ir_liveness_confirmed;

        std::vector<bool> samples_track_age_gender_set;

        std::vector<AgeGenderEstimator::AgeGender> samples_track_age_gender;

        std::vector<bool> samples_track_emotions_set;

        std::vector<EmotionsEstimator::EstimatedEmotionsVector> samples_track_emotions;

        std::vector<ActiveLiveness::ActiveLivenessStatus> samples_active_liveness_status;
    };

    typedef
        void (*TrackingCallbackU)(
            const TrackingCallbackData &data,
            void* const userdata);
    
    PBIO_API_DEPRECATED_744e321c
    typedef 
        void (*TrackingCallbackFuncU)(
            const TrackingCallbackData &data,
            void* const userdata);

    typedef
        void (*TemplateCreatedCallbackFunc)(
            const int stream_id,
            const int frame_id,
            const RawSample::Ptr &sample,
            const float quality,
            const Template::Ptr &templ,
            void* const userdata);

    struct TemplateCreatedCallbackData
    {
        int64_t stream_id;

        int64_t frame_id;

        RawSample::Ptr sample;

        double quality;

        Template::Ptr templ;
    };


    typedef
        void (*TemplateCreatedCallbackU)(
            const TemplateCreatedCallbackData &data,
            void* const userdata);

    PBIO_API_DEPRECATED_744e321c
    typedef
        void (*TemplateCreatedCallbackFuncU)(
            const TemplateCreatedCallbackData &data,
            void* const userdata);

    typedef
        void (*MatchFoundCallbackFunc)(
            const int stream_id,
            const int frame_id,
            const uint64_t person_id,
            const uint64_t element_id,
            const RawSample::Ptr &sample,
            const float quality,
            const Template::Ptr &templ,
            const Recognizer::MatchResult match_result,
            void* const userdata);

    typedef
        void (*MatchFoundCallbackFuncExt)(
            const int stream_id,
            const int frame_id,
            const RawSample::Ptr &sample,
            const float quality,
            const Template::Ptr &templ,
            const std::vector<SearchResult> &search_result,
            void* const userdata);

    struct MatchFoundCallbackData
    {
        int64_t stream_id;

        int64_t frame_id;

        RawSample::Ptr sample;

        double quality;

        Template::Ptr templ;

        std::vector<SearchResult> search_results;
    };

    typedef
        void (*MatchFoundCallbackU)(
            const MatchFoundCallbackData &data,
            void* const userdata);

    PBIO_API_DEPRECATED_744e321c
    typedef
        void (*MatchFoundCallbackFuncU)(
            const MatchFoundCallbackData &data,
            void* const userdata);

    typedef
        void (*TrackingLostCallbackFunc)(
            const int stream_id,
            const int first_frame_id,
            const int last_frame_id,
            const float best_quality,
            const int best_quality_frame_id,
            const RawSample::Ptr &best_quality_sample,
            const Template::Ptr &best_quality_templ,
            void* const userdata);

    struct TrackingLostCallbackData
    {
        int64_t stream_id;

        int64_t first_frame_id;

        int64_t last_frame_id;

        double best_quality;

        int64_t best_quality_frame_id;

        RawSample::Ptr best_quality_sample;

        Template::Ptr best_quality_templ;

        int64_t track_id;

        bool sti_person_id_set;

        int64_t sti_person_id;
    };

    typedef
        void (*TrackingLostCallbackU)(
            const TrackingLostCallbackData &data,
            void* const userdata);

    PBIO_API_DEPRECATED_744e321c
    typedef 
        void (*TrackingLostCallbackFuncU)(
            const TrackingLostCallbackData &data,
            void* const userdata);



    struct StiPersonOutdatedCallbackData
    {
        int64_t stream_id;

        int64_t sti_person_id;
    };



    typedef
        void (*StiPersonOutdatedCallbackU)(
            const StiPersonOutdatedCallbackData &data,
            void* const userdata);



    struct DatabaseElement
    {
        uint64_t element_id;

        uint64_t person_id;

        Template::Ptr face_template;

        float distance_threshold;
    };


    std::string getMethodName() const;


    int getStreamsCount() const;


    int getTrackingConveyorSize(const int stream_id) const;


    void setDatabase(
        const std::vector<DatabaseElement> &elements,
        const Recognizer::SearchAccelerationType
            acceleration = Recognizer::SEARCH_ACCELERATION_1);

    int addVideoFrame(
        const RawImage frame,
        const int stream_id,
        const uint64_t timestamp_microsec = uint64_t(-1));

    void addDepthFrame(
        const DepthMapRaw &depth_frame,
        const int stream_id,
        const uint64_t timestamp_microsec);

    void addIRFrame(
        const IRFrameRaw &ir_frame,
        const int stream_id,
        const uint64_t timestamp_microsec);

    void resetTrackerOnStream(const int stream_id);



    int resetStream(const int stream_id);


    void checkExceptions();

    PBIO_API_DEPRECATED_744e321c
    int addTrackingCallback(
        const TrackingCallbackFunc callback,
        void* const userdata);

    int addTrackingCallbackU(
        const TrackingCallbackU callback,
        void* const userdata);

    PBIO_API_DEPRECATED_744e321c
    int addTemplateCreatedCallback(
        const TemplateCreatedCallbackFunc callback,
        void* const userdata);

    int addTemplateCreatedCallbackU(
        const TemplateCreatedCallbackU callback,
        void* const userdata);

    PBIO_API_DEPRECATED_744e321c
    int addMatchFoundCallback(
        const MatchFoundCallbackFunc callback,
        void* const userdata);


    PBIO_API_DEPRECATED_744e321c
    int addMatchFoundCallbackExt(
        const MatchFoundCallbackFuncExt callback,
        void* const userdata);

    int addMatchFoundCallbackU(
        const MatchFoundCallbackU callback,
        void* const userdata);


    int addStiPersonOutdatedCallbackU(
        const StiPersonOutdatedCallbackU callback,
        void* const userdata);


    PBIO_API_DEPRECATED_744e321c
    int addTrackingLostCallback(
        const TrackingLostCallbackFunc callback,
        void* const userdata);

    int addTrackingLostCallbackU(
        const TrackingLostCallbackU callback,
        void* const userdata);

    void removeTrackingCallback(const int callback_id);


    void removeTemplateCreatedCallback(const int callback_id);


    void removeMatchFoundCallback(const int callback_id);


    void removeStiPersonOutdatedCallback(const int callback_id);

    void removeTrackingLostCallback(const int callback_id);


    void disableProcessingOnStream(const int stream_id);


    void enableProcessingOnStream(const int stream_id);



    void disableAgeGenderEstimationOnStream(const int stream_id);



    void enableAgeGenderEstimationOnStream(const int stream_id);

    void disableEmotionsEstimationOnStream(const int stream_id);



    void enableEmotionsEstimationOnStream(const int stream_id);

    void setParameter(
        const std::string parameter,
        const double value);


// add callbacks for functor objects (lambda, for example)
public:

    template<typename T>
    int addTrackingCallbackU(T* functor)
    {
        return addTrackingCallbackU(
            callCallbackFunctor<T, TrackingCallbackData>,
            (void*)functor);
    }

    template<typename T>
    int addTemplateCreatedCallbackU(T* functor)
    {
        return addTemplateCreatedCallbackU(
            callCallbackFunctor<T, TemplateCreatedCallbackData>,
            (void*)functor);
    }

    template<typename T>
    int addMatchFoundCallbackU(T* functor)
    {
        return addMatchFoundCallbackU(
            callCallbackFunctor<T, MatchFoundCallbackData>,
            (void*)functor);
    }

    template<typename T>
    int addStiPersonOutdatedCallbackU(T* functor)
    {
        return addStiPersonOutdatedCallbackU(
            callCallbackFunctor<T, StiPersonOutdatedCallbackData>,
            (void*)functor);
    }

    template<typename T>
    int addTrackingLostCallbackU(T* functor)
    {
        return addTrackingLostCallbackU(
            callCallbackFunctor<T, TrackingLostCallbackData>,
            (void*)functor);
    }

private:

    template<typename T, typename DT>
    static
    void callCallbackFunctor(
        const DT &data,
        void* const userdata)
    {
        (*reinterpret_cast<T*>(userdata))(data);
    }



    static
    void STrackingCallback(
        void* err_stream,
        void* this_vw,
        void const* callback_data,

        const int32_t callbacks_count,
        void* const* const callbacks_func,
        void* const* const callbacks_userdata,
        const int32_t u_callbacks_count,
        void* const* const u_callbacks_func,
        void* const* const u_callbacks_userdata);

    static
    void STemplateCreatedCallback(
        void* err_stream,
        void* this_vw,
        void const* callback_data,

        const int32_t callbacks_count,
        void* const* const callbacks_func,
        void* const* const callbacks_userdata,
        const int32_t u_callbacks_count,
        void* const* const u_callbacks_func,
        void* const* const u_callbacks_userdata);

    static
    void SMatchFoundCallback(
        void* err_stream,
        void* this_vw,
        void const* callback_data,

        const int32_t callbacks_count,
        void* const* const callbacks_func,
        void* const* const callbacks_userdata,
        const int32_t ext_callbacks_count,
        void* const* const ext_callbacks_func,
        void* const* const ext_callbacks_userdata,
        const int32_t u_callbacks_count,
        void* const* const u_callbacks_func,
        void* const* const u_callbacks_userdata);


    static
    void STrackingLostCallback(
        void* err_stream,
        void* this_vw,
        void const* callback_data,

        const int32_t callbacks_count,
        void* const* const callbacks_func,
        void* const* const callbacks_userdata,
        const int32_t u_callbacks_count,
        void* const* const u_callbacks_func,
        void* const* const u_callbacks_userdata);

    static
    void SStiPersonOutdatedCallback(
        void* err_stream,
        void* this_vw__,
        void const* callback_data,

        const int32_t callbacks_count,
        void* const* const callbacks_func,
        void* const* const callbacks_userdata);


    void toggleSomething(
        const int stream_id,
        const int something);

    VideoWorker(
        const DHPtr &dll_handle,
        void* impl);

    friend class FacerecService;
    friend class object_with_ref_counter<VideoWorker>;
};

}  // pbio namespace




namespace pbio
{



inline
VideoWorker::VideoWorker(
    const DHPtr &dll_handle,
    void* impl):
ComplexObject(dll_handle, impl)
{
    void* exception = NULL;

    _dll_handle->VideoWorker_setThisVW(
        _impl,
        this,
        &exception);

    checkException(exception, *_dll_handle);
}

inline
std::string VideoWorker::getMethodName() const
{
    std::ostringstream name_stream;
    pbio::stl_wraps::WrapOStreamImpl name_stream_wrap(name_stream);

    void* exception = NULL;

    _dll_handle->VideoWorker_getMethodName(
        _impl,
        &name_stream_wrap,
        pbio::stl_wraps::WrapOStream::write_func,
        &exception);

    checkException(exception, *_dll_handle);

    return name_stream.str();
}


inline
int VideoWorker::getStreamsCount() const
{
    void* exception = NULL;

    const int result = _dll_handle->VideoWorker_getStreamsCount(
        _impl,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}


inline
int VideoWorker::getTrackingConveyorSize(const int stream_id) const
{
    void* exception = NULL;

    const int result = _dll_handle->VideoWorker_getTrackingConveyorSize(
        _impl,
        stream_id,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}


inline
void VideoWorker::setDatabase(
    const std::vector<DatabaseElement> &elements,
    const Recognizer::SearchAccelerationType acceleration)
{
    std::vector<uint64_t> element_ids_v(elements.size());
    std::vector<uint64_t> person_ids_v(elements.size());
    std::vector<pbio::facerec::TemplateImpl const*> templates_v(elements.size());
    std::vector<float> thresholds_v(elements.size());

    for(size_t i = 0; i < elements.size(); ++i)
    {
        element_ids_v[i] = elements[i].element_id;
        person_ids_v[i] = elements[i].person_id;
        templates_v[i] = (pbio::facerec::TemplateImpl const*) elements[i].face_template->_impl;
        thresholds_v[i] = elements[i].distance_threshold;
    }

    void* exception = NULL;

    _dll_handle->VideoWorker_setDatabase(
        _impl,
        acceleration,
        elements.size(),
        element_ids_v.data(),
        person_ids_v.data(),
        templates_v.data(),
        thresholds_v.data(),
        &exception);

    checkException(exception, *_dll_handle);
}

inline
int VideoWorker::addVideoFrame(
    const RawImage frame,
    const int stream_id,
    const uint64_t timestamp_microsec)
{
    void* exception = NULL;

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

    const int result = _dll_handle->VideoWorker_addVideoFrameWithTimestamp_with_crop(
        _impl,

        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,

        stream_id,
        timestamp_microsec,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}

inline
void VideoWorker::addDepthFrame(
    const DepthMapRaw &depth_frame,
    const int stream_id,
    const uint64_t timestamp_microsec)
{
    void* exception = NULL;

    _dll_handle->VideoWorker_addDepthFrame(
        _impl,
        depth_frame.depth_map_rows,
        depth_frame.depth_map_cols,
        depth_frame.depth_map_2_image_offset_x,
        depth_frame.depth_map_2_image_offset_y,
        depth_frame.depth_map_2_image_scale_x,
        depth_frame.depth_map_2_image_scale_y,
        depth_frame.horizontal_fov,
        depth_frame.vertical_fov,
        depth_frame.depth_unit_in_millimeters,
        depth_frame.depth_data,
        depth_frame.depth_data_stride_in_bytes,
        stream_id,
        timestamp_microsec,
        &exception);

    checkException(exception, *_dll_handle);
}

inline
void VideoWorker::addIRFrame(
    const IRFrameRaw &ir_frame,
    const int stream_id,
    const uint64_t timestamp_microsec)
{
    void* exception = NULL;

    _dll_handle->VideoWorker_addIRFrame(
        _impl,
        ir_frame.ir_frame_rows,
        ir_frame.ir_frame_cols,
        ir_frame.ir_frame_2_image_offset_x,
        ir_frame.ir_frame_2_image_offset_y,
        ir_frame.ir_frame_2_image_scale_x,
        ir_frame.ir_frame_2_image_scale_y,
        ir_frame.ir_horizontal_fov,
        ir_frame.ir_vertical_fov,
        ir_frame.ir_frame_data,
        ir_frame.ir_data_stride_in_bytes,
        stream_id,
        timestamp_microsec,
        &exception);

    checkException(exception, *_dll_handle);
}

inline
void VideoWorker::resetTrackerOnStream(const int stream_id)
{
    void* exception = NULL;

    _dll_handle->VideoWorker_resetTrackerOnStream(
        _impl,
        stream_id,
        &exception);

    checkException(exception, *_dll_handle);
}


inline
int VideoWorker::resetStream(const int stream_id)
{
    void* exception = NULL;

    const int threshold_track_id = _dll_handle->VideoWorker_resetStream(
        _impl,
        stream_id,
        &exception);

    checkException(exception, *_dll_handle);

    return threshold_track_id;
}


inline
void VideoWorker::checkExceptions()
{
    void* exception = NULL;

    _dll_handle->VideoWorker_checkExceptions(
        _impl,
        &exception);

    checkException(exception, *_dll_handle);
}

inline
int VideoWorker::addTrackingCallback(
    const TrackingCallbackFunc callback,
    void* const userdata)
{
    void* exception = NULL;

    const int result = _dll_handle->VideoWorker_addTrackingCallback(
        _impl,
        reinterpret_cast<void*>(callback),
        userdata,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}

inline
int VideoWorker::addTrackingCallbackU(
    const TrackingCallbackU callback,
    void* const userdata)
{
    void* exception = NULL;

    const int result = _dll_handle->VideoWorker_addTrackingCallbackU(
        _impl,
        reinterpret_cast<void*>(callback),
        userdata,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}



inline
int VideoWorker::addTemplateCreatedCallback(
    const TemplateCreatedCallbackFunc callback,
    void* const userdata)
{
    void* exception = NULL;

    const int result = _dll_handle->VideoWorker_addTemplateCreatedCallback(
        _impl,
        reinterpret_cast<void*>(callback),
        userdata,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}

inline
int VideoWorker::addTemplateCreatedCallbackU(
    const TemplateCreatedCallbackU callback,
    void* const userdata)
{
    void* exception = NULL;

    const int result = _dll_handle->VideoWorker_addTemplateCreatedCallbackU(
        _impl,
        reinterpret_cast<void*>(callback),
        userdata,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}


inline
int VideoWorker::addMatchFoundCallback(
    const MatchFoundCallbackFunc callback,
    void* const userdata)
{
    void* exception = NULL;

    const int result = _dll_handle->VideoWorker_addMatchFoundCallback(
        _impl,
        reinterpret_cast<void*>(callback),
        userdata,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}


inline
int VideoWorker::addMatchFoundCallbackExt(
    const MatchFoundCallbackFuncExt callback,
    void* const userdata)
{
    void* exception = NULL;

    const int result = _dll_handle->VideoWorker_addMatchFoundCallbackExt(
        _impl,
        reinterpret_cast<void*>(callback),
        userdata,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}

inline
int VideoWorker::addMatchFoundCallbackU(
    const MatchFoundCallbackU callback,
    void* const userdata)
{
    void* exception = NULL;

    const int result = _dll_handle->VideoWorker_addMatchFoundCallbackU(
        _impl,
        reinterpret_cast<void*>(callback),
        userdata,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}


inline
int VideoWorker::addTrackingLostCallback(
    const TrackingLostCallbackFunc callback,
    void* const userdata)
{
    void* exception = NULL;

    const int result = _dll_handle->VideoWorker_addTrackingLostCallback(
        _impl,
        reinterpret_cast<void*>(callback),
        userdata,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}

inline
int VideoWorker::addTrackingLostCallbackU(
    const TrackingLostCallbackU callback,
    void* const userdata)
{
    void* exception = NULL;

    const int result = _dll_handle->VideoWorker_addTrackingLostCallbackU(
        _impl,
        reinterpret_cast<void*>(callback),
        userdata,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}

inline
int VideoWorker::addStiPersonOutdatedCallbackU(
    const StiPersonOutdatedCallbackU callback,
    void* const userdata)
{
    void* exception = NULL;

    const int result = _dll_handle->VideoWorker_addStiPersonOutdatedCallbackU(
        _impl,
        reinterpret_cast<void*>(callback),
        userdata,
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}



inline
void VideoWorker::removeTrackingCallback(
    const int callback_id)
{
    void* exception = NULL;

    _dll_handle->VideoWorker_removeTrackingCallback(
        _impl,
        callback_id,
        &exception);

    checkException(exception, *_dll_handle);
}

inline
void VideoWorker::removeTemplateCreatedCallback(
    const int callback_id)
{
    void* exception = NULL;

    _dll_handle->VideoWorker_removeTemplateCreatedCallback(
        _impl,
        callback_id,
        &exception);

    checkException(exception, *_dll_handle);
}

inline
void VideoWorker::removeMatchFoundCallback(
    const int callback_id)
{
    void* exception = NULL;

    _dll_handle->VideoWorker_removeMatchFoundCallback(
        _impl,
        callback_id,
        &exception);

    checkException(exception, *_dll_handle);
}


inline
void VideoWorker::removeStiPersonOutdatedCallback(
    const int callback_id)
{
    void* exception = NULL;

    _dll_handle->VideoWorker_removeStiPersonOutdatedCallback(
        _impl,
        callback_id,
        &exception);

    checkException(exception, *_dll_handle);
}

inline
void VideoWorker::removeTrackingLostCallback(
    const int callback_id)
{
    void* exception = NULL;

    _dll_handle->VideoWorker_removeTrackingLostCallback(
        _impl,
        callback_id,
        &exception);

    checkException(exception, *_dll_handle);
}



#define __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions(name) \
    catch(const std::exception &e) \
    { \
        const std::string error = \
            "VideoWorker " name " catch std::excetion: '" + \
            std::string( e.what() ) + "'."; \
        const VideoWorker &this_vw = *reinterpret_cast<VideoWorker const*>(this_vw__); \
        this_vw._dll_handle->VideoWorker_errStreamWriteFunc(err_stream, error.c_str(), error.length()); \
    } \
    catch(...) \
    { \
        const std::string error = "VideoWorker " name " catch '...'."; \
        const VideoWorker &this_vw = *reinterpret_cast<VideoWorker const*>(this_vw__); \
        this_vw._dll_handle->VideoWorker_errStreamWriteFunc(err_stream, error.c_str(), error.length()); \
    }


// static
inline
void VideoWorker::STrackingCallback(
    void* err_stream,
    void* this_vw__,
    void const* callback_data,

    const int32_t callbacks_count,
    void* const* const callbacks_func,
    void* const* const callbacks_userdata,
    const int32_t u_callbacks_count,
    void* const* const u_callbacks_func,
    void* const* const u_callbacks_userdata)
{
    try
    {
        const VideoWorker &this_vw = *reinterpret_cast<VideoWorker const*>(this_vw__);

        void* exception = NULL;

        const int64_t stream_id = this_vw._dll_handle->StructStorage_get_int64(
            callback_data,
            StructStorageFields::video_worker_stream_id_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);

        const int64_t frame_id = this_vw._dll_handle->StructStorage_get_int64(
            callback_data,
            StructStorageFields::video_worker_frame_id_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);

        const int64_t samples_count = this_vw._dll_handle->StructStorage_get_int64(
            callback_data,
            StructStorageFields::video_worker_samples_count_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);

        pbio::facerec::RawSampleImpl* const* const samples_impls = static_cast<pbio::facerec::RawSampleImpl* const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                StructStorageFields::video_worker_samples_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);

        int32_t const* const weak_samples = static_cast<int32_t const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                pbio::StructStorageFields::video_worker_weak_samples_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);

        float const* const samples_quality = static_cast<float const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                StructStorageFields::video_worker_samples_quality_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);

        int32_t const* const samples_good_light_and_blur = static_cast<int32_t const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                pbio::StructStorageFields::video_worker_good_light_and_blur_samples_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);

        int32_t const* const samples_good_angles = static_cast<int32_t const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                pbio::StructStorageFields::video_worker_good_angles_samples_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);

        int32_t const* const samples_good_face_size = static_cast<int32_t const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                pbio::StructStorageFields::video_worker_good_face_size_samples_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);


        int32_t const* const samples_detector_confirmed = static_cast<int32_t const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                pbio::StructStorageFields::video_worker_detector_confirmed_samples_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);

        int32_t const* const samples_depth_liveness_confirmed = static_cast<int32_t const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                pbio::StructStorageFields::video_worker_depth_liveness_confirmed_samples_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);

        int32_t const* const samples_ir_liveness_confirmed = static_cast<int32_t const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                pbio::StructStorageFields::video_worker_ir_liveness_confirmed_samples_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);


        int32_t const* const samples_track_age_gender_set = static_cast<int32_t const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                pbio::StructStorageFields::video_worker_samples_track_age_gender_set_t,
                &exception));
        checkException(exception, *this_vw._dll_handle);

        int32_t const* const samples_track_gender = static_cast<int32_t const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                pbio::StructStorageFields::video_worker_samples_track_gender_t,
                &exception));
        checkException(exception, *this_vw._dll_handle);

        int32_t const* const samples_track_age = static_cast<int32_t const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                pbio::StructStorageFields::video_worker_samples_track_age_t,
                &exception));
        checkException(exception, *this_vw._dll_handle);

        float const* const samples_track_age_years = static_cast<float const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                pbio::StructStorageFields::video_worker_samples_track_age_years_t,
                &exception));
        checkException(exception, *this_vw._dll_handle);

        int32_t const* const samples_track_emotions_set = static_cast<int32_t const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                pbio::StructStorageFields::video_worker_samples_track_emotions_set_t,
                &exception));
        checkException(exception, *this_vw._dll_handle);

        int32_t const* const samples_track_emotions_count = static_cast<int32_t const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                pbio::StructStorageFields::video_worker_samples_track_emotions_count_t,
                &exception));
        checkException(exception, *this_vw._dll_handle);

        float const* const samples_track_emotions_confidence = static_cast<float const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                pbio::StructStorageFields::video_worker_samples_track_emotions_confidence_t,
                &exception));
        checkException(exception, *this_vw._dll_handle);

        int32_t const* const samples_track_emotions_emotion = static_cast<int32_t const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                pbio::StructStorageFields::video_worker_samples_track_emotions_emotion_t,
                &exception));
        checkException(exception, *this_vw._dll_handle);

        int32_t const* const samples_track_active_liveness_type = static_cast<int32_t const* const>(
                this_vw._dll_handle->StructStorage_get_pointer(
                        callback_data,
                        pbio::StructStorageFields::video_worker_active_liveness_type_samples_t,
                        &exception));
        checkException(exception, *this_vw._dll_handle);

        int32_t const* const samples_track_active_liveness_confirmed = static_cast<int32_t const* const>(
                this_vw._dll_handle->StructStorage_get_pointer(
                        callback_data,
                        pbio::StructStorageFields::video_worker_active_liveness_confirmed_samples_t,
                        &exception));
        checkException(exception, *this_vw._dll_handle);

        float const* const samples_track_active_liveness_progress = static_cast<float const* const>(
                this_vw._dll_handle->StructStorage_get_pointer(
                        callback_data,
                        pbio::StructStorageFields::video_worker_active_liveness_score_samples_t,
                        &exception));
        checkException(exception, *this_vw._dll_handle);


        TrackingCallbackData data;

        data.stream_id = stream_id;
        data.frame_id = frame_id;
        data.samples.resize(samples_count);
        data.samples_track_id.resize(samples_count);
        data.samples_weak.resize(samples_count);
        data.samples_quality.resize(samples_count);
        data.samples_good_light_and_blur.resize(samples_count);
        data.samples_good_angles.resize(samples_count);
        data.samples_good_face_size.resize(samples_count);
        data.samples_detector_confirmed.resize(samples_count);
        data.samples_depth_liveness_confirmed.resize(samples_count);
        data.samples_ir_liveness_confirmed.resize(samples_count);
        data.samples_track_age_gender_set.resize(samples_count);
        data.samples_track_age_gender.resize(samples_count);
        data.samples_track_emotions_set.resize(samples_count);
        data.samples_track_emotions.resize(samples_count);
        data.samples_active_liveness_status.resize(samples_count);

        for(int i = 0, emotions_i = 0; i < samples_count; ++i)
        {
            data.samples[i] = RawSample::Ptr( RawSample::Ptr::make(this_vw._dll_handle, samples_impls[i]) );
            data.samples_track_id[i] = data.samples[i]->getID();

            data.samples_weak[i] = weak_samples[i];
            data.samples_quality[i] = samples_quality[i];

            data.samples_good_light_and_blur[i]      = (SampleCheckStatus::Verdict)samples_good_light_and_blur[i];
            data.samples_good_angles[i]              = (SampleCheckStatus::Verdict)samples_good_angles[i];
            data.samples_good_face_size[i]           = (SampleCheckStatus::Verdict)samples_good_face_size[i];
            data.samples_detector_confirmed[i]       = (SampleCheckStatus::Verdict)samples_detector_confirmed[i];

            data.samples_depth_liveness_confirmed[i] = (DepthLivenessEstimator::Liveness)samples_depth_liveness_confirmed[i];

            data.samples_ir_liveness_confirmed[i]    = (IRLivenessEstimator::Liveness)samples_ir_liveness_confirmed[i];

            data.samples_active_liveness_status[i].check_type     = (ActiveLiveness::CheckType)samples_track_active_liveness_type[i];
            data.samples_active_liveness_status[i].verdict        = (ActiveLiveness::Liveness)samples_track_active_liveness_confirmed[i];
            data.samples_active_liveness_status[i].progress_level = samples_track_active_liveness_progress[i];

            data.samples_track_age_gender_set[i]          = samples_track_age_gender_set[i];

            data.samples_track_age_gender[i].gender       = (AgeGenderEstimator::Gender) samples_track_gender[i];
            data.samples_track_age_gender[i].age          = (AgeGenderEstimator::Age) samples_track_age[i];
            data.samples_track_age_gender[i].age_years    = samples_track_age_years[i];

            data.samples_track_emotions_set[i]            = samples_track_emotions_set[i];

            const int emotions_count = samples_track_emotions_count[i];

            for(int k = 0; k < emotions_count; ++k, ++emotions_i)
            {
                pbio::EmotionsEstimator::EmotionConfidence ec;

                ec.emotion = (EmotionsEstimator::Emotion) samples_track_emotions_emotion[emotions_i];
                ec.confidence = samples_track_emotions_confidence[emotions_i];

                data.samples_track_emotions[i].push_back(ec);
            }
        }


        for(int i = 0; i < u_callbacks_count; ++i)
        {
            try
            {
                const TrackingCallbackU u_callback_function_i =
                    reinterpret_cast<TrackingCallbackU>(u_callbacks_func[i]);

                u_callback_function_i(
                    data,
                    u_callbacks_userdata[i]);
            }
            __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("TrackingCallbackU")
        }


        for(int i = 0; i < callbacks_count; ++i)
        {
            try
            {
                const TrackingCallbackFunc callback_function_i =
                    reinterpret_cast<TrackingCallbackFunc>(callbacks_func[i]);

                callback_function_i(
                    data.stream_id,
                    data.frame_id,
                    data.samples,
                    data.samples_weak,
                    data.samples_quality,
                    callbacks_userdata[i]);
            }
            __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("TrackingCallback")
        }
    }
    __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("TrackingCallback_")
}




// static
inline
void VideoWorker::STemplateCreatedCallback(
    void* err_stream,
    void* this_vw__,
    void const* callback_data,

    const int32_t callbacks_count,
    void* const* const callbacks_func,
    void* const* const callbacks_userdata,
    const int32_t u_callbacks_count,
    void* const* const u_callbacks_func,
    void* const* const u_callbacks_userdata)
{
    try
    {
        const VideoWorker &this_vw = *reinterpret_cast<VideoWorker const*>(this_vw__);

        void* exception = NULL;

        const int64_t stream_id = this_vw._dll_handle->StructStorage_get_int64(
            callback_data,
            StructStorageFields::video_worker_stream_id_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);

        const int64_t frame_id = this_vw._dll_handle->StructStorage_get_int64(
            callback_data,
            StructStorageFields::video_worker_frame_id_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);

        const double quality = this_vw._dll_handle->StructStorage_get_double(
            callback_data,
            StructStorageFields::video_worker_quality_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);

        pbio::facerec::RawSampleImpl* const sample_impl = static_cast<pbio::facerec::RawSampleImpl* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                StructStorageFields::video_worker_samples_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);

        pbio::facerec::TemplateImpl* const templ_impl = static_cast<pbio::facerec::TemplateImpl* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                StructStorageFields::video_worker_templ_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);

        const RawSample::Ptr sample( RawSample::Ptr::make(this_vw._dll_handle, sample_impl));

        const Template::Ptr templ( Template::Ptr::make(this_vw._dll_handle, templ_impl));

        TemplateCreatedCallbackData data;

        data.stream_id = stream_id;
        data.frame_id  = frame_id;
        data.quality   = quality;
        data.sample    = sample;
        data.templ     = templ;




        for(int i = 0; i < u_callbacks_count; ++i)
        {
            try
            {
                const TemplateCreatedCallbackU u_callback_function_i =
                    reinterpret_cast<TemplateCreatedCallbackU>(u_callbacks_func[i]);

                u_callback_function_i(
                    data,
                    u_callbacks_userdata[i]);
            }
            __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("TemplateCreatedCallbackU")
        }



        for(int i = 0; i < callbacks_count; ++i)
        {
            try
            {
                const TemplateCreatedCallbackFunc callback_function_i =
                    reinterpret_cast<TemplateCreatedCallbackFunc>(callbacks_func[i]);

                callback_function_i(
                    data.stream_id,
                    data.frame_id,
                    data.sample,
                    data.quality,
                    data.templ,
                    callbacks_userdata[i]);
            }
            __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("TemplateCreatedCallback")
        }


    }
    __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("TemplateCreatedCallback_")
}





// static
inline
void VideoWorker::SMatchFoundCallback(
    void* err_stream,
    void* this_vw__,
    void const* callback_data,

    const int32_t callbacks_count,
    void* const* const callbacks_func,
    void* const* const callbacks_userdata,
    const int32_t ext_callbacks_count,
    void* const* const ext_callbacks_func,
    void* const* const ext_callbacks_userdata,
    const int32_t u_callbacks_count,
    void* const* const u_callbacks_func,
    void* const* const u_callbacks_userdata)
{
    try
    {
        const VideoWorker &this_vw = *reinterpret_cast<VideoWorker const*>(this_vw__);

        void* exception = NULL;

        const int64_t stream_id = this_vw._dll_handle->StructStorage_get_int64(
            callback_data,
            StructStorageFields::video_worker_stream_id_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);

        const int64_t frame_id = this_vw._dll_handle->StructStorage_get_int64(
            callback_data,
            StructStorageFields::video_worker_frame_id_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);

        const double quality = this_vw._dll_handle->StructStorage_get_double(
            callback_data,
            StructStorageFields::video_worker_quality_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);

        pbio::facerec::RawSampleImpl* const sample_impl = static_cast<pbio::facerec::RawSampleImpl* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                StructStorageFields::video_worker_samples_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);

        pbio::facerec::TemplateImpl* const templ_impl = static_cast<pbio::facerec::TemplateImpl* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                StructStorageFields::video_worker_templ_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);

        const int64_t search_result_size = this_vw._dll_handle->StructStorage_get_int64(
            callback_data,
            StructStorageFields::video_worker_search_result_size_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);

        uint64_t const* const search_result_person_ids = static_cast<uint64_t const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                StructStorageFields::video_worker_search_result_person_ids_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);

        uint64_t const* const search_result_element_ids = static_cast<uint64_t const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                StructStorageFields::video_worker_search_result_element_ids_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);

        float const* const search_result_match_result_distances = static_cast<float const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                StructStorageFields::video_worker_search_result_match_result_distance_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);

        float const* const search_result_match_result_far_s = static_cast<float const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                StructStorageFields::video_worker_search_result_match_result_fa_r_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);

        float const* const search_result_match_result_frr_s = static_cast<float const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                StructStorageFields::video_worker_search_result_match_result_fr_r_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);

        float const* const search_result_match_result_scores = static_cast<float const* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                StructStorageFields::video_worker_search_result_match_result_score_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);


        const RawSample::Ptr sample( RawSample::Ptr::make(this_vw._dll_handle, sample_impl));

        const Template::Ptr templ( Template::Ptr::make(this_vw._dll_handle, templ_impl));

        std::vector<SearchResult> search_results(search_result_size);

        for(int i = 0; i < search_result_size; ++i)
        {
            search_results[i].person_id = search_result_person_ids[i];
            search_results[i].element_id = search_result_element_ids[i];
            search_results[i].match_result.distance = search_result_match_result_distances[i];
            search_results[i].match_result.fa_r = search_result_match_result_far_s[i];
            search_results[i].match_result.fr_r = search_result_match_result_frr_s[i];
            search_results[i].match_result.score = search_result_match_result_scores[i];
        }

        MatchFoundCallbackData data;
        data.stream_id = stream_id;
        data.frame_id  = frame_id;
        data.quality   = quality;
        data.sample    = sample;
        data.templ     = templ;
        data.search_results = search_results;





        for(int i = 0; i < u_callbacks_count; ++i)
        {
            try
            {
                const MatchFoundCallbackU u_callback_function_i =
                    reinterpret_cast<MatchFoundCallbackU>(u_callbacks_func[i]);

                u_callback_function_i(
                    data,
                    u_callbacks_userdata[i]);
            }
            __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("MatchFoundCallbackU")
        }


        for(int i = 0; i < ext_callbacks_count; ++i)
        {
            try
            {
                const MatchFoundCallbackFuncExt ext_callback_function_i =
                    reinterpret_cast<MatchFoundCallbackFuncExt>(ext_callbacks_func[i]);

                ext_callback_function_i(
                    data.stream_id,
                    data.frame_id,
                    data.sample,
                    data.quality,
                    data.templ,
                    data.search_results,
                    ext_callbacks_userdata[i]);
            }
            __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("MatchFoundCallbackExt")
        }


        for(int i = 0; i < callbacks_count; ++i)
        {
            try
            {
                const MatchFoundCallbackFunc callback_function_i =
                    reinterpret_cast<MatchFoundCallbackFunc>(callbacks_func[i]);

                callback_function_i(
                    data.stream_id,
                    data.frame_id,
                    data.search_results[0].person_id,
                    data.search_results[0].element_id,
                    data.sample,
                    data.quality,
                    data.templ,
                    data.search_results[0].match_result,
                    callbacks_userdata[i]);
            }
            __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("MatchFoundCallback")
        }

    }
    __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("MatchFoundCallback_")
}


// static
inline
void VideoWorker::SStiPersonOutdatedCallback(
    void* err_stream,
    void* this_vw__,
    void const* callback_data,

    const int32_t callbacks_count,
    void* const* const callbacks_func,
    void* const* const callbacks_userdata)
{
    try
    {
        const VideoWorker &this_vw = *reinterpret_cast<VideoWorker const*>(this_vw__);

        void* exception = NULL;

        const int64_t stream_id = this_vw._dll_handle->StructStorage_get_int64(
            callback_data,
            StructStorageFields::video_worker_stream_id_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);

        const int64_t sti_person_id = this_vw._dll_handle->StructStorage_get_int64(
            callback_data,
            StructStorageFields::video_worker_sti_person_id_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);


        StiPersonOutdatedCallbackData data;
        data.stream_id = stream_id;
        data.sti_person_id = sti_person_id;

        for(int i = 0; i < callbacks_count; ++i)
        {
            try
            {
                const StiPersonOutdatedCallbackU callback_function_i =
                    reinterpret_cast<StiPersonOutdatedCallbackU>(callbacks_func[i]);

                callback_function_i(
                    data,
                    callbacks_userdata[i]);
            }
            __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("StiPersonOutdated")
        }
    }
    __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("StiPersonOutdated")
}

// static
inline
void VideoWorker::STrackingLostCallback(
    void* err_stream,
    void* this_vw__,
    void const* callback_data,

    const int32_t callbacks_count,
    void* const* const callbacks_func,
    void* const* const callbacks_userdata,
    const int32_t u_callbacks_count,
    void* const* const u_callbacks_func,
    void* const* const u_callbacks_userdata)
{
    try
    {
        const VideoWorker &this_vw = *reinterpret_cast<VideoWorker const*>(this_vw__);

        void* exception = NULL;

        const int64_t stream_id = this_vw._dll_handle->StructStorage_get_int64(
            callback_data,
            StructStorageFields::video_worker_stream_id_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);

        const int64_t first_frame_id = this_vw._dll_handle->StructStorage_get_int64(
            callback_data,
            StructStorageFields::video_worker_first_frame_id_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);

        const int64_t last_frame_id = this_vw._dll_handle->StructStorage_get_int64(
            callback_data,
            StructStorageFields::video_worker_last_frame_id_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);

        const double best_quality = this_vw._dll_handle->StructStorage_get_double(
            callback_data,
            StructStorageFields::video_worker_best_quality_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);

        const int64_t best_quality_frame_id = this_vw._dll_handle->StructStorage_get_int64(
            callback_data,
            StructStorageFields::video_worker_best_qaulity_frame_id_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);

        pbio::facerec::RawSampleImpl* const best_quality_sample_impl = static_cast<pbio::facerec::RawSampleImpl* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                StructStorageFields::video_worker_samples_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);

        const RawSample::Ptr sample =
            best_quality_sample_impl ?
                RawSample::Ptr::make(this_vw._dll_handle, best_quality_sample_impl) :
                RawSample::Ptr();


        pbio::facerec::TemplateImpl* const best_quality_template_impl = static_cast<pbio::facerec::TemplateImpl* const>(
            this_vw._dll_handle->StructStorage_get_pointer(
                callback_data,
                StructStorageFields::video_worker_templ_t,
                &exception));

        checkException(exception, *this_vw._dll_handle);

        const Template::Ptr templ =
            best_quality_template_impl ?
                Template::Ptr( Template::Ptr::make(this_vw._dll_handle, best_quality_template_impl)) :
                Template::Ptr();


        const int64_t track_id = this_vw._dll_handle->StructStorage_get_int64(
            callback_data,
            StructStorageFields::video_worker_track_id_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);


        const int64_t sti_person_id = this_vw._dll_handle->StructStorage_get_int64(
            callback_data,
            StructStorageFields::video_worker_sti_person_id_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);


        const bool sti_person_id_set = this_vw._dll_handle->StructStorage_get_int64(
            callback_data,
            StructStorageFields::video_worker_sti_person_id_set_t,
            &exception);

        checkException(exception, *this_vw._dll_handle);



        TrackingLostCallbackData data;
        data.stream_id = stream_id;
        data.first_frame_id = first_frame_id;
        data.last_frame_id = last_frame_id;
        data.best_quality = best_quality;
        data.best_quality_frame_id = best_quality_frame_id;
        data.best_quality_sample = sample;
        data.best_quality_templ = templ;
        data.track_id = track_id;
        data.sti_person_id = sti_person_id;
        data.sti_person_id_set = sti_person_id_set;





        for(int i = 0; i < u_callbacks_count; ++i)
        {
            try
            {
                const TrackingLostCallbackU u_callback_function_i =
                    reinterpret_cast<TrackingLostCallbackU>(u_callbacks_func[i]);

                u_callback_function_i(
                    data,
                    u_callbacks_userdata[i]);
            }
            __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("TrackingLostCallbackU")
        }


        for(int i = 0; i < callbacks_count; ++i)
        {
            try
            {
                const TrackingLostCallbackFunc callback_function_i =
                    reinterpret_cast<TrackingLostCallbackFunc>(callbacks_func[i]);

                callback_function_i(
                    data.stream_id,
                    data.first_frame_id,
                    data.last_frame_id,
                    data.best_quality,
                    data.best_quality_frame_id,
                    data.best_quality_sample,
                    data.best_quality_templ,
                    callbacks_userdata[i]);
            }
            __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("TrackingLostCallback")
        }

    }
    __0x6ce24ef9_VideoWorker_static_callback_functions_catch_exceptions("TrackingLostCallback_")
}


inline
void VideoWorker::toggleSomething(
    const int stream_id,
    const int something)
{
    void* exception = NULL;

    _dll_handle->VideoWorker_toggleSomething(
        _impl,
        stream_id,
        something,
        &exception);

    checkException(exception, *_dll_handle);
}


inline
void VideoWorker::disableProcessingOnStream(const int stream_id)
{
    toggleSomething(stream_id, pbio::facerec::capi::VideoWorker_something_Processing_Disable);
}


inline
void VideoWorker::enableProcessingOnStream(const int stream_id)
{
    toggleSomething(stream_id, pbio::facerec::capi::VideoWorker_something_Processing_Enable);
}


inline
void VideoWorker::disableAgeGenderEstimationOnStream(const int stream_id)
{
    toggleSomething(stream_id, pbio::facerec::capi::VideoWorker_something_AgeGender_Disable);
}

inline
void VideoWorker::enableAgeGenderEstimationOnStream(const int stream_id)
{
    toggleSomething(stream_id, pbio::facerec::capi::VideoWorker_something_AgeGender_Enable);
}

inline
void VideoWorker::disableEmotionsEstimationOnStream(const int stream_id)
{
    toggleSomething(stream_id, pbio::facerec::capi::VideoWorker_something_Emotions_Disable);
}

inline
void VideoWorker::enableEmotionsEstimationOnStream(const int stream_id)
{
    toggleSomething(stream_id, pbio::facerec::capi::VideoWorker_something_Emotions_Enable);
}




inline
VideoWorker::Params::Params()
: _video_worker_config(std::string())
, _recognizer_ini_file()
, _recognizer_config(std::string())
, _streams_count(0)
, _processing_threads_count(0)
, _matching_threads_count(0)
, _age_gender_estimation_threads_count(0)
, _emotions_estimation_threads_count(0)
, _short_time_identification_enabled(false)
, _short_time_identification_distance_threshold(0)
, _short_time_identification_outdate_time_seconds(0)
, _active_liveness_checks_order()
{
    // nothing else
}


inline
void VideoWorker::setParameter(
    const std::string parameter,
    const double value)
{
    void* exception = NULL;

    _dll_handle->VideoWorker_setParameter(
        _impl,
        parameter.c_str(),
        value,
        &exception);

    checkException(exception, *_dll_handle);
}


}  // pbio namespace


#endif  // __PBIO_API__PBIO__VIDEOWORKER_H_