Bonjour,
J'ai la technique mais j'ai pas l'esprit à la synthèse.
Je cherche comment modéliser un objet dont j'ignore tout à priori.
C'est un hybride de théorie musical et processus informatiques temps réel.
Je ne parviens pas à savoir ce que je doit faire.
J'ai déjà fait trois programmes sur le sujet.
Possible d'avoir un coup de main pour l'analyse ?
 
 
\Mode express
 
Je viens de partir sur une idée, voilà déjà une orientation....
 
J'ai fait une unité générique avec un paramètre générique "max_polyphony", le maximum de note maintenu en même temps.
Et j'ai définit un type "Polyphonique_Type" de type tableau de taille "max_polyphony". Et je sais maintenant que je cherche l'objet à mettre dans ce tableau. A peu près.    
C'est un hybride entre un message event et peut-être une entrée dans un fichier pour lecture de mémoire. J'en sais rien.    
 
Une idée ?

Ah, j'ai une intuition, faut que je vous la donne.
 
En fait, ce que je doit modéliser, ce sont les instrument que je vais utiliser.
Par exemple, perso, j'ai un synthétiseur avec 2 oscillateurs+noise generator j'ai 9 wave forme sur l'oscillateur 1 etc...
Comme un drivers..., non ?

Bonjour,
 
Peut-être regarder des solutions existantes comme CSound ou SuperCollider.
 
Cordialement,
MaxS

Monjour, bonjour MaxS,
Pour te répondre tout de suite MaxS, après avoir jeté un petit coup d'oeil sur ce que pourraient être ces deux machins, je n'ai pas l'intention d'utiliser autre chose que le langage Ada avec trois petits bouts de C. Mais de toute manière, je ne pense pas qu'un programme comme celui que je vais probablement produire existe déjà. D'ailleurs, je ne sais pas encore lequel.
 
L'objectif est de produire un programme sachant composer et jouer la musique sur un instrument MIDI pour une durée indéterminée.
 
Ce que je cherche ici, c'est l'objet central du système, après je ferai mon travail.
 
Cet objet serait composé d'une vue de l'instrument (ici les Instruments MIDI), et d'une "tendance musicale" à jouer, mais c'est la que je pêche un peu. La tendance musicale, c'est très abstrait pour moi, parce qu'après il faut produire un système de production musicale à "tendance musical" et un système de production de tendance musicale. (Parce que je peux pas la donner pour une fois.)
 
Bon, y a deux minutes ça me paraissait très simple, et pis, ça devient plus compliqué... Bref.
Réutiliser c'est bien, mais qu'est que vous diriez si a chaque fois que vous proposiez de construire un nouveau truc on vous répondait "mais pour quoi t'utilises pas ça ?" C'est qui l'artiste ?

Arf, je m'en sort pas.
Bad code en fait.
 
 
j'arrive pas à savoir "quoi dépend de quoi".
 
En gros j'ai des pilote pour les entrées, des pilote pour les sorties, un sequenceur, et un compositeur.
 
Le séquenceur (task) doit avoir des entrées (entry) pour la lecture et l'écriture distinctes pour les entrées et les sortie.
 
J'arrive pas à déterminer qui va lire quoi.
 

Si ce que tu veux faire, c'est un programme qui crée de la musique à partir de certains paramètres comme le nb max de notes jouées en même temps, le tempo, le style musical, ça existe déjà
 
Et bien souvent, on trouve des algos génétiques dans ce type de création (par ex, avec des colonies de fourmis). En 2002, j'avais un  copain qui ont fait un programme de "fourmis musicales"...

Bonjour rufo.
Ouais, je me doute bien que je suis pas le premier à penser à ça.
 
J'en suis pas encore à l'implémentation du compositeur, mais j'ai entendu ailleurs que la génétique pouvait être intéressante.
 
Là, je me prend la tête pour organiser mon séquenceur avec les accès au entrées et sorties MIDI.

Bonjour,
 
je viens mettre à jour le sujet avec de nouveaux éléments pour construire mes objets musicaux.
 
