#ifndef CREAMTRACKERENGINE_H
#define CREAMTRACKERENGINE_H

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

//#define CreamTrackerPortable
#define CreamTrackerMinimalPlayer
#define CreamTrackerCompact
#define CreamTrackerMultithreading
#define CreamTrackerSINCResampling
//#define CreamTrackerSampleLoopCrossFade
#define CreamTrackerCode
//#define CreamTrackerTRICode
//#define CreamTrackerWRS
//#define CreamTrackerPCM
//#define CreamTrackerDPCM4
//#define CreamTrackerADPCMIMA
//#define CreamTrackerDeltaPCM
#define CreamTrackerStrippedPatterns
//#define CreamTrackerNormalPatterns
#define CreamTrackerFFT

//#define CreamTrackerThreadPriority
//#define CreamTrackerThreadAffinity

//#define CreamTrackerEffectAxx
//#define CreamTrackerEffectBxx
//#define CreamTrackerEffectCxx
#define CreamTrackerEffectDxx
//#define CreamTrackerEffectExx
//#define CreamTrackerEffectFxx
//#define CreamTrackerEffectGxx
//#define CreamTrackerEffectHxx
//#define CreamTrackerEffectIxx
//#define CreamTrackerEffectJxx
//#define CreamTrackerEffectKxx
//#define CreamTrackerEffectLxx
#define CreamTrackerEffectMxx
//#define CreamTrackerEffectNxx
//#define CreamTrackerEffectOxx
//#define CreamTrackerEffectPxx
//#define CreamTrackerEffectQxx
//#define CreamTrackerEffectRxx
//#define CreamTrackerEffectSxx
//#define CreamTrackerEffectS0x
//#define CreamTrackerEffectS1x
//#define CreamTrackerEffectS2x
//#define CreamTrackerEffectS3x
//#define CreamTrackerEffectS4x
//#define CreamTrackerEffectS5x
//#define CreamTrackerEffectS6x
//#define CreamTrackerEffectS7x
//#define CreamTrackerEffectS8x
//#define CreamTrackerEffectS9x
//#define CreamTrackerEffectSAx
//#define CreamTrackerEffectSBx
//#define CreamTrackerEffectSCx
//#define CreamTrackerEffectSDx
//#define CreamTrackerEffectSEx
//#define CreamTrackerEffectSFx
//#define CreamTrackerEffectTxx
//#define CreamTrackerEffectUxx
#define CreamTrackerEffectVxx
//#define CreamTrackerEffectWxx
//#define CreamTrackerEffectXxx
//#define CreamTrackerEffectYxx
//#define CreamTrackerEffectZxx

#define CREAMTRACKERENGINE_USE_STDINT

#include <stdio.h>
#include <stdlib.h>
#ifdef CREAMTRACKERENGINE_USE_STDINT
#include <stdint.h>
#endif
#include <string.h>
#include <math.h>

#ifndef CreamTrackerPortable
#include <windows.h>
#endif

