D:/SVN/Scol/trunk/plugins/Epoc/edk/edk.h

#ifndef EDK_H
#define EDK_H

#include "edkErrorCode.h"
#include "EmoStateDLL.h"


#ifndef EDK_STATIC_LIB

#ifdef EDK_EXPORTS
#ifdef _WIN32
#define EDK_API __declspec(dllexport)
#else
#define EDK_API __declspec(dllimport)
#endif
#else
#define EDK_API
#endif

#else

#define EDK_API extern

#endif


extern "C"
{
        typedef enum EE_ExpressivThreshold_enum {
                EXP_SENSITIVITY
        } EE_ExpressivThreshold_t;

        typedef enum EE_ExpressivTrainingControl_enum {
                EXP_NONE = 0, EXP_START, EXP_ACCEPT, EXP_REJECT, EXP_ERASE, EXP_RESET
        } EE_ExpressivTrainingControl_t;

        typedef enum EE_ExpressivSignature_enum {
                EXP_SIG_UNIVERSAL = 0, EXP_SIG_TRAINED
        } EE_ExpressivSignature_t;

        typedef enum EE_CognitivTrainingControl_enum {
                COG_NONE = 0, COG_START, COG_ACCEPT, COG_REJECT, COG_ERASE, COG_RESET
        } EE_CognitivTrainingControl_t;


        typedef void*         EmoStateHandle;

        typedef void*         EmoEngineEventHandle;

        typedef void*         OptimizationParamHandle;

        typedef void*             DataHandle;

        typedef enum EE_Event_enum {
                EE_UnknownEvent         = 0x0000,
                EE_EmulatorError        = 0x0001,
                EE_ReservedEvent        = 0x0002,
                EE_UserAdded            = 0x0010,
                EE_UserRemoved          = 0x0020,
                EE_EmoStateUpdated      = 0x0040,
                EE_ProfileEvent         = 0x0080,
                EE_CognitivEvent        = 0x0100,
                EE_ExpressivEvent       = 0x0200,
                EE_InternalStateChanged = 0x0400,
                EE_AllEvent                     = EE_UserAdded | EE_UserRemoved | EE_EmoStateUpdated | EE_ProfileEvent |
                                                          EE_CognitivEvent | EE_ExpressivEvent | EE_InternalStateChanged
        } EE_Event_t;

        typedef enum EE_ExpressivEvent_enum {
                EE_ExpressivNoEvent = 0, EE_ExpressivTrainingStarted, EE_ExpressivTrainingSucceeded,
                EE_ExpressivTrainingFailed, EE_ExpressivTrainingCompleted, EE_ExpressivTrainingDataErased,
                EE_ExpressivTrainingRejected, EE_ExpressivTrainingReset
        } EE_ExpressivEvent_t;
        
        typedef enum EE_CognitivEvent_enum {
                EE_CognitivNoEvent = 0, EE_CognitivTrainingStarted, EE_CognitivTrainingSucceeded,
                EE_CognitivTrainingFailed, EE_CognitivTrainingCompleted, EE_CognitivTrainingDataErased,
                EE_CognitivTrainingRejected, EE_CognitivTrainingReset,
                EE_CognitivAutoSamplingNeutralCompleted, EE_CognitivSignatureUpdated
        } EE_CognitivEvent_t;

        typedef enum EE_DataChannels_enum {
                ED_COUNTER = 0, ED_INTERPOLATED, ED_RAW_CQ,
                ED_AF3, ED_F7, ED_F3, ED_FC5, ED_T7, 
                ED_P7, ED_O1, ED_O2, ED_P8, ED_T8, 
                ED_FC6, ED_F4, ED_F8, ED_AF4, ED_GYROX, 
                ED_GYROY, ED_TIMESTAMP, ED_ES_TIMESTAMP, ED_FUNC_ID, ED_FUNC_VALUE, ED_MARKER, 
                ED_SYNC_SIGNAL
        } EE_DataChannel_t;

        typedef struct InputSensorDescriptor_struct {
                EE_InputChannels_t channelId;  // logical channel id
                int                fExists;    // does this sensor exist on this headset model
                const char*        pszLabel;   // text label identifying this sensor
                double             xLoc;       // x coordinate from center of head towards nose
                double             yLoc;       // y coordinate from center of head towards ears
                double             zLoc;       // z coordinate from center of head toward top of skull
        } InputSensorDescriptor_t;



        EDK_API int
                EE_EngineConnect();

        

        EDK_API int
                EE_EngineRemoteConnect(const char* szHost, unsigned short port);

        

        EDK_API int
                EE_EngineDisconnect();



        EDK_API int
                EE_EnableDiagnostics(const char* szFilename, int fEnable, int nReserved);

        

        EDK_API EmoEngineEventHandle
                EE_EmoEngineEventCreate();



        EDK_API EmoEngineEventHandle
                EE_ProfileEventCreate();

        

        EDK_API void
                EE_EmoEngineEventFree(EmoEngineEventHandle hEvent);

        

        EDK_API EmoStateHandle
                EE_EmoStateCreate();

        

        EDK_API void
                EE_EmoStateFree(EmoStateHandle hState);



        EDK_API EE_Event_t
                EE_EmoEngineEventGetType(EmoEngineEventHandle hEvent);

        

        EDK_API EE_CognitivEvent_t
                EE_CognitivEventGetType(EmoEngineEventHandle hEvent);



        EDK_API EE_ExpressivEvent_t
                EE_ExpressivEventGetType(EmoEngineEventHandle hEvent);
        


        EDK_API int
                EE_EmoEngineEventGetUserId(EmoEngineEventHandle hEvent, unsigned int *pUserIdOut);

        

        EDK_API int
                EE_EmoEngineEventGetEmoState(EmoEngineEventHandle hEvent, EmoStateHandle hEmoState);
        


        EDK_API int
                EE_EngineGetNextEvent(EmoEngineEventHandle hEvent);

        

        EDK_API int
                EE_EngineClearEventQueue(int eventTypes);

        

        EDK_API int
                EE_EngineGetNumUser(unsigned int* pNumUserOut);



        EDK_API int
                EE_SetHardwarePlayerDisplay(unsigned int userId, unsigned int playerNum);



        EDK_API int
                EE_SetUserProfile(unsigned int userId, const unsigned char profileBuffer[], unsigned int length);



        EDK_API int
                EE_GetUserProfile(unsigned int userId, EmoEngineEventHandle hEvent);



        EDK_API int
                EE_GetBaseProfile(EmoEngineEventHandle hEvent);
        


        EDK_API int
                EE_GetUserProfileSize(EmoEngineEventHandle hEvt, unsigned int* pProfileSizeOut);

        

        EDK_API int
                EE_GetUserProfileBytes(EmoEngineEventHandle hEvt, unsigned char destBuffer[], unsigned int length);


        EDK_API int
                EE_LoadUserProfile(unsigned int userID, const char* szInputFilename);


        EDK_API int
                EE_SaveUserProfile(unsigned int userID, const char* szOutputFilename);


        EDK_API int
                EE_ExpressivSetThreshold(unsigned int userId, EE_ExpressivAlgo_t algoName, EE_ExpressivThreshold_t thresholdName, int value);



        EDK_API int
                EE_ExpressivGetThreshold(unsigned int userId, EE_ExpressivAlgo_t algoName, EE_ExpressivThreshold_t thresholdName, int *pValueOut);



        EDK_API int 
                EE_ExpressivSetTrainingAction(unsigned int userId, EE_ExpressivAlgo_t action);



        EDK_API int 
                EE_ExpressivSetTrainingControl(unsigned int userId, EE_ExpressivTrainingControl_t control);



        EDK_API int 
                EE_ExpressivGetTrainingAction(unsigned int userId, EE_ExpressivAlgo_t* pActionOut);

        

        EDK_API int 
                EE_ExpressivGetTrainingTime(unsigned int userId, unsigned int* pTrainingTimeOut);



    EDK_API int
        EE_ExpressivGetTrainedSignatureActions(unsigned int userId, unsigned long* pTrainedActionsOut);



    EDK_API int
                EE_ExpressivGetTrainedSignatureAvailable(unsigned int userId, int* pfAvailableOut);


        EDK_API int 
                EE_ExpressivSetSignatureType(unsigned int userId, EE_ExpressivSignature_t sigType);


        EDK_API int 
                EE_ExpressivGetSignatureType(unsigned int userId, EE_ExpressivSignature_t* pSigTypeOut);





        EDK_API int
                EE_CognitivSetActiveActions(unsigned int userId, unsigned long activeActions);

        

        EDK_API int
                EE_CognitivGetActiveActions(unsigned int userId, unsigned long* pActiveActionsOut);

        

        EDK_API int 
                EE_CognitivGetTrainingTime(unsigned int userId, unsigned int* pTrainingTimeOut);

        

        EDK_API int 
                EE_CognitivSetTrainingControl(unsigned int userId, EE_CognitivTrainingControl_t control);

        

        EDK_API int 
                EE_CognitivSetTrainingAction(unsigned int userId, EE_CognitivAction_t action);



        EDK_API int 
                EE_CognitivGetTrainingAction(unsigned int userId, EE_CognitivAction_t* pActionOut);



    EDK_API int
        EE_CognitivGetTrainedSignatureActions(unsigned int userId, unsigned long* pTrainedActionsOut);
        
        

    EDK_API int
        EE_CognitivGetOverallSkillRating(unsigned int userId, float* pOverallSkillRatingOut);



    EDK_API int
        EE_CognitivGetActionSkillRating(unsigned int userId, EE_CognitivAction_t action, float* pActionSkillRatingOut);

        

        EDK_API int 
                EE_CognitivSetActivationLevel(unsigned int userId, int level);

        

        EDK_API int 
                EE_CognitivSetActionSensitivity(unsigned int userId,
                                                                                int action1Sensitivity, int action2Sensitivity,
                                                                                int action3Sensitivity, int action4Sensitivity);

        

        EDK_API int 
                EE_CognitivGetActivationLevel(unsigned int userId, int *pLevelOut);

        

        EDK_API int 
                EE_CognitivGetActionSensitivity(unsigned int userId,
                                                                                int* pAction1SensitivityOut, int* pAction2SensitivityOut,
                                                                                int* pAction3SensitivityOut, int* pAction4SensitivityOut);

        

        EDK_API int
                EE_CognitivStartSamplingNeutral(unsigned int userId);

        

        EDK_API int
                EE_CognitivStopSamplingNeutral(unsigned int userId);

        

        EDK_API int
                EE_CognitivSetSignatureCaching(unsigned int userId, unsigned int enabled);



        EDK_API int
                EE_CognitivGetSignatureCaching(unsigned int userId, unsigned int* pEnabledOut);



        EDK_API int
                EE_CognitivSetSignatureCacheSize(unsigned int userId, unsigned int size);



        EDK_API int
                EE_CognitivGetSignatureCacheSize(unsigned int userId, unsigned int* pSizeOut);



        EDK_API int
                EE_HeadsetGetSensorDetails(EE_InputChannels_t channelId, InputSensorDescriptor_t* pDescriptorOut);



        EDK_API int
                EE_HardwareGetVersion(unsigned int userId, unsigned long* pHwVersionOut);


        EDK_API int
                EE_SoftwareGetVersion(char* pszVersionOut, unsigned int nVersionChars, unsigned long* pBuildNumOut);


        EDK_API int
                EE_HeadsetGetGyroDelta(unsigned int userId, int* pXOut, int* pYOut);


        EDK_API int
                EE_HeadsetGyroRezero(unsigned int userId);


        EDK_API OptimizationParamHandle
                EE_OptimizationParamCreate();


        EDK_API void
                EE_OptimizationParamFree(OptimizationParamHandle hParam);


        EDK_API int
                EE_OptimizationEnable(OptimizationParamHandle hParam);


        EDK_API int
                EE_OptimizationIsEnabled(bool* pEnabledOut);


        EDK_API int
                EE_OptimizationDisable();


        EDK_API int
                EE_OptimizationGetParam(OptimizationParamHandle hParam);


        EDK_API int
                EE_OptimizationGetVitalAlgorithm(OptimizationParamHandle hParam, EE_EmotivSuite_t suite, unsigned int* pVitalAlgorithmBitVectorOut);


        EDK_API int
                EE_OptimizationSetVitalAlgorithm(OptimizationParamHandle hParam, EE_EmotivSuite_t suite, unsigned int vitalAlgorithmBitVector);


    EDK_API int EE_ResetDetection(unsigned int userId, EE_EmotivSuite_t suite, unsigned int detectionBitVector);


        EDK_API DataHandle EE_DataCreate();


        EDK_API void EE_DataFree(DataHandle hData);


        EDK_API int EE_DataUpdateHandle(unsigned int userId, DataHandle hData);


        EDK_API int EE_DataGet(DataHandle hData, EE_DataChannel_t channel, double buffer[], unsigned int bufferSizeInSample);


        EDK_API int EE_DataGetNumberOfSample(DataHandle hData, unsigned int* nSampleOut);


        EDK_API int EE_DataSetBufferSizeInSec(float bufferSizeInSec);


        EDK_API int EE_DataGetBufferSizeInSec(float* pBufferSizeInSecOut);


        EDK_API int EE_DataAcquisitionEnable(unsigned int userId, bool enable);


        EDK_API int EE_DataAcquisitionIsEnabled(unsigned int userId, bool* pEnableOut);


        EDK_API int EE_DataSetSychronizationSignal(unsigned int userId, int signal);


        EDK_API int EE_DataSetMarker(unsigned int userId, int marker);


        EDK_API int EE_DataGetSamplingRate(unsigned int userId, unsigned int* samplingRateOut);
};

#endif