Quel idiot je fais !

Je viens de me rendre compte qu'un petit nombre de phonèmes sonne quasi identiquement.

par exemple, "se" et "seu" finira presque exactement par la même chose une fois passé à la moulinette de keroove !

Par conséquent, je peux "sacrifier" cinq ou six échantillons dans la liste et donc arriver à une quantité de phonèmes inférieure à 256 donc tous casables dans un et un seul instrument banque-de sons (cf : le nombre de samples par instrument maximum est de 256)  !

J'ai en outre décidé de donner un nom à ces phonèmes qui morphent : les morphèmes, c'est un barbarisme, mais au point où j'en suis...

Ensuite une fois créés, on n'a plus qu'à utiliser la fonction de création de "loops" dans un sample pour isoler dans ce sample une forme d'onde très courte qui, une fois jouée en boucle, sera "freezée" et sonnera comme une tonalité continue.

Pour avoir une idée de cette bibliothèque de samples à utiliser dans frogoïd, télécharger cet instrument .XRNI ici.

Une fois que c'est fait, utilisez votre clavier maître MIDI pour jouer les notes. Vous verrez qu'en fonction de l'intensité de la frappe, certains morphèmes sont différents. On peut donc assigner plusieurs samples différent à une même note sans chevauchement, si et seulement si on joue cette note à différents niveaux de vélocité, en paramétrant cette vélocité dans la sous-colonne de vélocité (à droite de la colonne de note).

Ma grande difficulté pour la suite, ça va être d'élaborer une matrice en deux dimensions simple d'usage, facile à lire déjà dans l'onglet "sample keyzones", qui servirait de base de départ pour la construction en LUA d'un Wordpad pour Frogoïd.

C'est donc toujours en cours, mais bien parti.

@ bientôt pour la suite des aventures de frogoïd !

