sfe_core.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "sfe_core_detection.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum SFEHwidMethod {
  SFE_HWID_METHOD_AUTO = 0,
  SFE_HWID_METHOD_DISK_ID = 1,
  SFE_HWID_METHOD_MAC = 2,
  SFE_HWID_METHOD_SERIAL_NUMBER = 3,
  SFE_HWID_METHOD_IMEI = 4,
  SFE_HWID_METHOD_SM_BIOS = 5,
  SFE_HWID_METHOD_AMAZON = 6,
  SFE_HWID_METHOD_APP_ID = 7,
  SFE_HWID_METHOD_PHY = 8,
  SFE_HWID_METHOD_MAC_ADDRESS = 9,
  SFE_HWID_METHOD_SYS = 10,
  SFE_HWID_METHOD_ANDROID_ID = 11,
} SFEHwidMethod;
 
typedef enum SFELicenseType {
  SFE_LICENSE_TYPE_NONE = 0,
  SFE_LICENSE_TYPE_FILE = 1,
  SFE_LICENSE_TYPE_MEMORY = 2,
  SFE_LICENSE_TYPE_TOKEN = 3,
  SFE_LICENSE_TYPE_ENV = 4,
} SFELicenseType;
 
typedef enum SFEImageFormat {
  SFE_IMAGE_FORMAT_PNG = 0,
  SFE_IMAGE_FORMAT_JPEG = 1,
  SFE_IMAGE_FORMAT_GIF = 2,
  SFE_IMAGE_FORMAT_TGA = 3,
  SFE_IMAGE_FORMAT_BMP = 4,
  SFE_IMAGE_FORMAT_QOI = 5,
} SFEImageFormat;
 
typedef struct SFEImage {
  size_t width;
  size_t height;
  unsigned char *data;
} SFEImage;
 
typedef SFEImage SFEImageView;
 
typedef struct SFEImageInfo {
  size_t width;
  size_t height;
  SFEImageFormat format;
} SFEImageInfo;
 
typedef void *SFEError;
 
typedef void *SFESolver;
 
typedef struct SFESolverParameter {
  const char *name;
  const char *value;
} SFESolverParameter;
 
typedef struct SFEEntity {
  uint8_t uuid[16];
} SFEEntity;
 
typedef struct SFETemplateIdentificationCandidate {
  float score;
  size_t index;
} SFETemplateIdentificationCandidate;
 
typedef struct SFEEntityIdentificationCandidate {
  float score;
  size_t index;
  SFEEntity entity;
} SFEEntityIdentificationCandidate;
 
const char *const sfeVersion();
 
void sfeErrorFree(SFEError error);
 
const char *sfeErrorMessage(SFEError error);
 
SFEError sfeHwidGet(char *out_hwid, size_t *in_out_hwid_len,
                    SFEHwidMethod method);
 
SFEError sfeLicenseValidate(void);
 
SFEError sfeLicenseType(SFELicenseType *out_license_type);
 
void sfeLicenseSet(const unsigned char *data, const size_t data_len);
 
SFEError sfeSolverCreate(const char *solver_file,
                         const SFESolverParameter *solver_parameters,
                         size_t solver_parameters_count, SFESolver *out_solver);
 
void sfeSolverFree(SFESolver solver);
 
SFEError sfeImageDecode(const unsigned char *data, size_t data_len,
                        SFEImage *out_image);
 
SFEError sfeImageEncode(SFEImageView image, SFEImageFormat image_format,
                        unsigned char *out_data, size_t *in_out_data_len);
 
SFEError sfeImageInfo(const unsigned char *data, size_t data_len,
                      SFEImageInfo *out_image_info);
 
void sfeImageFree(SFEImage image);
 
SFEError sfeImageColorTranspose(SFEImageView image, SFEImage *out_image);
 
SFEError sfeImageResize(SFEImageView image, size_t width, size_t height,
                        SFEImage *out_image);
 
SFEError sfeImageResizeWithAspectRatio(SFEImageView image, size_t width,
                                       size_t height, SFEImage *out_image);
 
// CORE DETECTION
 
SFEError sfeDetect(SFESolver solver, SFEImageView image, float threshold,
                   SFEDetection *out_detections,
                   size_t *in_out_detection_count);
 
// CORE TRACKING
 
typedef void *SFETracker;
 
enum SFETrackedState {
  SFE_TRACKED_STATE_NEW = 0,
  SFE_TRACKED_STATE_TRACKED = 1,
  SFE_TRACKED_STATE_LOST = 2,
  SFE_TRACKED_STATE_REMOVED = 3,
};
 
typedef struct SFETracked {
  SFEDetection detection;
  uint64_t id;
  SFEEntity uuid;
  enum SFETrackedState state;
} SFETracked;
 
SFEError
sfeDetectionTrackerCreate(float new_track_threshold, float track_high_threshold,
                          float track_low_threshold, float match_threshold,
                          uint64_t max_time_lost, SFETracker *out_tracker);
 
void sfeDetectionTrackerFree(SFETracker tracker);
 
SFEError sfeDetectionTrackerUpdate(SFETracker tracker,
                                   const SFEDetection *detections,
                                   size_t detections_count,
                                   SFETracked *out_tracked,
                                   size_t *in_out_tracked_count);
 
SFEError sfeDetectionTrackerLost(SFETracker tracker, SFEEntity *out_entities,
                                 size_t *in_out_entities_count);
 
SFEError sfeDetectionTrackerRemoved(SFETracker tracker, SFEEntity *out_entities,
                                    size_t *in_out_entities_count);
 
#ifdef __cplusplus
} // extern "C"
#endif