/*********************************************************/
//	Nkfl_Interface.H
//		Header File for Nikon File Library Interface.
//
//		This file defines the basic interface of Nikon File Library.
//
//		Copyright(c) 1999-2007, Nikon Corporation - All rights reserved.
/*********************************************************/
#ifndef _Nkfl_Interface_H
#define _Nkfl_Interface_H


/*********************************************************/
//	Function
/*********************************************************/
///////////////////////////////////////////////////////////
//	Declaration and definition for Entry Function of Nikon Browse Library
//
#ifdef _WINDOWS

#ifdef _cplusplus
extern "C"
{
#endif

	unsigned long __declspec(dllexport) WINAPI Nkfl_Entry(unsigned long ulCommand, void* pParam );
	typedef unsigned long __declspec(dllexport) WINAPI Nkfl_EntryProc( unsigned long ulCommand, void* pParam );
	typedef Nkfl_EntryProc *Nkfl_EntryProcPtr;

#ifdef _cplusplus
}
#endif

#else

	extern "C" unsigned long Nkfl_Entry(unsigned long ulCommand, void* pParam );
	typedef unsigned long Nkfl_EntryProc( unsigned long ulCommand, void* pParam );
	typedef Nkfl_EntryProc *Nkfl_EntryProcPtr;

#endif


///////////////////////////////////////////////////////////
//	Definition Callback function.
//
#ifdef _WINDOWS
	typedef unsigned long WINAPI NkflProgressProc( unsigned long ulDone, unsigned long ulTotal, void* pProgressParam );
	typedef NkflProgressProc* NkflProgressProcPtr;
#else
	typedef unsigned long NkflProgressProc( unsigned long ulDone, unsigned long ulTotal, void* pProgressParam );
	typedef NkflProgressProc* NkflProgressProcPtr;
#endif


///////////////////////////////////////////////////////////
#ifndef _WINDOWS
	typedef Rect RECT;
#endif

typedef	void*	NkflPtr;




/*********************************************************/
//	Structures.
/*********************************************************/
///////////////////////////////////////////////////////////
//	NkflLibraryParam
//		It's for kNkfl_Cmd_OpenLibrary
//
typedef struct tagNkflLibraryParam
{
	unsigned long	ulSize;					//	Size of structure
	unsigned long 	ulVersion;				//	Version
	unsigned long	ulVMMemorySize;			//	Size of vertual memory
	NkflPtr*		pNkflPtr;				//  Pointer of StratoObject
#ifdef _WINDOWS
	unsigned char	VMFileInfo[ MAX_PATH ];	//	Swap file info
#else
	AliasHandle		VMFileInfo;
#endif
} NkflLibraryParam, *NkflLibraryPtr;

///////////////////////////////////////////////////////////
//	NkflSessionParam
//		It's for kNkfl_Cmd_OpenSession and kNkfl_Cmd_CloseSession
//
typedef struct tagNkflSessionParam
{
	unsigned long	ulSize;					//	Size of structure
	unsigned long	ulSessionID;			//	ID value of session
	unsigned long	ulType;					//	File type (eNkflSource)
	void*			pFileInfo;				//	File Name or file Memory 
	unsigned long	ulFileSize;				//	Memory size
} NkflSessionParam, *NkflSessionPtr;

///////////////////////////////////////////////////////////
//	NkflFileInfoParam
//		It's for kNkfl_Cmd_GetImageInfo
//
typedef struct tagNkflFileInfoParam
{
	unsigned long	ulSize;					//	Size of structure
	unsigned long	ulSessionID;			//	ID value of session
	unsigned long	ulFormat;				//	File format (eNkflFormat)
} NkflFileInfoParam, *NkflFileInfoPtr;


///////////////////////////////////////////////////////////
//	NkflImageInfoParam
//		It's for kNkfl_Cmd_GetImageInfo, kNkfl_Cmd_GetOriginalInfo and kNkfl_Cmd_GetThumbnailInfo
//
typedef struct tagNkflImageInfoParam
{
	unsigned long	ulSize;					//	Size of structure
	unsigned long	ulSessionID;			//	ID value of session
	unsigned long	ulImageID;				//	Thumbnail ID
	unsigned long	ulWidth;				//	Image width
	unsigned long	ulHeight;				//	Image height
	unsigned long	ulByteDepth;			//	Image length
	unsigned long	ulColor;				//	Color (eNkflColor)
	unsigned long	ulOrientation;			//	Flip/Rotation (eNkflOrientation)
	double			dbResolution;			//	Resolution(for kNkfl_Cmd_GetImageInfo)
} NkflImageInfoParam, *NkflImageInfoPtr;

///////////////////////////////////////////////////////////
//	NkflImageParam
//		It's for kNkfl_Cmd_GetImageData and kNkfl_Cmd_GetThumbnailData
//
typedef struct tagNkflImageParam
{
	unsigned long	ulSize;					//	Size of structure
	unsigned long	ulSessionID;			//	ID value of session
	unsigned long	ulImageID;				//	Thumbnail ID
	RECT			rectArea;				//	Read Image rect
	unsigned long	ulDataSize;				//	Buffer size
	void*			pData;					//	Image buffer
	NkflProgressProc* pFunc;				//	Pointer of callback func
	void*			pProgressParam;			//	private data for callback func
} NkflImageParam, *NkflImagePtr;

///////////////////////////////////////////////////////////
//	NkflTagInfoParam
//		It's for kNkfl_Cmd_GetTagInfo
//
typedef struct tagNkflTagInfoParam
{
	unsigned long	ulSize;					//	Size of structure
	unsigned long	ulSessionID;			//	ID value of session
	unsigned long	ulCount;				//	Tag Count
	unsigned long*	pulTagList;				//	Tag List
} NkflTagInfoParam, *NkflTagInfoPtr;

///////////////////////////////////////////////////////////
//	NkflTagDataParam
//		It's for kNkfl_Cmd_GetTagData
//
typedef struct tagNkflTagDataParam
{
	unsigned long	ulSize;					//	Size of structure
	unsigned long	ulSessionID;			//	ID value of session
	unsigned long	ulTagID;				//	Tag ID (eNkflTag)
	unsigned long	ulTagType;				//	Tag Type (eNkflTagType)
	unsigned long	ulTagValue;				//	Tag Value
	unsigned long	ulTagLength;			//	Tag Length
	void*			pData;					//  Tag Data
} NkflTagDataParam, *NkflTagDataPtr;

/////////////////////////////////////////////////////////////
//	NkflTagParam_BitsPerSample
//		It's for kNkfl_Tag_BitsPerSample
//
typedef struct tagNkflTagParam_BitsPerSample
{
	unsigned long	ulSize;					//Size of Structure
	unsigned long	ulBitsPerSample[3];		//Bits per each component
}NkflTagParam_BitsPerSample,*NkflTagParam_BitsPerSamplePtr;

///////////////////////////////////////////////////////////
//	NkflTagParam_DateTime
//		It's for kNkfl_Tag_DateTime
//
typedef struct tagNkflTagParam_DateTime
{
	unsigned long	ulSize;					//	Size of structure
	unsigned long	ulYear;					//	Shot year
	unsigned long	ulMonth;				//	Shot month
	unsigned long	ulDay;					//	Shot day
	unsigned long	ulHour;					//	Shot hour
	unsigned long	ulMinute;				//	Shot minute
	double			dbSecond;				//	Shot second including subsecond
} NkflTagParam_DateTime, *NkflTagParam_DateTimePtr;

