with System;
with Interfaces.C;
 
package Portmidi is
 
 
 
 
 
 
   type PmError is (pmNoErro,
                    PmHostError,
                    pmInvalidDeviceId,
                    pmInsufficientMemory,
                    pmBufferTooSmall,
                    pmBufferOverflow,
                    pmBadPtr,
                    pmBadData,
                    pmInternalError,
                    PmBufferMaxSize);
 
   function Pm_GetDefaultInputDeviceID return Interfaces.C.int;
   pragma Import (C, Pm_GetDefaultInputDeviceID, "Pm_GetDefaultInputDeviceID" );
 
   function Pm_GetDefaultOutputDeviceID return Interfaces.C.Int;
   pragma Import (C, Pm_GetDefaultOutputDeviceID, "Pm_GetDefaultOutputDeviceID" );
 
 
   function Pm_Initialize return PmError;
   pragma Import (C, Pm_Initialize, "Pm_Initialize" );
 
   function Pm_Terminate return PmError;
   pragma Import (C, Pm_Terminate, "Pm_Terminate" );
 
 
 
   function Pm_OpenInput(PortMidiStream : System.address;
                         PmDeviceID : Integer;
                         InputDriverInfo : Integer;
                         BufferSize : Long_Integer;
                         PmTimeProcPtr : System.address;
                         time_info : integer) return PmError;
   pragma Import (C, Pm_OpenInput, "Pm_OpenInput" );
 
 
   function Pm_OpenOutput( PortMidiStream :System.address;
                           OutputDevice : Integer;
                           outputDriverInfo : System.address;
                           BufferSize : Long_Integer;
                           Time_Proc : Integer;
                           Time_Info : System.address;
                           latency : Long_integer) return PmError;
   pragma Import (C, Pm_OpenOutput, "Pm_OpenOutput" );
 
   function Pm_SetFilter(PortMidiStream : System.address;
                         filters : Long_Integer) return PmError;
   pragma Import (C, Pm_SetFilter, "Pm_SetFilter" );
 
   function Pm_SetChannelMask(PortMidiStream : System.address;
                              Mask : integer) return PmError;
   pragma Import (C, Pm_SetChannelMask, "Pm_SetChannelMask" );
 
   function Pm_Abort( PortMidiStream : System.address) return PmError;
   pragma Import (C, Pm_Abort, "Pm_Abort" );
 
   function Pm_Close( PortMidiStream : System.address) return PmError;
   pragma Import (C, Pm_Close, "Pm_Close" );
 
 
   function Pm_Read( PortMidiStream : System.address;
                     PmEvent : Integer;
                     Length :Long_integer) return PmError;
   pragma Import (C, Pm_Read, "Pm_Read" );
 
   function Pm_Poll( PortMidiStream : System.address) return PmError;
   pragma Import (C, Pm_Poll, "Pm_Poll" );
 
   function Pm_Write( PortMidiStream : System.address;
                      PmEvent : System.address;
                      length : Long_integer) return PmError ;
   pragma Import (C, Pm_Write, "Pm_Write" );
 
 
   function Pm_WriteShort( PortMidiStream :System.address;
                           PmTimestamp : Float;
                           Msg : Long_integer) return PmError;
   pragma Import (C, Pm_WriteShort, "Pm_WriteShort" );
 
   function Pm_WriteSysEx( PortMidiStream : System.address;
                           PmTimestamp : Float;
                           Msg : integer) return PmError;
   pragma Import (C, Pm_WriteSysEx, "Pm_WriteSysEx" );

with System;
use System;
with Portmidi;
use Portmidi;
package body Orchestration is
 
   procedure Play is
 
      Error : PmError;
 
      PortMidiStream_Ptr,
      OutputDriverInfo_Ptr,
      Time_Info_Ptr  : System.Address;
 
 
   begin
      Error := Pm_Initialize;
 
      Error := Pm_OpenOutput( PortMidiStream => PortMidiStream_Ptr,
                              OutputDevice => 1,
                              outputDriverInfo => OutputDriverInfo_ptr,
                              BufferSize => 10,
                              Time_Proc => 1,
                              Time_Info => Time_Info_ptr,
                              latency => 2);
 
      Error := Pm_Close(PortMidiStream => PortMidiStream_ptr);
      Error := Pm_Terminate;
 
   end Play;
