daily pastebin goal
23%
SHARE
TWEET

st3play v0.80

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