#ifndef _Np_CLIENT_H_
#define _Np_CLIENT_H_

#include "SDKExport.h"
#include "NpClientDefine.h"
#include <string>
#include <vector>

#ifdef __cplusplus
extern "C" {
#endif // __cplusplus

#ifndef BYTE
typedef unsigned char BYTE;
#endif // BYTE

#ifndef WORD
typedef unsigned short WORD;
#endif // WORD

#ifndef DWORD
#if defined(__APPLE__)
typedef unsigned int DWORD;
#else
typedef unsigned long DWORD;
#endif
#endif // DWORD

enum Np_ServerType { kMainConsoleLiveview = 1, kMainConsolePlayback, kCorporate, kTitan };

enum Np_VideoCodec{
    kVideoCodecNone = 0,
    kVideoCodecMJPEG = 1,
    kVideoCodecMPEG4 = 2,
    kVideoCodecH264 = 3,
    kVideoCodecMXPEG = 4,
};

enum Np_AudioCodec{    
    kAudioCodecNone = 0,
    kAudioCodecAAC = 1,
    kAudioCodecACM = 2,
    kAudioCodecMSADPCM = 3,
    kAudioCodecG711Alaw = 4,
    kAudioCodecG711Mulaw = 5,
    kAudioCodecG726 = 6,
    kAudioCodecGSM_AMR = 7,
    kAudioCodecPCM = 8,
    kAudioCodecG7221 = 9,
    kAudioCodecGSM610 = 10,    
};

enum Np_PixelFormat{
    kPixelFormatYUV420P = 0,
    kPixelFormatRGB24 = 1,
    kPixelFormatBGR24 = 2,
};

enum Np_ExportError {
    kExportSuccess = 0,
    kExportUpdateProgress = 1,
    kExportCallbackError = 2,
    kExportChannelEmpty = 3,
    kExportCueTimeError = 4,
    kExportDimesionError = 5,
    kExportFail = 6,
    kExportNoData = 7,
    kExportMJpegMac = 8,
    kExportSonyFormatMac = 9,
    kExportFormatChange = 10
};

typedef struct {
	WORD year;
	WORD month;
	WORD day;
	WORD hour;
	WORD minute;
	WORD second;
	WORD millisecond;
} Np_DateTime;

typedef int Np_Result_t;

typedef int Np_Error;

//////////////////////////////////////////////////////////////////
/*
 * ID 
 */
//////////////////////////////////////////////////////////////////

typedef struct {
	int centralID;
	int localID;
} Np_ID;

//////////////////////////////////////////////////////////////////
/*
 * Liveview Playback related
 */
//////////////////////////////////////////////////////////////////

typedef void (*fnVideoHandle) (Np_DateTime time,
						   	   char* buffer,
                               int len,
                           	   int width, 
                          	   int height, 
                           	   void* ctx);

typedef void (*fnAudioHandle) (Np_DateTime time,
                               char* buffer, 
                               int len, 
                               int bitsPerSample, 
                               int samplesPerSec, 
                               int channels, 
                               void* ctx);
                           
typedef void (*fnRawVideoHandle) (Np_DateTime time,
                               char* buffer,
                               int len,
                               bool isKeyFrame,
                               Np_VideoCodec videoCodec,
                           	   void* ctx);

typedef void (*fnErrorHandle) (Np_Error error, void* ctx);

typedef void (*fnExportHandle)(Np_ID id, 
                               Np_ExportError error, 
                               unsigned int percent,
                               int iFormatChangedIndex,
                               void* usrCtx);

typedef void (*fnOSDHandle)   (Np_ID id,
                               char* buffer,
                               int width,
                               int height,
                               Np_DateTime time, 
                               void* ctx);

//////////////////////////////////////////////////////////////////
/*
 * Info related 
 */
//////////////////////////////////////////////////////////////////

enum Np_StreamProfile {
	kProfileNormal = 0,
	kProfileOriginal,
    kProfileLow,
    kProfileMinimum
};


enum Np_ScheduleType {
    kScheduleNone					 = 0,
    kScheduleRecordOnly				 = 1,
    kScheduleMotionDetectOnly		 = 2,
    kScheduleRecordAndMotionDetect   = 3,
    kScheduleRecordMovingOnly		 = 4,
    kScheduleRecordOnEvent			 = 5,
    kScheduleUndefined				 = 6, //undefined
    kScheduleRecordBoost             = 7
};

typedef struct {
    Np_StreamProfile profile;
    std::wstring frameRate;	
    std::wstring bitrate;	
    std::wstring resolution;	
    std::wstring codec;	
    std::wstring quality;	    	
} Np_SensorProfile;

typedef std::vector<Np_SensorProfile> Np_SensorProfileList;

typedef struct {
	Np_ID ID;
    std::wstring name;
    std::wstring description;    
} Np_SubDevice;

typedef struct {
	Np_ID ID;
    std::wstring name;
    std::wstring description;    
    std::vector<Np_SubDevice> SensorDevices;
    std::vector<Np_SubDevice> PTZDevices;
    std::vector<Np_SubDevice> AudioDevices;
    std::vector<Np_SubDevice> DIDevices;
    std::vector<Np_SubDevice> DODevices;
} Np_Device;

typedef struct {
	std::wstring name; //server name
	std::wstring description;
	std::vector<Np_Device> Camera;
	std::vector<Np_Device> IOBox;
} Np_DeviceGroup;

typedef struct {
	std::vector<Np_DeviceGroup> PhysicalGroup;
	std::vector<Np_DeviceGroup> LogicalGroup;
} Np_DeviceList;

typedef struct {
	bool operationLog;
	bool configurationLog;
} Np_LogConditions;

typedef struct {
	Np_DateTime occurTime;
	Np_ID sourceID; 
	int eventID;	
	std::wstring description;
} Np_OperationLog;

typedef struct {
	Np_DateTime occurTime;	
	Np_ID sourceID; 
	int eventID;	
	std::wstring description;
	std::wstring user;
	std::wstring behavier;
} Np_ConfigurationLog;

typedef struct {
	std::vector<Np_OperationLog> 	 opLog;
	std::vector<Np_ConfigurationLog> cnfgLog;
} Np_Log;

typedef struct {
    Np_ID ID;
    Np_DateTime startTime;
    Np_DateTime endTime;
    Np_ScheduleType type;
} Np_ScheduleLogItem;

typedef struct {
    Np_ID ID;
    Np_DateTime startTime;
    Np_DateTime endTime;
} Np_RecordLogItem;

typedef struct {
    int size;
    Np_ScheduleLogItem* logList;
} Np_ScheduleLogList;

typedef struct {
    int size;
    Np_RecordLogItem* logList;
} Np_RecordLogList;

typedef struct {
    Np_DateTime occurTime;
    Np_ID sourceID; 
    int eventID;
    wchar_t* auxiliaryCode;
    wchar_t* description;
    wchar_t* sourceName;
} Np_Event;

typedef struct {
    int size;
    Np_Event* list;
} Np_EventList;

typedef struct {
    int size;
    Np_DateTime* dateList;
} Np_RecordDateList;

enum Np_DIOStatus {
    kDIO_OFF = 0,
	kDIO_ON,
};

enum Np_PlayerState {
    kStateStopped,
    kStatePaused,
    kStateRunning
};

//////////////////////////////////////////////////////////////////
/*
 * Events related 
 */
//////////////////////////////////////////////////////////////////

typedef void (*fnEventHandle) (Np_Event, void* ctx);

//////////////////////////////////////////////////////////////////
/*
 * Control related 
 */
//////////////////////////////////////////////////////////////////

enum Np_PTZCommand 
{	
	kPTZStop,
	kPTZContinuousMove,
	kPTZAutoFocus,
	kPTZHome,
	kPTZRectangle,
	kPTZPresetGo,
	kPTZPresetSet,
	kPTZPresetClear
};

enum Np_PanDirection   { kNoPan,   kPanLeft,   kPanRight };
enum Np_TiltDirection  { kNoTilt,  kTiltUp,    kTiltDown  };
enum Np_ZoomDirection  { kNoZoom,  kZoomIn,    kZoomOut   };
enum Np_FocusDirection { kNoFocus, kFocusNear, kFocusFar   };

enum Np_PTZCap{
    kPTZNone			= 0x0000,
    kPTZEnable			= 0x0001,
    kPTZBuiltin		    = 0x0002,
    kPTZPane			= 0x0004,
    kPTZTilt			= 0x0008,
    kPTZZoom			= 0x0010,
    kPTZFocus			= 0x0020,
    kPTZPreset			= 0x0040,
    kPTZLilin			= 0x0080,
    kPTZAutoPan         = 0x0100,
    kPTZAreaZoom        = 0x0200,
    kPTZSpeedDomeOSDMenu = 0x400
};

typedef struct {		
	Np_PanDirection    pan;
	Np_TiltDirection   tilt;
	Np_ZoomDirection   zoom;
	Np_FocusDirection	focus;			
	int panSpeed;   // speed from 1 ~ 100, -1 as default
	int tiltSpeed;  // speed from 1 ~ 100, -1 as default
	int zoomSpeed;  // speed from 1 ~ 100, -1 as default
	int focusSpeed; // speed from 1 ~ 100, -1 as default	
} Np_PTZContinuousMove;

typedef struct {
    int currentWidth;
    int currentHeight;
    int leftupX;
    int leftupY;
    int targetWidth;
    int targetHeight;
    int speed;      // speed from 1 ~ 100, -1 as default    
} Np_PTZRectangle;

typedef struct {
    int presetNo;
    std::wstring presetName;        
} Np_PTZPreset;

typedef std::vector<Np_PTZPreset> Np_PTZPresetList;

typedef union  {
	Np_PTZContinuousMove* move;
	Np_PTZRectangle* rectangle;
	Np_PTZPreset* preset;
} Np_PTZParameter; 

typedef struct {
	Np_PTZCommand   command;
	Np_PTZParameter param;
} Np_PTZControlParam;

typedef struct {
    wchar_t* serverType;
    wchar_t* serverVersion;
    wchar_t* modelType;
    wchar_t* oemName;
    int sessionNumber;
    int maximumChannel;
    int allowSmartGuard;
    int allowPOS;
    int allowCounting;
    int allowEMap;
    int dbType;
} Np_ServerInfo_MainConsole;

typedef union {
    Np_ServerInfo_MainConsole *serverInfoMC;
} Np_ServerInfo;

typedef struct {
    Np_ID id;
    Np_DateTime startTime;
    Np_DateTime endTime;
    bool excludeAudio;
    int width;
    int height;
} Np_ExportContent;

typedef struct {
    int profile;
    wchar_t* description;
} Np_ExportProfile;

typedef struct {
    size_t size;
    Np_ExportProfile* items;
} Np_ExportProfileList;

typedef struct {
    int format;
    wchar_t* description;
    Np_ExportProfileList supportedProfile;
} Np_ExportFormat;

typedef struct {
    size_t size;
    Np_ExportFormat* items;
} Np_ExportFormatList;

//////////////////////////////////////////////////////////////////
/*
* CSharp Related
*/
//////////////////////////////////////////////////////////////////

typedef struct {
    Np_StreamProfile profile;
    wchar_t* frameRate;	
    wchar_t* bitrate;	
    wchar_t* resolution;	
    wchar_t* codec;	
    wchar_t* quality;	    	
} Np_SensorProfile_CS;

typedef struct {
    size_t size;
    Np_SensorProfile_CS* items;
} Np_SensorProfile_CS_List;

typedef struct {
    Np_ID ID;
    wchar_t* name;
    wchar_t* description;
} Np_SubDevice_CS;

typedef struct {
    size_t size;
    Np_SubDevice_CS* items;
} Np_SubDevice_CS_List;

typedef struct {
	Np_ID ID;
    wchar_t* name;
    wchar_t* description;    
    Np_SubDevice_CS_List SensorDevices;
    Np_SubDevice_CS_List PTZDevices;
    Np_SubDevice_CS_List AudioDevices;
    Np_SubDevice_CS_List DIDevices;
    Np_SubDevice_CS_List DODevices;
} Np_Device_CS;

typedef struct {
    size_t size;
    Np_Device_CS* items;
} Np_Device_CS_List;

typedef struct {
	wchar_t* name; //server name
	wchar_t* description;
	Np_Device_CS_List Camera;
	Np_Device_CS_List IOBox;
} Np_DeviceGroup_CS;

typedef struct {
    size_t size;
    Np_DeviceGroup_CS* items;
} Np_DeviceGroup_CS_List;

typedef struct {
	Np_DeviceGroup_CS_List PhysicalGroup;
	Np_DeviceGroup_CS_List LogicalGroup;
} Np_DeviceList_CS;

typedef struct {
	Np_DateTime occurTime;
	Np_ID sourceID; 
	int eventID;	
	wchar_t* description;
} Np_OperationLog_CS;

typedef struct {
    size_t size;
    Np_OperationLog_CS* items;
} Np_OperationLog_CS_List;

typedef struct {
	Np_DateTime occurTime;	
	Np_ID sourceID; 
	int eventID;	
	wchar_t* description;
	wchar_t* user;
	wchar_t* behavier;
} Np_ConfigurationLog_CS;

typedef struct {
    size_t size;
    Np_ConfigurationLog_CS* items;
} Np_ConfigurationLog_CS_List;

typedef struct {
	Np_OperationLog_CS_List 	 opLog;
	Np_ConfigurationLog_CS_List cnfgLog;
} Np_Log_CS;

typedef struct {
    int presetNo;
    wchar_t* presetName;
} Np_PTZPreset_CS;

typedef struct {
    size_t size;
    Np_PTZPreset_CS* items;
} Np_PTZPreset_CS_List;

typedef union  {
	Np_PTZContinuousMove* move;
	Np_PTZRectangle* rectangle;
    Np_PTZPreset_CS* preset;
} Np_PTZParameter_CS;

typedef struct {
	Np_PTZCommand   command;
	Np_PTZParameter_CS param;
} Np_PTZControlParam_CS;

//////////////////////////////////////////////////////////////////
/*
 *  Fuctions 
 */
//////////////////////////////////////////////////////////////////
SDK_EXPORT 
Np_Result_t  Create_Handle         (void** handle, 
									Np_ServerType type, 									
									std::wstring username, 
									std::wstring passwd,
									std::wstring ipaddress, 
									WORD port);

// This function is used for C#
SDK_EXPORT 
Np_Result_t  Create_HandleWChar    (void** handle, 
                                    Np_ServerType type, 									
                                    const wchar_t* username, 
                                    const wchar_t* passwd,
                                    const wchar_t* ipaddress, 
                                    WORD port);

// This function is used for C#
SDK_EXPORT 
Np_Result_t  Info_GetDeviceIDList  (void*  handle, size_t& iDevNum, Np_ID** ppIDList);

// This function is used for C#
SDK_EXPORT 
Np_Result_t Info_DestroyDeviceIDList(Np_ID* ppIDList);

SDK_EXPORT 									
Np_Result_t  Destroy_Handle        (void*  handle);

SDK_EXPORT 
Np_Result_t  Info_GetServerInfo    (void*  handle, Np_ServerInfo& serverInfo);

SDK_EXPORT 
Np_Result_t  Info_ReleaseServerInfo(void*  handle, Np_ServerInfo& serverInfo);

SDK_EXPORT 
Np_Result_t  Info_GetDeviceList    (void*  handle, Np_DeviceList& deviceList);

SDK_EXPORT 
Np_Result_t  Info_GetDeviceList_CS    (void*  handle, Np_DeviceList_CS& deviceList);

SDK_EXPORT 
Np_Result_t  Info_ReleaseDeviceList_CS    (void*  handle, Np_DeviceList_CS& deviceList);

SDK_EXPORT 
Np_Result_t  Info_GetLog 		   (void*  handle, Np_LogConditions conditions, Np_Log& logs);

SDK_EXPORT 
Np_Result_t  Info_GetLog_CS 		   (void*  handle, Np_LogConditions conditions, Np_Log_CS& logs);

SDK_EXPORT 
Np_Result_t  Info_ReleaseLog_CS 		   (void*  handle, Np_Log_CS& logs);

SDK_EXPORT 
Np_Result_t  Info_GetDIOStatus     (void*  handle, Np_ID id, Np_DIOStatus& status);

SDK_EXPORT 
Np_Result_t  Info_GetDOPrivilege   (void*  handle, Np_ID id, DWORD& dwDOPrivilege);

SDK_EXPORT 
Np_Result_t  Info_GetPTZPreset     (void*  handle, Np_ID id, Np_PTZPresetList& ptzPresetList);

SDK_EXPORT 
Np_Result_t  Info_GetPTZPreset_CS    (void*  handle, Np_ID id, Np_PTZPreset_CS_List& ptzPresetList);

SDK_EXPORT 
Np_Result_t  Info_ReleasePTZPreset_CS     (void*  handle, Np_PTZPreset_CS_List& ptzPresetList);

SDK_EXPORT 
Np_Result_t  Info_GetPTZCapability (void*  handle, Np_ID id, long long& ptzCapability);

SDK_EXPORT 
Np_Result_t  Info_GetSensorProfileList (void*  handle, Np_ID id, Np_SensorProfileList& sensorProfileList);

SDK_EXPORT 
Np_Result_t  Info_GetSensorProfileList_CS (void*  handle, Np_ID id, Np_SensorProfile_CS_List& sensorProfileList);

SDK_EXPORT 
Np_Result_t  Info_ReleaseSensorProfileList_CS (void*  handle, Np_SensorProfile_CS_List& sensorProfileList);

SDK_EXPORT 
Np_Result_t  Info_GetRecordDateList (void*  handle, Np_RecordDateList& recordDateList);

SDK_EXPORT 
Np_Result_t  Info_GetRangedRecordDateList (void*  handle, Np_DateTime* startDate, Np_DateTime* endDate, Np_RecordDateList& recordDateList);

SDK_EXPORT 
Np_Result_t  Info_ReleaseRecordDateList (void*  handle, Np_RecordDateList& recordDateList);

SDK_EXPORT 
Np_Result_t  Info_GetScheduleLogs (void*  handle, Np_DateTime date, Np_ScheduleLogList& scheduleLogList);

SDK_EXPORT 
Np_Result_t  Info_ReleaseScheduleLogs (void*  handle, Np_ScheduleLogList& scheduleLogList);

SDK_EXPORT 
Np_Result_t  Info_GetRecordLogs (void*  handle, Np_DateTime date, Np_RecordLogList& scheduleLogList);

SDK_EXPORT 
Np_Result_t  Info_ReleaseRecordLogs (void*  handle, Np_RecordLogList& recordLogList);

SDK_EXPORT 
Np_Result_t  Info_QueryEvents (void*  handle, 
                               Np_DateTime* startTime, 
                               Np_DateTime* endTime, 
                               int* deviceTypeID, 
                               Np_ID* deviceID, 
                               int* eventID, 
                               Np_EventList& eventList);

SDK_EXPORT 
Np_Result_t  Info_ReleaseEvents (void*  handle, Np_EventList& eventList);

SDK_EXPORT 
Np_Result_t  Control_PTZ           (void*  handle, Np_ID id, Np_PTZControlParam *param);

SDK_EXPORT 
Np_Result_t  Control_PTZ_PTZDeviceID (void*  handle, Np_ID id, Np_PTZControlParam *param);

SDK_EXPORT 
Np_Result_t  Control_PTZ_CS           (void*  handle, Np_ID id, Np_PTZControlParam_CS *param);

SDK_EXPORT 
Np_Result_t  Control_PTZ_PTZDeviceID_CS (void*  handle, Np_ID id, Np_PTZControlParam_CS *param);

SDK_EXPORT 
Np_Result_t  Control_DigitalOutput (void*  handle, Np_ID id, bool turnOn);

SDK_EXPORT 
Np_Result_t  Event_Subscribe       (void*  handle, void** session, fnEventHandle callback, void* ctx); 

SDK_EXPORT 
Np_Result_t  Event_Unsubscribe     (void*  session);

SDK_EXPORT 
Np_Result_t  LiveView_CreatePlayer (void*  handle, void** player);

SDK_EXPORT 
Np_Result_t  LiveView_DestroyPlayer(void*  player);

SDK_EXPORT 
Np_Result_t  LiveView_AttachSession(void*  player, void** session, 
								    Np_ID id,
								    Np_StreamProfile profile, 
								    fnVideoHandle vcb, void* vctx, 
								    fnAudioHandle acb, void* actx, 
								    fnErrorHandle ecb, void* ectx);

SDK_EXPORT
Np_Result_t  LiveView_AttachSessionExt(void*  player, void** session,
                                       Np_ID id,
                                       Np_StreamProfile profile,
                                       Np_PixelFormat videoPixalFormat,
                                       fnVideoHandle vcb, void* vctx,
                                       fnAudioHandle acb, void* actx,
                                       fnErrorHandle ecb, void* ectx);

SDK_EXPORT 
Np_Result_t  LiveView_AttachRawVideoSession(void*  player, void** session, 
                                    Np_ID id,
                                    Np_StreamProfile profile, 
                                    fnRawVideoHandle vcb, void* vctx, 
                                    fnAudioHandle acb, void* actx, 
                                    fnErrorHandle ecb, void* ectx);

SDK_EXPORT 
Np_Result_t  LiveView_DetachSession(void*  player, void*  session);

SDK_EXPORT 
Np_Result_t  LiveView_SetAudioOn   (void*  player, void*  session);

SDK_EXPORT 
Np_Result_t  LiveView_SetAudioOff  (void*  player);

SDK_EXPORT 
Np_Result_t  LiveView_GetSessionBitrate  (void*  player, void*  session, double &bitrate);

SDK_EXPORT 
Np_Result_t  PlayBack_CreatePlayer (void*  handle,void** player);

SDK_EXPORT 
Np_Result_t  PlayBack_DestroyPlayer(void*  player);

SDK_EXPORT 
Np_Result_t  PlayBack_AttachSession(void*  player, void** session, 
								    Np_ID id, 								    
								    fnVideoHandle vcb, void* vctx, 
								    fnAudioHandle acb, void* actx, 
								    fnErrorHandle ecb, void* ectx);

SDK_EXPORT 
Np_Result_t  PlayBack_AttachSessionExt(void*  player, void** session, 
                                       Np_ID id,
                                       Np_PixelFormat videoPixelFormat,
                                       fnVideoHandle vcb, void* vctx, 
                                       fnAudioHandle acb, void* actx, 
                                       fnErrorHandle ecb, void* ectx);

SDK_EXPORT 
Np_Result_t  PlayBack_AttachRawVideoSession(void*  player, void** session, 
                                    Np_ID id, 								    
                                    fnRawVideoHandle vcb, void* vctx, 
                                    fnAudioHandle acb, void* actx, 
                                    fnErrorHandle ecb, void* ectx);

SDK_EXPORT 
Np_Result_t  PlayBack_DetachSession(void*  player, void* session);

SDK_EXPORT 
Np_Result_t  PlayBack_Seek         (void*  player, Np_DateTime time);

SDK_EXPORT 
Np_Result_t  PlayBack_OpenRecord   (void*  player, Np_DateTime startTime, Np_DateTime endTime);

SDK_EXPORT 
Np_Result_t  PlayBack_Play         (void*  player);

SDK_EXPORT 
Np_Result_t  PlayBack_ReversePlay  (void*  player);

SDK_EXPORT 
Np_Result_t  PlayBack_Pause        (void*  player);

SDK_EXPORT 
Np_Result_t  PlayBack_StepForward  (void*  player);

SDK_EXPORT 
Np_Result_t  PlayBack_StepBackward (void*  player);

SDK_EXPORT 
Np_Result_t  PlayBack_Next         (void*  player);

SDK_EXPORT 
Np_Result_t  PlayBack_Previous     (void*  player);

SDK_EXPORT 
Np_Result_t  PlayBack_SetSpeed     (void*  player, float speed); 

SDK_EXPORT 
Np_Result_t  PlayBack_GetSpeed     (void*  player, float &speed);

SDK_EXPORT 
Np_Result_t  PlayBack_GetTime      (void*  player, Np_DateTime &time);

SDK_EXPORT 
Np_Result_t  PlayBack_GetPlayerState(void*  player, Np_PlayerState &state);

SDK_EXPORT 
Np_Result_t  PlayBack_ExportVideo  (void*  player,
                                    Np_ExportContent content, 
                                    const wchar_t* filename, 
                                    int format,
                                    int profile,
                                    fnExportHandle ecb, void* ectx,
                                    fnOSDHandle ocb, void* octx);

SDK_EXPORT 
Np_Result_t  PlayBack_StopExport   (void* player);

SDK_EXPORT 
Np_Result_t  PlayBack_GetExportFormatList(void* player, Np_ExportFormatList& fmtlist);

SDK_EXPORT 
Np_Result_t  PlayBack_ReleaseExportFormatList(void* player, Np_ExportFormatList& fmtlist);

SDK_EXPORT 
Np_Result_t  Utility_SaveSnapShotImage(const wchar_t* filename, const char* buffer, int len, int width, int height);

SDK_EXPORT 
Np_Result_t  Utility_AddImageWaterMark(const wchar_t*  filename, Np_DateTime &time, const wchar_t* cameraname);

SDK_EXPORT 
Np_Result_t  Utility_AddVideoWaterMark(const wchar_t*  filename, Np_DateTime &start_time, Np_DateTime &end_time, const wchar_t* cameraname);

#ifdef __cplusplus
}
#endif // __cplusplus

#endif


