daily pastebin goal
62%
SHARE
TWEET

st3play v0.90

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