// Translated by Vitaliy Diatlov
// AIMP2: SDK (02.07.2009), v2.60

#ifndef AIMP2_SDK_H
#define AIMP2_SDK_H

#include <windows.h>
#include <unknwn.h>

const char  AIMP2_RemoteClass[] = "AIMP2_RemoteInfo";
const int  AIMP2_RemoteFileSize = 2048;

const int  WM_AIMP_COMMAND = WM_USER + 0x75; // WParam = One of Command, LPARAM - Parameter

const int  WM_AIMP_STATUS_GET = 1;
const int  WM_AIMP_STATUS_SET = 2;//HiWord of LParam - Command, LoWord of LParam - Parameter
const int  WM_AIMP_CALLFUNC = 3;// LPARAM - Func ID (see below Func ID for Addons)
const int  WM_AIMP_GET_VERSION = 4;
const int  WM_AIMP_STATUS_CHANGE = 5;

const int  WM_LANG = WM_USER + 101;

  // CallBack types
const int  AIMP_STATUS_CHANGE     = 1;
const int  AIMP_PLAY_FILE         = 2;
const int  AIMP_INFO_UPDATE       = 5;  // Update Info for current track
const int  AIMP_PLAYER_STATE      = 11; // Play/Pause/Stop
const int  AIMP_EFFECT_CHANGED    = 12; // Balance, Speed, Tempo, Pitch, Flanger and etc.
const int  AIMP_EQ_CHANGED        = 13; // Sliders changed
const int  AIMP_TRACK_POS_CHANGED = 14;

  // AIMP_Status_Set / AIMP_Status_Get
const int  AIMP_STS_VOLUME      = 1;
const int  AIMP_STS_BALANCE     = 2;
const int  AIMP_STS_SPEED       = 3;
const int  AIMP_STS_Player      = 4;
const int  AIMP_STS_MUTE        = 5;
const int  AIMP_STS_REVERB      = 6;
const int  AIMP_STS_ECHO        = 7;
const int  AIMP_STS_CHORUS      = 8;
const int  AIMP_STS_Flanger     = 9;

const int  AIMP_STS_EQ_STS      = 10;
const int  AIMP_STS_EQ_SLDR01   = 11;
const int  AIMP_STS_EQ_SLDR02   = 12;
const int  AIMP_STS_EQ_SLDR03   = 13;
const int  AIMP_STS_EQ_SLDR04   = 14;
const int  AIMP_STS_EQ_SLDR05   = 15;
const int  AIMP_STS_EQ_SLDR06   = 16;
const int  AIMP_STS_EQ_SLDR07   = 17;
const int  AIMP_STS_EQ_SLDR08   = 18;
const int  AIMP_STS_EQ_SLDR09   = 19;
const int  AIMP_STS_EQ_SLDR10   = 20;
const int  AIMP_STS_EQ_SLDR11   = 21;
const int  AIMP_STS_EQ_SLDR12   = 22;
const int  AIMP_STS_EQ_SLDR13   = 23;
const int  AIMP_STS_EQ_SLDR14   = 24;
const int  AIMP_STS_EQ_SLDR15   = 25;
const int  AIMP_STS_EQ_SLDR16   = 26;
const int  AIMP_STS_EQ_SLDR17   = 27;
const int  AIMP_STS_EQ_SLDR18   = 28;

const int  AIMP_STS_REPEAT      = 29;
const int  AIMP_STS_ON_STOP     = 30;
const int  AIMP_STS_POS         = 31;
const int  AIMP_STS_LENGTH      = 32;
const int  AIMP_STS_REPEATPLS   = 33;
const int  AIMP_STS_REP_PLS_1   = 34;
const int  AIMP_STS_KBPS        = 35;
const int  AIMP_STS_KHZ         = 36;
const int  AIMP_STS_MODE        = 37;
const int  AIMP_STS_RADIO       = 38;
const int  AIMP_STS_STREAM_TYPE = 39; // Music / CDA / Radio
const int  AIMP_STS_TIMER       = 40; // Reverse / Normal
const int  AIMP_STS_SHUFFLE     = 41;

