work for 2024-12-13 (2/2)

/******************************************************************************/
/******************************************************************************/
//"2024-12-13\kit_xmp\kit_xmp_namespace.cpp":
#include <kit/misc.hpp>
#include <kit/Xmp.hpp>

#define LIBXMP_STATIC
#include <libxmp-lite/xmp.h>


namespace kit {





const char* const* xmp::getFormatList(){
  return xmp_get_format_list();

}





s32 xmp::getSysErrno(){
  return xmp_syserrno();

}





const char* xmp::getVersionString(){
  return xmp_version;

}





Xmp_version xmp::getVersionCode(){
  Xmp_version ver;
  ver.value = xmp_vercode;

  return ver;

}





}; /* namespace kit */
/******************************************************************************/
/******************************************************************************/
//"2024-12-13\kit_xmp\kit_Xmp_playBuffer.cpp":
#include <kit/misc.hpp>
#include <kit/Xmp.hpp>

#define LIBXMP_STATIC
#include <libxmp-lite/xmp.h>

#define CTX_PTR ((xmp_context)_ctx)


namespace kit {





s32 Xmp::playBuffer(void* buffer, u31 size, bool ignoreLoopChecking){
  if(!_valid || !_initModule || !_initPlayer) return -KIT_XMP_ERROR_STATE;

  if(size.s) return -KIT_XMP_ERROR_INVALID;

  return xmp_play_buffer(CTX_PTR, buffer, size.v, !ignoreLoopChecking);

}





}; /* namespace kit */
/******************************************************************************/
/******************************************************************************/
//"2024-12-13\kit_xmp\kit_Xmp_player.cpp":
#include <kit/misc.hpp>
#include <kit/Xmp.hpp>

#define LIBXMP_STATIC
#include <libxmp-lite/xmp.h>

#define CTX_PTR ((xmp_context)_ctx)


namespace kit {

extern size_t numAllocations; //from kit namespace; relates to memory functions





s32 Xmp::getPlayer(s32 parameter){
  if(!_valid) return -KIT_XMP_ERROR_STATE;

  return xmp_get_player(CTX_PTR, parameter);

}





s32 Xmp::setPlayer(s32 parameter, s32 value){
  if(!_valid) return -KIT_XMP_ERROR_STATE;

  return xmp_set_player(CTX_PTR, parameter, value);

}





s32 Xmp::setPlayerTempoFactor(f64 multiplier){
  if(!_valid) return -KIT_XMP_ERROR_STATE;

  return xmp_set_tempo_factor(CTX_PTR, multiplier);

}





s32 Xmp::setPlayerTime(u31 milliseconds){
  if(!_valid || !_initPlayer) return -KIT_XMP_ERROR_STATE;

  return xmp_seek_time(CTX_PTR, milliseconds.v);

}





s32 Xmp::setPlayerRow(u31 row){
  if(!_valid) return -KIT_XMP_ERROR_STATE;

  return xmp_set_row(CTX_PTR, row.v);

}





s32 Xmp::setPlayerPosition(u31 pos){
  if(!_valid) return -KIT_XMP_ERROR_STATE;

  return xmp_set_position(CTX_PTR, pos.v);

}





s32 Xmp::playerPrevPosition(){
  if(!_valid) return -KIT_XMP_ERROR_STATE;

  return xmp_prev_position(CTX_PTR);

}





s32 Xmp::playerNextPosition(){
  if(!_valid) return -KIT_XMP_ERROR_STATE;

  return xmp_next_position(CTX_PTR);

}





s32 Xmp::playerMute(u31 channel, s32 status){
  if(!_valid) return -KIT_XMP_ERROR_STATE;

  return xmp_channel_mute(CTX_PTR, channel.v, status);

}





s32 Xmp::playerVolume(u31 channel, s32 volume){
  if(!_valid) return -KIT_XMP_ERROR_STATE;

  return xmp_channel_vol(CTX_PTR, channel.v, volume);

}





s32 Xmp::playerInjectEvent(u31 channel, Xmp_event* event_in){
  if(!_valid) return -KIT_XMP_ERROR_STATE;

  xmp_inject_event(CTX_PTR, channel.v, (xmp_event*)event_in);

  return 0;

}





s32 Xmp::playerStart(u31 sampleRate, s32 formatFlags){
  if(!_valid) return -KIT_XMP_ERROR_STATE;

  if(sampleRate.s) return -KIT_XMP_ERROR_INVALID;

  playerEnd();

  int err = xmp_start_player(CTX_PTR, sampleRate.v, formatFlags);
  if(err) return err;

  _initPlayer = true;

  ++numAllocations;

  return 0;

}





s32 Xmp::playerEnd(){
  if(!_valid || !_initPlayer) return -KIT_XMP_ERROR_STATE;

  xmp_end_player(CTX_PTR);

  _initPlayer = false;

  --numAllocations;

  return 0;

}





}; /* namespace kit */
/******************************************************************************/
/******************************************************************************/
//"2024-12-13\kit_xmp\kit_Xmp_playFrame.cpp":
#include <kit/misc.hpp>
#include <kit/Xmp.hpp>

