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.c < prev    next >
C/C++ Source or Header  |  1990-06-25  |  10KB  |  348 lines
  1. /* MED - music editor ⌐ 1989, 1990 by Teijo Kinnunen */
  2. #ifndef PRECOMPILED
  3. #include <exec/types.h>
  4. #include <exec/io.h>
  5. #include <exec/errors.h>
  6. #include <exec/memory.h>
  7. #include <exec/tasks.h>
  8. #include <devices/audio.h>
  9. #include <devices/timer.h>
  10. #include <libraries/dos.h>
  11. #include <libraries/dosextens.h>
  12. #include <intuition/screens.h>
  13. #include <intuition/intuition.h>
  14. #include <hardware/cia.h>
  15. #include <proto/exec.h>
  16. #include <proto/graphics.h>
  17. #include <proto/intuition.h>
  18. #include <proto/dos.h>
  19. #include <string.h>
  20. #include <stdlib.h>
  21. #define PRECOMPILED
  22. #else /* EsikΣΣntΣmistΣ varten */
  23. #include <exec/interrupts.h>
  24. #include <hardware/intbits.h>
  25. #include <hardware/custom.h>
  26. #include <math.h>
  27. #include "med.h"
  28. #include "medproto.h"
  29. /* for cback.o */
  30. LONG _stack = 4000;
  31. char *_procname = "MED - music editor";
  32. LONG _priority = 0;
  33. LONG _BackGroundIO = 0;
  34.  
  35. static void __regargs Poistu(char *),Alku(void);
  36. static void __regargs DrawLines(void);
  37. void _main(char *cmdline);
  38. extern UWORD periodit[],chip medpic0[],chip medpic1[],chip mouse1[];
  39. extern struct CIA far ciaa;
  40. extern struct Image far kuviot;
  41. extern struct TextAttr far nsfont;
  42. extern struct NewWindow far nw,far pnw;
  43. extern struct NewScreen far ns;
  44. extern struct Gadget far gadget1[],far gadget3[];
  45. extern struct Custom far custom;
  46. extern UWORD chip pylvaatdata[];
  47. struct Image eq1image = { 0,0,320,56,2,pylvaatdata,0x3,0x0,NULL };
  48. struct RastPort *wrp;
  49. struct ViewPort *vp;
  50. struct BitMap drawbm,screenbm;
  51. struct TextFont *topaz8;
  52. struct Task *maintsk;
  53. struct Kappale far song;
  54. struct Soitin *sample[63];
  55. extern struct Lohko far *lohko[];
  56. extern UBYTE firstdisptrk;
  57. extern BPTR currdir;
  58. UWORD *sprptr;
  59. BOOL trackon[16] = { 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 },updscrflag = TRUE;
  60. ULONG updscrmsk,hyppymsk,recmidimsk;
  61. LONG eq1strt0 = 0L,eq1strt1 = 0L,eq1strt2 = 0L,plane0ptr = 0L;
  62. CPTR pl2s[8];
  63. UBYTE eq1height[31] = { 0 };
  64. UBYTE far recmidi;
  65. void __asm VBServ(void);
  66. static struct Interrupt far vbserv = { { NULL,NULL,NT_INTERRUPT,-10,
  67.                 "MEDVBInt!" },(APTR)eq1height,VBServ };
  68. static char *initerror[] = { NULL,"MED: Can't allocate signal",
  69.     "MED: Can't open audio.device (channels in use??)",
  70.     "MED: Can't open ciaa.resource","MED: ciaa timer A in use" };
  71. struct Screen *screen;
  72. struct Window *window,*pw;
  73. extern char *verstr;
  74. static long scrupdsign = -1,jumpsign = -1,recmidisig = -1;
  75.  
  76. ULONG class; /* IntuiMsg stuff */
  77. WORD mousex,mousey;
  78. UWORD code,qual;
  79. APTR iaddr;
  80.  
  81. void _main(cmdline)
  82. char *cmdline;
  83. {
  84.     struct IntuiMessage *imsg;
  85.     ULONG mask;
  86.     register UWORD quit = FALSE;
  87.     APTR prevwinptr;
  88.     register long waitmsk;
  89.     struct Process *thisproc = (struct Process *)FindTask(0);
  90.     prevwinptr = thisproc->pr_WindowPtr;
  91.     Alku();
  92.     AddIntServer(INTB_VERTB,&vbserv);
  93.     thisproc->pr_WindowPtr = (APTR)window;
  94.     waitmsk = 1<<window->UserPort->mp_SigBit|updscrmsk|hyppymsk|recmidimsk;
  95.     for(;;) {
  96.         mask = Wait(waitmsk);
  97.         if(mask & hyppymsk) SetPointer(window,sprptr,23,16,-1,0);
  98.         if(mask & updscrmsk) PaivitaNaytto(FALSE);
  99.         if(mask & recmidimsk) PutMNote(recmidi);
  100.         while(imsg = (struct IntuiMessage *)GetMsg(window->UserPort)) {
  101.             class = imsg->Class;
  102.             code = imsg->Code;
  103.             qual = imsg->Qualifier;
  104.             iaddr = imsg->IAddress;
  105.             mousex = imsg->MouseX;
  106.             mousey = imsg->MouseY;
  107.             ReplyMsg((struct Message *)imsg);
  108.             if(KasitteleViesti()) {
  109.                 quit = TRUE;
  110.                 break;
  111.             }
  112.         }
  113.         if(quit) break;
  114.     }
  115.     thisproc->pr_WindowPtr = prevwinptr;
  116.     ciaa.ciapra &= ~CIAF_LED;
  117.     RemIntServer(INTB_VERTB,&vbserv);
  118.     Poistu(NULL);
  119. }
  120.  
  121. static void __regargs Poistu(char *err)
  122. {
  123.     char alerttxt[100];
  124.     if(err) {
  125.         alerttxt[0] = 0; alerttxt[1] = 20; alerttxt[2] = 16;
  126.         strcpy(&alerttxt[3],err);
  127.         alerttxt[strlen(err)+4] = '\0';
  128.         DisplayAlert(RECOVERY_ALERT,alerttxt,30);
  129.     }
  130.     RemEqualizer();
  131.     AudioRem();
  132.     FreeSerial();
  133.     FreeAllBlocks();
  134.     if(currdir) UnLock(currdir);
  135.     FreeFDatas();
  136.     FreeBuffer();
  137.     VapautaSoittimet();
  138.     FreePaths();
  139.     if(topaz8) CloseFont(topaz8);
  140.     if(drawbm.Planes[0]) FreeRaster(drawbm.Planes[0],320,120);
  141.     if(window) CloseWindow(window);
  142.     if(screen) CloseScreen(screen);
  143.     if(IntuitionBase) {
  144.         OpenWorkBench(); /* OK, =RJ=!! */
  145.         CloseLibrary(IntuitionBase);
  146.     }
  147.     if(GfxBase) CloseLibrary(GfxBase);
  148.     if(recmidisig != -1) FreeSignal(recmidisig);
  149.     if(scrupdsign != -1) FreeSignal(scrupdsign);
  150.     if(jumpsign != -1) FreeSignal(jumpsign);
  151.     XCEXIT(0);
  152. }
  153.  
  154. void VapautaSoittimet()
  155. {
  156.     UCOUNT slsk;
  157.     for(slsk = 0; slsk < 63; slsk++)
  158.         if(sample[slsk]) {
  159.             FreeMem((void *)sample[slsk],sample[slsk]->length +
  160.                 sizeof(struct Soitin));
  161.             sample[slsk] = NULL;
  162.             song.sample[slsk].sname[0] = '\0';
  163.         }
  164. }
  165.  
  166. void SammutaAanet(arg)
  167. UWORD arg;
  168. {
  169.     static UBYTE mididata[3] = { 0xb0,0x7b,0x0 }; /* MIDI: All notes off */
  170.     extern struct Gadget far gadget9[];
  171.     if(arg == 999) {
  172.         ChannelOff(0);    /* stop Amiga audio channels by calling */
  173.         ChannelOff(1);  /* ChannelOff().. */
  174.         ChannelOff(2);
  175.         ChannelOff(3);
  176.         if(gadget9[0].GadgetID & 0x1000) /* ..and MIDI this way */
  177.         for(mididata[0] = 0xB0; mididata[0] <= 0xBF; mididata[0]++)
  178.             AddMIDIData(mididata,3);
  179.     }
  180.     else ChannelOff((UBYTE)arg);
  181. }
  182.  
  183. static void __regargs Alku()
  184. {
  185.     long error;
  186.     if(!(IntuitionBase = OpenLibrary("intuition.library",33)))
  187.       Poistu(NULL); /* DisplayAlert() vaatii intuition.libraryn! */
  188.     scrupdsign = AllocSignal(-1);
  189.     jumpsign = AllocSignal(-1);
  190.     recmidisig = AllocSignal(-1);
  191.     if(scrupdsign == -1 || jumpsign == -1 || recmidisig == -1)
  192.         Poistu("MED: No free signal bits");
  193.     updscrmsk = 1 << scrupdsign;
  194.     hyppymsk = 1 << jumpsign;
  195.     recmidimsk = 1 << recmidisig;
  196.     if(!(GfxBase = OpenLibrary("graphics.library",0)))
  197.         Poistu("MED: No graphics.library");
  198.     if(!(screen = OpenScreen(&ns)))
  199.         Poistu("MED: Can't open screen (out of memory?)");
  200.     topaz8 = OpenFont(&nsfont);
  201.     nw.Height = screen->Height;
  202.     nw.Screen = screen;
  203.     maintsk = FindTask(0);
  204.     if(!(window = OpenWindow(&nw)))
  205.         Poistu("MED: Can't open window (out of memory?)");
  206.     ShowTitle(screen,FALSE);
  207.     wrp = window->RPort;
  208.     vp = ViewPortAddress(window);
  209.     NollaaVarit();
  210.     SetRGB4(vp,17,0xe,0xa,0xa); /* sprite */
  211.     SetRGB4(vp,18,0xf,0xf,0xf);
  212.     SetRGB4(vp,19,0x4,0x8,0xf);
  213.     InitBitMap(&screenbm,2,320,77);
  214.     screenbm.Planes[0] = (PLANEPTR)medpic0;
  215.     screenbm.Planes[1] = (PLANEPTR)medpic1;
  216.     BltBitMapRastPort(&screenbm,0,0,wrp,0,0,320,77,0xc0);
  217.     DrawLines();
  218.     OsionValinta(&gadget1[0]);
  219.     if(screen->Height >= 256) {
  220.         DrawImage(&(screen->RastPort),&eq1image,0,200);
  221.         eq1strt0 = (LONG)(screen->BitMap.Planes[0]) + 8484;
  222.         eq1strt1 = (LONG)(screen->BitMap.Planes[1]) + 8484;
  223.         eq1strt2 = (LONG)(screen->BitMap.Planes[2]) + 8484;
  224.     }
  225.     else {
  226.         pnw.Screen = screen;
  227.         eq1strt1 = (LONG)(screen->BitMap.Planes[1]) + 1124;
  228.         eq1strt2 = (LONG)(screen->BitMap.Planes[2]) + 1124;
  229.         gadget3[6].GadgetID &= ~0x1000; /* pylvΣΣt-gadget ei korostu */
  230.     }
  231.     pl2s[0] = (CPTR)(screen->BitMap.Planes[2]) + 6563;
  232.     pl2s[2] = pl2s[0] + 9;
  233.     pl2s[4] = pl2s[2] + 9;
  234.     pl2s[6] = pl2s[4] + 9;
  235.     pl2s[1] = (CPTR)(screen->BitMap.Planes[1]) + 6563;
  236.     pl2s[3] = pl2s[1] + 9;
  237.     pl2s[5] = pl2s[3] + 9;
  238.     pl2s[7] = pl2s[5] + 9;
  239.     InitDisp();
  240.     InitBitMap(&drawbm,1,320,120);
  241.     if(!(drawbm.Planes[0] = (PLANEPTR)AllocRaster(320,120)))
  242.         Poistu("MED: No memory for bit plane");
  243.     plane0ptr = (LONG)drawbm.Planes[0];
  244.     BltClear((char *)plane0ptr,((120 << 16) + 40),3);
  245.     wrp->Mask = 0x2; /* TehdΣΣn palkki, muuttamalla bittitaso 2 ykk÷siksi */
  246.     SetDrMd(wrp,COMPLEMENT);
  247.     RectFill(wrp,4,132,315,140);
  248.     wrp->Mask = 0xff;
  249.     NaytaKursori();
  250.     SetDrMd(wrp,JAM2);
  251.     SetAPen(wrp,1);
  252.     SetBPen(wrp,0);
  253.     Move(wrp,276,10);
  254.     Text(wrp,verstr,5); /* version */
  255.     SetAPen(wrp,0);
  256.     SetBPen(wrp,3);
  257.     if(error = AudioInit()) Poistu(initerror[error]);
  258.     SetPointer(window,&mouse1[0],23,16,-1,0);
  259.     LoadKeys();
  260.     LoadPathFile();
  261.     if(AlustaKappale(TRUE)) Poistu("MED: Too little memory");
  262.     DispInfoGadgets();
  263.     InitEqualizer();
  264.     PaivitaNaytto(TRUE);
  265. }
  266.  
  267. static void __regargs DrawLines()
  268. {
  269.     SetDrMd(wrp,JAM1);
  270.     SetAPen(wrp,2);
  271.     Move(wrp,0,77);    Draw(wrp,0,199);
  272.     Move(wrp,1,77);    Draw(wrp,1,199);
  273.     Move(wrp,2,199);    Draw(wrp,318,199);
  274.     Move(wrp,316,197);    Draw(wrp,316,77);
  275.     SetAPen(wrp,3);
  276.     Move(wrp,2,76);    Draw(wrp,2,198);
  277.     Draw(wrp,317,198);    Draw(wrp,317,77);
  278.     SetAPen(wrp,1);
  279.     Move(wrp,3,77);    Draw(wrp,3,197);
  280.     Draw(wrp,315,197);    Move(wrp,319,199);
  281.     Draw(wrp,319,77);    Move(wrp,318,77);
  282.     Draw(wrp,318,198);
  283. }
  284.  
  285. void FreeBlock(num)
  286. UWORD num;
  287. {
  288.     if(lohko[num]) {
  289.         FreeMem(lohko[num],BLKHDRSZ + lohko[num]->numtracks * 3 *
  290.             (lohko[num]->lines + 1));
  291.         lohko[num] = 0L;
  292.     }
  293. }
  294.  
  295. BOOL AllocBlock(UWORD num,UBYTE tracks,UWORD lines) /* TRUE=err, FALSE=ok!! */
  296. {
  297.     if(lohko[num]) {
  298.         if(lohko[num]->numtracks == tracks &&
  299.            lohko[num]->lines == (UBYTE)(lines - 1)) return(FALSE);
  300.         FreeBlock(num);
  301.     }
  302.     if(!(lohko[num] = AllocMem(BLKHDRSZ + 3 * lines * tracks,MEMF_PUBLIC|
  303.         MEMF_CLEAR))) return(TRUE);
  304.     lohko[num]->numtracks = tracks;
  305.     lohko[num]->lines = (UBYTE)(lines - 1);
  306.     return(FALSE);
  307. }
  308.  
  309. void FreeAllBlocks()
  310. {
  311.     UWORD cnt;
  312.     for(cnt = 0; cnt < 100; cnt++) FreeBlock(cnt);
  313. }
  314.  
  315. BOOL ChangeBlockSize(UWORD num,UWORD width,UWORD lines)
  316. {
  317.     struct Lohko *newblock,*oldblock;
  318.     UBYTE trk;
  319.     UWORD oldtrk,newtrk,line;
  320.     if(!lohko[num]) return(TRUE);
  321.     newblock = AllocMem(BLKHDRSZ + 12 * lines * width,MEMF_PUBLIC|MEMF_CLEAR);
  322.     if(!newblock) return(TRUE);
  323.     newblock->numtracks = 4 * width;
  324.     newblock->lines = lines - 1;
  325.     oldblock = lohko[num];
  326.     for(line = 0; line < 8; line++) newblock->hlmask[line] =
  327.         oldblock->hlmask[line];
  328.     for(line = 0; line < min(lines,oldblock->lines + 1); line++) {
  329.         newtrk = newblock->numtracks * 3 * line;
  330.         oldtrk = lohko[num]->numtracks * 3 * line;
  331.         for(trk = 0; trk < min(newblock->numtracks,lohko[num]->
  332.             numtracks); trk++) {
  333.             newblock->music[newtrk + 3 * trk] =
  334.                 oldblock->music[oldtrk + 3 * trk];
  335.             newblock->music[newtrk + 3 * trk + 1] =
  336.                 oldblock->music[oldtrk + 3 * trk + 1];
  337.             newblock->music[newtrk + 3 * trk + 2] =
  338.                 oldblock->music[oldtrk + 3 * trk + 2];
  339.         }
  340.     }
  341.     lohko[num] = newblock;
  342.     FreeMem(oldblock,BLKHDRSZ + oldblock->numtracks * (oldblock->lines + 1) * 3);
  343.     firstdisptrk = 0;
  344.     PaivitaNaytto(TRUE);
  345.     return(FALSE);
  346. }
  347. #endif
  348.