///////////////////////////////////////////////////////////
//	NkflTagParam_LensInfo
//		It's for kNkfl_Tag_LensInfo
//
typedef struct tagNkflTagParam_LensInfo
{
	unsigned long	ulSize;					//	Size of structure
	unsigned long	ulWideLength;			//	Focal length at minimum zoom
	unsigned long	ulTeleLength;			//	Focal length at maximum zoom
											//  When non-zoom lens, this is 0
	double			dbWideMaxAperture;		//	Maximum aperture at minimum zoom
	double			dbTeleMaxAperture;		//	Maximum aperture at maximum zoom
											//  When Max aperture is not varied, this is 0.0
} NkflLensInfo, *NkflLensInfoPtr;

////////////////////////////////////////////////////////////
//		NkflLensType
//		This structure is for kNkfl_Tag_LensType
//
typedef struct tagNkflTagParamLensType
{
    bool			bIsCPU;					// true = CPU(Nikon Lens), false = non-CPU or the other lenses.
    bool			bIsActiveDType;			// true = bIsDType is active
    bool			bIsDType;				// true = D type, false = conventional

	//for supporting Q50
	bool	        bIsGLense;			//	true:G-Lense		false:Normal
	bool	        bIsAntiVibration;	//  true:Anti-Vibration	false:Normal
	bool        	Reserved[3];		//for supporting Q50 5->3

} NkflLensType,*NkflLensTypePtr;

///////////////////////////////////////////////////////////
//	NkflTagParam_GPSPosition
//		It's for kNkfl_Tag_GPSLatitude and kNkfl_Tag_GPSLongitude
//
typedef struct tagNkflTagParam_GPSPosition
{
	unsigned long	ulSize;					//Size of Structure
	double			dbDegrees;			
	double			dbMinutes;
	double			dbSeconds;
}NkflTagParam_GPSPosition, *NkflTagParam_GPSPositionPtr;

///////////////////////////////////////////////////////////
//	NkflTagParam_GPSTimeStamp
//		It's for kNkfl_Tag_GPSTimeStamp
//
typedef struct tagNkflTagParam_GPSTimeStamp
{
	unsigned long	ulSize;					//Size of Structure
	unsigned long	ulHours;			
	unsigned long	ulMinutes;
	unsigned long	ulSeconds;
}NkflTagParam_GPSTimeStamp, *NkflTagParam_GPSTimeStampPtr;

//#####################################################################################
////////////////////////////////////////////////////////////
// NkflSplinePoint
//	It's for tagNkflTagParam_UserDefinedCurve structure
//
typedef struct tagNkflSplinePoint
{
	unsigned char	x;						//	Spline Point X ( 0 - 255 )
	unsigned char	y;						//	Spline Point Y ( 0 - 255 )
} NkflSplinePoint;
//#####################################################################################

//#####################################################################################
////////////////////////////////////////////////////////////
//  NkflTagParam_UserDefinedCurve
//		It's for kNkfl_Tag_NkUserDefinedCurve
//
typedef struct tagNkflTagParam_UserDefinedCurve
{
	unsigned long	ulSize;					//The size of this structure
	unsigned char	iID[2];					//	0x49, 0x5F
	unsigned char	iInputMin;				//	(Black Point)
	unsigned char	iInputMax;				//	(White Point)
	unsigned char	iOutputMin;
	unsigned char	iOutputMax;
	unsigned char	iGammaInteger;			//	integer portion ( 0 - 20 )
	unsigned char	iGammaFractional;		//	fractional portion ( 0 - 100 )
	unsigned char	iSplinePointNum;		//	Number of Spline Points ( 2 - 20 )
	NkflSplinePoint	SplinePoint[20];
	unsigned char	Reserved[15];
	unsigned char	LutData[2048];
} NkflTagParam_UserDefinedCurve,*NkflTagParam_UserDefinedCurvePtr;
//#####################################################################################

//#####################################################################################
////////////////////////////////////////////////////////////
//  NkflTagParam_WBMode
//		It's for kNkfl_Tag_NkWhiteBalance
//
typedef struct tagNkflTagParam_WBMode
{
	unsigned long	ulSize;					// size of this structure
	unsigned long	ulWBMode;				// WhilteBalance (eNkflWhiteBalance)
	unsigned long	ulColorTemperature;		// ulWBMode is kNkfl_WhiteBalance_ColorTemperature, set color temperature to this parameter
} NkflTagParam_WBMode, *NkflTagParam_WBModePtr;
//#####################################################################################

//#####################################################################################
////////////////////////////////////////////////////////////
//  NkflTagParam_ColorMatrix
//		It's for kNkfl_Tag_NkColorMatrixModulus
//
typedef struct tagNkflTagParam_ColorMatrix
{
	unsigned long	ulSize;					//	size of this structure
	double			dbMkr2;
	double			dbMkb2;
	double			dbMkr3;
	double			dbMkb3;
} NkflTagParam_ColorMatrix, *NkflTagParam_ColorMatrixPtr;
//#####################################################################################

///////////////////////////////////////////////////////////
//	NkflTagStringInfoParam
//		It's for kNkfl_Cmd_GetTagStringInfo
//
typedef struct tagNkflTagStringInfoParam
{
	unsigned long	ulSize;					//	Size of structure
	unsigned long	ulSessionID;			//	ID value of session
	unsigned long	ulLines;				//	Line count
	unsigned long	ulColumns;				//	Column count
} NkflTagStringInfoParam, *NkflTagStringInfoPtr;

///////////////////////////////////////////////////////////
//	NkflTagStringParam
//		It's for kNkfl_Cmd_GetTagString
//
typedef struct tagNkflTagStringParam
{
	unsigned long	ulSize;					//	Size of structure
	unsigned long	ulSessionID;			//	ID value of session
	unsigned long	ulLines;				//	Line number
	unsigned long	ulColumns;				//	Column number
	unsigned long	ulStringLength;			// 	String length
	unsigned long	ulLayoutLength;			//	Max string length in column
	void*			pData;					//	Data buffer
} NkflTagStringParam, *NkflTagStringPtr;


//=======================================================add 07/05/18 Yamaguchi.T
///////////////////////////////////////////////////////////
//	NkflColorTempRange
//		It's for kNkfl_Cmd_GetTagString
//
typedef struct tagNkflColorTempRangeParam
{
    unsigned long ulSize;
    unsigned long ulSessionID;
    unsigned long ulMWB;
    unsigned long ulDefalut;
    unsigned long ulMinColorTemp;
    unsigned long ulMaxColorTemp;
} NkflColorTempRangeParam, *NkflColorTempRangeParamPtr;

//=======================================================add 07/07/04 Yamaguchi.T
///////////////////////////////////////////////////////////
//	NkflRawDevelopmentInfo
//
typedef struct tagNkflRawDevelopmentInfo
{
    unsigned long ulSize;
    unsigned long ulSessionID;
    unsigned long ulRawDevelopmentInfo;
} NkflRawDevelopmentInfo, *NkflRawDevelopmentInfoPtr;