#ifdef _MSC_VER
// MSVC
#define CTE_PACK(decl) __pragma(pack(push, 1)) decl __pragma(pack(pop))
#define CTE_PACK_ALIGNED(decl, alignment) __pragma(pack(push, alignment)) decl __pragma(pack(pop))
#define CTE_likely(x)
#define CTE_unlikely(x)
#define CTE_restrict __restrict
#define CTE_POSSIBLY_UNUSED(x) x
#define CTE_WARN_UNUSED_RES
#define CTE_PRINTF_FORMAT(x, y)
#define CTE_WEAK_SYMBOL(x) x
#define CTE_PURE
#define CTE_CDECL __cdecl
#define CTE_STDCALL __stdcall
#define CTE_FASTCALL __fastcall
#define CTE_INLINE inline
#else
// GCC, TCC and clang. Other C99-capable compilers are on my ignore-list
#ifdef __TINYC__
#define CTE_GCC_COMPATIBLE
#endif
#ifdef __GNUC__
#define CTE_GCC_COMPATIBLE
#endif
#ifdef __clang__
#define CTE_GCC_COMPATIBLE
#endif
#ifdef CTE_GCC_COMPATIBLE
#define CTE_PACK(decl) decl __attribute__((__packed__))
#define CTE_PACK_ALIGNMENT(decl, alignment) decl __attribute__((__packed__, __aligned__(alignment)))
#define CTE_likely(x) __builtin_expect(!!(x), 1)
#define CTE_unlikely(x) __builtin_expect(!!(x), 0)
#define CTE_restrict __restrict__
#define CTE_POSSIBLY_UNUSED(x) x __attribute__((unused))
#define CTE_WARN_UNUSED_RES __attribute__((warn_unused_result))
#define CTE_PRINTF_FORMAT(x, y) __attribute__((format(printf, x, y)))
#define CTE_WEAK_SYMBOL(x) x __attribute__((weak))
#define CTE_PURE __attribute__((pure))
#define CTE_CDECL __attribute__((__cdecl__))
#define CTE_STDCALL __attribute__((__stdcall__))
#define CTE_FASTCALL __attribute__((__fastcall__))
#define CTE_INLINE inline
#else
#error "Non-supported C compiler!"
#endif
#endif

#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
#define CTE_C99
#include <inttypes.h>
#else
#undef CTE_C99
#endif

#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
#define CTE_C11
#else
#undef CTE_C11
#endif

#ifndef cte_malloc
#define cte_malloc malloc
#endif

#ifndef cte_realloc
#define cte_realloc realloc
#endif

#ifndef cte_free
#define cte_free free
#endif

#ifdef CREAMTRACKERENGINE_USE_STDINT
typedef int8_t cte_char_t;
typedef int8_t cte_int8_t;
typedef int16_t cte_int16_t;
typedef int32_t cte_int32_t;
typedef int64_t cte_int64_t;

typedef uint8_t cte_uchar_t;
typedef uint8_t cte_uint8_t;
typedef uint16_t cte_uint16_t;
typedef uint32_t cte_uint32_t;
typedef uint64_t cte_uint64_t;

typedef float cte_float_t;
typedef double cte_double_t;

typedef uint32_t cte_longbool_t;
#else
#ifndef CREAMTRACKERENGINE_USE_OWN_TYPES
typedef signed char cte_char_t;
typedef signed char cte_int8_t;
typedef signed short cte_int16_t;
typedef signed long int cte_int32_t;
typedef signed long long cte_int64_t;

typedef unsigned char cte_uchar_t;
typedef unsigned char cte_uint8_t;
typedef unsigned short cte_uint16_t;
typedef unsigned long int cte_uint32_t;
typedef unsigned long long cte_uint64_t;

typedef float cte_float_t;
typedef double cte_double_t;

typedef unsigned long int cte_longbool_t;
#endif
#endif

typedef void *cte_pointer;

typedef cte_char_t *cte_char_p;
typedef cte_int8_t *cte_int8_p;
typedef cte_int16_t *cte_int16_p;
typedef cte_int32_t *cte_int32_p;
typedef cte_int64_t *cte_int64_p;

typedef cte_uchar_t *cte_uchar_p;
typedef cte_uint8_t *cte_uint8_p;
typedef cte_uint16_t *cte_uint16_p;
typedef cte_uint32_t *cte_uint32_p;
typedef cte_uint64_t *cte_uint64_p;

typedef cte_float_t *cte_float_p;
typedef cte_double_t *cte_double_p;

#ifndef CreamTrackerPortable
typedef HANDLE cte_handle_t;
typedef DWORD cte_threadID_t;

typedef cte_handle_t *cte_handle_p;
typedef cte_threadID_t *cte_threadID_p;
#endif

typedef cte_longbool_t *cte_longbool_p;

#define CTE_FALSE (0)

#define CTE_TRUE (1)

#define PositionFactor (0x100000000ull)