--=============================================================
--                 Words Pad pour Frogoïd v.1.0  
--       Design:Satobox  Code:Uprime22   Trad:kurtz/lapiNIC
--         URL de référence pour l'utilitaire japonais :
-- (http://reg.s63.xrea.com/BBS/viewtopic.php?f=2&t=524&start=0 )
--        URL de référence pour l'utilitaire français :
--           (http://www.refra.fr/portail/node/100)
--================================================================
--[[
========================
main.lua
========================
--]]

-- Le concept de frogoïd est quasi similaire à celui développé pour renoid,
-- la différence réside dans le fait que les phonèmes ont été précisément
-- recrées pour permettre un maximum d'articulations verbales en
-- langue française ; je les appelle : les "morphèmes" (cf : barbarisme).
-- le problème est que la quantité de morphèmes nécessaire
-- est bien plus grande que ce que prévoit le code initial de renoid !
-- En effet, j'en ai créé 254. Il en résulte que frogoïd doit dispatcher
-- ses échantillons de façon très différente ; alors comment ?
-- En utilisant les fonctions avancées de la tabulation Sample Keyzones.
-- L'idée principale est d'empiler tous les samples sur 20 strates de vélocité
-- bien différentes, et de désarrimer la vélocité au volume ;
-- Le "package vocal" est ainsi réparti dans une matrice en 2D où
-- sur l'axe x (notes de C-0 à C-4) on én umère toutes les voyelles possibles
-- sur l'axe y, (vélocité de 08 à 7F), on énumère toutes les consonnes possibles
-- les zones contiennent des samples bouclés (forward) et accordés sur 440Hz.  
-- Cette stratégie permet de n'avoir qu'un seul  et unique instrument de stockage
-- d'échantillons, malgré le nombre important de morphèmes nécessaires.

-- Pour la fonction move_cursor, l'inspiratio vient de KMaki et Joule
-- un grand merci à eux !
-- http://forum.renoise.com/index.php?/topic/32240-snippet-edit-step/
require ("move_cursor")

-- la fonction suivante transmet à l'éditeur les ordres d'ajout de notes
-- chaque note étant associée à un "morphème" et à une vélocité précise
-- on a aussi les boutons 'up','down'.
-- notez que 'up','down' fonctionnent selon le paramètre edit step
function note_it (note,velo)
  local s = renoise.song()
  if s.transport.edit_mode == true
  then
    if note =="down" then move_cursor()
    elseif note =="up" then move_cursor(- s.transport.edit_step)
    else
     
      s.selected_note_column.note_string = note     
  -- ça je viens de l'ajouter, je définirai les vélocités plus tard
      s.selected_note_column.volume_string = velo
      
      if note =="---" then
        s.selected_note_column.instrument_value =255
      else
        s.selected_note_column.instrument_value =
        s.selected_instrument_index -1
      end
       move_cursor()
    end
  else return nil
  end
 end

 
  -- initialisation des tables pour l'interface graphique et les valeurs des boutons
  function set_ini(tbl)
    local new ={}
    for i,val in pairs(tbl) do
      if type(val) ~= "table" then
        new[i] = nil
      else
        new[i] = set_ini(val)
      end
    end
    return new
  end
 

--[[ là c'est de la donnée pure?]]------------------------
  -- voici les tables contenant les noms des morphèmes
  -- leurs correspondances sur les sample keyzones?
  -- sous forme de notes et de vélocités
  local tbl_ons =
  {
    {
      {"a","e","i","o","u","an","un","on","ou","oi","é","è"},
      {"ba","be","bi","bo","bu","ban","beu","bin","bon","bou","boi","bé","bè"},
      {"da","de","di","do","du","dan","din","don","dou","doi","dé","dè"},
      {"fa","fe","fi","fo","fu","fan","feu","fin","fon","fou","foi","fé","fè"},
      {"ga","ge","gi","go","gu","gan","geu","gin","gon","gou","goi","gé","gè"},
      {"cha","che","chi","cho","chu","chan","cheu","chin","chon","chou","choi","ché","chè"},
      {"ja","je","ji","jo","ju","jan","jin","jon","jou","joi","jé","jè"},
      {"ka","ke","ki","ko","ku","kan","keu","kin","kon","kou","koi","ké","kè"},
      {"la","le","li","lo","lu","lan","leu","lin","lon","lou","loi","lé","lè"},
      {"ma","me","mi","mo","mu","man","meu","min","mon","mou","moi","mé","mè"}
    },
    {  
      {"na","ne","ni","no","nu","nan","neu","nin","non","nou","noi","né","nè"},
      {"pa","pe","pi","po","pu","pan","peu","pin","pon","pou","poi","pé","pè"},
      {"ra","re","ri","ro","ru","ran","reu","rin","ron","rou","roi","ré","rè"},
      {"sa","se","si","so","su","san","sin","son","sou","soi","sé","sè"},
      {"ta","ti","to","tu","tan","teu","tin","ton","tou","toi","té","tè"},
      {"va","ve","vi","vo","vu","van","veu","vin","von","vou","voi","vé","vè"},
      {"wa","we","wi","wo","wu","wan","weu","win","won","wou","woi","wé","wè"},
      {"xa","xe","xi","xo","xu","xan","xeu","xin","xon","xou","xoi","xé","xè"},
      {"ya","ye","yi","yo","yu","yan","yeu","yin","yon","you","yoi","yé","yè"},
      {"za","ze","zi","zo","zu","zan","zeu","zin","zon","zou","zoi","zé","zè"},
      {"OFF"}
    },
    {
      {"?","?"}
    }
  }
 
  -- les notes qui correspondent sont dispatchées dans une sorte de matrice 2d?
  -- les valeurs 'C-0' - 'G-9', 'OFF' or '---'?
  -- ?'up','down'? peuvent être retournées
  -- et correspondant à la position sur l'axe des x sur les sample keyzones
  local tbl_notes =
  {
    {
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3"},
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3","C-4"},
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3"},
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3","C-4"},
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3","C-4"},
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3","C-4"},
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3"},
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3","C-4"},
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3","C-4"},
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3","C-4"}
    },
    {
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3","C-4"},
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3","C-4"},
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3","C-4"},
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3"},
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3"},
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3","C-4"},
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3","C-4"},
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3","C-4"},
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3","C-4"},
      {"C-0","E-0","G#0","C-1","E-1","G#1","C-2","E-2","G#2","C-3","E-3","G#3","C-4"},
      {"OFF"}
    },
    {
      {"up","down"}
    }
  }
 
-- là je rajoute en plus au code initial les valeurs de vélocité et ce
-- dans une nouvelle table tbv_velo, qui précise la hauteur de la vélocité
-- ATTENTION : cette stratégie ne fonctionne que si et seulement si
-- le bouton VEL->VOL est DECOCHE (ça permet de grouper en un seul
-- instrument la totalité des samples!). J'allais quand même pas
-- répartir tout ça sur 3 ou 4 banques étallées sur 3 ou 4 .xrni !
 
 local tbl_velo =
  {
    {
      {"7F","7F","7F","7F","7F","7F","7F","7F","7F","7F","7F","7F"},
      {"79","79","79","79","79","79","79","79","79","79","79","79","79"},
      {"73","73","73","73","73","73","73","73","73","73","73","73"},
      {"6D","6D","6D","6D","6D","6D","6D","6D","6D","6D","6D","6D","6D"},
      {"67","67","67","67","67","67","67","67","67","67","67","67","67"},
      {"61","61","61","61","61","61","61","61","61","61","61","61","61"},
      {"5B","5B","5B","5B","5B","5B","5B","5B","5B","5B","5B","5B"},
      {"55","55","55","55","55","55","55","55","55","55","55","55","55"},
      {"4F","4F","4F","4F","4F","4F","4F","4F","4F","4F","4F","4F","4F"},
      {"49","49","49","49","49","49","49","49","49","49","49","49","49"}
    },
    {
      {"43","43","43","43","43","43","43","43","43","43","43","43","43"},
      {"3D","3D","3D","3D","3D","3D","3D","3D","3D","3D","3D","3D","3D"},
      {"37","37","37","37","37","37","37","37","37","37","37","37","37"},
      {"31","31","31","31","31","31","31","31","31","31","31","31"},
      {"2B","2B","2B","2B","2B","2B","2B","2B","2B","2B","2B","2B"},
      {"25","25","25","25","25","25","25","25","25","25","25","25","25"},
      {"1F","1F","1F","1F","1F","1F","1F","1F","1F","1F","1F","1F","1F"},
      {"19","19","19","19","19","19","19","19","19","19","19","19","19"},
      {"13","13","13","13","13","13","13","13","13","13","13","13","13"},
      {"0D","0D","0D","0D","0D","0D","0D","0D","0D","0D","0D","0D","0D"},
      {""}
    },
    {
      {"",""}
    }
  }
   
---------------------------------------

 
  -- maintenant, on prépare l'interface graphique en définissant
  -- les valeurs limites desbords et des boutons
  -- simplement à partir des nombres d'items des tables
 
 function hmax()
   return table.maxn(tbl_ons)
 end

 function gmax(h)
   return table.maxn(tbl_ons[h])
 end

 function dmax(h,g)
   return table.maxn(tbl_ons[h][g])
 end

-- dessin de la GUI proprement dite
function on_buttons ()
  local vb = renoise.ViewBuilder()

  -- ViewBuilder comme son nom l'indique va créer une interface?
  -- ya 3 volets, (1) le premier bloc de morphèmes sur 10 lignes à gauche
  -- (2) le second bloc de morphèmes sur 10 lignes à droite
  -- (3) les boutons up&down en dessous
 

  local s0
  local s1 = set_ini(tbl_ons)
  local s2 = set_ini(tbl_ons)
  local s3 = set_ini(tbl_ons)

  -- à l'occasion on définit quoi faire quand un bouton est actionné
  -- via le notifier
  for h = 1,hmax() do
    for g = 1,gmax(h) do
      for d = 1,dmax(h,g) do
        s3[h][g][d] =
        vb:button ({
          width = 35,
          height = 35,
          text = tbl_ons[h][g][d],
          notifier =
          function()
            note_it(tbl_notes[h][g][d], tbl_velo[h][g][d])
          end
        })
      end
    end
  end

  for h = 1,hmax() do
    for g = 1,gmax(h) do
        s2[h][g] =
        vb:row(s3[h][g])
    end
  end

  for h = 1,hmax() do
    s1[h] =
    vb:column(s2[h])
  end

  -- il faut quelques espaces entre les boutons !
  s0 = vb:row{s1[1], spacing =12, vb:column{s1[2],spacing =20,s1[3]}}

  -- et il faut aussi un titre à l'application
  renoise.app():show_custom_dialog("Words Pad pour Frogoïd" ,s0)
end

-- sans oublier de rajouter une entrée au menu de la piste éditée :           
renoise.tool():add_menu_entry {
   name = "Pattern Editor:Words Pad pour Frogoïd...",
   invoke = function() on_buttons() end
}
 

Du nouveau dans le monde de Frogoïd !

Renoid évolue, et donc, Frogoïd aussi !

En effet je ne vous avais pas dit que le blog japonais faisait régulièrement état état d'un travail audacieux produisant l'analyse automatisée des librairies de phonèmes en LUA pour Renoid ; cette analyse automatisée permettrait de créer en alternative au système d'entrée de phonèmes par boutons, un système d'entrée de phonèmes basé sur une boite de texte écrit. Par exemple, il suffiit donc d'écrire dans cette boite les phonèmes désirés, avec le clavier azerty, et le programme les convertit en notes et les dispatche sur le pattern selon un tempo précis impulsé par l'éditeur du pattern. Plus besoins de boutons, il suffit de connaître les phonèmes.

Cette idée somme toute simple pourrait donner une énorme valeur ajoutée au wordspad existant.

Eh bien tada, elle vient juste d'être finalisée sur le plan de la programmation ! Ca s'appelle : txt2notes.

Comme vous le constatez dans cette capture d'écran, satobox, gérant du blog japonais, a en outre légèrement remanié ma librairie de samples français pour la rendre plus compatible avec cette extension très intéressante.

D'après mes tout premiers tests, ça semble marcher !

Cependant, quelque chose me gène, je constate quelques ratés, soit parce que je n'ai pas (justement) en tête tous mes phonèmes précisément, soit parce que l'entrée des notes est basé sur un système de combinaisons de touches qui n'est pas vraiment simple à retenir ; et en outre, l'interface ne daigne même pas s'agrémenter d'une petite aide même symbolique. C'est somme toute un problème mineur, et ça ne devrait pas me poser trop de problème pour m'inspirer du code de txt2notes pour faire un frogoid 2.0.

Je me demande en effet s'il ne serait pas finalement plus judicieux de conserver le système par bouton comme "mode d'édition avancée" en cas d'oubli et/ou de raté lors de l'introduction des phonèmes par boite de texte. En somme, j'aimerais fusionner les deux interfaces en une seule qui en combine les avantages.

Ah d'accord oui ça a du potentiel...

Sinon, en creusant l'idée pour savoir plus concrètement comment l'exploiter, il faudrait transcoder le célèbre Insutron en ligne dans Renoise.

C'est à dire que tu prononces toi-même si possible les bouts de phrases utiles.

Et ensuite faut qu'on adapte le code en JS, et le transformer en code type LUA.

C'est quand même un gros boulot mais ça pourrait être marrant de coder ça et ensuite de le proposer.