end Orchestration;

#include <stdio.h>
#include <portmidi.h>
#include <porttime.h>
 
#define DRIVER_INFO NULL
#define INPUT_BUFFER_SIZE 0
#define TIME_PROC ((long (*)(void *)) Pt_Time)
#define TIME_INFO NULL
#define TIME_START Pt_Start(1, 0, 0) /* timer started w/millisecond accuracy */
 
PmStream * midi;
 
long Input_Open_Handler (int device) {
  
  
 
  TIME_START;
 
  Pm_OpenInput(&midi, 
           device, 
           DRIVER_INFO,
           INPUT_BUFFER_SIZE, 
           TIME_PROC,
           TIME_INFO);
    return midi;
}

#include <stdio.h>
#include <portmidi.h>
#include <porttime.h>
 
#define DRIVER_INFO NULL
#define OUTPUT_BUFFER_SIZE 0
#define TIME_PROC ((long (*)(void *)) Pt_Time)
#define TIME_INFO NULL
#define TIME_START Pt_Start(1, 0, 0) /* timer started w/millisecond accuracy */
 
PmStream * midi;
 
long latency = 0;
 
long Output_Open_Handler (int device) {
  
  
 
  TIME_START;
 
  Pm_OpenOutput(&midi, 
        device, 
        DRIVER_INFO,
        OUTPUT_BUFFER_SIZE, 
        (latency == 0 ? NULL : TIME_PROC),
        (latency == 0 ? NULL : TIME_INFO), 
        latency);
  return midi;
}

#include <stdio.h>
#include <portmidi.h>
#include <porttime.h>
 
#define DRIVER_INFO NULL
#define INPUT_BUFFER_SIZE 1
#define TIME_PROC ((long (*)(void *)) Pt_Time)
#define TIME_INFO NULL
#define TIME_START Pt_Start(1, 0, 0) /* timer started w/millisecond accuracy */
 
PmError error;
long width;
PmStream *local;
PmEvent My_Event;
 
long Read_Handler (Void) 
{
  
  
  
  TIME_START;
  
  error = Pm_OpenInput(&local, 
               7, 
               DRIVER_INFO,
               INPUT_BUFFER_SIZE, 
               TIME_PROC,
               TIME_INFO);
  
  if (Pm_Poll(local))
    {
      printf("Read message...." );
      error = Pm_Read(local, 
              &My_Event, 
              1);  
      if (error < 0)
    printf("Errno : %d \n", error); 
      else if (error > 0)
    printf("Message : %d \n", My_Event.message); 
    }
  else
    printf("No message...." );
  Pm_Close(local);
  return My_Event.message;
}

#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(int i) {
    PmStream * midi;
    PmError status, length;
    PmEvent buffer[1];
    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(&midi, 
                 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);
    }
    /* now start paying attention to messages */
    i = 0; /* count messages as they arrive */
    while (i < num) {
        status = Pm_Poll(midi);
        if (status == TRUE) {
            length = Pm_Read(midi,buffer, 1);
            if (length > 0) {
                printf("Got message %d: time %ld, %2lx %2lx %2lx\n",
                       i,
                       buffer[0].timestamp,
                       Pm_MessageStatus(buffer[0].message),
                       Pm_MessageData1(buffer[0].message),
                       Pm_MessageData2(buffer[0].message));
                i++;            
            }
        }
       
    }
 
    /* close device (this not explicitly needed in most implementations) */
    printf("ready to close..." );
 
    Pm_Close(midi);
    printf("done closing..." );
    return buffer[0].message;
}