const int  AIMP_STS_MAIN_HWND   = 42;
const int  AIMP_STS_TC_HWND     = 43;
const int  AIMP_STS_APP_HWND    = 44;
const int  AIMP_STS_PL_HWND     = 45;
const int  AIMP_STS_EQ_HWND     = 46;

const int  AIMP_STS_TRAY        = 47;

  // Support Exts Flags
const int  AIMP_PLS_EXTS    = 1;
const int  AIMP_AUDIO_EXTS  = 2;

  // Menu IDs
const int  AIMP_MAIN_MENU_OPN   = 0;
const int  AIMP_MAIN_MENU_UTILS = 1;
const int  AIMP_MAIN_MENU_FNC   = 2;
const int  AIMP_MAIN_MENU_CFG   = 3;
const int  AIMP_UTILS_MENU      = 4;
const int  AIMP_PLS_MENU_ADD    = 5;
const int  AIMP_PLS_MENU_JUMP   = 6;
const int  AIMP_PLS_MENU_FNC    = 7;
const int  AIMP_PLS_MENU_SEND   = 8;
const int  AIMP_PLS_MENU_DEL    = 9;
const int  AIMP_ADD_MENU        = 10;
const int  AIMP_DEL_MENU        = 11;
const int  AIMP_FND_MENU        = 12;
const int  AIMP_SRT_MENU        = 13;
const int  AIMP_MSC_MENU        = 14;
const int  AIMP_PLS_MENU        = 15;
const int  AIMP_TRAY_UTILS      = 16;
const int  AIMP_TRAY            = 17;
const int  AIMP_EQ_LIB          = 18;
// use AIMP_UTILS_MENU overthis:
// + AIMP_MAIN_MENU_UTILS = 1;
// + AIMP_TRAY_UTILS      = 16;

  // AIMP_CallFunction
const int  AIMP_OPEN_FILES      = 0;
const int  AIMP_OPEN_DIR        = 1;
const int  AIMP_ABOUT           = 2;
const int  AIMP_SLEEP_TIMER     = 3;
const int  AIMP_UTILS_AC        = 4;
const int  AIMP_UTILS_SR        = 5;
const int  AIMP_UTILS_TE        = 6;
const int  AIMP_UTILS_CDB       = 7;
const int  AIMP_OPTIONS         = 8;
const int  AIMP_PLUGINS         = 9;
const int  AIMP_QUIT            = 10;
const int  AIMP_NEXT_VIS        = 11;
const int  AIMP_PREV_VIS        = 12;
const int AIMP_EQ_ANALOG       = 13;
const int  AIMP_TO_TRAY         = 14;
const int  AIMP_PLAY            = 15;
const int  AIMP_PAUSE           = 16;
const int  AIMP_STOP            = 17;
const int  AIMP_NEXT            = 18;
const int  AIMP_PREV            = 19;
const int  AIMP_ADD_FILES       = 20;
const int  AIMP_ADD_DIR         = 21;
const int  AIMP_ADD_PLS         = 22;
const int  AIMP_ADD_URL         = 23;
const int  AIMP_DEL_FILES       = 24;
const int  AIMP_DEL_BAD         = 25;
const int  AIMP_DEL_FROMHDD     = 26;
const int  AIMP_DEL_OFF         = 27;
const int  AIMP_DEL_OFF_HDD     = 28;
const int  AIMP_RESCAN_PLS      = 29;
const int  AIMP_SHOW_CURFILE    = 30;
const int  AIMP_SORT_INVERT     = 31;
const int  AIMP_SORT_RANDOM     = 32;
const int  AIMP_SORT_TITLE      = 33;
const int  AIMP_SORT_ARTIST     = 34;
const int  AIMP_SORT_FOLDER     = 35;
const int  AIMP_SORT_LENGTH     = 36;
const int  AIMP_SORT_RATING     = 37;
const int  AIMP_SEARCH          = 38;
const int  AIMP_OPEN_PLS        = 39;
const int  AIMP_SAVE_PLS        = 40;
const int  AIMP_PLAY_LAST       = 41;
const int  AIMP_OFF_SELECTED    = 42;
const int  AIMP_ON_SELECTED     = 43;
const int  AIMP_ADD2BOOKMARK    = 44;
const int  AIMP_EDITBOOKMARK    = 45;


  // For AIMP_GetPath