///////////////////////////////////////////////////////////
//	NkflRawDevelopmentParam
//		It's for kNkfl_Cmd_GetTagString
//
typedef struct tagNkflRawDevelopmentParam
{
    unsigned long ulSize;
    unsigned long ulSessionID;
    unsigned long ulRawDevelopment;
    void* pData;
} NkflRawDevelopmentParam, *NkflRawDevelopmentParamPtr;

///////////////////////////////////////////////////////////
//	NkflRawDevelopment_RawParameterSet
//		It's for kNkfl_Cmd_GetTagString
//
typedef struct tagNkflRawDevelopment_RawParameterSet
{
    unsigned long ulSize;
    unsigned long ulParamterSet;
} NkflRawDevelopment_RawParameterSet, *NkflRawDevelopment_RawParameterSetPtr;

typedef struct tagNkflRawDevelopment_RawQuality
{
    unsigned long ulSize;
    unsigned long ulQuality;
} NkflRawDevelopment_RawQuality, *NkflRawDevelopment_RawQualityPtr;

///////////////////////////////////////////////////////////
//	NkflRawDevelopment_ExpComp
//		It's for kNkfl_Cmd_GetTagString
//
typedef struct tagNkflRawDevelopment_ExpComp
{
    unsigned long ulSize;
    double dbExpComp;
} NkflRawDevelopment_ExpComp, *NkflRawDevelopment_ExpCompPtr;

///////////////////////////////////////////////////////////
//	NkflRGB
//		It's for kNkfl_Cmd_GetTagString
//
typedef struct tagNkflRGB
{
    unsigned long ulR;
    unsigned long ulG;
    unsigned long ulB;
} NkflRGB, *NkflRGBPtr;

///////////////////////////////////////////////////////////
//	NkflRawDevelopment_WBAdj
//		It's for kNkfl_Cmd_GetTagString
//
typedef struct tagNkflRawDevelopment_WBAdj
{
    unsigned long ulSize;
    unsigned long ulMWB;
    long lColorTemp;
    NkflRGB rgb;
} NkflRawDevelopment_WBAdj, *NkflRawDevelopment_WBAdjPtr;

///////////////////////////////////////////////////////////
//	NkflRawDevelopment_Tint
//		It's for kNkfl_Cmd_GetTagString
//
typedef struct tagNkflRawDevelopment_Tint
{
    unsigned long ulSize;
    long lTint; // -12 - 12
} NkflRawDevelopment_Tint, *NkflRawDevelopment_TintPtr;


///////////////////////////////////////////////////////////
//	NkflRawDevelopment_NR
//		It's for kNkfl_Cmd_GetTagString
//
typedef struct tagNkflRawDevelopment_NR
{
    unsigned long ulSize;
    unsigned long ulNRType;
} NkflRawDevelopment_NR, *NkflRawDevelopment_NRPtr;

///////////////////////////////////////////////////////////
//	NkflRawDevelopment_ColorMode
//		It's for kNkfl_Cmd_GetTagString
//
typedef struct tagNkflRawDevelopment_ColorMode
{
    unsigned long ulSize;
    unsigned long ulColorMode;
} NkflRawDevelopment_ColorMode, *NkflRawDevelopment_ColorModePtr;

///////////////////////////////////////////////////////////
//	NkflRawDevelopment_Sharpness
//		It's for kNkfl_Cmd_GetTagString
//
typedef struct tagNkflRawDevelopment_Sharpness
{
    unsigned long ulSize;
    unsigned long ulSharpness;
} NkflRawDevelopment_Sharpness, *NkflRawDevelopment_SharpnessPtr;

///////////////////////////////////////////////////////////
//	NkflRawDevelopment_ToneComp
//		It's for kNkfl_Cmd_GetTagString
//
typedef struct tagNkflRawDevelopment_ToneComp
{
    unsigned long ulSize;
    unsigned long ulToneComp;
} NkflRawDevelopment_ToneComp, *NkflRawDevelopment_ToneCompPtr;

///////////////////////////////////////////////////////////
//	NkflRawDevelopment_Saturation
//		It's for kNkfl_Cmd_GetTagString
//
typedef struct tagNkflRawDevelopment_Saturation
{
    unsigned long ulSize;
    unsigned long ulSaturation;
} NkflRawDevelopment_Saturation, *NkflRawDevelopment_SaturationPtr;

///////////////////////////////////////////////////////////
//	NkflRawDevelopment_HueAdj
//		It's for kNkfl_Cmd_GetTagString
//
typedef struct tagNkflRawDevelopment_HueAdj
{
    unsigned long ulSize;
    long ulHueAdj;
} NkflRawDevelopment_HueAdj, *NkflRawDevelopment_HueAdjPtr;

///////////////////////////////////////////////////////////
//	NkflRawDevelopment_FilterEffect
//		It's for kNkfl_Cmd_GetTagString
//
typedef struct tagNkflRawDevelopment_FilterEffect
{
    unsigned long ulSize;
    unsigned long ulFilterEffect;
} NkflRawDevelopment_FilterEffect, *NkflRawDevelopment_FilterEffectPtr;

///////////////////////////////////////////////////////////
//	NkflRawDevelopment_PictureControl
//
typedef struct tagNkflRawDevelopment_PictureControl
{
    unsigned long ulSize;
    unsigned long ulPictureControl;
    bool bApplyQuickAdjust;
    long lQuickAdjust;
    bool bSharpessAuto;
    unsigned long ulSharpness;
    bool bUserDefinedCurve;
    bool bContrastAuto;
    long lContrast;
    long lBrightness;
    bool bSaturationAuto;
    long lSaturation;
    long lHue;
    long lFilter;
    unsigned long lToning;
    long lToningIntensity;
} NkflRawDevelopment_PictureControl, *NkflRawDevelopment_PictureControlPtr;

///////////////////////////////////////////////////////////
//	NkflRawDevelopment_ActiveDLighting
//
typedef struct tagNkflRawDevelopment_ActiveDLighting
{
    unsigned long ulSize;
    unsigned long ulActiveDLighting;
} NkflRawDevelopment_ActiveDLighting, *NkflRawDevelopment_ActiveDLightingPtr;

///////////////////////////////////////////////////////////
//	NkflOutputProfileParam
//
typedef struct tagNkflOutputProfileParam
{
    unsigned long ulSize;
    unsigned long ulSessionID;
    unsigned long ulRenderingIntent;

#ifdef _WINDOWS
    unsigned char OutputProfile[MAX_PATH];
#else //macintosh
    AliasHandle OutputProfile;
#endif

} NkflOutputProfileParam, *NkflOutputProfileParamPtr;

//=======================================================add 07/05/18 Yamaguchi.T