#define InvPositionFactor (1.0 / ((cte_double_t)PositionFactor));

#define PositionAllRemainBits 24
#define PositionAllRemainFactor (1<<PositionAllRemainBits)

#define AddKillDenormal (1e-24f)

#define fDenormal (1e-18f)

#define FixUpSampleLength 1024

#define SafeAdditionalSampleLength 1024

#define TotalFixUpSafeAdditionalSampleLength (FixUpSampleLength+SafeAdditionalSampleLength)

#define MaxReverbAllPassFilters 16

#define MaxEnvelopes 16

#define MaxEnvelopeNodes 128

#define SubSamples 1024

#define fCI12 (1.0 / 12.0)
#define fCI24 (1.0 / 24.0)
#define fCI64 (1.0 / 64.0)
#define fCI127 (1.0 / 127.0)
#define fCI128 (1.0 / 128.0)
#define fCI128_4 (4.0 / 128.0)
#define fCI255 (1.0 / 255.0)
#define fCI256 (1.0 / 256.0)
#define fCI256_4 (4.0 / 256.0)

#define ftNONE 0
#define ftLOWPASS 1
#define ftHIGHPASS 2
#define ftBANDPASS 3
#define ftBANDREJECT 4
#define ftPEAK 5
#define ftALLPASS 6CTE_PACK

#define MaxThreads 64

#define ThreadTimeOut 1000

#define ctjmCHANNELMIX 0

#pragma pack(push,1)
typedef struct {
	cte_uint8_t Value;
	cte_uint8_t Slot;
} TCreamTrackerValue;
#pragma pack(pop)

typedef TCreamTrackerValue *PCreamTrackerValue;

typedef cte_int32_t *PCreamTrackerInt32;

#pragma pack(push,1)
typedef union {
	cte_int64_t Value;
	struct {
#ifdef __BIG_ENDIAN__
		cte_int32_t Hi;
		cte_uint32_t Lo;
#else
		cte_uint32_t Lo;
		cte_int32_t Hi;
#endif
	} HiLo;
} TCreamTrackerInt64;
#pragma pack(pop)

typedef TCreamTrackerInt64 *PCreamTrackerInt64;

#pragma pack(push,1)
typedef union {
	cte_float_t Values[2];
	struct {
		cte_float_t Left;
		cte_float_t Right;
	} LeftRight;
} TCreamTrackerBufferSample;
#pragma pack(pop)

typedef TCreamTrackerBufferSample *PCreamTrackerBufferSample;

typedef TCreamTrackerBufferSample TCreamTrackerBufferSamples[1];

typedef TCreamTrackerBufferSamples *PCreamTrackerBufferSamples;

typedef cte_uchar_t TCreamTrackerChunkSignature[4];

typedef TCreamTrackerChunkSignature *PCreamTrackerChunkSignature;

#pragma pack(push,1)
typedef struct {
	TCreamTrackerChunkSignature Signature;
	cte_int32_t Size;
} TCreamTrackerChunk;
#pragma pack(pop)

typedef TCreamTrackerChunk *PCreamTrackerChunk;

typedef struct {
	cte_uint32_t XorShift128x;
	cte_uint32_t XorShift128y;
	cte_uint32_t XorShift128z;
	cte_uint32_t XorShift128w;
	cte_uint32_t LCG;
	cte_uint32_t MWCx;
	cte_uint32_t MWCy;
	cte_uint32_t MWCc;
} TCreamTrackerRandomGenerator;

typedef TCreamTrackerRandomGenerator *PCreamTrackerRandomGenerator;

#pragma pack(push,1)
typedef struct {
	cte_uint8_t Note;
	cte_uint8_t Instrument;
	cte_uint8_t Volume;
	cte_uint8_t Effect;
	cte_uint8_t EffectParameter;
} TCreamTrackerPatternNote;
#pragma pack(pop)

typedef TCreamTrackerPatternNote *PCreamTrackerPatternNote;