const int  AIMP_CFG_DATA     = 0;
const int  AIMP_CFG_PLS      = 1;
const int  AIMP_CFG_LNG      = 2;
const int  AIMP_CFG_SKINS    = 3;
const int  AIMP_CFG_PLUGINS  = 4;
const int  AIMP_CFG_ICONS    = 5;
const int  AIMP_CFG_ML       = 6;


  // For AIMP_QueryObject
const int  IAIMP2PlayerID           = 0x0001;
const int  IAIMP2PlaylistManagerID  = 0x0003;
const int  IAIMP2ExtendedID         = 0x0004;
const int  IAIMP2CoverArtManagerID  = 0x0005;
const int  IAIMP2PlaylistManager2ID = 0x0006;
const int  IAIMPConfigFileID        = 0x0010;
const int  IAIMPLanguageFileID      = 0x0011;



  // For AIMP_ObjectClass
const int  AIMP_EXT_LC_MESSAGE = 100;
const int  AIMP_EXT_ML_MESSAGE = 101;


  // Option Frame Position Flags
const int  AIMP_FRAME_POS_PLAY     = 1;
const int  AIMP_FRAME_POS_PLAYLIST = 2;
const int  AIMP_FRAME_POS_PLAYER   = 3;
const int  AIMP_FRAME_POS_TEMPLATE = 4;
const int  AIMP_FRAME_POS_SYSTEM   = 5;
const int  AIMP_FRAME_POS_SKINS    = 6;
const int  AIMP_FRAME_POS_LANGS    = 7;

  // AIMP_PLS_SORT_TYPE_XXX
const int  AIMP_PLS_SORT_TYPE_TITLE      = 1;
const int  AIMP_PLS_SORT_TYPE_FILENAME   = 2;
const int  AIMP_PLS_SORT_TYPE_DURATION   = 3;
const int  AIMP_PLS_SORT_TYPE_ARTIST     = 4;
const int  AIMP_PLS_SORT_TYPE_INVERSE    = 5;
const int  AIMP_PLS_SORT_TYPE_RANDOMIZE  = 6;

#pragma pack(push, 1)
struct AIMP2FileInfo
{
    DWORD cbSizeOf;
    //
    BOOL nActive;
    DWORD nBitRate;
    DWORD nChannels;
    DWORD nDuration;
    INT64 nFileSize;
    DWORD nRating;
    DWORD nSampleRate;
    DWORD nTrackID;
    //
    DWORD nAlbumLen;
    DWORD nArtistLen;
    DWORD nDateLen;
    DWORD nFileNameLen;
    DWORD nGenreLen;
    DWORD nTitleLen;
    //
    PWCHAR sAlbum;
    PWCHAR sArtist;
    PWCHAR sDate;
    PWCHAR sFileName;
    PWCHAR sGenre;
    PWCHAR sTitle;
};
#pragma pack(pop)
typedef boolean (WINAPI *AIMPPlaylistDeleteProc)(AIMP2FileInfo AFileInfo, DWORD AUserData);
typedef int (WINAPI *AIMPPlaylistSortProc)(AIMP2FileInfo AFileInfo1, AIMP2FileInfo AFileInfo2, DWORD AUserData);

typedef void (WINAPI *AIMPMenuProc)(DWORD User, void *Handle);

typedef void (WINAPI *AIMPStatusChange)(DWORD User, DWORD CallBackType);

typedef void (WINAPI *CallBackFunc)(DWORD User, DWORD dwCBType);

#pragma pack(push, 1)
struct PLSInfo
{
    PCHAR PLSName;
    DWORD FileCount;
    DWORD PLSDuration;
    INT64 PLSSize;
    int PlaylistID;
};
#pragma pack(pop)

#pragma pack(push, 1)
struct AIMPMenuInfo
{
    boolean Checkbox;
    boolean RadioItem;
    boolean Checked;
    boolean Enabled;
    int ProcPtr; // TAIMPMenuProc;
    HBITMAP Bitmap; // 0 - no bmp
    PWCHAR Caption;
    DWORD User;
};
#pragma pack(pop)