/*********************************************************/
//	Enumlation values.
/*********************************************************/
///////////////////////////////////////////////////////////
//	eNkflCommand
//
enum eNkflCommand
{
	kNkfl_Cmd_OpenLibrary				= 0x0001,
	kNkfl_Cmd_CloseLibrary				= 0x0002,
	kNkfl_Cmd_OpenSession				= 0x0003,
	kNkfl_Cmd_CloseSession				= 0x0004,
	kNkfl_Cmd_GetFileInfo				= 0x0005,
	kNkfl_Cmd_GetOutputProfile          = 0x0016,//add 07/05/18 by Yamaguchi.T
	kNkfl_Cmd_SetOutputProfile          = 0x0116,//add 07/05/18 by Yamaguchi.T
	kNkfl_Cmd_GetImageInfo				= 0x0011,
	kNkfl_Cmd_SetImageInfo				= 0x0111,
	kNkfl_Cmd_GetRawDevelopmentInfo     = 0x0010,//add 07/05/18 by Yamaguchi.T
	kNkfl_Cmd_RawDevelopment            = 0x0110,//add 07/05/18 by Yamaguchi.T
	kNkfl_Cmd_GetRawDevelopmentParam    = 0x0210,//add 07/05/18 by Yamaguchi.T
	kNkfl_Cmd_GetImageData				= 0x0012,
	kNkfl_Cmd_GetThumbnailCount			= 0x0025,
	kNkfl_Cmd_GetThumbnailInfo			= 0x0021,
	kNkfl_Cmd_SetThumbnailInfo			= 0x0121,
	kNkfl_Cmd_GetThumbnailData			= 0x0022,
	kNkfl_Cmd_GetOriginalInfo			= 0x0031,
	kNkfl_Cmd_GetTagInfo				= 0x0051,
	kNkfl_Cmd_GetTagData				= 0x0052,
	kNkfl_Cmd_GetTagStringInfo			= 0x0041,
	kNkfl_Cmd_GetTagString				= 0x0042,
	kNkfl_Cmd_GetColorTempRange         = 0x0018 //add 07/05/18 by Yamaguchi.T
};

///////////////////////////////////////////////////////////
//	eNkflSource
//
enum eNkflSource
{
	kNkfl_Source_FileName				= 0x0001,
	kNkfl_Source_FSSpec					= 0x0002,
	kNkfl_Source_Memory					= 0x0004
};

///////////////////////////////////////////////////////////
//	eNkflFormat
//
enum eNkflFormat
{
	kNkfl_Format_None					= 0x000000,
	kNkfl_Format_JPEG					= 0x000020,
	kNkfl_Format_TIFF					= 0x000001,
//	kNkfl_Format_BMP					= 0x000002,// 07/05/18 by Yamaguchi.T
//	kNkfl_Format_PICT					= 0x000003,// 07/05/18 by Yamaguchi.T
	kNkfl_Format_NEF					= 0x100000
//	kNkfl_Format_QT_MOVIE				= 0x010000// 07/05/18 by Yamaguchi.T
};

///////////////////////////////////////////////////////////
//	eNkflColor
//
enum eNkflColor
{
	kNkfl_Color_Gray					= 0x0002,
	kNkfl_Color_RGB_Gray				= 0x0003,	// For 3 plane GrayScale images
	kNkfl_Color_CMYK_Gray				= 0x0004,   // support only reading
	kNkfl_Color_RGB						= 0x0020,   
	kNkfl_Color_CMYK					= 0x0022,   // support only reading
	kNkfl_Color_Lch						= 0x0023,   // not support
	kNkfl_Color_Lab						= 0x0024    // not support
};

///////////////////////////////////////////////////////////
// eNkflRawDevelopment
// 07/05/18 added by Yamaguchi
enum eNkflRawDevelopment
{
    kNkfl_RawDevelopment_RawParameterSet    = 0x0001,
    kNkfl_RawDevelopment_RawQuality         = 0x0002,
    kNkfl_RawDevelopment_ExpComp            = 0x0004,
    kNkfl_RawDevelopment_WBAdjustment       = 0x0008,
    kNkfl_RawDevelopment_Tint               = 0x0010,
    kNkfl_RawDevelopment_NR                 = 0x0020,
    kNkfl_RawDevelopment_PictureControl     = 0x0040,
    kNkfl_RawDevelopment_ColorMode          = 0x0080,
    kNkfl_RawDevelopment_Sharpness          = 0x0100,
    kNkfl_RawDevelopment_ToneComp           = 0x0200,
    kNkfl_RawDevelopment_Saturation         = 0x0400,
    kNkfl_RawDevelopment_HueAdjustment      = 0x0800,
    kNkfl_RawDevelopment_FilterEffect       = 0x1000,
    kNkfl_RawDevelopment_ActiveDLighting    = 0x2000, // add 070709 for D3/D300
};

///////////////////////////////////////////////////////////
// eNkflRawParameterSet
// 07/05/18 added by Yamaguchi
enum eNkflRawParameterSet
{
    kNkfl_RawParameterSet_AsShot            = 0x0001,
    kNkfl_RawParameterSet_LastSaveSetting   = 0x0002
};

///////////////////////////////////////////////////////////
// eNkflRawQuality
// 07/05/18 added by Yamaguchi
enum eNkflRawQuality
{
    kNkfl_RawQuality_High           = 0x0001,
    kNkfl_RawQuality_Low            = 0x0002,
    kNkfl_RawQuality_LowResolution  = 0x0003
};

// ============= 07/05/21 added by Yamaguchi =========== //
///////////////////////////////////////////////////////////
// 
enum eNkflWB
{
    kNkfl_WB_AsShot         = 0x0001,
    kNkfl_WB_GrayPoint      = 0x0002,
    kNkfl_WB_Auto           = 0x1000,
    kNkfl_WB_Incandescent   = 0x0100,
    kNkfl_WB_Flourescent    = 0x1002,       // Flourescent = HCFFlourescent
    kNkfl_WB_HCFlourescent  = 0x0400,
    kNkfl_WB_DirectSunLight = 0x0200,
    kNkfl_WB_Flash          = 0x0500,
    kNkfl_WB_Cloudy         = 0x0202,
    kNkfl_WB_Shade          = 0x0201
};

enum eNkflNR
{
    kNkfl_NR_AsShot = 1,
    kNkfl_NR_OFF    = 0,
    kNkfl_NR_Normal = 2,
    kNkfl_NR_High   = 3,
    kNkfl_NR_Low    = 4
};

enum eNkflPictureControl
{
    kNkfl_PictureControl_AsShot     = 1,
    kNkfl_PictureControl_Standard   = 2,
    kNkfl_PictureControl_Neutral    = 3,
    kNkfl_PictureControl_Vivid      = 4,
    kNkfl_PictureControl_Monochrome = 5,
    kNkfl_PictureControl_D2XModeI	= 6,
    kNkfl_PictureControl_D2XModeII	= 7,
    kNkfl_PictureControl_D2XModeIII	= 8
};

enum eNkflColorMode
{
    kNkfl_ColorMode_AsShot      = 0x0001,
    kNkfl_ColorMode_ModeI       = 0x0002,
    kNkfl_ColorMode_ModeII      = 0x0003,
    kNkfl_ColorMode_ModeIII     = 0x0004,
    kNkfl_ColorMode_ModeIa      = 0x0005,
    kNkfl_ColorMode_ModeIIIa    = 0x0006,
    kNkfl_ColorMode_BW          = 0x0007
};

enum eNkflSharpness
{
    kNkfl_Sharpness_AsShot      = 0x0001,
    kNkfl_Sharpness_None        = 0xFFFF,
    kNkfl_Sharpness_Normal      = 0x0002,
    kNkfl_Sharpness_Low         = 0x0003,
    kNkfl_Sharpness_MediumLow   = 0x0004,
    kNkfl_Sharpness_MediumHigh  = 0x0005,
    kNkfl_Sharpness_High        = 0x0006
};