#define LIBXMP_STATIC
#include <libxmp-lite/xmp.h>

#define CTX_PTR ((xmp_context)_ctx)


namespace kit {





s32 Xmp::playFrame(Xmp_frameInfo* finfo_out, bool callPlayFrame){
  if(!_valid || !_initModule || !_initPlayer) return -KIT_XMP_ERROR_STATE;

  int err = 0; //0 for no error
  if(callPlayFrame) err = xmp_play_frame(CTX_PTR);
  if(err) return err;

  if(finfo_out != nullptr) xmp_get_frame_info(CTX_PTR, (xmp_frame_info*)finfo_out);

  return err;

}





}; /* namespace kit */
/******************************************************************************/
/******************************************************************************/
//"2024-12-13\iso_game\include_all.hpp":
#ifndef _INCLUDE_ALL_HPP
#define _INCLUDE_ALL_HPP

#include <kit/all.hpp>
#include <kit/Xmp.hpp>

#define loghere kit_LogInfo("%s: %3i", __FILE__, __LINE__);

/********************************* "main.cpp" *********************************/

//(window is hidden initially, use setVisibility() to change that)
#define WIN_TITLE "IsoZooid"
#define WIN_W     1024
#define WIN_H     768
#define WIN_FLAGS 0

#define TEXTCOLORED_LEN 16

#define SFX_TRACKS 64

extern kit::Window*        wndw;
extern kit::Renderer*      rndr;
extern kit::BFont_Texture* text;
extern kit::BFont_Texture* textColored[TEXTCOLORED_LEN];

//if fade delta is 1/20th, then it will take 2/20ths of a second
 //for a new song to fully fade-in (unless index is <0 of course)

void music_play(kit::s32 index = -1); //<0 to stop music
void music_setFadeDelta(kit::f32 fadeTimeSeconds = 1.0f/20);

kit::f64 frand  (); // 0.0f -> 1.0f
kit::f64 frand2 (); //-1.0f -> 1.0f
kit::f32 frandf (); // 0.0f -> 1.0f
kit::f32 frandf2(); //-1.0f -> 1.0f

/****************************** "callbacks.cpp" *******************************/

extern kit::SoundEngine* sfx;

extern kit::s32        music_index;
extern kit::Stereo_f32 music_vol;

/****************************** "utils_core.cpp" ******************************/

#define TILE_ID_NULL     0

#define TILE_ID_BOXSMALL 1
#define TILE_ID_BOXBIG   2

#define TILE_ID_GOAL     3

#define TILE_ID_BLOCK_R  4
#define TILE_ID_BLOCK_G  5
#define TILE_ID_BLOCK_B  6
#define TILE_ID_BLOCK_Y  7 //more orange than yellow, but whatever

//...

#define TILE_ID_PLAYER_BACK  12
#define TILE_ID_PLAYER_RIGHT 13
#define TILE_ID_PLAYER_LEFT  14

#define TILE_ID_HIGHLIGHT 15 //for level editor

union tile_run {
  kit::u16 value;
  struct { kit::u16 len:11, tile:4, opaque:1; };
  tile_run(kit::u16 _value) : value(_value) {}
};

extern kit::shape::fpoint tile_camera;

void draw_tile(kit::s32 x, kit::s32 y, kit::s32 z,
               kit::u32 which, kit::f32 alpha = 1.0f);

