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

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

Windows CE

开发平台：

C/C++

mloader.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: mloader.c,v 1.1.1.1 2004/01/21 01:36:35 raph Exp $
  25.   These routines are used to access the available module loaders
  27. ==============================================================================*/
  29. #ifdef HAVE_CONFIG_H
  30. #include "config.h"
  31. #endif
  33. #ifdef HAVE_UNISTD_H
  34. #include <unistd.h>
  35. #endif
  37. #ifdef HAVE_MEMORY_H
  38. #include <memory.h>
  39. #endif
  40. #include <string.h>
  42. #include "mikmod_internals.h"
  44. #ifdef SUNOS
  45. extern int fprintf(FILE *, const char *, ...);
  46. #endif
  48. MREADER *modreader;
  49. MODULE of;
  51. static MLOADER *firstloader=NULL;
  53. UWORD finetune[16]={
  54. 8363,8413,8463,8529,8581,8651,8723,8757,
  55. 7895,7941,7985,8046,8107,8169,8232,8280
  56. };
  58. MIKMODAPI CHAR* MikMod_InfoLoader(void)
  59. {
  60. int len=0;
  61. MLOADER *l;
  62. CHAR *list=NULL;
  64. MUTEX_LOCK(lists);
  65. /* compute size of buffer */
  66. for(l=firstloader;l;l=l->next) len+=1+(l->next?1:0)+strlen(l->version);
  68. if(len)
  69. if((list=_mm_malloc(len*sizeof(CHAR)))) {
  70. list[0]=0;
  71. /* list all registered module loders */
  72. for(l=firstloader;l;l=l->next)
  73. sprintf(list,(l->next)?"%s%sn":"%s%s",list,l->version);
  74. }
  75. MUTEX_UNLOCK(lists);
  76. return list;
  77. }
  79. void _mm_registerloader(MLOADER* ldr)
  80. {
  81. MLOADER *cruise=firstloader;
  83. if(cruise) {
  84. while(cruise->next) cruise = cruise->next;
  85. cruise->next=ldr;
  86. } else
  87. firstloader=ldr; 
  88. }
  90. MIKMODAPI void MikMod_RegisterLoader(struct MLOADER* ldr)
  91. {
  92. /* if we try to register an invalid loader, or an already registered loader,
  93.    ignore this attempt */
  94. if ((!ldr)||(ldr->next))
  95. return;
  97. MUTEX_LOCK(lists);
  98. _mm_registerloader(ldr);
  99. MUTEX_UNLOCK(lists);
  100. }
  102. BOOL ReadComment(UWORD len)
  103. {
  104. if(len) {
  105. int i;
  107. if(!(of.comment=(CHAR*)_mm_malloc(len+1))) return 0;
  108. _mm_read_UBYTES(of.comment,len,modreader);
  110. /* translate IT linefeeds */
  111. for(i=0;i<len;i++)
  112. if(of.comment[i]=='r') of.comment[i]='n';
  114. of.comment[len]=0; /* just in case */
  115. }
  116. if(!of.comment[0]) {
  117. free(of.comment);
  118. of.comment=NULL;
  119. }
  120. return 1;
  121. }
  123. BOOL ReadLinedComment(UWORD len,UWORD linelen)
  124. {
  125. CHAR *tempcomment,*line,*storage;
  126. UWORD total=0,t,lines;
  127. int i;
  129. lines = (len + linelen - 1) / linelen;
  130. if (len) {
  131. if(!(tempcomment=(CHAR*)_mm_malloc(len+1))) return 0;
  132. if(!(storage=(CHAR*)_mm_malloc(linelen+1))) {
  133. free(tempcomment);
  134. return 0;
  135. }
  136. memset(tempcomment, ' ', len);
  137. _mm_read_UBYTES(tempcomment,len,modreader);
  139. /* compute message length */
  140. for(line=tempcomment,total=t=0;t<lines;t++,line+=linelen) {
  141. for(i=linelen;(i>=0)&&(line[i]==' ');i--) line[i]=0;
  142. for(i=0;i<linelen;i++) if (!line[i]) break;
  143. total+=1+i;
  144. }
  146. if(total>lines) {
  147. if(!(of.comment=(CHAR*)_mm_malloc(total+1))) {
  148. free(storage);
  149. free(tempcomment);
  150. return 0;
  151. }
  153. /* convert message */
  154. for(line=tempcomment,t=0;t<lines;t++,line+=linelen) {
  155. for(i=0;i<linelen;i++) if(!(storage[i]=line[i])) break;
  156. storage[i]=0; /* if (i==linelen) */
  157. strcat(of.comment,storage);strcat(of.comment,"r");
  158. }
  159. free(storage);
  160. free(tempcomment);
  161. }
  162. }
  163. return 1;
  164. }
  166. BOOL AllocPositions(int total)
  167. {
  168. if(!total) {
  169. _mm_errno=MMERR_NOT_A_MODULE;
  170. return 0;
  171. }
  172. if(!(of.positions=_mm_calloc(total,sizeof(UWORD)))) return 0;
  173. return 1;
  174. }
  176. BOOL AllocPatterns(void)
  177. {
  178. int s,t,tracks = 0;
  180. if((!of.numpat)||(!of.numchn)) {
  181. _mm_errno=MMERR_NOT_A_MODULE;
  182. return 0;
  183. }
  184. /* Allocate track sequencing array */
  185. if(!(of.patterns=(UWORD*)_mm_calloc((ULONG)(of.numpat+1)*of.numchn,sizeof(UWORD)))) return 0;
  186. if(!(of.pattrows=(UWORD*)_mm_calloc(of.numpat+1,sizeof(UWORD)))) return 0;
  188. for(t=0;t<=of.numpat;t++) {
  189. of.pattrows[t]=64;
  190. for(s=0;s<of.numchn;s++)
  191. of.patterns[(t*of.numchn)+s]=tracks++;
  192. }
  194. return 1;
  195. }
  197. BOOL AllocTracks(void)
  198. {
  199. if(!of.numtrk) {
  200. _mm_errno=MMERR_NOT_A_MODULE;
  201. return 0;
  202. }
  203. if(!(of.tracks=(UBYTE **)_mm_calloc(of.numtrk,sizeof(UBYTE *)))) return 0;
  204. return 1;
  205. }
  207. BOOL AllocInstruments(void)
  208. {
  209. int t,n;
  211. if(!of.numins) {
  212. _mm_errno=MMERR_NOT_A_MODULE;
  213. return 0;
  214. }
  215. if(!(of.instruments=(INSTRUMENT*)_mm_calloc(of.numins,sizeof(INSTRUMENT))))
  216. return 0;
  218. for(t=0;t<of.numins;t++) {
  219. for(n=0;n<INSTNOTES;n++) { 
  220. /* Init note / sample lookup table */
  221. of.instruments[t].samplenote[n]   = n;
  222. of.instruments[t].samplenumber[n] = t;
  223. }   
  224. of.instruments[t].globvol = 64;
  225. }
  226. return 1;
  227. }
  229. BOOL AllocSamples(void)
  230. {
  231. UWORD u;
  233. if(!of.numsmp) {
  234. _mm_errno=MMERR_NOT_A_MODULE;
  235. return 0;
  236. }
  237. if(!(of.samples=(SAMPLE*)_mm_calloc(of.numsmp,sizeof(SAMPLE)))) return 0;
  239. for(u=0;u<of.numsmp;u++) {
  240. of.samples[u].panning = 128; /* center */
  241. of.samples[u].handle  = -1;
  242. of.samples[u].globvol = 64;
  243. of.samples[u].volume  = 64;
  244. }
  245. return 1;
  246. }
  248. static BOOL ML_LoadSamples(void)
  249. {
  250. SAMPLE *s;
  251. int u;
  253. for(u=of.numsmp,s=of.samples;u;u--,s++)
  254. if(s->length) SL_RegisterSample(s,MD_MUSIC,modreader);
  256. return 1;
  257. }
  259. /* Creates a CSTR out of a character buffer of 'len' bytes, but strips any
  260.    terminating non-printing characters like 0, spaces etc.                    */
  261. CHAR *DupStr(CHAR* s,UWORD len,BOOL strict)
  262. {
  263. UWORD t;
  264. CHAR *d=NULL;
  266. /* Scan for last printing char in buffer [includes high ascii up to 254] */
  267. while(len) {
  268. if(s[len-1]>0x20) break;
  269. len--;
  270. }
  272. /* Scan forward for possible NULL character */
  273. if(strict) {
  274. for(t=0;t<len;t++) if (!s[t]) break;
  275. if (t<len) len=t;
  276. }
  278. /* When the buffer wasn't completely empty, allocate a cstring and copy the
  279.    buffer into that string, except for any control-chars */
  280. if((d=(CHAR*)_mm_malloc(sizeof(CHAR)*(len+1)))) {
  281. for(t=0;t<len;t++) d[t]=(s[t]<32)?'.':s[t];
  282. d[len]=0;
  283. }
  284. return d;
  285. }
  287. static void ML_XFreeSample(SAMPLE *s)
  288. {
  289. if(s->handle>=0)
  290. MD_SampleUnload(s->handle);
  291. if(s->samplename) free(s->samplename);
  292. }
  294. static void ML_XFreeInstrument(INSTRUMENT *i)
  295. {
  296. if(i->insname) free(i->insname);
  297. }
  299. static void ML_FreeEx(MODULE *mf)
  300. {
  301. UWORD t;
  303. if(mf->songname) free(mf->songname);
  304. if(mf->comment)  free(mf->comment);
  306. if(mf->modtype)   free(mf->modtype);
  307. if(mf->positions) free(mf->positions);
  308. if(mf->patterns)  free(mf->patterns);
  309. if(mf->pattrows)  free(mf->pattrows);
  311. if(mf->tracks) {
  312. for(t=0;t<mf->numtrk;t++)
  313. if(mf->tracks[t]) free(mf->tracks[t]);
  314. free(mf->tracks);
  315. }
  316. if(mf->instruments) {
  317. for(t=0;t<mf->numins;t++)
  318. ML_XFreeInstrument(&mf->instruments[t]);
  319. free(mf->instruments);
  320. }
  321. if(mf->samples) {
  322. for(t=0;t<mf->numsmp;t++)
  323. if(mf->samples[t].length) ML_XFreeSample(&mf->samples[t]);
  324. free(mf->samples);
  325. }
  326. memset(mf,0,sizeof(MODULE));
  327. if(mf!=&of) free(mf);
  328. }
  330. static MODULE *ML_AllocUniMod(void)
  331. {
  332. MODULE *mf;
  334. return (mf=_mm_malloc(sizeof(MODULE)));
  335. }
  337. void Player_Free_internal(MODULE *mf)
  338. {
  339. if(mf) {
  340. Player_Exit_internal(mf);
  341. ML_FreeEx(mf);
  342. }
  343. }
  345. MIKMODAPI void Player_Free(MODULE *mf)
  346. {
  347. MUTEX_LOCK(vars);
  348. Player_Free_internal(mf);
  349. MUTEX_UNLOCK(vars);
  350. }
  352. static CHAR* Player_LoadTitle_internal(MREADER *reader)
  353. {
  354. MLOADER *l;
  356. modreader=reader;
  357. _mm_errno = 0;
  358. _mm_critical = 0;
  359. _mm_iobase_setcur(modreader);
  361. /* Try to find a loader that recognizes the module */
  362. for(l=firstloader;l;l=l->next) {
  363. _mm_rewind(modreader);
  364. if(l->Test()) break;
  365. }
  367. if(!l) {
  368. _mm_errno = MMERR_NOT_A_MODULE;
  369. if(_mm_errorhandler) _mm_errorhandler();
  370. return NULL;
  371. }
  373. return l->LoadTitle();
  374. }
  376. MIKMODAPI CHAR* Player_LoadTitleFP(FILE *fp)
  377. {
  378. CHAR* result=NULL;
  379. MREADER* reader;
  381. if(fp && (reader=_mm_new_file_reader(fp))) {
  382. MUTEX_LOCK(lists);
  383. result=Player_LoadTitle_internal(reader);
  384. MUTEX_UNLOCK(lists);
  385. _mm_delete_file_reader(reader);
  386. }
  387. return result;
  388. }
  390. MIKMODAPI CHAR* Player_LoadTitle(CHAR* filename)
  391. {
  392. CHAR* result=NULL;
  393. FILE* fp;
  394. MREADER* reader;
  396. if((fp=_mm_fopen(filename,"rb"))) {
  397. if((reader=_mm_new_file_reader(fp))) {
  398. MUTEX_LOCK(lists);
  399. result=Player_LoadTitle_internal(reader);
  400. MUTEX_UNLOCK(lists);
  401. _mm_delete_file_reader(reader);
  402. }
  403. _mm_fclose(fp);
  404. }
  405. return result;
  406. }
  408. /* Loads a module given an reader */
  409. MODULE* Player_LoadGeneric_internal(MREADER *reader,int maxchan,BOOL curious)
  410. {
  411. int t;
  412. MLOADER *l;
  413. BOOL ok;
  414. MODULE *mf;
  416. modreader = reader;
  417. _mm_errno = 0;
  418. _mm_critical = 0;
  419. _mm_iobase_setcur(modreader);
  421. /* Try to find a loader that recognizes the module */
  422. for(l=firstloader;l;l=l->next) {
  423. _mm_rewind(modreader);
  424. if(l->Test()) break;
  425. }
  427. if(!l) {
  428. _mm_errno = MMERR_NOT_A_MODULE;
  429. if(_mm_errorhandler) _mm_errorhandler();
  430. _mm_rewind(modreader);_mm_iobase_revert();
  431. return NULL;
  432. }
  434. /* init unitrk routines */
  435. if(!UniInit()) {
  436. if(_mm_errorhandler) _mm_errorhandler();
  437. _mm_rewind(modreader);_mm_iobase_revert();
  438. return NULL;
  439. }
  441. /* init the module structure with vanilla settings */
  442. memset(&of,0,sizeof(MODULE));
  443. of.bpmlimit = 33;
  444. of.initvolume = 128;
  445. for (t = 0; t < UF_MAXCHAN; t++) of.chanvol[t] = 64;
  446. for (t = 0; t < UF_MAXCHAN; t++)
  447. of.panning[t] = ((t + 1) & 2) ? PAN_RIGHT : PAN_LEFT;
  449. /* init module loader and load the header / patterns */
  450. if (!l->Init || l->Init()) {
  451. _mm_rewind(modreader);
  452. ok = l->Load(curious);
  453. /* propagate inflags=flags for in-module samples */
  454. for (t = 0; t < of.numsmp; t++)
  455. if (of.samples[t].inflags == 0)
  456. of.samples[t].inflags = of.samples[t].flags;
  457. } else
  458. ok = 0;
  460. /* free loader and unitrk allocations */
  461. if (l->Cleanup) l->Cleanup();
  462. UniCleanup();
  464. if(!ok) {
  465. ML_FreeEx(&of);
  466. if(_mm_errorhandler) _mm_errorhandler();
  467. _mm_rewind(modreader);_mm_iobase_revert();
  468. return NULL;
  469. }
  471. if(!ML_LoadSamples()) {
  472. ML_FreeEx(&of);
  473. if(_mm_errorhandler) _mm_errorhandler();
  474. _mm_rewind(modreader);_mm_iobase_revert();
  475. return NULL;
  476. }
  478. if(!(mf=ML_AllocUniMod())) {
  479. ML_FreeEx(&of);
  480. _mm_rewind(modreader);_mm_iobase_revert();
  481. if(_mm_errorhandler) _mm_errorhandler();
  482. return NULL;
  483. }
  485. /* If the module doesn't have any specific panning, create a
  486.    MOD-like panning, with the channels half-separated. */
  487. if (!(of.flags & UF_PANNING))
  488. for (t = 0; t < of.numchn; t++)
  489. of.panning[t] = ((t + 1) & 2) ? PAN_HALFRIGHT : PAN_HALFLEFT;
  491. /* Copy the static MODULE contents into the dynamic MODULE struct. */
  492. memcpy(mf,&of,sizeof(MODULE));
  494. if(maxchan>0) {
  495. if(!(mf->flags&UF_NNA)&&(mf->numchn<maxchan))
  496. maxchan = mf->numchn;
  497. else
  498.   if((mf->numvoices)&&(mf->numvoices<maxchan))
  499. maxchan = mf->numvoices;
  501. if(maxchan<mf->numchn) mf->flags |= UF_NNA;
  503. if(MikMod_SetNumVoices_internal(maxchan,-1)) {
  504. _mm_iobase_revert();
  505. Player_Free(mf);
  506. return NULL;
  507. }
  508. }
  509. if(SL_LoadSamples()) {
  510. _mm_iobase_revert();
  511. Player_Free_internal(mf);
  512. return NULL;
  513. }
  514. if(Player_Init(mf)) {
  515. _mm_iobase_revert();
  516. Player_Free_internal(mf);
  517. mf=NULL;
  518. }
  519. _mm_iobase_revert();
  520. return mf;
  521. }
  523. MIKMODAPI MODULE* Player_LoadGeneric(MREADER *reader,int maxchan,BOOL curious)
  524. {
  525. MODULE* result;
  527. MUTEX_LOCK(vars);
  528. MUTEX_LOCK(lists);
  529. result=Player_LoadGeneric_internal(reader,maxchan,curious);
  530. MUTEX_UNLOCK(lists);
  531. MUTEX_UNLOCK(vars);
  533. return result;
  534. }
  536. /* Loads a module given a file pointer.
  537.    File is loaded from the current file seek position. */
  538. MIKMODAPI MODULE* Player_LoadFP(FILE* fp,int maxchan,BOOL curious)
  539. {
  540. MODULE* result=NULL;
  541. struct MREADER* reader=_mm_new_file_reader (fp);
  543. if (reader) {
  544. result=Player_LoadGeneric(reader,maxchan,curious);
  545. _mm_delete_file_reader(reader);
  546. }
  547. return result;
  548. }
  550. /* Open a module via its filename.  The loader will initialize the specified
  551.    song-player 'player'. */
  552. MIKMODAPI MODULE* Player_Load(CHAR* filename,int maxchan,BOOL curious)
  553. {
  554. FILE *fp;
  555. MODULE *mf=NULL;
  557. if((fp=_mm_fopen(filename,"rb"))) {
  558. mf=Player_LoadFP(fp,maxchan,curious);
  559. _mm_fclose(fp);
  560. }
  561. return mf;
  562. }
  564. /* ex:set ts=4: */