home *** CD-ROM | disk | FTP | other *** search
/ Audio 4.94 - Over 11,000 Files / audio-11000.iso / amiga / midi / med210.lhw / in.adf / Source / med210src.lzh / med-stmod.c < prev    next >
C/C++ Source or Header  |  1990-06-17  |  6KB  |  192 lines
  1. /* MED-stmod.c: SoundTracker 2.x module load/save & ST-song save functions
  2.         ⌐ 1989, 1990 by Teijo Kinnunen */
  3. #include "med.h"
  4. #include "medproto.h"
  5.  
  6. extern struct Kappale far song;
  7. extern UBYTE samplenum,blocks;
  8. extern struct Gadget far gadget3[];
  9. extern struct Soitin *sample[];
  10. extern struct Lohko *lohko[];
  11. extern BPTR fh;
  12.  
  13. static void __regargs ConvertToST(UBYTE,UBYTE *);
  14.  
  15. char *STModLoader(char *name)
  16. {
  17.     struct ST24Mod stsong = { 0 };
  18.     UBYTE scntr,*cnvblk;
  19.     long modlen,samplelen = 0,readlen;
  20.     if(*name == '\0') return(AskName());
  21.     if(!(fh = Open2(name,MODE_OLDFILE))) return(DISKERR);
  22.     if(AlustaKappale(TRUE)) return(nomem);
  23.     NollaaVarit();
  24.     blocks = 0;
  25.     Ilmoita("Loading ST/NT-module...");
  26.     Seek(fh,0,OFFSET_END);
  27.     modlen = Seek(fh,0,OFFSET_BEGINNING);
  28.     if(Read(fh,(void *)&stsong,sizeof(struct ST24Mod)) <
  29.         sizeof(struct ST24Mod)) return(DISKERR);
  30.     modlen -= sizeof(struct ST24Mod); /* length of the remaining part */
  31.     for(scntr = 0; scntr < 31; scntr++) {
  32.         samplelen += stsong.sample[scntr].length * 2;
  33.     }
  34.     modlen -= samplelen;
  35.     if(modlen < 0) return("Not a valid module.");
  36.     if(!(cnvblk = AllocMem(1028,MEMF_PUBLIC))) return(nomem);
  37.     Ilmoita("Loading blocks...");
  38.     while(modlen > 0) {    /* Load the song */
  39.         if(blocks >= 100) break; /* too many blocks */
  40.         if(AllocBlock((UWORD)blocks,4,64)) {
  41.             FreeMem(cnvblk,1028);
  42.             return(nomem);
  43.         }
  44.         blocks++;
  45.         TulostaLohkoJaSoitin();
  46.         if(modlen > 1024) readlen = 1024;
  47.         else { readlen = modlen; memset((void *)cnvblk,0,1028); }
  48.         if(Read(fh,cnvblk+4,readlen) < readlen) {
  49.             FreeMem(cnvblk,1028);
  50.             return(DISKERR);
  51.         }
  52.         modlen -= readlen;
  53.         ConvertTo200(cnvblk,(UBYTE *)lohko[blocks-1],TRUE);
  54.     }
  55.     FreeMem(cnvblk,1028);
  56.     song.numblocks = blocks;
  57.     song.deftempo = 6;
  58.     song.songlen = stsong.songlen;
  59.     song.flags |= FLAG_VOLHEX|FLAG_STSLIDE;
  60.     memcpy((char *)(song.playseq),(char *)(stsong.playseq),128);
  61.     for(scntr = 0; scntr < 31; scntr++) {
  62.         strcpy(song.sample[scntr].sname,stsong.sample[scntr].name);
  63.         song.sample[scntr].svol = stsong.sample[scntr].volume;
  64.         song.sample[scntr].rep = stsong.sample[scntr].repeat;
  65.         song.sample[scntr].replen = stsong.sample[scntr].replen;
  66.     }
  67.     StripPaths();
  68.     PaivitaNaytto(TRUE);
  69.     DispVolAndSldType();
  70.     SetTempo(6);
  71.     Ilmoita("Loading samples...");
  72.     samplenum = 0;
  73.     PaivitaSoittimennimi();
  74.     for(scntr = 0; scntr < 31; scntr++) {
  75.         samplelen = stsong.sample[scntr].length * 2;
  76.         if(samplelen) {
  77.             if(NewInstrument(samplelen,samplenum)) return(nomem);
  78.             if(Read(fh,(char *)(sample[samplenum]) +
  79.                 sizeof(struct Soitin),samplelen) <
  80.                   samplelen) return(DISKERR);
  81.         }
  82.         SeurSoitin();
  83.     }
  84.     samplenum = 0;
  85.     PaivitaSoittimennimi();
  86.     Close(fh); fh = 0L;
  87.     Ilmoita("Module loaded.");
  88.     return(NOERR);
  89. }
  90.  
  91. static void __regargs ConvertToST(UBYTE block,UBYTE *bgto)
  92. {
  93.     extern UWORD periodit[];
  94.     register UWORD cnt,cnt2,per;
  95.     register UBYTE instrG_V,nnum,*to,*from;
  96.     memset(bgto,0,1024);
  97.     for(cnt = 0; cnt < 64; cnt++) {
  98.         to = bgto + 16 * cnt;
  99.         from = &lohko[block]->music[cnt * lohko[block]->numtracks * 3];
  100.         if(cnt > lohko[block]->lines) {
  101.             *(to-1) = 0;
  102.             *(to-2) &= 0xf0;
  103.             *(to-2) |= 0x0d; /* insert pattern break */
  104.             break;
  105.         }
  106.         for(cnt2 = 0; cnt2 < 4; cnt2++) {
  107.             nnum = *from++;
  108.             instrG_V = 0;
  109.             if(nnum & 0x80) instrG_V = 1;
  110.             if(nnum & 0x40) instrG_V += 2;
  111.             if(!(nnum &= 0x3f)) per = 0;
  112.             else per = periodit[nnum - 1];
  113.             if(instrG_V) per |= (instrG_V << 12);
  114.             *to++ = (UBYTE)(per >> 8);
  115.             *to++ = (UBYTE)(per & 0xff);
  116.             nnum = *from++; /* Reuse the register variables */
  117.             instrG_V = *from++;
  118.             *to = nnum & 0xf0;
  119.             switch(nnum & 0x0f) {
  120.                 case 0xF: if(!instrG_V) *to |= 0xD;
  121.                       else if(instrG_V == 0xff) {
  122.                         *to |= 0xC;
  123.                         instrG_V = 0;
  124.                       }
  125.                       break;
  126.                 case 0xD: *to |= 0x0A; break;
  127.                 default:  *to |= nnum;
  128.             }
  129.             to++;
  130.             *to++ = instrG_V;
  131.         }
  132.     }
  133. }
  134.  
  135. char *SaveSTMod(char *name)
  136. {
  137.     UBYTE oldexists = 0,scnt,*convblk,lastused = 0;
  138.     ULONG null = NULL;
  139.     struct ST24Mod mod;
  140.     if(*name == '\0') return(AskName());
  141.     if(IsHere(name)) {
  142.         oldexists = 1;
  143.         Ilmoita(fileex);
  144.         if(!Continue()) return(notsaved);
  145.     }
  146.     if(!(fh = Open2(name,MODE_NEWFILE))) return(DISKERR);
  147.     Ilmoita("Saving ST/NT-module...");
  148.     memset((void *)(&mod),0,sizeof(mod));
  149.     strcpy(mod.songname,name);
  150.     for(scnt = 0; scnt < 32; scnt++) {
  151.         strcpy(mod.sample[scnt].name,song.sample[scnt].sname);
  152.         mod.sample[scnt].length = sample[scnt]->length / 2;
  153.         if(sample[scnt]) mod.sample[scnt].volume = song.sample[scnt].svol;
  154.         mod.sample[scnt].repeat = song.sample[scnt].rep;
  155.         if(song.sample[scnt].replen < 2) mod.sample[scnt].replen = 1;
  156.         else mod.sample[scnt].replen = song.sample[scnt].replen;
  157.     }
  158.     mod.songlen = song.songlen;
  159.     memcpy(mod.playseq,song.playseq,128);
  160.     mod.mk = ((long)'M')<<24|((long)'.')<<16|((long)'K')<<8|'.';
  161.     mod.I_dont_know_what_this_byte_is = 0x78; /* that's it!! */
  162.     if(Write(fh,(char *)(&mod),sizeof(mod)) < sizeof(mod)) return(DISKERR);
  163.     convblk = AllocMem(1024,MEMF_PUBLIC);
  164.     if(!convblk) return(nomem);
  165.     Ilmoita("Saving blocks...");
  166.     for(scnt = 0; scnt < song.songlen; scnt++) /* find last used block */
  167.         if(song.playseq[scnt] > lastused) lastused = song.playseq[scnt];
  168.     for(scnt = 0; scnt <= lastused; scnt++) {
  169.         ConvertToST(scnt,convblk);
  170.         if(Write(fh,convblk,1024) != 1024) {
  171.             FreeMem(convblk,1024);
  172.             return(DISKERR);
  173.         }
  174.     }
  175.     FreeMem(convblk,1024);
  176.     Ilmoita("Saving samples...");
  177.     for(scnt = 0; scnt < 32; scnt++) {
  178.         if(sample[scnt] && sample[scnt]->length > 4) {
  179.             if(Write(fh,(char *)(&null),4) != 4) return(DISKERR);
  180.             if(Write(fh,(char *)sample[scnt] + sizeof(struct
  181.                 Soitin) + 4,sample[scnt]->length - 4) !=
  182.                 sample[scnt]->length - 4)
  183.                 return(DISKERR);
  184.         }
  185.     }
  186.     if(fh) Close(fh);
  187.     fh = 0L;
  188.     if(!oldexists) InsertSavedFile(name);
  189.     Ilmoita("Module saved.");
  190.     return(NOERR);
  191. }
  192.