class IPLSStrings
    : public IUnknown
{
public:
    virtual boolean WINAPI AddFile(
        PWCHAR FileName,
        AIMP2FileInfo *FileInfo
        );
    virtual boolean WINAPI DelFile(
        int ID
        );
    virtual PWCHAR WINAPI GetFileName(
        int ID
        );
    virtual boolean WINAPI GetFileInfo(
        int ID,
        AIMP2FileInfo *FileInfo
        );
    virtual DWORD WINAPI GetFileObj(
        int ID
        );
    virtual int WINAPI GetCount();
};

class IAIMP2Controller
    :public IUnknown
{
public:
    virtual boolean WINAPI IsUnicodeVersion();
    virtual boolean WINAPI AIMP_CallBack_Set(
        DWORD dwCBType,
        CallBackFunc CallBackFuncPtr,
        DWORD User
        );
    virtual boolean WINAPI AIMP_CallBack_Remove(
        DWORD dwCBType,
        int ProcPtr
        );
    // Status
    virtual DWORD WINAPI AIMP_Status_Get(
        DWORD StatusType
        );
    virtual boolean WINAPI AIMP_Status_Set(
        DWORD StatusType,
        DWORD Value
        );
    // Playlist
    virtual boolean WINAPI AIMP_PLS_Clear(
        int ID
        );
    virtual boolean WINAPI AIMP_PLS_Delete(
        int ID
        );
    virtual boolean WINAPI AIMP_PLS_New(
        PWCHAR Name
        );
    virtual boolean WINAPI AIMP_PLS_Info(
        int Index,
        PLSInfo *info
        );
    virtual short WINAPI AIMP_PLS_Count();
    virtual boolean WINAPI AIMP_PLS_GetFiles(
        int ID,
        IPLSStrings **Strings
        );
    virtual boolean WINAPI AIMP_PLS_GetSelFiles(
        int ID,
        IPLSStrings **Strings
        );
    virtual boolean WINAPI AIMP_PLS_AddFiles(
        int ID,
        IPLSStrings *Strings
        );
    virtual boolean WINAPI AIMP_PLS_SetPLS(
        int ID
        );
    // System
    virtual boolean WINAPI AIMP_NewStrings(
        IPLSStrings **Strings
        );
    virtual boolean WINAPI AIMP_GetCurrentTrack(
        AIMP2FileInfo *AInfo
        );
    virtual boolean WINAPI AIMP_QueryInfo(
        PWCHAR Filename,
        AIMP2FileInfo *AInfo
        );
    virtual DWORD WINAPI AIMP_GetSystemVersion();
    virtual boolean WINAPI AIMP_CallFunction(
        DWORD FuncID
        );
    virtual int WINAPI AIMP_GetLanguage(
        PWCHAR Str,
        int ACount
        );
    virtual int WINAPI AIMP_GetCfgPath(
        PWCHAR Str,
        int ACount
        );
    virtual int WINAPI AIMP_GetSupportExts(
        DWORD Flags,
        PWCHAR Str,
        int BufSize
        );
    // Menu
    virtual DWORD WINAPI AIMP_GetSupportExts(
        DWORD Parent,
        AIMPMenuInfo *MenuInfo
        );
    virtual DWORD WINAPI AIMP_Menu_Create(
        DWORD MenuID,
        AIMPMenuInfo *MenuInfo
        );
    virtual boolean WINAPI AIMP_Menu_Update(
        int Handle,
        AIMPMenuInfo *MenuInfo
        );
    virtual boolean WINAPI AIMP_Menu_Remove(
        int Handle
        );
   // extention
    virtual boolean WINAPI AIMP_QueryObject(
        DWORD ObjectID,
        void *Obj
        );
};

class IAIMPAddonHeader
    :public IUnknown
{
public:
    virtual BOOL WINAPI GetHasSettingsDialog() = 0;
    virtual PWCHAR WINAPI GetPluginAuthor() = 0;
    virtual PWCHAR WINAPI GetPluginName() = 0;
    virtual void WINAPI Finalize() = 0;
    virtual void WINAPI Initialize(IAIMP2Controller *AController) = 0;
    virtual void WINAPI ShowSettingsDialog(HWND AParentWindow) = 0;
};

typedef IAIMPAddonHeader *(WINAPI *AddonProc)();