enum eNkflSaturation
{
    kNkfl_Saturation_AsShot     = 1,
    kNkfl_Saturation_Normal     = 2,
    kNkfl_Saturation_Moderate   = 3,
    kNkfl_Saturation_Enhanced   = 4
};

enum eNkflToneComp
{
    kNkfl_ToneComp_AsShot               = 0x0001,
    kNkfl_ToneComp_Normal               = 0x0002,
    kNkfl_ToneComp_LowContrast          = 0x0003,
    kNkfl_ToneComp_MediumLow            = 0x0004,
    kNkfl_ToneComp_MediumHigh           = 0x0005,
    kNkfl_ToneComp_HighContrast         = 0x0006,
    kNkfl_ToneComp_UserDefinedCurve     = 0x0007
};

enum eNkflFilterEffect
{
    kNkfl_FilterEffect_OFF      = 0,
    kNkfl_FilterEffect_Yellow   = 1,
    kNkfl_FilterEffect_Orange   = 2,
    kNkfl_FilterEffect_Red      = 3,
    kNkfl_FilterEffect_Green    = 4,
    kNkfl_FilterEffect_AsShot   = 0xFF
};

enum eNkflToning
{
    kNkfl_Toning_AsShot     = 0x0000,
    kNkfl_Toning_BW         = 0x0080,
    kNkfl_Toning_Sepia      = 0x0081,
    kNkfl_Toning_Cyanotype  = 0x0082,
    kNkfl_Toning_Red        = 0x0083,
    kNkfl_Toning_Yellow     = 0x0084,
    kNkfl_Toning_Green      = 0x0085,
    kNkfl_Toning_Turquoize  = 0x0086,
    kNkfl_Toning_Cyan       = 0x0087,
    kNkfl_Toning_Violet     = 0x0088,
    kNkfl_Toning_Magenta    = 0x0089
};

///////////////////////////////////////////////////////////
// eNkflActiveDLighting
// add 070709
enum eNkflActiveDLighting
{
    kNkfl_ActiveDLighting_AsShot = 1,
    kNkfl_ActiveDLighting_None,
    kNkfl_ActiveDLighting_Low,
    kNkfl_ActiveDLighting_Normal,
    kNkfl_ActiveDLighting_High,
};


// ======================= end ========================= //

///////////////////////////////////////////////////////////
//	eNkflTagType
//
enum eNkflTagType
{
	kNkfl_TagType_Byte					= 0x0001,
	kNkfl_TagType_String				= 0x0002,
	kNkfl_TagType_Long					= 0x0004,
	kNkfl_TagType_SLong					= 0x0009,
	kNkfl_TagType_Double				= 0x0008,
	kNkfl_TagType_Rational				= 0x0005,
	kNkfl_TagType_Undefined				= 0x0007,
	kNkfl_TagType_SRational				= 0x000A,
	kNkfl_TagType_Boolean				= 0x1001,
	kNkfl_TagType_DateTime				= 0x1002,
	kNkfl_TagType_LensInfo				= 0x8002,
//	kNkfl_TagType_UserDefinedCurve		= 0x8003, // not suppport
	kNkfl_TagType_GPSPosition			= 0x8004,
	kNkfl_TagType_GPSTimeStamp			= 0x8005,
	kNkfl_TagType_LensType				= 0x8006,
//	kNkfl_TagType_ColorMatrix			= 0x8009,// not support
	kNkfl_TagType_WBMode				= 0x800A
};

///////////////////////////////////////////////////////////
//	eNkflTag
//
enum eNkflTag
{
	kNkfl_Tag_ImageWidth				= 0x0100,
	kNkfl_Tag_ImageLength				= 0x0101,
	kNkfl_Tag_BitsPerSample				= 0x0102,
	kNkfl_Tag_PhotoMetric				= 0x0106,
//	kNkfl_Tag_Orientation				= 0x0112,		// One of eNkflOrientation, not support
	kNkfl_Tag_XResolution				= 0x011A,
	kNkfl_Tag_YResolution				= 0x011B,
	kNkfl_Tag_DateTime					= 0x0132,
	kNkfl_Tag_ImageDescription			= 0x010E,
	kNkfl_Tag_Make						= 0x010F,
	kNkfl_Tag_Model						= 0x0110,
	kNkfl_Tag_Software					= 0x0131,
	kNkfl_Tag_Artist					= 0x013B,

	kNkfl_Tag_CopyRight					= 0x8298,
	kNkfl_Tag_IPTC						= 0x83BB,
	kNkfl_Tag_ICCProfile				= 0x8773,
	kNkfl_Tag_UserComment				= 0x9286,
	kNkfl_Tag_ExifVersion				= 0x9000,
	kNkfl_Tag_ExposureTime				= 0x829A,
	kNkfl_Tag_FNumber					= 0x829D,
	kNkfl_Tag_ExposureProgram			= 0x8822,		// One of eNkflExposureMode
	kNkfl_Tag_ExposureBiasValue			= 0x9204,
	kNkfl_Tag_MeteringMode				= 0x9207,		// One of eNkflMeteringMode
	kNkfl_Tag_Flash						= 0x9209,
	kNkfl_Tag_FocalLength				= 0x920A,

	kNkfl_Tag_NkISOSensitivity			= 0x080002,		//	Nikon(D1)
	kNkfl_Tag_NkFileFormat				= 0x080004,		// One of eNkflFileFormat
	kNkfl_Tag_NkWhiteBalance			= 0x080005,		// One of eNkflWhiteBalance
	kNkfl_Tag_NkEdgeEnhancement			= 0x080006,		// One of eNkflEdgeEnhancement
	kNkfl_Tag_NkFocusMode				= 0x080007,		// One of eNkflFocusMode
	kNkfl_Tag_NkFlashSyncMode			= 0x080008,		// One of eNkflFlashSyncMode
	kNkfl_Tag_NkFlashAutoMode			= 0x080009,		// One of eNkflFlashAutoMode
	kNkfl_Tag_NkWBCompensation			= 0x08000B,
	kNkfl_Tag_NkFlexibleProgram			= 0x08000D,
	kNkfl_Tag_NkExposureDeviation		= 0x08000E,
	kNkfl_Tag_NkSensitivityMode			= 0x08000F,
	kNkfl_Tag_NkActiveDLighting      	= 0x080022,     // added 070709 for D3/D300
	kNkfl_Tag_NkPictureControlMode      = 0x080023,     // added 070628 for D3/D300
	kNkfl_Tag_NkBRTCNTCompensation		= 0x080080,		// One of eNkflBRTCNTCompensation
	kNkfl_Tag_NkGammaTable				= 0x080081,		// One of eNkflToneCompensation
	kNkfl_Tag_NkConverterLens			= 0x080082,		// One of eNkflBRTCNTConverterLens
	kNkfl_Tag_NkLensType				= 0x080083,
	kNkfl_Tag_NkLensInfo				= 0x080084,
//	kNkfl_Tag_NkElectricZoom			= 0x080086,     // not support
	kNkfl_Tag_NkAFAreaMode				= 0x08008A,		// One of eNkflAFAreaMode
	kNkfl_Tag_NkAFPreferedArea			= 0x08008B,		// One of eNkflAFPreferedArea
//	kNkfl_Tag_NkUserDefinedCurve		= 0x08008C,     // not support
	kNkfl_Tag_NkColorRecurrence			= 0x08008D,		
//	kNkfl_Tag_NkColorMatrixModulus  	= 0x08008E,     // not support
	kNkfl_Tag_NkColorAdjustment			= 0x080092,
	kNkfl_Tag_NkChromaAdjustment		= 0x080094,
	kNkfl_Tag_NkDateTimePrint			= 0x08009D,