J'écris actuellement un programme qui doit au final générer diverses formes de musiques selon trois modes de composition.
 
J'ai d'abord définit les modes : naturel, fusion, fission
En suite les formes : classique, jazz, electro, techno, acid, etc...
Une liste de type d'instrument comme : drums, lead, bass, clavier soft, clavier hard... etc.
 
avec ça je veux pouvoir piloter un synthétiseur multi-timbre.
 
Pour le moment, j'ai définit quelques types.
 

with Midi_Theory;
 
package Phoebus is
 
   use Midi_Theory;
 
   type Form_Type is (Null_Item,
                      Classical, Electro, Jazz,
                      Acid, Techno, Hardtech, Tribe,
                      Hardcore, Trance, Minimal, DnB);
   Default_Form : constant Form_Type := Null_Item;
 
   type Category_Type is (Off, Drums_Kit, Global,
                          Bass, Lead, Synth_Hard, Synth_Soft,
                          Motion, Strings_N_Pads, Keyboard, Guitare_N_Pluck,
                          Bell_N_Decay, Hit_N_Drum, S_E, Arp_Seq,
                          Split, Audio_In, Vocoder, User);
 
 
   type Orchester_Type is array (Channel_Type) of Category_Type;
 
   type Program_Type is
      record
         Form      : Form_Type := Null_Item;
         Orchester : Orchester_Type := (others =>  off);
      end record;
 
   Null_Program : constant Program_Type := (Null_Item, (others => Off));
 
   type Program_Access is access all Program_Type;
 
   type Bank_Type is array (Natural range <>, Natural range <>, Natural range <> ) of Program_Access;
 
 
   function Initialize_From_File(Filename : in String) return Bank_Type;
 
   procedure Save_To_File(Filename : in String; Bank     : in Bank_Type);
 
 
   subtype Num_Type is Positive range 1..16;
   subtype Den_Type is Positive range 1..16;
 
   type Schema_Type is
      record
         Num : Num_Type := 4;
         Den : Den_Type := 4;
      end record;
 
   type Schemas_Type is array (Natural range <> ) of Schema_Type;
 
   type Mode_Type is (Nature, Fusion, Fission, Silence);
 
   type Tempo_Type is delta 0.1 range 1.0..999.9;
 
   subtype Bar_Index_Type is Long_Long_Integer range 1..Long_Long_Integer'Last;
 
   type Transport_Type(Schema_Max : Positive := 16) is
      record
         Tempo          : Tempo_Type      := 120.0;
         Schema         : Schema_Type     := (4, 16);
         Current_Step   : Natural         := 0;
         Bar_Index      : Bar_Index_Type  := 1;
      end record;
   -- Un type qui regroupe les informations sur le transport.                                                                            
 
   type Transport_Access is access Transport_Type;
 
 
   function Quantum(Transport : in Transport_Type) return Duration;
   -- Renvoie la durée d'un pas.                                                                                                         
 
 
 
   type Part_Type(Mode : Mode_Type;
                  last : Positive) is
      record
         Initial_Form : Form_Type := Default_Form;
         Schemas      : Schemas_Type(0..last);
         Tempo        : Tempo_Type := 120.0;
         case Mode is
            when Fusion | Fission =>
               Terminal_Form : Form_Type := Default_Form;
            when others =>
               null;
         end case;
      end record;
 
   type Part_Access is access all Part_Type;
 
   Default_Part : constant Part_Access := new Part_Type ' (Silence, 1, Default_Form, (others => (4, 4)),  120.0);
end Phoebus;

Qques references biblio:
Algorithmic Composition: Paradigms of Automated Music Generation - Gerhard Nierhaus - Springer (le contenu vaut pas le titre en fait)
The Rubato Composer Music Software: Component-Based Implementation of a Functorial Concept Architecture - Gérard Milmeister - Springer
Applications of Generative String-Substitution Systems in Computer Music - R L Dubois - Thèse Univ de Columbia
Composing Music with Computers - Eduardo Reck Miranda - Focal Press
 
A+,

Bonjour,
 
