PerfectlyClearAdapter.cs

Go to the documentation of this file.

using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Diagnostics;
using System.Drawing.Imaging;
using System.IO;
using System.Runtime.InteropServices;

namespace PerfectlyClearAdapter
{
public struct PFCPOINT
{
    public int x; 
    public int y; 
};

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

public struct PFCFBFACEINFO1
{
    public PFCPOINT leftEye;    
    public PFCPOINT rightEye;   
    public PFCRECT  face;       
};

public class PFCFBFACEINFO
{
    public PFCPOINT leftEye;    
    public PFCPOINT rightEye;   
    public PFCRECT face;    

    public PFCFBFACEINFO()
    {
        face.left = 0;
        face.top = 0;
        face.width = 0;
        face.height = 0;
        leftEye.x = 0;
        leftEye.y = 0;
        rightEye.x = 0;
        rightEye.y = 0;
    }
};

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

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

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

public enum PFCNR_STATUS
{
    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     
};

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

public enum PFCFB_STATUS
{
    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        
};

public enum PFCRE_STATUS
{
    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    
};

public enum PFCAPPLYSTATUS
{
    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       
};

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

public enum AGGRESSIVENESS
{
    CONSERVATIVE,   
    MODERATE,       
    AGGRESSIVE,     
};

public enum DCFMODE
{
    FIDELITY_STANDARD,  
    FIDELITY_VIVID  
};

public enum CONTRASTMODE
{
    HIGH_CONTRAST,  
    HIGH_DEFINITION 
};

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

public enum ADPTRRETURNCODE
{
    SUCCESS,        
    WARNING,        
    INTERNALERROR,  
    WRONG_FORMAT    
};

public enum SKINMODE
{
    SKINMODE_FACE = 1,  
    SKINMODE_BODY   
};

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

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

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

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

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

public unsafe struct PFCNRPARAM
{
    public bool bEnabled;           
    public int  iPreset;            
    public int  iStrengthOffset;    
    public int  iDetailOffset;      
};

public struct PFCREPARAM

{
    public bool bEnabled;           
};

// V3 additions
public enum PFCCORE_MASK_TYPE
{
    PFCCORE_MASK_NONE,            // 0.0 everywhere, don't apply
    PFCCORE_MASK_ALL,             // 1.0 everywhere (background)
    PFCCORE_MASK_RADIAL,          // ellipse
    PFCCORE_MASK_TOP,             // linear from 1.0 on top
    PFCCORE_MASK_BOTTOM,          // linear from 1.0 on bottom
    PFCCORE_MASK_ROUNDRECT        // rounded rect
};

/* Description of mask for grad filter, all coordinates are relative (Y/height, X/width) in final crop-rotated image */
public unsafe struct PFCCOREMask
{
    public PFCCORE_MASK_TYPE type;      
    public float centerX;              
    public float centerY;              
    public float width;                
    public float height;               
    public float radius;               
    public float feather;              
    public float angle;                
    public float transparency;         
    public bool invert;               
};

[StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct PFC3DLutInfo
{
    [MarshalAsAttribute(UnmanagedType.ByValTStr, SizeConst = 33)]
    public string guid;

    public byte strength; // C++ unsigned char
}

public unsafe struct PFCV3PARAM
{
    // Image Ambulance
    public bool bPreprocessEV;   
    public int iPreprocessEV;   
    // built-in 3D luts
    public int iNeutralDensity;   
    public int iColorVibrancy;   
    public PFC3DLutInfo lutInputCorrective;   
    public PFC3DLutInfo lutInputSky;   
    public PFC3DLutInfo lutInputFoliageGreen;   
    public PFC3DLutInfo lutInputFoliageBrown;   
    // custom output 3D Lut
    public PFC3DLutInfo lutOutput;   
    // Finishing
    public int iFinishTemp;   
    public int iFinishTint;   
    public int iFinishExposure;   
    public int iFinishBlacks;   
    public int iFinishShadows;   
    public int iFinishHighlights;   
    public int iFinishWhites;   
    public int iFinishSaturation;   
    public int iFinishVibrancy;   
    public int iFinishContrast;   
};

[StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct PFCPARAM
{
    public PFCCOREPARAM core;   
    public PFCFBPARAM fb;   
    public PFCNRPARAM nr;   
    public PFCREPARAM re;   
    public PFCV3PARAM v3;   
    public PFCV3PARAM layer0;   
    public PFCV3PARAM layer1;   
    public PFCV3PARAM layer2;   
    public PFCCOREMask mask0;   
    public PFCCOREMask mask1;   
    public PFCCOREMask mask2;   
};

public struct PFCSTATUS
{
    public PFCCORE_STATUS CORE_Status;
    public PFCNR_STATUS NR_Status;
    public PFCFB_STATUS FB_Status;
    public PFCRE_STATUS RE_Status;
    public int Status;
}

    public unsafe class PerfectlyClear : IDisposable
    {
        protected unsafe struct PFCENGINE
        {
            void* pEngine;  
            public uint status; 
        };
        protected unsafe struct PerfectlyClearImageTransfer
        {
            public int width;       
            public int height;      
            public int rowBytes;    
            public int columnBytes; 
            public int data1;       
            public int data2;       
            public int data3;       
        };

        protected unsafe struct PFCIMAGEPROFILE
        {
            void* pPfcParam;    
            void* pNoiseParam;  
            void* pRedEyeParam; 
            void* pSFBParam;    
            void* pInternal;    

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

            public int Status;  
        };

        protected unsafe struct PFCIMAGE
        {
            public int width;           
            public int height;          
            public int stride;          
            public PFCPIXELFORMAT format;   
            public void* data;          
        };


        protected PFCENGINE* m_pEngine;
        protected PFCIMAGEPROFILE* m_pProfile;
        public PFCPARAM m_Param;
        public PFCSTATUS LastStatus;

        public PerfectlyClear(string path = "")
        {
            m_pEngine = null;
            m_pProfile = null;

#if PROTECTION_ENABLED
            try
            {
                byte* pLicpath = null;
                if (path != null)
                {
                    pLicpath = GetCharBuffer(path);
                }

                int status = PFC_SetProtectionPath(pLicpath);
                //Trace.WriteLine("status " + status.ToString());
            }
            catch (Exception ex)
            {
                Trace.WriteLine(ex.Message);
            }
#endif
            try
            {
                m_pEngine = PFC_CreateEngine();
                if (m_pEngine != null)
                {
                    LastStatus.Status = (int)(*m_pEngine).status;
                }
            }
            catch (Exception ex)
            {
                Trace.WriteLine(ex.Message);
            }

            PFC_SetParam(ref m_Param, PFCPRESETID.PRESET_INTELLIGENTAUTO);
        }

        ~PerfectlyClear()
        {
#if PROTECTION_ENABLED
            PFC_ReleaseProtectionPath();
#endif
            Dispose(false);
        }

        public unsafe ADPTRRETURNCODE Calc(ref Bitmap bm)
        {
            return Calc(ref bm, PFCFEATURE.CALC_ALL, -1, null);
        }

        public unsafe ADPTRRETURNCODE Calc(ref Bitmap bm, ref Bitmap bmds)
        {
            return Calc(ref bm, ref bmds, PFCFEATURE.CALC_ALL, -1, null);
        }

        public unsafe ADPTRRETURNCODE Calc(ref Bitmap bm, PFCFEATURE feature)
        {
            return Calc(ref bm, feature, -1, null);
        }

        public unsafe ADPTRRETURNCODE Calc(ref Bitmap bm, ref Bitmap bmds, PFCFEATURE feature)
        {
            return Calc(ref bm, ref bmds, feature, -1, null);
        }

        public unsafe ADPTRRETURNCODE Calc(ref Bitmap bm, PFCFEATURE feature, int ISO, string CameraModel)
        {
            BitmapData bd = null;
            Byte* pBase = null;
            bd = LockBitmapData(ref bm);
            if (bd.PixelFormat != PixelFormat.Format24bppRgb &&
                bd.PixelFormat != PixelFormat.Format32bppArgb &&
                bd.PixelFormat != PixelFormat.Format48bppRgb &&
                bd.PixelFormat != PixelFormat.Format64bppArgb)
            {
                ReleaseBitmapData(ref bm, ref bd);
                return ADPTRRETURNCODE.WRONG_FORMAT;
            }
            pBase = (Byte*)bd.Scan0.ToPointer();

            PFCIMAGE im;
            im.width = bd.Width;
            im.height = bd.Height;
            im.stride = bd.Stride;
            switch (bd.PixelFormat)
            {
                default:
                case PixelFormat.Format24bppRgb: im.format = PFCPIXELFORMAT.PFC_PixelFormat24bppRGB; break;
                case PixelFormat.Format32bppArgb: im.format = PFCPIXELFORMAT.PFC_PixelFormat32bppARGB; break;
                case PixelFormat.Format48bppRgb: im.format = PFCPIXELFORMAT.PFC_PixelFormat48bppRGB; break;
                case PixelFormat.Format64bppArgb: im.format = PFCPIXELFORMAT.PFC_PixelFormat64bppARGB; break;
            }
            im.data = (void*)pBase;

            if (m_pProfile != null)
                PFC_ReleaseProfile(m_pProfile);

            byte* pModel = null;
            if (CameraModel != null)
            {
                pModel = GetCharBuffer(CameraModel);
            }
            m_pProfile = PFC_Calc(&im, null, m_pEngine, feature, ISO, pModel, null, null, 1);

            FreeCharBuffer(pModel);

            ReleaseBitmapData(ref bm, ref bd);

            LastStatus.NR_Status = (*m_pProfile).NR_Status;
            LastStatus.CORE_Status = (*m_pProfile).CORE_Status;
            LastStatus.FB_Status = (*m_pProfile).FB_Status;
            LastStatus.RE_Status = (*m_pProfile).RE_Status;
            LastStatus.Status = (*m_pProfile).Status;

            return (LastStatus.Status == 0) ? ADPTRRETURNCODE.SUCCESS : ADPTRRETURNCODE.WARNING;
        }

        public unsafe ADPTRRETURNCODE Calc(ref Bitmap bm, ref Bitmap bmds, PFCFEATURE feature, int ISO, string CameraModel)
        {
            BitmapData bd = null;
            Byte* pBase = null;
            bd = LockBitmapData(ref bm);
            if (bd.PixelFormat != PixelFormat.Format24bppRgb &&
                bd.PixelFormat != PixelFormat.Format32bppArgb &&
                bd.PixelFormat != PixelFormat.Format48bppRgb &&
                bd.PixelFormat != PixelFormat.Format64bppArgb)
            {
                ReleaseBitmapData(ref bm, ref bd);
                return ADPTRRETURNCODE.WRONG_FORMAT;
            }
            pBase = (Byte*)bd.Scan0.ToPointer();

            PFCIMAGE im;
            im.width = bd.Width;
            im.height = bd.Height;
            im.stride = bd.Stride;
            switch (bd.PixelFormat)
            {
                default:
                case PixelFormat.Format24bppRgb: im.format = PFCPIXELFORMAT.PFC_PixelFormat24bppRGB; break;
                case PixelFormat.Format32bppArgb: im.format = PFCPIXELFORMAT.PFC_PixelFormat32bppARGB; break;
                case PixelFormat.Format48bppRgb: im.format = PFCPIXELFORMAT.PFC_PixelFormat48bppRGB; break;
                case PixelFormat.Format64bppArgb: im.format = PFCPIXELFORMAT.PFC_PixelFormat64bppARGB; break;
            }
            im.data = (void*)pBase;

            BitmapData bdds = null;
            bdds = LockBitmapData(ref bmds);
            if (bdds.PixelFormat != PixelFormat.Format24bppRgb &&
                bdds.PixelFormat != PixelFormat.Format32bppArgb &&
                bdds.PixelFormat != PixelFormat.Format48bppRgb &&
                bdds.PixelFormat != PixelFormat.Format64bppArgb)
            {
                ReleaseBitmapData(ref bmds, ref bdds);
                return ADPTRRETURNCODE.WRONG_FORMAT;
            }
            pBase = (Byte*)bdds.Scan0.ToPointer();

            PFCIMAGE imds;
            imds.width = bdds.Width;
            imds.height = bdds.Height;
            imds.stride = bdds.Stride;
            switch (bdds.PixelFormat)
            {
                default:
                case PixelFormat.Format24bppRgb: imds.format = PFCPIXELFORMAT.PFC_PixelFormat24bppRGB; break;
                case PixelFormat.Format32bppArgb: imds.format = PFCPIXELFORMAT.PFC_PixelFormat32bppARGB; break;
                case PixelFormat.Format48bppRgb: imds.format = PFCPIXELFORMAT.PFC_PixelFormat48bppRGB; break;
                case PixelFormat.Format64bppArgb: imds.format = PFCPIXELFORMAT.PFC_PixelFormat64bppARGB; break;
            }
            imds.data = (void*)pBase;

            if (m_pProfile != null)
                PFC_ReleaseProfile(m_pProfile);

            byte* pModel = null;
            if (CameraModel != null)
            {
                pModel = GetCharBuffer(CameraModel);
            }
            m_pProfile = PFC_Calc(&im, &imds, m_pEngine, feature, ISO, pModel, null, null, 1);

            FreeCharBuffer(pModel);

            ReleaseBitmapData(ref bm, ref bd);
            ReleaseBitmapData(ref bmds, ref bdds);

            LastStatus.NR_Status = (*m_pProfile).NR_Status;
            LastStatus.CORE_Status = (*m_pProfile).CORE_Status;
            LastStatus.FB_Status = (*m_pProfile).FB_Status;
            LastStatus.RE_Status = (*m_pProfile).RE_Status;
            LastStatus.Status = (*m_pProfile).Status;

            return (LastStatus.Status == 0) ? ADPTRRETURNCODE.SUCCESS : ADPTRRETURNCODE.WARNING;
        }

        public unsafe PFCAPPLYSTATUS Apply(ref Bitmap bm)
        {
            return Apply(ref bm, 100);
        }

        public unsafe PFCAPPLYSTATUS Apply(ref Bitmap bm, int iOpacity)
        {
            if (m_pProfile == null)
            {
                return PFCAPPLYSTATUS.APPLY_ERROR_PROFILE_MISSING;
            }

            BitmapData bd = null;
            Byte* pBase = null;
            bd = LockBitmapData(ref bm);
            if (bd.PixelFormat != PixelFormat.Format24bppRgb &&
                bd.PixelFormat != PixelFormat.Format32bppArgb &&
                bd.PixelFormat != PixelFormat.Format48bppRgb &&
                bd.PixelFormat != PixelFormat.Format64bppArgb)
            {
                ReleaseBitmapData(ref bm, ref bd);
                return PFCAPPLYSTATUS.APPLY_BADFORMAT;
            }
            pBase = (Byte*)bd.Scan0.ToPointer();

            PFCIMAGE im;
            im.width = bd.Width;
            im.height = bd.Height;
            im.stride = bd.Stride;
            switch (bd.PixelFormat)
            {
                default:
                case PixelFormat.Format24bppRgb: im.format = PFCPIXELFORMAT.PFC_PixelFormat24bppRGB; break;
                case PixelFormat.Format32bppArgb: im.format = PFCPIXELFORMAT.PFC_PixelFormat32bppARGB; break;
                case PixelFormat.Format48bppRgb: im.format = PFCPIXELFORMAT.PFC_PixelFormat48bppRGB; break;
                case PixelFormat.Format64bppArgb: im.format = PFCPIXELFORMAT.PFC_PixelFormat64bppARGB; break;
            }
            im.data = (void*)pBase;

            PFCAPPLYSTATUS ret = PFC_Apply(&im, m_pEngine, m_pProfile, ref m_Param, null, iOpacity);

            if (ret > 0)
            {
                int code = (int)ret;
                // Get individual return codes
                LastStatus.NR_Status = (PFCNR_STATUS)(code & 0x000000FF);
                LastStatus.CORE_Status = (PFCCORE_STATUS)((code >> 8) & 0x000000FF);
                LastStatus.FB_Status = (PFCFB_STATUS)((code >> 16) & 0x000000FF);
                LastStatus.RE_Status = (PFCRE_STATUS)((code >> 24) & 0x000000FF);
                LastStatus.Status = code;
            }

            ReleaseBitmapData(ref bm, ref bd);
            return ret;
        }

        public unsafe PFCAPPLYSTATUS ApplyLocal(ref Bitmap bm, int xOffset, int yOffset, int widthOrig, int heightOrig)
        {
            return ApplyLocal(ref bm, xOffset, yOffset, widthOrig, heightOrig, 100);
        }

        public unsafe PFCAPPLYSTATUS ApplyLocal(ref Bitmap bm, int xOffset, int yOffset, int widthOrig, int heightOrig, int iOpacity)
        {
            BitmapData bd = null;
            Byte* pBase = null;
            bd = LockBitmapData(ref bm);
            if (bd.PixelFormat != PixelFormat.Format24bppRgb &&
                bd.PixelFormat != PixelFormat.Format32bppArgb &&
                bd.PixelFormat != PixelFormat.Format48bppRgb &&
                bd.PixelFormat != PixelFormat.Format64bppArgb)
            {
                ReleaseBitmapData(ref bm, ref bd);
                return PFCAPPLYSTATUS.APPLY_BADFORMAT;
            }
            pBase = (Byte*)bd.Scan0.ToPointer();

            PFCIMAGE im;
            im.width = bd.Width;
            im.height = bd.Height;
            im.stride = bd.Stride;
            switch (bd.PixelFormat)
            {
                default:
                case PixelFormat.Format24bppRgb: im.format = PFCPIXELFORMAT.PFC_PixelFormat24bppRGB; break;
                case PixelFormat.Format32bppArgb: im.format = PFCPIXELFORMAT.PFC_PixelFormat32bppARGB; break;
                case PixelFormat.Format48bppRgb: im.format = PFCPIXELFORMAT.PFC_PixelFormat48bppRGB; break;
                case PixelFormat.Format64bppArgb: im.format = PFCPIXELFORMAT.PFC_PixelFormat64bppARGB; break;
            }
            im.data = (void*)pBase;

            PFCAPPLYSTATUS ret = PFC_ApplyLocal(&im, xOffset, yOffset, widthOrig, heightOrig, m_pEngine, m_pProfile, ref m_Param, iOpacity);

            ReleaseBitmapData(ref bm, ref bd);
            return ret;
        }

        public int AutoCorrect(ref Bitmap bm)
        {
            return AutoCorrect(ref bm, -1, null, false);
        }

        public int AutoCorrect(ref Bitmap bm, ref Bitmap bmds)
        {
            return AutoCorrect(ref bm, ref bmds, -1, null, false);
        }

        public int AutoCorrect(ref Bitmap bm, int ISO, string CameraModel, bool bFastFAE)
        {
            PFCFEATURE feature = 0;
            if (m_Param.nr.bEnabled)
                feature |= PFCFEATURE.CALC_NR;
            if (m_Param.core.bEnabled)
                feature |= PFCFEATURE.CALC_CORE;
            if (m_Param.fb.bEnabled)
                feature |= PFCFEATURE.CALC_FB;
            if (m_Param.re.bEnabled)
                feature |= PFCFEATURE.CALC_RE;
            if (!m_Param.core.bAbnormalTintRemoval)
                feature |= PFCFEATURE.CALC_NOTINTCALC;
            // Any FAE optimization
            if (m_Param.core.bUseFAE)
            {
                if (bFastFAE)
                    feature |= PFCFEATURE.CALC_FAEHISPEED;
            }
            else
            {
                feature |= PFCFEATURE.CALC_NOFAE;
            }

            ADPTRRETURNCODE ret = Calc(ref bm, feature, ISO, CameraModel);
            // Process image regardless of return code
            PFCAPPLYSTATUS aret = Apply(ref bm);

            if (ret != ADPTRRETURNCODE.SUCCESS && ret != ADPTRRETURNCODE.WARNING)
            {
                PFCNR_STATUS retNR = LastStatus.NR_Status;
                if (retNR == PFCNR_STATUS.PFC_NR_NOTFOUND || retNR == PFCNR_STATUS.PFC_NR_NOTENABLED)
                    retNR = PFCNR_STATUS.PFC_NR_SUCCESS;

                PFCCORE_STATUS retCORE = LastStatus.CORE_Status;
                if (retCORE == PFCCORE_STATUS.PFC_CORE_NOTENABLED)
                    retCORE = PFCCORE_STATUS.PFC_CORE_SUCCESS;

                PFCFB_STATUS retFB = LastStatus.FB_Status;
                if (retFB == PFCFB_STATUS.PFC_FB_NOTENABLED || retFB == PFCFB_STATUS.PFC_FB_WARNING)
                    retFB = PFCFB_STATUS.PFC_FB_SUCCESS;

                PFCRE_STATUS retRE = LastStatus.RE_Status;
                if (retRE == PFCRE_STATUS.PFC_RE_NOTENABLED || retRE == PFCRE_STATUS.PFC_RE_NOT_FOUND)
                    retRE = PFCRE_STATUS.PFC_RE_SUCCESS;

                int retInt = (((((((int)retRE << 8) | (int)retFB) << 8) | (int)retCORE) << 8) | (int)retNR);
                return retInt;
            }
            else
            {
                return (int)aret;
            }
        }

        public int AutoCorrect(ref Bitmap bm, ref Bitmap bmds, int ISO, string CameraModel, bool bFastFAE)
        {
            PFCFEATURE feature = 0;
            if (m_Param.nr.bEnabled)
                feature |= PFCFEATURE.CALC_NR;
            if (m_Param.core.bEnabled)
                feature |= PFCFEATURE.CALC_CORE;
            if (m_Param.fb.bEnabled)
                feature |= PFCFEATURE.CALC_FB;
            if (m_Param.re.bEnabled)
                feature |= PFCFEATURE.CALC_RE;
            if (!m_Param.core.bAbnormalTintRemoval)
                feature |= PFCFEATURE.CALC_NOTINTCALC;
            // Any FAE optimization
            if (m_Param.core.bUseFAE)
            {
                if (bFastFAE)
                    feature |= PFCFEATURE.CALC_FAEHISPEED;
            }
            else
            {
                feature |= PFCFEATURE.CALC_NOFAE;
            }

            ADPTRRETURNCODE ret = Calc(ref bm, ref bmds, feature, ISO, CameraModel);
            // Process image regardless of return code
            PFCAPPLYSTATUS aret = Apply(ref bm);

            if (ret != ADPTRRETURNCODE.SUCCESS && ret != ADPTRRETURNCODE.WARNING)
            {
                PFCNR_STATUS retNR = LastStatus.NR_Status;
                if (retNR == PFCNR_STATUS.PFC_NR_NOTFOUND || retNR == PFCNR_STATUS.PFC_NR_NOTENABLED)
                    retNR = PFCNR_STATUS.PFC_NR_SUCCESS;

                PFCCORE_STATUS retCORE = LastStatus.CORE_Status;
                if (retCORE == PFCCORE_STATUS.PFC_CORE_NOTENABLED)
                    retCORE = PFCCORE_STATUS.PFC_CORE_SUCCESS;

                PFCFB_STATUS retFB = LastStatus.FB_Status;
                if (retFB == PFCFB_STATUS.PFC_FB_NOTENABLED || retFB == PFCFB_STATUS.PFC_FB_WARNING)
                    retFB = PFCFB_STATUS.PFC_FB_SUCCESS;

                PFCRE_STATUS retRE = LastStatus.RE_Status;
                if (retRE == PFCRE_STATUS.PFC_RE_NOTENABLED || retRE == PFCRE_STATUS.PFC_RE_NOT_FOUND)
                    retRE = PFCRE_STATUS.PFC_RE_SUCCESS;

                int retInt = (((((((int)retRE << 8) | (int)retFB) << 8) | (int)retCORE) << 8) | (int)retNR);
                return retInt;
            }
            else
            {
                return (int)aret;
            }
        }

        public int AutoCorrect(ref Bitmap bm, string pathPreset)
        {
            int retCode = ReadPresets(pathPreset);
            if (retCode == 0)
            {
                return AutoCorrect(ref bm, -1, null, false);
            }
            return retCode-1000;
        }

        public int AutoCorrect(ref Bitmap bm, ref Bitmap bmds, string pathPreset)
        {
            int retCode = ReadPresets(pathPreset);
            if (retCode == 0)
            {
                return AutoCorrect(ref bm, ref bmds, -1, null, false);
            }
            return retCode - 1000;
        }

        public int AutoCorrect(ref Bitmap bm, string pathPreset, int ISO, string CameraModel, bool bFastFAE)
        {
            int retCode = ReadPresets(pathPreset);
            if (retCode == 0)
            {
                return AutoCorrect(ref bm, ISO, CameraModel, bFastFAE);
            }
            return retCode - 1000;
        }

        public int AutoCorrect(ref Bitmap bm, ref Bitmap bmds, string pathPreset, int ISO, string CameraModel, bool bFastFAE)
        {
            int retCode = ReadPresets(pathPreset);
            if (retCode == 0)
            {
                return AutoCorrect(ref bm, ref bmds, ISO, CameraModel, bFastFAE);
            }
            return retCode - 1000;
        }

        public void SetParam(PFCPRESETID id)
        {
            PFC_SetParam(ref m_Param, id);
        }

        public int ReadPresets(string path)
        {
            try
            {
                byte* presetpath = null;
                if (path != null)
                {
                    presetpath = GetCharBuffer(path);
                }

                // PFC_ReadPresets return code
                //  0  -  Success
                // -1  -  Attribute errors
                // -2  -  Unable to open file
                // -3  -  File read error.
                // -4  -  Parse error.
                // -5  -  Cannot convert text.
                // -6  -  No text node.
                // -7  -  Element depth exceeded.
                int status = PFC_ReadPresets(ref m_Param, presetpath);
                //Trace.WriteLine("status " + status.ToString());
                return status;
            }
            catch (Exception ex)
            {
                Trace.WriteLine(ex.Message);
            }
            return -8;
        }

        public int ReadPresetsFromStream(FileStream fs)
        {
            try
            {
                long len = fs.Length;
                byte[] buffer = new byte[len + 1];
                int size = (int)len;
                fs.Read(buffer, 0, size);
                buffer[size] = 0;
                byte* b = GetCharBuffer(buffer);
                // PFC_ReadPresetsFromStream return codes
                //  0  -  success
                // -3  -  Stream read error.
                // -4  -  Parse error.
                int status = PFC_ReadPresetsFromStream(ref m_Param, b);
                FreeCharBuffer(b);
                return status;
            }
            catch (Exception ex)
            {
                Trace.WriteLine(ex.Message);
            }
            return -8;
        }

        public bool HasFaceBeautification()
        {
            return PFC_HasFaceBeautification(m_pEngine);
        }

        public int FBFaceCount()
        {
            return PFC_FBFaceCount(m_pProfile);
        }

        public bool GetFaceInfo(ref PFCFBFACEINFO info, int index)
        {
            PFCFBFACEINFO1 fi;
            bool ret = PFC_GetFaceInfo(m_pProfile, &fi, index);
            info.face.left = fi.face.left;
            info.face.top = fi.face.top;
            info.face.width = fi.face.width;
            info.face.height = fi.face.height;
            info.leftEye.x = fi.leftEye.x;
            info.leftEye.y = fi.leftEye.y;
            info.rightEye.x = fi.rightEye.x;
            info.rightEye.y = fi.rightEye.y;
            return ret;
        }

        public bool AbnormalTintDetected(TINTCORRECTION eTintMethod)
        {
            return PFC_AbnormalTintDetected(m_pProfile, eTintMethod);
        }

        protected BitmapData LockBitmapData(ref Bitmap bm)
        {
            GraphicsUnit unit = GraphicsUnit.Pixel;
            RectangleF boundsF = bm.GetBounds(ref unit);
            Rectangle bounds = new Rectangle((int)boundsF.X,
                (int)boundsF.Y,
                (int)boundsF.Width,
                (int)boundsF.Height);

            BitmapData bitmapData =
                bm.LockBits(bounds, ImageLockMode.ReadWrite, bm.PixelFormat);
            return bitmapData;
        }

        protected void ReleaseBitmapData(ref Bitmap bm, ref BitmapData bitmapData)
        {
            bm.UnlockBits(bitmapData);
        }

        protected Bitmap DupBitmap(ref Bitmap bm)
        {
            PerfectlyClearImageTransfer tr, tr1;
            Byte* pBase = null;
            GraphicsUnit unit = GraphicsUnit.Pixel;
            RectangleF boundsF = bm.GetBounds(ref unit);
            Rectangle bounds = new Rectangle((int)boundsF.X,
                (int)boundsF.Y,
                (int)boundsF.Width,
                (int)boundsF.Height);
            BitmapData bd = bm.LockBits(bounds, ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
            Bitmap bm1 = new Bitmap(bd.Width, bd.Height, PixelFormat.Format24bppRgb);
            BitmapData bd1 = LockBitmapData(ref bm1);
            pBase = (Byte*)bd.Scan0.ToPointer();
            tr.columnBytes = (bd.PixelFormat == PixelFormat.Format24bppRgb) ? 3 : 4;
            tr.rowBytes = bd.Stride;
            tr.height = bd.Height;
            tr.width = bd.Width;
            tr.data1 = (int)(pBase + 2);
            tr.data2 = (int)(pBase + 1);
            tr.data3 = (int)pBase;
            pBase = (Byte*)bd1.Scan0.ToPointer();
            tr1.columnBytes = (bd1.PixelFormat == PixelFormat.Format24bppRgb) ? 3 : 4;
            tr1.rowBytes = bd1.Stride;
            tr1.height = bd1.Height;
            tr1.width = bd1.Width;
            tr1.data1 = (int)(pBase + 2);
            tr1.data2 = (int)(pBase + 1);
            tr1.data3 = (int)pBase;
            for (int i = 0; i < tr.height; i++)
            {
                for (int j = 0; j < tr.width; j++)
                {
                    ((Byte*)tr1.data1)[j * tr1.columnBytes] = ((Byte*)tr.data1)[j * tr.columnBytes];
                    ((Byte*)tr1.data2)[j * tr1.columnBytes] = ((Byte*)tr.data2)[j * tr.columnBytes];
                    ((Byte*)tr1.data3)[j * tr1.columnBytes] = ((Byte*)tr.data3)[j * tr.columnBytes];
                }
                tr.data1 += (int)tr.rowBytes;
                tr.data2 += (int)tr.rowBytes;
                tr.data3 += (int)tr.rowBytes;
                tr1.data1 += (int)tr1.rowBytes;
                tr1.data2 += (int)tr1.rowBytes;
                tr1.data3 += (int)tr1.rowBytes;
            }
            ReleaseBitmapData(ref bm1, ref bd1);
            ReleaseBitmapData(ref bm, ref bd);
            return bm1;
        }

        protected Bitmap BW2RGB(ref Bitmap bm)
        {
            Byte* pBase = null;
            Byte* pBase1 = null;
            GraphicsUnit unit = GraphicsUnit.Pixel;
            RectangleF boundsF = bm.GetBounds(ref unit);
            Rectangle bounds = new Rectangle((int)boundsF.X,
                (int)boundsF.Y,
                (int)boundsF.Width,
                (int)boundsF.Height);
            BitmapData bd = bm.LockBits(bounds, ImageLockMode.ReadOnly, PixelFormat.Format8bppIndexed);
            Bitmap bm1 = new Bitmap(bd.Width, bd.Height, PixelFormat.Format24bppRgb);
            BitmapData bd1 = LockBitmapData(ref bm1);
            pBase = (Byte*)bd.Scan0.ToPointer();
            pBase1 = (Byte*)bd1.Scan0.ToPointer();
            for (int i = 0; i < bd.Height; i++)
            {
                for (int j = 0; j < bd.Width; j++)
                {
                    pBase1[j * 3] = pBase[j];
                    pBase1[j * 3 + 1] = pBase[j];
                    pBase1[j * 3 + 2] = pBase[j];
                }
                pBase += bd.Stride;
                pBase1 += bd1.Stride;
            }
            ReleaseBitmapData(ref bm1, ref bd1);
            ReleaseBitmapData(ref bm, ref bd);
            return bm1;
        }

        public Bitmap ReadImage(string filename)
        {
            Bitmap bm = null;
            Bitmap myBitmap = new Bitmap(filename);
            if ((myBitmap.Flags & (int)ImageFlags.ColorSpaceYcck) != 0)
            {
                bm = DupBitmap(ref myBitmap);
                myBitmap.Dispose();
            }
            else
            {
                if (myBitmap.PixelFormat == PixelFormat.Format8bppIndexed)
                {
                    bm = BW2RGB(ref myBitmap);
                    myBitmap.Dispose();
                }
                else
                {
                    bm = myBitmap;
                }
            }
            return bm;
        }

        protected Bitmap GetStatImage(ref Bitmap bm, int iMaxDimension)
        {
            // Build max dim reference image
            bool bNeedResize = true;
            int w, h, w1, h1;
            w = bm.Width;
            h = bm.Height;
            // Calculate size of reference image. One dimension is 1024.
            if (w > h)
            {
                if (w <= iMaxDimension)
                    bNeedResize = false;
                w1 = iMaxDimension;
                h1 = w1 * h / w;
            }
            else
            {
                if (h <= iMaxDimension)
                    bNeedResize = false;
                h1 = iMaxDimension;
                w1 = h1 * w / h;
            }

            if (bNeedResize)
            {
                //
                //  Step 2.
                //      Create temporary bitmap to assist red eye analysis.
                //
                Bitmap bmds = new Bitmap(w1, h1, bm.PixelFormat);
                {
                    using (Graphics gr = Graphics.FromImage(bmds))
                    {
                        gr.SmoothingMode = SmoothingMode.HighQuality;
                        gr.InterpolationMode = InterpolationMode.HighQualityBicubic;
                        gr.PixelOffsetMode = PixelOffsetMode.HighQuality;
                        gr.DrawImage(bm, new Rectangle(0, 0, w1, h1));
                    }
                }

                return bmds;
            }
            else
            {
                Bitmap bmds = (Bitmap)bm.Clone();
                return bmds;
            }
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
            }

            if (m_pProfile != null)
            {
                PFC_ReleaseProfile(m_pProfile);
                m_pProfile = null;
            }

            if (m_pEngine != null)
            {
                PFC_DestroyEngine(m_pEngine);
                m_pEngine = null;
            }
        }

        protected byte* GetCharBuffer(byte[] s)
        {
            int i, iCount = s.Length;
            IntPtr _memory = IntPtr.Zero;
            _memory = Marshal.AllocHGlobal(iCount + 1);
            byte* p = (byte*)_memory;
            for (i = 0; i < iCount; i++)
            {
                p[i] = (byte)s[i];
            }
            p[iCount] = 0;

            return (byte*)p;
        }

        protected byte* GetCharBuffer(string s)
        {
            int i, iCount = s.Length;
            IntPtr _memory = IntPtr.Zero;
            _memory = Marshal.AllocHGlobal(iCount + 1);
            byte* p = (byte*)_memory;
            for (i = 0; i < iCount; i++)
            {
                p[i] = (byte)s[i];
            }
            p[iCount] = 0;

            return (byte*)p;
        }

        protected void FreeCharBuffer(byte* p)
        {
            IntPtr _memory = (IntPtr)p;
            Marshal.FreeHGlobal(_memory);
        }

#if ADAPTER64BIT
        [DllImport("PerfectlyClearPro.dll")]
        static extern int PFC_SetProtectionPath(byte* path);

        [DllImport("PerfectlyClearPro.dll")]
        static extern void PFC_ReleaseProtectionPath();

        [DllImport("PerfectlyClearPro.dll")]
        static extern PFCENGINE* PFC_CreateEngine();

        [DllImport("PerfectlyClearPro.dll")]
        static extern void PFC_DestroyEngine(PFCENGINE* p);

        [DllImport("PerfectlyClearPro.dll")]
        static extern void PFC_SetParam(ref PFCPARAM param, PFCPRESETID id);

        [DllImport("PerfectlyClearPro.dll")]
        static extern int PFC_ReadPresets(ref PFCPARAM param, byte* filename);

        [DllImport("PerfectlyClearPro.dll")]
        static extern int PFC_ReadPresetsFromStream(ref PFCPARAM param, byte* s);

        [DllImport("PerfectlyClearPro.dll")]
        static extern PFCIMAGEPROFILE* PFC_Calc(PFCIMAGE* pImage, PFCIMAGE* pImageds, PFCENGINE* pEngine, PFCFEATURE feature, int iISO, byte* pCameraModel, void* pImageProfile, void* progfn, int bRejectMonolith);

        [DllImport("PerfectlyClearPro.dll")]
        static extern void PFC_ReleaseProfile(void* pProfile);

        [DllImport("PerfectlyClearPro.dll")]
        static extern PFCAPPLYSTATUS PFC_Apply(PFCIMAGE* pImage, PFCENGINE* pEngine, void* pImageProfile, ref PFCPARAM param, void* progfn, int iOpacity);

        [DllImport("PerfectlyClearPro.dll")]
        static extern PFCAPPLYSTATUS PFC_ApplyLocal(PFCIMAGE* pImage, int xOffset, int yOffset, int widthOrig, int heightOrig, PFCENGINE* pEngine, PFCIMAGEPROFILE* pImageProfile, ref PFCPARAM param, int iOpacity);

        [DllImport("PerfectlyClearPro.dll")]
        static extern bool PFC_HasFaceBeautification(PFCENGINE* pEngine);

        [DllImport("PerfectlyClearPro.dll")]
        static extern int PFC_FBFaceCount(void* pImageProfile);

        [DllImport("PerfectlyClearPro.dll")]
        static extern bool PFC_GetFaceInfo(void* pImageProfile, PFCFBFACEINFO1* pFace, int index);

        [DllImport("PerfectlyClearPro.dll")]
        static extern bool PFC_AbnormalTintDetected(void* pImageProfile, TINTCORRECTION eTintMethod);
#endif

#if ADAPTER32BIT
        [DllImport("PerfectlyClearPro.dll", CallingConvention = CallingConvention.Cdecl)]
        static extern int PFC_SetProtectionPath(byte* path);

        [DllImport("PerfectlyClearPro.dll", CallingConvention = CallingConvention.Cdecl)]
        static extern void PFC_ReleaseProtectionPath();

        [DllImport("PerfectlyClearPro.dll", CallingConvention = CallingConvention.Cdecl)]
        static extern PFCENGINE* PFC_CreateEngine();

        [DllImport("PerfectlyClearPro.dll", CallingConvention = CallingConvention.Cdecl)]
        static extern void PFC_DestroyEngine(PFCENGINE* p);

        [DllImport("PerfectlyClearPro.dll", CallingConvention = CallingConvention.Cdecl)]
        static extern void PFC_SetParam(ref PFCPARAM param, PFCPRESETID id);

        [DllImport("PerfectlyClearPro.dll", CallingConvention = CallingConvention.Cdecl)]
        static extern int PFC_ReadPresets(ref PFCPARAM param, byte* filename);

        [DllImport("PerfectlyClearPro.dll", CallingConvention = CallingConvention.Cdecl)]
        static extern int PFC_ReadPresetsFromStream(ref PFCPARAM param, byte* s);

        [DllImport("PerfectlyClearPro.dll", CallingConvention = CallingConvention.Cdecl)]
        static extern PFCIMAGEPROFILE* PFC_Calc(PFCIMAGE* pImage, PFCIMAGE* pImageds, PFCENGINE* pEngine, PFCFEATURE feature, int iISO, byte* pCameraModel, void* pImageProfile, void* progfn, int bRejectMonolith);

        [DllImport("PerfectlyClearPro.dll", CallingConvention = CallingConvention.Cdecl)]
        static extern void PFC_ReleaseProfile(void* pProfile);

        [DllImport("PerfectlyClearPro.dll", CallingConvention = CallingConvention.Cdecl)]
        static extern PFCAPPLYSTATUS PFC_Apply(PFCIMAGE* pImage, PFCENGINE* pEngine, void* pImageProfile, ref PFCPARAM param, void* progfn, int iOpacity);

        [DllImport("PerfectlyClearPro.dll", CallingConvention = CallingConvention.Cdecl)]
        static extern PFCAPPLYSTATUS PFC_ApplyLocal(PFCIMAGE* pImage, int xOffset, int yOffset, int widthOrig, int heightOrig, PFCENGINE* pEngine, PFCIMAGEPROFILE* pImageProfile, ref PFCPARAM param, int iOpacity);

        [DllImport("PerfectlyClearPro.dll", CallingConvention = CallingConvention.Cdecl)]
        static extern bool PFC_HasFaceBeautification(PFCENGINE* pEngine);

        [DllImport("PerfectlyClearPro.dll", CallingConvention = CallingConvention.Cdecl)]
        static extern int PFC_FBFaceCount(void* pImageProfile);

        [DllImport("PerfectlyClearPro.dll", CallingConvention = CallingConvention.Cdecl)]
        static extern bool PFC_GetFaceInfo(void* pImageProfile, PFCFBFACEINFO1* pFace, int index);

        [DllImport("PerfectlyClearPro.dll", CallingConvention = CallingConvention.Cdecl)]
        static extern bool PFC_AbnormalTintDetected(void* pImageProfile, TINTCORRECTION eTintMethod);
#endif
    }
}