static inline bool isInFront(kit::shape::point3d p_a, kit::shape::point3d p_b){
  return (p_a.x < p_b.x) || (p_a.y < p_b.y) || (p_a.z > p_b.z);
}

/******************************************************************************/

#endif /* _INCLUDE_ALL_HPP */
/******************************************************************************/
/******************************************************************************/
//"2024-12-13\kit_xmp\Xmp.hpp":
//THIS LIBRARY WAS MADE TO USE LIBXMP 4.6.0

#ifndef _INC_XMP_HPP
#define _INC_XMP_HPP

#include <kit/commondef.hpp>



#define KIT_XMP_NAME_SIZE 64 //size of module name and type

#define KIT_XMP_KEY_OFF  0x81   //note number for key off event
#define KIT_XMP_KEY_CUT  0x82   //note number for key cut event
#define KIT_XMP_KEY_FADE 0x83   //note number for fade event

//mixer parameter macros

//sample format flags
#define KIT_XMP_FORMAT_8BIT     (1 << 0) //mix to 8-bit instead of 16
#define KIT_XMP_FORMAT_UNSIGNED (1 << 1) //mix to unsigned samples
#define KIT_XMP_FORMAT_MONO     (1 << 2) //mix to mono instead of stereo

//player parameters
#define KIT_XMP_PLAYER_AMP         0 //amplification factor
#define KIT_XMP_PLAYER_MIX         1 //stereo mixing
#define KIT_XMP_PLAYER_INTERP      2 //interpolation type
#define KIT_XMP_PLAYER_DSP         3 //DSP effect flags
#define KIT_XMP_PLAYER_FLAGS       4 //player flags
#define KIT_XMP_PLAYER_CFLAGS      5 //player flags for current module
#define KIT_XMP_PLAYER_SMPCTL      6 //sample control flags
#define KIT_XMP_PLAYER_VOLUME      7 //player module volume
#define KIT_XMP_PLAYER_STATE       8 //internal player state (read only)
#define KIT_XMP_PLAYER_SMIX_VOLUME 9 //SMIX volume
#define KIT_XMP_PLAYER_DEFPAN     10 //default pan setting
#define KIT_XMP_PLAYER_MODE       11 //player personality
#define KIT_XMP_PLAYER_MIXER_TYPE 12 //current mixer (read only)
#define KIT_XMP_PLAYER_VOICES     13 //maximum number of mixer voices

//interpolation types
#define KIT_XMP_INTERP_NEAREST 0 //nearest neighbor
#define KIT_XMP_INTERP_LINEAR  1 //linear (default)
#define KIT_XMP_INTERP_SPLINE  2 //cubic spline

//dsp effect types
#define KIT_XMP_DSP_LOWPASS (1 << 0) //lowpass filter effect
#define KIT_XMP_DSP_ALL     (KIT_XMP_DSP_LOWPASS)

//player state
#define KIT_XMP_STATE_UNLOADED 0 //context created
#define KIT_XMP_STATE_LOADED   1 //module loaded
#define KIT_XMP_STATE_PLAYING  2 //module playing

//player flags
#define KIT_XMP_FLAGS_VBLANK  (1 << 0) //use vblank timing
#define KIT_XMP_FLAGS_FX9BUG  (1 << 1) //emulate FX9 bug
#define KIT_XMP_FLAGS_FIXLOOP (1 << 2) //emulate sample loop bug
#define KIT_XMP_FLAGS_A500    (1 << 3) //use Paula mixer in Amig modules

//player modes
#define KIT_XMP_MODE_AUTO         0 //autodetect mode (default)
#define KIT_XMP_MODE_MOD          1 //play as a generic MOD player
#define KIT_XMP_MODE_NOISETRACKER 2 //play using Noisetracker quirks
#define KIT_XMP_MODE_PROTRACKER   3 //play using Protracker quirks
#define KIT_XMP_MODE_S3M          4 //play as a generic S3M player
#define KIT_XMP_MODE_ST3          5 //play using ST3 bug emulation
#define KIT_XMP_MODE_ST3GUS       6 //play using ST3+GUS quirks
#define KIT_XMP_MODE_XM           7 //play as a generic XM player
#define KIT_XMP_MODE_FT2          8 //play using FT2 bug emulation
#define KIT_XMP_MODE_IT           9 //play using IT quirks
#define KIT_XMP_MODE_ITSMP       10 //play using IT sample mode quirks