typedef TCreamTrackerPatternNote TCreamTrackerPattern[64][32];

typedef TCreamTrackerPattern *PCreamTrackerPattern;

typedef TCreamTrackerPattern TCreamTrackerPatterns[256];

typedef TCreamTrackerPatterns *PCreamTrackerPatterns;

#pragma pack(push,1)
typedef struct {
	cte_uint8_t InstrumentType;
	cte_uchar_t FileName[12];
	cte_uint8_t Offset[3];
	cte_int32_t Length;
	cte_int32_t LoopStart;
	cte_int32_t LoopEnd;
	cte_uint8_t Volume;
	cte_uint8_t CrossfadeType;
	cte_uint8_t Format;
	cte_uint8_t Flags;
	cte_uint32_t C4Speed;
	cte_int32_t CrossfadeStart;
	cte_uint32_t ExtOffset;
	cte_uint8_t Dummy[4];
	cte_uchar_t SampleName[28];
	cte_uchar_t Signature[4];
} TCreamTrackerInstrumentHeader;
#pragma pack(pop)

typedef TCreamTrackerInstrumentHeader *PCreamTrackerInstrumentHeader;

#ifdef CreamTrackerCode
typedef struct {
	cte_int32_t Synth;
	cte_int32_t Instances;
	cte_uchar_p CodeText;
	cte_int32_t CodeTextAllocated;
	cte_int32_t CodeTextSize;
#ifdef CreamTrackerTRICode
	cte_pointer TRIData;
	cte_int32_t TRIDataSize;
	cte_pointer TRIInstance;
#endif
	cte_pointer Instance;
	cte_pointer InstanceData;
	cte_int32_t InstanceDataSize;
	cte_int32_t InstanceWorkDataSize;
	void (CTE_STDCALL *ProcInitialize)(cte_int32_t SampleRate);
	void (CTE_STDCALL *ProcDeinitialize)();
	void (CTE_STDCALL *ProcReset)();
	void (CTE_STDCALL *SynthProcInstanceInitialize)(cte_int32_t ChannelIndex);
	void (CTE_STDCALL *SynthProcInstanceDeinitialize)();
	void (CTE_STDCALL *SynthProcInstanceReset)();
	void (CTE_STDCALL *SynthProcInstanceNoteOn)(cte_int32_t Note);
	void (CTE_STDCALL *SynthProcInstanceNoteOff)();
	cte_int32_t (CTE_STDCALL *SynthProcInstanceProcess)(cte_pointer Buffer, cte_int32_t Samples, cte_float_t PhaseIncrement);
	cte_int32_t (CTE_STDCALL *SampleProcProcess)(cte_pointer Dest);
	void (CTE_STDCALL *GlobalProcProcess)(cte_pointer GlobalBuffer, cte_pointer ChannelBuffers, cte_int32_t Samples);
	void (CTE_STDCALL *GlobalProcProcessPatternNote)(cte_int32_t Pattern, cte_int32_t Row, cte_int32_t Tick, cte_int32_t Channel, cte_int32_t Note, cte_int32_t Instrument, cte_int32_t Volume, cte_int32_t Effect, cte_int32_t EffectParameter);
} TCreamTrackerCodeData;

typedef TCreamTrackerCodeData *PCreamTrackerCodeData;
#endif

typedef struct {
	TCreamTrackerInstrumentHeader Header;
	cte_pointer Data;
#ifdef CreamTrackerSINCResampling
	cte_float_p SINCLeftData;
	cte_float_p SINCRightData;
#else
	cte_pointer MixData;
#endif
	cte_pointer RawData;
	cte_int32_t RawLen;
#ifdef CreamTrackerCode
	PCreamTrackerCodeData CodeData;
#endif
} TCreamTrackerInstrument;

typedef TCreamTrackerInstrument *PCreamTrackerInstrument;

typedef TCreamTrackerInstrument TCreamTrackerInstruments[101];