typedef BOOL (WINAPI *AIMPAddonHeaderProc)(IAIMPAddonHeader *AHeader);
// Export function name: AIMP_QueryAddonEx

//==============================================================================
// Old Style Addon struct - don't use for new plugins
//==============================================================================

typedef PCHAR (WINAPI *GetPlgNameFunc)();
typedef PCHAR (WINAPI *GetAutorFunc)();
typedef void (WINAPI *InitFunc)(IAIMP2Controller *AIMP);
typedef void (WINAPI *ConfigFunc)(DWORD Handle, DWORD Win);
typedef void (WINAPI *FreeFunc)();

#pragma pack(push, 1)
struct AIMPAddonHeader
{
    DWORD version;
    DWORD DllInstance;
    GetPlgNameFunc PlgNameFuncPtr;
    GetAutorFunc AutorFuncPtr;
    InitFunc InitFuncPtr;
    ConfigFunc ConfigFuncPtr;
    FreeFunc FreeFuncPtr;
};
#pragma pack(pop)

//==============================================================================

class IAIMP2OptionFrame
    :public IUnknown
{
public:
    virtual HWND WINAPI FrameCreate(
        HWND AParent
        );
    virtual void *WINAPI FrameData(
        );  // reserved
    virtual int WINAPI FrameFlags(
        );  // See FramePositionFlags
    virtual PWCHAR WINAPI FrameName(
        );
    virtual HWND WINAPI FrameFree(
        HWND AWindow
        );
    virtual void WINAPI FrameLoadConfigNotify(
        );
    virtual void WINAPI FrameSaveConfigNotify(
        );
};

class IAIMP2Player
    : public IUnknown
{
public:
    virtual int WINAPI Version();
    virtual boolean WINAPI PlayTrack(
        int ID,
        int ATrackIndex
        );
    virtual void WINAPI PlayOrResume();
    virtual void WINAPI Pause();
    virtual void WINAPI Stop();
    virtual void WINAPI NextTrack();
    virtual void WINAPI PrevTrack();
};

class IAIMP2PlaylistManager
    : public IUnknown
{
public:
    virtual int WINAPI AIMP_PLS_CreateFromFile(
        PWCHAR AFile,
        boolean AActivate,
        boolean AStartPlay
        );
    virtual int WINAPI AIMP_PLS_ID_ActiveGet();
    virtual boolean WINAPI AIMP_PLS_ID_ActiveSet(
        int ID
        );
    virtual int WINAPI AIMP_PLS_ID_PlayingGet();
    virtual int WINAPI AIMP_PLS_ID_PlayingGetTrackIndex(
        int ID
        );
    virtual int WINAPI AIMP_PLS_NewEx(
        PWCHAR AName,
        boolean AActivate
        );
    virtual boolean WINAPI AIMP_PLS_PlayFile(
        PWCHAR AFileName,
        boolean AFailIfNotExists
        );
    // Playlist Processing
    virtual boolean WINAPI AIMP_PLS_DeleteByFilter(
        int ID,
        DWORD AFilterProc,
        DWORD AUserData
        );
    virtual boolean WINAPI AIMP_PLS_SortByFilter(
        int ID,
        DWORD AFilterProc,
        DWORD AUserData
        );
    // Entries
    virtual boolean WINAPI AIMP_PLS_Entry_Delete(
        int ID,
        int AEntryIndex
        );
    virtual boolean WINAPI AIMP_PLS_Entry_DeleteAll(
        int ID
        );
    virtual boolean WINAPI AIMP_PLS_Entry_FileNameGet(
        int ID,
        int AEntryIndex,
        PWCHAR PBuf,
        DWORD ABufLen
        );
    virtual boolean WINAPI AIMP_PLS_Entry_FileNameSet(
        int ID,
        int AEntryIndex,
        PWCHAR PBuf
        );
    virtual int WINAPI AIMP_PLS_Entry_FocusedGet(
        int ID
        );
    virtual boolean WINAPI AIMP_PLS_Entry_FocusedSet(
        int ID,
        int AEntryIndex
        );
    virtual boolean WINAPI AIMP_PLS_Entry_InfoGet(
        int ID,
        int AEntryIndex,
        AIMP2FileInfo *PFileInfo
        );
    virtual boolean WINAPI AIMP_PLS_Entry_InfoSet(
        int ID,
        int AEntryIndex,
        AIMP2FileInfo *PFileInfo
        );
    virtual boolean WINAPI AIMP_PLS_Entry_PlayingSwitchGet(
        int ID,
        int AEntryIndex
        );
    virtual boolean WINAPI AIMP_PLS_Entry_PlayingSwitchSet(
        int ID,
        int AEntryIndex,
        boolean ASwitch
        );
    virtual boolean WINAPI AIMP_PLS_Entry_ReloadInfo(
        int ID,
        int AEntryIndex
        );
    // Load/Save Playlists
    virtual boolean WINAPI AIMP_PM_DestroyStream(
        DWORD AHandle
        );
    virtual DWORD WINAPI AIMP_PM_ReadItem(
        DWORD AHandle,
        AIMP2FileInfo *PItem
        );
    virtual DWORD WINAPI AIMP_PM_ReadStream(
        PWCHAR AFileName,
        int *Count
        );
    virtual DWORD WINAPI AIMP_PM_SaveStream(
        PWCHAR AFileName
        );
    virtual DWORD WINAPI AIMP_PM_WriteItem(
        DWORD AHandle,
        AIMP2FileInfo *PItem
        );
    // added in 2.50 B295
    virtual boolean WINAPI AIMP_PLS_ID_PlayingSetTrackIndex(
        int ID,
        int AEntryIndex
        );
};