Merci Gilou, et bienvenue sur le topic ; Je pige rien à l'english, c'est probablement dommage.
 
Après, avec les type définis ci-dessus je défini un nouveau type qui englobe les dit types.
 

with Step_Sequences;
package Phoebus.Bandmaster is
 
   use Step_Sequences;
 
   type Break_Type is (No_Break, Bass_Break, Break, Break_Down);
 
   type Master_Type is
      record
         The_Part         : Part_Access;
         The_Transport    : Transport_Access;
         The_Schema_Index : Natural := 0;
         The_Program      : Program_Access;
         The_Break        : Break_Type := No_Break;
         The_Step_Seq     : Step_Seq_Access;
      end record;
 
   procedure Masterize(Master : in out Master_Type);
 
end Phoebus.Bandmaster;

 
Et voilà, je dois produire la musique selon les paramètres de masterization.
 
Ca fait un paquet de paramètres à prendre en compte    
 
A ceux-ci évidemment, je pense que vont s'ajouter encore d'autres paramètre en fonction des formes et des catégories des instruments joués.

Je vais plutôt faire un truc dans le genre :
 
 

--
   task type Composer_Type(Category : Category_Type) is
 
      entry Start(Quantum : in Duration);
      entry Stop;
      entry Halt;
      entry Compose(Form     : in Form_Type;
                    Channel  : in Channel_Type;
                    Schema   : in Schema_type);
      entry Receive(Buffer : in Buffer_Type);
      entry Send(Step_Seq  : out Step_Seq_Access);
   end Composer_Type;
 
   type Composer_Access is access Composer_Type;
 
   type Composers_Set_Type is array (Category_Type) of Composer_Access;

 
Parce que j'ai besoin d'interagir en temps réel avec le composer.

Bonjour,
 
Je refais un compositeur virtuel, après Quatuor qui n'a pas fonctionné comme prévu.
Je ne vais pas faire plus simple, mais mieux.
Parce que c'est pas simple.
Je découpe à peine une dizaine de bibliothèques aujourd'hui. Il en manque probablement au moins autant.
Et justement, avez vous des idée avec l'inspiration du code ci-dessous :

----------------------------------------
-- AcidPulse is Acid virtual composer.
-- Copyright (C) 2014 Manuel De Girardi
----------------------------------------
--                                    --
--        *******************         --
--        **               **         --
--        **   AcidPulse   **         --
--        **               **         --
--        *******************         --
--        **               **         --
--        ** version 0.0.1 **         --
--        **               **         --
--        **  2014-02-07   **         --
--        **               **         --
--        *******************         --
--                                    --
----------------------------------------
-- Description : Compositeur virtuel.
----------------------------------------
with Ap; 
 
with Ap.System;
with Ap.System.MIDI;
with Ap.System.MIDI.Devices;
with Ap.System.MIDI.Drivers;
with Ap.System.MIDI.General_MIDI;
with Ap.System.MIDI.General_MIDI.Generic_Instrument;
 
with Ap.Musical;
with Ap.Musical.Theory;
with Ap.Musical.Theory.Rhythm;
with Ap.Musical.Theory.Melody;
with Ap.Musical.Theory.Harmony;
 
procedure Acidpulse is
         
begin
      
   null;
end Acidpulse;

Je cherche au moins les nom de deux hiérarchies de bibliothèques, une pour constituer un orchestre, et l'autre pour centraliser les flux et le pilotage.
Il manquera celle du/des compositeurs et peut-être celle de des interprètes.
Je me lance dans un truc bien chiadé, je pense.

Bonjour,
 
Je répond à ma question précédente et je demande autre chose....
 
 
Voilà pour ce que j'ai fait :

with Ap.AcidPulse.Generic_Pulser;
 
with AP.HMI.Xwindow;
 
with Gtk.Main;
 
procedure Acidpulse is
 
   package Pulser is new Ap.Acidpulse.Generic_Pulser;