typedef TCreamTrackerInstruments *PCreamTrackerInstruments;

typedef struct {
	cte_pointer Instance;
	cte_pointer Channel;
} TCreamTrackerInstanceStubData;

typedef TCreamTrackerInstanceStubData *PCreamTrackerInstanceStubData;

#pragma pack(push,1)
typedef struct {
	cte_uchar_t Name[28];
	cte_uchar_t EOFChar;
	cte_uint8_t Type_;
	cte_uint16_t Dummy;
	cte_uint16_t OrdNum;
	cte_uint16_t InsNum;
	cte_uint16_t PatNum;
	cte_uint16_t Flags;
	cte_uint16_t CWTV;
	cte_uint16_t FileFormatInformation;
	cte_uchar_t Signature[4];
	cte_uint8_t GlobalVolume;
	cte_uint8_t InitialSpeed;
	cte_uint8_t InitialTempo;
	cte_uint8_t MasterVolume;
	cte_uint8_t UltraClickRemoval;
	cte_uint8_t Panning;
	cte_uint32_t Data;
	cte_uint8_t RowHilightMinor;
	cte_uint8_t RowHilightMajor;
	cte_uint16_t Dummy2;
	cte_uint16_t Special;
	cte_uint8_t ChannelSettings[32];
} TCreamTrackerHeader;
#pragma pack(pop)

typedef TCreamTrackerHeader *PCreamTrackerHeader;

typedef cte_uint8_t TCreamTrackerOrders[256];

typedef TCreamTrackerOrders *PCreamTrackerOrders;

typedef cte_float_t TCreamTrackerBuffer[SubSamples * 2];

typedef TCreamTrackerBuffer *PCreamTrackerBuffer;

#ifdef CreamTrackerCode
typedef cte_uint8_t TCreamTrackerValueMemory[64];

typedef TCreamTrackerValueMemory *PCreamTrackerValueMemory;

typedef cte_uint8_t TCreamTrackerChannelValueMemory[64];

typedef TCreamTrackerChannelValueMemory *PCreamTrackerChannelValueMemory;

typedef cte_uint8_t TCreamTrackerChannelData[1 << 16];

typedef TCreamTrackerChannelData *PCreamTrackerChannelData;

typedef TCreamTrackerChannelData TCreamTrackerChannelDataArray[32];

typedef TCreamTrackerChannelDataArray *PCreamTrackerChannelDataArray;
#endif

typedef struct {
	cte_pointer Instance;
	cte_pointer Master;
#ifdef CreamTrackerCode
  PCreamTrackerChannelValueMemory ValueMemory;
#endif
	cte_int32_t Index;
	cte_longbool_t Active;
	cte_longbool_t Enabled;
	cte_longbool_t Muted;
	cte_longbool_t NewNote;
	cte_longbool_t FastRamping;
	cte_double_t C4SpeedFactor;
	cte_double_t NoteFrequencyFactor;
	cte_float_t LastLeftClickRemovalFadeOut;
	cte_float_t LastRightClickRemovalFadeOut;
	cte_float_t LastLeft;
	cte_float_t LastRight;
	cte_uint32_t LastInstrument;
	PCreamTrackerInstrument Instrument;
	cte_uint32_t BaseNote;
	TCreamTrackerInt64 SamplePosition;
	cte_uint32_t VibratoPosition;
	cte_uint32_t VibratoWaveForm;
	cte_uint32_t TremoloWaveForm;
	cte_double_t SynthFrequency;
	cte_float_t SynthIncrement;
	cte_double_t LivePeriod;
	cte_double_t SlideToPeriod;
	cte_double_t StablePeriod;
	cte_double_t LiveIncrement;
	cte_int64_t Increment;
	cte_int32_t SINCCutOffLevel;
	cte_double_t Volume;
	cte_int32_t Velocity;
	cte_int32_t Glissando;
	cte_uint32_t ArpeggioPos;
	cte_uint32_t LastEffectParameter;
	cte_uint32_t LastVibrato;
	cte_uint32_t LastPortamento;
#ifdef CreamTrackerEffectQxx
	cte_int32_t RetrigCounter;
#endif
	cte_int32_t NoteOnTick;
	cte_int32_t NoteCutTick;
	cte_int32_t NoteCutCounter;
	cte_uint32_t SampleHighOffset;
#ifdef CreamTrackerEffectIxx
	cte_uint32_t TremorCounter;
	cte_uint32_t TremorParameter;
#endif
	cte_int32_t Panning;
	cte_int32_t ChannelVolume;
	cte_float_t LeftVolume;
	cte_float_t RightVolume;
	cte_float_t LeftVolumeCurrent;
	cte_float_t RightVolumeCurrent;
	cte_float_t LeftVolumeInc;
	cte_float_t RightVolumeInc;
	cte_int32_t VolumeRampingRemain;
	cte_float_t ChannelBufferVolume;
	cte_float_t ChannelBufferVolumeCurrent;
	cte_float_t ChannelBufferVolumeInc;
	cte_int32_t ChannelBufferVolumeRampingRemain;
	TCreamTrackerPatternNote PatternNote;
#ifdef CreamTrackerGUI
	TCreamTrackerPatternNote InjectPatternNote;
	cte_longbool_t HasInjectPatternNote;
#endif
	TCreamTrackerBuffer Buffer;
	TCreamTrackerBuffer TempBuffer;
} TCreamTrackerChannel;