	kNkfl_Tag_GPSLatitudeRef			= 0x030001,		// One of eNkflGPSPositionRef
	kNkfl_Tag_GPSLatitude				= 0x030002,
	kNkfl_Tag_GPSLongitudeRef			= 0x030003,		// One of eNkflGPSPositionRef
	kNkfl_Tag_GPSLongitude				= 0x030004,
	kNkfl_Tag_GPSAltitude				= 0x030006,
	kNkfl_Tag_GPSTimeStamp				= 0x030007,
	kNkfl_Tag_GPSSatellites				= 0x030008,
	kNkfl_Tag_GPSMapDatum				= 0x030012,

	kNkfl_Tag_None						= 0xffffffff
};

///////////////////////////////////////////////////////////
//	eNkflOrientation
//
enum eNkflOrientation
{
	kNkfl_Orientation_CW0				= 1,			// Image's top left is visual top left
	kNkfl_Orientation_FlippedCW0		= 2,			// Image's top left is visual top right
	kNkfl_Orientation_CW180				= 3,			// Image's top left is viaual bottom right
	kNkfl_Orientation_FlippedCW180		= 4,			// Image's top left is viaual bottom left
	kNkfl_Orientation_FlippedCW270		= 5,			// Image's top left is viaual left top
	kNkfl_Orientation_CW270				= 6,			// Image's top left is viaual right top
	kNkfl_Orientation_FlippedCW90		= 7,			// Image's top left is viaual right bottom
	kNkfl_Orientation_CW90				= 8				// Image's top left is viaual left bottom
};

///////////////////////////////////////////////////////////
// eNkflPhotometric
//
enum eNkflPhotometric
{
	kNkfl_Photometric_WHITE0			= 0,			// WhiteIsZero. For bilevel and grayscale images:
	kNkfl_Photometric_BLACK0			= 1,			// BlackIsZero. For bilevel and grayscale images:
	kNkfl_Photometric_RGB				= 2,			// RGB
	kNkfl_Photometric_CMYK				= 5,			// CMYK
	kNkfl_Photometric_YCbCr				= 6,			// YCbCr
	kNkfl_Photometric_CFA				= 0x8023,		// CFA ( Color Filter Array )
	kNkfl_Photometric_LAB				= 8,			// CIE Lab
	kNkfl_Photometric_Palette           = 9             // Palette color 2007/05/21 add    
};

///////////////////////////////////////////////////////////
//	eNkflExposureMode
//
enum eNkflExposureMode
{
	kNkfl_ExposureMode_Undefined		= 0,			
	kNkfl_ExposureMode_Manual			= 1,			// Manual
	kNkfl_ExposureMode_Program			= 2,			// Program Auto
	kNkfl_ExposureMode_AperturePriority	= 3,			// Aperture Priority Auto
	kNkfl_ExposureMode_ShutterPriority	= 4,			// Shutter Priority Auto
	kNkfl_ExposureMode_CreativeProgram	= 5,			// Biased toward depth of field
	kNkfl_ExposureMode_ActionProgram	= 6,			// Biased toward fast shutter speed
	kNkfl_ExposureMode_PortraitMode		= 7,			// Portrait mode
	kNkfl_ExposureMode_LandscapeMode	= 8				// Landscape mode
};

///////////////////////////////////////////////////////////
//	eNkflMeteringMode
//
enum eNkflMeteringMode
{
	kNkfl_MeteringMode_Undefined		= 0,
	kNkfl_MeteringMode_Average			= 1,			// So far not used
	kNkfl_MeteringMode_CenterWeightedAverage	= 2,	// Center-weighted metering
	kNkfl_MeteringMode_Spot				= 3,			// Spot metering
	kNkfl_MeteringMode_MutiSpot			= 4,			// So far not used
	kNkfl_MeteringMode_Pattern			= 5,			// Color matrix metering
	kNkfl_MeteringMode_Patial			= 6				// So far not used	
};

///////////////////////////////////////////////////////////
//	eNkflFileFormat
//
enum eNkflFileFormat
{
	kNkfl_FileFormat_JPEG_Basic			= 0,			// JPEG-Basic
	kNkfl_FileFormat_JPEG_Normal		= 1,			// JPEG-Normal
	kNkfl_FileFormat_JPEG_Fine			= 2,			// JPEG-Fine
	kNkfl_FileFormat_TIFF_YCbCr			= 16,			// TIFF-YCbCr
	kNkfl_FileFormat_TIFF_RGB			= 17,			// TIFF-RGB
	kNkfl_FileFormat_NEF_RAW			= 32,			// NEF-RAW
	kNkfl_FileFormat_NEF_RGB			= 38,			// NEF-RBG
	kNkfl_FileFormat_NEF_COMP			= 39			// Compression NEF
};

///////////////////////////////////////////////////////////
//	eNkflWhiteBalance
//
enum eNkflWhiteBalance
{
	kNkfl_WhiteBalance_Auto				= 0x00,			// Auto
	kNkfl_WhiteBalance_Incandescent		= 0x01,			// Incandescent
	kNkfl_WhiteBalance_Fluorescent		= 0x02,			// Fluorescent
	kNkfl_WhiteBalance_Sunlight			= 0x03,			// Direct sunlight
	kNkfl_WhiteBalance_Flash			= 0x04,			// Flash
	kNkfl_WhiteBalance_Shade			= 0x05,			// Shade
	kNkfl_WhiteBalance_Overcast			= 0x06,			// Overcast, cloudy
	kNkfl_WhiteBalance_Preset			= 0x07,			// Preset white balance
	kNkfl_WhiteBalance_Preset1			= 0x17,			// Preset1 white balance
	kNkfl_WhiteBalance_Preset2			= 0x27,			// Preset2 white balance
	kNkfl_WhiteBalance_Preset3			= 0x37,			// Preset3 white balance
	kNkfl_WhiteBalance_Preset4			= 0x47,			// Preset3 white balance
	kNkfl_WhiteBalance_ColorTemperature	= 0x08,			// Color temperature
	kNkfl_WhiteBalance_AppCustom        = 0x09          // Application custom 07/05/21 add by Yamaguchi.T
	//kNkfl_WhiteBalance_SodiumLamp		= 0x0A,	// Add 2007/06/12 for Q440/Q310
	//kNkfl_WhiteBalance_WarmWhiteFL		= 0x0B,	// Add 2007/06/12 for Q440/Q310
	//kNkfl_WhiteBalance_WhiteFL			= 0x0C,	// Add 2007/06/12 for Q440/Q310
	//kNkfl_WhiteBalance_CoolWhiteFL		= 0x0D,	// Add 2007/06/12 for Q440/Q310
	//kNkfl_WhiteBalance_DayWhiteFL		= 0x0E,	// Add 2007/06/12 for Q440/Q310
	//kNkfl_WhiteBalance_DaylightFL		= 0x0F,	// Add 2007/06/12 for Q440/Q310
	//kNkfl_WhiteBalance_MercuryLamp		= 0x10	// Add 2007/06/12 for Q440/Q310
};

