roc.h

// Copyright © 2015-2022 Rank One Computing Corporation. All rights reserved.

#ifndef ROC_H
#define ROC_H

#include <float.h>
#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#include "roc-embedded.h"

#ifdef __cplusplus
extern "C" {
#endif

#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdocumentation"
#endif // defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE

#ifndef SWIG_ROC_VIDEO

#ifdef SWIG
%module roc
%module(directors="1") roc
%feature("director") roc_template_pipe_type;
%begin %{
#define SWIG_PYTHON_STRICT_BYTE_CHAR
%}
%include cpointer.i
%include carrays.i
#if defined(SWIGPYTHON) || defined(SWIGJAVA)
%include cdata.i
#endif // SWIGPYTHON || SWIGJAVA
%include stdint.i
%{
#include "roc.h"
%}
#ifdef SWIGJAVA
SWIG_JAVABODY_PROXY(public, public, SWIGTYPE)
SWIG_JAVABODY_TYPEWRAPPER(public, public, public, SWIGTYPE)
%include enumtypeunsafe.swg
%native (roc_preinitialize_android) roc_string roc_preinitialize_android(jobject);
%{
JNIEXPORT jstring JNICALL
Java_io_rankone_rocsdk_rocJNI_roc_1preinitialize_1android(JNIEnv *,
                                                          jclass,
                                                          jobject);
%}

// https://stackoverflow.com/a/33543680
%typemap(jni) uint8_t *UBYTE "jbyteArray"
%typemap(jtype) uint8_t *UBYTE "byte[]"
%typemap(jstype) uint8_t *UBYTE "byte[]"
%typemap(in) uint8_t *UBYTE {
  $1 = (uint8_t *) JCALL2(GetByteArrayElements, jenv, $input, 0);
}
%typemap(argout) uint8_t *UBYTE {
  JCALL3(ReleaseByteArrayElements, jenv, $input, (jbyte *) $1, 0);
}
%typemap(javain) uint8_t *UBYTE "$javainput"
%typemap(freearg) uint8_t *UBYTE ""
%apply uint8_t *UBYTE { uint8_t *input_byte_array };
%apply uint8_t *UBYTE { uint8_t *output_byte_array };
%apply uint8_t *UBYTE { uint8_t *y_in };
%apply uint8_t *UBYTE { uint8_t *u_in };
%apply uint8_t *UBYTE { uint8_t *v_in };
#endif // SWIGJAVA
#ifdef SWIGCSHARP
%apply void *VOID_INT_PTR { void * }
%include "arrays_csharp.i"
%apply uint8_t INPUT[]  { uint8_t *input_byte_array }
%apply uint8_t OUTPUT[] { uint8_t *output_byte_array }
%apply uint8_t INPUT[]  { uint8_t *y_in }
%apply uint8_t INPUT[]  { uint8_t *u_in }
%apply uint8_t INPUT[]  { uint8_t *v_in }
%typemap(csbase) roc_algorithm_options "long"
#endif // SWIGSCHARP
#ifdef SWIGPYTHON
%include "pybuffer.i"
%pybuffer_binary(const uint8_t *input_byte_array, size_t len)
#endif // SWIGPYTHON
%pointer_functions(bool, bool)
%pointer_functions(int, int)
%pointer_functions(float, float)
%pointer_functions(double, double)
%pointer_functions(size_t, size_t)
%pointer_functions(uint32_t, uint32_t)
%pointer_functions(uint64_t, uint64_t)
%pointer_functions(int64_t, int64_t)
%pointer_functions(roc_gallery, roc_gallery)
%pointer_functions(roc_similarity, roc_similarity)
%pointer_functions(roc_string, roc_string)
%pointer_functions(roc_buffer, roc_buffer)
%pointer_functions(roc_time, roc_time)
%pointer_functions(roc_video, roc_video)
%pointer_functions(roc_video_service, roc_video_service)
%pointer_functions(roc_stream, roc_stream)
%pointer_functions(roc_tracker, roc_tracker)
%pointer_functions(roc_foreground, roc_foreground)
%pointer_functions(roc_database, roc_database)
%pointer_functions(roc_alerter, roc_alerter)
%pointer_functions(roc_algorithm_options, roc_algorithm_options)
%pointer_functions(roc_server, roc_server)
%pointer_functions(roc_template_pipe, roc_template_pipe)
%pointer_functions(roc_uuid_array, roc_dynamic_uuid_array)
%pointer_functions(roc_template_index_array, roc_dynamic_template_index_array)
%array_functions(uint8_t, uint8_t_array)
%array_functions(float, float_array)
%array_functions(roc_template, roc_template_array)
%array_functions(roc_template_index, roc_template_index_array)
%array_functions(roc_similarity, roc_similarity_array)
%array_functions(roc_candidate, roc_candidate_array)
%array_functions(roc_person_id, roc_person_id_array)
%array_functions(roc_detection, roc_detection_array)
%array_functions(roc_landmark, roc_landmark_array)
%array_functions(roc_adjudication, roc_adjudication_array)
%array_functions(roc_uuid, roc_uuid_array)
%array_functions(roc_hash, roc_hash_array)
%array_functions(roc_roi, roc_roi_array)
%copyctor roc_uuid;
%copyctor roc_hash;
%include roc-embedded.h
#endif // SWIG

ROC_EXPORT roc_error roc_initialize(const char *license_file,
                                    const char *log_file);


ROC_EXPORT roc_error roc_set_keylok_keys(int validateCode1,
                                         int validateCode2,
                                         int validateCode3,
                                         int clientIDCode1,
                                         int clientIDCode2,
                                         int readCode3);

ROC_EXPORT roc_error roc_set_floating_license_server(const char *hostname);

ROC_EXPORT roc_error roc_set_cuda_benchmarking(bool benchmark, bool clear_cache);

ROC_EXPORT roc_error roc_set_cuda_device(int device);

ROC_EXPORT roc_error roc_enable_cuda(bool enabled, roc_progress progress);


ROC_EXPORT roc_error roc_get_cuda_utilization(float *gpu_utilization_percentage,
                                              float *memory_utilization_percentage);

ROC_EXPORT roc_error roc_set_opportunistic_batching(int ideal_batch_size,
                                                    int maximum_latency);


ROC_EXPORT roc_error roc_enable_snpe(bool enabled,
                                     roc_string snpe_model_path);

#if !defined(SWIG)

ROC_EXPORT roc_error roc_cuda_device_count(unsigned int *device_count);

ROC_EXPORT roc_error roc_cuda_utilization(unsigned int index,
                                          unsigned int *gpu,
                                          unsigned int *memory);
#endif // !SWIG

ROC_EXPORT roc_error roc_finalize();

ROC_EXPORT roc_error roc_get_hostname(roc_string *hostname);

ROC_EXPORT roc_error roc_get_host_id_extended(roc_string *host_id);

ROC_EXPORT roc_error roc_get_application_certificate(roc_string *app_cert);

typedef enum roc_license_term
{
    ROC_INITIALIZED,

    ROC_ANALYTICS_ONLY,

    ROC_EXPLORE,

    ROC_TATTOO_ENABLED,

    ROC_LIVENESS_ENABLED,

    ROC_ICAO_ENABLED,

    ROC_OCR_ENABLED,

    ROC_OBJECT_ENABLED,

    ROC_WATCH,

    ROC_GPU,

    ROC_UNLOCKED_FV,

    ROC_FACE_ENABLED,

    ROC_FINGERPRINT_ENABLED
} roc_license_term;

ROC_EXPORT roc_error roc_get_license_term(roc_license_term license_term,
                                          bool *enabled);

ROC_EXPORT roc_error roc_get_thread_limit(int *limit);

ROC_EXPORT roc_error roc_set_thread_limit(int limit);

ROC_EXPORT roc_error roc_get_floating_license_limit(uint32_t *clients_remaining,
                                                    uint64_t *
                                                         comparisons_remaining);

ROC_EXPORT roc_error roc_get_floating_license_status(bool *is_connected);

ROC_EXPORT roc_error roc_set_icao_background_color(uint8_t r,
                                                   uint8_t g,
                                                   uint8_t b); // end of initialization

typedef struct roc_uuid_string
{
    char data[39]; 
} roc_uuid_string;

ROC_EXPORT roc_uuid_string roc_uuid_to_string(roc_uuid uuid);

ROC_EXPORT const char *roc_uuid_string_cast(const roc_uuid_string *uuid);

ROC_EXPORT roc_uuid roc_uuid_from_string(const char *str);

ROC_EXPORT roc_uuid roc_uuid_get_random();

typedef struct roc_hash_string
{
    char data[41]; 
} roc_hash_string;

ROC_EXPORT roc_hash_string roc_hash_to_string(roc_hash hash);

ROC_EXPORT const char *roc_hash_string_cast(const roc_hash_string *hash);

ROC_EXPORT roc_hash roc_hash_from_string(const char *str);

ROC_EXPORT roc_hash roc_hash_calc_sha1(const uint8_t *input_byte_array,
                                       size_t length);

ROC_EXPORT roc_hash roc_hash_calc_sha1_file(const char *file_path);

ROC_EXPORT roc_hash roc_hash_get_random();
 // end of identifiers_and_hashes

typedef struct roc_alerter_type *roc_alerter;

ROC_EXPORT roc_error roc_initialize_alerter(
    roc_alerter *alerter,
    const char *key_file_path);

ROC_EXPORT roc_error roc_alerter_has_sms_credentials(
    const roc_alerter alerter,
    bool *has_sms_credentials);

ROC_EXPORT roc_error roc_alerter_has_email_credentials(
    const roc_alerter alerter,
    bool *has_email_credentials);

ROC_EXPORT roc_error roc_alerter_has_whatsapp_credentials(
    const roc_alerter alerter,
    bool *has_whatsapp_credentials);

ROC_EXPORT roc_error roc_send_text_message(
    const roc_alerter alerter,
    const char *phone_number,
    const char *message,
    roc_buffer image_data,
    size_t image_data_length);

ROC_EXPORT roc_error roc_send_whatsapp_message(
    const roc_alerter alerter,
    const char *phone_number,
    const char *alerts_sender_name,
    const char *person_name,
    const char *camera_name,
    const char *date_time,
    roc_buffer image_data,
    size_t image_data_length);

ROC_EXPORT roc_error roc_send_email(
    const roc_alerter alerter,
    const char *to_email_address,
    const char *recipient_name,
    const char *subject,
    const char *message,
    roc_buffer image_data,
    size_t image_data_length);

ROC_EXPORT roc_error roc_free_alerter(
    roc_alerter *alerter);
 // end of roc_alerts

ROC_EXPORT roc_error roc_read_image(const char *file_name,
                                    roc_color_space color_space,
                                    roc_image *image);

ROC_EXPORT roc_error roc_read_image_w(const wchar_t *file_name,
                                      roc_color_space color_space,
                                      roc_image *image);

ROC_EXPORT roc_error roc_read_exif(const char *jpeg_file_name,
                                   roc_string *exif);

ROC_EXPORT roc_error roc_write_image(roc_image image,
                                     const char *file_name);

ROC_EXPORT roc_error roc_decode_image(const uint8_t *input_byte_array,
                                      size_t len,
                                      roc_color_space color_space,
                                      roc_image *image);

ROC_EXPORT roc_error roc_encode_image(roc_image image,
                                      const char *format,
                                      int quality,
                                      roc_buffer *buffer,
                                      size_t *buffer_length);

ROC_EXPORT roc_error roc_convert_nv21(const uint8_t *input_byte_array,
                                      size_t width,
                                      size_t height,
                                      roc_image *image);

ROC_EXPORT roc_error roc_redact_image(roc_image image,
                                      roc_detection detection,
                                      bool blur);

ROC_EXPORT roc_error roc_render_detection(roc_image image,
                                          const roc_detection detection,
                                          uint8_t r,
                                          uint8_t g,
                                          uint8_t b);

ROC_EXPORT roc_error roc_resize_image(roc_image src,
                                      roc_image *dst,
                                      size_t width,
                                      size_t height);

ROC_EXPORT roc_error roc_read_ebts(const char *file_path,
                                   int num_face_images,
                                   roc_string *ebts,
                                   roc_image *images); // end of image_decoding

#endif // !SWIG_ROC_VIDEO

typedef struct roc_video_type *roc_video;

typedef struct roc_video_metadata
{
    size_t width;      
    size_t height;     
    roc_time duration; 
    roc_time keyframe_interval; 
    double frame_rate; 
    int bit_rate;      
    roc_media_id media_id; 
    roc_camera_id camera_id; 
    bool is_live; 
} roc_video_metadata;

typedef enum roc_video_log_level
{
    ROC_VIDEO_QUIET   = -8, 
    ROC_VIDEO_PANIC   =  0, 
    ROC_VIDEO_FATAL   =  8, 
    ROC_VIDEO_ERROR   = 16, 
    ROC_VIDEO_WARNING = 24, 
    ROC_VIDEO_INFO    = 32, 
    ROC_VIDEO_VERBOSE = 40  
} roc_video_log_level;

#if !defined(SWIG) || defined(SWIG_ROC_VIDEO)

#ifdef SWIG
%module roc_video
#ifdef SWIGJAVA
%include enumtypeunsafe.swg
#endif // SWIGJAVA
%{
#include "roc.h"
%}
%include roc-embedded.h
#endif // SWIG

ROC_EXPORT roc_error roc_set_video_logging(roc_video_log_level log_level);

ROC_EXPORT roc_error roc_open_video(const char *file_name,
                                    roc_color_space color_space,
                                    roc_video *video,
                                    roc_video_metadata *metadata);

ROC_EXPORT roc_error roc_open_video_w(const wchar_t *file_name,
                                      roc_color_space color_space,
                                      roc_video *video,
                                      roc_video_metadata *metadata);

ROC_EXPORT roc_error roc_open_gst_video(const char *video_url,
                                        roc_color_space color_space,
                                        bool gpu_decoding,
                                        roc_video *video);

ROC_EXPORT roc_error roc_video_set_camera_id(roc_video video,
                                             roc_camera_id camera_id);

ROC_EXPORT roc_error roc_video_set_start_time(roc_video video,
                                              roc_time timestamp);

#endif // !defined(SWIG) || defined(SWIG_ROC_VIDEO)
#ifndef SWIG_ROC_VIDEO

ROC_EXPORT roc_error roc_open_spinnaker(int index,
                                        roc_color_space color_space,
                                        roc_video *camera);

ROC_EXPORT roc_error roc_is_live(roc_video video, bool *is_live);

ROC_EXPORT roc_error roc_seek_keyframe(roc_video video,
                                       roc_time timestamp,
                                       bool backwards);

ROC_EXPORT roc_error roc_seek_frame(roc_video video,
                                    roc_time timestamp);

ROC_EXPORT roc_error roc_read_frame(roc_video video,
                                    roc_image *frame);

ROC_EXPORT roc_error roc_close_video(roc_video video);
 // end of video_decoding

typedef struct roc_thumbnail_parameters
{
    int width;

    int height;

    float scale;

    float quality;
} roc_thumbnail_parameters;

ROC_EXPORT roc_error roc_get_thumbnail_parameters(
                         roc_thumbnail_parameters *thumbnail_parameters);

ROC_EXPORT roc_error roc_set_thumbnail_parameters(
                         roc_thumbnail_parameters thumbnail_parameters);
ROC_EXPORT roc_error roc_preload(roc_algorithm_id algorithm_id);

ROC_EXPORT roc_error roc_set_model_path(const char *path);

ROC_EXPORT roc_error roc_represent(roc_image image,
                                   roc_algorithm_id algorithm_id,
                                   size_t min_size,
                                   int k,
                                   float false_detection_rate,
                                   float min_quality,
                                   roc_template *templates);

ROC_EXPORT roc_error roc_represent_roi(roc_image image,
                                       roc_algorithm_id algorithm_id,
                                       float relative_min_size,
                                       size_t absolute_min_size,
                                       size_t min_representation_size,
                                       int k,
                                       float false_detection_rate,
                                       float min_quality,
                                       const roc_roi *include,
                                       size_t num_include,
                                       const roc_roi *exclude,
                                       size_t num_exclude,
                                       float min_roi_overlap,
                                       const roc_string text_filter,
                                       const roc_thumbnail_parameters thumbnail_parameters,
                                       bool rotate_on_failure,
                                       roc_template *templates);

ROC_EXPORT roc_error roc_represent_fingerprint(roc_image image,
                                               roc_finger_id finger_id,
                                               const int resolution,
                                               const int k,
                                               float false_detection_rate,
                                               float min_quality,
                                               roc_template *templates);

ROC_EXPORT roc_error roc_merge_fingerprints(const roc_template *templates,
                                            int n, 
                                            roc_template *merged);

ROC_EXPORT roc_error roc_representation_limit(size_t *representation_limit);
 // end of template_generation

#ifndef SWIG

ROC_EXPORT roc_error roc_read_template(FILE *file,
                                       roc_template *template_);

#endif // !SWIG

ROC_EXPORT roc_error roc_read_template_fd(int fd,
                                          roc_template *template_);

ROC_EXPORT roc_error roc_read_template_fd_ext(int fd,
                                              roc_template *template_,
                                              bool read_md,
                                              bool read_fv,
                                              bool read_tn);

#ifndef SWIG

ROC_EXPORT roc_error roc_write_template(FILE *file,
                                        const roc_template template_);

#endif // !SWIG

ROC_EXPORT roc_error roc_write_template_fd(int fd,
                                           const roc_template template_);

ROC_EXPORT roc_error roc_get_metadata(const roc_template template_,
                                      const char *key,
                                      roc_string *value);

ROC_EXPORT roc_error roc_set_metadata(roc_template *template_,
                                      const char *key,
                                      const char *value);

ROC_EXPORT roc_error roc_set_metadata_object(roc_template *template_,
                                             const char *json_object);

ROC_EXPORT roc_error roc_realloc_metadata(roc_template *template_,
                                          uint32_t md_size);

ROC_EXPORT roc_error roc_clear_metadata(roc_template *template_);

ROC_EXPORT roc_error roc_clear_thumbnail(roc_template *template_);

ROC_EXPORT roc_error roc_clear_feature_vector(roc_template *template_,
                                              roc_algorithm_id representations);


ROC_EXPORT roc_error roc_get_metadata_double(const roc_template template_,
                                             const char *key,
                                             double *value);

ROC_EXPORT roc_error roc_set_metadata_double(roc_template *template_,
                                             const char *key,
                                             double value);

ROC_EXPORT roc_error roc_to_base64(const uint8_t *input_byte_array,
                                   size_t length,
                                   roc_string *str);

ROC_EXPORT roc_error roc_from_base64(const char *str,
                                     roc_buffer *buffer,
                                     size_t *buffer_length);

struct roc_template_pipe_type;

typedef struct roc_template_pipe_type *roc_template_pipe;
 // end of template_io

typedef struct roc_stream_type *roc_stream;

typedef void (*roc_stream_image_callback)(roc_stream stream,
                                          void*,
                                          roc_error,
                                          roc_image);

typedef void (*roc_stream_encoded_image_callback)(roc_stream stream,
                                                  void*,
                                                  roc_error,
                                                  size_t,
                                                  const uint8_t*,
                                                  roc_time);

typedef void (*roc_stream_template_callback)(roc_stream stream,
                                             void*,
                                             roc_error,
                                             roc_template);

ROC_EXPORT roc_error roc_stream_load_configuration(const char* stream_info,
                                   roc_stream *stream);
ROC_EXPORT roc_error roc_stream_start(roc_stream *stream,
                                      float frames_per_second,
                                      int num_worker_threads);

ROC_EXPORT roc_error roc_stream_set_warmup(roc_stream stream,
                                           roc_time warmup);

ROC_EXPORT roc_error roc_stream_limit(size_t *stream_limit);

ROC_EXPORT roc_error roc_stream_set_image_callback(roc_stream stream,
                                                   roc_stream_image_callback
                                                                 image_callback,
                                                   void
                                                       *image_callback_context);

ROC_EXPORT roc_error roc_stream_set_encoded_image_callback(
                         roc_stream stream,
                         roc_stream_encoded_image_callback
                                                         encoded_image_callback,
                         void *encoded_image_callback_context);

ROC_EXPORT roc_error roc_stream_set_video(roc_stream stream,
                                          roc_video video);

ROC_EXPORT roc_error roc_stream_clear_video(roc_stream stream);

ROC_EXPORT roc_error roc_stream_stop(roc_stream *stream);

ROC_EXPORT roc_error roc_stream_set_frame_rate(roc_stream stream,
                                               float frames_per_second);

ROC_EXPORT bool roc_stream_is_paused(roc_stream stream);

ROC_EXPORT roc_error roc_stream_set_paused(roc_stream stream,
                                           bool paused);

ROC_EXPORT roc_error roc_stream_get_true_frame_rate(roc_stream stream,
                                                    float *frames_per_second);

ROC_EXPORT roc_error roc_stream_get_frame_counts(roc_stream stream,
                                                 size_t *ignored,
                                                 size_t *queued,
                                                 size_t *processed,
                                                 size_t *dropped);

ROC_EXPORT roc_error roc_stream_add_image(roc_stream stream,
                                          roc_image image);

ROC_EXPORT roc_error roc_stream_add_encoded_image(
                         roc_stream stream,
                         size_t len,
                         const uint8_t *input_byte_array,
                         roc_time timestamp);

ROC_EXPORT roc_error roc_stream_sync(roc_stream stream,
                                     roc_time timestamp);
 // end of video_streaming

typedef const char *roc_gallery_file;

typedef struct roc_gallery_type *roc_gallery;

typedef const struct roc_gallery_type *roc_const_gallery;

ROC_EXPORT roc_error roc_open_gallery(roc_gallery_file gallery_file,
                                      roc_gallery *gallery,
                                      roc_progress progress);

typedef size_t roc_template_index;

extern const roc_template_index ROC_EXPORT ROC_INVALID_TEMPLATE_INDEX;

ROC_EXPORT roc_template_index roc_get_invalid_template_index();

typedef roc_template_index *roc_template_index_array;

ROC_EXPORT void roc_free_template_index_array(roc_template_index_array
                                                         *template_index_array);

ROC_EXPORT roc_error roc_enroll(roc_gallery gallery,
                                const roc_template template_,
                                roc_template_index *index);

ROC_EXPORT roc_error roc_fsync(roc_gallery gallery);

ROC_EXPORT roc_error roc_size(roc_const_gallery gallery,
                              size_t *size);

ROC_EXPORT roc_error roc_last_modified(roc_const_gallery gallery,
                                       roc_time *timestamp);

ROC_EXPORT roc_error roc_take_snapshot(roc_const_gallery gallery,
                                       const char *file_path,
                                       bool defragment);

ROC_EXPORT roc_error roc_at(roc_const_gallery gallery,
                            roc_template_index index,
                            roc_template *template_);

ROC_EXPORT roc_error roc_at_n(roc_const_gallery gallery,
                              roc_template_index start_index,
                              size_t n,
                              roc_template *templates);

ROC_EXPORT roc_error roc_get(roc_const_gallery gallery,
                             roc_template_id template_id,
                             roc_template *template_);

ROC_EXPORT roc_error roc_index_for_id(roc_const_gallery gallery,
                                      roc_template_id template_id,
                                      roc_template_index *index);

ROC_EXPORT roc_error roc_replace(roc_gallery gallery,
                                 roc_template_index index,
                                 const roc_template template_);

ROC_EXPORT roc_error roc_remove(roc_gallery gallery,
                                roc_template_index index);

ROC_EXPORT roc_error roc_remove_n(roc_gallery gallery,
                                  roc_template_index start_index,
                                  size_t n);

ROC_EXPORT roc_error roc_remove_id(roc_gallery gallery,
                                   roc_template_id template_id);

ROC_EXPORT roc_error roc_remove_before(roc_gallery gallery,
                                       roc_time timestamp);

ROC_EXPORT roc_error roc_close_gallery(roc_gallery gallery);

ROC_EXPORT roc_error roc_template_limit(size_t *template_limit);

ROC_EXPORT roc_error roc_defragment(roc_gallery_file input,
                                    roc_gallery_file output);

ROC_EXPORT roc_error roc_validate(roc_gallery_file gallery,
                                  bool truncate,
                                  size_t *templates,
                                  int64_t *bytes_read,
                                  int64_t *bytes_unread);
 // end of gallery_construction

ROC_EXPORT roc_error roc_compare_templates(const roc_template a,
                                           const roc_template b,
                                           roc_similarity *similarity);

ROC_EXPORT roc_error roc_acquire_search_thread();

ROC_EXPORT roc_error roc_release_search_thread();

ROC_EXPORT roc_error roc_compare_galleries(roc_const_gallery target,
                                           roc_const_gallery query,
                                           roc_similarity *similarity_matrix);

ROC_EXPORT roc_error roc_comparison_limit(size_t *comparison_limit);
 // end of comparison

typedef struct roc_candidate
{
    roc_person_id person_id; 
    roc_template_id template_id; 
    roc_template_index index; 
    roc_similarity similarity; 
#if defined(__cplusplus) && !defined(SWIG)

    roc_candidate()
        : person_id(roc_uuid_get_null())
        , template_id(roc_uuid_get_null())
        , index(roc_get_invalid_template_index())
        , similarity(ROC_INVALID_SIMILARITY)
    {}

    roc_candidate(const roc_person_id &person_id,
                  const roc_template_id &template_id,
                  roc_template_index index,
                  roc_similarity similarity)
        : person_id(person_id)
        , template_id(template_id)
        , index(index)
        , similarity(similarity)
    {}

    inline bool operator<(const roc_candidate &other) const
    {
        if (similarity != other.similarity)
            return similarity > other.similarity;
        return index < other.index;
    }
#endif // __cplusplus && !SWIG
} roc_candidate;

ROC_EXPORT roc_error roc_search(roc_const_gallery gallery,
                                const roc_template probe,
                                size_t k,
                                roc_similarity min_similarity,
                                roc_candidate *candidates);

ROC_EXPORT roc_error roc_knn(roc_const_gallery gallery,
                             roc_const_gallery probes,
                             size_t k,
                             roc_similarity min_similarity,
                             roc_candidate *neighbors,
                             roc_progress progress);

ROC_EXPORT roc_error roc_knn_and_cluster(roc_gallery gallery,
                                         size_t k,
                                         roc_similarity min_similarity,
                                         bool incremental,
                                         roc_progress progress);

ROC_EXPORT roc_error roc_search_persons(roc_const_gallery gallery,
                                        roc_const_gallery probes,
                                        size_t k,
                                        roc_similarity min_similarity,
                                        bool one_candidate_per_person_id,
                                        bool ignore_identical,
                                        roc_candidate *candidates);

ROC_EXPORT roc_error roc_rerank(roc_const_gallery gallery,
                                size_t k,
                                roc_candidate *candidates);

ROC_EXPORT roc_error roc_rank_persons(roc_const_gallery gallery,
                                      const roc_template probe,
                                      size_t k,
                                      roc_person_id *person_ids,
                                      roc_similarity *similarities);

ROC_EXPORT roc_error roc_consolidate_candidates(roc_gallery gallery,
                                                roc_similarity max_similarity,
                                                size_t k,
                                                roc_candidate *candidates);
 // end of search

typedef struct roc_database_type *roc_database;

ROC_EXPORT roc_error roc_open_database(const char *path,
                                       roc_database *database);

ROC_EXPORT roc_error roc_close_database(roc_database *database);

ROC_EXPORT roc_error roc_database_add_file(roc_database database,
                                           const char *file_path,
                                           roc_hash key);

ROC_EXPORT roc_error roc_database_add_link(roc_database database,
                                           const char *file_path,
                                           roc_hash key);

ROC_EXPORT roc_error roc_database_add_data(roc_database database,
                                           const uint8_t *input_byte_array,
                                           size_t length,
                                           roc_hash key);

ROC_EXPORT roc_error roc_database_has_key(roc_database database,
                                          roc_hash key,
                                          bool *has_key);

ROC_EXPORT roc_error roc_database_retrieve_file(roc_database database,
                                                roc_hash key,
                                                roc_string *file_path);

ROC_EXPORT roc_error roc_database_retrieve_data(roc_database database,
                                                roc_hash key,
                                                roc_buffer *data,
                                                size_t *length);

ROC_EXPORT roc_error roc_database_remove(roc_database database,
                                         roc_hash key);

ROC_EXPORT roc_error roc_database_first_key(roc_database database,
                                            roc_hash *first_key);

ROC_EXPORT roc_error roc_database_next_key(roc_database database,
                                           roc_hash current_key,
                                           roc_hash *next_key);

ROC_EXPORT roc_error roc_database_sync(roc_database from,
                                       const char *to,
                                       bool async);
 // end of media_database

typedef struct roc_foreground_type *roc_foreground;

ROC_EXPORT roc_error roc_new_foreground(roc_foreground *foreground);

ROC_EXPORT roc_error roc_foreground_add_frame(roc_foreground foreground,
                                              const roc_image frame,
                                              roc_image *mask);

ROC_EXPORT roc_error roc_foreground_quality(const roc_image mask,
                                            float *foreground_quality);

ROC_EXPORT roc_error roc_foreground_roi(const roc_image mask,
                                        size_t *x,
                                        size_t *y,
                                        size_t *width,
                                        size_t *height);

ROC_EXPORT roc_error roc_foreground_render(const roc_image frame,
                                           const roc_image mask,
                                           roc_image *rendering);

ROC_EXPORT roc_error roc_free_foreground(roc_foreground *foreground);
 // end of foreground_modeling

typedef struct roc_event
{
    roc_event_type reasons; 
    roc_template probe; 
    float quality; 
    roc_person_id replaced_by; 
    roc_time previous_event; 
    roc_candidate candidate; 
    roc_gallery watchlist; 
    roc_time start; 
    roc_time stop; 
    roc_detection first_detection; 
    roc_detection latest_detection; 
    roc_camera_id camera; 
    uint32_t count; 
} roc_event;

typedef struct roc_tracker_type *roc_tracker;

ROC_EXPORT roc_error roc_new_tracker(roc_tracker *tracker);

#ifndef SWIG

#define ROC_DEFAULT_MIN_TRACKING_SIMILARITY 0.45f
#else // SWIG
%constant float ROC_DEFAULT_MIN_TRACKING_SIMILARITY = 0.45f;
#endif // !SWIG

#ifndef SWIG

#define ROC_SUGGESTED_MIN_DETECTION_OVERLAP 0.0f
#else // SWIG
%constant float ROC_SUGGESTED_MIN_DETECTION_OVERLAP = 0.0f;
#endif // !SWIG

#ifndef SWIG

#define ROC_DEFAULT_MAX_TIME_SEPARATION 5000
#else // SWIG
%constant int ROC_DEFAULT_MAX_TIME_SEPARATION = 5000;
#endif // !SWIG

#ifndef SWIG

#define ROC_DEFAULT_MIN_COUNT 1
#else // SWIG
%constant int ROC_DEFAULT_MIN_COUNT = 1;
#endif // !SWIG

#ifndef SWIG

#define ROC_DEFAULT_LICENSE_PLATE_STATE_THRESHOLD 0.9
#else // SWIG
%constant float ROC_DEFAULT_LICENSE_PLATE_STATE_THRESHOLD = 0.9;
#endif // !SWIG

typedef struct roc_tracker_algorithm_parameters {
    roc_algorithm_id algorithm_id;            
    float relative_min_size;                  
    int k;                                    
    float false_detection_rate;               
    float min_quality;                        
    roc_event_type reasons;                   
    roc_time max_time_separation;             
    float min_detection_overlap;              
    roc_similarity min_tracking_similarity;   
    int min_count;                            
    char *text_filter;                        
    roc_thumbnail_parameters thumbnail_parameters; 
    char *metadata_object;                    
} roc_tracker_algorithm_parameters;

ROC_EXPORT roc_error roc_tracker_set_tracking_parameters(roc_tracker tracker,
                                                         roc_event_type reasons,
                                                         roc_time max_time_separation,
                                                         float min_detection_overlap,
                                                         roc_similarity min_tracking_similarity,
                                                         int min_count);

ROC_EXPORT roc_error roc_tracker_set_represent_parameters(roc_tracker tracker,
                                                          roc_algorithm_id algorithm_id,
                                                          float relative_min_size,
                                                          int k,
                                                          float false_detection_rate,
                                                          float min_quality);

ROC_EXPORT roc_error roc_tracker_set_algorithm_parameters(roc_tracker tracker,
                                                          const roc_tracker_algorithm_parameters *algorithm_params_list,
                                                          size_t list_size);

ROC_EXPORT roc_error roc_tracker_set_enhance_contrast_parameters(
                         roc_tracker tracker,
                         float clip_limit,
                         int num_tiles);

ROC_EXPORT roc_error roc_tracker_load_configuration(const char* tracker_info,
                                        roc_gallery *galleries,
                                        size_t gallery_count,
                                        const char *process_id,
                                        roc_tracker tracker);

ROC_EXPORT roc_error roc_tracker_set_output_pipe(roc_tracker tracker,
                                                 const char* template_pipe_file,
                                                 bool append,
                                                 bool keep_alive,
                                                 bool replay_on_failure,
                                                 int frame_rate,
                                                 int quality,
                                                 size_t height);

ROC_EXPORT roc_error roc_tracker_set_rendering_options(roc_tracker tracker,
                                                       bool render_detections,
                                                       bool render_foreground,
                                                       bool render_timestamps,
                                                       bool render_person_ids,
                                                       bool render_recording,
                                                       uint8_t r,
                                                       uint8_t g,
                                                       uint8_t b);

typedef enum roc_tracker_privacy
{
    ROC_REDACT_NONE = 0x0,

    ROC_REDACT_NONMATCHING = 0x1,

    ROC_REDACT_MATCHING = 0x2,

    ROC_REDACT_ALL = ROC_REDACT_NONMATCHING
                   | ROC_REDACT_MATCHING,
} roc_tracker_privacy;

ROC_EXPORT roc_error roc_tracker_set_privacy_parameters(roc_tracker tracker,
                                             roc_tracker_privacy face_privacy,
                                             bool blur,
                                             roc_tracker_privacy image_privacy);

ROC_EXPORT roc_error roc_tracker_set_watchlisting_parameters(
                                     roc_tracker tracker,
                                     roc_similarity min_watchlist_similarity);

ROC_EXPORT roc_error roc_tracker_add_watchlist(roc_tracker tracker,
                                               roc_gallery watchlist);

ROC_EXPORT roc_error roc_tracker_remove_watchlist(roc_tracker tracker,
                                                  roc_gallery watchlist);

ROC_EXPORT roc_error roc_tracker_set_rois(roc_tracker tracker,
                                          const roc_roi *include,
                                          size_t num_include,
                                          const roc_roi *exclude,
                                          size_t num_exclude,
                                          float min_roi_overlap);

ROC_EXPORT roc_error roc_tracker_set_foreground_parameters(roc_tracker tracker);

ROC_EXPORT roc_error roc_tracker_set_best_image_parameters(roc_tracker tracker,
                                                roc_database database,
                                                const char *template_pipe_file,
                                                const char *format,
                                                int quality,
                                                roc_event_type reasons,
                                                bool append,
                                                bool keep_alive,
                                                bool replay_on_failure);

ROC_EXPORT roc_error roc_tracker_set_time_elapsed(roc_tracker tracker,
                                                  roc_time threshold_ms,
                                                  roc_time interval_ms);

ROC_EXPORT roc_error roc_tracker_add_template(roc_tracker tracker,
                                              const roc_template template_);

ROC_EXPORT roc_error roc_tracker_add_image(roc_tracker tracker,
                                           const roc_image image,
                                           roc_stream stream);

ROC_EXPORT roc_error roc_tracker_add_encoded_image(roc_tracker tracker,
                                                size_t len,
                                                const uint8_t *input_byte_array,
                                                roc_time timestamp,
                                                roc_stream stream);

ROC_EXPORT roc_error roc_tracker_update_time(roc_tracker tracker,
                                             roc_time timestamp);

ROC_EXPORT roc_error roc_tracker_get_current_frame(roc_tracker tracker,
                                                   roc_image *frame,
                                                   roc_event *events,
                                                   int *num_events);

ROC_EXPORT void *roc_tracker_cast(roc_tracker tracker);

#ifdef SWIG
%constant void roc_tracker_add_image_callback(void*, roc_error, roc_image);
#else // !SWIG

ROC_EXPORT void roc_tracker_add_image_callback(roc_stream stream,
                                               void *tracker,
                                               roc_error error,
                                               roc_image image);
#endif // SWIG

#ifdef SWIG
%constant void roc_tracker_add_encoded_image_callback(void*, roc_error, size_t, const uint8_t*, roc_time);
#else // !SWIG

ROC_EXPORT void roc_tracker_add_encoded_image_callback(
                    roc_stream stream,
                    void *tracker,
                    roc_error error,
                    size_t len,
                    const uint8_t *input_byte_array,
                    roc_time timestamp);
#endif // SWIG

ROC_EXPORT bool roc_tracker_has_events(roc_tracker tracker, roc_time wait);

ROC_EXPORT roc_error roc_tracker_take_event(roc_tracker tracker,
                                            roc_event *event);

ROC_EXPORT roc_error roc_tracker_best_image(roc_tracker tracker,
                                            roc_person_id person_id,
                                            roc_image *image);

ROC_EXPORT roc_error roc_tracker_set_recorder_parameters(roc_tracker tracker,
                         const char *database_path,
                         bool keep_alive,
                         int max_frames_stored,
                         unsigned int idr_interval,
                         bool persistent_recording_enabled,
                         roc_time persistent_recording_clips_duration);

ROC_EXPORT roc_error roc_tracker_get_video_clip(const roc_tracker tracker,
                                                roc_time *start_time,
                                                roc_time *stop_time,
                                                roc_buffer *bit_stream,
                                                size_t *bit_stream_size);

ROC_EXPORT roc_error roc_tracker_get_next_video_clip(const roc_tracker tracker,
                                                     roc_time *start_time,
                                                     roc_time *stop_time,
                                                     roc_buffer *bit_stream,
                                                     size_t *bit_stream_size);

ROC_EXPORT roc_error roc_tracker_flush_remaining_clips(const roc_tracker tracker,
                                                       roc_camera_id camera_id);

ROC_EXPORT roc_error roc_tracker_get_earliest_recorded_time(const roc_tracker tracker,
                                                            roc_time *timestamp);

ROC_EXPORT roc_error roc_tracker_get_current_recorded_time(const roc_tracker tracker,
                                                           roc_time *timestamp);

ROC_EXPORT roc_error roc_tracker_store_clip(const roc_tracker tracker,
                                            roc_media_id media_id,
                                            roc_camera_id camera_id,
                                            roc_time *start,
                                            roc_time *stop);

ROC_EXPORT roc_error roc_tracker_store_next_clip(const roc_tracker tracker,
                                                 roc_media_id media_id,
                                                 roc_camera_id camera_id,
                                                 roc_time *start,
                                                 roc_time *stop);

ROC_EXPORT roc_error roc_free_tracker(roc_tracker tracker);
 // end of tracking

typedef struct roc_video_service_type *roc_video_service;

#if !defined(SWIG) || defined(SWIG_ROC_VIDEO)

ROC_EXPORT roc_error roc_new_video_service(roc_video_service *video_service);

ROC_EXPORT roc_error roc_video_service_start(roc_video_service video_service,
                                             roc_string global_settings);
typedef struct roc_stream_tracker_status {
    bool enabled;               
    size_t events;              
    char *filename;             
    float fps;                  
    size_t frames_queued;       
    size_t frames_dropped;      
    size_t frames_processed;    
    char *stream_id;            
} roc_stream_tracker_status;

typedef roc_stream_tracker_status *roc_stream_tracker_status_array;

ROC_EXPORT void roc_free_stream_tracker_status_array(
                    roc_stream_tracker_status_array *stream_tracker_status_array,
                    size_t status_count);

ROC_EXPORT roc_error roc_video_service_status(roc_video_service video_service,
                                              roc_stream_tracker_status_array *stream_tracker_statuses,
                                              size_t *num_stream_tracker_statuses,
                                              bool *done,
                                              size_t *pending_transmissions);

ROC_EXPORT roc_error roc_video_service_add_stream(roc_video_service video_service,
                                                  const char *new_stream_configuration);

ROC_EXPORT roc_error roc_video_service_update_stream(roc_video_service video_service,
                                                     const char *updated_stream_configuration);

ROC_EXPORT roc_error roc_video_service_remove_stream(roc_video_service video_service,
                                                     const char *removed_stream_id);

ROC_EXPORT roc_error roc_video_service_read_configuration(roc_video_service video_service,
                                                          roc_string *current_configuration);

ROC_EXPORT roc_error roc_free_video_service(roc_video_service video_service);

#endif // !defined(SWIG) || defined(SWIG_ROC_VIDEO)
 // end of roc_video_service

ROC_EXPORT roc_error roc_cluster(roc_gallery gallery,
                                 size_t k,
                                 const roc_candidate *neighbors,
                                 roc_similarity similarity,
                                 bool incremental,
                                 roc_progress progress);

typedef struct roc_adjudication
{
    roc_template_index a; 
    roc_template_index b; 
    bool same_person; 
} roc_adjudication;

ROC_EXPORT roc_error roc_adjudicate_knn(size_t gallery_size,
                                        size_t k,
                                        roc_candidate *neighbors,
                                        const roc_adjudication *adjudications,
                                        size_t num_adjudications);

ROC_EXPORT roc_error roc_adjudicate_gallery(roc_gallery gallery,
                                            const roc_adjudication *adjudications,
                                            size_t num_adjudications);

ROC_EXPORT roc_error roc_extend(roc_gallery gallery,
                                roc_const_gallery probes,
                                roc_similarity threshold,
                                bool spawn);

ROC_EXPORT roc_error roc_consolidate(roc_gallery gallery,
                                     roc_similarity max_similarity,
                                     size_t max_count);

ROC_EXPORT roc_error roc_consolidate_persons(roc_gallery gallery,
                                             roc_similarity max_similarity);

ROC_EXPORT roc_error roc_consolidate_fingerprints(roc_gallery gallery);

ROC_EXPORT roc_error roc_get_template_id(roc_gallery gallery,
                                         roc_template_index index,
                                         roc_template_id *template_id);

ROC_EXPORT roc_error roc_get_person_id(roc_gallery gallery,
                                       roc_template_index index,
                                       roc_person_id *person_id);

ROC_EXPORT roc_error roc_set_person_id(roc_gallery gallery,
                                       roc_template_index index,
                                       roc_person_id person_id);

ROC_EXPORT roc_error roc_all_person_ids(roc_const_gallery gallery,
                                        roc_person_id_array *person_ids,
                                        size_t *num_person_ids);

ROC_EXPORT roc_error roc_unique_person_ids(roc_const_gallery gallery,
                                           roc_person_id_array *person_ids,
                                           size_t *num_person_ids);

ROC_EXPORT roc_error roc_indicies_for_person_id(roc_const_gallery gallery,
                                                roc_person_id person_id,
                                                roc_template_index_array
                                                             *template_indicies,
                                                size_t *num_template_indicies);

ROC_EXPORT roc_error roc_indicies_for_media_id(roc_const_gallery gallery,
                                               roc_media_id media_id,
                                               roc_template_index_array
                                                             *template_indicies,
                                               size_t *num_template_indicies);
 // end of identity_discovery

ROC_EXPORT roc_error roc_set_server_credentials(const char *private_key,
                                                const char *certificate);

ROC_EXPORT roc_error roc_get_ssl_protocols(roc_string *protocols);

ROC_EXPORT roc_error roc_set_ssl_protocols(const char *protocol_string);

ROC_EXPORT roc_error roc_get_ssl_ciphers(roc_string *ciphers);

ROC_EXPORT roc_error roc_set_ssl_ciphers(const char *cipher_string);

ROC_EXPORT roc_error roc_set_server_protocol(bool use_http);

typedef struct roc_server_type *roc_server;

ROC_EXPORT roc_error roc_start_gallery_server(roc_gallery gallery,
                                              int port,
                                              roc_server *server);

typedef struct roc_amqp_server_type *roc_amqp_server;

ROC_EXPORT roc_error roc_start_amqp_server(roc_amqp_server *server,
                                           roc_string location,
                                           roc_gallery gallery,
                                           const char *local_gallery_path,
                                           roc_string stream_name,
                                           int64_t offset);

ROC_EXPORT roc_error roc_stop_amqp_server(roc_amqp_server *server);

ROC_EXPORT roc_error roc_gallery_exec_protobuf(roc_gallery gallery,
                                               uint8_t *request_data,
                                               size_t request_len,
                                               roc_buffer *response_data,
                                               size_t *response_len);

ROC_EXPORT roc_error roc_gallery_server_update(roc_server server,
                                               roc_gallery new_gallery,
                                               const char *
                                                         original_gallery_file);

ROC_EXPORT roc_error roc_start_database_server(roc_database database,
                                               int port,
                                               roc_server *server);

ROC_EXPORT roc_error roc_start_template_pipe_server(roc_template_pipe
                                                                  template_pipe,
                                                    int port,
                                                    roc_server *server);

ROC_EXPORT roc_error roc_start_floating_license_server(int port,
                                                       roc_server *server);


ROC_EXPORT roc_error roc_server_connections(roc_server server,
                                            int *connections);

ROC_EXPORT roc_error roc_stop_server(roc_server *server);
 // end of remote_data_structures

struct ROC_EXPORT roc_template_pipe_type
#ifdef __cplusplus
{
    virtual ~roc_template_pipe_type();

    virtual roc_error transmit(const roc_template &template_) = 0;

    virtual roc_error transmit_event(const roc_event &event)
    {
        return transmit(event.probe);
    }

    virtual roc_error transmit_data(const uint8_t *data,
                                    size_t length,
                                    roc_hash key)
    {
        (void) data;
        (void) length;
        (void) key;
        return NULL;
    }

    virtual roc_error transmit_image(const uint8_t *data,
                                     size_t length,
                                     roc_media_id media_id,
                                     roc_camera_id camera,
                                     roc_time timestamp)
    {
        (void) camera;
        (void) timestamp;
        return transmit_data(data, length, media_id);
    }

    virtual roc_error transmit_video(const uint8_t *data,
                                     size_t length,
                                     roc_media_id media_id,
                                     roc_camera_id camera,
                                     roc_time start,
                                     roc_time stop)
    {
        (void) camera;
        (void) start;
        (void) stop;
        return transmit_data(data, length, media_id);
    }

    virtual roc_error transmit_log(const char *message)
    {
        (void) message;
        return NULL;
    }

    virtual roc_error transmit_status(roc_stream_tracker_status_array status,
                                      size_t status_count,
                                      bool done,
                                      size_t pending_transmissions,
                                      float gpu_utilization_percent,
                                      float gpu_memory_used_percent)
    {
        (void) status;
        (void) status_count;
        (void) done;
        (void) pending_transmissions;
        (void) gpu_utilization_percent;
        (void) gpu_memory_used_percent;
        return NULL;
    }
}
#endif // _cplusplus
;

ROC_EXPORT roc_error roc_open_template_pipe(const char *template_pipe_file,
                                            bool append,
                                            bool keep_alive,
                                            bool replay_on_failure,
                                            const char *sender_id,
                                            roc_template_pipe *template_pipe);

ROC_EXPORT roc_error roc_template_pipe_transmit(roc_template_pipe template_pipe,
                                                const roc_template template_);

ROC_EXPORT roc_error roc_template_pipe_transmit_event(
                         roc_template_pipe template_pipe,
                         const roc_event event);

ROC_EXPORT roc_error roc_template_pipe_transmit_data(
                         roc_template_pipe template_pipe,
                         const uint8_t *data,
                         size_t length,
                         roc_hash key);

ROC_EXPORT roc_error roc_template_pipe_transmit_image(
                         roc_template_pipe template_pipe,
                         const uint8_t *data,
                         size_t length,
                         roc_media_id media_id,
                         roc_camera_id camera_id,
                         roc_time timestamp);

ROC_EXPORT roc_error roc_template_pipe_transmit_video(
                         roc_template_pipe template_pipe,
                         const uint8_t *data,
                         size_t length,
                         roc_media_id media_id,
                         roc_camera_id camera_id,
                         roc_time start,
                         roc_time stop);

ROC_EXPORT roc_error roc_template_pipe_transmit_log(
                         roc_template_pipe template_pipe,
                         const char *message);

ROC_EXPORT roc_error roc_set_template_pipe_log_callback(roc_template_pipe template_pipe);

ROC_EXPORT void roc_template_pipe_log_callback(const char *message);

ROC_EXPORT size_t roc_pending_transmissions();

ROC_EXPORT roc_error roc_template_pipe_transmit_status(roc_template_pipe template_pipe,
                         roc_stream_tracker_status_array status,
                         size_t status_count,
                         bool done,
                         size_t pending_transmissions,
                         float gpu_utilization_percent,
                         float gpu_memory_used_percent);

ROC_EXPORT roc_error roc_close_template_pipe(roc_template_pipe *template_pipe);

ROC_EXPORT roc_error roc_decode_protobuf_template(
                         const uint8_t *input_byte_array,
                         size_t length,
                         roc_template *template_);

ROC_EXPORT roc_error roc_encode_protobuf_template(const roc_template template_,
                         roc_buffer *buffer,
                         size_t *buffer_length);
 // end of template_io

#endif // !SWIG_ROC_VIDEO

#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
#pragma clang pop
#endif // defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE

#ifdef __cplusplus
}
#endif

#endif // ROC_H