//mixer types
#define KIT_XMP_MIXER_STANDARD 0 //standard mixer
#define KIT_XMP_MIXER_A500     1 //amiga 500
#define KIT_XMP_MIXER_A500F    2 //amiga 500 with led filter

//sample flags
#define KIT_XMP_SMPCTL_SKIP (1 << 0) //don't load samples

//limits
#define KIT_XMP_MAX_KEYS      121 //number of valid keys
#define KIT_XMP_MAX_ENV_POINTS 32 //max number of envelope points
#define KIT_XMP_MAX_MOD_LEN   256 //max number of patterns in module
#define KIT_XMP_MAX_CHANNELS   64 //max number of channels in module
#define KIT_XMP_MAX_SRATE   49170 //max sampling rate (Hz)
#define KIT_XMP_MIN_SRATE    4000 //min sampling rate (Hz)
#define KIT_XMP_MIN_BPM        20 //min BPM
//frame rate = (50 * bpm / 125) Hz
//frame size = (sampling rate * channels * size) / frame rate
#define KIT_XMP_MAX_FRAMESIZE (5 * KIT_XMP_MAX_SRATE * 2 / KIT_XMP_MIN_BPM)

//error codes
#define KIT_XMP_END            1
#define KIT_XMP_ERROR_INTERNAL 2 //internal error
#define KIT_XMP_ERROR_FORMAT   3 //unsupported module format
#define KIT_XMP_ERROR_LOAD     4 //error loading file
#define KIT_XMP_ERROR_DEPACK   5 //error depacking file
#define KIT_XMP_ERROR_SYSTEM   6 //system error
#define KIT_XMP_ERROR_INVALID  7 //invalid parameter
#define KIT_XMP_ERROR_STATE    8 //invalid player state



namespace kit {





#define KIT_XMP_CHANNEL_SYNTH    (1 << 0) //channel is synthesized
#define KIT_XMP_CHANNEL_MUTE     (1 << 1) //channel is muted
#define KIT_XMP_CHANNEL_SPLIT    (1 << 2) //split Amiga channel in bits 5-4
#define KIT_XMP_CHANNEL_SURROUND (1 << 4) //surround channel

struct Xmp_channel { //12B
  s32 pan; //channel pan (0x80 is center)
  s32 vol; //channel volume
  s32 flg; //channel flags

};





struct Xmp_pattern { //8B
  s32  rows;    //number of rows
  s32 index[1]; //track index

};





struct Xmp_event { //8B
  u8     note; //note number (0 means no note)
  u8      ins; //patch number
  u8   volume; //volume (0 to basevol)
  u8   fxType; //effect type
  u8  fxParam; //effect parameter
  u8  fx2Type; //secondary effect type
  u8 fx2Param; //secondary effect parameter
  u8   _flags; //internal (reserved) flags

};





struct Xmp_track { //12B
  s32        rows;    //number of rows
  Xmp_event event[1]; //event data
};





#define KIT_XMP_ENVELOPE_ON    (1 << 0) //envelope is enabled
#define KIT_XMP_ENVELOPE_SUS   (1 << 1) //envelope has sustain point
#define KIT_XMP_ENVELOPE_LOOP  (1 << 2) //envelope has loop
#define KIT_XMP_ENVELOPE_FLT   (1 << 3) //envelope is used for filter
#define KIT_XMP_ENVELOPE_SLOOP (1 << 4) //envelope has sustain loop
#define KIT_XMP_ENVELOPE_CARRY (1 << 5) //don't reset envelope position

struct Xmp_envelope { //156B
  s32 flg; //flags
  s32 npt; //number of envelope points
  s32 scl; //envelope scaling
  s32 sus; //sustain start point
  s32 sue; //sustain end point
  s32 lps; //loop start point
  s32 lpe; //loop end point

