home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 19 / CD_ASCQ_19_010295.iso / dos / prg / midas / dbp.pas < prev    next >
Pascal/Delphi Source File  |  1994-08-06  |  8KB  |  271 lines
  1. {*      DBP.PAS
  2.  *
  3.  * MIDAS debug module player
  4.  *
  5.  * Copyright 1994 Petteri Kangaslampi and Jarno Paananen
  6.  *
  7.  * This file is part of the MIDAS Sound System, and may only be
  8.  * used, modified and distributed under the terms of the MIDAS
  9.  * Sound System license, LICENSE.TXT. By continuing to use,
  10.  * modify or distribute this file you indicate that you have
  11.  * read the license and understand and accept it fully.
  12. *}
  13.  
  14.  
  15. uses crt, MIDAS, Errors, mGlobals, mMem, SDevice, MPlayer, DMA, DSM
  16. {$IFDEF REALVUMETERS}
  17.     , VU
  18. {$ENDIF}
  19.     ;
  20.  
  21.  
  22. procedure WaitVR; assembler;
  23. asm
  24.         mov     dx,03DAh
  25. @wvr:   in      al,dx
  26.         test    al,8
  27.         jz      @wvr
  28. end;
  29.  
  30.  
  31. procedure WaitDE; assembler;
  32. asm
  33.         mov     dx,03DAh
  34. @wde:   in      al,dx
  35.         test    al,1
  36.         jnz     @wde
  37. end;
  38.  
  39.  
  40.  
  41. procedure SetBorder(color : byte); assembler;
  42. asm
  43.         mov     dx,03C0h
  44.         mov     al,31h
  45.         out     dx,al
  46.         mov     al,color
  47.         out     dx,al
  48. end;
  49.  
  50.  
  51.  
  52. var
  53.     free1, free2 : longint;
  54.  
  55.  
  56. procedure showheap;
  57. begin
  58.     free2 := MaxAvail;
  59.     WriteLn(free2, ' bytes memory free - ', free1-free2, ' bytes used.');
  60. end;
  61.  
  62.  
  63.  
  64. var
  65.     error, plMusic : integer;
  66.     module : PmpModule;
  67.     SD : PSoundDevice;
  68.     MP : PModulePlayer;
  69.     key : char;
  70.     meter : word;
  71.     info : PmpInformation;
  72.  
  73.  
  74. procedure DrawMeters;
  75. var
  76.     i, error : integer;
  77.     meter, pos : word;
  78.     rate : longint;
  79.     chan : PmpChanInfo;
  80.  
  81. begin
  82.     { do all channels: }
  83.     for i := 0 to (info^.numChannels-1) do
  84.     begin
  85.         { point chan to current channel information: }
  86.         chan := @info^.chans^[i];
  87.  
  88.         { check that the channel has a valid instrument set }
  89.         if (chan^.instrument > 0) and
  90.             (chan^.instrument <= module^.numInsts) then
  91.         begin
  92. {$IFDEF REALVUMETERS}
  93.             if realVU = 1 then
  94.             begin
  95.                 { read channel playing rate: }
  96.                 error := SD^.GetRate(i, @rate);
  97.                 if error <> OK then
  98.                     midasError(errorMsg[error]);
  99.  
  100.                 { read channel playing position: }
  101.                 error := SD^.GetPosition(i, @pos);
  102.                 if error <> OK then
  103.                     midasError(errorMsg[error]);
  104.  
  105.                 { if there is sound being player, calculate VU-meter value: }
  106.                 if rate <> 0 then
  107.                 begin
  108.                     error := vuMeter(
  109.                         module^.insts^[chan^.instrument-1].sdInstHandle,
  110.                         rate, pos, chan^.volume, @meter);
  111.                     if error <> OK then
  112.                         midasError(errorMsg[error]);
  113.                 end
  114.                 else
  115.                     { no sound - meter = 0; }
  116.                     meter := 0;
  117.             end
  118.             else
  119. {$ENDIF}
  120.                 meter := chan^.volumebar;
  121.         end
  122.         else
  123.         begin
  124.             { no valid instrument - set meter to zero }
  125.             meter := 0;
  126.         end;
  127.  
  128.         { Draw the VU-meter: }
  129. asm
  130.         cld
  131.         mov     ax,$B800                { point es to screen segment }
  132.         mov     es,ax
  133.  
  134.         mov     ax,160
  135.         mul     i                       { i = channel number = y-coordinate }
  136.         mov     di,ax                   { address = 160 * i }
  137.         mov     bx,64                   { bx = total amount to draw }
  138.         mov     cx,meter                { cx = vu meter }
  139.         sub     bx,cx                   { bx = amount left after meter }
  140.         test    cx,cx
  141.         jz      @nometer
  142.         mov     ax,$0BFE                { draw first 'meter' boxes with }
  143.         rep     stosw                   { attribute $0B }
  144.  
  145. @nometer:
  146.         mov     cx,bx                   { cx = amount to draw after meter }
  147.         test    cx,cx
  148.         jz      @done
  149.         mov     ax,$08FE                { draw the rest of the 64 boxes with }
  150.         rep     stosw                   { attribute $0B }
  151. @done:
  152. end;
  153.  
  154.     end;
  155. end;
  156.  
  157.  
  158.  
  159. BEGIN
  160.     if ParamCount < 1 then
  161.     begin
  162.         WriteLn('Usage:  DBP     <filename> [MIDAS options]');
  163.         halt;
  164.     end;
  165.  
  166.     free1 := MaxAvail;
  167.     WriteLn(free1, ' bytes free');
  168.  
  169.     midasSetDefaults;                       { set MIDAS defaults }
  170.     midasParseEnvironment;                  { parse "MIDAS" environment }
  171.     midasParseOptions(2, ParamCount-1);     { parse MIDAS options }
  172.     midasInit;                              { initialize MIDAS }
  173.     SD := SDptr;
  174.     showheap;
  175.     module := midasPlayModule(ParamStr(1), 0); { load and play module }
  176.     MP := MPptr;
  177.     WriteLn('Playing - press any key to stop');
  178.  
  179.     { allocate memory for Module Player information structure: }
  180.     error := memAlloc(SizeOf(mpInformation), @info);
  181.     if error <> OK then
  182.         midasError(errorMsg[error]);
  183.  
  184.     { allocate memory for mpInformation channel structures: }
  185.     error := memAlloc(module^.numChans * SizeOf(mpChanInfo), @info^.chans);
  186.     if error <> OK then
  187.         midasError(errorMsg[error]);
  188.  
  189.     { set number of channels in structure: }
  190.     info^.numChannels := module^.numChans;
  191.  
  192.     showheap;
  193.  
  194.     while not KeyPressed do
  195.     begin
  196.         WaitVR;                         { wait for Vertical Retrace }
  197.         WaitDE;                         { wait for Display Enable }
  198. {$IFDEF NOTIMER}
  199.  
  200.         { If timer is not being used, poll the player manually. Note that this
  201.           should not normally be done, as it changes the tempo when playing
  202.           with GUS, but is here to help debugging. }
  203.  
  204.         SetBorder(15);
  205.         if SD^.tempoPoll = 1 then
  206.         begin
  207.             error := SD^.Play(@plMusic);
  208.             if error <> OK then
  209.                 midasError(errorMsg[error]);
  210.             SetBorder(14);
  211.             error := MP^.Play;
  212.             if error <> OK then
  213.                 midasError(errorMsg[error]);
  214.         end
  215.         else
  216.         begin
  217.             error := dmaGetPos(@dsmBuffer, @dsmDMAPos);
  218.             if error <> OK then
  219.                 midasError(errorMsg[error]);
  220.             error := SD^.Play(@plMusic);
  221.             if error <> OK then
  222.                 midasError(errorMsg[error]);
  223.  
  224.             while plMusic = 1 do
  225.             begin
  226.                 SetBorder(14);
  227.                 error := MP^.Play;
  228.                 if error <> OK then
  229.                     midasError(errorMsg[error]);
  230.                 SetBorder(15);
  231.                 error := SD^.Play(@plMusic);
  232.                 if error <> OK then
  233.                     midasError(errorMsg[error]);
  234.             end;
  235.         end;
  236. {$ENDIF}
  237.         SetBorder(4);
  238.  
  239.         { read Module Player information to info^: }
  240.         error := MP^.GetInformation(info);
  241.         if error <> OK then
  242.             midasError(errorMsg[error]);
  243.  
  244.         { draw VU-meters to top of display: }
  245.         DrawMeters;
  246.  
  247.         SetBorder(0);
  248.     end;
  249.  
  250.     key := ReadKey;
  251.  
  252.     { deallocate channel information structures: }
  253.     error := memFree(info^.chans);
  254.     if error <> OK then
  255.         midasError(errorMsg[error]);
  256.  
  257.     { deallocate Module Player information structure: }
  258.     error := memFree(info);
  259.     if error <> OK then
  260.         midasError(errorMsg[error]);
  261.  
  262.     midasStopModule(module);            { stop playing module }
  263.     showheap;
  264.     midasClose;                         { uninitialize MIDAS Sound System }
  265.     showHeap;
  266.  
  267. {$IFDEF DEBUG}
  268.     errPrintList;
  269. {$ENDIF}
  270. END.
  271.