begin
 
   Pulser.Initialize;
 
   Gtk.Main.Init;
 
   declare
 
      package XAcidPulser is new Ap.HMI.Xwindow(Pulser);
 
      Xwindow : XAcidpulser.Xwindow_Type;
   begin
 
      XAcidpulser.New_Xwindow(Xwindow);
 
      XAcidPulser.Initialize(Xwindow);
 
      Gtk.Main.Main;
   end;
 
end Acidpulse;

 
Et j'ai gardé la liste de mon cédoupage précédant augmenté à tord ou à raison :

with Ap;
 
with Ap.System;
with Ap.System.MIDI;
with Ap.System.MIDI.Devices;
with Ap.System.MIDI.Drivers;
with Ap.System.MIDI.General_MIDI;
with Ap.System.MIDI.General_MIDI.Generic_Instrument;
 
with Ap.Musical;
with Ap.Musical.Theory;
with Ap.Musical.Theory.Rhythm;
with Ap.Musical.Theory.Melody;
with Ap.Musical.Theory.Harmony;
 
with Ap.Software;
with Ap.Software.Common;
with Ap.Software.Tools;
with Ap.Software.Engineering; -- genetics&connexions
with Ap.Software.Engines; -- Sequencers&transport
 
with Ap.Computing;
with Ap.Computing.System;
with Ap.Computing.Musical;
with Ap.Computing.Software;
 
with Ap.Acidpulse.Orchester;
with Ap.AcidPulse.Composer;
with Ap.Acidpulse.Pulser;
 
with Ap.HMI;
with Ap.HMI.System;
with Ap.HMI.Software;
with Ap.HMI.Musical;
 
with Ap.HMI.Xwindow;

 
 
Du coup je passe à l'étape suivante, l'interface graphique.
J'écris un compositeur virtuel qui envoie directement la partition aux périphériques, en temps réel.
Le compositeur au totalement automatique après paramétrage, le système MIDI restant pilotable, c'est à dire que l'utilisateur peu jouer en live en plus du compositeur.
 
je cherche comment présenter mon système à l'utilisateur, comment interfacer par logiciel mon système MIDI+Compositeur.
 
Pour le moment je vois grosso modo, soit une interface, je dirais cognitive avec une architecture complexe, soit un ensemble de tableaux avec des lignes et quelques paramètres ou informations par ligne sur le système, une architecture plus simple, peut-être moins jolie, mon ergonomique moins élégante.
 
J'aurais aimé avoir votre avis rapidement, si'l vous plaît ?
 
Fritures :
Paramétrage

• utilisation d'un ou plusieurs instrument MIDI.
• tempo moyen à observer.
• durée de la boucle (fin de partition)
• jouer en boucle.
• les paramètre musicaux.

 
Contrôle

• lecture d'un fichier de commandes globale.
• lecture d'un fichier de commande pour un instrument.
• déclaration/suppression d'un contrôleur à variation paramétrable supplémentaire.
• déclaration/suppression d'une séquence de notes supplémentaire.

 
Merci pour votre aide.
 
C'est à dire que si je me dis que je présente tous par tableau, ça deviens plus simple, mais je vais probablement faire une bêtise.
non ?

Bonjour,
 
 
je refais un compositeur virtuel pour instrument midi pour faire de l'acid music.
 
J'ai mon type de base qui sera manipuler partout dans mon programmme.
 
C'est un controleur ; un controleur pour le moment c'est un article paramétré de son numéro de contrôle contenant une valeur.
Typiquement avec 128 contrôleurs, on modélise un instrument midi.
 
Après je vais générer des variation de valeur de ces controleurs avec une machine que je souhaiterai modéliser avec un autre jeux de contrôleur que je présenterais enfin à l'utilisateur pour paramètrer le générateur.
 
Mais pour le moment je n'ai que quelques fonctions à associer à mes contrôleur.
 
Je me suis dis déjà que je présenterais un paramètre "Acidifier" valant de 0 à 127 pour obtenir le ph voulue.
Ce serait le paramètre de finalization du générateur.
En gros je compte composer une musique occidentale plus ou moins savante que je qualifirais de naturelle, et en suite je l'acifie.
 
Si ce modèle vous branche on peut en discuter peut-être pour enrichire nos connaissances.