///////////////////////////////////////////////////////////
//	eNkflEdgeEnhancement
//
enum eNkflEdgeEnhancement
{
	kNkfl_EdgeEnhancement_None			= 0,			// Sharpening-None
	kNkfl_EdgeEnhancement_Low			= 1,			// Sharpening-Low
	kNkfl_EdgeEnhancement_Normal		= 2,			// Sharpening-Normal, middle
	kNkfl_EdgeEnhancement_High			= 3,			// Sharpening-High
	kNkfl_EdgeEnhancement_MediumLow     = 4,            // Sharpening-Medium Low  07/05/21 add by Yamaguchi.T
	kNkfl_EdgeEnhancement_MediumHigh    = 5,            // Sharpening-Medium High  07/05/21 add by Yamaguchi.T
	kNkfl_EdgeEnhancement_Auto			= 9				// Sharpening-Auto
};

///////////////////////////////////////////////////////////
//	eNkflFocusMode
//
enum eNkflFocusMode
{
	kNkfl_FocusMode_Manual				= 0,			// Manual focus mode
	kNkfl_FocusMode_SingleAF			= 16,			// Single servo AF (focus priority)
	kNkfl_FocusMode_ContinuousAF		= 17,			// Continuous servo AF (release priority)
	kNkfl_FocusMode_AutoAF              = 18,           // Auto servo AF 07/05/21 add by Yamaguchi.T
	kNkfl_FocusMode_Preset				= 32
};

///////////////////////////////////////////////////////////
//	eNkflFlashSyncMode
//
enum eNkflFlashSyncMode
{
	kNkfl_FlashSync_Normal				= 0x00,			// Front-curtain sync
	kNkfl_FlashSync_Slow				= 0x01,			// Slow sync
	kNkfl_FlashSync_Rear				= 0x02,			// Rear-curtain sync
    kNkfl_FlashSync_RearSlow            = 0x03,         // Rear with slow sync 07/05/21 add by Yamaguchi.T
	kNkfl_FlashSync_Redeye				= 0x10,			// Red-eye reduction
	kNkfl_FlashSync_RedeyeSlow			= 0x11,			// Red-eye reduction with slow sync
    kNkfl_FlashSync_Off                 = 0x20          // OFF  07/05/21 add by Yamaguchi.T
};

///////////////////////////////////////////////////////////
//	eNkflFlashAutoMode
//  07/05/21 edit by Yamaguchi.T
enum eNkflFlashAutoMode
{
	kNkfl_FlashAuto_External			= 0,			// Non-TTL auto
	kNkfl_FlashAuto_Manual				= 1,			// Manual
	kNkfl_FlashAuto_FP					= 2,			// FP High-Speed Sync
//	kNkfl_FlashAuto_TTL					= 3				// change TTL
    kNkfl_FlashAuto_NewTTL              = 3,           // New TTL
    kNkfl_FlashAuto_AA                  = 4,           // AA
    kNkfl_FlashAuto_BuiltinTTL          = 5,           // inside SB TTL
    kNkfl_FlashAuto_BuiltinM            = 6,           // inside SB Manual
    kNkfl_FlashAuto_OptionalTTL         = 7,           // outside SB TTL
    kNkfl_FlashAuto_OptionalAA          = 8,           // outside SB AA
    kNkfl_FlashAuto_OptionalA           = 9,           // outside SB A
    kNkfl_FlashAuto_OptionalM           = 10,           // outside SB Manual
    kNkfl_FlashAuto_ComdrTTL            = 11,           // commander TTL
    kNkfl_FlashAuto_ComdrAA             = 12,           // commander AA
    kNkfl_FlashAuto_ComdrM              = 13,           // commander Manual
    kNkfl_FlashAuto_Optional            = 14,           // no comunication SB 
    kNkfl_FlashAuto_BuiltinRPT          = 15,           // inside SB Repeating
    kNkfl_FlashAuto_Comdr               = 16,           // commander
    kNkfl_FlashAuto_BuiltinTTLComdr     = 17,           // inside SB & commander
    kNkfl_FlashAuto_BuiltinMComdr       = 18,           // inside SB Manual & Commander
    kNkfl_FlashAuto_OptionalRPT         = 19,           // outside SB Repeating
    kNkfl_FlashAuto_OptionalTTLComdr    = 20,           // outside SB TTL & commander
    kNkfl_FlashAuto_OptionalAAComdr     = 21,           // outside SB AA & commander
    kNkfl_FlashAuto_OptionalMComdr      = 22,           // outside SB Manula & commander
    kNkfl_FlashAuto_OptionalRPTComdr    = 23,           // outside SB repeating & commander
    kNkfl_FlashAuto_OptionalAComdr      = 24,           // outside SB A & commander
    kNkfl_FlashAuto_None                                    // None
};
	
///////////////////////////////////////////////////////////
//	Sensitiveity Mode
//
enum eNkflSensitivityMode
{
	kNkfl_SensitivityMode_Normal		= 0,			//	It's for D1	
	kNkfl_SensitivityMode_High			= 1,
	kNkfl_SensitivityMode_Low           = 2,            // 07/05/21 add by Yamaguchi.T
	kNkfl_SensitivityMode_High2EV		= 3,

	kNkfl_SensitivityMode_Manual		= 0x8001,		//	It's for CoolPix
	kNkfl_SensitivityMode_Default		= 0x8008,
	kNkfl_SensitivityMode_Auto			= 0x8009,
	kNkfl_SensitivityMode_1EVUp         = 0x8010,       // 07/05/21 add by Yamaguchi.T
	kNkfl_SensitivityMode_2EVUp         = 0x8011        // 07/05/21 add by Yamaguchi.T
};

///////////////////////////////////////////////////////////
//	eNkflBRTCNTComp		Brightness Contrast compensation for Coolpix
//
enum eNkflBRTCNTComp
{
	kNkfl_BRTCNTComp_Normal				= 0x0001,		// Normal
	kNkfl_BRTCNTComp_Auto				= 0x0002,		// Auto
	kNkfl_BRTCNTComp_BrightnessUp		= 0x0101,		// Brightness (+)
	kNkfl_BRTCNTComp_BrightnessDown		= 0x0102,		// Brightness (-)
	kNkfl_BRTCNTComp_ContrastUp			= 0x0104,		// Contrast (+)
	kNkfl_BRTCNTComp_ContrastDown		= 0x0108,		// Contrast (-)
	kNkfl_BRTCNTComp_BW					= 0x010A,		// B & W
	kNkfl_BRTCNTComp_Sepia              = 0x010C        // sepia 07/05/21 add by Yamaguchi.T
};

///////////////////////////////////////////////////////////
//	eNkflToneCompensation	
//  07/05/21 edit by Yamaguchi.T
enum eNkflToneCompensation
{
	kNkfl_ToneCompensation_Normal		= 0,			// Normal
	kNkfl_ToneCompensation_Low			= 1,			// Low-contrast
	kNkfl_ToneCompensation_High			= 2,			// High-contrast
	kNkfl_ToneCompensation_BW			= 3,			// Black and White
	kNkfl_ToneCompensation_Auto         = 4,            // Auto
	kNkfl_ToneCompensation_MidLow       = 5,            // Medium Low
	kNkfl_ToneCompensation_MidHigh      = 6,            // Medium Hight
	kNkfl_ToneCompensation_DownLoad     = 16,            // DownLoad
	kNkfl_ToneCompensation_CS1			= 17,			// User-defined custom curve1
	kNkfl_ToneCompensation_CS2			= 18,			// User-defined custom curve2
	kNkfl_ToneCompensation_CS3			= 19			// User-defined custom curve3
};

