SHARE
TWEET

st3play v0.78

8bitbubsy Dec 26th, 2013 (edited) 446 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2. ** ST3PLAY v0.78 - 9th of February - http://16-bits.org
  3. ** ====================================================
  4. **
  5. ** Very accurate C port of Scream Tracker 3.21's replayer,
  6. ** by Olav "8bitbubsy" Sørensen. Using the original asm source codes
  7. ** by Sami "PSI" Tammilehto (Future Crew) with permission.
  8. **
  9. ** Non-ST3 additions from other trackers (only handled for non ST3 S3Ms):
  10. **
  11. ** - Mixing:
  12. **   * 16-bit sample support
  13. **   * Stereo sample support
  14. **   * 2^31-1 sample length support
  15. **   * Middle-C speeds beyond 65535
  16. **   * Process the last 16 channels as PCM
  17. **   * Process 8 octaves instead of 7
  18. **   * The ability to play samples backwards
  19. **
  20. ** - Effects:
  21. **   * Command S2x        (set middle-C finetune)
  22. **   * Command S5x        (panbrello type)
  23. **   * Command S6x        (tick delay)
  24. **   * Command S9x        (sound control - only S90/S91/S9E/S9F)
  25. **   * Command Mxx        (set channel volume)
  26. **   * Command Nxy        (channel volume slide)
  27. **   * Command Pxy        (panning slide)
  28. **   * Command Txx<0x20   (tempo slide)
  29. **   * Command Wxy        (global volume slide)
  30. **   * Command Xxx        (7+1-bit pan) + XA4 for 'surround'
  31. **   * Command Yxy        (panbrello)
  32. **   * Volume Command Pxx (set 4+1-bit panning)
  33. **
  34. ** - Variables:
  35. **   * Pan changed from 4-bit (0..15) to 8+1-bit (0..256)
  36. **   * Memory variables for the new N/P/T/W/Y effects
  37. **   * Panbrello counter
  38. **   * Panbrello type
  39. **   * Channel volume multiplier
  40. **   * Channel surround flag
  41. **
  42. ** - Other changes:
  43. **   * Added tracker identification to make sure Scream Tracker 3.xx
  44. **     modules are still played exactly like they should. :-)
  45. **
  46. ** You need to link winmm.lib for this to compile (-lwinmm)
  47. ** Alternatively, you can wrap around your own audio callback for using
  48. ** st3play on other platforms.
  49. **
  50. ** Changelog from v0.77:
  51. ** - PROPER initial pan loading this time, ignore earlier changelog entry.
  52. **   Also pan*17 instead of pan*16, to use the full pan range.
  53. **
  54. ** Changelog from v0.75a:
  55. ** - Initial panning was wrong. Set to center instead! (if no followed pans)
  56. **
  57. ** Changelog from v0.75:
  58. ** - Code cleanup
  59. **
  60. ** Changelog from v0.72:
  61. ** - Added sound card types (for a specific Gxx effect bug between SB/GUS driver)
  62. **
  63. ** Changelog from v0.71:
  64. ** - Code cleanup
  65. ** - Proper check for memory allocations
  66. **
  67. ** Changelog from v0.70:
  68. ** - Any pan commands except Lxy/Yxy/XA4 should disable channel surround
  69. **
  70. ** Changelog from v0.60:
  71. ** - Added S2x (non-ST3, set middle-C finetune)
  72. ** - Added S6x (non-ST3, tick delay)
  73. ** - Added S9E/S9F (non-ST3, play sample backwards/forwards)
  74. ** - Fixed a bug in setspd() in Amiga limit mode
  75. ** - Proper tracker handling for non-ST3 effects
  76. ** - Panbrello (Yxy) didn't set the panning at all (heh)
  77. ** - Mxx (set cannel volume) didn't work correctly
  78. **
  79. **
  80. ** User functions:
  81. **
  82. ** #include <stdint.h>
  83. **
  84. ** enum
  85. ** {
  86. **     SOUNDCARD_SB,
  87. **     SOUNDCARD_GUS
  88. ** };
  89. **
  90. ** int8_t st3play_LoadModule(const uint8_t *buffer, uint32_t size);
  91. ** int8_t st3play_Init(uint32_t outputFreq, int8_t interpolation);
  92. ** void st3play_FreeSong(void);
  93. ** void st3play_Close(void);
  94. ** void st3play_PauseSong(int8_t pause);
  95. ** void st3play_PlaySong(uint8_t soundCardType);
  96. */
  97.  
  98. #ifndef WIN32_LEAN_AND_MEAN
  99. #define WIN32_LEAN_AND_MEAN
  100. #endif
  101.  
  102. #include <stdio.h>
  103. #include <stdlib.h>
  104. #include <string.h>
  105. #include <stdint.h>
  106. #include <math.h>
  107. #include <windows.h>
  108. #include <mmsystem.h>
  109.  
  110. #define LERP(x, y, z) ((x) + ((y) - (x)) * (z))
  111.  
  112. enum
  113. {
  114.     SOUNDCARD_SB,
  115.     SOUNDCARD_GUS
  116. };
  117.  
  118. /* don't change these two unless you know what you're doing... */
  119. #define MIX_BUF_NUM 7
  120. #define MIX_BUF_LEN 2048
  121.  
  122. /* TRACKER ID */
  123. enum
  124. {
  125.     SCREAM_TRACKER  = 1,
  126.     IMAGO_ORPHEUS   = 2,
  127.     IMPULSE_TRACKER = 3,
  128.     SCHISM_TRACKER  = 4,
  129.     OPENMPT         = 5,
  130.     BEROTRACKER     = 6
  131.     /* there is also CREAMTRACKER (7), but let's ignore that for now */
  132. };
  133.  
  134. /* STRUCTS */
  135. typedef struct chn
  136. {
  137.     int8_t aorgvol;
  138.     int8_t avol;
  139.     uint8_t channelnum;
  140.     uint8_t achannelused;
  141.     uint8_t aglis;
  142.     uint8_t atremor;
  143.     uint8_t atreon;
  144.     uint8_t atrigcnt;
  145.     uint8_t anotecutcnt;
  146.     uint8_t anotedelaycnt;
  147.     uint8_t avibtretype;
  148.     uint8_t note;
  149.     uint8_t ins;
  150.     uint8_t vol;
  151.     uint8_t cmd;
  152.     uint8_t info;
  153.     uint8_t lastins;
  154.     uint8_t lastnote;
  155.     uint8_t alastnfo;
  156.     uint8_t alasteff;
  157.     uint8_t alasteff1;
  158.     int16_t apanpos;
  159.     int16_t avibcnt;
  160.     uint16_t astartoffset;
  161.     uint16_t astartoffset00;
  162.     int32_t ac2spd;
  163.     int32_t asldspd;
  164.     int32_t aorgspd;
  165.     int32_t aspd;
  166.  
  167.     /* NON-ST3 variables */
  168.     int8_t chanvol;
  169.     uint8_t surround;
  170.     uint8_t apantype;
  171.     uint8_t nxymem;
  172.     uint8_t pxymem;
  173.     uint8_t txxmem;
  174.     uint8_t wxymem;
  175.     uint8_t yxymem;
  176.     int16_t apancnt;
  177. } chn_t;
  178.  
  179. typedef struct
  180. {
  181.     const int8_t *sampleData;
  182.     int8_t loopEnabled;
  183.     int8_t sixteenBit;
  184.     int8_t stereo;
  185.     int8_t mixing;
  186.     int8_t playBackwards;
  187.     int32_t sampleLength;
  188.     int32_t sampleLoopBegin;
  189.     int32_t sampleLoopEnd;
  190.     int32_t samplePosition;
  191.     int32_t sampleLoopLength;
  192.  
  193.     float incRate;
  194.     float frac;
  195.     float volumeL;
  196.     float volumeR;
  197.     float orgVolL;
  198. } VOICE;
  199.  
  200. typedef void (*effect_routine)(chn_t *ch);
  201.  
  202.  
  203. /* STATIC DATA */
  204. static int8_t tickdelay; /* NON-ST3 */
  205. static int8_t volslidetype;
  206. static int8_t patterndelay;
  207. static int8_t patloopcount;
  208. static uint8_t breakpat;
  209. static uint8_t startrow;
  210. static uint8_t musiccount;
  211. static int16_t np_ord;
  212. static int16_t np_row;
  213. static int16_t np_pat;
  214. static int16_t np_patoff;
  215. static int16_t patloopstart;
  216. static int16_t jumptorow;
  217. static uint16_t patternadd;
  218. static uint16_t patmusicrand;
  219. static int32_t aspdmax;
  220. static int32_t aspdmin;
  221. static uint32_t np_patseg;
  222. static chn_t chn[32];
  223. static uint8_t soundcardtype;
  224. static int32_t soundBufferSize;
  225. static uint32_t audioFreq;
  226. static VOICE voice[32];
  227. static WAVEFORMATEX wfx;
  228. static WAVEHDR waveBlocks[MIX_BUF_NUM];
  229. static HWAVEOUT _hWaveOut;
  230. static float f_audioFreq;
  231. static float f_masterVolume;
  232. static int8_t samplingInterpolation;
  233. static float *masterBufferL;
  234. static float *masterBufferR;
  235. static int8_t *mixerBuffer;
  236. static int32_t samplesLeft;
  237. static uint32_t samplesPerFrame;
  238. static volatile int8_t mixingMutex;
  239. static volatile int8_t isMixing;
  240.  
  241. /* GLOBAL VARIABLES */
  242. int8_t ModuleLoaded = 0;
  243. int8_t MusicPaused = 0;
  244. int8_t Playing = 0;
  245.  
  246. uint8_t *mseg = NULL;
  247. uint16_t instrumentadd;
  248. int8_t lastachannelused;
  249. int8_t tracker;
  250. int8_t oldstvib;
  251. int8_t fastvolslide;
  252. int8_t amigalimits;
  253. uint8_t musicmax;
  254. uint8_t numChannels;
  255. int16_t tempo;
  256. int16_t globalvol;
  257. int8_t stereomode;
  258. uint8_t mastervol;
  259. uint32_t mseg_len;
  260.  
  261.  
  262. /* TABLES */
  263. static const int16_t xfinetune_amiga[16] =
  264. {
  265.     7895, 7941, 7985, 8046, 8107, 8169, 8232, 8280,
  266.     8363, 8413, 8463, 8529, 8581, 8651, 8723, 8757
  267. };
  268.  
  269. static const int8_t retrigvoladd[32] =
  270. {
  271.     0, -1, -2, -4, -8,-16,  0,  0,
  272.     0,  1,  2,  4,  8, 16,  0,  0,
  273.     0,  0,  0,  0,  0,  0, 10,  8,
  274.     0,  0,  0,  0,  0,  0, 24, 32
  275. };
  276.  
  277. static const uint16_t notespd[12] =
  278. {
  279.     1712 * 16, 1616 * 16, 1524 * 16,
  280.     1440 * 16, 1356 * 16, 1280 * 16,
  281.     1208 * 16, 1140 * 16, 1076 * 16,
  282.     1016 * 16,  960 * 16,  907 * 16
  283. };
  284.  
  285. static const int16_t vibsin[64] =
  286. {
  287.      0x00, 0x18, 0x31, 0x4A, 0x61, 0x78, 0x8D, 0xA1,
  288.      0xB4, 0xC5, 0xD4, 0xE0, 0xEB, 0xF4, 0xFA, 0xFD,
  289.      0xFF, 0xFD, 0xFA, 0xF4, 0xEB, 0xE0, 0xD4, 0xC5,
  290.      0xB4, 0xA1, 0x8D, 0x78, 0x61, 0x4A, 0x31, 0x18,
  291.      0x00,-0x18,-0x31,-0x4A,-0x61,-0x78,-0x8D,-0xA1,
  292.     -0xB4,-0xC5,-0xD4,-0xE0,-0xEB,-0xF4,-0xFA,-0xFD,
  293.     -0xFF,-0xFD,-0xFA,-0xF4,-0xEB,-0xE0,-0xD4,-0xC5,
  294.     -0xB4,-0xA1,-0x8D,-0x78,-0x61,-0x4A,-0x31,-0x18
  295. };
  296.  
  297. static const uint8_t vibsqu[64] =
  298. {
  299.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  300.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  301.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  302.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  303.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  304.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  305.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  306.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  307. };
  308.  
  309. static const int16_t vibramp[64] =
  310. {
  311.        0, -248,-240,-232,-224,-216,-208,-200,
  312.     -192, -184,-176,-168,-160,-152,-144,-136,
  313.     -128, -120,-112,-104, -96, -88, -80, -72,
  314.      -64,  -56, -48, -40, -32, -24, -16,  -8,
  315.        0,    8,  16,  24,  32,  40,  48,  56,
  316.       64,   72,  80,  88,  96, 104, 112, 120,
  317.      128,  136, 144, 152, 160, 168, 176, 184,
  318.      192,  200, 208, 216, 224, 232, 240, 248
  319. };
  320.  
  321. typedef struct
  322. {
  323.     uint8_t *_ptr;
  324.     uint32_t _cnt;
  325.     uint8_t *_base;
  326.     uint32_t _bufsiz;
  327.     int32_t _eof;
  328. } MEM;
  329.  
  330.  
  331. /* FUNCTION DECLARATIONS */
  332. static MEM *mopen(const uint8_t *src, uint32_t length);
  333. static void mclose(MEM **buf);
  334. static size_t mread(void *buffer, size_t size, size_t count, MEM *buf);
  335. static uint32_t mtell(MEM *buf);
  336. static int32_t meof(MEM *buf);
  337. static void mseek(MEM *buf, int32_t offset, int32_t whence);
  338. void startMixing(void);
  339. void setSamplesPerFrame(uint32_t val);
  340. void setSamplingInterpolation(int8_t value);
  341. void setStereoMode(int8_t value);
  342. int8_t getStereoFlag(void);
  343. void setMasterVolume(uint8_t value);
  344. uint8_t getMasterVol(void);
  345. void voiceSetSource(uint8_t voiceNumber, const int8_t *sampleData,
  346.     int32_t sampleLength, int32_t sampleLoopLength, int32_t sampleLoopEnd,
  347.     int8_t loopEnabled, int8_t sixteenbit, int8_t stereo);
  348. void voiceSetSamplePosition(uint8_t voiceNumber, uint16_t value);
  349. void voiceSetVolume(uint8_t voiceNumber, float vol, uint16_t pan);
  350. void voiceSetSurround(uint8_t voiceNumber, int8_t surround);
  351. void voiceSetSamplingFrequency(uint8_t voiceNumber, uint32_t samplingFrequency);
  352. void voiceSetPlayBackwards(uint8_t voiceNumber, int8_t playBackwards);
  353. void voiceSetReadPosToEnd(uint8_t voiceNumber);
  354.  
  355. void st3play_FreeSong(void);
  356.  
  357. static void s_ret(chn_t *ch);
  358. static void s_setgliss(chn_t *ch);
  359. static void s_setfinetune(chn_t *ch); /* NON-ST3 */
  360. static void s_setvibwave(chn_t *ch);
  361. static void s_settrewave(chn_t *ch);
  362. static void s_setpanwave(chn_t *ch); /* NON-ST3 */
  363. static void s_tickdelay(chn_t *ch); /* NON-ST3 */
  364. static void s_setpanpos(chn_t *ch);
  365. static void s_sndcntrl(chn_t *ch); /* NON-ST3 */
  366. static void s_patloop(chn_t *ch);
  367. static void s_notecut(chn_t *ch);
  368. static void s_notecutb(chn_t *ch);
  369. static void s_notedelay(chn_t *ch);
  370. static void s_notedelayb(chn_t *ch);
  371. static void s_patterdelay(chn_t *ch);
  372. static void s_setspeed(chn_t *ch);
  373. static void s_jmpto(chn_t *ch);
  374. static void s_break(chn_t *ch);
  375. static void s_volslide(chn_t *ch);
  376. static void s_slidedown(chn_t *ch);
  377. static void s_slideup(chn_t *ch);
  378. static void s_toneslide(chn_t *ch);
  379. static void s_vibrato(chn_t *ch);
  380. static void s_tremor(chn_t *ch);
  381. static void s_arp(chn_t *ch);
  382. static void s_chanvol(chn_t *ch); /* NON-ST3 */
  383. static void s_chanvolslide(chn_t *ch); /* NON-ST3 */
  384. static void s_vibvol(chn_t *ch);
  385. static void s_tonevol(chn_t *ch);
  386. static void s_panslide(chn_t *ch);
  387. static void s_retrig(chn_t *ch);
  388. static void s_tremolo(chn_t *ch);
  389. static void s_scommand1(chn_t *ch);
  390. static void s_scommand2(chn_t *ch);
  391. static void s_settempo(chn_t *ch);
  392. static void s_finevibrato(chn_t *ch);
  393. static void s_setgvol(chn_t *ch);
  394. static void s_globvolslide(chn_t *ch); /* NON-ST3 */
  395. static void s_setpan(chn_t *ch); /* NON-ST3 */
  396. static void s_panbrello(chn_t *ch); /* NON-ST3 */
  397.  
  398. static effect_routine ssoncejmp[16] =
  399. {
  400.     s_ret,
  401.     s_setgliss,
  402.     s_setfinetune,
  403.     s_setvibwave,
  404.     s_settrewave,
  405.     s_setpanwave, /* NON-ST3 */
  406.     s_tickdelay, /* NON-ST3 */
  407.     s_ret,
  408.     s_setpanpos,
  409.     s_sndcntrl, /* NON-ST3 */
  410.     s_ret,
  411.     s_patloop,
  412.     s_notecut,
  413.     s_notedelay,
  414.     s_patterdelay,
  415.     s_ret
  416. };
  417.  
  418. static effect_routine ssotherjmp[16] =
  419. {
  420.     s_ret,
  421.     s_ret,
  422.     s_ret,
  423.     s_ret,
  424.     s_ret,
  425.     s_ret,
  426.     s_ret,
  427.     s_ret,
  428.     s_ret,
  429.     s_ret,
  430.     s_ret,
  431.     s_ret,
  432.     s_notecutb,
  433.     s_notedelayb,
  434.     s_ret,
  435.     s_ret
  436. };
  437.  
  438. static effect_routine soncejmp[27] =
  439. {
  440.     s_ret,
  441.     s_setspeed,
  442.     s_jmpto,
  443.     s_break,
  444.     s_volslide,
  445.     s_slidedown,
  446.     s_slideup,
  447.     s_ret,
  448.     s_ret,
  449.     s_tremor,
  450.     s_arp,
  451.     s_ret,
  452.     s_ret,
  453.     s_chanvol, /* NON-ST3 */
  454.     s_chanvolslide, /* NON-ST3 */
  455.     s_ret,
  456.     s_panslide, /* NON-ST3 */
  457.     s_retrig,
  458.     s_ret,
  459.     s_scommand1,
  460.     s_settempo,
  461.     s_ret,
  462.     s_ret,
  463.     s_globvolslide, /* NON-ST3 */
  464.     s_setpan, /* NON-ST3 */
  465.     s_panbrello, /* NON-ST3 */
  466.     s_ret
  467. };
  468.  
  469. static effect_routine sotherjmp[27] =
  470. {
  471.     s_ret,
  472.     s_ret,
  473.     s_ret,
  474.     s_ret,
  475.     s_volslide,
  476.     s_slidedown,
  477.     s_slideup,
  478.     s_toneslide,
  479.     s_vibrato,
  480.     s_tremor,
  481.     s_arp,
  482.     s_vibvol,
  483.     s_tonevol,
  484.     s_ret,
  485.     s_chanvolslide, /* NON-ST3 */
  486.     s_ret,
  487.     s_panslide, /* NON-ST3 */
  488.     s_retrig,
  489.     s_tremolo,
  490.     s_scommand2,
  491.     s_settempo, /* NON-ST3 (for tempo slides) */
  492.     s_finevibrato,
  493.     s_setgvol,
  494.     s_globvolslide, /* NON-ST3 */
  495.     s_ret,
  496.     s_panbrello, /* NON-ST3 */
  497.     s_ret
  498. };
  499.  
  500.  
  501. /* CODE START */
  502.  
  503.  
  504. static void getlastnfo(chn_t *ch)
  505. {
  506.     if (!ch->info)
  507.         ch->info = ch->alastnfo;
  508. }
  509.  
  510. static void setspeed(uint8_t val)
  511. {
  512.     if (val)
  513.         musicmax = val;
  514. }
  515.  
  516. static void settempo(uint16_t val)
  517. {
  518.     if (val > 32)
  519.     {
  520.         tempo = val;
  521.         setSamplesPerFrame(((audioFreq * 5) / 2) / tempo);
  522.     }
  523. }
  524.  
  525. static void setspd(uint8_t ch)
  526. {
  527.     int32_t tmpspd;
  528.  
  529.     chn[ch].achannelused |= 0x80;
  530.  
  531.     tmpspd = chn[ch].aspd;
  532.  
  533.     if (amigalimits)
  534.     {
  535.         if (chn[ch].aorgspd > aspdmax) chn[ch].aorgspd = aspdmax;
  536.         if (chn[ch].aorgspd < aspdmin) chn[ch].aorgspd = aspdmin;
  537.  
  538.         if (chn[ch].aspd > aspdmax)
  539.             chn[ch].aspd = aspdmax;
  540.     }
  541.  
  542.     if ((tracker == SCREAM_TRACKER) || amigalimits)
  543.     {
  544.         if (tmpspd > aspdmax)
  545.             tmpspd = aspdmax;
  546.     }
  547.     else
  548.     {
  549.         /* *ABSOLUTE* max! */
  550.         if (tmpspd > 14317056)
  551.             tmpspd = 14317056;
  552.     }
  553.  
  554.     if (tmpspd == 0)
  555.     {
  556.         /* cut channel */
  557.         voiceSetSamplingFrequency(ch, 0);
  558.         return;
  559.     }
  560.  
  561.     if (tmpspd < aspdmin)
  562.     {
  563.         tmpspd = aspdmin;
  564.  
  565.         if (amigalimits && (chn[ch].aspd < aspdmin))
  566.             chn[ch].aspd = aspdmin;
  567.     }
  568.  
  569.     /* ST3 actually uses 14317056 (3.579264MHz * 4) instead of 14317456 (1712*8363) */
  570.     if (tmpspd > 0)
  571.         voiceSetSamplingFrequency(ch, 14317056 / tmpspd);
  572. }
  573.  
  574. static void setvol(uint8_t ch)
  575. {
  576.     chn[ch].achannelused |= 0x80;
  577.     voiceSetVolume(ch, (chn[ch].avol / 63.0f) * (chn[ch].chanvol / 64.0f) * (globalvol / 64.0f), chn[ch].apanpos);
  578. }
  579.  
  580. static void setpan(uint8_t ch)
  581. {
  582.     voiceSetVolume(ch, (chn[ch].avol / 63.0f) * (chn[ch].chanvol / 64.0f) * (globalvol / 64.0f), chn[ch].apanpos);
  583. }
  584.  
  585. static int16_t stnote2herz(uint8_t note)
  586. {
  587.     uint8_t tmpnote;
  588.     uint8_t tmpocta;
  589.  
  590.     if (note == 254) return (0);
  591.  
  592.     tmpnote = note & 0x0F;
  593.     tmpocta = note >> 4;
  594.  
  595.     /* ST3 doesn't do this, but do it for safety */
  596.     if (tmpnote > 11) tmpnote = 11;
  597.  
  598.     /* limit octaves to 8 in ST3 mode */
  599.     if ((tracker == SCREAM_TRACKER) && (tmpocta > 7))
  600.         tmpocta = 7;
  601.  
  602.     return (notespd[tmpnote] >> tmpocta);
  603. }
  604.  
  605. static int32_t scalec2spd(uint8_t ch, int32_t spd)
  606. {
  607.     spd *= 8363;
  608.  
  609.     if (tracker == SCREAM_TRACKER)
  610.     {
  611.         if ((spd / 65536) >= chn[ch].ac2spd)
  612.             return (32767);
  613.     }
  614.  
  615.     if (chn[ch].ac2spd)
  616.         spd /= chn[ch].ac2spd;
  617.  
  618.     if (tracker == SCREAM_TRACKER)
  619.     {
  620.         if (spd > 32767)
  621.             return (32767);
  622.     }
  623.  
  624.     return (spd);
  625. }
  626.  
  627. /* for Gxx with semitones slide flag */
  628. static int32_t roundspd(uint8_t ch, int32_t spd)
  629. {
  630.     int8_t octa;
  631.     int8_t lastnote;
  632.     int8_t newnote;
  633.     int32_t note;
  634.     int32_t lastspd;
  635.     int32_t newspd;
  636.  
  637.     newspd = spd * chn[ch].ac2spd;
  638.  
  639.     if (tracker == SCREAM_TRACKER)
  640.     {
  641.         if ((newspd / 65536) >= 8363)
  642.             return (spd);
  643.     }
  644.  
  645.     newspd /= 8363;
  646.  
  647.     /* find octave */
  648.     octa    = 0;
  649.     lastspd = ((1712 * 8) + (907 * 16)) / 2;
  650.     while (lastspd >= newspd)
  651.     {
  652.         octa++;
  653.         lastspd /= 2;
  654.     }
  655.  
  656.     /* find note */
  657.     lastnote = 0;
  658.     newnote  = 0;
  659.  
  660.     if (tracker == SCREAM_TRACKER)
  661.         lastspd = 32767;
  662.     else
  663.         lastspd = 32767 * 2;
  664.  
  665.     while (newnote < 11)
  666.     {
  667.         note = (notespd[newnote] >> octa) - newspd;
  668.         if (note < 0) note *= -1; /* abs() */
  669.  
  670.         if (note < lastspd)
  671.         {
  672.             lastspd  = note;
  673.             lastnote = newnote;
  674.         }
  675.  
  676.         newnote++;
  677.     }
  678.  
  679.     /* get new speed from new note */
  680.     newspd = (stnote2herz((octa << 4) | (lastnote & 0x0F))) * 8363;
  681.  
  682.     if (tracker == SCREAM_TRACKER)
  683.     {
  684.         if ((newspd / 65536) >= chn[ch].ac2spd)
  685.             return (spd);
  686.     }
  687.  
  688.     if (chn[ch].ac2spd)
  689.         newspd /= chn[ch].ac2spd;
  690.  
  691.     return (newspd);
  692. }
  693.  
  694. static int16_t neworder(void)
  695. {
  696. newOrderSkip:
  697.     np_ord++;
  698.  
  699.     if ((mseg[0x60 + (np_ord - 1)] == 255) || (np_ord > *((uint16_t *)(&mseg[0x20])))) /* end */
  700.         np_ord = 1;
  701.  
  702.     if (mseg[0x60 + (np_ord - 1)] == 254) /* skip */
  703.         goto newOrderSkip;
  704.  
  705.     np_pat       = (int16_t)(mseg[0x60 + (np_ord - 1)]);
  706.     np_patoff    = -1; /* force reseek */
  707.     np_row       = startrow;
  708.     startrow     = 0;
  709.     patmusicrand = 0;
  710.     patloopstart = -1;
  711.     jumptorow    = -1;
  712.  
  713.     return (np_row);
  714. }
  715.  
  716. /* updates np_patseg and np_patoff */
  717. static void seekpat(void)
  718. {
  719.     uint8_t dat;
  720.     int16_t i;
  721.     int16_t j;
  722.  
  723.     if (np_patoff == -1) /* seek must be done */
  724.     {
  725.         np_patseg = (*((uint16_t *)(&mseg[patternadd + (np_pat * 2)]))) * 16;
  726.         if (np_patseg)
  727.         {
  728.             j = 2; /* skip packed pat len flag */
  729.  
  730.             /* increase np_patoff on patbreak */
  731.             if (np_row)
  732.             {
  733.                 i = np_row;
  734.                 while (i)
  735.                 {
  736.                     dat = mseg[np_patseg + j++];
  737.                     if (!dat)
  738.                     {
  739.                         i--;
  740.                     }
  741.                     else
  742.                     {
  743.                         /* skip ch data */
  744.                         if (dat & 0x20) j += 2;
  745.                         if (dat & 0x40) j += 1;
  746.                         if (dat & 0x80) j += 2;
  747.                     }
  748.                 }
  749.             }
  750.  
  751.             np_patoff = j;
  752.         }
  753.     }
  754. }
  755.  
  756. static uint8_t getnote(void)
  757. {
  758.     uint8_t dat;
  759.     uint8_t ch;
  760.     int16_t i;
  761.  
  762.     if (!np_patseg || (np_patseg >= mseg_len) || (np_pat >= *((uint16_t *)(&mseg[0x24]))))
  763.         return (255);
  764.  
  765.     i = np_patoff;
  766.     for (;;)
  767.     {
  768.         dat = mseg[np_patseg + i++];
  769.         if (!dat) /* end of row */
  770.         {
  771.             np_patoff = i;
  772.             return (255);
  773.         }
  774.  
  775.         if (!(mseg[0x40 + (dat & 0x1F)] & 0x80))
  776.         {
  777.             ch = dat & 0x1F; /* channel to trigger */
  778.             break;
  779.         }
  780.  
  781.         /* channel is off, skip data */
  782.         if (dat & 0x20) i += 2;
  783.         if (dat & 0x40) i += 1;
  784.         if (dat & 0x80) i += 2;
  785.     }
  786.  
  787.     if (dat & 0x20)
  788.     {
  789.         chn[ch].note = mseg[np_patseg + i++];
  790.         chn[ch].ins  = mseg[np_patseg + i++];
  791.  
  792.         if (chn[ch].note != 255) chn[ch].lastnote = chn[ch].note;
  793.         if (chn[ch].ins)         chn[ch].lastins  = chn[ch].ins;
  794.     }
  795.  
  796.     if (dat & 0x40)
  797.         chn[ch].vol = mseg[np_patseg + i++];
  798.  
  799.     if (dat & 0x80)
  800.     {
  801.         chn[ch].cmd  = mseg[np_patseg + i++];
  802.         chn[ch].info = mseg[np_patseg + i++];
  803.     }
  804.  
  805.     np_patoff = i;
  806.     return (ch);
  807. }
  808.  
  809. static void doamiga(uint8_t ch)
  810. {
  811.     uint8_t *insdat;
  812.     int8_t loop;
  813.     uint32_t insoffs;
  814.     uint32_t inslen;
  815.     uint32_t insrepbeg;
  816.     uint32_t insrepend;
  817.  
  818.     if (chn[ch].ins)
  819.     {
  820.         chn[ch].lastins = chn[ch].ins;
  821.         chn[ch].astartoffset = 0;
  822.  
  823.         if (chn[ch].ins <= *((uint16_t *)(&mseg[0x22]))) /* added for safety reasons */
  824.         {
  825.             insdat = &mseg[(*((uint16_t *)(&mseg[instrumentadd + ((chn[ch].ins - 1) * 2)]))) * 16];
  826.             if (insdat[0])
  827.             {
  828.                 if (insdat[0] == 1)
  829.                 {
  830.                     chn[ch].ac2spd = *((uint32_t *)(&insdat[0x20]));
  831.  
  832.                     if ((tracker == OPENMPT) || (tracker == BEROTRACKER))
  833.                     {
  834.                         if ((chn[ch].cmd == ('S' - 64)) && ((chn[ch].info & 0xF0) == 0x20))
  835.                             chn[ch].ac2spd = xfinetune_amiga[chn[ch].info & 0x0F];
  836.                     }
  837.  
  838.                     chn[ch].avol = (int8_t)(insdat[0x1C]);
  839.  
  840.                          if (chn[ch].avol <  0) chn[ch].avol =  0;
  841.                     else if (chn[ch].avol > 63) chn[ch].avol = 63;
  842.  
  843.                     chn[ch].aorgvol = chn[ch].avol;
  844.                     setvol(ch);
  845.  
  846.                     insoffs = ((insdat[0x0D] << 16) | (insdat[0x0F] << 8) | insdat[0x0E]) * 16;
  847.  
  848.                     inslen    = *((uint32_t *)(&insdat[0x10]));
  849.                     insrepbeg = *((uint32_t *)(&insdat[0x14]));
  850.                     insrepend = *((uint32_t *)(&insdat[0x18]));
  851.  
  852.                     if (insrepbeg > inslen) insrepbeg = inslen;
  853.                     if (insrepend > inslen) insrepend = inslen;
  854.  
  855.                     loop = 0;
  856.                     if ((insdat[0x1F] & 1) && inslen && (insrepend > insrepbeg))
  857.                         loop = 1;
  858.  
  859.                     /* This specific portion differs from what sound card driver you use in ST3... */
  860.                     if ((soundcardtype == SOUNDCARD_SB) || (chn[ch].cmd != ('G' - 64)) && (chn[ch].cmd != ('L' - 64)))
  861.                     {
  862.                         voiceSetSource(ch, (const int8_t *)(&mseg[insoffs]), inslen,
  863.                             insrepend - insrepbeg, insrepend, loop,
  864.                             insdat[0x1F] & 4, insdat[0x1F] & 2);
  865.                     }
  866.                 }
  867.                 else
  868.                 {
  869.                     chn[ch].lastins = 0;
  870.                 }
  871.             }
  872.         }
  873.     }
  874.  
  875.     /* continue only if we have an active instrument on this channel */
  876.     if (!chn[ch].lastins) return;
  877.  
  878.     if (chn[ch].cmd == ('O' - 64))
  879.     {
  880.         if (!chn[ch].info)
  881.         {
  882.             chn[ch].astartoffset = chn[ch].astartoffset00;
  883.         }
  884.         else
  885.         {
  886.             chn[ch].astartoffset   = 256 * chn[ch].info;
  887.             chn[ch].astartoffset00 = chn[ch].astartoffset;
  888.         }
  889.     }
  890.  
  891.     if (chn[ch].note != 255)
  892.     {
  893.         if (chn[ch].note == 254)
  894.         {
  895.             chn[ch].aspd    = 0;
  896.             chn[ch].avol    = 0;
  897.             chn[ch].asldspd = 65535;
  898.  
  899.             setspd(ch);
  900.             setvol(ch);
  901.  
  902.             /* shutdown channel */
  903.             voiceSetSource(ch, NULL, 0, 0, 0, 0, 0, 0);
  904.             voiceSetSamplePosition(ch, 0);
  905.         }
  906.         else
  907.         {
  908.             chn[ch].lastnote = chn[ch].note;
  909.  
  910.             if ((chn[ch].cmd != ('G' - 64)) && (chn[ch].cmd != ('L' - 64)))
  911.                 voiceSetSamplePosition(ch, chn[ch].astartoffset);
  912.  
  913.             if ((tracker == OPENMPT) || (tracker == BEROTRACKER))
  914.             {
  915.                 voiceSetPlayBackwards(ch, 0);
  916.                 if ((chn[ch].cmd == ('S' - 64)) && (chn[ch].info == 0x9F))
  917.                     voiceSetReadPosToEnd(ch);
  918.             }
  919.  
  920.             if (!chn[ch].aorgspd || ((chn[ch].cmd != ('G' - 64)) && (chn[ch].cmd != ('L' - 64))))
  921.             {
  922.                 chn[ch].aspd    = scalec2spd(ch, stnote2herz(chn[ch].note));
  923.                 chn[ch].aorgspd = chn[ch].aspd;
  924.                 chn[ch].avibcnt = 0;
  925.                 chn[ch].apancnt = 0;
  926.  
  927.                 setspd(ch);
  928.             }
  929.  
  930.             chn[ch].asldspd = scalec2spd(ch, stnote2herz(chn[ch].note));
  931.         }
  932.     }
  933.  
  934.     if (chn[ch].vol != 255)
  935.     {
  936.         if (chn[ch].vol <= 64)
  937.         {
  938.             chn[ch].avol    = chn[ch].vol;
  939.             chn[ch].aorgvol = chn[ch].vol;
  940.  
  941.             setvol(ch);
  942.  
  943.             return;
  944.         }
  945.  
  946.         /* NON-ST3, but let's handle it no matter what tracker */
  947.         if ((chn[ch].vol >= 128) && (chn[ch].vol <= 192))
  948.         {
  949.             chn[ch].surround = 0;
  950.             voiceSetSurround(ch, 0);
  951.  
  952.             chn[ch].apanpos = (chn[ch].vol - 128) * 4;
  953.             setpan(ch);
  954.         }
  955.     }
  956. }
  957.  
  958. static void donewnote(uint8_t ch, int8_t notedelayflag)
  959. {
  960.     if (notedelayflag)
  961.     {
  962.         chn[ch].achannelused = 0x81;
  963.     }
  964.     else
  965.     {
  966.         if (chn[ch].channelnum > lastachannelused)
  967.         {
  968.             lastachannelused = chn[ch].channelnum + 1;
  969.  
  970.             /* sanity fix */
  971.             if (lastachannelused > 31) lastachannelused = 31;
  972.         }
  973.  
  974.         chn[ch].achannelused = 0x01;
  975.  
  976.         if (chn[ch].cmd == ('S' - 64))
  977.         {
  978.             if ((chn[ch].info & 0xF0) == 0xD0)
  979.                 return;
  980.         }
  981.     }
  982.  
  983.     doamiga(ch);
  984. }
  985.  
  986. static void donotes(void)
  987. {
  988.     uint8_t i;
  989.     uint8_t ch;
  990.  
  991.     for (i = 0; i < 32; ++i)
  992.     {
  993.         chn[i].note = 255;
  994.         chn[i].vol  = 255;
  995.         chn[i].ins  = 0;
  996.         chn[i].cmd  = 0;
  997.         chn[i].info = 0;
  998.     }
  999.  
  1000.     seekpat();
  1001.  
  1002.     for (;;)
  1003.     {
  1004.         ch = getnote();
  1005.         if (ch == 255) break; /* end of row/channels */
  1006.  
  1007.         if ((mseg[0x40 + ch] & 0x7F) <= 15) /* no adlib channel types yet */
  1008.             donewnote(ch, 0);
  1009.     }
  1010. }
  1011.  
  1012. /* tick 0 commands */
  1013. static void docmd1(void)
  1014. {
  1015.     uint8_t i;
  1016.  
  1017.     for (i = 0; i < (lastachannelused + 1); ++i)
  1018.     {
  1019.         if (chn[i].achannelused)
  1020.         {
  1021.             if (chn[i].info)
  1022.                 chn[i].alastnfo = chn[i].info;
  1023.  
  1024.             if (chn[i].cmd)
  1025.             {
  1026.                 chn[i].achannelused |= 0x80;
  1027.  
  1028.                 if (chn[i].cmd == ('D' - 64))
  1029.                 {
  1030.                     /* fix retrig if Dxy */
  1031.                     chn[i].atrigcnt = 0;
  1032.  
  1033.                     /* fix speed if tone port noncomplete */
  1034.                     if (chn[i].aspd != chn[i].aorgspd)
  1035.                     {
  1036.                         chn[i].aspd = chn[i].aorgspd;
  1037.                         setspd(i);
  1038.                     }
  1039.                 }
  1040.                 else
  1041.                 {
  1042.                     if (chn[i].cmd != ('I' - 64))
  1043.                     {
  1044.                         chn[i].atremor = 0;
  1045.                         chn[i].atreon  = 1;
  1046.                     }
  1047.  
  1048.                     if ((chn[i].cmd != ('H' - 64)) &&
  1049.                         (chn[i].cmd != ('U' - 64)) &&
  1050.                         (chn[i].cmd != ('K' - 64)) &&
  1051.                         (chn[i].cmd != ('R' - 64)))
  1052.                     {
  1053.                         chn[i].avibcnt |= 0x80;
  1054.                     }
  1055.  
  1056.                     /* NON-ST3 */
  1057.                     if ((tracker != SCREAM_TRACKER) && (tracker != IMAGO_ORPHEUS))
  1058.                     {
  1059.                         if (chn[i].cmd != ('Y' - 64))
  1060.                             chn[i].apancnt |= 0x80;
  1061.                     }
  1062.                 }
  1063.  
  1064.                 if (chn[i].cmd < 27)
  1065.                 {
  1066.                     volslidetype = 0;
  1067.                     soncejmp[chn[i].cmd](&chn[i]);
  1068.                 }
  1069.             }
  1070.             else
  1071.             {
  1072.                 /* NON-ST3 */
  1073.                 if (tracker != SCREAM_TRACKER)
  1074.                 {
  1075.                     /* recalc pans */
  1076.                     setpan(i);
  1077.                     voiceSetSurround(i, chn[i].surround);
  1078.                 }
  1079.  
  1080.                 /* fix retrig if no command */
  1081.                 chn[i].atrigcnt = 0;
  1082.  
  1083.                 /* fix speed if tone port noncomplete */
  1084.                 if (chn[i].aspd != chn[i].aorgspd)
  1085.                 {
  1086.                     chn[i].aspd  = chn[i].aorgspd;
  1087.                     setspd(i);
  1088.                 }
  1089.             }
  1090.         }
  1091.     }
  1092. }
  1093.  
  1094. /* tick >0 commands */
  1095. static void docmd2(void)
  1096. {
  1097.     uint8_t i;
  1098.  
  1099.     for (i = 0; i < (lastachannelused + 1); ++i)
  1100.     {
  1101.         if (chn[i].achannelused)
  1102.         {
  1103.             if (chn[i].cmd)
  1104.             {
  1105.                 chn[i].achannelused |= 0x80;
  1106.  
  1107.                 if (chn[i].cmd < 27)
  1108.                 {
  1109.                     volslidetype = 0;
  1110.                     sotherjmp[chn[i].cmd](&chn[i]);
  1111.                 }
  1112.             }
  1113.         }
  1114.     }
  1115. }
  1116.  
  1117. void dorow(void) /* periodically called from mixer */
  1118. {
  1119.     patmusicrand = (((patmusicrand * 0xCDEF) >> 16) + 0x1727) & 0x0000FFFF;
  1120.  
  1121.     if (!musiccount)
  1122.     {
  1123.         if (patterndelay)
  1124.         {
  1125.             np_row--;
  1126.             docmd1();
  1127.             patterndelay--;
  1128.         }
  1129.         else
  1130.         {
  1131.             donotes();
  1132.             docmd1();
  1133.         }
  1134.     }
  1135.     else
  1136.     {
  1137.         docmd2();
  1138.     }
  1139.  
  1140.     musiccount++;
  1141.     if (musiccount >= (musicmax + tickdelay))
  1142.     {
  1143.         tickdelay = 0;
  1144.         np_row++;
  1145.  
  1146.         if (jumptorow != -1)
  1147.         {
  1148.             np_row = jumptorow;
  1149.             jumptorow = -1;
  1150.         }
  1151.  
  1152.         /* np_row = 0..63, 64 = get new pat */
  1153.         if ((np_row >= 64) || (!patloopcount && breakpat))
  1154.         {
  1155.             if (breakpat == 255)
  1156.             {
  1157.                 breakpat = 0;
  1158.                 Playing  = 0;
  1159.  
  1160.                 return;
  1161.             }
  1162.  
  1163.             breakpat = 0;
  1164.             np_row = neworder(); /* if breakpat, np_row = break row */
  1165.         }
  1166.  
  1167.         musiccount = 0;
  1168.     }
  1169. }
  1170.  
  1171. static void loadheaderparms(void)
  1172. {
  1173.     uint8_t *insdat;
  1174.     uint16_t insnum;
  1175.     uint32_t i;
  1176.     uint32_t j;
  1177.     uint32_t inslen;
  1178.     uint32_t insoff;
  1179.  
  1180.     /* set to init defaults first */
  1181.     oldstvib = 0;
  1182.     setspeed(6);
  1183.     settempo(125);
  1184.     aspdmin = 64;
  1185.     aspdmax = 32767;
  1186.     globalvol = 64;
  1187.     amigalimits = 0;
  1188.     fastvolslide = 0;
  1189.     setStereoMode(0);
  1190.     setMasterVolume(48);
  1191.  
  1192.     tracker = mseg[0x29] >> 4;
  1193.  
  1194.     if (mseg[0x33])
  1195.     {
  1196.         if (mseg[0x33] & 0x80)
  1197.             setStereoMode(1);
  1198.  
  1199.         if (mseg[0x33] & 0x7F)
  1200.         {
  1201.             if ((mseg[0x33] & 0x7F) < 16)
  1202.                 setMasterVolume(16);
  1203.             else
  1204.                 setMasterVolume(mseg[0x33] & 0x7F);
  1205.         }
  1206.     }
  1207.  
  1208.     if (mseg[0x32])
  1209.         settempo(mseg[0x32]);
  1210.  
  1211.     if (mseg[0x31] != 255)
  1212.         setspeed(mseg[0x31]);
  1213.  
  1214.     if (mseg[0x30] != 255)
  1215.     {
  1216.         globalvol = mseg[0x30];
  1217.         if (globalvol > 64)
  1218.             globalvol = 64;
  1219.     }
  1220.  
  1221.     if (mseg[0x26] != 255)
  1222.     {
  1223.         amigalimits  = mseg[0x26] & 0x10;
  1224.         fastvolslide = mseg[0x26] & 0x40;
  1225.  
  1226.         if (amigalimits)
  1227.         {
  1228.             aspdmax = 1712 * 2;
  1229.             aspdmin =  907 / 2;
  1230.         }
  1231.     }
  1232.  
  1233.     /* force fastvolslide if ST3.00 */
  1234.     if (*((uint16_t *)(&mseg[0x28])) == 0x1300)
  1235.         fastvolslide = 1;
  1236.  
  1237.     oldstvib = mseg[0x26] & 0x01;
  1238.  
  1239.     if (*((uint16_t *)(&mseg[0x2A])))
  1240.     {
  1241.         /* we have unsigned samples, convert to signed */
  1242.  
  1243.         insnum = *((uint16_t *)(&mseg[0x22]));
  1244.         for (i = 0; i < insnum; ++i)
  1245.         {
  1246.             insdat = &mseg[*((uint16_t *)(&mseg[instrumentadd + (i * 2)])) * 16];
  1247.             insoff = ((insdat[0x0D] << 16) | (insdat[0x0F] << 8) | insdat[0x0E]) * 16;
  1248.  
  1249.             if (insoff && (insdat[0] == 1))
  1250.             {
  1251.                 inslen = *((uint32_t *)(&insdat[0x10]));
  1252.  
  1253.                 if (insdat[0x1F] & 2) inslen *= 2; /* stereo */
  1254.  
  1255.                 if (insdat[0x1F] & 4)
  1256.                 {
  1257.                     /* 16-bit */
  1258.                     for (j = 0; j < inslen; ++j)
  1259.                         *((int16_t *)(&mseg[insoff + (j * 2)])) = *((uint16_t *)(&mseg[insoff + (j * 2)])) - 0x8000;
  1260.                 }
  1261.                 else
  1262.                 {
  1263.                     /* 8-bit */
  1264.                     for (j = 0; j < inslen; ++j)
  1265.                         mseg[insoff + j] = mseg[insoff + j] - 0x80;
  1266.                 }
  1267.             }
  1268.         }
  1269.     }
  1270. }
  1271.  
  1272. void st3play_PlaySong(int32_t soundCardType)
  1273. {
  1274.     uint8_t i;
  1275.     uint8_t dat;
  1276.     int16_t pan;
  1277.  
  1278.     soundcardtype = (soundCardType == SOUNDCARD_GUS) ? SOUNDCARD_GUS : SOUNDCARD_SB;
  1279.  
  1280.     if (!ModuleLoaded) return;
  1281.  
  1282.     memset(voice, 0, sizeof (voice));
  1283.  
  1284.     loadheaderparms();
  1285.  
  1286.     np_ord = 0;
  1287.     neworder();
  1288.  
  1289.     /* set up pans */
  1290.     for (i = 0; i < 32; ++i)
  1291.     {
  1292.         pan = 128;
  1293.         if (mseg[0x40 + i] != 0xFF)
  1294.             pan = (mseg[0x40 + i] & 8) ? (0x0C * 17) : (0x03 * 17);
  1295.  
  1296.         if (mseg[0x35] == 0xFC) /* non-default pannings follow */
  1297.         {
  1298.             dat = mseg[(patternadd + (*((uint16_t *)(&mseg[0x24])) * 2)) + i];
  1299.             if (dat & 0x20)
  1300.                 pan = (dat & 0x0F) * 17;
  1301.         }
  1302.  
  1303.         chn[i].apanpos = stereomode ? pan : 128;
  1304.         setpan(i);
  1305.     }
  1306.  
  1307.     Playing = 1;
  1308.     setSamplesPerFrame(((audioFreq * 5) / 2 / tempo));
  1309.     isMixing = 1;
  1310.  
  1311.     if (MusicPaused)
  1312.         MusicPaused = 0;
  1313. }
  1314.  
  1315. int8_t st3play_LoadModule(const uint8_t *moduleData, uint32_t dataLength)
  1316. {
  1317.     char SCRM[4];
  1318.  
  1319.     uint32_t filesize;
  1320.     uint16_t i;
  1321.  
  1322.     MEM *modhandle;
  1323.  
  1324.     if (ModuleLoaded)
  1325.         st3play_FreeSong();
  1326.  
  1327.     ModuleLoaded = 0;
  1328.  
  1329.     modhandle = mopen(moduleData, dataLength);
  1330.     if (modhandle == NULL) return (0);
  1331.  
  1332.     mseek(modhandle, 0, SEEK_END);
  1333.     filesize = mtell(modhandle);
  1334.     mseek(modhandle, 0, SEEK_SET);
  1335.  
  1336.     if (filesize < 0x30)
  1337.     {
  1338.         mseg_len = 0;
  1339.         mclose(&modhandle);
  1340.         return (0);
  1341.     }
  1342.  
  1343.     mseek(modhandle, 0x2C, SEEK_SET);
  1344.     mread(SCRM, 1, 4, modhandle);
  1345.     if (memcmp(SCRM, "SCRM", 4))
  1346.     {
  1347.         mseg_len = 0;
  1348.         mclose(&modhandle);
  1349.         return (0);
  1350.     }
  1351.  
  1352.     mseek(modhandle, 0, SEEK_SET);
  1353.  
  1354.     if (mseg)
  1355.     {
  1356.         free(mseg);
  1357.         mseg = NULL;
  1358.     }
  1359.  
  1360.     mseg = (uint8_t *)(malloc(filesize));
  1361.     if (mseg == NULL)
  1362.     {
  1363.         mseg_len = 0;
  1364.         mclose(&modhandle);
  1365.         return (0);
  1366.     }
  1367.  
  1368.     if (mread(mseg, 1, filesize, modhandle) != filesize)
  1369.     {
  1370.         mseg_len = 0;
  1371.         mclose(&modhandle);
  1372.         return (0);
  1373.     }
  1374.  
  1375.     mclose(&modhandle);
  1376.  
  1377.     mseg_len = filesize;
  1378.  
  1379.     instrumentadd    = 0x60          +  mseg[0x20];
  1380.     patternadd       = instrumentadd + (mseg[0x22] * 2);
  1381.     musiccount       = 0;
  1382.     patterndelay     = 0;
  1383.     patloopstart     = 0;
  1384.     patloopcount     = 0;
  1385.     np_row           = 0;
  1386.     np_pat           = 0;
  1387.     startrow         = 0;
  1388.     np_patseg        = 0;
  1389.     np_patoff        = 0;
  1390.     breakpat         = 0;
  1391.     patmusicrand     = 0;
  1392.     volslidetype     = 0;
  1393.     jumptorow        = 0;
  1394.  
  1395.     /* zero all channel vars */
  1396.     memset(chn, 0, sizeof (chn));
  1397.  
  1398.     numChannels = 0;
  1399.     for (i = 0; i < 32; ++i)
  1400.     {
  1401.         if (!(mseg[0x40 + i] & 0x80))
  1402.             numChannels++;
  1403.  
  1404.         chn[i].channelnum   = (int8_t)(i);
  1405.         chn[i].achannelused = 0x80;
  1406.         chn[i].chanvol      = 0x40;
  1407.     }
  1408.  
  1409.     lastachannelused = 1;
  1410.  
  1411.     /* count *real* amounts of orders */
  1412.     i = *((uint16_t *)(&mseg[0x20]));
  1413.     while (i)
  1414.     {
  1415.         if (mseg[0x60 + (i - 1)] != 255)
  1416.             break;
  1417.  
  1418.         i--;
  1419.     }
  1420.     *((uint16_t *)(&mseg[0x20])) = i;
  1421.  
  1422.     ModuleLoaded = 1;
  1423.  
  1424.     return (1);
  1425. }
  1426.  
  1427.  
  1428. /* EFFECTS */
  1429.  
  1430. /* non-used effects */
  1431. static void s_ret(chn_t *ch) { (void)(ch); }
  1432. /* ---------------- */
  1433.  
  1434. static void s_setgliss(chn_t *ch)
  1435. {
  1436.     ch->aglis = ch->info & 0x0F;
  1437. }
  1438.  
  1439. static void s_setfinetune(chn_t *ch)
  1440. {
  1441.     /* this function does nothing in ST3 and many other trackers */
  1442.     if ((tracker == OPENMPT) || (tracker == BEROTRACKER))
  1443.         ch->ac2spd = xfinetune_amiga[ch->info & 0x0F];
  1444. }
  1445.  
  1446. static void s_setvibwave(chn_t *ch)
  1447. {
  1448.     ch->avibtretype = (ch->avibtretype & 0xF0) | ((ch->info << 1) & 0x0F);
  1449. }
  1450.  
  1451. static void s_settrewave(chn_t *ch)
  1452. {
  1453.     ch->avibtretype = ((ch->info << 5) & 0xF0) | (ch->avibtretype & 0x0F);
  1454. }
  1455.  
  1456. static void s_setpanwave(chn_t *ch) /* NON-ST3 */
  1457. {
  1458.     if ((tracker != SCREAM_TRACKER) && (tracker != IMAGO_ORPHEUS))
  1459.         ch->apantype = ch->info & 0x0F;
  1460. }
  1461.  
  1462. static void s_tickdelay(chn_t *ch) /* NON-ST3 */
  1463. {
  1464.     if (   (tracker == OPENMPT)
  1465.         || (tracker == BEROTRACKER)
  1466.         || (tracker == IMPULSE_TRACKER)
  1467.         || (tracker == SCHISM_TRACKER)
  1468.        )
  1469.     {
  1470.         tickdelay += (ch->info & 0x0F);
  1471.     }
  1472. }
  1473.  
  1474. static void s_setpanpos(chn_t *ch)
  1475. {
  1476.     ch->surround = 0;
  1477.     voiceSetSurround(ch->channelnum, 0);
  1478.  
  1479.     ch->apanpos = (ch->info & 0x0F) * 17;
  1480.     setpan(ch->channelnum);
  1481. }
  1482.  
  1483. static void s_sndcntrl(chn_t *ch) /* NON-ST3 */
  1484. {
  1485.     if ((ch->info & 0x0F) == 0x00)
  1486.     {
  1487.         if ((tracker != SCREAM_TRACKER) && (tracker != IMAGO_ORPHEUS))
  1488.         {
  1489.             ch->surround = 0;
  1490.             voiceSetSurround(ch->channelnum, 0);
  1491.         }
  1492.     }
  1493.     else if ((ch->info & 0x0F) == 0x01)
  1494.     {
  1495.         if ((tracker != SCREAM_TRACKER) && (tracker != IMAGO_ORPHEUS))
  1496.         {
  1497.             ch->surround = 1;
  1498.             voiceSetSurround(ch->channelnum, 1);
  1499.         }
  1500.     }
  1501.     else if ((ch->info & 0x0F) == 0x0E)
  1502.     {
  1503.         if ((tracker == OPENMPT) || (tracker == BEROTRACKER))
  1504.             voiceSetPlayBackwards(ch->channelnum, 0);
  1505.     }
  1506.     else if ((ch->info & 0x0F) == 0x0F)
  1507.     {
  1508.         if ((tracker == OPENMPT) || (tracker == BEROTRACKER))
  1509.             voiceSetPlayBackwards(ch->channelnum, 1);
  1510.     }
  1511. }
  1512.  
  1513. static void s_patloop(chn_t *ch)
  1514. {
  1515.     if (!(ch->info & 0x0F))
  1516.     {
  1517.         patloopstart = np_row;
  1518.         return;
  1519.     }
  1520.  
  1521.     if (!patloopcount)
  1522.     {
  1523.         patloopcount = (ch->info & 0x0F) + 1;
  1524.  
  1525.         if (patloopstart == -1)
  1526.             patloopstart = 0; /* default loopstart */
  1527.     }
  1528.  
  1529.     if (patloopcount > 1)
  1530.     {
  1531.         patloopcount--;
  1532.  
  1533.         jumptorow = patloopstart;
  1534.         np_patoff = -1; /* force reseek */
  1535.     }
  1536.     else
  1537.     {
  1538.         patloopcount = 0;
  1539.         patloopstart = np_row + 1;
  1540.     }
  1541. }
  1542.  
  1543. static void s_notecut(chn_t *ch)
  1544. {
  1545.     ch->anotecutcnt = ch->info & 0x0F;
  1546. }
  1547.  
  1548. static void s_notecutb(chn_t *ch)
  1549. {
  1550.     if (ch->anotecutcnt)
  1551.     {
  1552.         ch->anotecutcnt--;
  1553.         if (!ch->anotecutcnt)
  1554.             voiceSetSamplingFrequency(ch->channelnum, 0); /* cut note */
  1555.     }
  1556. }
  1557.  
  1558. static void s_notedelay(chn_t *ch)
  1559. {
  1560.     ch->anotedelaycnt = ch->info & 0x0F;
  1561. }
  1562.  
  1563. static void s_notedelayb(chn_t *ch)
  1564. {
  1565.     if (ch->anotedelaycnt)
  1566.     {
  1567.         ch->anotedelaycnt--;
  1568.         if (!ch->anotedelaycnt)
  1569.             donewnote(ch->channelnum, 1); /* 1 = notedelay end */
  1570.     }
  1571. }
  1572.  
  1573. static void s_patterdelay(chn_t *ch)
  1574. {
  1575.     if (patterndelay == 0)
  1576.         patterndelay = ch->info & 0x0F;
  1577. }
  1578.  
  1579. static void s_setspeed(chn_t *ch)
  1580. {
  1581.     setspeed(ch->info);
  1582. }
  1583.  
  1584. static void s_jmpto(chn_t *ch)
  1585. {
  1586.     if (ch->info != 0xFF)
  1587.     {
  1588.         breakpat = 1;
  1589.         np_ord = ch->info;
  1590.     }
  1591.     else
  1592.     {
  1593.         breakpat = 255;
  1594.     }
  1595. }
  1596.  
  1597. static void s_break(chn_t *ch)
  1598. {
  1599.     startrow = ((ch->info >> 4) * 10) + (ch->info & 0x0F);
  1600.     breakpat = 1;
  1601. }
  1602.  
  1603. static void s_volslide(chn_t *ch)
  1604. {
  1605.     uint8_t infohi;
  1606.     uint8_t infolo;
  1607.  
  1608.     getlastnfo(ch);
  1609.  
  1610.     infohi = ch->info >> 4;
  1611.     infolo = ch->info & 0x0F;
  1612.  
  1613.     if (infolo == 0x0F)
  1614.     {
  1615.         if (!infohi)
  1616.             ch->avol -= infolo;
  1617.         else if (!musiccount)
  1618.             ch->avol += infohi;
  1619.     }
  1620.     else if (infohi == 0x0F)
  1621.     {
  1622.         if (!infolo)
  1623.             ch->avol += infohi;
  1624.         else if (!musiccount)
  1625.             ch->avol -= infolo;
  1626.     }
  1627.     else if (fastvolslide || musiccount)
  1628.     {
  1629.         if (!infolo)
  1630.             ch->avol += infohi;
  1631.         else
  1632.             ch->avol -= infolo;
  1633.     }
  1634.     else
  1635.     {
  1636.         return; /* illegal slide */
  1637.     }
  1638.  
  1639.          if (ch->avol <  0) ch->avol =  0;
  1640.     else if (ch->avol > 63) ch->avol = 63;
  1641.  
  1642.     setvol(ch->channelnum);
  1643.  
  1644.          if (volslidetype == 1) s_vibrato(ch);
  1645.     else if (volslidetype == 2) s_toneslide(ch);
  1646. }
  1647.  
  1648. static void s_slidedown(chn_t *ch)
  1649. {
  1650.     if (ch->aorgspd)
  1651.     {
  1652.         getlastnfo(ch);
  1653.  
  1654.         if (musiccount)
  1655.         {
  1656.             if (ch->info >= 0xE0) return; /* no fine slides here */
  1657.  
  1658.             ch->aspd += (ch->info * 4);
  1659.             if (ch->aspd > 32767) ch->aspd = 32767;
  1660.         }
  1661.         else
  1662.         {
  1663.             if (ch->info <= 0xE0) return; /* only fine slides here */
  1664.  
  1665.             if (ch->info <= 0xF0)
  1666.             {
  1667.                 ch->aspd += (ch->info & 0x0F);
  1668.                 if (ch->aspd > 32767) ch->aspd = 32767;
  1669.             }
  1670.             else
  1671.             {
  1672.                 ch->aspd += ((ch->info & 0x0F) * 4);
  1673.                 if (ch->aspd > 32767) ch->aspd = 32767;
  1674.             }
  1675.         }
  1676.  
  1677.         ch->aorgspd = ch->aspd;
  1678.         setspd(ch->channelnum);
  1679.     }
  1680. }
  1681.  
  1682. static void s_slideup(chn_t *ch)
  1683. {
  1684.     if (ch->aorgspd)
  1685.     {
  1686.         getlastnfo(ch);
  1687.  
  1688.         if (musiccount)
  1689.         {
  1690.             if (ch->info >= 0xE0) return; /* no fine slides here */
  1691.  
  1692.             ch->aspd -= (ch->info * 4);
  1693.             if (ch->aspd < 0) ch->aspd = 0;
  1694.         }
  1695.         else
  1696.         {
  1697.             if (ch->info <= 0xE0) return; /* only fine slides here */
  1698.  
  1699.             if (ch->info <= 0xF0)
  1700.             {
  1701.                 ch->aspd -= (ch->info & 0x0F);
  1702.                 if (ch->aspd < 0) ch->aspd = 0;
  1703.             }
  1704.             else
  1705.             {
  1706.                 ch->aspd -= ((ch->info & 0x0F) * 4);
  1707.                 if (ch->aspd < 0) ch->aspd = 0;
  1708.             }
  1709.         }
  1710.  
  1711.         ch->aorgspd = ch->aspd;
  1712.         setspd(ch->channelnum);
  1713.     }
  1714. }
  1715.  
  1716. static void s_toneslide(chn_t *ch)
  1717. {
  1718.     if (volslidetype == 2) /* we came from an Lxy (toneslide+volslide) */
  1719.     {
  1720.         ch->info = ch->alasteff1;
  1721.     }
  1722.     else
  1723.     {
  1724.         if (!ch->aorgspd)
  1725.         {
  1726.             if (!ch->asldspd)
  1727.                 return;
  1728.  
  1729.             ch->aorgspd = ch->asldspd;
  1730.             ch->aspd    = ch->asldspd;
  1731.         }
  1732.  
  1733.         if (!ch->info)
  1734.             ch->info = ch->alasteff1;
  1735.         else
  1736.             ch->alasteff1 = ch->info;
  1737.    }
  1738.  
  1739.     if (ch->aorgspd != ch->asldspd)
  1740.     {
  1741.         if (ch->aorgspd < ch->asldspd)
  1742.         {
  1743.             ch->aorgspd += (ch->info * 4);
  1744.             if (ch->aorgspd > ch->asldspd)
  1745.                 ch->aorgspd = ch->asldspd;
  1746.         }
  1747.         else
  1748.         {
  1749.             ch->aorgspd -= (ch->info * 4);
  1750.             if (ch->aorgspd < ch->asldspd)
  1751.                 ch->aorgspd = ch->asldspd;
  1752.         }
  1753.  
  1754.         if (ch->aglis)
  1755.             ch->aspd = roundspd(ch->channelnum, ch->aorgspd);
  1756.         else
  1757.             ch->aspd = ch->aorgspd;
  1758.  
  1759.         setspd(ch->channelnum);
  1760.     }
  1761. }
  1762.  
  1763. static void s_vibrato(chn_t *ch)
  1764. {
  1765.     int8_t type;
  1766.     int16_t cnt;
  1767.     int32_t dat;
  1768.  
  1769.     if (volslidetype == 1) /* we came from a Kxy (vibrato+volslide) */
  1770.     {
  1771.         ch->info = ch->alasteff;
  1772.     }
  1773.     else
  1774.     {
  1775.         if (!ch->info)
  1776.             ch->info = ch->alasteff;
  1777.  
  1778.         if (!(ch->info & 0xF0))
  1779.             ch->info = (ch->alasteff & 0xF0) | (ch->info & 0x0F);
  1780.  
  1781.         ch->alasteff = ch->info;
  1782.     }
  1783.  
  1784.     if (ch->aorgspd)
  1785.     {
  1786.         cnt  = ch->avibcnt;
  1787.         type = (ch->avibtretype & 0x0E) >> 1;
  1788.         dat  = 0;
  1789.  
  1790.         /* sine */
  1791.         if ((type == 0) || (type == 4))
  1792.         {
  1793.             if (type == 4)
  1794.             {
  1795.                 cnt &= 0x7F;
  1796.             }
  1797.             else
  1798.             {
  1799.                 if (cnt & 0x80) cnt = 0;
  1800.             }
  1801.  
  1802.             dat = vibsin[cnt / 2];
  1803.         }
  1804.  
  1805.         /* ramp */
  1806.         else if ((type == 1) || (type == 5))
  1807.         {
  1808.             if (type == 5)
  1809.             {
  1810.                 cnt &= 0x7F;
  1811.             }
  1812.             else
  1813.             {
  1814.                 if (cnt & 0x80) cnt = 0;
  1815.             }
  1816.  
  1817.             dat = vibramp[cnt / 2];
  1818.         }
  1819.  
  1820.         /* square */
  1821.         else if ((type == 2) || (type == 6))
  1822.         {
  1823.             if (type == 6)
  1824.             {
  1825.                 cnt &= 0x7F;
  1826.             }
  1827.             else
  1828.             {
  1829.                 if (cnt & 0x80) cnt = 0;
  1830.             }
  1831.  
  1832.             dat = vibsqu[cnt / 2];
  1833.         }
  1834.  
  1835.         /* random */
  1836.         else if ((type == 3) || (type == 7))
  1837.         {
  1838.             if (type == 7)
  1839.             {
  1840.                 cnt &= 0x7F;
  1841.             }
  1842.             else
  1843.             {
  1844.                 if (cnt & 0x80) cnt = 0;
  1845.             }
  1846.  
  1847.             dat = vibsin[cnt / 2];
  1848.             cnt += (patmusicrand & 0x1E);
  1849.         }
  1850.  
  1851.         if (oldstvib)
  1852.             dat = ((dat * (ch->info & 0x0F)) >> 4) + ch->aorgspd;
  1853.         else
  1854.             dat = ((dat * (ch->info & 0x0F)) >> 5) + ch->aorgspd;
  1855.  
  1856.         ch->aspd = dat;
  1857.         setspd(ch->channelnum);
  1858.  
  1859.         ch->avibcnt = (cnt + ((ch->info >> 4) * 2)) & 0x7E;
  1860.     }
  1861. }
  1862.  
  1863. static void s_tremor(chn_t *ch)
  1864. {
  1865.     getlastnfo(ch);
  1866.  
  1867.     if (ch->atremor)
  1868.     {
  1869.         ch->atremor--;
  1870.         return;
  1871.     }
  1872.  
  1873.     if (ch->atreon)
  1874.     {
  1875.         ch->atreon = 0;
  1876.  
  1877.         ch->avol = 0;
  1878.         setvol(ch->channelnum);
  1879.  
  1880.         ch->atremor = ch->info & 0x0F;
  1881.     }
  1882.     else
  1883.     {
  1884.         ch->atreon = 1;
  1885.  
  1886.         ch->avol = ch->aorgvol;
  1887.         setvol(ch->channelnum);
  1888.  
  1889.         ch->atremor = ch->info >> 4;
  1890.     }
  1891. }
  1892.  
  1893. static void s_arp(chn_t *ch)
  1894. {
  1895.     int8_t note;
  1896.     int8_t octa;
  1897.     int8_t noteadd;
  1898.     uint8_t tick;
  1899.  
  1900.     getlastnfo(ch);
  1901.  
  1902.     tick = musiccount % 3;
  1903.  
  1904.          if (tick == 1) noteadd = ch->info >> 4;
  1905.     else if (tick == 2) noteadd = ch->info & 0x0F;
  1906.     else                noteadd = 0;
  1907.  
  1908.     /* check for octave overflow */
  1909.     octa =  ch->lastnote & 0xF0;
  1910.     note = (ch->lastnote & 0x0F) + noteadd;
  1911.  
  1912.     while (note >= 12)
  1913.     {
  1914.         note -= 12;
  1915.         octa += 16;
  1916.     }
  1917.  
  1918.     ch->aspd = scalec2spd(ch->channelnum, stnote2herz(octa | note));
  1919.     setspd(ch->channelnum);
  1920. }
  1921.  
  1922. static void s_chanvol(chn_t *ch) /* NON-ST3 */
  1923. {
  1924.     if ((tracker != SCREAM_TRACKER) && (tracker != IMAGO_ORPHEUS))
  1925.     {
  1926.         if (ch->info <= 0x40)
  1927.             ch->chanvol = ch->info;
  1928.            
  1929.         setvol(ch->channelnum);
  1930.     }
  1931. }
  1932.  
  1933. static void s_chanvolslide(chn_t *ch) /* NON-ST3 */
  1934. {
  1935.     uint8_t infohi;
  1936.     uint8_t infolo;
  1937.  
  1938.     if ((tracker != SCREAM_TRACKER) && (tracker != IMAGO_ORPHEUS))
  1939.     {
  1940.         if (ch->info)
  1941.             ch->nxymem = ch->info;
  1942.         else
  1943.             ch->info = ch->nxymem;
  1944.  
  1945.         infohi = ch->nxymem >> 4;
  1946.         infolo = ch->nxymem & 0x0F;
  1947.  
  1948.         if (infolo == 0x0F)
  1949.         {
  1950.             if (!infohi)
  1951.                 ch->chanvol -= infolo;
  1952.             else if (!musiccount)
  1953.                 ch->chanvol += infohi;
  1954.         }
  1955.         else if (infohi == 0x0F)
  1956.         {
  1957.             if (!infolo)
  1958.                 ch->chanvol += infohi;
  1959.             else if (!musiccount)
  1960.                 ch->chanvol -= infolo;
  1961.         }
  1962.         else if (musiccount) /* don't rely on fastvolslide flag here */
  1963.         {
  1964.             if (!infolo)
  1965.                 ch->chanvol += infohi;
  1966.             else
  1967.                 ch->chanvol -= infolo;
  1968.         }
  1969.         else
  1970.         {
  1971.             return; /* illegal slide */
  1972.         }
  1973.  
  1974.              if (ch->chanvol <  0) ch->chanvol =  0;
  1975.         else if (ch->chanvol > 64) ch->chanvol = 64;
  1976.  
  1977.         setvol(ch->channelnum);
  1978.     }
  1979. }
  1980.  
  1981. static void s_vibvol(chn_t *ch)
  1982. {
  1983.     volslidetype = 1;
  1984.     s_volslide(ch);
  1985. }
  1986.  
  1987. static void s_tonevol(chn_t *ch)
  1988. {
  1989.     volslidetype = 2;
  1990.     s_volslide(ch);
  1991. }
  1992.  
  1993. static void s_panslide(chn_t *ch) /* NON-ST3 */
  1994. {
  1995.     uint8_t infohi;
  1996.     uint8_t infolo;
  1997.  
  1998.     if ((tracker != SCREAM_TRACKER) && (tracker != IMAGO_ORPHEUS))
  1999.     {
  2000.         if (ch->info)
  2001.             ch->pxymem = ch->info;
  2002.         else
  2003.             ch->info = ch->pxymem;
  2004.  
  2005.         infohi = ch->pxymem >> 4;
  2006.         infolo = ch->pxymem & 0x0F;
  2007.  
  2008.         if (infolo == 0x0F)
  2009.         {
  2010.             if (!infohi)
  2011.                 ch->apanpos += (infolo * 4);
  2012.             else if (!musiccount)
  2013.                 ch->apanpos -= (infohi * 4);
  2014.         }
  2015.         else if (infohi == 0x0F)
  2016.         {
  2017.             if (!infolo)
  2018.                 ch->apanpos -= (infohi * 4);
  2019.             else if (!musiccount)
  2020.                 ch->apanpos += (infolo * 4);
  2021.         }
  2022.         else if (musiccount) /* don't rely on fastvolslide flag here */
  2023.         {
  2024.             if (!infolo)
  2025.                 ch->apanpos -= (infohi * 4);
  2026.             else
  2027.                 ch->apanpos += (infolo * 4);
  2028.         }
  2029.         else
  2030.         {
  2031.             return; /* illegal slide */
  2032.         }
  2033.  
  2034.              if (ch->apanpos <   0) ch->apanpos =   0;
  2035.         else if (ch->apanpos > 256) ch->apanpos = 256;
  2036.  
  2037.         setpan(ch->channelnum);
  2038.     }
  2039. }
  2040.  
  2041. static void s_retrig(chn_t *ch)
  2042. {
  2043.     uint8_t infohi;
  2044.  
  2045.     getlastnfo(ch);
  2046.     infohi = ch->info >> 4;
  2047.  
  2048.     if (!(ch->info & 0x0F) || (ch->atrigcnt < (ch->info & 0x0F)))
  2049.     {
  2050.         ch->atrigcnt++;
  2051.         return;
  2052.     }
  2053.  
  2054.     ch->atrigcnt = 0;
  2055.  
  2056.     voiceSetPlayBackwards(ch->channelnum, 0);
  2057.     voiceSetSamplePosition(ch->channelnum, 0);
  2058.  
  2059.     if (!retrigvoladd[16 + infohi])
  2060.         ch->avol += retrigvoladd[infohi];
  2061.     else
  2062.         ch->avol = (int8_t)((ch->avol * retrigvoladd[16 + infohi]) / 16);
  2063.  
  2064.          if (ch->avol > 63) ch->avol = 63;
  2065.     else if (ch->avol <  0) ch->avol =  0;
  2066.  
  2067.     setvol(ch->channelnum);
  2068.  
  2069.     ch->atrigcnt++; /* probably a mistake? Keep it anyways. */
  2070. }
  2071.  
  2072. static void s_tremolo(chn_t *ch)
  2073. {
  2074.     int8_t type;
  2075.     int16_t cnt;
  2076.     int16_t dat;
  2077.  
  2078.     getlastnfo(ch);
  2079.  
  2080.     if (!(ch->info & 0xF0))
  2081.         ch->info = (ch->alastnfo & 0xF0) | (ch->info & 0x0F);
  2082.  
  2083.     ch->alastnfo = ch->info;
  2084.  
  2085.     if (ch->aorgvol)
  2086.     {
  2087.         cnt  = ch->avibcnt;
  2088.         type = ch->avibtretype >> 5;
  2089.         dat  = 0;
  2090.  
  2091.         /* sine */
  2092.         if ((type == 0) || (type == 4))
  2093.         {
  2094.             if (type == 4)
  2095.             {
  2096.                 cnt &= 0x7F;
  2097.             }
  2098.             else
  2099.             {
  2100.                 if (cnt & 0x80) cnt = 0;
  2101.             }
  2102.  
  2103.             dat = vibsin[cnt / 2];
  2104.         }
  2105.  
  2106.         /* ramp */
  2107.         else if ((type == 1) || (type == 5))
  2108.         {
  2109.             if (type == 5)
  2110.             {
  2111.                 cnt &= 0x7F;
  2112.             }
  2113.             else
  2114.             {
  2115.                 if (cnt & 0x80) cnt = 0;
  2116.             }
  2117.  
  2118.             dat = vibramp[cnt / 2];
  2119.         }
  2120.  
  2121.         /* square */
  2122.         else if ((type == 2) || (type == 6))
  2123.         {
  2124.             if (type == 6)
  2125.             {
  2126.                 cnt &= 0x7F;
  2127.             }
  2128.             else
  2129.             {
  2130.                 if (cnt & 0x80) cnt = 0;
  2131.             }
  2132.  
  2133.             dat = vibsqu[cnt / 2];
  2134.         }
  2135.  
  2136.         /* random */
  2137.         else if ((type == 3) || (type == 7))
  2138.         {
  2139.             if (type == 7)
  2140.             {
  2141.                 cnt &= 0x7F;
  2142.             }
  2143.             else
  2144.             {
  2145.                 if (cnt & 0x80) cnt = 0;
  2146.             }
  2147.  
  2148.             dat = vibsin[cnt / 2];
  2149.             cnt += (patmusicrand & 0x1E);
  2150.         }
  2151.  
  2152.         dat = ((dat * (ch->info & 0x0F)) >> 7) + ch->aorgvol;
  2153.  
  2154.              if (dat > 63) dat = 63;
  2155.         else if (dat <  0) dat =  0;
  2156.  
  2157.         ch->avol = (int8_t)(dat);
  2158.         setvol(ch->channelnum);
  2159.  
  2160.         ch->avibcnt = (cnt + ((ch->info >> 4) * 2)) & 0x7E;
  2161.     }
  2162. }
  2163.  
  2164. static void s_scommand1(chn_t *ch)
  2165. {
  2166.     getlastnfo(ch);
  2167.     ssoncejmp[ch->info >> 4](ch);
  2168. }
  2169.  
  2170. static void s_scommand2(chn_t *ch)
  2171. {
  2172.     getlastnfo(ch);
  2173.     ssotherjmp[ch->info >> 4](ch);
  2174. }
  2175.  
  2176. static void s_settempo(chn_t *ch)
  2177. {
  2178.     if (!musiccount && (ch->info >= 0x20))
  2179.         tempo = ch->info;
  2180.  
  2181.     /* NON-ST3 tempo slide */
  2182.     if ((tracker != SCREAM_TRACKER) && (tracker != IMAGO_ORPHEUS))
  2183.     {
  2184.         if (!musiccount)
  2185.         {
  2186.             if (!ch->info)
  2187.                 ch->info = ch->txxmem;
  2188.             else
  2189.                 ch->txxmem = ch->info;
  2190.         }
  2191.         else if (musiccount)
  2192.         {
  2193.             if (ch->info <= 0x0F)
  2194.             {
  2195.                 tempo -= ch->info;
  2196.                 if (tempo < 32)
  2197.                     tempo = 32;
  2198.             }
  2199.             else if (ch->info <= 0x1F)
  2200.             {
  2201.                 tempo += (ch->info - 0x10);
  2202.                 if (tempo > 255)
  2203.                     tempo = 255;
  2204.             }
  2205.         }
  2206.     }
  2207.     /* ------------------ */
  2208.  
  2209.     settempo(tempo);
  2210. }
  2211.  
  2212. static void s_finevibrato(chn_t *ch)
  2213. {
  2214.     int8_t type;
  2215.     int16_t cnt;
  2216.     int32_t dat;
  2217.  
  2218.     if (!ch->info)
  2219.         ch->info = ch->alasteff;
  2220.  
  2221.     if (!(ch->info & 0xF0))
  2222.         ch->info = (ch->alasteff & 0xF0) | (ch->info & 0x0F);
  2223.  
  2224.     ch->alasteff = ch->info;
  2225.  
  2226.     if (ch->aorgspd)
  2227.     {
  2228.         cnt  =  ch->avibcnt;
  2229.         type = (ch->avibtretype & 0x0E) >> 1;
  2230.         dat  = 0;
  2231.  
  2232.         /* sine */
  2233.         if ((type == 0) || (type == 4))
  2234.         {
  2235.             if (type == 4)
  2236.             {
  2237.                 cnt &= 0x7F;
  2238.             }
  2239.             else
  2240.             {
  2241.                 if (cnt & 0x80) cnt = 0;
  2242.             }
  2243.  
  2244.             dat = vibsin[cnt / 2];
  2245.         }
  2246.  
  2247.         /* ramp */
  2248.         else if ((type == 1) || (type == 5))
  2249.         {
  2250.             if (type == 5)
  2251.             {
  2252.                 cnt &= 0x7F;
  2253.             }
  2254.             else
  2255.             {
  2256.                 if (cnt & 0x80) cnt = 0;
  2257.             }
  2258.  
  2259.             dat = vibramp[cnt / 2];
  2260.         }
  2261.  
  2262.         /* square */
  2263.         else if ((type == 2) || (type == 6))
  2264.         {
  2265.             if (type == 6)
  2266.             {
  2267.                 cnt &= 0x7F;
  2268.             }
  2269.             else
  2270.             {
  2271.                 if (cnt & 0x80) cnt = 0;
  2272.             }
  2273.  
  2274.             dat = vibsqu[cnt / 2];
  2275.         }
  2276.  
  2277.         /* random */
  2278.         else if ((type == 3) || (type == 7))
  2279.         {
  2280.             if (type == 7)
  2281.             {
  2282.                 cnt &= 0x7F;
  2283.             }
  2284.             else
  2285.             {
  2286.                 if (cnt & 0x80) cnt = 0;
  2287.             }
  2288.  
  2289.             dat = vibsin[cnt / 2];
  2290.             cnt += (patmusicrand & 0x1E);
  2291.         }
  2292.  
  2293.         if (oldstvib)
  2294.             dat = ((dat * (ch->info & 0x0F)) >> 6) + ch->aorgspd;
  2295.         else
  2296.             dat = ((dat * (ch->info & 0x0F)) >> 7) + ch->aorgspd;
  2297.  
  2298.         ch->aspd = dat;
  2299.         setspd(ch->channelnum);
  2300.  
  2301.         ch->avibcnt = (cnt + ((ch->info >> 4) * 2)) & 0x7E;
  2302.     }
  2303. }
  2304.  
  2305. static void s_setgvol(chn_t *ch)
  2306. {
  2307.     if (ch->info <= 64)
  2308.         globalvol = ch->info;
  2309. }
  2310.  
  2311. static void s_globvolslide(chn_t *ch) /* NON-ST3 */
  2312. {
  2313.     uint8_t i;
  2314.     uint8_t infohi;
  2315.     uint8_t infolo;
  2316.  
  2317.     if ((tracker != SCREAM_TRACKER) && (tracker != IMAGO_ORPHEUS))
  2318.     {
  2319.         if (ch->info)
  2320.             ch->wxymem = ch->info;
  2321.         else
  2322.             ch->info = ch->wxymem;
  2323.  
  2324.         infohi = ch->wxymem >> 4;
  2325.         infolo = ch->wxymem & 0x0F;
  2326.  
  2327.         if (infolo == 0x0F)
  2328.         {
  2329.             if (!infohi)
  2330.                 globalvol -= infolo;
  2331.             else if (!musiccount)
  2332.                 globalvol += infohi;
  2333.         }
  2334.         else if (infohi == 0x0F)
  2335.         {
  2336.             if (!infolo)
  2337.                 globalvol += infohi;
  2338.             else if (!musiccount)
  2339.                 globalvol -= infolo;
  2340.         }
  2341.         else if (musiccount) /* don't rely on fastvolslide flag here */
  2342.         {
  2343.             if (!infolo)
  2344.                 globalvol += infohi;
  2345.             else
  2346.                 globalvol -= infolo;
  2347.         }
  2348.         else
  2349.         {
  2350.             return; /* illegal slide */
  2351.         }
  2352.  
  2353.              if (globalvol <  0) globalvol =  0;
  2354.         else if (globalvol > 64) globalvol = 64;
  2355.  
  2356.         /* update all channels now */
  2357.         for (i = 0; i < (lastachannelused + 1); ++i)
  2358.             setvol(i);
  2359.     }
  2360. }
  2361.  
  2362. static void s_setpan(chn_t *ch) /* NON-ST3 */
  2363. {
  2364.     /*
  2365.     ** this one should work even in mono mode
  2366.     ** for newer trackers that exports as ST3
  2367.     */
  2368.     if (ch->info <= 0x80)
  2369.     {
  2370.         ch->surround = 0;
  2371.         voiceSetSurround(ch->channelnum, 0);
  2372.  
  2373.         ch->apanpos = ch->info * 2;
  2374.         setpan(ch->channelnum);
  2375.     }
  2376.     else if (ch->info == 0xA4) /* surround */
  2377.     {
  2378.         if ((tracker != SCREAM_TRACKER) && (tracker != IMAGO_ORPHEUS))
  2379.         {
  2380.             ch->surround = 1;
  2381.             voiceSetSurround(ch->channelnum, 1);
  2382.         }
  2383.     }
  2384. }
  2385.  
  2386. static void s_panbrello(chn_t *ch) /* NON-ST3 */
  2387. {
  2388.     int8_t type;
  2389.     int16_t cnt;
  2390.     int16_t dat;
  2391.  
  2392.     if ((tracker != SCREAM_TRACKER) && (tracker != IMAGO_ORPHEUS))
  2393.     {
  2394.         if (!musiccount)
  2395.         {
  2396.             if (!ch->info)
  2397.                 ch->info = ch->alasteff;
  2398.             else
  2399.                 ch->yxymem = ch->info;
  2400.  
  2401.             if (!(ch->info & 0xF0))
  2402.                 ch->info = (ch->yxymem & 0xF0) | (ch->info & 0x0F);
  2403.  
  2404.             if (!(ch->info & 0x0F))
  2405.                 ch->info = (ch->info & 0xF0) | (ch->yxymem & 0x0F);
  2406.         }
  2407.  
  2408.         cnt  = ch->apancnt;
  2409.         type = ch->apantype;
  2410.         dat  = 0;
  2411.  
  2412.         /* sine */
  2413.         if ((type == 0) || (type == 4))
  2414.         {
  2415.             if (type == 4)
  2416.             {
  2417.                 cnt &= 0x7F;
  2418.             }
  2419.             else
  2420.             {
  2421.                 if (cnt & 0x80) cnt = 0;
  2422.             }
  2423.  
  2424.             dat = vibsin[cnt / 2];
  2425.         }
  2426.  
  2427.         /* ramp */
  2428.         else if ((type == 1) || (type == 5))
  2429.         {
  2430.             if (type == 5)
  2431.             {
  2432.                 cnt &= 0x7F;
  2433.             }
  2434.             else
  2435.             {
  2436.                 if (cnt & 0x80) cnt = 0;
  2437.             }
  2438.  
  2439.             dat = vibramp[cnt / 2];
  2440.         }
  2441.  
  2442.         /* square */
  2443.         else if ((type == 2) || (type == 6))
  2444.         {
  2445.             if (type == 6)
  2446.             {
  2447.                 cnt &= 0x7F;
  2448.             }
  2449.             else
  2450.             {
  2451.                 if (cnt & 0x80) cnt = 0;
  2452.             }
  2453.  
  2454.             dat = vibsqu[cnt / 2];
  2455.         }
  2456.  
  2457.         /* random */
  2458.         else if ((type == 3) || (type == 7))
  2459.         {
  2460.             if (type == 7)
  2461.             {
  2462.                 cnt &= 0x7F;
  2463.             }
  2464.             else
  2465.             {
  2466.                 if (cnt & 0x80) cnt = 0;
  2467.             }
  2468.  
  2469.             dat = vibsin[cnt / 2];
  2470.             cnt += (patmusicrand & 0x1E);
  2471.         }
  2472.  
  2473.         dat = ((dat * (ch->info & 0x0F)) >> 4) + ch->apanpos;
  2474.  
  2475.              if (dat <   0) dat =   0;
  2476.         else if (dat > 256) dat = 256;
  2477.  
  2478.         voiceSetVolume(ch->channelnum,
  2479.               (chn[ch->channelnum].avol    / 63.0f)
  2480.             * (chn[ch->channelnum].chanvol / 64.0f)
  2481.             * (globalvol                   / 64.0f), dat);
  2482.  
  2483.         ch->apancnt = (cnt + ((ch->info >> 6) * 2)) & 0x7E;
  2484.     }
  2485. }
  2486.  
  2487. void setSamplesPerFrame(uint32_t val)
  2488. {
  2489.     samplesPerFrame = val;
  2490. }
  2491.  
  2492. void setSamplingInterpolation(int8_t value)
  2493. {
  2494.     samplingInterpolation = value;
  2495. }
  2496.  
  2497. void setStereoMode(int8_t value)
  2498. {
  2499.     stereomode = value;
  2500. }
  2501.  
  2502. void setMasterVolume(uint8_t value)
  2503. {
  2504.     mastervol = value;
  2505.     f_masterVolume = value / 127.0f;
  2506. }
  2507.  
  2508. void voiceSetSource(uint8_t voiceNumber, const int8_t *sampleData,
  2509.     int32_t sampleLength, int32_t sampleLoopLength, int32_t sampleLoopEnd,
  2510.     int8_t loopEnabled, int8_t sixteenbit, int8_t stereo)
  2511. {
  2512.     VOICE *v;
  2513.  
  2514.     v = &voice[voiceNumber];
  2515.  
  2516.     v->sampleData       = sampleData;
  2517.     v->sampleLength     = sampleLength;
  2518.     v->sampleLoopBegin  = sampleLoopEnd - sampleLoopLength;
  2519.     v->sampleLoopEnd    = sampleLoopEnd;
  2520.     v->sampleLoopLength = sampleLoopLength;
  2521.     v->loopEnabled      = loopEnabled;
  2522.     v->sixteenBit       = sixteenbit;
  2523.     v->stereo           = stereo;
  2524.     v->mixing           = 1;
  2525.  
  2526.     if (v->samplePosition >= v->sampleLength)
  2527.         v->samplePosition  = 0;
  2528. }
  2529.  
  2530. void voiceSetSamplePosition(uint8_t voiceNumber, uint16_t value)
  2531. {
  2532.     VOICE *v;
  2533.  
  2534.     v = &voice[voiceNumber];
  2535.  
  2536.     v->samplePosition = value;
  2537.  
  2538.     v->frac   = 0.0f;
  2539.     v->mixing = 1;
  2540.  
  2541.     if (v->loopEnabled)
  2542.     {
  2543.         while (v->samplePosition >= v->sampleLoopEnd)
  2544.                v->samplePosition -= v->sampleLoopLength;
  2545.     }
  2546.     else if (v->samplePosition >= v->sampleLength)
  2547.     {
  2548.         v->mixing         = 0;
  2549.         v->samplePosition = 0;
  2550.     }
  2551. }
  2552.  
  2553. void voiceSetVolume(uint8_t voiceNumber, float vol, uint16_t pan)
  2554. {
  2555.     float p;
  2556.  
  2557.     VOICE *v;
  2558.  
  2559.     v = &voice[voiceNumber];
  2560.     p = pan / 256.0f;
  2561.  
  2562.     v->volumeL = vol * (1.0f - p);
  2563.     v->volumeR = vol * p;
  2564.     v->orgVolL = v->volumeL; /* backup for surround */
  2565. }
  2566.  
  2567. void voiceSetSurround(uint8_t voiceNumber, int8_t surround)
  2568. {
  2569.     if (surround)
  2570.     {
  2571.         chn[voiceNumber].apanpos = 128;
  2572.         setpan(voiceNumber);
  2573.  
  2574.         voice[voiceNumber].volumeL = -voice[voiceNumber].orgVolL;
  2575.     }
  2576.     else
  2577.     {
  2578.         voice[voiceNumber].volumeL =  voice[voiceNumber].orgVolL;
  2579.     }
  2580. }
  2581.  
  2582. void voiceSetSamplingFrequency(uint8_t voiceNumber, uint32_t samplingFrequency)
  2583. {
  2584.     voice[voiceNumber].incRate = samplingFrequency / f_audioFreq;
  2585. }
  2586.  
  2587. void voiceSetPlayBackwards(uint8_t voiceNumber, int8_t playBackwards)
  2588. {
  2589.     voice[voiceNumber].playBackwards = playBackwards;
  2590. }
  2591.  
  2592. void voiceSetReadPosToEnd(uint8_t voiceNumber)
  2593. {
  2594.     voice[voiceNumber].samplePosition = voice[voiceNumber].sampleLength - 1;
  2595. }
  2596.  
  2597. void mix8b(uint8_t ch, uint32_t samples)
  2598. {
  2599.     uint8_t intFrac;
  2600.     int32_t samplePosition2;
  2601.     uint32_t j;
  2602.  
  2603.     float sample;
  2604.     float sample2;
  2605.  
  2606.     VOICE *v;
  2607.  
  2608.     v = &voice[ch];
  2609.  
  2610.     for (j = 0; (j < samples) && v->sampleData; ++j)
  2611.     {
  2612.         samplePosition2 = v->samplePosition + 1;
  2613.  
  2614.         if (samplingInterpolation)
  2615.         {
  2616.             if (v->loopEnabled)
  2617.             {
  2618.                 if (samplePosition2 >= v->sampleLoopEnd)
  2619.                     samplePosition2  = v->sampleLoopBegin;
  2620.             }
  2621.             else
  2622.             {
  2623.                 if (samplePosition2 >= v->sampleLength)
  2624.                     samplePosition2  = v->sampleLength - 1;
  2625.             }
  2626.  
  2627.             sample  = v->sampleData[v->samplePosition];
  2628.             sample2 = v->sampleData[samplePosition2];
  2629.             sample  = LERP(sample, sample2, voice[ch].frac);
  2630.         }
  2631.         else
  2632.         {
  2633.             sample = v->sampleData[v->samplePosition];
  2634.         }
  2635.  
  2636.         sample *= 256.0f;
  2637.  
  2638.         masterBufferL[j] += (sample * v->volumeL);
  2639.         masterBufferR[j] += (sample * v->volumeR);
  2640.  
  2641.         v->frac += v->incRate;
  2642.         while (v->frac >= 1.0f)
  2643.         {
  2644.             intFrac = (uint8_t)(v->frac);
  2645.             v->frac -= intFrac;
  2646.  
  2647.             if (v->playBackwards)
  2648.             {
  2649.                 v->samplePosition -= intFrac;
  2650.  
  2651.                 if (v->loopEnabled)
  2652.                 {
  2653.                     if (v->samplePosition < v->sampleLoopBegin)
  2654.                         v->samplePosition = v->sampleLoopEnd - (v->sampleLoopBegin - v->samplePosition);
  2655.                 }
  2656.                 else if (v->samplePosition < 0)
  2657.                 {
  2658.                     v->mixing         = 0;
  2659.                     v->samplePosition = 0;
  2660.                     v->frac           = 0.0f;
  2661.  
  2662.                     j = samples;
  2663.                     break;
  2664.                 }
  2665.             }
  2666.             else
  2667.             {
  2668.                 v->samplePosition += intFrac;
  2669.  
  2670.                 if (v->loopEnabled)
  2671.                 {
  2672.                     if (v->samplePosition >= v->sampleLoopEnd)
  2673.                         v->samplePosition  = v->sampleLoopBegin + (v->samplePosition - v->sampleLoopEnd);
  2674.                 }
  2675.                 else if (v->samplePosition >= v->sampleLength)
  2676.                 {
  2677.                     v->mixing         = 0;
  2678.                     v->samplePosition = 0;
  2679.                     v->frac           = 0.0f;
  2680.  
  2681.                     j = samples;
  2682.                     break;
  2683.                 }
  2684.             }
  2685.         }
  2686.     }
  2687. }
  2688.  
  2689. void mix8bstereo(uint8_t ch, uint32_t samples)
  2690. {
  2691.     uint8_t intFrac;
  2692.     int32_t samplePosition2;
  2693.     uint32_t j;
  2694.  
  2695.     float sampleL;
  2696.     float sampleR;
  2697.     float sampleL2;
  2698.     float sampleR2;
  2699.  
  2700.     VOICE *v;
  2701.  
  2702.     v = &voice[ch];
  2703.  
  2704.     for (j = 0; (j < samples) && v->sampleData; ++j)
  2705.     {
  2706.         samplePosition2 = v->samplePosition + 1;
  2707.  
  2708.         if (samplingInterpolation)
  2709.         {
  2710.             if (v->loopEnabled)
  2711.             {
  2712.                 if (samplePosition2 >= v->sampleLoopEnd)
  2713.                     samplePosition2  = v->sampleLoopBegin;
  2714.             }
  2715.             else
  2716.             {
  2717.                 if (samplePosition2 >= v->sampleLength)
  2718.                     samplePosition2  = v->sampleLength - 1;
  2719.             }
  2720.  
  2721.             sampleL  = v->sampleData[v->samplePosition];
  2722.             sampleL2 = v->sampleData[samplePosition2];
  2723.             sampleL  = LERP(sampleL, sampleL2, v->frac);
  2724.  
  2725.             sampleR  = v->sampleData[v->sampleLength + v->samplePosition];
  2726.             sampleR2 = v->sampleData[v->sampleLength + samplePosition2];
  2727.             sampleR  = LERP(sampleR, sampleR2, v->frac);
  2728.         }
  2729.         else
  2730.         {
  2731.             sampleL = v->sampleData[v->samplePosition];
  2732.             sampleR = v->sampleData[v->sampleLength + v->samplePosition];
  2733.         }
  2734.  
  2735.         sampleL *= 256.0f;
  2736.         sampleR *= 256.0f;
  2737.  
  2738.         masterBufferL[j] += (sampleL * v->volumeL);
  2739.         masterBufferR[j] += (sampleR * v->volumeR);
  2740.  
  2741.         v->frac += v->incRate;
  2742.         while (v->frac >= 1.0f)
  2743.         {
  2744.             intFrac = (uint8_t)(v->frac);
  2745.             v->frac -= intFrac;
  2746.  
  2747.             if (v->playBackwards)
  2748.             {
  2749.                 v->samplePosition -= intFrac;
  2750.  
  2751.                 if (v->loopEnabled)
  2752.                 {
  2753.                     if (v->samplePosition < v->sampleLoopBegin)
  2754.                         v->samplePosition = v->sampleLoopEnd - (v->sampleLoopBegin - v->samplePosition);
  2755.                 }
  2756.                 else if (v->samplePosition < 0)
  2757.                 {
  2758.                     v->mixing         = 0;
  2759.                     v->samplePosition = 0;
  2760.                     v->frac           = 0.0f;
  2761.  
  2762.                     j = samples;
  2763.                     break;
  2764.                 }
  2765.             }
  2766.             else
  2767.             {
  2768.                 v->samplePosition += intFrac;
  2769.  
  2770.                 if (v->loopEnabled)
  2771.                 {
  2772.                     if (v->samplePosition >= v->sampleLoopEnd)
  2773.                         v->samplePosition  = v->sampleLoopBegin + (v->samplePosition - v->sampleLoopEnd);
  2774.                 }
  2775.                 else if (v->samplePosition >= v->sampleLength)
  2776.                 {
  2777.                     v->mixing         = 0;
  2778.                     v->samplePosition = 0;
  2779.                     v->frac           = 0.0f;
  2780.  
  2781.                     j = samples;
  2782.                     break;
  2783.                 }
  2784.             }
  2785.         }
  2786.     }
  2787. }
  2788.  
  2789. void mix16b(uint8_t ch, uint32_t samples)
  2790. {
  2791.     uint8_t intFrac;
  2792.     int32_t samplePosition2;
  2793.     uint32_t j;
  2794.  
  2795.     const int16_t *sampleData;
  2796.  
  2797.     float sample;
  2798.     float sample2;
  2799.  
  2800.     VOICE *v;
  2801.  
  2802.     v = &voice[ch];
  2803.  
  2804.     sampleData = (int16_t *)(v->sampleData);
  2805.  
  2806.     for (j = 0; (j < samples) && v->sampleData; ++j)
  2807.     {
  2808.         samplePosition2 = v->samplePosition + 1;
  2809.  
  2810.         if (samplingInterpolation)
  2811.         {
  2812.             if (v->loopEnabled)
  2813.             {
  2814.                 if (samplePosition2 >= v->sampleLoopEnd)
  2815.                     samplePosition2  = v->sampleLoopBegin;
  2816.             }
  2817.             else
  2818.             {
  2819.                 if (samplePosition2 >= v->sampleLength)
  2820.                     samplePosition2  = v->sampleLength - 1;
  2821.             }
  2822.  
  2823.             sample  = sampleData[v->samplePosition];
  2824.             sample2 = sampleData[samplePosition2];
  2825.             sample  = LERP(sample, sample2, voice[ch].frac);
  2826.         }
  2827.         else
  2828.         {
  2829.             sample = sampleData[v->samplePosition];
  2830.         }
  2831.  
  2832.         masterBufferL[j] += (sample * v->volumeL);
  2833.         masterBufferR[j] += (sample * v->volumeR);
  2834.  
  2835.         v->frac += v->incRate;
  2836.         while (v->frac >= 1.0f)
  2837.         {
  2838.             intFrac = (uint8_t)(v->frac);
  2839.             v->frac -= intFrac;
  2840.  
  2841.             if (v->playBackwards)
  2842.             {
  2843.                 v->samplePosition -= intFrac;
  2844.  
  2845.                 if (v->loopEnabled)
  2846.                 {
  2847.                     if (v->samplePosition < v->sampleLoopBegin)
  2848.                         v->samplePosition = v->sampleLoopEnd - (v->sampleLoopBegin - v->samplePosition);
  2849.                 }
  2850.                 else if (v->samplePosition < 0)
  2851.                 {
  2852.                     v->mixing         = 0;
  2853.                     v->samplePosition = 0;
  2854.                     v->frac           = 0.0f;
  2855.  
  2856.                     j = samples;
  2857.                     break;
  2858.                 }
  2859.             }
  2860.             else
  2861.             {
  2862.                 v->samplePosition += intFrac;
  2863.  
  2864.                 if (v->loopEnabled)
  2865.                 {
  2866.                     if (v->samplePosition >= v->sampleLoopEnd)
  2867.                         v->samplePosition  = v->sampleLoopBegin + (v->samplePosition - v->sampleLoopEnd);
  2868.                 }
  2869.                 else if (v->samplePosition >= v->sampleLength)
  2870.                 {
  2871.                     v->mixing         = 0;
  2872.                     v->samplePosition = 0;
  2873.                     v->frac           = 0.0f;
  2874.  
  2875.                     j = samples;
  2876.                     break;
  2877.                 }
  2878.             }
  2879.         }
  2880.     }
  2881. }
  2882.  
  2883. void mix16bstereo(uint8_t ch, uint32_t samples)
  2884. {
  2885.     uint8_t intFrac;
  2886.     int32_t samplePosition2;
  2887.     uint32_t j;
  2888.  
  2889.     const int16_t *sampleData;
  2890.  
  2891.     float sampleL;
  2892.     float sampleR;
  2893.     float sampleL2;
  2894.     float sampleR2;
  2895.  
  2896.     VOICE *v;
  2897.  
  2898.     v = &voice[ch];
  2899.  
  2900.     sampleData = (int16_t *)(v->sampleData);
  2901.  
  2902.     for (j = 0; (j < samples) && v->sampleData; ++j)
  2903.     {
  2904.         samplePosition2 = v->samplePosition + 1;
  2905.  
  2906.         if (samplingInterpolation)
  2907.         {
  2908.             if (v->loopEnabled)
  2909.             {
  2910.                 if (samplePosition2 >= v->sampleLoopEnd)
  2911.                     samplePosition2  = v->sampleLoopBegin;
  2912.             }
  2913.             else
  2914.             {
  2915.                 if (samplePosition2 >= v->sampleLength)
  2916.                     samplePosition2  = v->sampleLength - 1;
  2917.             }
  2918.  
  2919.             sampleL  = sampleData[v->samplePosition];
  2920.             sampleL2 = sampleData[samplePosition2];
  2921.             sampleL  = LERP(sampleL, sampleL2, v->frac);
  2922.  
  2923.             sampleR  = sampleData[v->sampleLength + v->samplePosition];
  2924.             sampleR2 = sampleData[v->sampleLength + samplePosition2];
  2925.             sampleR  = LERP(sampleR, sampleR2, v->frac);
  2926.         }
  2927.         else
  2928.         {
  2929.             sampleL = sampleData[v->samplePosition];
  2930.             sampleR = sampleData[v->sampleLength + v->samplePosition];
  2931.         }
  2932.  
  2933.         masterBufferL[j] += (sampleL * v->volumeL);
  2934.         masterBufferR[j] += (sampleR * v->volumeR);
  2935.  
  2936.         v->frac += v->incRate;
  2937.         while (v->frac >= 1.0f)
  2938.         {
  2939.             intFrac = (uint8_t)(v->frac);
  2940.             v->frac -= intFrac;
  2941.  
  2942.             if (v->playBackwards)
  2943.             {
  2944.                 v->samplePosition -= intFrac;
  2945.  
  2946.                 if (v->loopEnabled)
  2947.                 {
  2948.                     if (v->samplePosition < v->sampleLoopBegin)
  2949.                         v->samplePosition = v->sampleLoopEnd - (v->sampleLoopBegin - v->samplePosition);
  2950.                 }
  2951.                 else if (v->samplePosition < 0)
  2952.                 {
  2953.                     v->mixing         = 0;
  2954.                     v->samplePosition = 0;
  2955.                     v->frac           = 0.0f;
  2956.  
  2957.                     j = samples;
  2958.                     break;
  2959.                 }
  2960.             }
  2961.             else
  2962.             {
  2963.                 v->samplePosition += intFrac;
  2964.  
  2965.                 if (v->loopEnabled)
  2966.                 {
  2967.                     if (v->samplePosition >= v->sampleLoopEnd)
  2968.                         v->samplePosition  = v->sampleLoopBegin + (v->samplePosition - v->sampleLoopEnd);
  2969.                 }
  2970.                 else if (v->samplePosition >= v->sampleLength)
  2971.                 {
  2972.                     v->mixing         = 0;
  2973.                     v->samplePosition = 0;
  2974.                     v->frac           = 0.0f;
  2975.  
  2976.                     j = samples;
  2977.                     break;
  2978.                 }
  2979.             }
  2980.         }
  2981.     }
  2982. }
  2983.  
  2984. void mixSampleBlock(int16_t *outputStream, uint32_t sampleBlockLength)
  2985. {
  2986.     int16_t *streamPointer;
  2987.     uint8_t i;
  2988.     uint32_t j;
  2989.  
  2990.     float outL;
  2991.     float outR;
  2992.  
  2993.     memset(masterBufferL, 0, sampleBlockLength * sizeof (float));
  2994.     memset(masterBufferR, 0, sampleBlockLength * sizeof (float));
  2995.  
  2996.     for (i = 0; i < 32; ++i)
  2997.     {
  2998.         if (voice[i].incRate && voice[i].mixing)
  2999.         {
  3000.             if (voice[i].stereo)
  3001.             {
  3002.                 if (voice[i].sixteenBit)
  3003.                     mix16bstereo(i, sampleBlockLength);
  3004.                 else
  3005.                     mix8bstereo(i, sampleBlockLength);
  3006.             }
  3007.             else
  3008.             {
  3009.                 if (voice[i].sixteenBit)
  3010.                     mix16b(i, sampleBlockLength);
  3011.                 else
  3012.                     mix8b(i, sampleBlockLength);
  3013.             }
  3014.         }
  3015.     }
  3016.  
  3017.     streamPointer = outputStream;
  3018.     for (j = 0; j < sampleBlockLength; ++j)
  3019.     {
  3020.         if (MusicPaused)
  3021.         {
  3022.             *streamPointer++ = 0;
  3023.             *streamPointer++ = 0;
  3024.         }
  3025.         else
  3026.         {
  3027.             outL = masterBufferL[j] * f_masterVolume;
  3028.             outR = masterBufferR[j] * f_masterVolume;
  3029.  
  3030.                  if (outL >  32767.0f) outL =  32767.0f;
  3031.             else if (outL < -32768.0f) outL = -32768.0f;
  3032.                  if (outR >  32767.0f) outR =  32767.0f;
  3033.             else if (outR < -32768.0f) outR = -32768.0f;
  3034.  
  3035.             *streamPointer++ = (int16_t)(outL);
  3036.             *streamPointer++ = (int16_t)(outR);
  3037.         }
  3038.     }
  3039. }
  3040.  
  3041. void CALLBACK waveOutProc(HWAVEOUT hWaveOut, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
  3042. {
  3043.     int16_t *outputStream;
  3044.     int32_t sampleBlock;
  3045.     int32_t samplesTodo;
  3046.  
  3047.     WAVEHDR *waveBlockHeader;
  3048.  
  3049.     /* make compiler happy! */
  3050.     (void)(dwParam2);
  3051.     (void)(dwInstance);
  3052.  
  3053.     if (uMsg == MM_WOM_DONE)
  3054.     {
  3055.         mixingMutex = 1;
  3056.  
  3057.         waveBlockHeader = (WAVEHDR *)(dwParam1);
  3058.         waveOutUnprepareHeader(hWaveOut, waveBlockHeader, sizeof (WAVEHDR));
  3059.  
  3060.         if (isMixing)
  3061.         {
  3062.             memcpy(waveBlockHeader->lpData, mixerBuffer, soundBufferSize);
  3063.  
  3064.             waveOutPrepareHeader(hWaveOut, waveBlockHeader, sizeof (WAVEHDR));
  3065.             waveOutWrite(hWaveOut, waveBlockHeader, sizeof (WAVEHDR));
  3066.  
  3067.             outputStream = (int16_t *)(mixerBuffer);
  3068.             sampleBlock  = soundBufferSize / 4;
  3069.  
  3070.             while (sampleBlock)
  3071.             {
  3072.                 samplesTodo = (sampleBlock < samplesLeft) ? sampleBlock : samplesLeft;
  3073.                 if (samplesTodo > soundBufferSize)
  3074.                     samplesTodo = soundBufferSize;
  3075.  
  3076.                 if (samplesTodo > 0)
  3077.                 {
  3078.                     mixSampleBlock(outputStream, samplesTodo);
  3079.  
  3080.                     outputStream += (samplesTodo * 2);
  3081.                     sampleBlock  -=  samplesTodo;
  3082.                     samplesLeft  -=  samplesTodo;
  3083.                 }
  3084.                 else
  3085.                 {
  3086.                     if (Playing && !MusicPaused)
  3087.                         dorow();
  3088.  
  3089.                     samplesLeft = samplesPerFrame;
  3090.                 }
  3091.             }
  3092.         }
  3093.  
  3094.         mixingMutex = 0;
  3095.     }
  3096. }
  3097.  
  3098. int8_t openMixer(uint32_t _samplingFrequency, uint32_t _soundBufferSize)
  3099. {
  3100.     uint8_t i;
  3101.     MMRESULT r;
  3102.  
  3103.     if (!_hWaveOut)
  3104.     {
  3105.         audioFreq           = _samplingFrequency;
  3106.         f_audioFreq         = (float)(audioFreq);
  3107.         soundBufferSize     = _soundBufferSize;
  3108.         masterBufferL       = (float *)(malloc(soundBufferSize * sizeof (float)));
  3109.         masterBufferR       = (float *)(malloc(soundBufferSize * sizeof (float)));
  3110.         wfx.nSamplesPerSec  = audioFreq;
  3111.         wfx.wBitsPerSample  = 16;
  3112.         wfx.nChannels       = 2;
  3113.         wfx.cbSize          = 0;
  3114.         wfx.wFormatTag      = WAVE_FORMAT_PCM;
  3115.         wfx.nBlockAlign     = (wfx.wBitsPerSample * wfx.nChannels) / 8;
  3116.         wfx.nAvgBytesPerSec = wfx.nBlockAlign * wfx.nSamplesPerSec;
  3117.  
  3118.         if ((masterBufferL == NULL) || (masterBufferR == NULL))
  3119.             return (0); /* gets free'd later */
  3120.  
  3121.         r = waveOutOpen(&_hWaveOut, WAVE_MAPPER, &wfx, (DWORD_PTR)(waveOutProc), 0L, CALLBACK_FUNCTION);
  3122.         if (r != MMSYSERR_NOERROR)
  3123.             return (0);
  3124.  
  3125.         for (i = 0; i < MIX_BUF_NUM; ++i)
  3126.         {
  3127.             waveBlocks[i].dwBufferLength = soundBufferSize;
  3128.  
  3129.             waveBlocks[i].lpData = (LPSTR)(calloc(soundBufferSize, 1));
  3130.             if (waveBlocks[i].lpData == NULL)
  3131.                 return (0); /* gets free'd later */
  3132.  
  3133.             waveOutPrepareHeader(_hWaveOut, &waveBlocks[i], sizeof (WAVEHDR));
  3134.             waveOutWrite(_hWaveOut, &waveBlocks[i], sizeof (WAVEHDR));
  3135.         }
  3136.  
  3137.         mixerBuffer = (int8_t *)(calloc(soundBufferSize, 1));
  3138.         if (mixerBuffer == NULL)
  3139.             return (0); /* gets free'd later */
  3140.  
  3141.         isMixing = 1;
  3142.         return (1);
  3143.     }
  3144.  
  3145.     return (1);
  3146. }
  3147.  
  3148. void closeMixer(void)
  3149. {
  3150.     uint32_t i;
  3151.  
  3152.     if (isMixing)
  3153.     {
  3154.         isMixing = 0;
  3155.         while (mixingMutex);
  3156.  
  3157.         if (_hWaveOut)
  3158.         {
  3159.             for (i = 0; i < MIX_BUF_NUM; ++i)
  3160.                 waveOutUnprepareHeader(_hWaveOut, &waveBlocks[i], sizeof (WAVEHDR));
  3161.  
  3162.             for (i = 0; i < MIX_BUF_NUM; ++i)
  3163.             {
  3164.                 while (waveBlocks[i].dwFlags & WHDR_PREPARED);
  3165.                 if (waveBlocks[i].lpData != NULL)
  3166.                 {
  3167.                     free(waveBlocks[i].lpData);
  3168.                     waveBlocks[i].lpData = NULL;
  3169.                 }
  3170.             }
  3171.  
  3172.             waveOutReset(_hWaveOut);
  3173.             waveOutClose(_hWaveOut);
  3174.  
  3175.             _hWaveOut = 0;
  3176.  
  3177.             if (mixerBuffer != NULL)
  3178.             {
  3179.                 free(mixerBuffer);
  3180.                 mixerBuffer = NULL;
  3181.             }
  3182.  
  3183.             if (masterBufferL != NULL)
  3184.             {
  3185.                 free(masterBufferL);
  3186.                 masterBufferL = NULL;
  3187.             }
  3188.  
  3189.             if (masterBufferR != NULL)
  3190.             {
  3191.                 free(masterBufferR);
  3192.                 masterBufferR = NULL;
  3193.             }
  3194.         }
  3195.     }
  3196. }
  3197.  
  3198. int8_t st3play_Init(uint32_t outputFreq, int8_t interpolation)
  3199. {
  3200.     numChannels = 32;
  3201.     stereomode = 1;
  3202.     globalvol = 64;
  3203.     mastervol = 48;
  3204.     setSamplingInterpolation(interpolation);
  3205.     setSamplesPerFrame(((outputFreq * 5) / 2 / 125));
  3206.  
  3207.     if (!openMixer(outputFreq, MIX_BUF_LEN))
  3208.     {
  3209.         closeMixer();
  3210.         return (0);
  3211.     }
  3212.  
  3213.     return (1);
  3214. }
  3215.  
  3216. void st3play_FreeSong(void)
  3217. {
  3218.     Playing = 0;
  3219.     MusicPaused = 1;
  3220.  
  3221.     memset(voice, 0, sizeof (voice));
  3222.  
  3223.     while (mixingMutex);
  3224.  
  3225.     if (mseg != NULL)
  3226.     {
  3227.         free(mseg);
  3228.         mseg = NULL;
  3229.     }
  3230.  
  3231.     ModuleLoaded = 0;
  3232. }
  3233.  
  3234. void st3play_Close(void)
  3235. {
  3236.     Playing     = 0;
  3237.     MusicPaused = 1;
  3238.  
  3239.     while (mixingMutex);
  3240.  
  3241.     closeMixer();
  3242. }
  3243.  
  3244. static MEM *mopen(const uint8_t *src, uint32_t length)
  3245. {
  3246.     MEM *b;
  3247.     if ((src == NULL) || (length == 0)) return (NULL);
  3248.  
  3249.     b = (MEM *)(malloc(sizeof (MEM)));
  3250.     if (b == NULL) return (NULL);
  3251.  
  3252.     b->_base   = (uint8_t *)(src);
  3253.     b->_ptr    = (uint8_t *)(src);
  3254.     b->_cnt    = length;
  3255.     b->_bufsiz = length;
  3256.     b->_eof    = 0;
  3257.  
  3258.     return (b);
  3259. }
  3260.  
  3261. static void mclose(MEM **buf)
  3262. {
  3263.     if (*buf != NULL)
  3264.     {
  3265.         free(*buf);
  3266.         *buf = NULL;
  3267.     }
  3268. }
  3269.  
  3270. static size_t mread(void *buffer, size_t size, size_t count, MEM *buf)
  3271. {
  3272.     size_t wrcnt;
  3273.     int32_t pcnt;
  3274.  
  3275.     if (buf       == NULL) return (0);
  3276.     if (buf->_ptr == NULL) return (0);
  3277.  
  3278.     wrcnt = size * count;
  3279.     if ((size == 0) || buf->_eof) return (0);
  3280.  
  3281.     pcnt = (buf->_cnt > wrcnt) ? wrcnt : buf->_cnt;
  3282.     memcpy(buffer, buf->_ptr, pcnt);
  3283.  
  3284.     buf->_cnt -= pcnt;
  3285.     buf->_ptr += pcnt;
  3286.  
  3287.     if (buf->_cnt <= 0)
  3288.     {
  3289.         buf->_ptr = buf->_base + buf->_bufsiz;
  3290.         buf->_cnt = 0;
  3291.         buf->_eof = 1;
  3292.     }
  3293.  
  3294.     return (pcnt / size);
  3295. }
  3296.  
  3297. static uint32_t mtell(MEM *buf)
  3298. {
  3299.     return (buf->_ptr - buf->_base);
  3300. }
  3301.  
  3302. static int32_t meof(MEM *buf)
  3303. {
  3304.     if (buf == NULL)
  3305.         return (1);
  3306.  
  3307.     return (buf->_eof);
  3308. }
  3309.  
  3310. static void mseek(MEM *buf, int32_t offset, int32_t whence)
  3311. {
  3312.     if (buf == NULL) return;
  3313.  
  3314.     if (buf->_base)
  3315.     {
  3316.         switch (whence)
  3317.         {
  3318.             case SEEK_SET: buf->_ptr  = buf->_base + offset;                break;
  3319.             case SEEK_CUR: buf->_ptr += offset;                             break;
  3320.             case SEEK_END: buf->_ptr  = buf->_base + buf->_bufsiz + offset; break;
  3321.             default: break;
  3322.         }
  3323.  
  3324.         buf->_eof = 0;
  3325.         if (buf->_ptr >= (buf->_base + buf->_bufsiz))
  3326.         {
  3327.             buf->_ptr = buf->_base + buf->_bufsiz;
  3328.             buf->_eof = 1;
  3329.         }
  3330.  
  3331.         buf->_cnt = (buf->_base + buf->_bufsiz) - buf->_ptr;
  3332.     }
  3333. }
  3334.  
  3335. /* END OF FILE */
RAW Paste Data
Top