with Interfaces.C;                      use Interfaces.C;
with System;                            use System;
with Ada.Containers.Vectors;
package Libmy.MIDI is
 
  type Tempo_Type is delta 0.1 digits 4 range 20.0..300.0;
 
  package Long_Vectors is new Ada.Containers.Vectors(Positive,
                                                         Long,
                                                        Interfaces.C."=" );
   use Long_Vectors;
 
   subtype Step_Index_Type is Positive range 1..16*256;
 
   type Sequencer is array (Step_Index_Type'Range) of Vector;
 
   type Seq_Page_Type is
      record
         Keyb  : Sequencer;
         Input : Sequencer;
         Output : Sequencer;
      end record;
 
   type Seq_Page_Access is access all Seq_Page_Type;
   type Scheduler_Type is array (boolean'Range) of Seq_Page_Access;
 
   type Byte_Type is mod 256;
 
   type Message_Type is
      record
         Status : Byte_Type := 0;
         Data1  : Byte_Type := 0;
         Data2  : Byte_Type := 0;
      end record;
   Null_Message : constant Message_Type := (0, 0, 0);
end Libmy.MIDI;

with Calendar;                          use Calendar;
 
generic
 
package Libmy.MIDI.Composer is
   task Composer is
      entry Halt;
      entry Start(Seq_Page : in Seq_Page_Access;
                  Bpm : in Tempo_Type; Top : in Time);
      entry Stop;
      entry Switch(Seq_Page : in Seq_Page_Access);
   end Composer;
end Libmy.MIDI.Composer;

package body Libmy.MIDI.Composer is
 
   -- Copy all input on output for composed current page.
   procedure In2out(Seq_Page : in out Seq_Page_Type) is
   begin
 
      for Step in Step_Index_Type'range loop
         if Last_Index(Seq_Page.Keyb(Step)) /= 0 then
            for I in 1..Last_Index(Seq_Page.Keyb(Step)) loop
               Insert(Seq_Page.Output(Step),
                      Last_Index(Seq_Page.Output(Step)) + 1,
                      Element(Seq_Page.Keyb(Step), i));
            end loop;
         end if;
         if Last_Index(Seq_Page.Input(Step)) /= 0 then
            for I in 1..Last_Index(Seq_Page.Input(Step)) loop
               Insert(Seq_Page.Output(Step),
                      Last_Index(Seq_Page.Output(Step)) + 1,
                      Element(Seq_Page.Input(Step), i));
            end loop;
         end if;
      end loop;
 
   end In2out;
 
 
   task body Composer is
      The_Step  : positive := 1;
      End_Of_Task : Boolean := False;
      Suspended : Boolean := False;
      Step_Date : Time := Clock;
      Step_Sync : Duration;
      Message : Long := 0;
      The_Seq_Page : Seq_Page_Access;
   begin
      while not End_Of_Task loop
         select
            accept Start(Seq_Page : in Seq_Page_Access;
                         Bpm : in Tempo_Type; Top : in Time) do
               Suspended := False;
               Step_Sync  := Duration(60.0/Float(bpm)/16.0);
               Step_Date  := Top;
               The_Step := 1;
               The_Seq_Page := Seq_Page;
            end Start;
         or
            accept Halt do
               Suspended := True;
               End_Of_Task := True;
            end Halt;
         end select;
         delay until Step_Date;
         while not Suspended loop
 
            select
               accept Stop do
                  Suspended := True;
               end Stop;
            or
               accept Halt do
                  Suspended := True;
                  End_Of_Task := True;
               end Halt;
            or
               accept Switch(Seq_Page : in Seq_Page_Access) do
                  The_Seq_Page := Seq_Page;
               end Switch;
               In2out(The_Seq_Page.all);
            else
               null;
            end select;
         end loop;
      end loop;
   end Composer;
end Libmy.MIDI.Composer;

with Libmy.MIDI.Composer;
with System;                            use System;
generic
   Keyb_Addr   : access Address;
   Input_Addr  : access Address;
   Output_Addr : access Address;
   with package Composer is new Libmy.MIDI.Composer;
package Libmy.MIDI.Scheduler is
 
   -- Master keybord driver.
   task Keyboard is
      entry Send(Message : out Long);
   end Keyboard;
 
   -- Synth input driver
   task input is
      entry Send(Message : out Long);
   end Input;
 
   -- synth output driver.
   task Output is
      entry receive(Message : in Long);
   end Output;
 
   -- smal step sequencer.
   task Scheduler is
      entry Start;
      entry Stop;
      entry Halt;
   end Scheduler;
end Libmy.MIDI.Scheduler;

with Calendar;                          use Calendar;
with Libmy.MIDI.Portmidi;               use Libmy.MIDI.Portmidi;
with Libmy.MIDI.Porttime;               use Libmy.MIDI.Porttime;
with Text_Io;
package body Libmy.MIDI.Scheduler is
 
   task body Keyboard is
      Pm_Event : PmEvent;
   begin
      loop
         Pm_Event.Message := Read_handler(Keyb_Addr.all);
         accept Send(Message : out Long) do
            Message := Pm_Event.Message;
         end Send;
      end loop;
   end Keyboard;
 
   task body Input is
      Pm_Event : PmEvent;
   begin
      loop
         Pm_Event.Message := Read_handler(Input_Addr.all);
         accept Send(Message : out Long) do
            Message := Pm_Event.Message;
         end Send;
      end loop;
   end Input;
 
   task body Output is
      Pm_Event : PmEvent;
      Pm_Error : PmError;
      Date : Time := Clock;
      Sync : Duration := 0.0;
   begin
      loop
         accept receive(Message : in Long) do
            Pm_Event.Message := Message;
         end Receive;
         if Pm_Event.Message > 0 then
            Pm_Event.PmTimestamp := Pt_time;
            Pm_Error := Pm_Write(Output_Addr.All, Pm_Event, 1);
         end if;
      end loop;
      Text_Io.Put_Line("End_output_Drivers" );
   exception
      when others =>
         Text_Io.Put_line("exception in output driver." );
   end Output;
 
 
   task body Scheduler is
 
 
      task Tempo_Drive is
         entry Start(Bpm : in Tempo_Type; Top : in Time);
         entry Stop;
         entry Halt;
      end Tempo_Drive;
 
      task body Tempo_Drive is
 
 
         Suspended, End_Of_Task : Boolean := False;
         Tempo_Message : Message_Type;
         Tempo_Date : Time := Clock;
         Tempo_Sync : Duration;
 
      begin
 
         while not End_Of_Task loop
 
            select
               accept Start(Bpm : in Tempo_Type; Top : in Time) do
                  Suspended := False;
                  Text_Io.Put_Line("start global." );
                  Tempo_Sync := duration(60.0/Float(Bpm)/24.0);
                  Tempo_Date := Top;
               end Start;
            or
               accept Halt do
                  Text_Io.Put_Line("Halt global." );
                  Suspended := True;
                  End_Of_Task := True;
               end Halt;
            end select;
            while not Suspended loop
               select
                  accept Stop do
                     Text_Io.Put_Line("Stop global." );
                     Suspended := True;
                     end Stop;
               or
                  accept Halt do
                     Text_Io.Put_Line("Halt global." );
                     Suspended := True;
                     End_Of_Task := True;
                  end Halt;
               or
                  delay until Tempo_Date;
                  Tempo_Date := Tempo_Date + Tempo_Sync;
                  Tempo_Message := (16#F8#, 0, 0);
                  Output.Receive(Pm_Message(Tempo_Message));
               end select;
            end loop;
         end loop;
         Text_Io.Put_Line("End_Tempo_Drivers" );
      exception
         when others =>
            Text_Io.Put("Exception in Tempo Driver" );
      end Tempo_Drive;
 
 
      The_Sched : Scheduler_Type := (new Seq_Page_Type, new Seq_Page_Type);
      The_Step  : positive := 1;
      The_Page : Boolean := False;
      End_Of_Task : Boolean := False;
      Suspended : Boolean := False;
      Step_Date : Time := Clock;
      Step_Sync : Duration;
      Message : Long := 0;
      Tempo : Tempo_Type := 240.0;
   begin
      while not End_Of_Task loop
         select
            accept Start do
               Suspended := False;
               Step_Sync  := Duration(60.0/Float(Tempo)/16.0);
               Step_Date  := Clock;
               The_Step := 1;
               Tempo_Drive.Start(Tempo,
                                 Step_Date);
               Composer.Composer.Start(The_Sched(not The_Page),
                                       Tempo,
                                       Step_Date);
            end Start;
         or
            accept Halt do
               Suspended := True;
               End_Of_Task := True;
               Composer.Composer.Halt;
               Tempo_Drive.Halt;
            end Halt;
         end select;
         delay until Step_Date;
         while not Suspended loop
 
            select
               accept Stop do
                  Suspended := True;
                  Composer.Composer.Stop;
                  Tempo_Drive.Stop;
               end Stop;
            or
               accept Halt do
                  Suspended := True;
                  End_Of_Task := True;
                  Composer.Composer.Halt;
                  Tempo_Drive.Halt;
               end Halt;
 
            else
               -- Reading data in input while not end of step.
               while Step_Date > Clock loop
                  select
                     keyboard.Send(Message);
                     Insert(The_Sched(not The_Page).Keyb(The_Step),
                            Last_index(The_Sched(not The_Page).Keyb(The_Step)) + 1,
                            Message,
                            1);
                  else
                     null;
                  end select;
                  select
                     input.Send(Message);
                      Insert(The_Sched(not The_Page).Keyb(The_Step),
                            Last_index(The_Sched(not The_Page).Keyb(The_Step)) + 1,
                            Message,
                            1);
                  else
                     null;
                  end select;
               end loop;
 
               -- Writing Data for current step.
               if Last_index(The_Sched(The_Page).Output(The_Step)) /= 0 then
                  for I in 1..Last_index(The_Sched(The_Page).Output(The_Step)) loop
                     Output.Receive(Element(The_Sched(The_Page).Output(The_Step), i));
                  end loop;
 
                  Clear(The_Sched(The_Page).Output(The_Step));
               end if;
 
               -- Step & page managment.
               Step_Date := Step_Date + Step_Sync;
               if The_Step = Step_Index_Type'Last then
 
                  Text_Io.Put(Character'Val(13) & "Step :" &
                                Step_Index_Type'Image(The_Step));
                  Text_Io.Put_Line(", change page..." );
                  The_Step := 1;
                  The_Page := not The_Page;
                  Composer.Composer.Switch(The_Sched(not The_Page));
               else
                  Text_Io.Put(Character'Val(13) & "Step :" &
                                Step_Index_Type'Image(The_Step));
 
 
                  The_Step := The_Step + 1;
               end if;
 
            end select;
         end loop;
      end loop;
      abort Keyboard;
      abort Input;
      abort Output;
      Text_Io.Put_Line("End_scheduler" );
   exception
      when others =>
         Text_Io.Put_Line("Exception in scheduler driver" );
   end Scheduler;
end Libmy.MIDI.Scheduler;

with System;                            use System;
with Interfaces.C;                      use Interfaces.C;
 
with Libmy.MIDI.Portmidi;               use Libmy.MIDI.Portmidi;
with Libmy.MIDI.Composer;
with Libmy.MIDI.Scheduler;
with Libmy.MIDI;                        use Libmy.MIDI;
with Text_Io;
procedure Main is
 
 
   use ErrorText_Conversion;
   use DeviceInfo_Conversion;
 
   Keyb_In   : aliased Address;
   Synth_In  : aliased Address;
   Synth_Out : aliased Address;
begin
 
   loop
      declare
         line : String(1..512) := (others => Character'Val(32));
         Last,
         Choice : Natural := 0;
         The_Deviceinfo : DeviceInfo;
         Name : T_ErrorText;
      begin
 
         loop
            Text_Io.Put_Line("Enter master Keyboard" );
            Text_Io.Put_Line("ID, Device Name" );
            for I in 0..Pm_CountDevices-1 loop
               The_DeviceInfo :=
                 DeviceInfo_Conversion.To_pointer(Pm_GetDeviceInfo(I)).all;
               if The_Deviceinfo.input = 1 then
                  Name := To_Pointer(The_Deviceinfo.name).all;
                  Text_Io.Put(Integer'Image(I));
                  Text_Io.Put_line(", " & To_Ada(Name));
               end if;
            end loop;
            Text_Io.Put("Enter device ID : " );
            Text_Io.Get_line(line, Last);
            if Last /= 0 then
               Choice := Natural'Value(Line(1..Last));
               exit;
            end if;
         end loop;
         Keyb_In := Input_Open_Handler(Choice);
         exit;
      exception
         when others =>
            null;
      end;
   end loop;
 
 
   loop
      declare
         line : String(1..512) := (others => Character'Val(32));
         Last,
         Choice : Natural := 0;
         The_Deviceinfo : DeviceInfo;
         Name : T_ErrorText;
      begin
 
         loop
            Text_Io.Put_Line("Enter input for instrument" );
            Text_Io.Put_Line("ID, Device Name" );
            for I in 0..Pm_CountDevices-1 loop
               The_DeviceInfo :=
                 DeviceInfo_Conversion.To_pointer(Pm_GetDeviceInfo(I)).all;
               if The_Deviceinfo.Input = 1 then
                  Name := To_Pointer(The_Deviceinfo.name).all;
                  Text_Io.Put(Integer'Image(I));
                  Text_Io.Put_line(", " & To_Ada(Name));
               end if;
            end loop;
            Text_Io.Put("Enter device ID : " );
            Text_Io.Get_line(line, Last);
            if Last /= 0 then
               Choice := Natural'Value(Line(1..Last));
               exit;
            end if;
         end loop;
         Synth_in := input_Open_Handler(Choice);
         exit;
      exception
         when others =>
            null;
      end;
   end loop;
 
   loop
 
      declare
         line : String(1..512) := (others => Character'Val(32));
         Last,
         Choice : Natural := 0;
         The_Deviceinfo : DeviceInfo;
         Name : T_ErrorText;
      begin
 
         loop
            Text_Io.Put_Line("Enter output for instrument" );
            Text_Io.Put_Line("ID, Device Name" );
            for I in 0..Pm_CountDevices-1 loop
               The_DeviceInfo :=
                 DeviceInfo_Conversion.To_pointer(Pm_GetDeviceInfo(I)).all;
               if The_Deviceinfo.Output = 1 then
                  Name := To_Pointer(The_Deviceinfo.name).all;
                  Text_Io.Put(Integer'Image(I));
                  Text_Io.Put_line(", " & To_Ada(Name));
               end if;
            end loop;
            Text_Io.Put("Enter device ID : " );
            Text_Io.Get_line(line, Last);
            if Last /= 0 then
               Choice := Natural'Value(Line(1..Last));
               exit;
            end if;
         end loop;
         Synth_Out := Output_Open_Handler(Choice);
         exit;
      exception
         when others =>
            null;
      end;
   end loop;
 
   declare
 
      package My_Composer is new Libmy.MIDI.Composer;
      package My_Scheduler is new Libmy.MIDI.Scheduler(Keyb_In'Access,
 
 
                                                       Synth_In'access,
                                                       Synth_Out'Access,
                                                       My_Composer);
      Run : Boolean := False;
      Char: Character;
   begin
 
      loop
         Text_Io.Put_Line("Press 'Esc' to quit or 'space' to start or stop." );
         Text_Io.Get_Immediate(Char);
         case Char is
            when Character'Val(27) =>
               My_Scheduler.Scheduler.Halt;
               Text_Io.Put_Line("Active one Ctrl on all input device." );
               exit;
            when Character'Val(32) =>
               if Run then
                  My_Scheduler.Scheduler.Stop;
                  Run := False;
               else
                  My_Scheduler.Scheduler.Start;
                  Run := True;
               end if;
            when others =>
               null;
         end case;
      end loop;
   end;
end Main;

--
if Tempo /= The_Sched(The_Page).Tempo(The_Step) then
   Tempo := The_Sched(The_Page).Tempo(The_Step);
   Tempo_Drive.Sync(Tempo);
   Step_Sync  := Duration(60.0/Float(Tempo)/16.0);
end if;
Step_Date := Step_Date + Step_Sync;

--
               if Tempo /= The_Sched(The_Page).Tempo(The_Step) then
                  Tempo := The_Sched(The_Page).Tempo(The_Step);
                  Tempo_Drive.Sync(Tempo);
                  Step_Sync  := Duration(60.0/Float(Tempo)/16.0);
               end if;
               Step_Date := Step_Date + Step_Sync;