///////////////////////////////////////////////////////////
//	eNkflConverterLens	
//
enum eNkflConverterLens
{
	kNkfl_ConverterLens_None			= 0x0000,		// Not attached
	kNkfl_ConverterLens_Attached		= 0x0001,		// attached	 for CoolPix 950 or before Add by H.Uwai Nov 10,2000 
	kNkfl_ConverterLens_Fisheye1		= 0x1001,		// Fisheye converter type 1
	kNkfl_ConverterLens_Fisheye2		= 0x1002,		// Fisheye converter type 2
	kNkfl_ConverterLens_Wide			= 0x2001,		// Wide converter
	kNkfl_ConverterLens_Telephoto1		= 0x3001,		// Tele converter type 1
	kNkfl_ConverterLens_Telephoto2		= 0x3002,		// Tele converter type 2
	kNkfl_ConverterLens_Slide			= 0x4001		// Slide Adaptor Add by H.Uwai Feb 20 2001
};

///////////////////////////////////////////////////////////
//	eNkflAFAreaMode	
//
enum eNkflAFAreaMode
{
	kNkfl_AFAreaMode_Single				= 0,			// Single Area AF
	kNkfl_AFAreaMode_Dynamic			= 1,			// Dynamic AF
	kNkfl_AFAreaMode_CloseRangePriorDynamic = 2,        // Close range Prior Dynamic mode 07/05/21 add by Yamaguchi.T
	kNkfl_AFAreaMode_Group              = 3             // Group Area mode 07/05/21 add by Yamaguchi.T
};

///////////////////////////////////////////////////////////
//	eNkflAFPreferedArea	
//
enum eNkflAFPreferedArea
{
	kNkfl_AFPreferedArea_Center			= 0,			// Center cell
	kNkfl_AFPreferedArea_Top			= 1,			// Top cell
	kNkfl_AFPreferedArea_Bottom			= 2,			// Bottom cell
	kNkfl_AFPreferedArea_Left			= 3,			// Left cell
	kNkfl_AFPreferedArea_Right			= 4				// Right cell
};

////////////////////////////////////////////////////////////
//	eNkflColorRecurrence
//
enum eNkflColorRecurrence
{
    kNkfl_ColorRecurrence_None          = 0,             // none 
	kNkfl_ColorRecurrence_sRGB			= 1,			// Natural Mode
	kNkfl_ColorRecurrence_AdobeRGB		= 2,			// Product Mode
	kNkfl_ColorRecurrence_Mode3			= 3,            // Mode 3
	kNkfl_ColorRecurrence_Mode4         = 4,            // Mode 4
	kNkfl_ColorRecurrence_Mode5         = 5,            // Mode 5
	kNkfl_ColorRecurrence_BW            = 6,            // Black & White
	kNkfl_ColorRecurrence_D1Color       = 10             // D1Color
};

///////////////////////////////////////////////////////////
//	eNkflDateTimePrint
//
enum eNkflDateTimePrint
{
	kNkfl_DateTimePrint_None			= 0x0000,		// Non DateTime Print
	kNkfl_DateTimePrint_DateTimePrinted	= 0x0001,		// Date-Time Printed
	kNkfl_DateTimePrint_DateOnly		= 0x0002		// Date Printed
};

/////////////////////////////////////////////////////////////
//	eNkflGPSPositionRef
//
enum eNkflGPSPositionRef
{
	kNkfl_GPSPosition_North_Latitude	=0,
	kNkfl_GPSPosition_South_Latitude	=1,
	kNkfl_GPSPosition_East_Longitude	=2,
	kNkfl_GPSPosition_West_Longitude	=3
};

///////////////////////////////////////////////////////////
//	eNkflCMS
//  for loacal
enum eNkflCMS
{
	kNkfl_CMS_None						= 0,		
	kNkfl_CMS_RGB8						= 1,			// RGB 8bit
	kNkfl_CMS_RGB16						= 2,			// RGB 16bit
	kNkfl_CMS_CMYK						= 3,			// CMYK
	kNkfl_CMS_GRAY8						= 4,			// GRAY 8bit
	kNkfl_CMS_GRAY16					= 5				// GRAY 16bit
};

////////////////////////////////////////////////////////////
//	eNkflRenderingIntent
//
enum eNkflRenderingIntent
{
	kNkfl_RenderingIntent_Perceptual	= 0,			//	Perceptual
	kNkfl_RenderingIntent_Relative		= 1,			//	Relative
	kNkfl_RenderingIntent_Absolute		= 2,			//	Absolute
	kNkfl_RenderingIntent_Saturation	= 3				//	Saturation
};

///////////////////////////////////////////////////////////
//	eNkflCode
//
enum eNkflCode
{
	kNkfl_Code_None			        			= 0x0000,	//	There is no error.
	kNkfl_Code_Err_OutofMemory		        	= 0x0001,	//	Could not allocate memory.
	kNkfl_Code_Err_OutofResource	        	= 0x0002,	//	Could not resource.
	kNkfl_Code_Err_NotSupported	        		= 0x0003,	//	Not supported function was called.
	kNkfl_Code_Err_InvalidParam     			= 0x0004,	//	Parameter error.
	kNkfl_Code_Err_WrongSequence        		= 0x0005,	//	Sequence error
	kNkfl_Code_Err_FileNotFound	        		= 0x0006,	//	Could not find DLL file.
	kNkfl_Code_Err_OutofVersion	          		= 0x0007,	//	Version error
	kNkfl_Code_Err_Unexpected		        	= 0x0008,	//	The reason may be bug.	
	kNkfl_Code_Err_FileIO				        = 0x0009,	//	File IO error.
	kNkfl_Code_Err_NotAllowed	        		= 0x000A,	//	No allowed.
	kNkfl_Code_Err_TagNotFound		           	= 0x000B,	//	Specified tag is not found.
	kNkfl_Code_Err_Abort			         	= 0x000C,	//	Abort because error has occuurred at callback proc.
	kNkfl_Code_Err_Cancel		        		= 0x000D,	//	Cancel indicated by application.
	kNkfl_Code_Err_TagRead			        	= 0x000E,	//	Read tag data is invalid.
	kNkfl_Code_Err_WrongAliasHandle	        	= 0x000F,	//	Wrong Alias handle is set to parameter (Macintosh Only)
	kNkfl_Code_Err_PictureControlAppliedImage   = 0x0010,   //  cannot apply for picture control image(add 2007/05/18 by Yamaguchi.T)
	kNkfl_Code_Err_ColorModeNotSupported        = 0x0011,   //  cannot apply for color mode image(add 2007/05/18 by Yamaguchi.T)
	kNkfl_Code_Err_RawDevelopmentNotAllowed     = 0x0012,   //  no allowed to raw develop
	kNkfl_Code_Err_ShootingDataNotFound         = 0x0013    //  do not find ShooingData in image.
};

///////////////////////////////////////////////////////////
#endif