class IAIMP2PlaylistManager2
    : public IAIMP2PlaylistManager
{
public:
    // Count of loaded playlists
    virtual unsigned short WINAPI AIMP_PLS_Count();
    // Return = -1 - ID is not valid, otherthis - count of files in playlist
    virtual int WINAPI AIMP_PLS_GetFilesCount(int ID);
    virtual HRESULT WINAPI AIMP_PLS_GetInfo(int ID, INT64 *ADuration, INT64 *ASize);
    virtual HRESULT WINAPI AIMP_PLS_GetName(int ID, PWCHAR ABuffer, int ABufferSizeInChars);
    // Custom Sorting, see AIMP_PLS_SORT_TYPE_XXX
    virtual HRESULT WINAPI AIMP_PLS_Sort(int ID, int ASortType);
    virtual HRESULT WINAPI AIMP_PLS_SortByTemplate(int ID, PWCHAR ABuffer, int ABufferSizeInChars);
    // if Index = -1 returned ID of current playlist.
    virtual HRESULT WINAPI AIMP_PLS_ID_By_Index(int Index, int *ID);
    // Get Formated title for Entry
    virtual HRESULT WINAPI AIMP_PLS_Entry_GetTitle(int ID, int AEntryIndex,
      PWCHAR ABuffer, int ABufferSizeInChars);
    // Set Entry to playback queue
    virtual HRESULT WINAPI AIMP_PLS_Entry_QueueRemove(int ID, int AEntryIndex);
    virtual HRESULT WINAPI AIMP_PLS_Entry_QueueSet(int ID, int AEntryIndex, BOOL AInsertAtQueueBegining);
    // Moving Entry
    virtual HRESULT WINAPI AIMP_PLS_Entry_SetPosition(int ID, int AEntryIndex, int ANewEntryIndex);
};

// See IAIMP2ExtendedID
class IAIMP2Extended
    :public IUnknown
{
public:
    virtual int WINAPI AIMP_GetPath(
        int ID,
        PWCHAR buffer,
        int bufSize
        );
    virtual boolean WINAPI AIMP_ObjectClass(
        int ID,
        void *AData,
        boolean ARegister
        );
    // User Option Dialogs
    virtual DWORD WINAPI AIMP_Options_FrameAdd(
        IAIMP2OptionFrame *AFrame
        );
    virtual DWORD WINAPI AIMP_Options_FrameRemove(
        IAIMP2OptionFrame *AFrame
        );
    virtual DWORD WINAPI AIMP_Options_ModifiedChanged(
        IAIMP2OptionFrame *AFrame
        );
};