  s16 data[KIT_XMP_MAX_ENV_POINTS * 2];

};





#define KIT_XMP_INST_NNA_CUT    0x00
#define KIT_XMP_INST_NNA_CONT   0x01
#define KIT_XMP_INST_NNA_OFF    0x02
#define KIT_XMP_INST_NNA_FADE   0x03

#define KIT_XMP_INST_DCT_OFF    0x00
#define KIT_XMP_INST_DCT_NOTE   0x01
#define KIT_XMP_INST_DCT_SMP    0x02
#define KIT_XMP_INST_DCT_INST   0x03

#define KIT_XMP_INST_DCA_CUT    KIT_XMP_INST_NNA_CUT
#define KIT_XMP_INST_DCA_OFF    KIT_XMP_INST_NNA_OFF
#define KIT_XMP_INST_DCA_FADE   KIT_XMP_INST_NNA_FADE

struct Xmp_subInstrument { //64B
  s32 vol; //default volume
  s32 gvl; //global volume
  s32 pan; //pan
  s32 xpo; //transpose
  s32 fin; //finetune
  s32 vwf; //vibrato waveform
  s32 vde; //vibrato depth
  s32 vra; //vibrato rate
  s32 vsw; //vibrato sweep
  s32 rvv; //random volume/pan variation (IT)
  s32 sid; //sample number
  s32 nna; //new note action
  s32 dct; //duplicate check type
  s32 dca; //duplicate check action
  s32 ifc; //initial filter cutoff
  s32 ifr; //initial filter resonance
};





struct Xmp_instrument { //776B
  char         name[32]; //instrument name
  s32          vol;      //instrument volume
  s32          nsm;      //number of samples
  s32          rls;      //release (fadeout)
  Xmp_envelope aei;      //amplitude envelope info
  Xmp_envelope pei;      //pan envelope info
  Xmp_envelope fei;      //frequency envelope info

  struct {
    u8 ins; //instrument number for each key
    s8 xpo; //instrument transpose for each key
  } map[KIT_XMP_MAX_KEYS];

  Xmp_subInstrument* sub;

  void *extra; //extra fields

};





#define KIT_XMP_SMP_16BIT        (1 <<  0) //16bit sample
#define KIT_XMP_SMP_LOOP         (1 <<  1) //sample is looped
#define KIT_XMP_SMP_LOOP_BIDIR   (1 <<  2) //bidirectional sample loop
#define KIT_XMP_SMP_LOOP_REVERSE (1 <<  3) //backwards sample loop
#define KIT_XMP_SMP_LOOP_FULL    (1 <<  4) //play full sample before looping
#define KIT_XMP_SMP_SLOOP        (1 <<  5) //sample has sustain loop
#define KIT_XMP_SMP_SLOOP_BIDIR  (1 <<  6) //bidirectional sustain loop
#define KIT_XMP_SMP_STEREO       (1 <<  7) //interlaced stereo sample
#define KIT_XMP_SMP_SYNTH        (1 << 15) //data contains synth patch

struct Xmp_sample { //56B
  char name[32]; //sample name
  s32   len;     //sample length
  s32   lps;     //loop start
  s32   lpe;     //loop end
  s32   flg;     //flags
  u8*  data;     //sample data
};





struct Xmp_sequence { //8B
  s32 entry_point;
  s32 duration;
};





struct Xmp_module { //1224B
  char            name[KIT_XMP_NAME_SIZE];  //module title
  char            type[KIT_XMP_NAME_SIZE];  //module format
  s32             pat;                      //number of patterns
  s32             trk;                      //number of tracks
  s32             chn;                      //tracks per pattern
  s32             ins;                      //number of instruments
  s32             smp;                      //number of samples
  s32             spd;                      //initial speed
  s32             bpm;                      //initial BPM
  s32             len;                      //module length in patterns
  s32             rst;                      //restart position
  s32             gvl;                      //global volume
  Xmp_pattern**   xxp;                      //patterns
  Xmp_track**     xxt;                      //tracks
  Xmp_instrument* xxi;                      //instruments
  Xmp_sample*     xxs;                      //samples
  Xmp_channel     xxc[64];                  //channel info
  u8              xxo[KIT_XMP_MAX_MOD_LEN]; //orders

};





struct Xmp_testInfo { //128B
  char name[KIT_XMP_NAME_SIZE]; //module title
  char type[KIT_XMP_NAME_SIZE]; //module format

};





struct Xmp_moduleInfo { //56B
  u8        md5[16]; //MD5 message digest
  s32      vol_base; //volume scale
  Xmp_module*   mod; //pointer to module data
  char*     comment; //comment text, if any
  s32       seq_len; //number of valid sequences
  Xmp_sequence* seq; //pointer to sequence data
};





struct Xmp_channelInfo { //24B
  u32      period; //sample period (* 4096)
  u32    position; //sample position
  s16   pitchbend; //linear bend from base note
  u8         note; //current base note number
  u8   instrument; //current instrument number
  u8       sample; //current sample number
  u8       volume; //current volume
  u8          pan; //current stereo pan
  u8    _reserved; //reserved
  Xmp_event event; //current track event
};





struct Xmp_frameInfo { //1616B; current frame information
  s32           pos; //current position
  s32       pattern; //current pattern
  s32           row; //current row in pattern
  s32      num_rows; //number of rows in current pattern
  s32         frame; //current frame
  s32         speed; //current replay speed
  s32           bpm; //current bpm
  s32          time; //current module time in ms
  s32    total_time; //estimated replay time in ms
  s32    frame_time; //frame replay time in us
  void*      buffer; //pointer to sound buffer
  s32   buffer_size; //used buffer size
  s32    total_size; //total buffer size
  s32        volume; //current master volume
  s32    loop_count; //loop counter
  s32 virt_channels; //number of virtual channels
  s32     virt_used; //used virtual channels
  s32      sequence; //current sequence