typedef TCreamTrackerChannel *PCreamTrackerChannel;

typedef TCreamTrackerChannel TCreamTrackerChannels[64];

typedef TCreamTrackerChannels *PCreamTrackerChannels;

typedef cte_uint8_t TCreamTrackerChannelPannings[32];

typedef TCreamTrackerChannelPannings *PCreamTrackerChannelPannings;

typedef struct {
	cte_int32_t PrevSample;
	cte_int32_t StepIndex;
} TCreamTrackerADPCMIMAState;

typedef TCreamTrackerADPCMIMAState *PCreamTrackerADPCMIMAState;

#ifdef CreamTrackerMultithreading
typedef cte_int32_t TCreamTrackerJobMode;

typedef struct {
	TCreamTrackerJobMode Mode;
	cte_int32_t Samples;
	cte_longbool_t NewTick;
	cte_pointer Instance;
	PCreamTrackerChannel Channel;
} TCreamTrackerJob;

typedef TCreamTrackerJob *PCreamTrackerJob;

typedef TCreamTrackerJob TCreamTrackerJobs[64];

typedef TCreamTrackerJobs *PCreamTrackerJobs;

typedef struct {
	cte_pointer Instance;
	cte_int32_t ThreadNumber;
	cte_handle_t ThreadHandle;
	cte_threadID_t ThreadID;
	cte_handle_t Event;
	cte_handle_t DoneEvent;
} TCreamTrackerJobThread;

typedef TCreamTrackerJobThread *PCreamTrackerJobThread;

typedef TCreamTrackerJobThread TCreamTrackerJobThreads[MaxThreads];

typedef TCreamTrackerJobThreads *PCreamTrackerJobThreads;

typedef struct {
	TCreamTrackerJobs Jobs;
	cte_int32_t JobQueueIndex;
	cte_int32_t CountJobs;
	TCreamTrackerJobThreads Threads;
	cte_int32_t CountThreads;
	cte_handle_t DoneEventHandles[MaxThreads];
} TCreamTrackerJobManager;

typedef TCreamTrackerJobManager *PCreamTrackerJobManager;

#endif

