daily pastebin goal
86%
SHARE
TWEET

st3play v0.84

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