  Xmp_channelInfo channel_info[KIT_XMP_MAX_CHANNELS]; //current channel info

};





/* //(will probably be left unused)
struct Xmp_callbacks { //32B
  u32 (* read_func)(void* dst, u32 len, u32 nmemb, void* priv);
  s32 (* seek_func)(void* priv, s32 offset, s32 whence);
  s32 (* tell_func)(void* priv);
  s32 (*close_func)(void* priv);

};
*/





//SMIX FUNCTIONALITY IS NOT IMPLEMENTED!

//(ALSO, ALL ERROR CODES WILL BE NEGATIVE!)

class Xmp { //16B
  u32          _type;
  bool        _valid = false;
  bool _constructing = true;
  bool   _initModule = false;
  bool   _initPlayer = false;
  GenOpqPtr     _ctx = nullptr;


  s32 _test_from_memory(const void* data, u31 size, Xmp_testInfo* tinfo_out);

  s32 _module_from_memory(const void* data, u31 size);


public:

  Xmp();

  ~Xmp();



  //returns 0 on success, or an error code on failure
  inline s32 getTestInfo(const void* data, u31 size, Xmp_testInfo* tinfo_out)
  { return _test_from_memory(data, size, tinfo_out); }

  s32 getTestInfo(const char* filePath, Xmp_testInfo* tinfo_out);



  //returns 0 on success or -KIT_XMP_END if the module ended or was stopped,
   //or -KIT_XMP_ERROR_STATE if player is not in a playing state
  s32 playBuffer(void* buffer, u31 size, bool ignoreLoopChecking = false);

  //leaving finfo_out as nullptr will result in xmp_play_frame being called,
   //but not xmp_get_frame_info (though why you'd want to do this is beyond me)
  //if callPlayFrame is false, then that too won't be called
  s32 playFrame(Xmp_frameInfo* finfo_out = nullptr, bool callPlayFrame = true);



/*********************************** MODULE ***********************************/

  inline bool isModuleLoaded(){ return _initModule; }

  //get information about the currently loaded module
  //returns 0 on success, or an error code on failure
  s32 getModuleInfo(Xmp_moduleInfo* minfo_out);

  inline s32 moduleLoad(const void* data, u31 size)
  { return _module_from_memory(data, size); }

  //returns 0 on success, or error code on failure
  s32 moduleLoad(const char* filePath);

  //returns whether or not there was a loaded module to be released,
   //or false if Xmp instance is invalid
  bool moduleRelease();

  //returns 0 on success, or error code on failure
  s32 moduleStop();

  s32 moduleRestart();



/*********************************** PLAYER ***********************************/

