git.mutantstargoat.com Git - dosdemo/blob - libs/mikmod/playercode/mloader.c

   1 /*      MikMod sound library
   2         (c) 1998, 1999, 2000, 2001, 2002 Miodrag Vallat and others - see file
   3         AUTHORS for complete list.
   4
   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 */
  20
  21 /*==============================================================================
  22
  23   $Id$
  24
  25   These routines are used to access the available module loaders
  26
  27 ==============================================================================*/
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 #ifdef HAVE_UNISTD_H
  34 #include <unistd.h>
  35 #endif
  36
  37 #ifdef HAVE_MEMORY_H
  38 #include <memory.h>
  39 #endif
  40 #include <string.h>
  41
  42 #include "mikmod_internals.h"
  43
  44 #ifdef SUNOS
  45 extern int fprintf(FILE *, const char *, ...);
  46 #endif
  47
  48 MREADER *modreader;
  49 MODULE of;
  50
  51 static  MLOADER *firstloader=NULL;
  52
  53 static  MUNPACKER unpackers[] = {
  54         PP20_Unpack,
  55         MMCMP_Unpack,
  56         XPK_Unpack,
  57         S404_Unpack,
  58         NULL
  59 };
  60
  61 const UWORD finetune[16] = {
  62         8363,8413,8463,8529,8581,8651,8723,8757,
  63         7895,7941,7985,8046,8107,8169,8232,8280
  64 };
  65
  66 MIKMODAPI CHAR* MikMod_InfoLoader(void)
  67 {
  68         int len=0;
  69         MLOADER *l;
  70         CHAR *list=NULL;
  71
  72         MUTEX_LOCK(lists);
  73         /* compute size of buffer */
  74         for(l = firstloader; l; l = l->next)
  75                 len += 1 + (l->next ? 1 : 0) + strlen(l->version);
  76
  77         if(len)
  78           if((list=(CHAR*)MikMod_malloc(len*sizeof(CHAR))) != NULL) {
  79                 CHAR *list_end = list;
  80                 list[0] = 0;
  81                 /* list all registered module loders */
  82                 for(l = firstloader; l; l = l->next) {
  83                     list_end += sprintf(list_end, "%s%s", l->version, (l->next) ? "\n" : "");
  84                 }
  85         }
  86         MUTEX_UNLOCK(lists);
  87         return list;
  88 }
  89
  90 void _mm_registerloader(MLOADER* ldr)
  91 {
  92         MLOADER *cruise=firstloader;
  93
  94         if(cruise) {
  95                 while(cruise->next) cruise = cruise->next;
  96                 cruise->next=ldr;
  97         } else
  98                 firstloader=ldr;
  99 }
 100
 101 MIKMODAPI void MikMod_RegisterLoader(struct MLOADER* ldr)
 102 {
 103         /* if we try to register an invalid loader, or an already registered loader,
 104            ignore this attempt */
 105         if ((!ldr)||(ldr->next))
 106                 return;
 107
 108         MUTEX_LOCK(lists);
 109         _mm_registerloader(ldr);
 110         MUTEX_UNLOCK(lists);
 111 }
 112
 113 BOOL ReadComment(UWORD len)
 114 {
 115         if(len) {
 116                 int i;
 117
 118                 if(!(of.comment=(CHAR*)MikMod_malloc(len+1))) return 0;
 119                 _mm_read_UBYTES(of.comment,len,modreader);
 120
 121                 /* translate IT linefeeds */
 122                 for(i=0;i<len;i++)
 123                         if(of.comment[i]=='\r') of.comment[i]='\n';
 124
 125                 of.comment[len]=0;      /* just in case */
 126         }
 127         if(!of.comment[0]) {
 128                 MikMod_free(of.comment);
 129                 of.comment=NULL;
 130         }
 131         return 1;
 132 }
 133
 134 BOOL ReadLinedComment(UWORD len,UWORD linelen)
 135 {
 136         CHAR *tempcomment,*line,*storage;
 137         UWORD total=0,t,lines;
 138         int i;
 139
 140         lines = (len + linelen - 1) / linelen;
 141         if (len) {
 142                 if(!(tempcomment=(CHAR*)MikMod_malloc(len+1))) return 0;
 143                 if(!(storage=(CHAR*)MikMod_malloc(linelen+1))) {
 144                         MikMod_free(tempcomment);
 145                         return 0;
 146                 }
 147                 memset(tempcomment, ' ', len);
 148                 _mm_read_UBYTES(tempcomment,len,modreader);
 149
 150                 /* compute message length */
 151                 for(line=tempcomment,total=t=0;t<lines;t++,line+=linelen) {
 152                         for(i=linelen;(i>=0)&&(line[i]==' ');i--) line[i]=0;
 153                         for(i=0;i<linelen;i++) if (!line[i]) break;
 154                         total+=1+i;
 155                 }
 156
 157                 if(total>lines) {
 158                         if(!(of.comment=(CHAR*)MikMod_malloc(total+1))) {
 159                                 MikMod_free(storage);
 160                                 MikMod_free(tempcomment);
 161                                 return 0;
 162                         }
 163
 164                         /* convert message */
 165                         for(line=tempcomment,t=0;t<lines;t++,line+=linelen) {
 166                                 for(i=0;i<linelen;i++) if(!(storage[i]=line[i])) break;
 167                                 storage[i]=0; /* if (i==linelen) */
 168                                 strcat(of.comment,storage);strcat(of.comment,"\r");
 169                         }
 170                         MikMod_free(storage);
 171                         MikMod_free(tempcomment);
 172                 }
 173         }
 174         return 1;
 175 }
 176
 177 BOOL AllocPositions(int total)
 178 {
 179         if(!total) {
 180                 _mm_errno=MMERR_NOT_A_MODULE;
 181                 return 0;
 182         }
 183         if(!(of.positions=(UWORD*)MikMod_calloc(total,sizeof(UWORD)))) return 0;
 184         return 1;
 185 }
 186
 187 BOOL AllocPatterns(void)
 188 {
 189         int s,t,tracks = 0;
 190
 191         if((!of.numpat)||(!of.numchn)) {
 192                 _mm_errno=MMERR_NOT_A_MODULE;
 193                 return 0;
 194         }
 195         /* Allocate track sequencing array */
 196         if(!(of.patterns=(UWORD*)MikMod_calloc((ULONG)(of.numpat+1)*of.numchn,sizeof(UWORD)))) return 0;
 197         if(!(of.pattrows=(UWORD*)MikMod_calloc(of.numpat+1,sizeof(UWORD)))) return 0;
 198
 199         for(t=0;t<=of.numpat;t++) {
 200                 of.pattrows[t]=64;
 201                 for(s=0;s<of.numchn;s++)
 202                 of.patterns[(t*of.numchn)+s]=tracks++;
 203         }
 204
 205         return 1;
 206 }
 207
 208 BOOL AllocTracks(void)
 209 {
 210         if(!of.numtrk) {
 211                 _mm_errno=MMERR_NOT_A_MODULE;
 212                 return 0;
 213         }
 214         if(!(of.tracks=(UBYTE **)MikMod_calloc(of.numtrk,sizeof(UBYTE *)))) return 0;
 215         return 1;
 216 }
 217
 218 BOOL AllocInstruments(void)
 219 {
 220         int t,n;
 221
 222         if(!of.numins) {
 223                 _mm_errno=MMERR_NOT_A_MODULE;
 224                 return 0;
 225         }
 226         if(!(of.instruments=(INSTRUMENT*)MikMod_calloc(of.numins,sizeof(INSTRUMENT))))
 227                 return 0;
 228
 229         for(t=0;t<of.numins;t++) {
 230                 for(n=0;n<INSTNOTES;n++) {
 231                         /* Init note / sample lookup table */
 232                         of.instruments[t].samplenote[n]   = n;
 233                         of.instruments[t].samplenumber[n] = t;
 234                 }
 235                 of.instruments[t].globvol = 64;
 236         }
 237         return 1;
 238 }
 239
 240 BOOL AllocSamples(void)
 241 {
 242         UWORD u;
 243
 244         if(!of.numsmp) {
 245                 _mm_errno=MMERR_NOT_A_MODULE;
 246                 return 0;
 247         }
 248         if(!(of.samples=(SAMPLE*)MikMod_calloc(of.numsmp,sizeof(SAMPLE)))) return 0;
 249
 250         for(u=0;u<of.numsmp;u++) {
 251                 of.samples[u].panning = 128; /* center */
 252                 of.samples[u].handle  = -1;
 253                 of.samples[u].globvol = 64;
 254                 of.samples[u].volume  = 64;
 255         }
 256         return 1;
 257 }
 258
 259 static BOOL ML_LoadSamples(void)
 260 {
 261         SAMPLE *s;
 262         int u;
 263
 264         for(u=of.numsmp,s=of.samples;u;u--,s++)
 265                 if(s->length) SL_RegisterSample(s,MD_MUSIC,modreader);
 266
 267         return 1;
 268 }
 269
 270 /* Creates a CSTR out of a character buffer of 'len' bytes, but strips any
 271    terminating non-printing characters like 0, spaces etc. */
 272 CHAR *DupStr(const CHAR* s, UWORD len, BOOL strict)
 273 {
 274         UWORD t;
 275         CHAR *d=NULL;
 276
 277         /* Scan for last printing char in buffer [includes high ascii up to 254] */
 278         while(len) {
 279                 if(s[len-1]>0x20) break;
 280                 len--;
 281         }
 282
 283         /* Scan forward for possible NULL character */
 284         if(strict) {
 285                 for(t=0;t<len;t++) if (!s[t]) break;
 286                 if (t<len) len=t;
 287         }
 288
 289         /* When the buffer wasn't completely empty, allocate a cstring and copy the
 290            buffer into that string, except for any control-chars */
 291         if((d=(CHAR*)MikMod_malloc(sizeof(CHAR)*(len+1))) != NULL) {
 292                 for(t=0;t<len;t++) d[t]=(s[t]<32)?'.':s[t];
 293                 d[len]=0;
 294         }
 295         return d;
 296 }
 297
 298 static void ML_XFreeSample(SAMPLE *s)
 299 {
 300         if(s->handle>=0)
 301                 MD_SampleUnload(s->handle);
 302
 303 /* moved samplename freeing to our caller ML_FreeEx(),
 304  * because we are called conditionally. */
 305 }
 306
 307 static void ML_XFreeInstrument(INSTRUMENT *i)
 308 {
 309         MikMod_free(i->insname);
 310 }
 311
 312 static void ML_FreeEx(MODULE *mf)
 313 {
 314         UWORD t;
 315
 316         MikMod_free(mf->songname);
 317         MikMod_free(mf->comment);
 318
 319         MikMod_free(mf->modtype);
 320         MikMod_free(mf->positions);
 321         MikMod_free(mf->patterns);
 322         MikMod_free(mf->pattrows);
 323
 324         if(mf->tracks) {
 325                 for(t=0;t<mf->numtrk;t++)
 326                         MikMod_free(mf->tracks[t]);
 327                 MikMod_free(mf->tracks);
 328         }
 329         if(mf->instruments) {
 330                 for(t=0;t<mf->numins;t++)
 331                         ML_XFreeInstrument(&mf->instruments[t]);
 332                 MikMod_free(mf->instruments);
 333         }
 334         if(mf->samples) {
 335                 for(t=0;t<mf->numsmp;t++) {
 336                         MikMod_free(mf->samples[t].samplename);
 337                         if(mf->samples[t].length) ML_XFreeSample(&mf->samples[t]);
 338                 }
 339                 MikMod_free(mf->samples);
 340         }
 341         memset(mf,0,sizeof(MODULE));
 342         if(mf!=&of) MikMod_free(mf);
 343 }
 344
 345 static MODULE *ML_AllocUniMod(void)
 346 {
 347         return (MODULE *) MikMod_malloc(sizeof(MODULE));
 348 }
 349
 350 static BOOL ML_TryUnpack(MREADER *reader,void **out,long *outlen)
 351 {
 352         int i;
 353
 354         *out = NULL;
 355         *outlen = 0;
 356
 357         for(i=0;unpackers[i]!=NULL;++i) {
 358                 _mm_rewind(reader);
 359                 if(unpackers[i](reader,out,outlen)) return 1;
 360         }
 361         return 0;
 362 }
 363
 364 static void Player_Free_internal(MODULE *mf)
 365 {
 366         if(mf) {
 367                 Player_Exit_internal(mf);
 368                 ML_FreeEx(mf);
 369         }
 370 }
 371
 372 MIKMODAPI void Player_Free(MODULE *mf)
 373 {
 374         MUTEX_LOCK(vars);
 375         Player_Free_internal(mf);
 376         MUTEX_UNLOCK(vars);
 377 }
 378
 379 static CHAR* Player_LoadTitle_internal(MREADER *reader)
 380 {
 381         MLOADER *l;
 382         CHAR *title;
 383         void *unpk;
 384         long newlen;
 385
 386         modreader=reader;
 387         _mm_errno = 0;
 388         _mm_critical = 0;
 389         _mm_iobase_setcur(modreader);
 390
 391         if(ML_TryUnpack(modreader,&unpk,&newlen)) {
 392                 if(!(modreader=_mm_new_mem_reader(unpk,newlen))) {
 393                         modreader=reader;
 394                         MikMod_free(unpk);
 395                         return NULL;
 396                 }
 397         }
 398
 399         /* Try to find a loader that recognizes the module */
 400         for(l=firstloader;l;l=l->next) {
 401                 _mm_rewind(modreader);
 402                 if(l->Test()) break;
 403         }
 404
 405         if(l) {
 406                 title = l->LoadTitle();
 407         }
 408         else {
 409                 _mm_errno = MMERR_NOT_A_MODULE;
 410                 if(_mm_errorhandler) _mm_errorhandler();
 411                 title = NULL;
 412         }
 413
 414         if (modreader!=reader) {
 415                 _mm_delete_mem_reader(modreader);
 416                 modreader=reader;
 417                 MikMod_free(unpk);
 418         }
 419         return title;
 420 }
 421
 422 MIKMODAPI CHAR* Player_LoadTitleFP(FILE *fp)
 423 {
 424         CHAR* result=NULL;
 425         MREADER* reader;
 426
 427         if(fp && (reader=_mm_new_file_reader(fp)) != NULL) {
 428                 MUTEX_LOCK(lists);
 429                 result=Player_LoadTitle_internal(reader);
 430                 MUTEX_UNLOCK(lists);
 431                 _mm_delete_file_reader(reader);
 432         }
 433         return result;
 434 }
 435
 436 MIKMODAPI CHAR* Player_LoadTitleMem(const char *buffer,int len)
 437 {
 438         CHAR *result=NULL;
 439         MREADER* reader;
 440
 441         if (!buffer || len <= 0) return NULL;
 442         if ((reader=_mm_new_mem_reader(buffer,len)) != NULL)
 443         {
 444                 MUTEX_LOCK(lists);
 445                 result=Player_LoadTitle_internal(reader);
 446                 MUTEX_UNLOCK(lists);
 447                 _mm_delete_mem_reader(reader);
 448         }
 449
 450         return result;
 451 }
 452
 453 MIKMODAPI CHAR* Player_LoadTitleGeneric(MREADER *reader)
 454 {
 455         CHAR *result=NULL;
 456
 457         if (reader) {
 458                 MUTEX_LOCK(lists);
 459                 result=Player_LoadTitle_internal(reader);
 460                 MUTEX_UNLOCK(lists);
 461         }
 462         return result;
 463 }
 464
 465 MIKMODAPI CHAR* Player_LoadTitle(const CHAR* filename)
 466 {
 467         CHAR* result=NULL;
 468         FILE* fp;
 469         MREADER* reader;
 470
 471         if((fp=_mm_fopen(filename,"rb")) != NULL) {
 472                 if((reader=_mm_new_file_reader(fp)) != NULL) {
 473                         MUTEX_LOCK(lists);
 474                         result=Player_LoadTitle_internal(reader);
 475                         MUTEX_UNLOCK(lists);
 476                         _mm_delete_file_reader(reader);
 477                 }
 478                 _mm_fclose(fp);
 479         }
 480         return result;
 481 }
 482
 483 /* Loads a module given an reader */
 484 static MODULE* Player_LoadGeneric_internal(MREADER *reader,int maxchan,BOOL curious)
 485 {
 486         int t;
 487         MLOADER *l;
 488         BOOL ok;
 489         MODULE *mf;
 490         void *unpk;
 491         long newlen;
 492
 493         modreader = reader;
 494         _mm_errno = 0;
 495         _mm_critical = 0;
 496         _mm_iobase_setcur(modreader);
 497
 498         if(ML_TryUnpack(modreader,&unpk,&newlen)) {
 499                 if(!(modreader=_mm_new_mem_reader(unpk,newlen))) {
 500                         modreader=reader;
 501                         MikMod_free(unpk);
 502                         return NULL;
 503                 }
 504         }
 505
 506         /* Try to find a loader that recognizes the module */
 507         for(l=firstloader;l;l=l->next) {
 508                 _mm_rewind(modreader);
 509                 if(l->Test()) break;
 510         }
 511
 512         if(!l) {
 513                 _mm_errno = MMERR_NOT_A_MODULE;
 514                 if(modreader!=reader) {
 515                         _mm_delete_mem_reader(modreader);
 516                         modreader=reader;
 517                         MikMod_free(unpk);
 518                 }
 519                 if(_mm_errorhandler) _mm_errorhandler();
 520                 _mm_rewind(modreader);
 521                 _mm_iobase_revert(modreader);
 522                 return NULL;
 523         }
 524
 525         /* init unitrk routines */
 526         if(!UniInit()) {
 527                 if(modreader!=reader) {
 528                         _mm_delete_mem_reader(modreader);
 529                         modreader=reader;
 530                         MikMod_free(unpk);
 531                 }
 532                 if(_mm_errorhandler) _mm_errorhandler();
 533                 _mm_rewind(modreader);
 534                 _mm_iobase_revert(modreader);
 535                 return NULL;
 536         }
 537
 538         /* init the module structure with vanilla settings */
 539         memset(&of,0,sizeof(MODULE));
 540         of.bpmlimit = 33;
 541         of.initvolume = 128;
 542         for (t = 0; t < UF_MAXCHAN; t++) of.chanvol[t] = 64;
 543         for (t = 0; t < UF_MAXCHAN; t++)
 544                 of.panning[t] = ((t + 1) & 2) ? PAN_RIGHT : PAN_LEFT;
 545
 546         /* init module loader and load the header / patterns */
 547         if (!l->Init || l->Init()) {
 548                 _mm_rewind(modreader);
 549                 ok = l->Load(curious);
 550                 if (ok) {
 551                         /* propagate inflags=flags for in-module samples */
 552                         for (t = 0; t < of.numsmp; t++)
 553                                 if (of.samples[t].inflags == 0)
 554                                         of.samples[t].inflags = of.samples[t].flags;
 555                 }
 556         } else
 557                 ok = 0;
 558
 559         /* free loader and unitrk allocations */
 560         if (l->Cleanup) l->Cleanup();
 561         UniCleanup();
 562
 563         if(ok) ok = ML_LoadSamples();
 564         if(ok) ok = ((mf=ML_AllocUniMod()) != NULL);
 565         if(!ok) {
 566                 ML_FreeEx(&of);
 567                 if(modreader!=reader) {
 568                         _mm_delete_mem_reader(modreader);
 569                         modreader=reader;
 570                         MikMod_free(unpk);
 571                 }
 572                 if(_mm_errorhandler) _mm_errorhandler();
 573                 _mm_rewind(modreader);
 574                 _mm_iobase_revert(modreader);
 575                 return NULL;
 576         }
 577
 578         /* If the module doesn't have any specific panning, create a
 579            MOD-like panning, with the channels half-separated. */
 580         if (!(of.flags & UF_PANNING))
 581                 for (t = 0; t < of.numchn; t++)
 582                         of.panning[t] = ((t + 1) & 2) ? PAN_HALFRIGHT : PAN_HALFLEFT;
 583
 584         /* Copy the static MODULE contents into the dynamic MODULE struct. */
 585         memcpy(mf,&of,sizeof(MODULE));
 586
 587         if(maxchan>0) {
 588                 if(!(mf->flags&UF_NNA)&&(mf->numchn<maxchan))
 589                         maxchan = mf->numchn;
 590                 else
 591                   if((mf->numvoices)&&(mf->numvoices<maxchan))
 592                         maxchan = mf->numvoices;
 593
 594                 if(maxchan<mf->numchn) mf->flags |= UF_NNA;
 595
 596                 ok = !MikMod_SetNumVoices_internal(maxchan,-1);
 597         }
 598
 599         if(ok) ok = !SL_LoadSamples();
 600         if(ok) ok = !Player_Init(mf);
 601
 602         if(modreader!=reader) {
 603                 _mm_delete_mem_reader(modreader);
 604                 modreader=reader;
 605                 MikMod_free(unpk);
 606         }
 607         _mm_iobase_revert(modreader);
 608
 609         if(!ok) {
 610                 Player_Free_internal(mf);
 611                 return NULL;
 612         }
 613         return mf;
 614 }
 615
 616 MIKMODAPI MODULE* Player_LoadGeneric(MREADER *reader,int maxchan,BOOL curious)
 617 {
 618         MODULE* result;
 619
 620         MUTEX_LOCK(vars);
 621         MUTEX_LOCK(lists);
 622                 result=Player_LoadGeneric_internal(reader,maxchan,curious);
 623         MUTEX_UNLOCK(lists);
 624         MUTEX_UNLOCK(vars);
 625
 626         return result;
 627 }
 628
 629 MIKMODAPI MODULE* Player_LoadMem(const char *buffer,int len,int maxchan,BOOL curious)
 630 {
 631         MODULE* result=NULL;
 632         MREADER* reader;
 633
 634         if (!buffer || len <= 0) return NULL;
 635         if ((reader=_mm_new_mem_reader(buffer, len)) != NULL) {
 636                 result=Player_LoadGeneric(reader,maxchan,curious);
 637                 _mm_delete_mem_reader(reader);
 638         }
 639         return result;
 640 }
 641
 642 /* Loads a module given a file pointer.
 643    File is loaded from the current file seek position. */
 644 MIKMODAPI MODULE* Player_LoadFP(FILE* fp,int maxchan,BOOL curious)
 645 {
 646         MODULE* result=NULL;
 647         struct MREADER* reader;
 648
 649         if (fp && (reader=_mm_new_file_reader(fp)) != NULL) {
 650                 result=Player_LoadGeneric(reader,maxchan,curious);
 651                 _mm_delete_file_reader(reader);
 652         }
 653         return result;
 654 }
 655
 656 /* Open a module via its filename.  The loader will initialize the specified
 657    song-player 'player'. */
 658 MIKMODAPI MODULE* Player_Load(const CHAR* filename,int maxchan,BOOL curious)
 659 {
 660         FILE *fp;
 661         MODULE *mf=NULL;
 662
 663         if((fp=_mm_fopen(filename,"rb")) != NULL) {
 664                 mf=Player_LoadFP(fp,maxchan,curious);
 665                 _mm_fclose(fp);
 666         }
 667         return mf;
 668 }
 669
 670 /* ex:set ts=4: */