开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
mplayer.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：77k
源码类别：

Windows CE

开发平台：

C/C++

mplayer.c：源码内容
  1. /* MikMod sound library
  2. (c) 1998, 1999, 2000, 2001 Miodrag Vallat and others - see file AUTHORS
  3. for complete list.
  5. This library is free software; you can redistribute it and/or modify
  6. it under the terms of the GNU Library General Public License as
  7. published by the Free Software Foundation; either version 2 of
  8. the License, or (at your option) any later version.
  9.  
  10. This program is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. GNU Library General Public License for more details.
  14.  
  15. You should have received a copy of the GNU Library General Public
  16. License along with this library; if not, write to the Free Software
  17. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  18. 02111-1307, USA.
  19. */
  21. /*==============================================================================
  23.   $Id: mplayer.c,v 1.5 2004/01/31 22:40:22 raph Exp $
  25.   The Protracker Player Driver
  27.   The protracker driver supports all base Protracker 3.x commands and features.
  29. ==============================================================================*/
  31. #ifdef HAVE_CONFIG_H
  32. #include "config.h"
  33. #endif
  35. #include <string.h>
  36. #include <stdarg.h>
  37. #ifdef SRANDOM_IN_MATH_H
  38. #include <math.h>
  39. #else
  40. #include <stdlib.h>
  41. #endif
  43. #include "mikmod_internals.h"
  45. #ifdef SUNOS
  46. extern int fprintf(FILE *, const char *, ...);
  47. extern long int random(void);
  48. #endif
  50. /* The currently playing module */
  51. /* This variable should better be static, but it would break the ABI, so this
  52.    will wait */
  53. /*static*/ MODULE *pf = NULL;
  55. #define HIGH_OCTAVE 2 /* number of above-range octaves */
  57. static UWORD oldperiods[OCTAVE*2]={
  58. 0x6b00, 0x6800, 0x6500, 0x6220, 0x5f50, 0x5c80,
  59. 0x5a00, 0x5740, 0x54d0, 0x5260, 0x5010, 0x4dc0,
  60. 0x4b90, 0x4960, 0x4750, 0x4540, 0x4350, 0x4160,
  61. 0x3f90, 0x3dc0, 0x3c10, 0x3a40, 0x38b0, 0x3700
  62. };
  64. static UBYTE VibratoTable[32]={
  65.   0, 24, 49, 74, 97,120,141,161,180,197,212,224,235,244,250,253,
  66. 255,253,250,244,235,224,212,197,180,161,141,120, 97, 74, 49, 24
  67. };
  69. static UBYTE avibtab[128]={
  70.  0, 1, 3, 4, 6, 7, 9,10,12,14,15,17,18,20,21,23,
  71. 24,25,27,28,30,31,32,34,35,36,38,39,40,41,42,44,
  72. 45,46,47,48,49,50,51,52,53,54,54,55,56,57,57,58,
  73. 59,59,60,60,61,61,62,62,62,63,63,63,63,63,63,63,
  74. 64,63,63,63,63,63,63,63,62,62,62,61,61,60,60,59,
  75. 59,58,57,57,56,55,54,54,53,52,51,50,49,48,47,46,
  76. 45,44,42,41,40,39,38,36,35,34,32,31,30,28,27,25,
  77. 24,23,21,20,18,17,15,14,12,10, 9, 7, 6, 4, 3, 1
  78. };
  80. /* Triton's linear periods to frequency translation table (for XM modules) */
  81. static ULONG lintab[768]={
  82. 535232,534749,534266,533784,533303,532822,532341,531861,
  83. 531381,530902,530423,529944,529466,528988,528511,528034,
  84. 527558,527082,526607,526131,525657,525183,524709,524236,
  85. 523763,523290,522818,522346,521875,521404,520934,520464,
  86. 519994,519525,519057,518588,518121,517653,517186,516720,
  87. 516253,515788,515322,514858,514393,513929,513465,513002,
  88. 512539,512077,511615,511154,510692,510232,509771,509312,
  89. 508852,508393,507934,507476,507018,506561,506104,505647,
  90. 505191,504735,504280,503825,503371,502917,502463,502010,
  91. 501557,501104,500652,500201,499749,499298,498848,498398,
  92. 497948,497499,497050,496602,496154,495706,495259,494812,
  93. 494366,493920,493474,493029,492585,492140,491696,491253,
  94. 490809,490367,489924,489482,489041,488600,488159,487718,
  95. 487278,486839,486400,485961,485522,485084,484647,484210,
  96. 483773,483336,482900,482465,482029,481595,481160,480726,
  97. 480292,479859,479426,478994,478562,478130,477699,477268,
  98. 476837,476407,475977,475548,475119,474690,474262,473834,
  99. 473407,472979,472553,472126,471701,471275,470850,470425,
  100. 470001,469577,469153,468730,468307,467884,467462,467041,
  101. 466619,466198,465778,465358,464938,464518,464099,463681,
  102. 463262,462844,462427,462010,461593,461177,460760,460345,
  103. 459930,459515,459100,458686,458272,457859,457446,457033,
  104. 456621,456209,455797,455386,454975,454565,454155,453745,
  105. 453336,452927,452518,452110,451702,451294,450887,450481,
  106. 450074,449668,449262,448857,448452,448048,447644,447240,
  107. 446836,446433,446030,445628,445226,444824,444423,444022,
  108. 443622,443221,442821,442422,442023,441624,441226,440828,
  109. 440430,440033,439636,439239,438843,438447,438051,437656,
  110. 437261,436867,436473,436079,435686,435293,434900,434508,
  111. 434116,433724,433333,432942,432551,432161,431771,431382,
  112. 430992,430604,430215,429827,429439,429052,428665,428278,
  113. 427892,427506,427120,426735,426350,425965,425581,425197,
  114. 424813,424430,424047,423665,423283,422901,422519,422138,
  115. 421757,421377,420997,420617,420237,419858,419479,419101,
  116. 418723,418345,417968,417591,417214,416838,416462,416086,
  117. 415711,415336,414961,414586,414212,413839,413465,413092,
  118. 412720,412347,411975,411604,411232,410862,410491,410121,
  119. 409751,409381,409012,408643,408274,407906,407538,407170,
  120. 406803,406436,406069,405703,405337,404971,404606,404241,
  121. 403876,403512,403148,402784,402421,402058,401695,401333,
  122. 400970,400609,400247,399886,399525,399165,398805,398445,
  123. 398086,397727,397368,397009,396651,396293,395936,395579,
  124. 395222,394865,394509,394153,393798,393442,393087,392733,
  125. 392378,392024,391671,391317,390964,390612,390259,389907,
  126. 389556,389204,388853,388502,388152,387802,387452,387102,
  127. 386753,386404,386056,385707,385359,385012,384664,384317,
  128. 383971,383624,383278,382932,382587,382242,381897,381552,
  129. 381208,380864,380521,380177,379834,379492,379149,378807,
  130. 378466,378124,377783,377442,377102,376762,376422,376082,
  131. 375743,375404,375065,374727,374389,374051,373714,373377,
  132. 373040,372703,372367,372031,371695,371360,371025,370690,
  133. 370356,370022,369688,369355,369021,368688,368356,368023,
  134. 367691,367360,367028,366697,366366,366036,365706,365376,
  135. 365046,364717,364388,364059,363731,363403,363075,362747,
  136. 362420,362093,361766,361440,361114,360788,360463,360137,
  137. 359813,359488,359164,358840,358516,358193,357869,357547,
  138. 357224,356902,356580,356258,355937,355616,355295,354974,
  139. 354654,354334,354014,353695,353376,353057,352739,352420,
  140. 352103,351785,351468,351150,350834,350517,350201,349885,
  141. 349569,349254,348939,348624,348310,347995,347682,347368,
  142. 347055,346741,346429,346116,345804,345492,345180,344869,
  143. 344558,344247,343936,343626,343316,343006,342697,342388,
  144. 342079,341770,341462,341154,340846,340539,340231,339924,
  145. 339618,339311,339005,338700,338394,338089,337784,337479,
  146. 337175,336870,336566,336263,335959,335656,335354,335051,
  147. 334749,334447,334145,333844,333542,333242,332941,332641,
  148. 332341,332041,331741,331442,331143,330844,330546,330247,
  149. 329950,329652,329355,329057,328761,328464,328168,327872,
  150. 327576,327280,326985,326690,326395,326101,325807,325513,
  151. 325219,324926,324633,324340,324047,323755,323463,323171,
  152. 322879,322588,322297,322006,321716,321426,321136,320846,
  153. 320557,320267,319978,319690,319401,319113,318825,318538,
  154. 318250,317963,317676,317390,317103,316817,316532,316246,
  155. 315961,315676,315391,315106,314822,314538,314254,313971,
  156. 313688,313405,313122,312839,312557,312275,311994,311712,
  157. 311431,311150,310869,310589,310309,310029,309749,309470,
  158. 309190,308911,308633,308354,308076,307798,307521,307243,
  159. 306966,306689,306412,306136,305860,305584,305308,305033,
  160. 304758,304483,304208,303934,303659,303385,303112,302838,
  161. 302565,302292,302019,301747,301475,301203,300931,300660,
  162. 300388,300117,299847,299576,299306,299036,298766,298497,
  163. 298227,297958,297689,297421,297153,296884,296617,296349,
  164. 296082,295815,295548,295281,295015,294749,294483,294217,
  165. 293952,293686,293421,293157,292892,292628,292364,292100,
  166. 291837,291574,291311,291048,290785,290523,290261,289999,
  167. 289737,289476,289215,288954,288693,288433,288173,287913,
  168. 287653,287393,287134,286875,286616,286358,286099,285841,
  169. 285583,285326,285068,284811,284554,284298,284041,283785,
  170. 283529,283273,283017,282762,282507,282252,281998,281743,
  171. 281489,281235,280981,280728,280475,280222,279969,279716,
  172. 279464,279212,278960,278708,278457,278206,277955,277704,
  173. 277453,277203,276953,276703,276453,276204,275955,275706,
  174. 275457,275209,274960,274712,274465,274217,273970,273722,
  175. 273476,273229,272982,272736,272490,272244,271999,271753,
  176. 271508,271263,271018,270774,270530,270286,270042,269798,
  177. 269555,269312,269069,268826,268583,268341,268099,267857
  178. };
  180. #define LOGFAC 2*16
  181. static UWORD logtab[104]={
  182. LOGFAC*907,LOGFAC*900,LOGFAC*894,LOGFAC*887,
  183. LOGFAC*881,LOGFAC*875,LOGFAC*868,LOGFAC*862,
  184. LOGFAC*856,LOGFAC*850,LOGFAC*844,LOGFAC*838,
  185. LOGFAC*832,LOGFAC*826,LOGFAC*820,LOGFAC*814,
  186. LOGFAC*808,LOGFAC*802,LOGFAC*796,LOGFAC*791,
  187. LOGFAC*785,LOGFAC*779,LOGFAC*774,LOGFAC*768,
  188. LOGFAC*762,LOGFAC*757,LOGFAC*752,LOGFAC*746,
  189. LOGFAC*741,LOGFAC*736,LOGFAC*730,LOGFAC*725,
  190. LOGFAC*720,LOGFAC*715,LOGFAC*709,LOGFAC*704,
  191. LOGFAC*699,LOGFAC*694,LOGFAC*689,LOGFAC*684,
  192. LOGFAC*678,LOGFAC*675,LOGFAC*670,LOGFAC*665,
  193. LOGFAC*660,LOGFAC*655,LOGFAC*651,LOGFAC*646,
  194. LOGFAC*640,LOGFAC*636,LOGFAC*632,LOGFAC*628,
  195. LOGFAC*623,LOGFAC*619,LOGFAC*614,LOGFAC*610,
  196. LOGFAC*604,LOGFAC*601,LOGFAC*597,LOGFAC*592,
  197. LOGFAC*588,LOGFAC*584,LOGFAC*580,LOGFAC*575,
  198. LOGFAC*570,LOGFAC*567,LOGFAC*563,LOGFAC*559,
  199. LOGFAC*555,LOGFAC*551,LOGFAC*547,LOGFAC*543,
  200. LOGFAC*538,LOGFAC*535,LOGFAC*532,LOGFAC*528,
  201. LOGFAC*524,LOGFAC*520,LOGFAC*516,LOGFAC*513,
  202. LOGFAC*508,LOGFAC*505,LOGFAC*502,LOGFAC*498,
  203. LOGFAC*494,LOGFAC*491,LOGFAC*487,LOGFAC*484,
  204. LOGFAC*480,LOGFAC*477,LOGFAC*474,LOGFAC*470,
  205. LOGFAC*467,LOGFAC*463,LOGFAC*460,LOGFAC*457,
  206. LOGFAC*453,LOGFAC*450,LOGFAC*447,LOGFAC*443,
  207. LOGFAC*440,LOGFAC*437,LOGFAC*434,LOGFAC*431
  208. };
  210. static SBYTE PanbrelloTable[256]={
  211.   0,  2,  3,  5,  6,  8,  9, 11, 12, 14, 16, 17, 19, 20, 22, 23,
  212.  24, 26, 27, 29, 30, 32, 33, 34, 36, 37, 38, 39, 41, 42, 43, 44,
  213.  45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59,
  214.  59, 60, 60, 61, 61, 62, 62, 62, 63, 63, 63, 64, 64, 64, 64, 64,
  215.  64, 64, 64, 64, 64, 64, 63, 63, 63, 62, 62, 62, 61, 61, 60, 60,
  216.  59, 59, 58, 57, 56, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46,
  217.  45, 44, 43, 42, 41, 39, 38, 37, 36, 34, 33, 32, 30, 29, 27, 26,
  218.  24, 23, 22, 20, 19, 17, 16, 14, 12, 11,  9,  8,  6,  5,  3,  2,
  219.   0,- 2,- 3,- 5,- 6,- 8,- 9,-11,-12,-14,-16,-17,-19,-20,-22,-23,
  220. -24,-26,-27,-29,-30,-32,-33,-34,-36,-37,-38,-39,-41,-42,-43,-44,
  221. -45,-46,-47,-48,-49,-50,-51,-52,-53,-54,-55,-56,-56,-57,-58,-59,
  222. -59,-60,-60,-61,-61,-62,-62,-62,-63,-63,-63,-64,-64,-64,-64,-64,
  223. -64,-64,-64,-64,-64,-64,-63,-63,-63,-62,-62,-62,-61,-61,-60,-60,
  224. -59,-59,-58,-57,-56,-56,-55,-54,-53,-52,-51,-50,-49,-48,-47,-46,
  225. -45,-44,-43,-42,-41,-39,-38,-37,-36,-34,-33,-32,-30,-29,-27,-26,
  226. -24,-23,-22,-20,-19,-17,-16,-14,-12,-11,- 9,- 8,- 6,- 5,- 3,- 2
  227. };
  229. /* returns a random value between 0 and ceil-1, ceil must be a power of two */
  230. static int getrandom(int ceil)
  231. {
  232. #ifdef HAVE_SRANDOM
  233. return random()&(ceil-1);
  234. #else
  235. return (rand()*ceil)/(RAND_MAX+1.0);
  236. #endif
  237. }
  239. /* New Note Action Scoring System :
  240. --------------------------------
  241. 1) total-volume (fadevol, chanvol, volume) is the main scorer.
  242. 2) a looping sample is a bonus x2
  243. 3) a foreground channel is a bonus x4
  244. 4) an active envelope with keyoff is a handicap -x2
  245. */
  246. static int MP_FindEmptyChannel(MODULE *mod)
  247. {
  248. MP_VOICE *a;
  249. ULONG t,k,tvol,pp;
  251. for (t=0;t<md_sngchn;t++)
  252. if (((mod->voice[t].main.kick==KICK_ABSENT)||
  253.  (mod->voice[t].main.kick==KICK_ENV))&&
  254.    Voice_Stopped_internal(t))
  255. return t;
  257. tvol=0xffffffUL;t=-1;a=mod->voice;
  258. for (k=0;k<md_sngchn;k++,a++) {
  259. /* allow us to take over a nonexisting sample */
  260. if (!a->main.s)
  261. return k;
  263. if ((a->main.kick==KICK_ABSENT)||(a->main.kick==KICK_ENV)) {
  264. pp=a->totalvol<<((a->main.s->flags&SF_LOOP)?1:0);
  265. if ((a->master)&&(a==a->master->slave))
  266. pp<<=2;
  268. if (pp<tvol) {
  269. tvol=pp;
  270. t=k;
  271. }
  272. }
  273. }
  275. if (tvol>8000*7) return -1;
  276. return t;
  277. }
  279. static SWORD Interpolate(SWORD p,SWORD p1,SWORD p2,SWORD v1,SWORD v2)
  280. {
  281. if ((p1==p2)||(p==p1)) return v1;
  282. return v1+((SLONG)((p-p1)*(v2-v1))/(p2-p1));
  283. }
  285. UWORD getlinearperiod(UWORD note,ULONG fine)
  286. {
  287. UWORD t;
  289. t=((20L+2*HIGH_OCTAVE)*OCTAVE+2-note)*32L-(fine>>1);
  290. return t;
  291. }
  293. static UWORD getlogperiod(UWORD note,ULONG fine)
  294. {
  295. UWORD n,o;
  296. UWORD p1,p2;
  297. ULONG i;
  299. n=note%(2*OCTAVE);
  300. o=note/(2*OCTAVE);
  301. i=(n<<2)+(fine>>4); /* n*8 + fine/16 */
  303. p1=logtab[i];
  304. p2=logtab[i+1];
  306. return (Interpolate(fine>>4,0,15,p1,p2)>>o);
  307. }
  309. static UWORD getoldperiod(UWORD note,ULONG speed)
  310. {
  311. UWORD n,o;
  313. /* This happens sometimes on badly converted AMF, and old MOD */
  314. if (!speed) {
  315. #ifdef MIKMOD_DEBUG
  316. fprintf(stderr,"rmplayer: getoldperiod() called with note=%d, speed=0 !n",note);
  317. #endif
  318. return 4242; /* <- prevent divide overflow.. (42 hehe) */
  319. }
  321. n=note%(2*OCTAVE);
  322. o=note/(2*OCTAVE);
  323. return ((8363L*(ULONG)oldperiods[n])>>o)/speed;
  324. }
  326. static UWORD GetPeriod(UWORD flags, UWORD note, ULONG speed)
  327. {
  328. if (flags & UF_XMPERIODS) {
  329. if (flags & UF_LINEAR)
  330. return getlinearperiod(note, speed);
  331. else
  332. return getlogperiod(note, speed);
  333. } else
  334. return getoldperiod(note, speed);
  335. }
  337. static SWORD InterpolateEnv(SWORD p,ENVPT *a,ENVPT *b)
  338. {
  339. return (Interpolate(p,a->pos,b->pos,a->val,b->val));
  340. }
  342. static SWORD DoPan(SWORD envpan,SWORD pan)
  343. {
  344. int newpan;
  346. newpan=pan+(((envpan-PAN_CENTER)*(128-abs(pan-PAN_CENTER)))/128);
  348. return (newpan<PAN_LEFT)?PAN_LEFT:(newpan>PAN_RIGHT?PAN_RIGHT:newpan);
  349. }
  351. static SWORD StartEnvelope(ENVPR *t,UBYTE flg,UBYTE pts,UBYTE susbeg,UBYTE susend,UBYTE beg,UBYTE end,ENVPT *p,UBYTE keyoff)
  352. {
  353. t->flg=flg;
  354. t->pts=pts;
  355. t->susbeg=susbeg;
  356. t->susend=susend;
  357. t->beg=beg;
  358. t->end=end;
  359. t->env=p;
  360. t->p=0;
  361. t->a=0;
  362. t->b=((t->flg&EF_SUSTAIN)&&(!(keyoff&KEY_OFF)))?0:1;
  364. /* Imago Orpheus sometimes stores an extra initial point in the envelope */
  365. if ((t->pts>=2)&&(t->env[0].pos==t->env[1].pos)) {
  366. t->a++;t->b++;
  367. }
  369. /* Fit in the envelope, still */
  370. if (t->a >= t->pts)
  371. t->a = t->pts - 1;
  372. if (t->b >= t->pts)
  373. t->b = t->pts-1;
  375. return t->env[t->a].val;
  376. }
  378. /* This procedure processes all envelope types, include volume, pitch, and
  379.    panning.  Envelopes are defined by a set of points, each with a magnitude
  380.    [relating either to volume, panning position, or pitch modifier] and a tick
  381.    position.
  383.    Envelopes work in the following manner:
  385.    (a) Each tick the envelope is moved a point further in its progression. For
  386.        an accurate progression, magnitudes between two envelope points are
  387.        interpolated.
  389.    (b) When progression reaches a defined point on the envelope, values are
  390.        shifted to interpolate between this point and the next, and checks for
  391.        loops or envelope end are done.
  393.    Misc:
  394.      Sustain loops are loops that are only active as long as the keyoff flag is
  395.      clear.  When a volume envelope terminates, so does the current fadeout.
  396. */
  397. static SWORD ProcessEnvelope(MP_VOICE *aout, ENVPR *t, SWORD v)
  398. {
  399. if (t->flg & EF_ON) {
  400. UBYTE a, b; /* actual points in the envelope */
  401. UWORD p; /* the 'tick counter' - real point being played */
  403. a = t->a;
  404. b = t->b;
  405. p = t->p;
  407. /*
  408.  * Sustain loop on one point (XM type).
  409.  * Not processed if KEYOFF.
  410.  * Don't move and don't interpolate when the point is reached
  411.  */
  412. if ((t->flg & EF_SUSTAIN) && t->susbeg == t->susend &&
  413.    (!(aout->main.keyoff & KEY_OFF) && p == t->env[t->susbeg].pos)) {
  414. v = t->env[t->susbeg].val;
  415. } else {
  416. /*
  417.  * All following situations will require interpolation between
  418.  * two envelope points.
  419.  */
  421. /*
  422.  * Sustain loop between two points (IT type).
  423.  * Not processed if KEYOFF.
  424.  */
  425. /* if we were on a loop point, loop now */
  426. if ((t->flg & EF_SUSTAIN) && !(aout->main.keyoff & KEY_OFF) &&
  427.    a >= t->susend) {
  428. a = t->susbeg;
  429. b = (t->susbeg==t->susend)?a:a+1;
  430. p = t->env[a].pos;
  431. v = t->env[a].val;
  432. } else
  433. /*
  434.  * Regular loop.
  435.  * Be sure to correctly handle single point loops.
  436.  */
  437. if ((t->flg & EF_LOOP) && a >= t->end) {
  438. a = t->beg;
  439. b = t->beg == t->end ? a : a + 1;
  440. p = t->env[a].pos;
  441. v = t->env[a].val;
  442. } else
  443. /*
  444.  * Non looping situations.
  445.  */
  446. if (a != b)
  447. v = InterpolateEnv(p, &t->env[a], &t->env[b]);
  448. else
  449. v = t->env[a].val;
  451. /*
  452.  * Start to fade if the volume envelope is finished.
  453.  */
  454. if (p >= t->env[t->pts - 1].pos) {
  455. if (t->flg & EF_VOLENV) {
  456. aout->main.keyoff |= KEY_FADE;
  457. if (!v)
  458. aout->main.fadevol = 0;
  459. }
  460. } else {
  461. p++;
  462. /* did pointer reach point b? */
  463. if (p >= t->env[b].pos)
  464. a = b++; /* shift points a and b */
  465. }
  466. t->a = a;
  467. t->b = b;
  468. t->p = p;
  469. }
  470. }
  471. return v;
  472. }
  474. /* XM linear period to frequency conversion */
  475. ULONG getfrequency(UWORD flags,ULONG period)
  476. {
  477. if (flags & UF_LINEAR) {
  478. SLONG shift = ((SLONG)period / 768) - HIGH_OCTAVE;
  480. if (shift >= 0)
  481. return lintab[period % 768] >> shift;
  482. else
  483. return lintab[period % 768] << (-shift);
  484. } else
  485. return (8363L*1712L)/(period?period:1);
  486. }
  488. /*========== Protracker effects */
  490. static void DoArpeggio(UWORD tick, UWORD flags, MP_CONTROL *a, UBYTE style)
  491. {
  492. UBYTE note=a->main.note;
  494. if (a->arpmem) {
  495. switch (style) {
  496. case 0: /* mod style: N, N+x, N+y */
  497. switch (tick % 3) {
  498. /* case 0: unchanged */
  499. case 1:
  500. note += (a->arpmem >> 4);
  501. break;
  502. case 2:
  503. note += (a->arpmem & 0xf);
  504. break;
  505. }
  506. break;
  507. case 3: /* okt arpeggio 3: N-x, N, N+y */
  508. switch (tick % 3) {
  509. case 0:
  510. note -= (a->arpmem >> 4);
  511. break;
  512. /* case 1: unchanged */
  513. case 2:
  514. note += (a->arpmem & 0xf);
  515. break;
  516. }
  517. break;
  518. case 4: /* okt arpeggio 4: N, N+y, N, N-x */
  519. switch (tick % 4) {
  520. /* case 0, case 2: unchanged */
  521. case 1:
  522. note += (a->arpmem & 0xf);
  523. break;
  524. case 3:
  525. note -= (a->arpmem >> 4);
  526. break;
  527. }
  528. break;
  529. case 5: /* okt arpeggio 5: N-x, N+y, N, and nothing at tick 0 */
  530. if (!tick)
  531. break;
  532. switch (tick % 3) {
  533. /* case 0: unchanged */
  534. case 1:
  535. note -= (a->arpmem >> 4);
  536. break;
  537. case 2:
  538. note += (a->arpmem & 0xf);
  539. break;
  540. }
  541. break;
  542. }
  543. a->main.period = GetPeriod(flags, (UWORD)note << 1, a->speed);
  544. a->ownper = 1;
  545. }
  546. }
  548. static int DoPTEffect0(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  549. {
  550. UBYTE dat;
  552. dat = UniGetByte();
  553. if (!tick) {
  554. if (!dat && (flags & UF_ARPMEM))
  555. dat=a->arpmem;
  556. else
  557. a->arpmem=dat;
  558. }
  559. if (a->main.period)
  560. DoArpeggio(tick, flags, a, 0);
  562. return 0;
  563. }
  565. static int DoPTEffect1(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  566. {
  567. UBYTE dat;
  569. dat = UniGetByte();
  570. if (!tick && dat)
  571. a->slidespeed = (UWORD)dat << 2;
  572. if (a->main.period)
  573. if (tick)
  574. a->tmpperiod -= a->slidespeed;
  576. return 0;
  577. }
  579. static int DoPTEffect2(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  580. {
  581. UBYTE dat;
  583. dat = UniGetByte();
  584. if (!tick && dat)
  585. a->slidespeed = (UWORD)dat << 2;
  586. if (a->main.period)
  587. if (tick)
  588. a->tmpperiod += a->slidespeed;
  590. return 0;
  591. }
  593. static void DoToneSlide(UWORD tick, MP_CONTROL *a)
  594. {
  595. if (!a->main.fadevol)
  596. a->main.kick = (a->main.kick == KICK_NOTE)? KICK_NOTE : KICK_KEYOFF;
  597. else
  598. a->main.kick = (a->main.kick == KICK_NOTE)? KICK_ENV : KICK_ABSENT;
  600. if (tick != 0) {
  601. int dist;
  603. /* We have to slide a->main.period towards a->wantedperiod, so compute
  604.    the difference between those two values */
  605. dist=a->main.period-a->wantedperiod;
  607. /* if they are equal or if portamentospeed is too big ...*/
  608. if (dist == 0 || a->portspeed > abs(dist))
  609. /* ...make tmpperiod equal tperiod */
  610. a->tmpperiod=a->main.period=a->wantedperiod;
  611. else if (dist>0) {
  612. a->tmpperiod-=a->portspeed;
  613. a->main.period-=a->portspeed; /* dist>0, slide up */
  614. } else {
  615. a->tmpperiod+=a->portspeed;
  616. a->main.period+=a->portspeed; /* dist<0, slide down */
  617. }
  618. } else
  619. a->tmpperiod=a->main.period;
  620. a->ownper = 1;
  621. }
  623. static int DoPTEffect3(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  624. {
  625. UBYTE dat;
  627. dat=UniGetByte();
  628. if ((!tick)&&(dat)) a->portspeed=(UWORD)dat<<2;
  629. if (a->main.period)
  630. DoToneSlide(tick, a);
  632. return 0;
  633. }
  635. static void DoVibrato(UWORD tick, MP_CONTROL *a)
  636. {
  637. UBYTE q;
  638. UWORD temp = 0; /* silence warning */
  640. if (!tick)
  641. return;
  643. q=(a->vibpos>>2)&0x1f;
  645. switch (a->wavecontrol&3) {
  646. case 0: /* sine */
  647. temp=VibratoTable[q];
  648. break;
  649. case 1: /* ramp down */
  650. q<<=3;
  651. if (a->vibpos<0) q=255-q;
  652. temp=q;
  653. break;
  654. case 2: /* square wave */
  655. temp=255;
  656. break;
  657. case 3: /* random wave */
  658. temp=getrandom(256);
  659. break;
  660. }
  662. temp*=a->vibdepth;
  663. temp>>=7;temp<<=2;
  665. if (a->vibpos>=0)
  666. a->main.period=a->tmpperiod+temp;
  667. else
  668. a->main.period=a->tmpperiod-temp;
  669. a->ownper = 1;
  671. if (tick != 0)
  672. a->vibpos+=a->vibspd;
  673. }
  675. static int DoPTEffect4(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  676. {
  677. UBYTE dat;
  679. dat=UniGetByte();
  680. if (!tick) {
  681. if (dat&0x0f) a->vibdepth=dat&0xf;
  682. if (dat&0xf0) a->vibspd=(dat&0xf0)>>2;
  683. }
  684. if (a->main.period)
  685. DoVibrato(tick, a);
  687. return 0;
  688. }
  690. static void DoVolSlide(MP_CONTROL *a, UBYTE dat)
  691. {
  692. if (dat&0xf) {
  693. a->tmpvolume-=(dat&0x0f);
  694. if (a->tmpvolume<0)
  695. a->tmpvolume=0;
  696. } else {
  697. a->tmpvolume+=(dat>>4);
  698. if (a->tmpvolume>64)
  699. a->tmpvolume=64;
  700. }
  701. }
  703. static int DoPTEffect5(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  704. {
  705. UBYTE dat;
  707. dat=UniGetByte();
  708. if (a->main.period)
  709. DoToneSlide(tick, a);
  711. if (tick)
  712. DoVolSlide(a, dat);
  714. return 0;
  715. }
  717. /* DoPTEffect6 after DoPTEffectA */
  719. static int DoPTEffect7(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  720. {
  721. UBYTE dat;
  722. UBYTE q;
  723. UWORD temp = 0; /* silence warning */
  725. dat=UniGetByte();
  726. if (!tick) {
  727. if (dat&0x0f) a->trmdepth=dat&0xf;
  728. if (dat&0xf0) a->trmspd=(dat&0xf0)>>2;
  729. }
  730. if (a->main.period) {
  731. q=(a->trmpos>>2)&0x1f;
  733. switch ((a->wavecontrol>>4)&3) {
  734. case 0: /* sine */
  735. temp=VibratoTable[q];
  736. break;
  737. case 1: /* ramp down */
  738. q<<=3;
  739. if (a->trmpos<0) q=255-q;
  740. temp=q;
  741. break;
  742. case 2: /* square wave */
  743. temp=255;
  744. break;
  745. case 3: /* random wave */
  746. temp=getrandom(256);
  747. break;
  748. }
  749. temp*=a->trmdepth;
  750. temp>>=6;
  752. if (a->trmpos>=0) {
  753. a->volume=a->tmpvolume+temp;
  754. if (a->volume>64) a->volume=64;
  755. } else {
  756. a->volume=a->tmpvolume-temp;
  757. if (a->volume<0) a->volume=0;
  758. }
  759. a->ownvol = 1;
  761. if (tick)
  762. a->trmpos+=a->trmspd;
  763. }
  765. return 0;
  766. }
  768. static int DoPTEffect8(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  769. {
  770. UBYTE dat;
  772. dat = UniGetByte();
  773. if (mod->panflag)
  774. a->main.panning = mod->panning[channel] = dat;
  776. return 0;
  777. }
  779. static int DoPTEffect9(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  780. {
  781. UBYTE dat;
  783. dat=UniGetByte();
  784. if (!tick) {
  785. if (dat) a->soffset=(UWORD)dat<<8;
  786. a->main.start=a->hioffset|a->soffset;
  788. if ((a->main.s)&&(a->main.start>a->main.s->length))
  789. a->main.start=a->main.s->flags&(SF_LOOP|SF_BIDI)?
  790.     a->main.s->loopstart:a->main.s->length;
  791. }
  793. return 0;
  794. }
  796. static int DoPTEffectA(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  797. {
  798. UBYTE dat;
  800. dat=UniGetByte();
  801. if (tick)
  802. DoVolSlide(a, dat);
  804. return 0;
  805. }
  807. static int DoPTEffect6(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  808. {
  809. if (a->main.period)
  810. DoVibrato(tick, a);
  811. DoPTEffectA(tick, flags, a, mod, channel);
  813. return 0;
  814. }
  816. static int DoPTEffectB(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  817. {
  818. UBYTE dat;
  820. dat=UniGetByte();
  822. if (tick || mod->patdly2)
  823. return 0;
  825. /* Vincent Voois uses a nasty trick in "Universal Bolero" */
  826. if (dat == mod->sngpos && mod->patbrk == mod->patpos)
  827. return 0;
  829. if (!mod->loop && !mod->patbrk &&
  830.     (dat < mod->sngpos ||
  831.  (mod->sngpos == (mod->numpos - 1) && !mod->patbrk) ||
  832.      (dat == mod->sngpos && (flags & UF_NOWRAP))
  833. )) {
  834. /* if we don't loop, better not to skip the end of the
  835.    pattern, after all... so:
  836. mod->patbrk=0; */
  837. mod->posjmp=3;
  838. } else {
  839. /* if we were fading, adjust... */
  840. if (mod->sngpos == (mod->numpos-1))
  841. mod->volume=mod->initvolume>128?128:mod->initvolume;
  842. mod->sngpos=dat;
  843. mod->posjmp=2;
  844. mod->patpos=0;
  845. }
  847. return 0;
  848. }
  850. static int DoPTEffectC(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  851. {
  852. UBYTE dat;
  854. dat=UniGetByte();
  855. if (tick) return 0;
  856. if (dat==(UBYTE)-1) a->anote=dat=0; /* note cut */
  857. else if (dat>64) dat=64;
  858. a->tmpvolume=dat;
  860. return 0;
  861. }
  863. static int DoPTEffectD(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  864. {
  865. UBYTE dat;
  867. dat=UniGetByte();
  868. if ((tick)||(mod->patdly2)) return 0;
  869. if ((mod->positions[mod->sngpos]!=LAST_PATTERN)&&
  870.    (dat>mod->pattrows[mod->positions[mod->sngpos]]))
  871. dat=mod->pattrows[mod->positions[mod->sngpos]];
  872. mod->patbrk=dat;
  873. if (!mod->posjmp) {
  874. /* don't ask me to explain this code - it makes
  875.    backwards.s3m and children.xm (heretic's version) play
  876.    correctly, among others. Take that for granted, or write
  877.    the page of comments yourself... you might need some
  878.    aspirin - Miod */
  879. if ((mod->sngpos==mod->numpos-1)&&(dat)&&((mod->loop)||
  880.                (mod->positions[mod->sngpos]==(mod->numpat-1)
  881. && !(flags&UF_NOWRAP)))) {
  882. mod->sngpos=0;
  883. mod->posjmp=2;
  884. } else
  885. mod->posjmp=3;
  886. }
  888. return 0;
  889. }
  891. static void DoEEffects(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod,
  892. SWORD channel, UBYTE dat)
  893. {
  894. UBYTE nib = dat & 0xf;
  896. switch (dat>>4) {
  897. case 0x0: /* hardware filter toggle, not supported */
  898. break;
  899. case 0x1: /* fineslide up */
  900. if (a->main.period)
  901. if (!tick)
  902. a->tmpperiod-=(nib<<2);
  903. break;
  904. case 0x2: /* fineslide dn */
  905. if (a->main.period)
  906. if (!tick)
  907. a->tmpperiod+=(nib<<2);
  908. break;
  909. case 0x3: /* glissando ctrl */
  910. a->glissando=nib;
  911. break;
  912. case 0x4: /* set vibrato waveform */
  913. a->wavecontrol&=0xf0;
  914. a->wavecontrol|=nib;
  915. break;
  916. case 0x5: /* set finetune */
  917. if (a->main.period) {
  918. if (flags&UF_XMPERIODS)
  919. a->speed=nib+128;
  920. else
  921. a->speed=finetune[nib];
  922. a->tmpperiod=GetPeriod(flags, (UWORD)a->main.note<<1,a->speed);
  923. }
  924. break;
  925. case 0x6: /* set patternloop */
  926. if (tick)
  927. break;
  928. if (nib) { /* set reppos or repcnt ? */
  929. /* set repcnt, so check if repcnt already is set, which means we
  930.    are already looping */
  931. if (a->pat_repcnt)
  932. a->pat_repcnt--; /* already looping, decrease counter */
  933. else {
  934. #if 0
  935. /* this would make walker.xm, shipped with Xsoundtracker,
  936.    play correctly, but it's better to remain compatible
  937.    with FT2 */
  938. if ((!(flags&UF_NOWRAP))||(a->pat_reppos!=POS_NONE))
  939. #endif
  940. a->pat_repcnt=nib; /* not yet looping, so set repcnt */
  941. }
  943. if (a->pat_repcnt) { /* jump to reppos if repcnt>0 */
  944. if (a->pat_reppos==POS_NONE)
  945. a->pat_reppos=mod->patpos-1;
  946. if (a->pat_reppos==-1) {
  947. mod->pat_repcrazy=1;
  948. mod->patpos=0;
  949. } else
  950. mod->patpos=a->pat_reppos;
  951. } else a->pat_reppos=POS_NONE;
  952. } else
  953. a->pat_reppos=mod->patpos-1; /* set reppos - can be (-1) */
  954. break;
  955. case 0x7: /* set tremolo waveform */
  956. a->wavecontrol&=0x0f;
  957. a->wavecontrol|=nib<<4;
  958. break;
  959. case 0x8: /* set panning */
  960. if (mod->panflag) {
  961. if (nib<=8) nib<<=4;
  962. else nib*=17;
  963. a->main.panning=mod->panning[channel]=nib;
  964. }
  965. break;
  966. case 0x9: /* retrig note */
  967. /* do not retrigger on tick 0, until we are emulating FT2 and effect
  968.    data is zero */
  969. if (!tick && !((flags & UF_FT2QUIRKS) && (!nib)))
  970. break;
  971. /* only retrigger if data nibble > 0, or if tick 0 (FT2 compat) */
  972. if (nib || !tick) {
  973. if (!a->retrig) {
  974. /* when retrig counter reaches 0, reset counter and restart
  975.    the sample */
  976. if (a->main.period) a->main.kick=KICK_NOTE;
  977. a->retrig=nib;
  978. }
  979. a->retrig--; /* countdown */
  980. }
  981. break;
  982. case 0xa: /* fine volume slide up */
  983. if (tick)
  984. break;
  985. a->tmpvolume+=nib;
  986. if (a->tmpvolume>64) a->tmpvolume=64;
  987. break;
  988. case 0xb: /* fine volume slide dn  */
  989. if (tick)
  990. break;
  991. a->tmpvolume-=nib;
  992. if (a->tmpvolume<0)a->tmpvolume=0;
  993. break;
  994. case 0xc: /* cut note */
  995. /* When tick reaches the cut-note value, turn the volume to
  996.    zero (just like on the amiga) */
  997. if (tick>=nib)
  998. a->tmpvolume=0; /* just turn the volume down */
  999. break;
  1000. case 0xd: /* note delay */
  1001. /* delay the start of the sample until tick==nib */
  1002. if (!tick)
  1003. a->main.notedelay=nib;
  1004. else if (a->main.notedelay)
  1005. a->main.notedelay--;
  1006. break;
  1007. case 0xe: /* pattern delay */
  1008. if (!tick)
  1009. if (!mod->patdly2)
  1010. mod->patdly=nib+1; /* only once, when tick=0 */
  1011. break;
  1012. case 0xf: /* invert loop, not supported  */
  1013. break;
  1014. }
  1015. }
  1017. static int DoPTEffectE(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1018. {
  1019. DoEEffects(tick, flags, a, mod, channel, UniGetByte());
  1021. return 0;
  1022. }
  1024. static int DoPTEffectF(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1025. {
  1026. UBYTE dat;
  1028. dat=UniGetByte();
  1029. if (tick||mod->patdly2) return 0;
  1030. if (mod->extspd&&(dat>=mod->bpmlimit))
  1031. mod->bpm=dat;
  1032. else 
  1033.   if (dat) {
  1034. mod->sngspd=(dat>=mod->bpmlimit)?mod->bpmlimit-1:dat;
  1035. mod->vbtick=0;
  1036. }
  1038. return 0;
  1039. }
  1041. /*========== Scream Tracker effects */
  1043. static int DoS3MEffectA(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1044. {
  1045. UBYTE speed;
  1047. speed = UniGetByte();
  1049. if (tick || mod->patdly2)
  1050. return 0;
  1052. if (speed > 128)
  1053. speed -= 128;
  1054. if (speed) {
  1055. mod->sngspd = speed;
  1056. mod->vbtick = 0;
  1057. }
  1059. return 0;
  1060. }
  1062. static void DoS3MVolSlide(UWORD tick, UWORD flags, MP_CONTROL *a, UBYTE inf)
  1063. {
  1064. UBYTE lo, hi;
  1066. if (inf)
  1067. a->s3mvolslide=inf;
  1068. else
  1069. inf=a->s3mvolslide;
  1071. lo=inf&0xf;
  1072. hi=inf>>4;
  1074. if (!lo) {
  1075. if ((tick)||(flags&UF_S3MSLIDES)) a->tmpvolume+=hi;
  1076. } else
  1077.   if (!hi) {
  1078. if ((tick)||(flags&UF_S3MSLIDES)) a->tmpvolume-=lo;
  1079. } else
  1080.   if (lo==0xf) {
  1081. if (!tick) a->tmpvolume+=(hi?hi:0xf);
  1082. } else
  1083.   if (hi==0xf) {
  1084. if (!tick) a->tmpvolume-=(lo?lo:0xf);
  1085. } else
  1086.   return;
  1088. if (a->tmpvolume<0)
  1089. a->tmpvolume=0;
  1090. else if (a->tmpvolume>64)
  1091. a->tmpvolume=64;
  1092. }
  1094. static int DoS3MEffectD(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1095. {
  1096. DoS3MVolSlide(tick, flags, a, UniGetByte());
  1098. return 1;
  1099. }
  1101. static void DoS3MSlideDn(UWORD tick, MP_CONTROL *a, UBYTE inf)
  1102. {
  1103. UBYTE hi,lo;
  1105. if (inf)
  1106. a->slidespeed=inf;
  1107. else
  1108. inf=a->slidespeed;
  1110. hi=inf>>4;
  1111. lo=inf&0xf;
  1113. if (hi==0xf) {
  1114. if (!tick) a->tmpperiod+=(UWORD)lo<<2;
  1115. } else
  1116.   if (hi==0xe) {
  1117. if (!tick) a->tmpperiod+=lo;
  1118. } else {
  1119. if (tick) a->tmpperiod+=(UWORD)inf<<2;
  1120. }
  1121. }
  1123. static int DoS3MEffectE(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1124. {
  1125. UBYTE dat;
  1127. dat=UniGetByte();
  1128. if (a->main.period)
  1129. DoS3MSlideDn(tick, a,dat);
  1131. return 0;
  1132. }
  1134. static void DoS3MSlideUp(UWORD tick, MP_CONTROL *a, UBYTE inf)
  1135. {
  1136. UBYTE hi,lo;
  1138. if (inf) a->slidespeed=inf;
  1139. else inf=a->slidespeed;
  1141. hi=inf>>4;
  1142. lo=inf&0xf;
  1144. if (hi==0xf) {
  1145. if (!tick) a->tmpperiod-=(UWORD)lo<<2;
  1146. } else
  1147.   if (hi==0xe) {
  1148. if (!tick) a->tmpperiod-=lo;
  1149. } else {
  1150. if (tick) a->tmpperiod-=(UWORD)inf<<2;
  1151. }
  1152. }
  1154. static int DoS3MEffectF(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1155. {
  1156. UBYTE dat;
  1158. dat=UniGetByte();
  1159. if (a->main.period)
  1160. DoS3MSlideUp(tick, a,dat);
  1162. return 0;
  1163. }
  1165. static int DoS3MEffectI(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1166. {
  1167. UBYTE inf, on, off;
  1169. inf = UniGetByte();
  1170. if (inf)
  1171. a->s3mtronof = inf;
  1172. else {
  1173. inf = a->s3mtronof;
  1174. if (!inf)
  1175. return 0;
  1176. }
  1178. if (!tick)
  1179. return 0;
  1181. on=(inf>>4)+1;
  1182. off=(inf&0xf)+1;
  1183. a->s3mtremor%=(on+off);
  1184. a->volume=(a->s3mtremor<on)?a->tmpvolume:0;
  1185. a->ownvol=1;
  1186. a->s3mtremor++;
  1188. return 0;
  1189. }
  1191. static int DoS3MEffectQ(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1192. {
  1193. UBYTE inf;
  1195. inf = UniGetByte();
  1196. if (a->main.period) {
  1197. if (inf) {
  1198. a->s3mrtgslide=inf>>4;
  1199. a->s3mrtgspeed=inf&0xf;
  1200. }
  1202. /* only retrigger if low nibble > 0 */
  1203. if (a->s3mrtgspeed>0) {
  1204. if (!a->retrig) {
  1205. /* when retrig counter reaches 0, reset counter and restart the
  1206.    sample */
  1207. if (a->main.kick!=KICK_NOTE) a->main.kick=KICK_KEYOFF;
  1208. a->retrig=a->s3mrtgspeed;
  1210. if ((tick)||(flags&UF_S3MSLIDES)) {
  1211. switch (a->s3mrtgslide) {
  1212. case 1:
  1213. case 2:
  1214. case 3:
  1215. case 4:
  1216. case 5:
  1217. a->tmpvolume-=(1<<(a->s3mrtgslide-1));
  1218. break;
  1219. case 6:
  1220. a->tmpvolume=(2*a->tmpvolume)/3;
  1221. break;
  1222. case 7:
  1223. a->tmpvolume>>=1;
  1224. break;
  1225. case 9:
  1226. case 0xa:
  1227. case 0xb:
  1228. case 0xc:
  1229. case 0xd:
  1230. a->tmpvolume+=(1<<(a->s3mrtgslide-9));
  1231. break;
  1232. case 0xe:
  1233. a->tmpvolume=(3*a->tmpvolume)>>1;
  1234. break;
  1235. case 0xf:
  1236. a->tmpvolume=a->tmpvolume<<1;
  1237. break;
  1238. }
  1239. if (a->tmpvolume<0)
  1240. a->tmpvolume=0;
  1241. else if (a->tmpvolume>64)
  1242. a->tmpvolume=64;
  1243. }
  1244. }
  1245. a->retrig--; /* countdown  */
  1246. }
  1247. }
  1249. return 0;
  1250. }
  1252. static int DoS3MEffectR(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1253. {
  1254. UBYTE dat, q;
  1255. UWORD temp=0; /* silence warning */
  1257. dat = UniGetByte();
  1258. if (!tick) {
  1259. if (dat&0x0f) a->trmdepth=dat&0xf;
  1260. if (dat&0xf0) a->trmspd=(dat&0xf0)>>2;
  1261. }
  1263. q=(a->trmpos>>2)&0x1f;
  1265. switch ((a->wavecontrol>>4)&3) {
  1266. case 0: /* sine */
  1267. temp=VibratoTable[q];
  1268. break;
  1269. case 1: /* ramp down */
  1270. q<<=3;
  1271. if (a->trmpos<0) q=255-q;
  1272. temp=q;
  1273. break;
  1274. case 2: /* square wave */
  1275. temp=255;
  1276. break;
  1277. case 3: /* random */
  1278. temp=getrandom(256);
  1279. break;
  1280. }
  1282. temp*=a->trmdepth;
  1283. temp>>=7;
  1285. if (a->trmpos>=0) {
  1286. a->volume=a->tmpvolume+temp;
  1287. if (a->volume>64) a->volume=64;
  1288. } else {
  1289. a->volume=a->tmpvolume-temp;
  1290. if (a->volume<0) a->volume=0;
  1291. }
  1292. a->ownvol = 1;
  1294. if (tick)
  1295. a->trmpos+=a->trmspd;
  1297. return 0;
  1298. }
  1300. static int DoS3MEffectT(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1301. {
  1302. UBYTE tempo;
  1304. tempo = UniGetByte();
  1306. if (tick || mod->patdly2)
  1307. return 0;
  1309. mod->bpm = (tempo < 32) ? 32 : tempo;
  1311. return 0;
  1312. }
  1314. static int DoS3MEffectU(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1315. {
  1316. UBYTE dat, q;
  1317. UWORD temp = 0; /* silence warning */
  1319. dat = UniGetByte();
  1320. if (!tick) {
  1321. if (dat&0x0f) a->vibdepth=dat&0xf;
  1322. if (dat&0xf0) a->vibspd=(dat&0xf0)>>2;
  1323. } else
  1324. if (a->main.period) {
  1325. q=(a->vibpos>>2)&0x1f;
  1327. switch (a->wavecontrol&3) {
  1328. case 0: /* sine */
  1329. temp=VibratoTable[q];
  1330. break;
  1331. case 1: /* ramp down */
  1332. q<<=3;
  1333. if (a->vibpos<0) q=255-q;
  1334. temp=q;
  1335. break;
  1336. case 2: /* square wave */
  1337. temp=255;
  1338. break;
  1339. case 3: /* random */
  1340. temp=getrandom(256);
  1341. break;
  1342. }
  1344. temp*=a->vibdepth;
  1345. temp>>=8;
  1347. if (a->vibpos>=0)
  1348. a->main.period=a->tmpperiod+temp;
  1349. else
  1350. a->main.period=a->tmpperiod-temp;
  1351. a->ownper = 1;
  1353. a->vibpos+=a->vibspd;
  1354. }
  1356. return 0;
  1357. }
  1359. /*========== Envelope helpers */
  1361. static int DoKeyOff(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1362. {
  1363. a->main.keyoff|=KEY_OFF;
  1364. if ((!(a->main.volflg&EF_ON))||(a->main.volflg&EF_LOOP))
  1365. a->main.keyoff=KEY_KILL;
  1367. return 0;
  1368. }
  1370. static int DoKeyFade(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1371. {
  1372. UBYTE dat;
  1374. dat=UniGetByte();
  1375. if ((tick>=dat)||(tick==mod->sngspd-1)) {
  1376. a->main.keyoff=KEY_KILL;
  1377. if (!(a->main.volflg&EF_ON))
  1378. a->main.fadevol=0;
  1379. }
  1381. return 0;
  1382. }
  1384. /*========== Fast Tracker effects */
  1386. /* DoXMEffect6 after DoXMEffectA */
  1388. static int DoXMEffectA(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1389. {
  1390. UBYTE inf, lo, hi;
  1392. inf = UniGetByte();
  1393. if (inf)
  1394. a->s3mvolslide = inf;
  1395. else
  1396. inf = a->s3mvolslide;
  1398. if (tick) {
  1399. lo=inf&0xf;
  1400. hi=inf>>4;
  1402. if (!hi) {
  1403. a->tmpvolume-=lo;
  1404. if (a->tmpvolume<0) a->tmpvolume=0;
  1405. } else {
  1406. a->tmpvolume+=hi;
  1407. if (a->tmpvolume>64) a->tmpvolume=64;
  1408. }
  1409. }
  1411. return 0;
  1412. }
  1414. static int DoXMEffect6(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1415. {
  1416. if (a->main.period)
  1417. DoVibrato(tick, a);
  1419. return DoXMEffectA(tick, flags, a, mod, channel);
  1420. }
  1422. static int DoXMEffectE1(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1423. {
  1424. UBYTE dat;
  1426. dat=UniGetByte();
  1427. if (!tick) {
  1428. if (dat) a->fportupspd=dat;
  1429. if (a->main.period)
  1430. a->tmpperiod-=(a->fportupspd<<2);
  1431. }
  1433. return 0;
  1434. }
  1436. static int DoXMEffectE2(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1437. {
  1438. UBYTE dat;
  1440. dat=UniGetByte();
  1441. if (!tick) {
  1442. if (dat) a->fportdnspd=dat;
  1443. if (a->main.period)
  1444. a->tmpperiod+=(a->fportdnspd<<2);
  1445. }
  1447. return 0;
  1448. }
  1450. static int DoXMEffectEA(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1451. {
  1452. UBYTE dat;
  1454. dat=UniGetByte();
  1455. if (!tick)
  1456. if (dat) a->fslideupspd=dat;
  1457. a->tmpvolume+=a->fslideupspd;
  1458. if (a->tmpvolume>64) a->tmpvolume=64;
  1460. return 0;
  1461. }
  1463. static int DoXMEffectEB(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1464. {
  1465. UBYTE dat;
  1467. dat=UniGetByte();
  1468. if (!tick)
  1469. if (dat) a->fslidednspd=dat;
  1470. a->tmpvolume-=a->fslidednspd;
  1471. if (a->tmpvolume<0) a->tmpvolume=0;
  1473. return 0;
  1474. }
  1476. static int DoXMEffectG(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1477. {
  1478. mod->volume=UniGetByte()<<1;
  1479. if (mod->volume>128) mod->volume=128;
  1481. return 0;
  1482. }
  1484. static int DoXMEffectH(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1485. {
  1486. UBYTE inf;
  1488. inf = UniGetByte();
  1490. if (tick) {
  1491. if (inf) mod->globalslide=inf;
  1492. else inf=mod->globalslide;
  1493. if (inf & 0xf0) inf&=0xf0;
  1494. mod->volume=mod->volume+((inf>>4)-(inf&0xf))*2;
  1496. if (mod->volume<0)
  1497. mod->volume=0;
  1498. else if (mod->volume>128)
  1499. mod->volume=128;
  1500. }
  1502. return 0;
  1503. }
  1505. static int DoXMEffectL(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1506. {
  1507. UBYTE dat;
  1509. dat=UniGetByte();
  1510. if ((!tick)&&(a->main.i)) {
  1511. UWORD points;
  1512. INSTRUMENT *i=a->main.i;
  1513. MP_VOICE *aout;
  1515. if ((aout=a->slave)) {
  1516. if (aout->venv.env) {
  1517. points=i->volenv[i->volpts-1].pos;
  1518. aout->venv.p=aout->venv.env[(dat>points)?points:dat].pos;
  1519. }
  1520. if (aout->penv.env) {
  1521. points=i->panenv[i->panpts-1].pos;
  1522. aout->penv.p=aout->penv.env[(dat>points)?points:dat].pos;
  1523. }
  1524. }
  1525. }
  1527. return 0;
  1528. }
  1530. static int DoXMEffectP(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1531. {
  1532. UBYTE inf, lo, hi;
  1533. SWORD pan;
  1535. inf = UniGetByte();
  1536. if (!mod->panflag)
  1537. return 0;
  1539. if (inf)
  1540. a->pansspd = inf;
  1541. else
  1542. inf =a->pansspd;
  1544. if (tick) {
  1545. lo=inf&0xf;
  1546. hi=inf>>4;
  1548. /* slide right has absolute priority */
  1549. if (hi)
  1550. lo = 0;
  1552. pan=((a->main.panning==PAN_SURROUND)?PAN_CENTER:a->main.panning)+hi-lo;
  1553. a->main.panning=(pan<PAN_LEFT)?PAN_LEFT:(pan>PAN_RIGHT?PAN_RIGHT:pan);
  1554. }
  1556. return 0;
  1557. }
  1559. static int DoXMEffectX1(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1560. {
  1561. UBYTE dat;
  1563. dat = UniGetByte();
  1564. if (dat)
  1565. a->ffportupspd = dat;
  1566. else
  1567. dat = a->ffportupspd;
  1569. if (a->main.period)
  1570. if (!tick) {
  1571. a->main.period-=dat;
  1572. a->tmpperiod-=dat;
  1573. a->ownper = 1;
  1574. }
  1576. return 0;
  1577. }
  1579. static int DoXMEffectX2(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1580. {
  1581. UBYTE dat;
  1583. dat = UniGetByte();
  1584. if (dat)
  1585. a->ffportdnspd=dat;
  1586. else
  1587. dat = a->ffportdnspd;
  1589. if (a->main.period)
  1590. if (!tick) {
  1591. a->main.period+=dat;
  1592. a->tmpperiod+=dat;
  1593. a->ownper = 1;
  1594. }
  1596. return 0;
  1597. }
  1599. /*========== Impulse Tracker effects */
  1601. static void DoITToneSlide(UWORD tick, MP_CONTROL *a, UBYTE dat)
  1602. {
  1603. if (dat)
  1604. a->portspeed = dat;
  1606. /* if we don't come from another note, ignore the slide and play the note
  1607.    as is */
  1608. if (!a->oldnote || !a->main.period)
  1609. return;
  1611. if ((!tick)&&(a->newsamp)){
  1612. a->main.kick=KICK_NOTE;
  1613. a->main.start=-1;
  1614. } else
  1615. a->main.kick=(a->main.kick==KICK_NOTE)?KICK_ENV:KICK_ABSENT;
  1617. if (tick) {
  1618. int dist;
  1620. /* We have to slide a->main.period towards a->wantedperiod, compute the
  1621.    difference between those two values */
  1622. dist=a->main.period-a->wantedperiod;
  1624.     /* if they are equal or if portamentospeed is too big... */
  1625. if ((!dist)||((a->portspeed<<2)>abs(dist)))
  1626. /* ... make tmpperiod equal tperiod */
  1627. a->tmpperiod=a->main.period=a->wantedperiod;
  1628. else
  1629.   if (dist>0) {
  1630. a->tmpperiod-=a->portspeed<<2;
  1631. a->main.period-=a->portspeed<<2; /* dist>0 slide up */
  1632. } else {
  1633. a->tmpperiod+=a->portspeed<<2;
  1634. a->main.period+=a->portspeed<<2; /* dist<0 slide down */
  1635. }
  1636. } else
  1637. a->tmpperiod=a->main.period;
  1638. a->ownper=1;
  1639. }
  1641. static int DoITEffectG(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1642. {
  1643. DoITToneSlide(tick, a, UniGetByte());
  1645. return 0;
  1646. }
  1648. static void DoITVibrato(UWORD tick, MP_CONTROL *a, UBYTE dat)
  1649. {
  1650. UBYTE q;
  1651. UWORD temp=0;
  1653. if (!tick) {
  1654. if (dat&0x0f) a->vibdepth=dat&0xf;
  1655. if (dat&0xf0) a->vibspd=(dat&0xf0)>>2;
  1656. }
  1657. if (!a->main.period)
  1658. return;
  1660. q=(a->vibpos>>2)&0x1f;
  1662. switch (a->wavecontrol&3) {
  1663. case 0: /* sine */
  1664. temp=VibratoTable[q];
  1665. break;
  1666. case 1: /* square wave */
  1667. temp=255;
  1668. break;
  1669. case 2: /* ramp down */
  1670. q<<=3;
  1671. if (a->vibpos<0) q=255-q;
  1672. temp=q;
  1673. break;
  1674. case 3: /* random */
  1675. temp=getrandom(256);
  1676. break;
  1677. }
  1679. temp*=a->vibdepth;
  1680. temp>>=8;
  1681. temp<<=2;
  1683. if (a->vibpos>=0)
  1684. a->main.period=a->tmpperiod+temp;
  1685. else
  1686. a->main.period=a->tmpperiod-temp;
  1687. a->ownper=1;
  1689. a->vibpos+=a->vibspd;
  1690. }
  1692. static int DoITEffectH(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1693. {
  1694. DoITVibrato(tick, a, UniGetByte());
  1696. return 0;
  1697. }
  1699. static int DoITEffectI(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1700. {
  1701. UBYTE inf, on, off;
  1703. inf = UniGetByte();
  1704. if (inf)
  1705. a->s3mtronof = inf;
  1706. else {
  1707. inf = a->s3mtronof;
  1708. if (!inf)
  1709. return 0;
  1710. }
  1712. on=(inf>>4);
  1713. off=(inf&0xf);
  1715. a->s3mtremor%=(on+off);
  1716. a->volume=(a->s3mtremor<on)?a->tmpvolume:0;
  1717. a->ownvol = 1;
  1718. a->s3mtremor++;
  1720. return 0;
  1721. }
  1723. static int DoITEffectM(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1724. {
  1725. a->main.chanvol=UniGetByte();
  1726. if (a->main.chanvol>64)
  1727. a->main.chanvol=64;
  1728. else if (a->main.chanvol<0)
  1729. a->main.chanvol=0;
  1731. return 0;
  1732. }
  1734. static int DoITEffectN(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1735. {
  1736. UBYTE inf, lo, hi;
  1738. inf = UniGetByte();
  1740. if (inf)
  1741. a->chanvolslide = inf;
  1742. else
  1743. inf = a->chanvolslide;
  1745. lo=inf&0xf;
  1746. hi=inf>>4;
  1748. if (!hi) 
  1749. a->main.chanvol-=lo;
  1750. else
  1751.   if (!lo) {
  1752. a->main.chanvol+=hi;
  1753. } else
  1754.   if (hi==0xf) {
  1755. if (!tick) a->main.chanvol-=lo;
  1756. } else
  1757.   if (lo==0xf) {
  1758. if (!tick) a->main.chanvol+=hi;
  1759. }
  1761. if (a->main.chanvol<0)
  1762. a->main.chanvol=0;
  1763. else if (a->main.chanvol>64)
  1764. a->main.chanvol=64;
  1766. return 0;
  1767. }
  1769. static int DoITEffectP(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1770. {
  1771. UBYTE inf, lo, hi;
  1772. SWORD pan;
  1774. inf = UniGetByte();
  1775. if (inf)
  1776. a->pansspd = inf;
  1777. else
  1778. inf = a->pansspd;
  1780. if (!mod->panflag)
  1781. return 0;
  1783. lo=inf&0xf;
  1784. hi=inf>>4;
  1786. pan=(a->main.panning==PAN_SURROUND)?PAN_CENTER:a->main.panning;
  1788. if (!hi)
  1789. pan+=lo<<2;
  1790. else
  1791.   if (!lo) {
  1792. pan-=hi<<2;
  1793. } else
  1794.   if (hi==0xf) {
  1795. if (!tick) pan+=lo<<2;
  1796. } else
  1797.   if (lo==0xf) {
  1798. if (!tick) pan-=hi<<2;
  1799. }
  1800. a->main.panning=
  1801.   (pan<PAN_LEFT)?PAN_LEFT:(pan>PAN_RIGHT?PAN_RIGHT:pan);
  1803. return 0;
  1804. }
  1806. static int DoITEffectT(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1807. {
  1808. UBYTE tempo;
  1809. SWORD temp;
  1811.     tempo = UniGetByte();
  1813. if (mod->patdly2)
  1814. return 0;
  1816. temp = mod->bpm;
  1817. if (tempo & 0x10)
  1818. temp += (tempo & 0x0f);
  1819. else
  1820. temp -= tempo;
  1822. mod->bpm=(temp>255)?255:(temp<1?1:temp);
  1824. return 0;
  1825. }
  1827. static int DoITEffectU(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1828. {
  1829. UBYTE dat, q;
  1830. UWORD temp = 0; /* silence warning */
  1832. dat = UniGetByte();
  1833. if (!tick) {
  1834. if (dat&0x0f) a->vibdepth=dat&0xf;
  1835. if (dat&0xf0) a->vibspd=(dat&0xf0)>>2;
  1836. }
  1837. if (a->main.period) {
  1838. q=(a->vibpos>>2)&0x1f;
  1840. switch (a->wavecontrol&3) {
  1841. case 0: /* sine */
  1842. temp=VibratoTable[q];
  1843. break;
  1844. case 1: /* square wave */
  1845. temp=255;
  1846. break;
  1847. case 2: /* ramp down */
  1848. q<<=3;
  1849. if (a->vibpos<0) q=255-q;
  1850. temp=q;
  1851. break;
  1852. case 3: /* random */
  1853. temp=getrandom(256);
  1854. break;
  1855. }
  1857. temp*=a->vibdepth;
  1858. temp>>=8;
  1860. if (a->vibpos>=0)
  1861. a->main.period=a->tmpperiod+temp;
  1862. else
  1863. a->main.period=a->tmpperiod-temp;
  1864. a->ownper = 1;
  1866. a->vibpos+=a->vibspd;
  1867. }
  1869. return 0;
  1870. }
  1872. static int DoITEffectW(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1873. {
  1874. UBYTE inf, lo, hi;
  1876. inf = UniGetByte();
  1878. if (inf)
  1879. mod->globalslide = inf;
  1880. else
  1881. inf = mod->globalslide;
  1883. lo=inf&0xf;
  1884. hi=inf>>4;
  1886. if (!lo) {
  1887. if (tick) mod->volume+=hi;
  1888. } else
  1889.   if (!hi) {
  1890. if (tick) mod->volume-=lo;
  1891. } else
  1892.   if (lo==0xf) {
  1893. if (!tick) mod->volume+=hi;
  1894. } else
  1895.   if (hi==0xf) {
  1896. if (!tick) mod->volume-=lo;
  1897. }
  1899. if (mod->volume<0)
  1900. mod->volume=0;
  1901. else if (mod->volume>128)
  1902. mod->volume=128;
  1904. return 0;
  1905. }
  1907. static int DoITEffectY(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1908. {
  1909. UBYTE dat, q;
  1910. SLONG temp = 0; /* silence warning */
  1913. dat=UniGetByte();
  1914. if (!tick) {
  1915. if (dat&0x0f) a->panbdepth=(dat&0xf);
  1916. if (dat&0xf0) a->panbspd=(dat&0xf0)>>4;
  1917. }
  1918. if (mod->panflag) {
  1919. q=a->panbpos;
  1921. switch (a->panbwave) {
  1922. case 0: /* sine */
  1923. temp=PanbrelloTable[q];
  1924. break;
  1925. case 1: /* square wave */
  1926. temp=(q<0x80)?64:0;
  1927. break;
  1928. case 2: /* ramp down */
  1929. q<<=3;
  1930. temp=q;
  1931. break;
  1932. case 3: /* random */
  1933. temp=getrandom(256);
  1934. break;
  1935. }
  1937. temp*=a->panbdepth;
  1938. temp=(temp/8)+mod->panning[channel];
  1940. a->main.panning=
  1941. (temp<PAN_LEFT)?PAN_LEFT:(temp>PAN_RIGHT?PAN_RIGHT:temp);
  1942. a->panbpos+=a->panbspd;
  1944. }
  1946. return 0;
  1947. }
  1949. static void DoNNAEffects(MODULE *, MP_CONTROL *, UBYTE);
  1951. /* Impulse/Scream Tracker Sxx effects.
  1952.    All Sxx effects share the same memory space. */
  1953. static int DoITEffectS0(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  1954. {
  1955. UBYTE dat, inf, c;
  1957. dat = UniGetByte();
  1958. inf=dat&0xf;
  1959. c=dat>>4;
  1961. if (!dat) {
  1962. c=a->sseffect;
  1963. inf=a->ssdata;
  1964. } else {
  1965. a->sseffect=c;
  1966. a->ssdata=inf;
  1967. }
  1969. switch (c) {
  1970. case SS_GLISSANDO: /* S1x set glissando voice */
  1971. DoEEffects(tick, flags, a, mod, channel, 0x30|inf);
  1972. break;              
  1973. case SS_FINETUNE: /* S2x set finetune */
  1974. DoEEffects(tick, flags, a, mod, channel, 0x50|inf);
  1975. break;
  1976. case SS_VIBWAVE: /* S3x set vibrato waveform */
  1977. DoEEffects(tick, flags, a, mod, channel, 0x40|inf);
  1978. break;   
  1979. case SS_TREMWAVE: /* S4x set tremolo waveform */
  1980. DoEEffects(tick, flags, a, mod, channel, 0x70|inf);
  1981. break;
  1982. case SS_PANWAVE: /* S5x panbrello */
  1983. a->panbwave=inf;
  1984. break;
  1985. case SS_FRAMEDELAY: /* S6x delay x number of frames (patdly) */
  1986. DoEEffects(tick, flags, a, mod, channel, 0xe0|inf);
  1987. break;
  1988. case SS_S7EFFECTS: /* S7x instrument / NNA commands */
  1989. DoNNAEffects(mod, a, inf);
  1990. break;
  1991. case SS_PANNING: /* S8x set panning position */
  1992. DoEEffects(tick, flags, a, mod, channel, 0x80 | inf);
  1993. break;
  1994. case SS_SURROUND: /* S9x set surround sound */
  1995. if (mod->panflag)
  1996. a->main.panning = mod->panning[channel] = PAN_SURROUND;
  1997. break;    
  1998. case SS_HIOFFSET: /* SAy set high order sample offset yxx00h */
  1999. if (!tick) {
  2000. a->hioffset=inf<<16;
  2001. a->main.start=a->hioffset|a->soffset;
  2003. if ((a->main.s)&&(a->main.start>a->main.s->length))
  2004. a->main.start=a->main.s->flags&(SF_LOOP|SF_BIDI)?
  2005.     a->main.s->loopstart:a->main.s->length;
  2006. }
  2007. break;
  2008. case SS_PATLOOP: /* SBx pattern loop */
  2009. DoEEffects(tick, flags, a, mod, channel, 0x60|inf);
  2010. break;
  2011. case SS_NOTECUT: /* SCx notecut */
  2012. if (!inf) inf = 1;
  2013. DoEEffects(tick, flags, a, mod, channel, 0xC0|inf);
  2014. break;
  2015. case SS_NOTEDELAY: /* SDx notedelay */
  2016. DoEEffects(tick, flags, a, mod, channel, 0xD0|inf);
  2017. break;
  2018. case SS_PATDELAY: /* SEx patterndelay */
  2019. DoEEffects(tick, flags, a, mod, channel, 0xE0|inf);
  2020. break;
  2021. }
  2023. return 0;
  2024. }
  2026. /*========== Impulse Tracker Volume/Pan Column effects */
  2028. /*
  2029.  * All volume/pan column effects share the same memory space.
  2030.  */
  2032. static int DoVolEffects(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  2033. {
  2034. UBYTE c, inf;
  2036. c = UniGetByte(); 
  2037. inf = UniGetByte(); 
  2039. if ((!c)&&(!inf)) {
  2040. c=a->voleffect;
  2041. inf=a->voldata;
  2042. } else {
  2043. a->voleffect=c;
  2044. a->voldata=inf;
  2045. }
  2047. if (c)
  2048. switch (c) {
  2049. case VOL_VOLUME:
  2050. if (tick) break;
  2051. if (inf>64) inf=64;
  2052. a->tmpvolume=inf;
  2053. break;
  2054. case VOL_PANNING:
  2055. if (mod->panflag)
  2056. a->main.panning=inf;
  2057. break;
  2058. case VOL_VOLSLIDE:
  2059. DoS3MVolSlide(tick, flags, a, inf);
  2060. return 1;
  2061. case VOL_PITCHSLIDEDN:
  2062. if (a->main.period)
  2063. DoS3MSlideDn(tick, a, inf);
  2064. break;
  2065. case VOL_PITCHSLIDEUP:
  2066. if (a->main.period)
  2067. DoS3MSlideUp(tick, a, inf);
  2068. break;
  2069. case VOL_PORTAMENTO:
  2070. DoITToneSlide(tick, a, inf);
  2071. break;
  2072. case VOL_VIBRATO:
  2073. DoITVibrato(tick, a, inf);
  2074. break;
  2075. }
  2077. return 0;
  2078. }
  2080. /*========== UltraTracker effects */
  2082. static int DoULTEffect9(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  2083. {
  2084. UWORD offset=UniGetWord();
  2086. if (offset)
  2087. a->ultoffset=offset;
  2089. a->main.start=a->ultoffset<<2;
  2090. if ((a->main.s)&&(a->main.start>a->main.s->length))
  2091. a->main.start=a->main.s->flags&(SF_LOOP|SF_BIDI)?
  2092.     a->main.s->loopstart:a->main.s->length;
  2094. return 0;
  2095. }
  2097. /*========== OctaMED effects */
  2099. static int DoMEDSpeed(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  2100. {
  2101. UWORD speed=UniGetWord();
  2103. mod->bpm=speed;
  2105. return 0;
  2106. }
  2108. static int DoMEDEffectF1(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  2109. {
  2110. DoEEffects(tick, flags, a, mod, channel, 0x90|(mod->sngspd/2));
  2112. return 0;
  2113. }
  2115. static int DoMEDEffectF2(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  2116. {
  2117. DoEEffects(tick, flags, a, mod, channel, 0xd0|(mod->sngspd/2));
  2119. return 0;
  2120. }
  2122. static int DoMEDEffectF3(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  2123. {
  2124. DoEEffects(tick, flags, a, mod, channel, 0x90|(mod->sngspd/3));
  2126. return 0;
  2127. }
  2129. /*========== Oktalyzer effects */
  2131. static int DoOktArp(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  2132. {
  2133. UBYTE dat, dat2;
  2135. dat2 = UniGetByte(); /* arpeggio style */
  2136. dat = UniGetByte();
  2137. if (!tick) {
  2138. if (!dat && (flags & UF_ARPMEM))
  2139. dat=a->arpmem;
  2140. else
  2141. a->arpmem=dat;
  2142. }
  2143. if (a->main.period)
  2144. DoArpeggio(tick, flags, a, dat2);
  2146. return 0;
  2147. }
  2149. /*========== General player functions */
  2151. static int DoNothing(UWORD tick, UWORD flags, MP_CONTROL *a, MODULE *mod, SWORD channel)
  2152. {
  2153. UniSkipOpcode();
  2155. return 0;
  2156. }
  2158. typedef int (*effect_func) (UWORD, UWORD, MP_CONTROL *, MODULE *, SWORD);
  2160. static effect_func effects[UNI_LAST] = {
  2161. DoNothing, /* 0 */
  2162. DoNothing, /* UNI_NOTE */
  2163. DoNothing, /* UNI_INSTRUMENT */
  2164. DoPTEffect0, /* UNI_PTEFFECT0 */
  2165. DoPTEffect1, /* UNI_PTEFFECT1 */
  2166. DoPTEffect2, /* UNI_PTEFFECT2 */
  2167. DoPTEffect3, /* UNI_PTEFFECT3 */
  2168. DoPTEffect4, /* UNI_PTEFFECT4 */
  2169. DoPTEffect5, /* UNI_PTEFFECT5 */
  2170. DoPTEffect6, /* UNI_PTEFFECT6 */
  2171. DoPTEffect7, /* UNI_PTEFFECT7 */
  2172. DoPTEffect8, /* UNI_PTEFFECT8 */
  2173. DoPTEffect9, /* UNI_PTEFFECT9 */
  2174. DoPTEffectA, /* UNI_PTEFFECTA */
  2175. DoPTEffectB, /* UNI_PTEFFECTB */
  2176. DoPTEffectC, /* UNI_PTEFFECTC */
  2177. DoPTEffectD, /* UNI_PTEFFECTD */
  2178. DoPTEffectE, /* UNI_PTEFFECTE */
  2179. DoPTEffectF, /* UNI_PTEFFECTF */
  2180. DoS3MEffectA, /* UNI_S3MEFFECTA */
  2181. DoS3MEffectD, /* UNI_S3MEFFECTD */
  2182. DoS3MEffectE, /* UNI_S3MEFFECTE */
  2183. DoS3MEffectF, /* UNI_S3MEFFECTF */
  2184. DoS3MEffectI, /* UNI_S3MEFFECTI */
  2185. DoS3MEffectQ, /* UNI_S3MEFFECTQ */
  2186. DoS3MEffectR, /* UNI_S3MEFFECTR */
  2187. DoS3MEffectT, /* UNI_S3MEFFECTT */
  2188. DoS3MEffectU, /* UNI_S3MEFFECTU */
  2189. DoKeyOff, /* UNI_KEYOFF */
  2190. DoKeyFade, /* UNI_KEYFADE */
  2191. DoVolEffects, /* UNI_VOLEFFECTS */
  2192. DoPTEffect4, /* UNI_XMEFFECT4 */
  2193. DoXMEffect6, /* UNI_XMEFFECT6 */
  2194. DoXMEffectA, /* UNI_XMEFFECTA */
  2195. DoXMEffectE1, /* UNI_XMEFFECTE1 */
  2196. DoXMEffectE2, /* UNI_XMEFFECTE2 */
  2197. DoXMEffectEA, /* UNI_XMEFFECTEA */
  2198. DoXMEffectEB, /* UNI_XMEFFECTEB */
  2199. DoXMEffectG, /* UNI_XMEFFECTG */
  2200. DoXMEffectH, /* UNI_XMEFFECTH */
  2201. DoXMEffectL, /* UNI_XMEFFECTL */
  2202. DoXMEffectP, /* UNI_XMEFFECTP */
  2203. DoXMEffectX1, /* UNI_XMEFFECTX1 */
  2204. DoXMEffectX2, /* UNI_XMEFFECTX2 */
  2205. DoITEffectG, /* UNI_ITEFFECTG */
  2206. DoITEffectH, /* UNI_ITEFFECTH */
  2207. DoITEffectI, /* UNI_ITEFFECTI */
  2208. DoITEffectM, /* UNI_ITEFFECTM */
  2209. DoITEffectN, /* UNI_ITEFFECTN */
  2210. DoITEffectP, /* UNI_ITEFFECTP */
  2211. DoITEffectT, /* UNI_ITEFFECTT */
  2212. DoITEffectU, /* UNI_ITEFFECTU */
  2213. DoITEffectW, /* UNI_ITEFFECTW */
  2214. DoITEffectY, /* UNI_ITEFFECTY */
  2215. DoNothing, /* UNI_ITEFFECTZ */
  2216. DoITEffectS0, /* UNI_ITEFFECTS0 */
  2217. DoULTEffect9, /* UNI_ULTEFFECT9 */
  2218. DoMEDSpeed, /* UNI_MEDSPEED */
  2219. DoMEDEffectF1, /* UNI_MEDEFFECTF1 */
  2220. DoMEDEffectF2, /* UNI_MEDEFFECTF2 */
  2221. DoMEDEffectF3, /* UNI_MEDEFFECTF3 */
  2222. DoOktArp, /* UNI_OKTARP */
  2223. };
  2225. static int pt_playeffects(MODULE *mod, SWORD channel, MP_CONTROL *a)
  2226. {
  2227. UWORD tick = mod->vbtick;
  2228. UWORD flags = mod->flags;
  2229. UBYTE c;
  2230. int explicitslides = 0;
  2231. effect_func f;
  2233. while((c=UniGetByte())) {
  2234. f = effects[c];
  2235. if (f != DoNothing)
  2236. a->sliding = 0;
  2237. explicitslides |= f(tick, flags, a, mod, channel);
  2238. }
  2239. return explicitslides;
  2240. }
  2242. static void DoNNAEffects(MODULE *mod, MP_CONTROL *a, UBYTE dat)
  2243. {
  2244. int t;
  2245. MP_VOICE *aout;
  2247. dat&=0xf; 
  2248. aout=(a->slave)?a->slave:NULL;
  2250. switch (dat) {
  2251. case 0x0: /* past note cut */
  2252. for (t=0;t<md_sngchn;t++)
  2253. if (mod->voice[t].master==a)
  2254. mod->voice[t].main.fadevol=0;
  2255. break;
  2256. case 0x1: /* past note off */
  2257. for (t=0;t<md_sngchn;t++)
  2258. if (mod->voice[t].master==a) {
  2259. mod->voice[t].main.keyoff|=KEY_OFF;
  2260. if ((!(mod->voice[t].venv.flg & EF_ON))||
  2261.    (mod->voice[t].venv.flg & EF_LOOP))
  2262. mod->voice[t].main.keyoff=KEY_KILL;
  2263. }
  2264. break;
  2265. case 0x2: /* past note fade */
  2266. for (t=0;t<md_sngchn;t++)
  2267. if (mod->voice[t].master==a)
  2268. mod->voice[t].main.keyoff|=KEY_FADE;
  2269. break;
  2270. case 0x3: /* set NNA note cut */
  2271. a->main.nna=(a->main.nna&~NNA_MASK)|NNA_CUT;
  2272. break;
  2273. case 0x4: /* set NNA note continue */
  2274. a->main.nna=(a->main.nna&~NNA_MASK)|NNA_CONTINUE;
  2275. break;
  2276. case 0x5: /* set NNA note off */
  2277. a->main.nna=(a->main.nna&~NNA_MASK)|NNA_OFF;
  2278. break;   
  2279. case 0x6: /* set NNA note fade */
  2280. a->main.nna=(a->main.nna&~NNA_MASK)|NNA_FADE;
  2281. break;
  2282. case 0x7: /* disable volume envelope */
  2283. if (aout)
  2284. aout->main.volflg&=~EF_ON;
  2285. break;
  2286. case 0x8: /* enable volume envelope  */
  2287. if (aout)
  2288. aout->main.volflg|=EF_ON;
  2289. break;
  2290. case 0x9: /* disable panning envelope */
  2291. if (aout)
  2292. aout->main.panflg&=~EF_ON;
  2293. break;    
  2294. case 0xa: /* enable panning envelope */
  2295. if (aout)
  2296. aout->main.panflg|=EF_ON;
  2297. break;
  2298. case 0xb: /* disable pitch envelope */
  2299. if (aout)
  2300. aout->main.pitflg&=~EF_ON;
  2301. break;
  2302. case 0xc: /* enable pitch envelope */
  2303. if (aout)
  2304. aout->main.pitflg|=EF_ON;
  2305. break;
  2306. }
  2307. }
  2309. void pt_UpdateVoices(MODULE *mod, int max_volume)
  2310. {
  2311. SWORD envpan,envvol,envpit,channel;
  2312. UWORD playperiod;
  2313. SLONG vibval,vibdpt;
  2314. ULONG tmpvol;
  2316. MP_VOICE *aout;
  2317. INSTRUMENT *i;
  2318. SAMPLE *s;
  2320. mod->totalchn=mod->realchn=0;
  2321. for (channel=0;channel<md_sngchn;channel++) {
  2322. aout=&mod->voice[channel];
  2323. i=aout->main.i;
  2324. s=aout->main.s;
  2326. if (!s || !s->length) continue;
  2328. if (aout->main.period<40)
  2329. aout->main.period=40;
  2330. else if (aout->main.period>50000)
  2331. aout->main.period=50000;
  2333. if ((aout->main.kick==KICK_NOTE)||(aout->main.kick==KICK_KEYOFF)) {
  2334. Voice_Play_internal(channel,s,(aout->main.start==-1)?
  2335.     ((s->flags&SF_UST_LOOP)?s->loopstart:0):aout->main.start);
  2336. aout->main.fadevol=32768;
  2337. aout->aswppos=0;
  2338. }
  2340. envvol = 256;
  2341. envpan = PAN_CENTER;
  2342. envpit = 32;
  2343. if (i && ((aout->main.kick==KICK_NOTE)||(aout->main.kick==KICK_ENV))) {
  2344. if (aout->main.volflg & EF_ON)
  2345. envvol = StartEnvelope(&aout->venv,aout->main.volflg,
  2346.   i->volpts,i->volsusbeg,i->volsusend,
  2347.   i->volbeg,i->volend,i->volenv,aout->main.keyoff);
  2348. if (aout->main.panflg & EF_ON)
  2349. envpan = StartEnvelope(&aout->penv,aout->main.panflg,
  2350.   i->panpts,i->pansusbeg,i->pansusend,
  2351.   i->panbeg,i->panend,i->panenv,aout->main.keyoff);
  2352. if (aout->main.pitflg & EF_ON)
  2353. envpit = StartEnvelope(&aout->cenv,aout->main.pitflg,
  2354.   i->pitpts,i->pitsusbeg,i->pitsusend,
  2355.   i->pitbeg,i->pitend,i->pitenv,aout->main.keyoff);
  2357. if (aout->cenv.flg & EF_ON)
  2358. aout->masterperiod=GetPeriod(mod->flags,
  2359.   (UWORD)aout->main.note<<1, aout->master->speed);
  2360. } else {
  2361. if (aout->main.volflg & EF_ON)
  2362. envvol = ProcessEnvelope(aout,&aout->venv,256);
  2363. if (aout->main.panflg & EF_ON)
  2364. envpan = ProcessEnvelope(aout,&aout->penv,PAN_CENTER);
  2365. if (aout->main.pitflg & EF_ON)
  2366. envpit = ProcessEnvelope(aout,&aout->cenv,32);
  2367. }
  2368. if (aout->main.kick == KICK_NOTE) {
  2369. aout->main.kick_flag = 1;
  2370. }
  2371. aout->main.kick=KICK_ABSENT;
  2373. tmpvol = aout->main.fadevol; /* max 32768 */
  2374. tmpvol *= aout->main.chanvol; /* * max 64 */
  2375. tmpvol *= aout->main.outvolume; /* * max 256 */
  2376. tmpvol /= (256 * 64); /* tmpvol is max 32768 again */
  2377. aout->totalvol = tmpvol >> 2; /* used to determine samplevolume */
  2378. tmpvol *= envvol; /* * max 256 */
  2379. tmpvol *= mod->volume; /* * max 128 */
  2380. tmpvol /= (128 * 256 * 128);
  2382. /* fade out */
  2383. if (mod->sngpos>=mod->numpos)
  2384. tmpvol=0;
  2385. else
  2386. tmpvol=(tmpvol*max_volume)/128;
  2388. if ((aout->masterchn!=-1)&& mod->control[aout->masterchn].muted)
  2389. Voice_SetVolume_internal(channel,0);
  2390. else {
  2391. Voice_SetVolume_internal(channel,tmpvol);
  2392. if ((tmpvol)&&(aout->master)&&(aout->master->slave==aout))
  2393. mod->realchn++;
  2394. mod->totalchn++;
  2395. }
  2397. if (aout->main.panning==PAN_SURROUND)
  2398. Voice_SetPanning_internal(channel,PAN_SURROUND);
  2399. else
  2400. if ((mod->panflag)&&(aout->penv.flg & EF_ON))
  2401. Voice_SetPanning_internal(channel,
  2402.     DoPan(envpan,aout->main.panning));
  2403. else
  2404. Voice_SetPanning_internal(channel,aout->main.panning);
  2406. if (aout->main.period && s->vibdepth)
  2407. switch (s->vibtype) {
  2408. case 0:
  2409. vibval=avibtab[s->avibpos&127];
  2410. if (aout->avibpos & 0x80) vibval=-vibval;
  2411. break;
  2412. case 1:
  2413. vibval=64;
  2414. if (aout->avibpos & 0x80) vibval=-vibval;
  2415. break;
  2416. case 2:
  2417. vibval=63-(((aout->avibpos+128)&255)>>1);
  2418. break;
  2419. default:
  2420. vibval=(((aout->avibpos+128)&255)>>1)-64;
  2421. break;
  2422. }
  2423. else
  2424. vibval=0;
  2426. if (s->vibflags & AV_IT) {
  2427. if ((aout->aswppos>>8)<s->vibdepth) {
  2428. aout->aswppos += s->vibsweep;
  2429. vibdpt=aout->aswppos;
  2430. } else
  2431. vibdpt=s->vibdepth<<8;
  2432. vibval=(vibval*vibdpt)>>16;
  2433. if (aout->mflag) {
  2434. if (!(mod->flags&UF_LINEAR)) vibval>>=1;
  2435. aout->main.period-=vibval;
  2436. }
  2437. } else {
  2438. /* do XM style auto-vibrato */
  2439. if (!(aout->main.keyoff & KEY_OFF)) {
  2440. if (aout->aswppos<s->vibsweep) {
  2441. vibdpt=(aout->aswppos*s->vibdepth)/s->vibsweep;
  2442. aout->aswppos++;
  2443. } else
  2444. vibdpt=s->vibdepth;
  2445. } else {
  2446. /* keyoff -> depth becomes 0 if final depth wasn't reached or
  2447.    stays at final level if depth WAS reached */
  2448. if (aout->aswppos>=s->vibsweep)
  2449. vibdpt=s->vibdepth;
  2450. else
  2451. vibdpt=0;
  2452. }
  2453. vibval=(vibval*vibdpt)>>8;
  2454. aout->main.period-=vibval;
  2455. }
  2457. /* update vibrato position */
  2458. aout->avibpos=(aout->avibpos+s->vibrate)&0xff;
  2460. /* process pitch envelope */
  2461. playperiod=aout->main.period;
  2463. if ((aout->main.pitflg&EF_ON)&&(envpit!=32)) {
  2464. long p1;
  2466. envpit-=32;
  2467. if ((aout->main.note<<1)+envpit<=0) envpit=-(aout->main.note<<1);
  2469. p1=GetPeriod(mod->flags, ((UWORD)aout->main.note<<1)+envpit,
  2470.     aout->master->speed)-aout->masterperiod;
  2471. if (p1>0) {
  2472. if ((UWORD)(playperiod+p1)<=playperiod) {
  2473. p1=0;
  2474. aout->main.keyoff|=KEY_OFF;
  2475. }
  2476. } else if (p1<0) {
  2477. if ((UWORD)(playperiod+p1)>=playperiod) {
  2478. p1=0;
  2479. aout->main.keyoff|=KEY_OFF;
  2480. }
  2481. }
  2482. playperiod+=p1;
  2483. }
  2485. if (!aout->main.fadevol) { /* check for a dead note (fadevol=0) */
  2486. Voice_Stop_internal(channel);
  2487. mod->totalchn--;
  2488. if ((tmpvol)&&(aout->master)&&(aout->master->slave==aout))
  2489. mod->realchn--;
  2490. } else {
  2491. Voice_SetFrequency_internal(channel,
  2492.                             getfrequency(mod->flags,playperiod));
  2494. /* if keyfade, start substracting fadeoutspeed from fadevol: */
  2495. if ((i)&&(aout->main.keyoff&KEY_FADE)) {
  2496. if (aout->main.fadevol>=i->volfade)
  2497. aout->main.fadevol-=i->volfade;
  2498. else
  2499. aout->main.fadevol=0;
  2500. }
  2501. }
  2503. md_bpm=mod->bpm+mod->relspd;
  2504. if (md_bpm<32)
  2505. md_bpm=32;
  2506. else if ((!(mod->flags&UF_HIGHBPM)) && md_bpm>255)
  2507. md_bpm=255;
  2508. }
  2509. }
  2511. /* Handles new notes or instruments */
  2512. void pt_Notes(MODULE *mod)
  2513. {
  2514. SWORD channel;
  2515. MP_CONTROL *a;
  2516. UBYTE c,inst;
  2517. int tr,funky; /* funky is set to indicate note or instrument change */
  2519. for (channel=0;channel<mod->numchn;channel++) {
  2520. a=&mod->control[channel];
  2522. if (mod->sngpos>=mod->numpos) {
  2523. tr=mod->numtrk;
  2524. mod->numrow=0;
  2525. } else {
  2526. tr=mod->patterns[(mod->positions[mod->sngpos]*mod->numchn)+channel];
  2527. mod->numrow=mod->pattrows[mod->positions[mod->sngpos]];
  2528. }
  2530. a->row=(tr<mod->numtrk)?UniFindRow(mod->tracks[tr],mod->patpos):NULL;
  2531. a->newsamp=0;
  2532. if (!mod->vbtick) a->main.notedelay=0;
  2534. if (!a->row) continue;
  2535. UniSetRow(a->row);
  2536. funky=0;
  2538. while((c=UniGetByte()))
  2539. switch (c) {
  2540. case UNI_NOTE:
  2541. funky|=1;
  2542. a->oldnote=a->anote,a->anote=UniGetByte();
  2543. a->main.kick =KICK_NOTE;
  2544. a->main.start=-1;
  2545. a->sliding=0;
  2547. /* retrig tremolo and vibrato waves ? */
  2548. if (!(a->wavecontrol & 0x80)) a->trmpos=0;
  2549. if (!(a->wavecontrol & 0x08)) a->vibpos=0;
  2550. if (!a->panbwave) a->panbpos=0;
  2551. break;
  2552. case UNI_INSTRUMENT:
  2553. inst=UniGetByte();
  2554. if (inst>=mod->numins) break; /* safety valve */
  2555. funky|=2;
  2556. a->main.i=(mod->flags & UF_INST)?&mod->instruments[inst]:NULL;
  2557. a->retrig=0;
  2558. a->s3mtremor=0;
  2559. a->ultoffset=0;
  2560. a->main.sample=inst;
  2561. break;
  2562. default:
  2563. UniSkipOpcode();
  2564. break;
  2565. }
  2567. if (funky) {
  2568. INSTRUMENT *i;
  2569. SAMPLE *s;
  2571. if ((i=a->main.i)) {
  2572. if (i->samplenumber[a->anote] >= mod->numsmp) continue;
  2573. s=&mod->samples[i->samplenumber[a->anote]];
  2574. a->main.note=i->samplenote[a->anote];
  2575. } else {
  2576. a->main.note=a->anote;
  2577. s=&mod->samples[a->main.sample];
  2578. }
  2580. if (a->main.s!=s) {
  2581. a->main.s=s;
  2582. a->newsamp=a->main.period;
  2583. }
  2585. /* channel or instrument determined panning ? */
  2586. a->main.panning=mod->panning[channel];
  2587. if (s->flags & SF_OWNPAN)
  2588. a->main.panning=s->panning;
  2589. else if ((i)&&(i->flags & IF_OWNPAN))
  2590. a->main.panning=i->panning;
  2592. a->main.handle=s->handle;
  2593. a->speed=s->speed;
  2595. if (i) {
  2596. if ((mod->panflag)&&(i->flags & IF_PITCHPAN)
  2597.    &&(a->main.panning!=PAN_SURROUND)){
  2598. a->main.panning+=
  2599.     ((a->anote-i->pitpancenter)*i->pitpansep)/8;
  2600. if (a->main.panning<PAN_LEFT)
  2601. a->main.panning=PAN_LEFT;
  2602. else if (a->main.panning>PAN_RIGHT)
  2603. a->main.panning=PAN_RIGHT;
  2604. }
  2605. a->main.pitflg=i->pitflg;
  2606. a->main.volflg=i->volflg;
  2607. a->main.panflg=i->panflg;
  2608. a->main.nna=i->nnatype;
  2609. a->dca=i->dca;
  2610. a->dct=i->dct;
  2611. } else {
  2612. a->main.pitflg=a->main.volflg=a->main.panflg=0;
  2613. a->main.nna=a->dca=0;
  2614. a->dct=DCT_OFF;
  2615. }
  2617. if (funky&2) /* instrument change */ {
  2618. /* IT random volume variations: 0:8 bit fixed, and one bit for
  2619.    sign. */
  2620. a->volume=a->tmpvolume=s->volume;
  2621. if ((s)&&(i)) {
  2622. if (i->rvolvar) {
  2623. a->volume=a->tmpvolume=s->volume+
  2624.   ((s->volume*((SLONG)i->rvolvar*(SLONG)getrandom(512)
  2625.   ))/25600);
  2626. if (a->volume<0)
  2627. a->volume=a->tmpvolume=0;
  2628. else if (a->volume>64)
  2629. a->volume=a->tmpvolume=64;
  2630. }
  2631. if ((mod->panflag)&&(a->main.panning!=PAN_SURROUND)) {
  2632. a->main.panning+=((a->main.panning*((SLONG)i->rpanvar*
  2633.   (SLONG)getrandom(512)))/25600);
  2634. if (a->main.panning<PAN_LEFT)
  2635. a->main.panning=PAN_LEFT;
  2636. else if (a->main.panning>PAN_RIGHT)
  2637. a->main.panning=PAN_RIGHT;
  2638. }
  2639. }
  2640. }
  2642. a->wantedperiod=a->tmpperiod=
  2643.     GetPeriod(mod->flags, (UWORD)a->main.note<<1,a->speed);
  2644. a->main.keyoff=KEY_KICK;
  2645. }
  2646. }
  2647. }
  2649. /* Handles effects */
  2650. void pt_EffectsPass1(MODULE *mod)
  2651. {
  2652. SWORD channel;
  2653. MP_CONTROL *a;
  2654. MP_VOICE *aout;
  2655. int explicitslides;
  2657. for (channel=0;channel<mod->numchn;channel++) {
  2658. a=&mod->control[channel];
  2660. if ((aout=a->slave)) {
  2661. a->main.fadevol=aout->main.fadevol;
  2662. a->main.period=aout->main.period;
  2663. if (a->main.kick==KICK_KEYOFF)
  2664. a->main.keyoff=aout->main.keyoff;
  2665. }
  2667. if (!a->row) continue;
  2668. UniSetRow(a->row);
  2670. a->ownper=a->ownvol=0;
  2671. explicitslides = pt_playeffects(mod, channel, a);
  2673. /* continue volume slide if necessary for XM and IT */
  2674. if (mod->flags&UF_BGSLIDES) {
  2675. if (!explicitslides && a->sliding)
  2676. DoS3MVolSlide(mod->vbtick, mod->flags, a, 0);
  2677. else if (a->tmpvolume)
  2678. a->sliding = explicitslides;
  2679. }
  2681. if (!a->ownper)
  2682. a->main.period=a->tmpperiod;
  2683. if (!a->ownvol)
  2684. a->volume=a->tmpvolume;
  2686. if (a->main.s) {
  2687. if (a->main.i)
  2688. a->main.outvolume=
  2689.     (a->volume*a->main.s->globvol*a->main.i->globvol)>>10;
  2690. else
  2691. a->main.outvolume=(a->volume*a->main.s->globvol)>>4;
  2692. if (a->main.outvolume>256)
  2693. a->main.outvolume=256;
  2694. else if (a->main.outvolume<0)
  2695. a->main.outvolume=0;
  2696. }
  2697. }
  2698. }
  2700. /* NNA management */
  2701. void pt_NNA(MODULE *mod)
  2702. {
  2703. SWORD channel;
  2704. MP_CONTROL *a;
  2706. for (channel=0;channel<mod->numchn;channel++) {
  2707. a=&mod->control[channel];
  2709. if (a->main.kick==KICK_NOTE) {
  2710. BOOL kill=0;
  2712. if (a->slave) {
  2713. MP_VOICE *aout;
  2715. aout=a->slave;
  2716. if (aout->main.nna & NNA_MASK) {
  2717. /* Make sure the old MP_VOICE channel knows it has no
  2718.    master now ! */
  2719. a->slave=NULL;
  2720. /* assume the channel is taken by NNA */
  2721. aout->mflag=0;
  2723. switch (aout->main.nna) {
  2724. case NNA_CONTINUE: /* continue note, do nothing */
  2725. break;
  2726. case NNA_OFF: /* note off */
  2727. aout->main.keyoff|=KEY_OFF;
  2728. if ((!(aout->main.volflg & EF_ON))||
  2729.   (aout->main.volflg & EF_LOOP))
  2730. aout->main.keyoff=KEY_KILL;
  2731. break;
  2732. case NNA_FADE:
  2733. aout->main.keyoff |= KEY_FADE;
  2734. break;
  2735. }
  2736. }
  2737. }
  2739. if (a->dct!=DCT_OFF) {
  2740. int t;
  2742. for (t=0;t<md_sngchn;t++)
  2743. if ((!Voice_Stopped_internal(t))&&
  2744.    (mod->voice[t].masterchn==channel)&&
  2745.    (a->main.sample==mod->voice[t].main.sample)) {
  2746. kill=0;
  2747. switch (a->dct) {
  2748. case DCT_NOTE:
  2749. if (a->main.note==mod->voice[t].main.note)
  2750. kill=1;
  2751. break;
  2752. case DCT_SAMPLE:
  2753. if (a->main.handle==mod->voice[t].main.handle)
  2754. kill=1;
  2755. break;
  2756. case DCT_INST:
  2757. kill=1;
  2758. break;
  2759. }
  2760. if (kill)
  2761. switch (a->dca) {
  2762. case DCA_CUT:
  2763. mod->voice[t].main.fadevol=0;
  2764. break;
  2765. case DCA_OFF:
  2766. mod->voice[t].main.keyoff|=KEY_OFF;
  2767. if ((!(mod->voice[t].main.volflg&EF_ON))||
  2768.     (mod->voice[t].main.volflg&EF_LOOP))
  2769. mod->voice[t].main.keyoff=KEY_KILL;
  2770. break;
  2771. case DCA_FADE:
  2772. mod->voice[t].main.keyoff|=KEY_FADE;
  2773. break;
  2774. }
  2775. }
  2776. }
  2777. } /* if (a->main.kick==KICK_NOTE) */
  2778. }
  2779. }
  2781. /* Setup module and NNA voices */
  2782. void pt_SetupVoices(MODULE *mod)
  2783. {
  2784. SWORD channel;
  2785. MP_CONTROL *a;
  2786. MP_VOICE *aout;
  2788. for (channel=0;channel<mod->numchn;channel++) {
  2789. a=&mod->control[channel];
  2791. if (a->main.notedelay) continue;
  2792. if (a->main.kick==KICK_NOTE) {
  2793. /* if no channel was cut above, find an empty or quiet channel
  2794.    here */
  2795. if (mod->flags&UF_NNA) {
  2796. if (!a->slave) {
  2797. int newchn;
  2799. if ((newchn=MP_FindEmptyChannel(mod))!=-1)
  2800. a->slave=&mod->voice[a->slavechn=newchn];
  2801. }
  2802. } else 
  2803. a->slave=&mod->voice[a->slavechn=channel];
  2805. /* assign parts of MP_VOICE only done for a KICK_NOTE */
  2806. if ((aout=a->slave)) {
  2807. if (aout->mflag && aout->master) aout->master->slave=NULL;
  2808. aout->master=a;
  2809. a->slave=aout;
  2810. aout->masterchn=channel;
  2811. aout->mflag=1;
  2812. }
  2813. } else
  2814. aout=a->slave;
  2816. if (aout)
  2817. aout->main=a->main;
  2818. a->main.kick=KICK_ABSENT;
  2819. }
  2820. }
  2822. /* second effect pass */
  2823. void pt_EffectsPass2(MODULE *mod)
  2824. {
  2825. SWORD channel;
  2826. MP_CONTROL *a;
  2827. UBYTE c;
  2829. for (channel=0;channel<mod->numchn;channel++) {
  2830. a=&mod->control[channel];
  2832. if (!a->row) continue;
  2833. UniSetRow(a->row);
  2835. while((c=UniGetByte()))
  2836. if (c==UNI_ITEFFECTS0) {
  2837. c=UniGetByte();
  2838. if ((c>>4)==SS_S7EFFECTS)
  2839. DoNNAEffects(mod, a, c&0xf);
  2840. } else
  2841. UniSkipOpcode();
  2842. }
  2843. }
  2845. void Player_HandleTick(void)
  2846. {
  2847. SWORD channel;
  2848. int max_volume;
  2850. #if 0
  2851. /* don't handle the very first ticks, this allows the other hardware to
  2852.    settle down so we don't loose any starting notes */
  2853. if (isfirst) {
  2854. isfirst--;
  2855. return;
  2856. }
  2857. #endif
  2859. if ((!pf)||(pf->forbid)||(pf->sngpos>=pf->numpos)) return;
  2861. /* update time counter (sngtime is in milliseconds (in fact 2^-10)) */
  2862. pf->sngremainder+=(1<<9)*5; /* thus 2.5*(1<<10), since fps=0.4xtempo */
  2863. pf->sngtime+=pf->sngremainder/pf->bpm;
  2864. pf->sngremainder%=pf->bpm;
  2866. if (++pf->vbtick>=pf->sngspd) {
  2867. if (pf->pat_repcrazy) 
  2868. pf->pat_repcrazy=0; /* play 2 times row 0 */
  2869. else
  2870. pf->patpos++;
  2871. pf->vbtick=0;
  2873. /* process pattern-delay. pf->patdly2 is the counter and pf->patdly is
  2874.    the command memory. */
  2875. if (pf->patdly)
  2876. pf->patdly2=pf->patdly,pf->patdly=0;
  2877. if (pf->patdly2) {
  2878. /* patterndelay active */
  2879. if (--pf->patdly2)
  2880. /* so turn back pf->patpos by 1 */
  2881. if (pf->patpos) pf->patpos--;
  2882. }
  2884. /* do we have to get a new patternpointer ? (when pf->patpos reaches the
  2885.    pattern size, or when a patternbreak is active) */
  2886. if (((pf->patpos>=pf->numrow)&&(pf->numrow>0))&&(!pf->posjmp))
  2887. pf->posjmp=3;
  2889. if (pf->posjmp) {
  2890. pf->patpos=pf->numrow?(pf->patbrk%pf->numrow):0;
  2891. pf->pat_repcrazy=0;
  2892. pf->sngpos+=(pf->posjmp-2);
  2893. for (channel=0;channel<pf->numchn;channel++)
  2894. pf->control[channel].pat_reppos=-1;
  2896. pf->patbrk=pf->posjmp=0;
  2897. /* handle the "---" (end of song) pattern since it can occur
  2898.    *inside* the module in some formats */
  2899. if ((pf->sngpos>=pf->numpos)||
  2900. (pf->positions[pf->sngpos]==LAST_PATTERN)) {
  2901. if (!pf->wrap) return;
  2902. if (!(pf->sngpos=pf->reppos)) {
  2903.     pf->volume=pf->initvolume>128?128:pf->initvolume;
  2904. if(pf->initspeed!=0)
  2905. pf->sngspd=pf->initspeed<32?pf->initspeed:32;
  2906. else
  2907. pf->sngspd=6;
  2908. pf->bpm=pf->inittempo<32?32:pf->inittempo;
  2909. }
  2910. }
  2911. if (pf->sngpos<0) pf->sngpos=pf->numpos-1;
  2912. }
  2914. if (!pf->patdly2)
  2915. pt_Notes(pf);
  2916. }
  2918. /* Fade global volume if enabled and we're playing the last pattern */
  2919. if (((pf->sngpos==pf->numpos-1)||
  2920.  (pf->positions[pf->sngpos+1]==LAST_PATTERN))&&
  2921.     (pf->fadeout))
  2922. max_volume=pf->numrow?((pf->numrow-pf->patpos)*128)/pf->numrow:0;
  2923. else
  2924. max_volume=128;
  2926. pt_EffectsPass1(pf);
  2927. if (pf->flags&UF_NNA)
  2928. pt_NNA(pf);
  2929. pt_SetupVoices(pf);
  2930. pt_EffectsPass2(pf);
  2932. /* now set up the actual hardware channel playback information */
  2933. pt_UpdateVoices(pf, max_volume);
  2934. }
  2936. static void Player_Init_internal(MODULE* mod)
  2937. {
  2938. int t;
  2940. for (t=0;t<mod->numchn;t++) {
  2941. mod->control[t].main.chanvol=mod->chanvol[t];
  2942. mod->control[t].main.panning=mod->panning[t];
  2943. }
  2945. mod->sngtime=0;
  2946. mod->sngremainder=0;
  2948. mod->pat_repcrazy=0;
  2949. mod->sngpos=0;
  2950. if(mod->initspeed!=0)
  2951. mod->sngspd=mod->initspeed<32?mod->initspeed:32;
  2952. else
  2953. mod->sngspd=6;
  2954. mod->volume=mod->initvolume>128?128:mod->initvolume;
  2956. mod->vbtick=mod->sngspd;
  2957. mod->patdly=0;
  2958. mod->patdly2=0;
  2959. mod->bpm=mod->inittempo<32?32:mod->inittempo;
  2960. mod->realchn=0;
  2962. mod->patpos=0;
  2963. mod->posjmp=2; /* make sure the player fetches the first note */
  2964. mod->numrow=-1;
  2965. mod->patbrk=0;
  2966. }
  2968. BOOL Player_Init(MODULE* mod)
  2969. {
  2970. mod->extspd=1;
  2971. mod->panflag=1;
  2972. mod->wrap=0;
  2973. mod->loop=1;
  2974. mod->fadeout=0;
  2976. mod->relspd=0;
  2978. /* make sure the player doesn't start with garbage */
  2979. if (!(mod->control=(MP_CONTROL*)_mm_calloc(mod->numchn,sizeof(MP_CONTROL))))
  2980. return 1;
  2981. if (!(mod->voice=(MP_VOICE*)_mm_calloc(md_sngchn,sizeof(MP_VOICE))))
  2982. return 1;
  2984. Player_Init_internal(mod);
  2985. return 0;
  2986. }
  2988. void Player_Exit_internal(MODULE* mod)
  2989. {
  2990. if (!mod)
  2991. return;
  2993. /* Stop playback if necessary */
  2994. if (mod==pf) {
  2995. Player_Stop_internal();
  2996. pf=NULL;
  2997. }
  2999. if (mod->control)
  3000. free(mod->control);
  3001. if (mod->voice)
  3002. free(mod->voice);
  3003. mod->control=NULL;
  3004. mod->voice=NULL;
  3005. }
  3007. void Player_Exit(MODULE* mod)
  3008. {
  3009. MUTEX_LOCK(vars);
  3010. Player_Exit_internal(mod);
  3011. MUTEX_UNLOCK(vars);
  3012. }
  3014. MIKMODAPI void Player_SetVolume(SWORD volume)
  3015. {
  3016. MUTEX_LOCK(vars);
  3017. if (pf)
  3018. pf->volume=(volume<0)?0:(volume>128)?128:volume;
  3019. MUTEX_UNLOCK(vars);
  3020. }
  3022. MIKMODAPI MODULE* Player_GetModule(void)
  3023. {
  3024. MODULE* result;
  3026. MUTEX_LOCK(vars);
  3027. result=pf;
  3028. MUTEX_UNLOCK(vars);
  3030. return result;
  3031. }
  3033. MIKMODAPI void Player_Start(MODULE *mod)
  3034. {
  3035. int t;
  3037. if (!mod)
  3038. return;
  3040. if (!MikMod_Active())
  3041. MikMod_EnableOutput();
  3043. mod->forbid=0;
  3045. MUTEX_LOCK(vars);
  3046. if (pf!=mod) {
  3047. /* new song is being started, so completely stop out the old one. */
  3048. if (pf) pf->forbid=1;
  3049. for (t=0;t<md_sngchn;t++) Voice_Stop_internal(t);
  3050. }
  3051. pf=mod;
  3052. MUTEX_UNLOCK(vars);
  3053. }
  3055. void Player_Stop_internal(void)
  3056. {
  3057. if (!md_sfxchn) MikMod_DisableOutput_internal();
  3058. if (pf) pf->forbid=1;
  3059. pf=NULL;
  3060. }
  3062. MIKMODAPI void Player_Stop(void)
  3063. {
  3064. MUTEX_LOCK(vars);
  3065. Player_Stop_internal();
  3066. MUTEX_UNLOCK(vars);
  3067. }
  3069. MIKMODAPI BOOL Player_Active(void)
  3070. {
  3071. BOOL result=0;
  3073. MUTEX_LOCK(vars);
  3074. if (pf)
  3075. result=(!(pf->sngpos>=pf->numpos));
  3076. MUTEX_UNLOCK(vars);
  3078. return result;
  3079. }
  3081. MIKMODAPI void Player_NextPosition(void)
  3082. {
  3083. MUTEX_LOCK(vars);
  3084. if (pf) {
  3085. int t;
  3087. pf->forbid=1;
  3088. pf->posjmp=3;
  3089. pf->patbrk=0;
  3090. pf->vbtick=pf->sngspd;
  3092. for (t=0;t<md_sngchn;t++) {
  3093. Voice_Stop_internal(t);
  3094. pf->voice[t].main.i=NULL;
  3095. pf->voice[t].main.s=NULL;
  3096. }
  3097. for (t=0;t<pf->numchn;t++) {
  3098. pf->control[t].main.i=NULL;
  3099. pf->control[t].main.s=NULL;
  3100. }
  3101. pf->forbid=0;
  3102. }
  3103. MUTEX_UNLOCK(vars);
  3104. }
  3106. MIKMODAPI void Player_PrevPosition(void)
  3107. {
  3108. MUTEX_LOCK(vars);
  3109. if (pf) {
  3110. int t;
  3112. pf->forbid=1;
  3113. pf->posjmp=1;
  3114. pf->patbrk=0;
  3115. pf->vbtick=pf->sngspd;
  3117. for (t=0;t<md_sngchn;t++) {
  3118. Voice_Stop_internal(t);
  3119. pf->voice[t].main.i=NULL;
  3120. pf->voice[t].main.s=NULL;
  3121. }
  3122. for (t=0;t<pf->numchn;t++) {
  3123. pf->control[t].main.i=NULL;
  3124. pf->control[t].main.s=NULL;
  3125. }
  3126. pf->forbid=0;
  3127. }
  3128. MUTEX_UNLOCK(vars);
  3129. }
  3131. MIKMODAPI void Player_SetPosition(UWORD pos)
  3132. {
  3133. MUTEX_LOCK(vars);
  3134. if (pf) {
  3135. int t;
  3137. pf->forbid=1;
  3138. if (pos>=pf->numpos) pos=pf->numpos;
  3139. pf->posjmp=2;
  3140. pf->patbrk=0;
  3141. pf->sngpos=pos;
  3142. pf->vbtick=pf->sngspd;
  3144. for (t=0;t<md_sngchn;t++) {
  3145. Voice_Stop_internal(t);
  3146. pf->voice[t].main.i=NULL;
  3147. pf->voice[t].main.s=NULL;
  3148. }
  3149. for (t=0;t<pf->numchn;t++) {
  3150. pf->control[t].main.i=NULL;
  3151. pf->control[t].main.s=NULL;
  3152. }
  3153. pf->forbid=0;
  3155. if (!pos)
  3156. Player_Init_internal(pf);
  3157. }
  3158. MUTEX_UNLOCK(vars);
  3159. }    
  3161. static void Player_Unmute_internal(SLONG arg1,va_list ap)
  3162. {
  3163. SLONG t,arg2,arg3=0;
  3165. if (pf) {
  3166. switch (arg1) {
  3167. case MUTE_INCLUSIVE:
  3168. if (((!(arg2=va_arg(ap,SLONG)))&&(!(arg3=va_arg(ap,SLONG))))||
  3169.    (arg2>arg3)||(arg3>=pf->numchn))
  3170. return;
  3171. for (;arg2<pf->numchn && arg2<=arg3;arg2++)
  3172. pf->control[arg2].muted=0;
  3173. break;
  3174. case MUTE_EXCLUSIVE:
  3175. if (((!(arg2=va_arg(ap,SLONG)))&&(!(arg3=va_arg(ap,SLONG))))||
  3176.    (arg2>arg3)||(arg3>=pf->numchn))
  3177. return;
  3178. for (t=0;t<pf->numchn;t++) {
  3179. if ((t>=arg2) && (t<=arg3))
  3180. continue;
  3181. pf->control[t].muted=0;
  3182. }
  3183. break;
  3184. default:
  3185. if (arg1<pf->numchn) pf->control[arg1].muted=0;
  3186. break;
  3187. }
  3188. }
  3189. }
  3191. MIKMODAPI void Player_Unmute(SLONG arg1, ...)
  3192. {
  3193. va_list args;
  3195. va_start(args,arg1);
  3196. MUTEX_LOCK(vars);
  3197. Player_Unmute_internal(arg1,args);
  3198. MUTEX_UNLOCK(vars);
  3199. va_end(args);
  3200. }
  3202. static void Player_Mute_internal(SLONG arg1,va_list ap)
  3203. {
  3204. SLONG t,arg2,arg3=0;
  3206. if (pf) {
  3207. switch (arg1) {
  3208. case MUTE_INCLUSIVE:
  3209. if (((!(arg2=va_arg(ap,SLONG)))&&(!(arg3=va_arg(ap,SLONG))))||
  3210.     (arg2>arg3)||(arg3>=pf->numchn))
  3211. return;
  3212. for (;arg2<pf->numchn && arg2<=arg3;arg2++)
  3213. pf->control[arg2].muted=1;
  3214. break;
  3215. case MUTE_EXCLUSIVE:
  3216. if (((!(arg2=va_arg(ap,SLONG)))&&(!(arg3=va_arg(ap,SLONG))))||
  3217.     (arg2>arg3)||(arg3>=pf->numchn))
  3218. return;
  3219. for (t=0;t<pf->numchn;t++) {
  3220. if ((t>=arg2) && (t<=arg3))
  3221. continue;
  3222. pf->control[t].muted=1;
  3223. }
  3224. break;
  3225. default:
  3226. if (arg1<pf->numchn)
  3227. pf->control[arg1].muted=1;
  3228. break;
  3229. }
  3230. }
  3231. }
  3233. MIKMODAPI void Player_Mute(SLONG arg1,...)
  3234. {
  3235. va_list args;
  3237. va_start(args,arg1);
  3238. MUTEX_LOCK(vars);
  3239. Player_Mute_internal(arg1,args);
  3240. MUTEX_UNLOCK(vars);
  3241. va_end(args);
  3242. }
  3244. static void Player_ToggleMute_internal(SLONG arg1,va_list ap)
  3245. {
  3246. SLONG arg2,arg3=0;
  3247. ULONG t;
  3249. if (pf) {
  3250. switch (arg1) {
  3251. case MUTE_INCLUSIVE:
  3252. if (((!(arg2=va_arg(ap,SLONG)))&&(!(arg3=va_arg(ap,SLONG))))||
  3253.     (arg2>arg3)||(arg3>=pf->numchn))
  3254. return;
  3255. for (;arg2<pf->numchn && arg2<=arg3;arg2++)
  3256. pf->control[arg2].muted=1-pf->control[arg2].muted;
  3257. break;
  3258. case MUTE_EXCLUSIVE:
  3259. if (((!(arg2=va_arg(ap,SLONG)))&&(!(arg3=va_arg(ap,SLONG))))||
  3260.     (arg2>arg3)||(arg3>=pf->numchn))
  3261. return;
  3262. for (t=0;t<pf->numchn;t++) {
  3263. if ((t>=arg2) && (t<=arg3))
  3264. continue;
  3265. pf->control[t].muted=1-pf->control[t].muted;
  3266. }
  3267. break;
  3268. default:
  3269. if (arg1<pf->numchn) 
  3270. pf->control[arg1].muted=1-pf->control[arg1].muted;
  3271. break;
  3272. }
  3273. }
  3274. }
  3276. MIKMODAPI void Player_ToggleMute(SLONG arg1,...)
  3277. {
  3278. va_list args;
  3280. va_start(args,arg1);
  3281. MUTEX_LOCK(vars);
  3282. Player_ToggleMute_internal(arg1,args);
  3283. MUTEX_UNLOCK(vars);
  3284. va_end(args);
  3285. }
  3287. MIKMODAPI BOOL Player_Muted(UBYTE chan)
  3288. {
  3289. BOOL result=1;
  3291. MUTEX_LOCK(vars);
  3292. if (pf)
  3293. result=(chan<pf->numchn)?pf->control[chan].muted:1;
  3294. MUTEX_UNLOCK(vars);
  3296. return result;
  3297. }
  3299. MIKMODAPI int Player_GetChannelVoice(UBYTE chan)
  3300. {
  3301. int result=0;
  3303. MUTEX_LOCK(vars);
  3304. if (pf)
  3305. result=(chan<pf->numchn)?pf->control[chan].slavechn:-1;
  3306. MUTEX_UNLOCK(vars);
  3308. return result;
  3309. }
  3311. MIKMODAPI UWORD Player_GetChannelPeriod(UBYTE chan)
  3312. {
  3313. UWORD result=0;
  3315. MUTEX_LOCK(vars);
  3316.     if (pf)
  3317.     result=(chan<pf->numchn)?pf->control[chan].main.period:0;
  3318. MUTEX_UNLOCK(vars);
  3320. return result;
  3321. }
  3323. BOOL Player_Paused_internal(void)
  3324. {
  3325. return pf?pf->forbid:1;
  3326. }
  3328. MIKMODAPI BOOL Player_Paused(void)
  3329. {
  3330. BOOL result;
  3332. MUTEX_LOCK(vars);
  3333. result=Player_Paused_internal();
  3334. MUTEX_UNLOCK(vars);
  3336. return result;
  3337. }
  3339. MIKMODAPI void Player_TogglePause(void)
  3340. {
  3341. MUTEX_LOCK(vars);
  3342. if (pf)
  3343. pf->forbid=1-pf->forbid;
  3344. MUTEX_UNLOCK(vars);
  3345. }
  3347. MIKMODAPI void Player_SetSpeed(UWORD speed)
  3348. {
  3349. MUTEX_LOCK(vars);
  3350. if (pf) 
  3351. pf->sngspd=speed?(speed<32?speed:32):1;
  3352. MUTEX_UNLOCK(vars);
  3353. }
  3355. MIKMODAPI void Player_SetTempo(UWORD tempo)
  3356. {
  3357. if (tempo<32) tempo=32;
  3358. MUTEX_LOCK(vars);
  3359. if (pf) {
  3360. if ((!(pf->flags&UF_HIGHBPM))&&(tempo>255)) tempo=255;
  3361. pf->bpm=tempo;
  3362. }
  3363. MUTEX_UNLOCK(vars);
  3364. }
  3366. MIKMODAPI int Player_QueryVoices(UWORD numvoices, VOICEINFO *vinfo)
  3367. {
  3368. int i;
  3370. if (numvoices > md_sngchn)
  3371. numvoices = md_sngchn;
  3373. MUTEX_LOCK(vars);
  3374. if (pf)
  3375. for (i = 0; i < md_sngchn; i++) {
  3376. vinfo [i].i = pf->voice[i].main.i;
  3377. vinfo [i].s = pf->voice[i].main.s;
  3378. vinfo [i].panning = pf->voice [i].main.panning;
  3379. vinfo [i].volume = pf->voice [i].main.chanvol;
  3380. vinfo [i].period = pf->voice [i].main.period;
  3381. vinfo [i].kick = pf->voice [i].main.kick_flag;
  3382. pf->voice [i].main.kick_flag = 0;
  3383. }
  3384. MUTEX_UNLOCK(vars);
  3386. return numvoices;
  3387. }
  3391. /* ex:set ts=4: */