  //parameter can be one of:
   //KIT_XMP_PLAYER_AMP         //amplification factor
   //KIT_XMP_PLAYER_MIX         //stereo mixing
   //KIT_XMP_PLAYER_INTERP      //interpolation type
   //KIT_XMP_PLAYER_DSP         //DSP effect flags
   //KIT_XMP_PLAYER_FLAGS       //player flags
   //KIT_XMP_PLAYER_CFLAGS      //player flags for current module
   //KIT_XMP_PLAYER_SMPCTL      //control sample loading
   //KIT_XMP_PLAYER_VOLUME      //player master volume
   //KIT_XMP_PLAYER_STATE       //current player state (read only)
   //KIT_XMP_PLAYER_SMIX_VOLUME //SMIX Volume
   //KIT_XMP_PLAYER_DEFPAN      //default pan separation
   //KIT_XMP_PLAYER_MODE        //player personality
   //KIT_XMP_PLAYER_MIXER_TYPE  //current mixer (read only)
   //KIT_XMP_PLAYER_VOICES      //maximum number of mixer voices
  //returns the parameter's value, or an error code on failure
   //(error codes are always <0, and parameter values are >= 0!)
  s32 getPlayer(s32 parameter);



  inline s32 setPlayerAmp(s32 value) //amplification factor; 0-3, default of 1
  { return setPlayer(KIT_XMP_PLAYER_AMP, value); }

  inline s32 setPlayerMix(s32 value) //% of l/r channel sep.; default of 70
  { return setPlayer(KIT_XMP_PLAYER_MIX, value); }

  //value can be one of:
   //KIT_XMP_INTERP_NEAREST: nearest-neighbor
   //KIT_XMP_INTERP_LINEAR:  linear (default)
   //KIT_XMP_INTERP_SPLINE:  cubic spline
  inline s32 setPlayerInterp(s32 value) //interpolation type
  { return setPlayer(KIT_XMP_PLAYER_INTERP, value); }

  //value can be one or more of:
   //KIT_XMP_DSP_LOWPASS: low-pass filter effect
   //KIT_XMP_DSP_ALL:     all effects
  inline s32 setPlayerDSP(s32 value) //DSP effects flags
  { return setPlayer(KIT_XMP_PLAYER_DSP, value); }

  //value can be one or more of
   //KIT_XMP_FLAGS_VBLANK:  //use vblank timing
   //KIT_XMP_FLAGS_FX9BUG:  //emulate Protracker 2.x FX9 bug
   //KIT_XMP_FLAGS_FIXLOOP: //make sample loop value / 2
   //KIT_XMP_FLAGS_A500:    //use Paula mixer in Amiga modules
  inline s32 setPlayerFlags(s32 value) //player flags
  { return setPlayer(KIT_XMP_PLAYER_FLAGS, value); }

  //value can be one or more of the values above ^^
  inline s32 setPlayerCFlags(s32 value) //player flags for current module
  { return setPlayer(KIT_XMP_PLAYER_CFLAGS, value); }

  //value can be one of:
   //0:                   load samples when loading module (default)
   //KIT_XMP_SMPCTL_SKIP: don't load samples when loading module
  inline s32 setPlayerSmpCtl(s32 value) //control sample loading
  { return setPlayer(KIT_XMP_PLAYER_SMPCTL, value); }

  inline s32 setPlayerVolume(s32 value) //player master volume; 0-100
  { return setPlayer(KIT_XMP_PLAYER_VOLUME, value); }

  inline s32 setPlayerSMIXVolume(s32 value) //SMIX volume; 0-100
  { return setPlayer(KIT_XMP_PLAYER_SMIX_VOLUME, value); }

  inline s32 setPlayerDefPan(s32 value) //default pan sep.; %, default of 100%
  { return setPlayer(KIT_XMP_PLAYER_DEFPAN, value); }

