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

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

Windows CE

开发平台：

C/C++

load_m15.c：源码内容
  1. /* MikMod sound library
  2. (c) 1998, 1999, 2000, 2001, 2002 Miodrag Vallat and others - see file
  3. AUTHORS 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: load_m15.c,v 1.1.1.1 2004/01/21 01:36:35 raph Exp $
  25.   15 instrument MOD loader
  26.   Also supports Ultimate Sound Tracker (old M15 format)
  28. ==============================================================================*/
  30. #ifdef HAVE_CONFIG_H
  31. #include "config.h"
  32. #endif
  34. #ifdef HAVE_UNISTD_H
  35. #include <unistd.h>
  36. #endif
  38. #include <ctype.h>
  39. #include <stdio.h>
  40. #ifdef HAVE_MEMORY_H
  41. #include <memory.h>
  42. #endif
  43. #include <string.h>
  45. #include "mikmod_internals.h"
  47. #ifdef SUNOS
  48. extern int fprintf(FILE *, const char *, ...);
  49. #endif
  51. /*========== Module Structure */
  53. typedef struct MSAMPINFO {
  54. CHAR  samplename[23]; /* 22 in module, 23 in memory */
  55. UWORD length;
  56. UBYTE finetune;
  57. UBYTE volume;
  58. UWORD reppos;
  59. UWORD replen;
  60. } MSAMPINFO;
  62. typedef struct MODULEHEADER {
  63. CHAR      songname[21]; /* the songname.., 20 in module, 21 in memory */
  64. MSAMPINFO samples[15]; /* all sampleinfo */
  65. UBYTE     songlength; /* number of patterns used */
  66. UBYTE     magic1;        /* should be 127 */
  67. UBYTE     positions[128]; /* which pattern to play at pos */
  68. } MODULEHEADER;
  70. typedef struct MODNOTE {
  71. UBYTE a,b,c,d;
  72. } MODNOTE;
  74. /*========== Loader variables */
  76. static MODULEHEADER *mh = NULL;
  77. static MODNOTE *patbuf = NULL;
  78. static BOOL ust_loader = 0; /* if TRUE, load as an ust module. */
  80. /* known file formats which can confuse the loader */
  81. #define REJECT 2
  82. static char *signatures[REJECT]={
  83. "CAKEWALK", /* cakewalk midi files */
  84. "SZDD" /* Microsoft compressed files */
  85. };
  86. static int siglen[REJECT]={8,4};
  88. /*========== Loader code */
  90. static BOOL LoadModuleHeader(MODULEHEADER *mh)
  91. {
  92. int t,u;
  94. _mm_read_string(mh->songname,20,modreader);
  95. mh->songname[20]=0; /* just in case */
  97. /* sanity check : title should contain printable characters and a bunch
  98.    of null chars */
  99. for(t=0;t<20;t++)
  100. if((mh->songname[t])&&(mh->songname[t]<32)) return 0;
  101. for(t=0;(mh->songname[t])&&(t<20);t++);
  102. if(t<20) for(;t<20;t++) if(mh->songname[t]) return 0;
  104. for(t=0;t<15;t++) {
  105. MSAMPINFO *s=&mh->samples[t];
  107. _mm_read_string(s->samplename,22,modreader);
  108. s->samplename[22]=0; /* just in case */
  109. s->length   =_mm_read_M_UWORD(modreader);
  110. s->finetune =_mm_read_UBYTE(modreader);
  111. s->volume   =_mm_read_UBYTE(modreader);
  112. s->reppos   =_mm_read_M_UWORD(modreader);
  113. s->replen   =_mm_read_M_UWORD(modreader);
  115. /* sanity check : sample title should contain printable characters and
  116.    a bunch of null chars */
  117. for(u=0;u<20;u++)
  118. if((s->samplename[u])&&(s->samplename[u]</*32*/14)) return 0;
  119. for(u=0;(s->samplename[u])&&(u<20);u++);
  120. if(u<20) for(;u<20;u++) if(s->samplename[u]) return 0;
  122. /* sanity check : finetune values */
  123. if(s->finetune>>4) return 0;
  124. }
  126. mh->songlength  =_mm_read_UBYTE(modreader);
  127. mh->magic1      =_mm_read_UBYTE(modreader); /* should be 127 */
  129. /* sanity check : no more than 128 positions, restart position in range */
  130. if((!mh->songlength)||(mh->songlength>128)) return 0;
  131. /* values encountered so far are 0x6a and 0x78 */
  132. if(((mh->magic1&0xf8)!=0x78)&&(mh->magic1!=0x6a)&&(mh->magic1>mh->songlength)) return 0;
  134. _mm_read_UBYTES(mh->positions,128,modreader);
  136. /* sanity check : pattern range is 0..63 */
  137. for(t=0;t<128;t++)
  138. if(mh->positions[t]>63) return 0;
  140. return(!_mm_eof(modreader));
  141. }
  143. /* Checks the patterns in the modfile for UST / 15-inst indications.
  144.    For example, if an effect 3xx is found, it is assumed that the song 
  145.    is 15-inst.  If a 1xx effect has dat greater than 0x20, it is UST.   
  147.    Returns:  0 indecisive; 1 = UST; 2 = 15-inst                               */
  148. static int CheckPatternType(int numpat)
  149. {
  150. int t;
  151. UBYTE eff, dat;
  153. for(t=0;t<numpat*(64U*4);t++) {
  154. /* Load the pattern into the temp buffer and scan it */
  155. _mm_read_UBYTE(modreader);_mm_read_UBYTE(modreader);
  156. eff = _mm_read_UBYTE(modreader);
  157. dat = _mm_read_UBYTE(modreader);
  159. switch(eff) {
  160. case 1:
  161. if(dat>0x1f) return 1;
  162. if(dat<0x3)  return 2;
  163. break;
  164. case 2:
  165. if(dat>0x1f) return 1;
  166. return 2;
  167. case 3:
  168. if (dat) return 2;
  169. break;
  170. default:
  171. return 2;
  172. }
  173. }
  174. return 0;
  175. }
  177. static BOOL M15_Test(void)
  178. {
  179. int t, numpat;
  180. MODULEHEADER mh;
  182. ust_loader = 0;
  183. if(!LoadModuleHeader(&mh)) return 0;
  185. /* reject other file types */
  186. for(t=0;t<REJECT;t++)
  187. if(!memcmp(mh.songname,signatures[t],siglen[t])) return 0;
  189. if(mh.magic1>127) return 0;
  190. if((!mh.songlength)||(mh.songlength>mh.magic1)) return 0;
  192. for(t=0;t<15;t++) {
  193. /* all finetunes should be zero */
  194. if(mh.samples[t].finetune) return 0;
  196. /* all volumes should be <= 64 */
  197. if(mh.samples[t].volume>64) return 0;
  199. /* all instrument names should begin with s, st-, or a number */
  200. if((mh.samples[t].samplename[0]=='s')||
  201.    (mh.samples[t].samplename[0]=='S')) {
  202. if((memcmp(mh.samples[t].samplename,"st-",3)) &&
  203.    (memcmp(mh.samples[t].samplename,"ST-",3)) &&
  204.    (*mh.samples[t].samplename))
  205. ust_loader = 1;
  206. } else
  207.   if(!isdigit((int)mh.samples[t].samplename[0]))
  208. ust_loader = 1;
  210. if(mh.samples[t].length>4999||mh.samples[t].reppos>9999) {
  211. ust_loader = 0;
  212. if(mh.samples[t].length>32768) return 0;
  213. }
  215. /* if loop information is incorrect as words, but correct as bytes,
  216.    this is likely to be an ust-style module */
  217. if((mh.samples[t].reppos+mh.samples[t].replen>mh.samples[t].length)&&
  218.    (mh.samples[t].reppos+mh.samples[t].replen<(mh.samples[t].length<<1))){
  219. ust_loader = 1;
  220. return 1;
  221. }
  223. if(!ust_loader) return 1; 
  224. }
  226. for(numpat=0,t=0;t<mh.songlength;t++) 
  227. if(mh.positions[t]>numpat)
  228. numpat = mh.positions[t];
  229. numpat++;
  230. switch(CheckPatternType(numpat)) {
  231. case 0:   /* indecisive, so check more clues... */
  232. break;
  233. case 1:
  234. ust_loader = 1;
  235. break;
  236. case 2:
  237. ust_loader = 0;
  238. break;
  239. }
  240. return 1;
  241. }
  243. static BOOL M15_Init(void)
  244. {
  245. if(!(mh=(MODULEHEADER*)_mm_malloc(sizeof(MODULEHEADER)))) return 0;
  246. return 1;
  247. }
  249. static void M15_Cleanup(void)
  250. {
  251. _mm_free(mh);
  252. _mm_free(patbuf);
  253. }
  255. /*
  256. Old (amiga) noteinfo:
  258.  _____byte 1_____   byte2_    _____byte 3_____   byte4_
  259. /                 /        /                 /      
  260. 0000          0000-00000000  0000          0000-00000000
  262. Upper four    12 bits for    Lower four    Effect command.
  263. bits of sam-  note period.   bits of sam-
  264. ple number.                  ple number.
  265. */
  267. static UBYTE M15_ConvertNote(MODNOTE* n, UBYTE lasteffect)
  268. {
  269. UBYTE instrument,effect,effdat,note;
  270. UWORD period;
  271. UBYTE lastnote=0;
  273. /* decode the 4 bytes that make up a single note */
  274. instrument = n->c>>4;
  275. period     = (((UWORD)n->a&0xf)<<8)+n->b;
  276. effect     = n->c&0xf;
  277. effdat     = n->d;
  279. /* Convert the period to a note number */
  280. note=0;
  281. if(period) {
  282. for(note=0;note<7*OCTAVE;note++)
  283. if(period>=npertab[note]) break;
  284. if(note==7*OCTAVE) note=0;
  285. else note++;
  286. }
  288. if(instrument) {
  289. /* if instrument does not exist, note cut */
  290. if((instrument>15)||(!mh->samples[instrument-1].length)) {
  291. UniPTEffect(0xc,0);
  292. if(effect==0xc) effect=effdat=0;
  293. } else {
  294. /* if we had a note, then change instrument... */
  295. if(note)
  296. UniInstrument(instrument-1);
  297. /* ...otherwise, only adjust volume... */
  298. else {
  299. /* ...unless an effect was specified, which forces a new note
  300.    to be played */
  301. if(effect||effdat) {
  302. UniInstrument(instrument-1);
  303. note=lastnote;
  304. } else
  305. UniPTEffect(0xc,mh->samples[instrument-1].volume&0x7f);
  306. }
  307. }
  308. }
  309. if(note) {
  310. UniNote(note+2*OCTAVE-1);
  311. lastnote=note;
  312. }
  314. /* Convert pattern jump from Dec to Hex */
  315. if(effect == 0xd)
  316. effdat=(((effdat&0xf0)>>4)*10)+(effdat&0xf);
  318. /* Volume slide, up has priority */
  319. if((effect==0xa)&&(effdat&0xf)&&(effdat&0xf0))
  320. effdat&=0xf0;
  322. /* Handle ``heavy'' volumes correctly */
  323. if ((effect == 0xc) && (effdat > 0x40))
  324. effdat = 0x40;
  326. if(ust_loader) {
  327. switch(effect) {
  328. case 0:
  329. case 3:
  330. break;
  331. case 1:
  332. UniPTEffect(0,effdat);
  333. break;
  334. case 2:  
  335. if(effdat&0xf) UniPTEffect(1,effdat&0xf);
  336. else if(effdat>>2)  UniPTEffect(2,effdat>>2);
  337. break;
  338. default:
  339. UniPTEffect(effect,effdat);
  340. break;
  341. }
  342. } else {
  343. /* An isolated 100, 200 or 300 effect should be ignored (no
  344.    "standalone" porta memory in mod files). However, a sequence
  345.    such as 1XX, 100, 100, 100 is fine. */
  346. if ((!effdat) && ((effect == 1)||(effect == 2)||(effect ==3)) &&
  347. (lasteffect < 0x10) && (effect != lasteffect))
  348. effect = 0;
  350. UniPTEffect(effect,effdat);
  351. }
  352. if (effect == 8)
  353. of.flags |= UF_PANNING;
  355. return effect;
  356. }
  358. static UBYTE *M15_ConvertTrack(MODNOTE* n)
  359. {
  360. int t;
  361. UBYTE lasteffect = 0x10; /* non existant effect */
  363. UniReset();
  364. for(t=0;t<64;t++) {
  365. lasteffect = M15_ConvertNote(n,lasteffect);
  366. UniNewline();
  367. n+=4;
  368. }
  369. return UniDup();
  370. }
  372. /* Loads all patterns of a modfile and converts them into the 3 byte format. */
  373. static BOOL M15_LoadPatterns(void)
  374. {
  375. int t,s,tracks=0;
  377. if(!AllocPatterns()) return 0;
  378. if(!AllocTracks()) return 0;
  380. /* Allocate temporary buffer for loading and converting the patterns */
  381. if(!(patbuf=(MODNOTE*)_mm_calloc(64U*4,sizeof(MODNOTE)))) return 0;
  383. for(t=0;t<of.numpat;t++) {
  384. /* Load the pattern into the temp buffer and convert it */
  385. for(s=0;s<(64U*4);s++) {
  386. patbuf[s].a=_mm_read_UBYTE(modreader);
  387. patbuf[s].b=_mm_read_UBYTE(modreader);
  388. patbuf[s].c=_mm_read_UBYTE(modreader);
  389. patbuf[s].d=_mm_read_UBYTE(modreader);
  390. }
  392. for(s=0;s<4;s++)
  393. if(!(of.tracks[tracks++]=M15_ConvertTrack(patbuf+s))) return 0;
  394. }
  395. return 1;
  396. }
  398. static BOOL M15_Load(BOOL curious)
  399. {
  400. int t,scan;
  401. SAMPLE *q;
  402. MSAMPINFO *s;
  404. /* try to read module header */
  405. if(!LoadModuleHeader(mh)) {
  406. _mm_errno = MMERR_LOADING_HEADER;
  407. return 0;
  408. }
  410. if(ust_loader)
  411. of.modtype = strdup("Ultimate Soundtracker");
  412. else
  413. of.modtype = strdup("Soundtracker");
  415. /* set module variables */
  416. of.initspeed = 6;
  417. of.inittempo = 125;
  418. of.numchn    = 4;
  419. of.songname  = DupStr(mh->songname,21,1);
  420. of.numpos    = mh->songlength;
  421. of.reppos    = 0;
  423. /* Count the number of patterns */
  424. of.numpat = 0;
  425. for(t=0;t<of.numpos;t++)
  426. if(mh->positions[t]>of.numpat)
  427. of.numpat=mh->positions[t];
  428. /* since some old modules embed extra patterns, we have to check the
  429.    whole list to get the samples' file offsets right - however we can find
  430.    garbage here, so check carefully */
  431. scan=1;
  432. for(t=of.numpos;t<128;t++)
  433. if(mh->positions[t]>=0x80) scan=0;
  434. if (scan)
  435. for(t=of.numpos;t<128;t++) {
  436. if(mh->positions[t]>of.numpat)
  437. of.numpat=mh->positions[t];
  438. if((curious)&&(mh->positions[t])) of.numpos=t+1;
  439. }
  440. of.numpat++;
  441. of.numtrk = of.numpat*of.numchn;
  443. if(!AllocPositions(of.numpos)) return 0;
  444. for(t=0;t<of.numpos;t++)
  445. of.positions[t]=mh->positions[t];
  447. /* Finally, init the sampleinfo structures */
  448. of.numins=of.numsmp=15;
  449. if(!AllocSamples()) return 0;
  451. s = mh->samples;
  452. q = of.samples;
  454. for(t=0;t<of.numins;t++) {
  455. /* convert the samplename */
  456. q->samplename = DupStr(s->samplename,23,1);
  458. /* init the sampleinfo variables and convert the size pointers */
  459. q->speed     = finetune[s->finetune&0xf];
  460. q->volume    = s->volume;
  461. if(ust_loader)
  462. q->loopstart = s->reppos;
  463. else
  464. q->loopstart = s->reppos<<1;
  465. q->loopend   = q->loopstart+(s->replen<<1);
  466. q->length    = s->length<<1;
  468. q->flags = SF_SIGNED;
  469.     if(ust_loader) q->flags |= SF_UST_LOOP;
  470. if(s->replen>2) q->flags |= SF_LOOP;
  472. s++;
  473. q++;
  474. }
  476. if(!M15_LoadPatterns()) return 0;
  477. ust_loader = 0;
  479. return 1;
  480. }
  482. static CHAR *M15_LoadTitle(void)
  483. {
  484. CHAR s[21];
  486. _mm_fseek(modreader,0,SEEK_SET);
  487. if(!_mm_read_UBYTES(s,20,modreader)) return NULL;
  488. s[20]=0; /* just in case */
  489. return(DupStr(s,21,1));
  490. }
  492. /*========== Loader information */
  494. MIKMODAPI MLOADER load_m15={
  495. NULL,
  496. "15-instrument module",
  497. "MOD (15 instrument)",
  498. M15_Init,
  499. M15_Test,
  500. M15_Load,
  501. M15_Cleanup,
  502. M15_LoadTitle
  503. };
  505. /* ex:set ts=4: */