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-buff.c < prev    next >
C/C++ Source or Header  |  1990-06-17  |  6KB  |  183 lines
  1. /* med-buff.c: MED buffer handling routines, ⌐ 1990 by Teijo Kinnunen */
  2. #include <math.h> /* min(), abs() */
  3. #include "med.h"
  4. #include "medproto.h"
  5.  
  6. static UBYTE *buffer, bufftracks;
  7. static UBYTE markblock, marktrack, markline;
  8. static UWORD bufflines;
  9. extern UBYTE currtrk,blocks;
  10. extern UWORD pblock,pline;
  11. extern WORD actplayline;
  12. extern struct Lohko *lohko[];
  13.  
  14. void FreeBuffer()
  15. {
  16.     if(!buffer) return;
  17.     FreeMem((void *)buffer, bufftracks * bufflines * 3);
  18.     bufftracks = bufflines = 0;
  19.     buffer = NULL;
  20. }
  21.  
  22. BOOL AllocBuffer(UBYTE tracks,UWORD lines) /* FALSE = ok, TRUE = error */
  23. {
  24.     FreeBuffer(); /* free the previous buffer */
  25.     if(!(buffer = AllocMem(tracks * lines * 3,MEMF_PUBLIC))) return(TRUE);
  26.     bufftracks = tracks;
  27.     bufflines = lines;
  28.     return(FALSE);
  29. }
  30.  
  31. void CutCopyPaste(UBYTE block,UBYTE startline,UWORD lines,UBYTE starttrack,
  32.     UBYTE tracks,UBYTE op) /* op: 0 = copy, 1 = cut, 2 = paste, 3 = swap */
  33. {
  34.     UWORD linecnt;
  35.     UBYTE ntrks = lohko[block]->numtracks; /* tracks in the block */
  36.     UBYTE *p1 = &lohko[block]->music[startline * ntrks * 3 +
  37.                 starttrack * 3],*p2,trkcnt,swb;
  38.     UBYTE *linep1,*linep2;
  39.     if(starttrack + tracks > ntrks) tracks = ntrks - starttrack;
  40.     if(startline + lines > lohko[block]->lines + 1)
  41.         lines = lohko[block]->lines + 1 - startline;
  42.     if((op == 0 || op == 1) && AllocBuffer(tracks,lines)) { Ilmoita(nomem); return; }
  43.     else if(op >= 2) {
  44.         if(lines > bufflines) lines = bufflines;
  45.         if(tracks > bufftracks) tracks = bufftracks;
  46.     }
  47.     if(!(p2 = buffer)) { Ilmoita("The buffer is empty."); return; }
  48.     for(linecnt = 0; linecnt < lines; linecnt++) {
  49.         linep1 = p1; linep2 = p2;
  50.         for(trkcnt = 0; trkcnt < tracks; trkcnt++) {
  51.             if(op == 0 || op == 1) { /* cut/copy */
  52.                 *p2=*p1; *(p2+1)=*(p1+1); *(p2+2)=*(p1+2);
  53.                 if(op == 1) *p1 = *(p1+1) = *(p1+2) = 0;
  54.             } else if(op == 2) { /* paste */
  55.                 *p1=*p2; *(p1+1)=*(p2+1); *(p1+2)=*(p2+2);
  56.             } else if(op == 3) { /* swap */
  57.                 swb = *p1; *p1 = *p2; *p2 = swb;
  58.                 swb=*(p1+1); *(p1+1)=*(p2+1); *(p2+1)=swb;
  59.                 swb=*(p1+2); *(p1+2)=*(p2+2); *(p2+2)=swb;
  60.             }
  61.             p1 += 3; p2 += 3; /* advance pointers one note */
  62.         }
  63.         p1 = linep1 + 3 * ntrks; /* advance blockptr one line */
  64.         p2 = linep2 + 3 * bufftracks; /* advance buffptr 1 line */
  65.     }
  66. }
  67.  
  68. void SetMark()
  69. {
  70.     markblock = (UBYTE)pblock;
  71.     markline = (UBYTE)pline;
  72.     marktrack = (UBYTE)currtrk;
  73. }
  74.  
  75. void HandleMark(UBYTE code)
  76. {
  77.     UBYTE block = pblock,line = pline,track = currtrk;
  78.     if(markblock != pblock && code != 0x34) {
  79.         Ilmoita("One block at a time, please."); return;
  80.     }
  81.     if(code == 0x34) CutCopyPaste((UBYTE)block,(UBYTE)line,
  82.         bufflines,(UBYTE)currtrk,bufftracks,2);
  83.     else    CutCopyPaste((UBYTE)block,(UBYTE)min(markline,line),
  84.         (UWORD)(abs(markline-line)+1),(UBYTE)min(marktrack,track),
  85.         (UBYTE)(abs(marktrack - track) + 1),
  86.         (UBYTE)(code == 0x32 ? 1 : 0));
  87.     PaivitaNaytto(TRUE);
  88. }
  89.  
  90. void ExpandBlock(UWORD block)
  91. {
  92.     UBYTE tracks;
  93.     WORD linecnt,lines,oldl = lohko[block]->lines;
  94.     ULONG hlmsks[4];
  95.     if(lohko[block]->lines > 127) {
  96.         Ilmoita("Too many lines.");
  97.         return;
  98.     }
  99.     tracks = lohko[block]->numtracks;
  100.     if(ChangeBlockSize(block,(UWORD)(tracks / 4),
  101.         (UWORD)((lohko[block]->lines + 1) * 2))) {
  102.             Ilmoita(nomem); return;
  103.     }
  104.     lines = (WORD)(lohko[block]->lines);
  105.     for(linecnt = lines; linecnt >= 0; linecnt--) {
  106.         if(linecnt & 0x1) /* clear odd-numbered lines */
  107.             memset(&lohko[block]->music[linecnt * 3 * tracks],
  108.                 0,3 * tracks);
  109.         else    memcpy(&lohko[block]->music[linecnt * 3 * tracks],
  110.                 &lohko[block]->music[linecnt / 2 *
  111.                 3 * tracks], 3 * tracks);
  112.     }
  113.     for(linecnt = 0; linecnt < 4; linecnt++) hlmsks[linecnt] =
  114.         lohko[block]->hlmask[linecnt];
  115.     for(linecnt = 0; linecnt < 8; linecnt++) lohko[block]->hlmask[linecnt] = 0L;
  116.     for(linecnt = 0; linecnt <= oldl; linecnt++)
  117.         if(hlmsks[linecnt /á32] & (1 << (linecnt & 31))) HLLine(block,(UBYTE)(linecnt * 2));
  118.     PaivitaNaytto(TRUE);
  119.     TulostaLohkoJaSoitin();
  120. }
  121.  
  122. void ShrinkBlock(UWORD block)
  123. {
  124.     UBYTE tracks = lohko[block]->numtracks;
  125.     ULONG hlmsks[8];
  126.     WORD linecnt,lines = lohko[block]->lines;
  127.     if(!lines) { Ilmoita("Can't split a line."); return; }
  128.     for(linecnt = 0; linecnt <= lines ; linecnt++)
  129.         memcpy(&lohko[block]->music[linecnt * 3 * tracks],
  130.             &lohko[block]->music[linecnt * 6 * tracks],3 * tracks);
  131.     ChangeBlockSize(block,(UWORD)(tracks / 4),(UWORD)((lines + 1) /á2));
  132.     lines = lohko[block]->lines;
  133.     for(linecnt = 0; linecnt < 8; linecnt++) {
  134.         hlmsks[linecnt] = lohko[block]->hlmask[linecnt];
  135.         lohko[block]->hlmask[linecnt] = 0L;
  136.     }
  137.     for(linecnt = 0; linecnt <= lines * 2; linecnt += 2)
  138.         if(hlmsks[linecnt /á32] & (1 << (linecnt & 31))) HLLine(block,(UBYTE)(linecnt / 2));
  139.     PaivitaNaytto(TRUE);
  140.     TulostaLohkoJaSoitin();
  141. }
  142.  
  143.  
  144. void SplitBlock(UWORD block,UWORD line)
  145. {
  146.     UBYTE trks = lohko[block]->numtracks;
  147.     UWORD lines = lohko[block]->lines + 1;
  148.     if(!line) return; /* can't split */
  149.     if(NewBlockHere(block,(UWORD)trks,line)) return;
  150.     memcpy(lohko[block]->music,lohko[block+1]->music,3 * line * trks);
  151.     movmem(&lohko[block+1]->music[3 * line * trks],
  152.         lohko[block+1]->music,3 * trks * (lines - line));
  153.     ChangeBlockSize((UWORD)(block+1),(UWORD)(trks /á4),(UWORD)(lines - line));
  154.     Disable();
  155.     pblock = block + 1;
  156.     pline = 0;
  157.     actplayline = -1;
  158.     Enable();
  159.     PaivitaNaytto(TRUE);
  160.     TulostaLohkoJaSoitin(); 
  161. }
  162.  
  163. void JoinBlocks(UWORD block)
  164. {
  165.     UWORD lines,l2 = lohko[block]->lines;
  166.     if(block >= blocks - 1) {
  167.         Ilmoita("This is the last block.");
  168.         return;
  169.     }
  170.     lines = l2 + lohko[block + 1]->lines + 2;
  171.     if(lines > 256) {
  172.         Ilmoita("Blocks are too long."); return;
  173.     }
  174.     if(ChangeBlockSize(block,(UWORD)(lohko[block]->numtracks /á4),lines)) {
  175.         Ilmoita(nomem);
  176.         return;
  177.     }
  178.     memcpy(&lohko[block]->music[3 * lohko[block]->numtracks *
  179.         (l2 + 1)],lohko[block+1]->music,3 * lohko[block]
  180.         ->numtracks * (lohko[block+1]->lines + 1));
  181.     DelBlockHere((UWORD)(block + 1));
  182. }
  183.