typedef struct {
	TCreamTrackerHeader Header;
	cte_longbool_t CreamTrackerModule;
	TCreamTrackerPatterns Patterns;
	TCreamTrackerOrders Orders;
	TCreamTrackerInstruments Instruments;
	TCreamTrackerChannelPannings ChannelPannings;
#ifdef CreamTrackerCode
  TCreamTrackerValueMemory ValueMemory;
	TCreamTrackerChannelValueMemory ChannelValueMemory[64];
#endif
	PCreamTrackerChannel CurrentChannel;
	TCreamTrackerChannels Channels;
	cte_int32_t ChannelOrder[64];
	cte_int32_t SampleRate;
	cte_double_t InvSampleRate;
	cte_int32_t TickSamples;
	cte_int32_t TickSamplesRemain;
	cte_double_t HertzRatio;
	cte_double_t CurrentTime;
	cte_double_t NoteFactorTable[16];
	cte_double_t NoteToPeriodTable[195];
	cte_float_t ClickRemovalFadeOutFactor;
	cte_float_t SmoothFactor;
	cte_float_t DCFilterCoef;
	cte_int32_t Speed;
	cte_int32_t Tempo;
	cte_double_t GlobalVolume;
	cte_int32_t NextRow;
	cte_int32_t NextOrder;
#ifndef CreamTrackerCompact
	cte_int32_t ForceOrder;
	cte_int32_t ForceRow;
#endif
	cte_int32_t Row;
	cte_int32_t Order;
	cte_int32_t Pattern;
	cte_int32_t Tick;
	cte_int32_t AbsoluteTick;
	cte_int32_t FrameDelay;
	cte_int32_t PatternDelay;
	cte_int32_t PatternDelayRowCounter;
	cte_longbool_t FirstTick;
	cte_longbool_t FirstRowTick;
	cte_longbool_t VeryFirstTick;
	cte_longbool_t TrackEnd;
	cte_longbool_t PatternLoop;
	cte_int32_t RepeatCounter;
	cte_int32_t RepeatCounters[256];
	cte_int32_t RepeatRowCounters[256][64];
	cte_int32_t LoopRow;
	cte_int32_t LoopRowCounter;
	cte_uint32_t PatternRandom;
	cte_float_t BufferVolume;
	cte_float_t BufferVolumeCurrent;
	cte_float_t BufferVolumeInc;
	cte_int32_t BufferVolumeRampingRemain;
	cte_longbool_t Playing;
	cte_longbool_t Changed;
	cte_longbool_t FollowSong;
	cte_int32_t RowHilightMinor;
	cte_int32_t RowHilightMajor;
#ifdef CreamTrackerMultithreading
	TCreamTrackerJobManager JobManager;
	cte_int32_t Threads;
	cte_longbool_t ThreadsTerminated;
	cte_longbool_t UseMultithreading;
#endif
#ifdef CreamTrackerCode
    PCreamTrackerCodeData CodeData;
#endif
	cte_pointer ChannelBuffers[32];
	TCreamTrackerBuffer TempBuffers[2];
#ifdef CreamTrackerCode
	TCreamTrackerChannelDataArray ChannelDataArray;
#endif
} TCreamTrackerInstance;

typedef TCreamTrackerInstance *PCreamTrackerInstance;

#ifdef CreamTrackerFFT
#pragma pack(push,1)
typedef struct {
	float Re, Im;
} TCreamTrackerFFTComplex;
#pragma pack(pop)

typedef TCreamTrackerFFTComplex* PCreamTrackerFFTComplex;

void CTE_STDCALL CreamTrackerHostFFT(PCreamTrackerFFTComplex InBuffer, PCreamTrackerFFTComplex OutBuffer, cte_int32_t NumSamples, cte_longbool_t Inverse);
#endif

cte_pointer CreamTrackerGetMem(size_t Size);
cte_pointer CreamTrackerReallocMem(cte_pointer ThePointer, size_t Size);
void CreamTrackerFreeMem(cte_pointer ThePointer);

cte_int64_t CreamTrackerRound(cte_double_t Value);

