Ada

Séquenceur MIDI avec Ada

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : Séquenceur MIDI avec Ada

The matrix

Chacun fait ce qu'il en veut.

Bonjour,

Sous le conseil je pense avisé de el muchacho, je viens vous demander conseil pour le réalisation d'un séquenceur MIDI avec Ada.

Voilà, j'y connais rien en temps réel.
Je peux vous poster ce que j'ai fait depuis 7 heure ce matin...

Code :

with Portmidi, Porttime;
use Portmidi, Porttime;
with System;
use System;
with Musician;
use Musician;
 
package body Harmonia is
 
 
   type T_Orchester is array (Positive range <> ) of T_Musician;
 
 
   task body Conductor is
      End_Of_Task : Boolean := False;
      Entract : Boolean := False;
 
      Orchester : T_Orchester(1..1);
 
      Pt_Error : PtError;
      Pm_Error : PmError;
      Resolution : Integer := 1;
      PtCallback,
      UserData : System.Address := Null_Address;
   begin
 
      Pt_Error := Pt_Start(Resolution, PtCallback, UserData);
      Pm_Error := Pm_Initialize;
 
      Orchester(1).Initialize(6);
      while not End_Of_Task loop
         accept Start do
            for I in Orchester'Range loop
               Orchester(I).start;
            end loop;
            Entract := False;
         end Start;
         loop
            select
               accept Stop do
                  for I in Orchester'Range loop
                     Orchester(I).stop;
                  end loop;
                  Entract := True;
               end Stop;
            or
               accept Halt do
                  for I in Orchester'Range loop
                     Orchester(I).Halt;
                  end loop;
                  Entract := True;
                  End_Of_Task := True;
               end Halt;
            or
               delay 0.0;
         null;
 
 
            end select;
            exit when Entract;
         end loop;
      end loop;
 
      Pm_Error := Pm_Terminate;
 
   end Conductor;
 
 
end Harmonia;

Code :

with Text_Io;
with System;
with System.Address_To_Access_Conversions;
with Interfaces.C;
with Portmidi, Porttime;
use Text_Io;
use System;
use Interfaces.C;
use Portmidi, Porttime;
 
 
 
