task type T_Input_Driver(Input_address : Address_Access) is
         entry Halt;
      end T_Input_Driver;
 
      task body T_Input_Driver is
 
         task type T_Input(Input_address : Address_Access) is
            entry Initialize;
            entry Send(Message : out Interfaces.C.Long);
         end T_Input;
         task body T_Input is
            Pm_Event : PmEvent;
         begin
 
            accept Initialize;
            loop
               if Input_Address /= null then
                  Put_Line("Reading input" );
                  Pm_Event.Message := Read_handler(Input_address.All);
                  Put_Line("Sending input" );
                  accept Send(Message : out Interfaces.C.Long) do
                     Message := Pm_Event.Message;
                  end Send;
               else
                  delay 1.0;
               end if;
            end loop;
         end T_Input;
 
         The_Chord :  T_Chord(1..24);
         The_Status : T_Status;
         Step_Time : Time := clock;
         Step_Length : Duration := 0.1;
         Index : Natural := 0;
         Message : Interfaces.C.Long;
         Input : T_Input(Input_Address);
         End_Of_Task : Boolean := False;
      begin
 
         Input.Initialize;
         Put_Line("Initialize input" );
         while not End_Of_Task loop
            select
               accept Halt do
                  End_Of_Task := True;
               end Halt;
            else
               null;
            end select;
            select
               Input.Send(Message);
               Put_Line("Receive message" );
               The_Status := Status(Message);
               case The_Status is
                  when Noteon =>
                     if Clock < Step_Time then
                        if Index < 5 then
                           Index := Index + 1;;
                           The_Chord(Index) :=
                             (T_value'Value("16#" & data1(Message) & '#'),
                              T_value'Value("16#" & data2(Message) & '#' ),
                              0);
                        end if;
                     else
                        if Index /= 0 then
                           T_MidiCtrl.Receive(The_Chord(1..Index), Channel(Message));
                           Index := 0;
                        end if;
                        Index := 1;
                        The_Chord(Index) := (T_value'Value("16#" & data1(Message) & '#'),
                                             T_value'Value("16#" & data2(Message) & '#' ),
                                             0);
                        Step_Time := Clock + 0.125;
                     end if;
                  when Noteoff =>
                     null;
                  when others =>
                     T_MidiCtrl.Receive(Message);
               end case;
            or
               delay 0.1;
               if Index /= 0 then
                  T_MidiCtrl.Receive(The_Chord(1..Index), Channel(message));
                  Index := 0;
               end if;
            end select;
         end loop;
         abort Input;
      end T_Input_Driver;

if Input_Address /= null then                                          -- si l'adresse n'est pas nulle, 
   Put_Line("Reading input" );
   Pm_Event.Message := Read_handler(Input_address.All);   -- je lis à l'adresse, ici on devrais s'arrêter si il n'y a pas de donnée en sortie à l'adresse.
   Put_Line("Sending input" );
   accept Send(Message : out Interfaces.C.Long) do           -- j'accepte le lecture du buffer Pm_Event. Qui est appelé en continue.
        Message := Pm_Event.Message;
   end Send;
else                                                                             -- si l'adresse est null, j'attends 1 seconde.
  delay 1.0;
end if;

#include "unistd.h"
#include "portmidi.h"
#include "porttime.h"
#include "stdio.h"
 
#define INPUT_BUFFER_SIZE 100
#define OUTPUT_BUFFER_SIZE 0
#define DRIVER_INFO NULL
#define TIME_PROC ((long (*)(void *)) Pt_Time)
#define TIME_INFO NULL
#define TIME_START Pt_Start(1, 0, 0) /* timer started w/millisecond accuracy */
 
 
 
long Read_Handler(long midi) {
  PmError status, length;
  PmEvent buffer[1];
  int i = 0;
  int num = 1;
    /* It is recommended to start timer before Midi; otherwise, PortMidi may                                                                                                                                         
       start the timer with its (default) parameters                                                                                                                                                                 
     */
  /*TIME_START;*/
 
  /* open input device                                                                                                                                                                                               
    Pm_OpenInput(,                                                                                                                                                                                                   
                 i,                                                                                                                                                                                                  
                 DRIVER_INFO,                                                                                                                                                                                        
                 INPUT_BUFFER_SIZE,                                                                                                                                                                                  
                 TIME_PROC,                                                                                                                                                                                          
                 TIME_INFO);*/
 
    /*printf("Midi Input opened. Reading %d Midi messages...\n",num);*/
    Pm_SetFilter(midi, PM_FILT_ACTIVE | PM_FILT_CLOCK);
    /* empty the buffer after setting filter, just in case anything                                                                                                                                                  
       got through */
    while (Pm_Poll(midi)) {
        Pm_Read(midi, buffer, 1);
        usleep(0.05);
    }
    /* now start paying attention to messages */
    i = 0; /* count messages as they arrive */
    buffer[0].message = 0;
    while (i < num) {
        status = Pm_Poll(midi);
        if (status == TRUE) {
            length = Pm_Read(midi,buffer, 1);
            if (length > 0)
              i++;
        }
        usleep(0.05);
    }
 
    /* close device (this not explicitly needed in most implementations) */
    /*printf("ready to close..." );*/
 
    /*Pm_Close(midi);*/
    /*printf("done closing..." );*/
    return buffer[0].message;
}