class IAIMP2CoverArtManager
    :public IUnknown
{
public:
    // Return picture will be proportional stretched to ADisplaySize value
    virtual HBITMAP WINAPI GetCoverArtForFile(PWCHAR AFile, const SIZE *ADisplaySize);
    // Draw CoverArt of playing file, Return - cover art drawing successfuly
    // CoverArt will be proportional stretched to R value
    virtual HRESULT WINAPI CurrentCoverArtDraw(HDC DC, const RECT *R);
    // Return <> S_OK, CoverArt is empty or file are not playing
    virtual HRESULT WINAPI CurrentCoverArtGetSize(SIZE *ASize);
    // W, H - destination display sizes, function will correct sizes for proportional drawing
    // Return <> S_OK, CoverArt is empty or file are not playing
    virtual HRESULT WINAPI CurrentCoverArtCorrectSizes(int *W, int *H);
};

  // See IAIMPLanguageFileID
class IAIMPLanguageFile
    :public IUnknown
{
public:
    virtual int AIMP_Lang_Version();
    virtual int AIMP_Lang_CurrentFile(PWCHAR ABuffer, int ABufferSizeInChars);
    virtual HRESULT AIMP_Lang_IsSectionExists(PWCHAR ASectionName, int ASectionNameSizeInChars);
    virtual HRESULT AIMP_Lang_ReadString(PWCHAR ASectionName, PWCHAR AItemName, PWCHAR AValueBuffer,
      int ASectionNameSizeInChars, int AItemNameSizeInChars, int AValueBufferSizeInChars);
    // When Language changed AIMP will send to window handle "WM_LANG" message
    virtual HRESULT AIMP_Lang_Notification(HWND AWndHandle, BOOL ARegister);
};

// See IAIMPConfigFileID
class IAIMPConfigFile
    :public IUnknown
{
    // functions return null value, if value don't exists in configuration file
    virtual HRESULT AIMP_Config_ReadString(PWCHAR ASectionName, PWCHAR AItemName, PWCHAR AValueBuffer,
        int ASectionNameSizeInChars, int AItemNameSizeInChars, int AValueBufferSizeInChars);
    virtual HRESULT AIMP_Config_ReadInteger(PWCHAR ASectionName, PWCHAR AItemName,
        int ASectionNameSizeInChars, int AItemNameSizeInChars, int * AValue);
    //
    virtual HRESULT AIMP_Config_WriteString(PWCHAR ASectionName, PWCHAR AItemName, PWCHAR AValueBuffer,
      int ASectionNameSizeInChars, int AItemNameSizeInChars, int AValueBufferSizeInChars);
    virtual HRESULT AIMP_Config_WriteInteger(PWCHAR ASectionName, PWCHAR AItemName,
      int ASectionNameSizeInChars, int AItemNameSizeInChars, int AValue);
    //
    virtual HRESULT AIMP_Config_IsSectionExists(PWCHAR ASectionName, int ASectionNameSizeInChars);
    virtual HRESULT AIMP_Config_RemoveSection(PWCHAR ASectionName, int ASectionNameSizeInChars);
};

//==============================================================================
// V I S U A L S
//==============================================================================

const int  VIS_RQD_DATA_WAVE       = 1;
const int  VIS_RQD_DATA_SPECTRUM   = 2;
const int  VIS_RQD_NOT_SUSPEND     = 4;

typedef short WaveForm[2][512];
typedef short Spectrum[2][256];

struct AIMPVisualData
{
    int LevelR;
    int LevelL;
    Spectrum spectrum;
    WaveForm waveForm;
};

typedef AIMPVisualData *PAIMPVisualData;

class IAIMP2VisualPlugin
    :public IUnknown
{
public:
    virtual PWCHAR WINAPI AuthorName();
    virtual PWCHAR WINAPI PluginName();
    virtual PWCHAR WINAPI PluginInfo();
    virtual DWORD WINAPI PluginFlags();
    virtual BOOL WINAPI Initialize();
    virtual void WINAPI Deinitialize();
    virtual void WINAPI DisplayClick(int X, int Y);
    virtual void WINAPI DisplayRender(HDC DC, PAIMPVisualData AData);
    virtual void WINAPI DisplayResize(int AWidth, int AHeight);
};

// Export function name: AIMP_QueryVisual
typedef IAIMP2VisualPlugin *(WINAPI *AIMPVisualProc)();

#endif