  //value can be one of:
   //KIT_XMP_MODE_AUTO:         autodetect mode (default)
   //KIT_XMP_MODE_MOD:          play as a generic MOD player
   //KIT_XMP_MODE_NOISETRACKER: play using Noisetracker quirks
   //KIT_XMP_MODE_PROTRACKER:   play using Protracker 1/2 quirks
   //KIT_XMP_MODE_S3M:          play as a generic S3M player
   //KIT_XMP_MODE_ST3:          play using ST3 bug emulation
   //KIT_XMP_MODE_ST3GUS:       play using ST3+GUS quirks
   //KIT_XMP_MODE_XM:           play as a generic XM player
   //KIT_XMP_MODE_FT2:          play using FT2 bug emulation
   //KIT_XMP_MODE_IT:           play using IT quirks
   //KIT_XMP_MODE_ITSMP:        play using IT sample mode quirks
  inline s32 setPlayerMode(s32 value) //player personality
  { return setPlayer(KIT_XMP_PLAYER_MODE, value); }

  inline s32 setPlayerVoices(s32 value) //max # of mixer voices; default of 128
  { return setPlayer(KIT_XMP_PLAYER_VOICES, value); }

  //parameter can be one of:
   //KIT_XMP_PLAYER_AMP:         //amplification factor
   //KIT_XMP_PLAYER_MIX:         //stereo mixing
   //KIT_XMP_PLAYER_INTERP:      //interpolation type
   //KIT_XMP_PLAYER_DSP:         //DSP effect flags
   //KIT_XMP_PLAYER_FLAGS:       //player flags
   //KIT_XMP_PLAYER_CFLAGS:      //player flags for current module
   //KIT_XMP_PLAYER_SMPCTL:      //control sample loading
   //KIT_XMP_PLAYER_VOLUME:      //clayer master volume
   //KIT_XMP_PLAYER_SMIX_VOLUME: //SMIX Volume
   //KIT_XMP_PLAYER_DEFPAN:      //default pan separation
   //KIT_XMP_PLAYER_MODE:        //player personality
   //KIT_XMP_PLAYER_VOICES:      //maximum number of mixer voices
  //look at the above inline functions to see the valid values for each paramter
  //returns 0 on success, or an error code on failure
  s32 setPlayer(s32 parameter, s32 value);



  s32 setPlayerTempoFactor(f64 multiplier);



  //returns the new time index (in milliseconds), or an error code on failure
  s32 setPlayerTime(u31 milliseconds);

  //returns the new row index, or an error code on failure
  s32 setPlayerRow(u31 row);

  //returns the new position index, or an error code on failure
  s32 setPlayerPosition(u31 pos);

  s32 playerPrevPosition();

  s32 playerNextPosition();



  //status can be one of:
   //-1: query the mute status of the selected channel without changing anything
   // 0: mute the selected channel
   // 1: unmute the selected channel
  //returns the channel's previous mute status, or an error code on failure
  s32 playerMute(u31 channel, s32 status);

  //volume can be one of:
   //   -1: query the volume of the selected channel without changing anything
   //0-100: the desired volume percentage
  //returns the channel's previous volume, or an error code on failure
  s32 playerVolume(u31 channel, s32 volume);

  //returns 0 on success, or an error code on failure
  s32 playerInjectEvent(u31 channel, Xmp_event* event_in);



  //formatFlags can use one or more of:
   //KIT_XMP_FORMAT_8BIT:     Mix to 8-bit instead of 16
   //KIT_XMP_FORMAT_UNSIGNED: Mix to unsigned samples
   //KIT_XMP_FORMAT_MONO:     Mix to mono instead of stereo
  //returns 0 on success, or an error code on failure
  s32 playerStart(u31 sampleRate, s32 formatFlags = 0);

  //returns 0 on success, or -KIT_XMP_ERROR_STATE if !_valid || !_initPlayer
  s32 playerEnd(); //ends module replay and releases player memory

};





union Xmp_version { //4B
  u32 value;

  struct {
    u8 release; //_._.X
    u8   minor; //_.X._
    u8   major; //X._._
    u8       _;
  };

};





namespace xmp {



const char* const* getFormatList();

//used to retrieve errno if -KIT_XMP_ERROR_SYSTEM was returned as an error code
s32 getSysErrno();

//returns a null-terminated string of a human-readable version number of
 //the current libxmp build being linked (example: "4.0.0")
const char* getVersionString();

Xmp_version getVersionCode();



}; /* namespace xmp */





}; /* namespace kit */

#endif /* _INC_XMP_HPP */