package body Musician is
 
   subtype SubString is Char_array(1..64);
   package String_Address_Conversion is new System.Address_To_Access_Conversions(substring);
   use String_Address_conversion;
 
 
 
   task body T_Musician is
      End_Of_Task : Boolean := False;
      Entract : Boolean := False;
 
 
 
 
 
 
      Pm_Error : PmError;
 
      PortMidiStream_Ptr : System.Address;
 
      OutputDriverInfo_Ptr : System.Address := Null_Address;
      Time_Info_Ptr : System.Address;
 
 
      Current_DeviceInfo : DeviceInfo;
 
 
 
 
      Resolution : Integer := 1;
      PtCallback,
      UserData : System.Address := Null_Address;
 
      Pm_Event : PmEvent;
 
      Content : T_Message := (16#90#, 60, 100);
 
 
 
   begin
 
 
 
 
      accept Initialize(Instrument : T_instrument) do
         PortMidiStream_Ptr := Open_Handler(Instrument);
         Put_line("Pm_OpenOutput... Ok !" );
         delay 1.0;
         if Pm_HasHostError(PortMidiStream_Ptr) /= 0 then
            Put_line(To_Ada(Pm_GetErrorText(Pm_Error)));
         else
            Put_line("PortMidiStream... Ok !" );
            Pm_Event.Message := Pm_Message(Content);
            delay 1.0;
         end if;
      end Initialize;
      while not End_Of_Task loop
         accept Start do
            Entract := False;
         end Start;
         loop
            select
               accept Receive(Partition : T_Partition) do
                  null;
               end Receive;
            or
               accept Tempo(Length : in Duration) do
                  null;
               end Tempo;
            or
               accept Sync do
                  null;
               end Sync;
            or
               accept Stop do
                  Entract := True;
               end Stop;
            or
               accept Halt do
                  Pm_Error := Pm_Close(PortMidiStream => PortMidiStream_ptr);
                  --Put_line(To_ada(Pm_GetErrorText(Pm_Error))); -- Cause Error C Terminator;
                  Entract := True;
                  End_Of_Task := True;
               end Halt;
            or
               delay 0.0;
               Pm_Event.PmTimestamp := Pt_time;
               Pm_Error := Pm_WriteShort(PortMidiStream_Ptr, Pt_Time, Pm_Event.message);
               if Pm_HasHostError(PortMidiStream_Ptr) /= 0 then
                  Put_line(To_Ada(Pm_GetErrorText(Pm_Error)));
               else
                  Put_line("Pm_Write... Ok !" );
               end if;
            end select;
            exit when Entract;
         end loop;
      end loop;
   end T_Musician;
 
 
end Musician;

Mais vraiment au pif.

Merci pour votre participation, votre aide.. et tout et tout. :jap:

---------------
des gestes simples et ponctués, par quelques points presque importants, la précision coordonnée, d'une île déserte, des plans secrets, d'un architecte, à la retraite, passionné par son métier, refaire le monde, à son idée, tracer des routes, les emprunter

Publicité

The matrix

Chacun fait ce qu'il en veut.

Bonjour,

Question de capacité intellectuelle, je me sans limité sur le coup !

Pour construire les message MIDI à envoyer, je doit me référer à la norme General MIDI.
N'ayant pas trouvé de document ressemblant à celui-ci ::= RADIAS MIDI Implementation je vais donc m'en contenter pour le moment quitte à tout refaire plus tard, ça me fera un exercice. Mais, le problème c'est que j'ai beaucoup de mal à le comprendre. Il est plein de référence, c'est un vrai code.

Donc, si vous avez un connaissance du problème, ou le temps et l'envie de vous y intéresser... La question est : Comment dois-je m'y prendre pour modéliser les différents types utilisés ?

Je suis même pas certain de poser la bonne question [:tinostar]

Message édité par The matrix le 14-08-2009 à 14:49:13

Profil supprimé

Bonjour,

Je vous poste ce que j'ai commencer à faire dans le cadre de l'implémentation de la norme General MIDI, la critique sera plus facile...

En fait, il ne s'agit pas tout à fait de la General MIDI, mais de l'implémentation MIDI d'un instrument particulier, nommé Radias (Vois le doc ci-dessus)

Code :

package Midi_Implementation is
 
   subtype T_Chanel is Natural range 0..15;
 
   subtype T_Note_Sens is Positive range 1..127;
   subtype T_Note is Positive range 21..108;
 
   Note_Off : constant T_Note := 64;
 
   subtype T_Bank is Natural range 0..1;
   subtype T_Program is Natural range 0..127;
 
   Arp_Off : constant Natural := 0;
   Arp_On  : constant Natural := 127;
   Latch_Off : constant Natural := 0;
   Latch_On  : constant Natural := 127;
 
   Arp_Type_up : constant Natural := 16#0#;
   Arp_Type_down : constant Natural := 16#15#;
   Arp_Type_alt1 : constant Natural := 16#2A#;
   Arp_Type_alt2 : constant Natural := 16#3F#;
   Arp_Type_random : constant Natural := 16#54#;
   Arp_Type_trigger : constant Natural := 16#69#;
 
   subtype T_Arp_Gate is Natural range 0..127;
 
   Arp_Select_Off : constant Natural := 0;
   Arp_Select_arp : constant Natural := 1;
   Arp_Select_Step_Seq_1 : constant Natural := 2;
   Arp_Select_Step_Seq_2 : constant Natural := 3;
 
   Step_Seq_1_Latch_off : constant Natural := 0;
   Step_Seq_1_Latch_on  : constant Natural := 127;
 
   subtype Step_Seq_1_Gate is Natural range 0..127;
 
   Step_Seq_2_Latch_off : constant Natural := 0;
   Step_Seq_2_Latch_on  : constant Natural := 127;
 
   subtype Step_Seq_2_Gate is Natural range 0..127;
 
end Midi_Implementation;

Je suis carrément paumé là [:tinostar]

Profil supprimé

Bonjour, pour l'implémentation midi de finalement ça prends plutôt la fomre suivante :

j'ai fait ça :

midi_implementation.ads

Code :

with Message;
use Message;
 
package Midi_Implementation is
 
   subtype T_Chanel is Natural range 0..15;
   subtype T_Note_Sens is Positive range 1..127;
   subtype T_Note is Positive range 21..108;
   function Note_On(Chanel : in T_Chanel;
                    Note : in T_Note;
                    Sens : in T_Note_Sens) return T_Message;
 
   function Note_Off (Chanel : in T_Chanel;
                     Note : in T_Note) return T_Message;
 
   subtype T_Bank is Natural range 0..1;
   subtype T_Program is Natural range 0..127;
 
   function Bank_Select_MSB(Chanel : in T_Chanel;
                            Bank : in T_Bank) return T_Message;
   function Bank_Select_LSB(Chanel : in T_Chanel;
                            Program : in T_Program) return T_Message;
 
   function Program_Change(Chanel : in T_Chanel) return T_Message;
 
   subtype T_Value is Natural range 1..127;
 
   function NRPM_MSB (Chanel : in T_Chanel;
                      Value : in T_Value) return T_Message;
   function NRPM_LSB (Chanel : in T_Chanel;
                      Value : in T_Value) return T_Message;
   function Data_Entry_MSB (Chanel : in T_Chanel;
                            Value : in T_Value) return T_Message;
 
  
end Midi_Implementation;

midi_implementation.adb

Code :

function Note_On(Chanel : in T_Chanel;
                    Note : in T_Note;
                    Sens : in T_Note_Sens) return T_Message is
 
      Message : T_Message := (16#90# + Chanel, Note, Sens);
   begin
 
      return Message;
   end;
   function Note_Off (Chanel : in T_Chanel;
                     Note : in T_Note) return T_Message is
      Message : T_Message := (16#80# + Chanel, Note, 64);
   begin
 
      return Message;
   end;
   function Bank_Select_MSB(Chanel : in T_Chanel;
                            Bank : in T_Bank) return T_Message is
 
      Message : T_Message := (16#B0# + chanel, 0 , Bank);
   begin
 
      return Message;
   end;
 
   function Bank_Select_LSB(Chanel : in T_Chanel;
                            Program : in T_Program) return T_Message is
 
      Message : T_Message := (16#B0# + chanel, 32 , Program);
   begin
 
      return Message;
   end;
 
   function Program_Change(Chanel : in T_Chanel) return T_Message is
 
      Message : T_Message := (16#B0# + chanel, 1, 0);
   begin
 
      return Message;
   end;
 
   function NRPM_MSB (Chanel : in T_Chanel;
                      Value : in T_Value) return T_Message is
 
      Message : T_Message := (16#B0# + Chanel, 98, Value);
   begin
 
      return Message;
   end;
 
   function NRPM_LSB (Chanel : in T_Chanel;
                      Value : in T_Value) return T_Message is
 
      Message : T_Message := (16#B0# + Chanel, 99, Value);
   begin
 
      return Message;
   end;
   function Data_Entry_MSB (Chanel : in T_Chanel;
                            Value : in T_Value) return T_Message is
 
      Message : T_Message := (16#B0# + Chanel, 6, Value);
   begin
 
      return Message;
   end;
 
end Midi_Implementation;

Et j'appelle comme ça :

Code :

Oeuvre(1).Last_content := 1;
      Oeuvre(1).Staff(4) := Bank_Select_MSB(15, 0);
      Oeuvre(1).Staff(4) := Bank_Select_LSB(15, 14);
      Oeuvre(1).Staff(4) := Program_change(15);
      Oeuvre(1).Staff(4) := Note_On(0, 60, 100);

J'ai déjà testé un note-on, mais la le Bank_Select_MSB marche pas !
la lib midiport me dit

Citation :

PortMidi call failed...
PortMidi: `Illegal error number'
type ENTER...

Message édité par Profil supprimé le 15-08-2009 à 15:26:23

Profil supprimé

Citation :

#
euvre(1).Last_content := 1;
Oeuvre(1).Staff(4) := Bank_Select_MSB(15, 0);
Oeuvre(1).Staff(4) := Bank_Select_LSB(15, 14);
Oeuvre(1).Staff(4) := Program_change(15);
Oeuvre(1).Staff(4) := Note_On(0, 60, 100);

Tein, ça j'avais pas fait gaffe... Tous les message sont en 4ieme position de la partition. [:tinostar]

Flood, désolé !

Du coup, j'ai résolut mon problème. Merci

Profil supprimé

Yep !

J'ai un problème avec une boucle qui tourne pas. je devrais écrire 4 fois, et je n'en voie qu'un passer.

Voyez vous même :

Code :

with Text_Io;
with System;
with System.Address_To_Access_Conversions;
with Interfaces.C;
with Portmidi, Porttime;
use Text_Io;
use System;
use Interfaces.C;
use Portmidi, Porttime;
 
with Queue;
 
 
package body Musician is
 
   subtype SubString is Char_array(1..64);
   package String_Address_Conversion is new System.Address_To_Access_Conversions(substring);
   use String_Address_conversion;
 
   package Partition_Queue is new Queue(T_Partition);
   use Partition_Queue;
 
 
   task body T_Musician is
      End_Of_Task : Boolean := False;
      Entract : Boolean := False;
 
      Pm_Error : PmError;
 
      PortMidiStream_Ptr : System.Address;
 
      OutputDriverInfo_Ptr : System.Address := Null_Address;
 
      Resolution : Integer := 1;
      PtCallback,
      UserData : System.Address := Null_Address;
 
      Pm_Event : PmEvent;
 
 
      wait : Duration := 0.03;
      Index : Natural := 0;
 
      Current_Partition : T_Partition;
      Queue_Of_Partition : T_Queue;
 
   begin
 
      accept Initialize(Instrument : T_instrument) do
         Queue_Init(Queue_Of_Partition);
         PortMidiStream_Ptr := Open_Handler(Instrument);
         Put_line("Pm_OpenOutput... Ok !" );
      end Initialize;
      accept Adjust(Partition : T_Partition) do
         Current_Partition := Partition;
         Index := 1;
      end Adjust;
      while not End_Of_Task loop
         accept Start do
            Entract := False;
         end Start;
         loop
            select
               accept Receive(Partition : T_Partition) do
                  Queue_Push(Queue_Of_Partition, Partition);
               end Receive;
            or
               accept Tempo(Length : in Duration) do
                  Wait := Length;
               end Tempo;
        or
               accept Sync do
                  null;
               end Sync;
            or
               accept Stop do
                  Entract := True;
               end Stop;
            or
               accept Halt do
                  Pm_Error := Pm_Close(PortMidiStream => PortMidiStream_ptr);
                  --Put_line(To_ada(Pm_GetErrorText(Pm_Error))); -- Cause Error C Terminator;
                  Entract := True;
                  End_Of_Task := True;
               end Halt;
            or
               delay 0.0;
               if Index /= 0 then
                  Pm_Event.Message := Pm_Message(Current_Partition.Staff(Index));
                  Pm_Event.PmTimestamp := Pt_time;
                  Pm_Error := Pm_WriteShort(PortMidiStream_Ptr, Pt_Time, Pm_Event.message);
                  if Pm_HasHostError(PortMidiStream_Ptr) /= 0 then
                     Put_line(To_Ada(Pm_GetErrorText(Pm_Error)));
                  else
                     Put_line("Pm_Write... Ok !" );
                     if Index < Current_Partition.Last_Content then
                        Index := Index + 1;
                     else
                        if not Queue_Empty(Queue_Of_Partition) then
                           Queue_Pop(Queue_Of_Partition, Current_Partition);
                           Index := 1;
                        else
                           Index := 0;
                        end if;
 
                     end if;
                  end if;
                  delay Wait;
               end if;
            end select;
            exit when Entract;
         end loop;
      end loop;
   end T_Musician;

Merci !

Profil supprimé

C'est la panique [:kernel panic]

Désolé, pas pris les bon réflexe encore. je vais tracer.

The matrix

Chacun fait ce qu'il en veut.

Bonsoir, Bonjour,

j'ai un problème avec mon séquenceur. Harmonie-0.1.0-2b.tar.gz pour Gnu/linux.
En effet, j'ai un gros problème de rendez-vous entre tache.
Mais je distingue trois phénomènes.
Le système peut ce caler sur la tache la plus lente.
Ou alors, si il y a une grande différence de longueur de note, ça semble passer.
Et si non, on dirait qu'il est impossible d'envoyer une donnée synthé sans une donné drum ou inversement.
Il faut regarder dans le fichier Great_Architect.adb
La longueur d'une note est modélisé par un delay dans les taches Drum et Synth.
Voila, C'est toujours un peu complexe... Avis au amateurs.

Merci pour votre aide, bien à vous !

Message édité par The matrix le 30-08-2009 à 22:41:42

Profil supprimé

Bonjour à vous.

Je me casse la tête ce matin pour reconstruire un séquenceur.
J'avais dans l'idée de faire une queue par piste et de lire chaque piste en parallèle mais je me heurte au type de donnée à fournir.
J'ai tout un tas d'instruction midi à transmettre et toutes ces instructions sont formées de divers données comme entre autre le N° de piste.
Je me dis alors qu'il n'est pas possible de faire comme j'en avais l'intention.

Je viens donc poser pour réveiller l'analyste qui sommeille en vous (j'espère qu'à cette heure il soit tout de même bien réveillé) la question...
Qu'est-ce qu'un séquenceur Midi, comment est-ce construit ?
Merci pour votre contribution.

Profil supprimé

Lutin, faut avoir la tête à ça pour répondre, si on le sais pas.

Bon, alors j'essaye de pondre.

C'est un espace de message MID géré en temps réel et partagé par deux processus dont l'un permet d'écrire dans l'espace de message MIDI et l'autre permet de transmettre les messages à instrument MIDI.

Pour le faire, je ferais deux espaces de message, un disponible en écriture pendant que l'autre l'est en lecture et je ferais une lecture/écriture et une rotation des espace en fonction du tempo.

Ok !

FORUM HardWare.fr

Programmation

Ada

Séquenceur MIDI avec Ada

Sujets relatifs
[Résolut]liaison Ada avec un .o C	accès à fonction importée à accè à fonction importé.
utilisation d'un librairie C avec Ada.	[Ada] [Conception] Un compositeur interprète avec Ada.
[Divers][Lecture]Utilisation de la bibliothèque portmidi : Pm_Read()	Interface C/Ada + SDL
Fonction C times en Ada.	Faire des cadres en 'texte' avec Ada
Problème de Random pour Dichotomie
Plus de sujets relatifs à : Séquenceur MIDI avec Ada

Page générée en 0.101 secondes