cte_int32_t CreamTrackerADPCMIMADecompressSample(TCreamTrackerADPCMIMAState* ADPCMIMAState, cte_uint8_t Nibble);
#ifdef CreamTrackerSaveRoutines
cte_uint8_t CreamTrackerADPCMIMACompressSample(TCreamTrackerADPCMIMAState* ADPCMIMAState, cte_int16_t Sample);
#endif

#ifdef CreamTrackerGUI
cte_uchar_p CreamTrackerGetNameCode(cte_uchar_p Name);
#endif

#ifdef CreamTrackerMultithreading
void CreamTrackerJobCreateThreads(PCreamTrackerInstance Instance);
void CreamTrackerJobWakeThreads(PCreamTrackerInstance Instance);
void CreamTrackerJobWaitThreads(PCreamTrackerInstance Instance);
void CreamTrackerJobFreeThreads(PCreamTrackerInstance Instance);
void CreamTrackerJobManagerInitProcessChannelMix(PCreamTrackerInstance Instance, cte_int32_t SamplesCount, cte_longbool_t NewTick);
void CreamTrackerJobManagerProcess(PCreamTrackerInstance Instance);
#endif

void CreamTrackerCreate(PCreamTrackerInstance Instance, cte_int32_t SampleRate);
#ifndef CreamTrackerMinimalPlayer
void CreamTrackerDestroy(PCreamTrackerInstance Instance);
#endif
#ifdef CreamTrackerCode
void CreamTrackerCodeInit(PCreamTrackerInstance Instance, PCreamTrackerCodeData CodeData);
#ifndef CreamTrackerMinimalPlayer
void CreamTrackerCodeDestroy(PCreamTrackerInstance Instance, PCreamTrackerCodeData CodeData);
#endif
void CreamTrackerCodeReset(PCreamTrackerInstance Instance, PCreamTrackerCodeData CodeData);
#endif
#ifndef CreamTrackerMinimalPlayer
void CreamTrackerDestroyInstrument(PCreamTrackerInstance Instance, PCreamTrackerInstrument Instrument);
void CreamTrackerDestroySampleData(PCreamTrackerInstance Instance, PCreamTrackerInstrument Instrument);
#endif
void CreamTrackerReset(PCreamTrackerInstance Instance);
void CreamTrackerUpdateTempo(PCreamTrackerInstance Instance);
void CreamTrackerFixUpSample(PCreamTrackerInstance Instance, PCreamTrackerInstrument Instrument);
cte_longbool_t CreamTrackerLoadPatternsAsSingleChain(PCreamTrackerInstance Instance, cte_pointer InputData, cte_int32_t InputDataSize);
cte_longbool_t CreamTrackerLoad(PCreamTrackerInstance Instance, cte_pointer InputData, cte_int32_t InputDataSize);
void CreamTrackerUpdateTick(PCreamTrackerInstance Instance);
void CreamTrackerFillBuffer(PCreamTrackerInstance Instance, cte_pointer Buffer, cte_int32_t Samples);
cte_int32_t CreamTrackerFillBufferOneTick(PCreamTrackerInstance Instance, cte_pointer Buffer, cte_int32_t Samples, cte_longbool_t WithTrackEnd);
cte_int32_t CreamTrackerCalculateLength(PCreamTrackerInstance Instance);

#ifdef CreamTrackerSaveRoutines
cte_longbool_t CreamTrackerSavePatternsAsSingleChain(PCreamTrackerInstance Instance, cte_pointer OutputData, cte_int32_t OutputSize);
cte_longbool_t CreamTrackerSave(PCreamTrackerInstance Instance, cte_pointer OutputData, cte_int32_t OutputSize, cte_longbool_t IsExport);
#endif

#ifdef CreamTrackerSoundAPI
cte_longbool_t CreamTrackerSoundInit();
void CreamTrackerSoundDone();
void CreamTrackerSoundStart();
void CreamTrackerSoundStop();
cte_double_t CreamTrackerSoundGetTime();
void CreamTrackerSoundQuit();
#endif

#ifdef __cplusplus
}
#endif

#endif