PerfectlyClearPro.h

Go to the documentation of this file.

#ifndef __PERFECTLYCLEARPRO_H__
#define __PERFECTLYCLEARPRO_H__
#ifdef __cplusplus
extern "C" {
#endif

#ifdef _LINUX
#define BOOL int
#define ULONG unsigned long
#define UINT  unsigned int
#define TRUE  1
#define FALSE 0
//#define NULL  0
#endif

#define NRRETCODE(x) (x & 0x000000FF)
#define CORERETCODE(x) ((x >> 8) & 0x000000FF)
#define FBRETCODE(x) ((x >> 16) & 0x000000FF)
#define RERETCODE(x) ((x >> 24) & 0x000000FF)
#define PFCINTERNAL void*

typedef BOOL (*PFC_PROGRESS)(int iPercent);

typedef enum {
    PFC_PixelFormat24bppRGB,
    PFC_PixelFormat24bppBGR,
    PFC_PixelFormat32bppABGR,
    PFC_PixelFormat48bppRGB,
    PFC_PixelFormat64bppARGB,
    PFC_PixelFormat32bppARGB,
    PFC_PixelFormat48bppBGR,
    PFC_PixelFormat64bppABGR
} PFCPIXELFORMAT;

typedef enum {
    ENGINESTATUS_OK = 0,                                        
    ENGINESTATUS_FB_LIBRARY_LOAD_FAIL = 1,  
    ENGINESTATUS_FB_FUNCTION_NOT_FOUND = 2  
} PFCENGINESTATUS;

typedef enum {
    CALC_CORE = 1,          
    CALC_NR = 2,            
    CALC_FB = 4,            
    CALC_RE = 8,            
    CALC_ALL = 15,          
    CALC_NOTINTCALC = 16,   
    CALC_NOFAE = 32,        
    CALC_FAEHISPEED = 64    
} PFCFEATURE;

typedef enum {
    PRESET_BEAUTIFY, 
    PRESET_BEAUTIFYPLUS, 
    PRESET_DETAILS, 
    PRESET_VIVID, 
    PRESET_INTELLIGENTAUTO 
} PFCPRESETID;

typedef struct {
    int x; 
    int y; 
}
PFCPOINT;

typedef struct {
    int left; 
    int top;  
    int width;  
    int height; 
}
PFCRECT;

typedef struct {
    PFCPOINT leftEye;   
    PFCPOINT rightEye;  
    PFCRECT  face;      
}
PFCFBFACEINFO;

typedef struct PFCFaceRect{
    PFCRECT rect;       
    PFCRECT rcEyeL;     
    PFCRECT rcEyeR;     
    PFCRECT rcMouth;    
    PFCPOINT ptEyeL;    
    PFCPOINT ptEyeR;    
    int angle;          
    int blinkLevel;     
    int blinkLevelL;    
    int blinkLevelR;    
    int childLevel;     
    int confidence;     
    int smileLevel;     
    int yawAngle;       
    int FAE[3];         
    int widthImage;     
    int heightImage;    
    struct PFCFaceRect *pNext;  
} PFCFACERECT;
typedef PFCFACERECT* LPPFCFACERECT;

typedef struct {
    PFCINTERNAL pEngine;    
    PFCENGINESTATUS status; 
} PFCENGINE;

typedef struct {
    int width;              
    int height;             
    int stride;             
    PFCPIXELFORMAT format;  
    unsigned char *data;    
} PFCIMAGE;

typedef enum {
    TINTCORRECT_AGGRESSIVE,     
    TINTCORRECT_DEFAULT,        
    TINTCORRECT_CONSERVATIVE,   
    TINTCORRECT_STRONGEST       
}
TINTCORRECTION;

typedef enum {
    HIGH_CONTRAST,      
    HIGH_DEFINITION     
}
CONTRASTMODE;

typedef enum {
    DCF_STANDARD,   
    DCF_VIVID       
}
DCFMODE;

typedef enum {
    AGGRESSIVENESS_CONSERVATIVE,    
    AGGRESSIVENESS_MODERATE,        
    AGGRESSIVENESS_AGGRESSIVE       
}
AGGRESSIVENESS;

typedef enum {
    BIAS_NONE,                  
    BIAS_ASIAN_PREFERENCE,      
    BIAS_AVERAGE_PREFERENCE,    
    BIAS_BRIGHTER_PREFERENCE    
}
BIASMODE;

typedef enum {
    SKINMODE_FACE = 1,  
    SKINMODE_BODY       
}
SKINMODE;

typedef enum {
    SKINSMOOTHTYPE_SUBTLE = 1,  
    SKINSMOOTHTYPE_DEFAULT,     
    SKINSMOOTHTYPE_SUPERSMOOTH  
}
SKINSMOOTHTYPE;

typedef enum {
    SKINTONINGTYPE_WHITE = 1,   
    SKINTONINGTYPE_PALE,        
    SKINTONINGTYPE_WARM,        
    SKINTONINGTYPE_TAN,         
    SKINTONINGTYPE_FOUNDATION   
}
SKINTONINGTYPE;

typedef enum {
    LIPSHARPENTYPE_FINE = 1,    
    LIPSHARPENTYPE_MEDIUM,      
    LIPSHARPENTYPE_COARSE       
}
LIPSHARPENTYPE;

typedef enum {
    PFC_NR_SUCCESS,             
    PFC_NR_NOTENABLED,          
    PFC_NR_FULLRES_REQUIRED,    
    PFC_NR_CANCELLED,           
    PFC_NR_ERRBITMAP,           
    PFC_NR_ERRSETTINGS,         
    PFC_NR_MISC_ERROR,          
    PFC_NR_NOTFOUND             
} PFCNR_STATUS;

typedef enum {
    PFC_CORE_SUCCESS,               
    PFC_CORE_NOTENABLED,            
    PFC_CORE_CANCELLED,             
    PFC_CORE_NOSOURCEIMAGE,         
    PFC_CORE_INSUFFICIENTMEMORY,    
    PFC_CORE_MONOLITHIMAGE,         
    PFC_CORE_BELOWMINSIZE           
} PFCCORE_STATUS;

typedef enum {
    PFC_FB_SUCCESS,                 
    PFC_FB_NOTENABLED,              
    PFC_FB_WARNING,                 
    PFC_FB_FULLRES_REQUIRED,        
    PFC_FB_CANCELLED,               
    PFC_FB_FUNCTION_ERROR,          
    PFC_FB_CREATE_ENGINE_FAILED,    
    PFC_FB_ANALYSIS_FAILED,         
    PFC_FB_NO_CORRECTION,           
    PFC_FB_NOT_EXECUTED,            
    PFC_FB_NOT_AVAILABLE            
} PFCFB_STATUS;

typedef enum {
    PFC_RE_SUCCESS,                 
    PFC_RE_NOTENABLED,              
    PFC_RE_FULLRES_REQUIRED,        
    PFC_RE_NOT_FOUND,               
    PFC_RE_GEN_ERROR,               
    PFC_RE_INVALID_PARAMETER,       
    PFC_RE_NO_MEMORY,               
    PFC_RE_CANCELLED,               
    PFC_RE_NOT_SUPPORTED            
} PFCRE_STATUS;

typedef enum {
    APPLY_SUCCESS = 0,                  
    APPLY_ERROR_PROFILE_MISSING = -1,   
    APPLY_ERROR_ENGINE_MISSING = -2,    
    APPLY_CANCELLED = -3,               
    APPLY_NOSOURCE = -4,                
    APPLY_BADFORMAT = -5,               
    APPLY_INVALIDLICENSE = -6           
} PFCAPPLYSTATUS;

typedef struct {
    BOOL bEnabled;                          
    BOOL bAbnormalTintRemoval;              
    TINTCORRECTION eTintMode;               
    float fTintScale;                       
    int iBlackEnhancement;                  
    BOOL bVibrancy;                         
    int iVibrancy;                          
    int iStrength;                          
    BOOL bContrast;                         
    CONTRASTMODE eContrastMode;             
    int iContrast;                          
    BIASMODE eBiasMode;                     
    float   fBiasScale;                     
    BOOL bSharpen;                          
    float fSharpenScale;                    
    BOOL bUseAutomaticStrengthSelection;    
    BOOL bUseFAE;                           
    AGGRESSIVENESS eAggressiveness;         
    int iMaxStrength;                       
    BOOL bInfrared;                         
    float fInfrared;                        
    BOOL  bLightDiffusion;                  
    float fLightDiffusion;                  
    BOOL  bDynamicRange;                    
    BOOL  bDCF;                             
    DCFMODE eDCFMode;                       
    float fDCF;                             
} PFCCOREPARAM;

typedef struct {
    BOOL bEnabled;                  
    BOOL bSmooth;                   
    int iSmoothLevel;               
    SKINMODE eSmoothMode;           
    SKINSMOOTHTYPE eSmoothType;     
    BOOL bEnlarge;                  
    int iEnlargeLevel;              
    BOOL bEnhance;                  
    int iEnhanceLevel;              
    BOOL bEyeCirc;                  
    int iEyeCirc;                   
    BOOL bTeeth;                    
    int iTeethLevel;                
    BOOL bBlemish;                  
    int iBlemish;                   
    BOOL bSlim;                     
    int iSlim;                      
    BOOL bDeFlash;                  
    int iDeFlash;                   
    BOOL bCatchLight;               
    int iCatchLight;                
    int iCatchLightMode;            
    BOOL bSkinToning;               
    int iSkinToning;                
    SKINMODE eSkinToningMode;       
    SKINTONINGTYPE eSkinToningType; 
    BOOL bLipSharpen;               
    int iLipSharpen;                
    LIPSHARPENTYPE eLipSharpenType; 
    BOOL bBlush;                    
    int iBlush;                     
} PFCFBPARAM;

typedef struct {
    BOOL bEnabled;          
    int iPreset;            
    int iStrengthOffset;    
    int iDetailOffset;      
} PFCNRPARAM;

typedef struct {
    BOOL bEnabled;          
} PFCREPARAM;

#define PFC3DLutGuidLength 32
typedef struct {
    char guid[PFC3DLutGuidLength + 1];  
    unsigned char strength;             
} PFC3DLutInfo;

enum PFCCORE_MASK_TYPE {
    MASK_NONE,            
    MASK_ALL,             
    MASK_RADIAL,          
    MASK_TOP,             
    MASK_BOTTOM,          
    MASK_ROUNDRECT        
};

typedef struct PFCCOREMask
{
    PFCCORE_MASK_TYPE type;
    float centerX;              
    float centerY;              
    float width;                
    float height;               
    float radius;               
    float feather;              
    float angle;                
    float transparency;         
    bool  invert;               
    // if two layers (top and bottom) - swap params between layers instead.
} PFCCOREMask;

typedef struct {
    // Image Ambulance
    bool bPreprocessEV;   
    int iPreprocessEV;   

    // built-in 3D luts
    int iNeutralDensity;   
    int iColorVibrancy;   
    PFC3DLutInfo lutInputCorrective;   
    PFC3DLutInfo lutInputSky;   
    PFC3DLutInfo lutInputFoliageGreen;   
    PFC3DLutInfo lutInputFoliageBrown;   
    // custom output 3D Lut
    PFC3DLutInfo lutOutput;   

    // Finishing
    int iFinishTemp;   
    int iFinishTint;   
    int iFinishExposure;   
    int iFinishBlacks;   
    int iFinishShadows;   
    int iFinishHighlights;   
    int iFinishWhites;   
    int iFinishSaturation;   
    int iFinishVibrancy;   
    int iFinishContrast;   
} PFCV3PARAM;

typedef struct {
    PFCCOREPARAM core;   
    PFCFBPARAM fb;   
    PFCNRPARAM nr;   
    PFCREPARAM re;   
#ifndef No_V3PARAM
    PFCV3PARAM v3;   
    PFCV3PARAM layer[3]; 
    PFCCOREMask mask[3]; 
#endif
} PFCPARAM;

typedef struct {
    PFCINTERNAL pPfcParam;   
    PFCINTERNAL pNoiseParam;   
    PFCINTERNAL pRedEyeParam;   
    PFCINTERNAL pSFBParam;   
    PFCINTERNAL pInternal;   

    PFCCORE_STATUS CORE_Status;   
    PFCNR_STATUS NR_Status;   
    PFCFB_STATUS FB_Status;   
    PFCRE_STATUS RE_Status;   

    int Status;   
} PFCIMAGEPROFILE;
#define PFCPROFILE PFCIMAGEPROFILE*

#define PFCBGPROFILE PFCINTERNAL

bool PFC_HasFaceBeautification(PFCENGINE *pEngine);

int PFC_FBFaceCount(PFCPROFILE pImageProfile);

LPPFCFACERECT PFC_EnumFAEFaceRect(PFCIMAGEPROFILE *pImageProfile, LPPFCFACERECT p);

bool PFC_IsNoiseDetected(PFCIMAGEPROFILE *pImageProfile, int iNoisePreset);

bool PFC_GetFaceInfo(PFCIMAGEPROFILE *pImageProfile, PFCFBFACEINFO *pFace, int index);

bool PFC_AbnormalTintDetected(PFCIMAGEPROFILE *pImageProfile, TINTCORRECTION eTintMethod);

void PFC_SetParam(PFCPARAM &param, PFCPRESETID id=PRESET_INTELLIGENTAUTO);

PFCAPPLYSTATUS PFC_Apply(PFCIMAGE *pImage, PFCENGINE *pEngine, PFCPROFILE pImageProfile, PFCPARAM &param, PFC_PROGRESS progfn=NULL, int iOpacity=100);

PFCAPPLYSTATUS PFC_ApplyLocal(PFCIMAGE *pImage, int xOffset, int yOffset, int widthOrig, int heightOrig, PFCENGINE *pEngine, PFCPROFILE pImageProfile, PFCPARAM &param, int iOpacity=100);

PFCPROFILE PFC_Calc(PFCIMAGE *pImage, PFCIMAGE *pImageds, PFCENGINE* pEngine, unsigned int feature=CALC_ALL, int iISO=-1, char *pCameraModel=NULL, PFCPROFILE pImageProfile=NULL, PFC_PROGRESS progfn=NULL, BOOL bRejectMonolith=TRUE);

PFCENGINE* PFC_CreateEngine();

void PFC_DestroyEngine(PFCENGINE* p);

void PFC_ReleaseProfile(PFCPROFILE pProfile);

int PFC_AutoCorrect(PFCIMAGE *pImage, PFCIMAGE *pImageds, PFCPARAM &param, int iISO=-1, char *pCameraModel=NULL, BOOL bFastFAE=FALSE, PFC_PROGRESS progfn=NULL);

int PFC_AutoCorrectPreset(PFCIMAGE *pImage, PFCIMAGE *pImageds, PFCPRESETID id=PRESET_INTELLIGENTAUTO, int iISO=-1, char *pCameraModel=NULL, BOOL bFastFAE=FALSE, PFC_PROGRESS progfn=NULL);

int PFC_ReadPresets(PFCPARAM &param, char *filename);

int PFC_ReadPresetsFromStream(PFCPARAM &param, const char *s);

void PFC_SetSingleThreadedEngine(PFCENGINE* p, bool bSingleThreaded);

void PFC_GetVersion(char* buf, int *len, bool bFormatted = false);

int PFC_Resize(PFCIMAGE *pImageSrc, PFCIMAGE *pImageDst);

int PFC_SetProtectionPath(const char*utf8FolderPath);

/* \brief Releases resources from PFC_SetProtectionPath function call
 */
void PFC_ReleaseProtectionPath();

PFCBGPROFILE PFC_CreateBGProfile();

void PFC_ReleaseBGProfile(PFCBGPROFILE pProfile);

void PFC_ResetBGProfile(PFCBGPROFILE pProfile);

void PFC_CombineBGProfile(void* pProfile1, void* pProfile2);

void PFC_ScaleBGProfile(void* pProfile, double scaleR, double scaleG, double scaleB);

int PFC_BGSyncCalc(PFCIMAGE *pImage, PFCENGINE *pEngine, PFCBGPROFILE pProfile, BOOL bFastFAE = TRUE);

int PFC_BGSyncApply(PFCIMAGE *pImage, PFCENGINE *pEngine, PFCBGPROFILE pProfile, BOOL bFastFAE = TRUE);

#ifdef __cplusplus
}
#endif
#endif //__PERFECTLYCLEARPRO_H__