#26 Le 26/05/2013, à 14:48
- amj
Re : [Résolu] Métronome pour mesures composées
Je crois que c'est mieux écris comme ceci 
(j'ai un peu lu la doc et ton script)
j'ai oublier les mesures 
#!/bin/bash
#metronome.sh v0.3 by amj
#à emploiyer de cette manière
# ./metronome.sh longeur_d'une_noire nb_de_mesure "croche && noire && croche && double_croche" #(les trois paramètres droivent être présents et dans l'ordre)
mesure=$2
time=$1
rythm=$3
text1="Entrez le nombre de mesures."
text2="Entrez le temps d'une noire."
text3="Entrez les rythmes voulus dans l'ordre et de la manière suivante:\n
rythme1 rythme2 rythme3 ... rythme_n \n
Les rythmes supportés sont les suivants: \n
noire croche et double\_croche "
if [[ $rythm == "" ]];then mesure=$(zenity --entry --text="$text1" ) && time=$(zenity --entry --text="$text2" ) && rythm=$(zenity --entry --text="$text3" ) ; fi
sound=/usr/share/sounds/free*/s*/bell.oga #tu peux remplacer par le sons que tu veux
i=-1
noire() { sleep $time ; paplay $sound; }
croche() { sleep $( echo "scale=2;$time/2" | bc) ; paplay $sound; }
double_croche() { sleep $( echo "scale=2;$time/4" | bc ) ; paplay $sound; }
for i in $rythm
do
$i
done
exit 0;Dernière modification par amj (Le 26/05/2013, à 14:49)
Vive le logiciel libre !! Articles aléatoires sur Wikipédia sur les logiciels libre, sur linux.
Hors ligne
#27 Le 26/05/2013, à 14:54
- philoup44
Re : [Résolu] Métronome pour mesures composées
J'obtiens ceci avec l'option bash -x
bash -x ./metronome-v03.sh
+ read -p 'Entre la longueur de la noire et valide : ' time
Entre la longueur de la noire et valide : 1
+ read -p 'Entre le nbre de mesure et valide : ' mesure
Entre le nbre de mesure et valide : 2
+ read -p 'Entre le rhytme et valide : ' rhytm
Entre le rhytme et valide : noire croche noire
+ sound='/usr/share/sounds/free*/s*/bell.oga'
+ i=1
+ echo 'valeur d'\''une croche'
valeur d'une croche
++ echo 'scale=2;1/2'
++ bc
+ echo .50
.50
+ echo 'valeur d'\''une doublecroche'
valeur d'une doublecroche
++ echo 'scale=2;1/4'
++ bc
+ echo .25
.25
+ (( 1<=2 ))
+ echo 'mesure 1'
mesure 1
+ (( i=1+1 ))
+ for a in '$rhytm'
+ echo noire
noire
+ noire
+ sleep 1
+ paplay /usr/share/sounds/freedesktop/stereo/bell.oga
+ for a in '$rhytm'
+ echo croche
croche
+ croche
++ echo 'scale=2;1/2'
++ bc
+ sleep .50
+ paplay /usr/share/sounds/freedesktop/stereo/bell.oga
+ for a in '$rhytm'
+ echo noire
noire
+ noire
+ sleep 1
+ paplay /usr/share/sounds/freedesktop/stereo/bell.oga
+ sleep 1
+ (( 2<=2 ))
+ echo 'mesure 2'
mesure 2
+ (( i=1+2 ))
+ for a in '$rhytm'
+ echo noire
noire
+ noire
+ sleep 1
+ paplay /usr/share/sounds/freedesktop/stereo/bell.oga
+ for a in '$rhytm'
+ echo croche
croche
+ croche
++ echo 'scale=2;1/2'
++ bc
+ sleep .50
+ paplay /usr/share/sounds/freedesktop/stereo/bell.oga
+ for a in '$rhytm'
+ echo noire
noire
+ noire
+ sleep 1
+ paplay /usr/share/sounds/freedesktop/stereo/bell.oga
+ sleep 1
+ (( 3<=2 ))
+ exit 0Hors ligne
#28 Le 26/05/2013, à 15:01
- amj
Re : [Résolu] Métronome pour mesures composées
Essaye cette nouvelle version du script stp ( ! double_croche devient doublecroche)
#!/bin/bash
#metronome.sh v0.3 by amj
#à emploiyer de cette manière
# ./metronome.sh longeur_d'une_noire nb_de_mesure "croche && noire && croche && doublecroche" #(les trois paramètres droivent être présents et dans l'ordre)
mesure=$2
time=$1
rythm=$3
text1="Entrez le nombre de mesures."
text2="Entrez le temps d'une noire."
text3="Entrez les rythmes voulus dans l'ordre et de la manière suivante:\n
rythme1 rythme2 rythme3 ... rythme_n \n
Les rythmes supportés sont les suivants: \n
noire croche et doublecroche "
if [[ $rythm == "" ]];then mesure=$(zenity --entry --text="$text1" ) && time=$(zenity --entry --text="$text2" ) && rythm=$(zenity --entry --text="$text3" ) ; fi
sound=/usr/share/sounds/free*/s*/bell.oga #tu peux remplacer par le sons que tu veux
noire() { sleep $time ; paplay $sound; }
croche() { sleep $( echo "scale=2;$time/2" | bc) ; paplay $sound; }
doublecroche() { sleep $( echo "scale=2;$time/4" | bc ) ; paplay $sound; }
for m in $(seq 1 $mesure )
do
for i in $rythm
do
$i
done
done
exit 0;Dernière modification par amj (Le 26/05/2013, à 15:14)
Vive le logiciel libre !! Articles aléatoires sur Wikipédia sur les logiciels libre, sur linux.
Hors ligne
#29 Le 26/05/2013, à 15:12
- philoup44
Re : [Résolu] Métronome pour mesures composées
i=-1 ??
Hors ligne
#30 Le 26/05/2013, à 15:13
- amj
Re : [Résolu] Métronome pour mesures composées
i=-1 ??
Je corrige dans mon post, ça n'a plus d'utilité.
Sinon ça marche bien?
Dernière modification par amj (Le 26/05/2013, à 15:14)
Vive le logiciel libre !! Articles aléatoires sur Wikipédia sur les logiciels libre, sur linux.
Hors ligne
#31 Le 26/05/2013, à 15:17
- philoup44
Re : [Résolu] Métronome pour mesures composées
Je vais éssayer !!
seq 1 ---> pour décrémenter $mesure de 1 ??
Hors ligne
#32 Le 26/05/2013, à 15:19
- amj
Re : [Résolu] Métronome pour mesures composées
Je vais éssayer !!
seq 1 ---> pour décrémenter $mesure de 1 ??
Oui, j'ai trouvé ça à la place de {1..$mesure} qui ne marche pas.
Vive le logiciel libre !! Articles aléatoires sur Wikipédia sur les logiciels libre, sur linux.
Hors ligne
#33 Le 26/05/2013, à 15:28
- philoup44
Re : [Résolu] Métronome pour mesures composées
cà à l'air de bien fonctionner ce coup ci !!
à rhytm j'ai mis "noire croche croche"
mesure=4
time=1
et j'ai eu 12 battements !!, donc, cette partie (notes x mesures) est bonnes !!
je vais donner des sons différents pour chaque notes, pour pouvoir plus aisément les distinguer !!
et je te dirais !!
Hors ligne
#34 Le 26/05/2013, à 15:38
- philoup44
Re : [Résolu] Métronome pour mesures composées
sound1=/usr/share/sounds/free*/s*/bell.oga #tu peux remplacer par le sons que tu veux
sound2=/usr/share/sounds/free*/s*/complete.oga
sound3=/usr/share/sounds/free*/s*/dialog-warning.oga
noire() { sleep $time ; paplay $sound1; }
croche() { sleep $( echo "scale=2;$time/2" | bc) ; paplay $sound2; }
doublecroche() { sleep $( echo "scale=2;$time/4" | bc ) ; paplay $sound3; }Hors ligne
#35 Le 26/05/2013, à 21:35
- amj
Re : [Résolu] Métronome pour mesures composées
T'aurais pas une bonne manière pour nommer les diff sons? Une chaîne alfa-numérique va être difficile à mémorisé non?
Dernière modification par amj (Le 26/05/2013, à 21:37)
Vive le logiciel libre !! Articles aléatoires sur Wikipédia sur les logiciels libre, sur linux.
Hors ligne
#36 Le 26/05/2013, à 22:38
- philoup44
Re : [Résolu] Métronome pour mesures composées
J'ai pas saisi la question ... 
Hors ligne
#37 Le 27/05/2013, à 12:53
- amj
Re : [Résolu] Métronome pour mesures composées
Salut
Bah je contes faire pour que le 3èm paramètre sois comme ceci
noire-son2 croche-son1 croche-son2 ...etcmais il faut trouver une bonne manière pour nommer les sons.
Vive le logiciel libre !! Articles aléatoires sur Wikipédia sur les logiciels libre, sur linux.
Hors ligne
#38 Le 27/05/2013, à 13:04
- philoup44
Re : [Résolu] Métronome pour mesures composées
Autrement dit, pouvoir associer plusieurs sons à une note ??
Hors ligne
#39 Le 27/05/2013, à 13:13
- Nasman
Re : [Résolu] Métronome pour mesures composées
A une époque j'avais fait un programme pour coder la musique. Mon codage était le suivant :
ronde = 128
blanche = 64
noire = 32
croche = 16
double croche = 8
...
noire pointée = 48 (32+16)
Pour les triolets il fallait partager en 11, 10, 11
Les notes étaient :
silence = 0
do = 1
do# = 2
re = 3
re# = 4
mi = 5
fa = 6
fa# = 7
sol = 8
sol# = 9
la = 10
la# = 11
si = 12
etc pour les octaves suivantes.
Chaque note était donc codée par sa hauteur et sa durée. Par exemple un sol avec une noire était : 8,32
Le fichier faisait (en gros) 2 octets par note + quelques instructions comme le changement d'octave ou de tempo.
Dernière modification par Nasman (Le 27/05/2013, à 13:15)
PC fixe sous Bionic 64 bits et portable avec Focal 64 bits
Hors ligne
#40 Le 27/05/2013, à 13:15
- philoup44
Re : [Résolu] Métronome pour mesures composées
@ amj
J'ai repris ton premier script, pour éssayer de lui faire interpréter $rythm (à la fin)
Je l'ai simplifié
#!/bin/bash
#metronome.sh v0.2 by amj
read -p 'Entre le ryhtme et valide : ' rythm # noire croche ou doublecroche
sound1=/usr/share/sounds/free*/s*/bell.oga
sound2=/usr/share/sounds/free*/s*/complete.oga
sound3=/usr/share/sounds/free*/s*/dialog-warning.oga
noire="paplay $sound1"
croche="paplay $sound2"
doublecroche="paplay $sound3"
#indirection ou référence indirecte
#echo "valeur de rythm = ${!rythm}"
${!rythm} #fonctionne que si on entre qu'une seule note ??
exit 0;ça fonctionne, mais uniquement si on entre qu'une NOTE ??
il doit y avoir une écriture qui manque
Dernière modification par philoup44 (Le 27/05/2013, à 13:22)
Hors ligne
#41 Le 27/05/2013, à 13:21
- philoup44
Re : [Résolu] Métronome pour mesures composées
@ Nasman
intérressant comme base
Hors ligne
#42 Le 27/05/2013, à 13:43
- Nasman
Re : [Résolu] Métronome pour mesures composées
Pour terminer le codage, j'utilisais le bit zéro de l'octet de durée pour indiquer si la note qui suivait était le prolongement de la note en cours. Cela permettait de dépasser la durée d'une ronde (voire d'une ronde pointée = 192).
Pour l'octave j'utilisais le code O pour octave suivi de l'octave souhaitée
Pour le tempo c'était T et une durée de base.
Les infos étaient donc une succession de groupe de 2 octets.
PC fixe sous Bionic 64 bits et portable avec Focal 64 bits
Hors ligne
#43 Le 27/05/2013, à 15:43
- amj
Re : [Résolu] Métronome pour mesures composées
Je vous ai pas dis main en fait mon code n'est pas correct car il ne tien pas en compte du temps de chaque sons qui est à déduire du temps de pose 
Je pense que je vais donc m'arrêter là. (une solution serais de calculer le temps de chaque sons avec time et le déduire à la pose suivante...) comme ceci
time paplay /usr/share/sounds/free*/s*/dialog-warning.oga
real 0m1.146s
user 0m0.012s
sys 0m0.008sVive le logiciel libre !! Articles aléatoires sur Wikipédia sur les logiciels libre, sur linux.
Hors ligne
#44 Le 27/05/2013, à 16:00
- amj
Re : [Résolu] Métronome pour mesures composées
A une époque j'avais fait un programme pour coder la musique. Mon codage était le suivant :
ronde = 128
blanche = 64
noire = 32
croche = 16
double croche = 8
...noire pointée = 48 (32+16)
Pour les triolets il fallait partager en 11, 10, 11
Les notes étaient :
silence = 0
do = 1
do# = 2
re = 3
re# = 4
mi = 5
fa = 6
fa# = 7
sol = 8
sol# = 9
la = 10
la# = 11
si = 12etc pour les octaves suivantes.
Chaque note était donc codée par sa hauteur et sa durée. Par exemple un sol avec une noire était : 8,32
Le fichier faisait (en gros) 2 octets par note + quelques instructions comme le changement d'octave ou de tempo.
J'aime bien la manière dont c'est fait
T'aurais pu faire ça en base 13 ça aurait été plus facile à comprendre
comme ceci:
sol une octave plus haut aurait été 19
et si 1b
Ça pourrait être intéressant si t'as toujours le code
Vive le logiciel libre !! Articles aléatoires sur Wikipédia sur les logiciels libre, sur linux.
Hors ligne
#45 Le 27/05/2013, à 16:23
- Nasman
Re : [Résolu] Métronome pour mesures composées
Je doit pouvoir retrouver le code mais c'était en assembleur.
Je créais le fichier de données avec un éditeur de texte puis avec Nasm, je transformais les chaines de textes en codes hexa selon le principe de codage ci dessus.
Un programme (assembleur) analysait le fichier assemblé et générait des sons en tenant compte :
- du tempo
- de l'octave (en début de fichier)
La hauteur de la note et la durée permettait de générer un signal de la bonne fréquence, de la bonne durée et en utilisant une enveloppe genre piano.
A ce stade un fichier .wav était généré.
PC fixe sous Bionic 64 bits et portable avec Focal 64 bits
Hors ligne
#46 Le 27/05/2013, à 16:26
- amj
Re : [Résolu] Métronome pour mesures composées
Un peut comme du midi non?
http://www.fileformat.info/format/midi/corion.htm
Dernière modification par amj (Le 27/05/2013, à 16:29)
Vive le logiciel libre !! Articles aléatoires sur Wikipédia sur les logiciels libre, sur linux.
Hors ligne
#47 Le 27/05/2013, à 17:25
- Nasman
Re : [Résolu] Métronome pour mesures composées
Je pense que le principe doit être similaire.
J'ai retrouvé les programmes mais ils étaient conçus pour Windows - mais ils fonctionnent avec wine.
Il y a ;
le fichier de données type
[SEGMENT .data] ;Initialised data segment
db "T",32,"O",3,11,32,11,96,8,32,8,96,10,64,10,48,10,16,10,32,10,32,11,64;1-4
db 11,32,11,96,13,16,13,16,11,96,10,32,10,32,13,16,13,48,11,96,0,32;5-8
db 15,32,15,32,15,32,13,32,13,32,15,32,15,32,11,64,7,32,10,32,13,16,13,48,11,96;9-13
db 15,32,15,32,15,32,13,32,13,32,15,32,15,32,11,64,7,32,10,32,13,16,13,48,11,128;14-18
db 11,32,11,96,8,32,8,96,10,64,10,48,10,16,10,32,10,32,11,64;1-4
db 11,32,11,96,13,16,13,16,11,96,10,32,10,32,13,16,13,48,11,96,0,32;5-8
db 15,32,15,32,15,32,13,32,13,32,15,32,15,32,11,64,7,32,10,32,13,16,13,48,11,96;9-13
db 15,32,15,32,15,32,13,32,13,32,15,32,15,32,11,64,7,32,10,32,13,16,13,48,11,128;14-18
db 11,32,11,96,8,32,8,96,10,64,10,48,10,16,10,32,10,32,11,64;1-4
db 11,32,11,96,13,16,13,16,11,96,10,32,10,32,13,16,13,48,11,96,0,32;5-8
db 15,32,15,32,15,32,13,32,13,32,15,32,15,32,11,64,7,32,10,32,13,16,13,48,11,96;9-13
db 15,32,15,32,15,32,13,32,13,32,15,32,15,32,11,64,7,32,10,32,13,16,13,48,11,128;14-18
db 11,32,11,96,8,32,8,96,10,64,10,48,10,16,10,32,10,32,11,64;1-4
db 11,32,11,96,13,16,13,16,11,96,10,32,10,32,13,16,13,48,11,96,0,32;5-8
db 11,32,11,96,8,32,8,96,10,64,10,48,10,16,10,32,10,32,11,64;1-4
db 11,32,11,96,13,16,13,16,11,96,10,32,10,32,13,16,13,48,11,128;5-8Ce fichier assemblé avec Nasm est constitué de la traduction du fichier en hexa, soit pout le début 54 20 4F 03 0B 20 ....
Le programme pour le lire est en assembleur et utilise une dll maison tfr.dll qui opère une transformée de Fourier inverse pour transformer une fréquence en signal périodique. Cette dll doit pouvoir être facilement convertie en fichier linux (.so ?) car elle ne contient pas (ou quasiment pas) de directive Windows.
Pour les curieux
;nasmw -fobj tfr.asm
;alink -oPE tfr.obj -dll
global tfr
export tfr
segment code public use32 class=CODE
..start:
dllstart:
mov eax,1
ret 12
;registres employés eax, ecx (compteur), ebx (m), edx, esi (j), edi (i), ebp (pointeur sur le premier élément)
; fonction appelée avec 3 paramètres n (esp+36), adresse matrice (esp+40), direct ou inverse (esp+44)
tfr: pushad ;empile 8*4=32 octets
mov eax,[esp+44] ;pointe sur inv (<0)/direct(>=0)
mov [inv],eax
mov ebp,[esp+40] ;pointe sur matrice
mov eax,[esp+36] ;32 octets empilés avec pushad + 4 pour eip - pointe sur le nombre de valeurs
mov ecx,33 ;calcul du nb de bit nécessaires (33=32bits+cf)
taille dec ecx
shl eax,1 ;décale à gauche jusqu'à avoir un bit non nul
jnc taille
mov eax,0 ;calcule la puissance de 2
rcl eax,cl
mov [n],eax
dec ecx ;soustrait 1 (on ne compte plus cf)
mov [p],ecx ;sauvegarde nb bit
dec ecx ;soustrait 1 pour pointeur table trigo
mov [q],ecx
mov ebx,[n]
shr ebx,1 ;calcule m:=n/2
mov dword[hmax],1
bouclem mov dword[zr],1048576 ;initialise zr et zi,z0r et z0i (2 puissance 20)
mov dword[zi],0
mov ecx,[q]
mov eax,[trigo+8*ecx]
mov [z0r],eax
xor eax,eax
mov edx,[inv]
and edx,edx
jns direct
mov eax,[trigo+8*ecx+4] ;indirect sin(2theta)
jmp suite
direct sub eax,[trigo+8*ecx+4] ;direct -sin(2theta)
suite mov [z0i],eax
mov dword[k],0 ;initialise k
bouclek
mov ecx,[hmax]
mov edi,[n]
add edi,[k]
sub edi,ebx
mov esi,edi ;jinitial:=n+k-m
sub edi,ebx ;iinitial:=n+k-2*m
boucleh mov eax,[ebp+8*edi] ;df(i)=f(i)-f(j)
sub eax,[ebp+8*esi]
mov [foncr],eax
mov eax,[ebp+8*edi+4]
sub eax,[ebp+8*esi+4]
mov [fonci],eax
call rotation
mov eax,[ebp+8*esi] ;f(i):=f(i)+f(j)
add [ebp+8*edi],eax
mov eax,[ebp+8*esi+4]
add [ebp+8*edi+4],eax
mov eax,[tmpr] ;f(j):=tmp
mov [ebp+8*esi],eax
mov eax,[tmpi]
mov [ebp+8*esi+4],eax
sub edi,ebx ;i:=i-2*m
sub edi,ebx
sub esi,ebx ;j:=j-2*m
sub esi,ebx
loop boucleh ;h varie de n/(2*m) à 1
mov eax,[z0r]
mov [foncr],eax
mov eax,[z0i]
mov [fonci],eax
call rotation
mov eax,[tmpr] ;z:=tmp
mov [zr],eax
mov eax,[tmpi]
mov [zi],eax
inc dword[k]
cmp dword[k],ebx
jz suite1
jmp bouclek
suite1 dec dword[q] ;q:=q-1
shl dword[hmax],1
shr ebx,1 ;m:=m/2
and ebx,ebx
jz suite2
jmp bouclem ;m>=1
suite2 mov esi,[n]
dec esi
permute call invbit ;effectue une permutation entre les indices
mov eax,[ebp+8*esi] ;par exemple pour 8 valeurs, 1 (001) permute avec 4 (100)
mov [u+8*edi],eax ;2 (010) avec lui même, 3 (011) avec 6 (110), 5 (101) avec lui même
mov eax,[ebp+8*esi+4]
mov [u+8*edi+4],eax
dec esi
and esi,esi
jns permute
;normalise si besoin
mov edi,[n]
dec edi
mov cl,[p] ;nombre de bit pour décaler si transformée inverse
mov edx,[inv]
and edx,edx
js divise ;nombre négatif alors transformée inverse
copie mov eax,[u+8*edi] ;positif alors direct sans division
mov [ebp+8*edi],eax
mov eax,[u+8*edi+4]
mov [ebp+8*edi+4],eax
dec edi
and edi,edi
jns copie
jmp fin
divise mov eax,[u+8*edi]
and eax,eax
jns normal1 ;eax positif, procédure normale
neg eax ;inverse la valeur (rend positif)
shr eax,cl ;effectue la division par n
neg eax ;restaure le signe
jmp suite3
normal1 shr eax,cl ;effectue la division
suite3 mov [ebp+8*edi],eax
mov eax,[u+8*edi+4]
and eax,eax
jns normal2 ;eax positif, procédure normale
neg eax ;inverse la valeur (rend positif)
shr eax,cl ;effectue la division
neg eax ;restaure le signe
jmp suite4
normal2 shr eax,cl
suite4 mov [ebp+8*edi+4],eax
dec edi
and edi,edi
jns divise
fin popad ;restaure les registres
ret 12 ;dépile les 3 paramètres d'appel
rotation:
; effectue les 4 multiplications
mov eax,[foncr]
imul dword [zr]
mov [rzr],eax
mov [rzr+4],edx
mov eax,[fonci]
imul dword [zi]
mov [izi],eax
mov [izi+4],edx
mov eax,[foncr]
imul dword [zi]
mov [rzi],eax
mov [rzi+4],edx
mov eax,[fonci]
imul dword [zr]
mov [izr],eax
mov [izr+4],edx
; effectue la soustraction et l'addition et divise par 2 puissance 20
mov eax,[rzr]
sub eax,[izi]
mov edx,[rzr+4]
sbb edx,[izi+4]
shr eax,20 ;divise par 2 puissance 20
mov [tmpr],eax
shl edx,12 ;multiplie par 2 puissance 12
or [tmpr],edx ;rajoute à tmpr : division implicite par 2 puissance 32
mov eax,[rzi]
add eax,[izr]
mov edx,[rzi+4]
adc edx,[izr+4]
shr eax,20
mov [tmpi],eax
shl edx,12
or [tmpi],edx
ret
invbit: ;p=nb de bit pour coder, esi contient la valeur à inverser, edi contient le résultat
mov ecx,[p]
xor edi,edi
mov eax,esi
decale shr eax,1
rcl edi,1
loop decale
ret
segment data public use32 class=DATA
trigo ;table des cosinus et sinus multipliée par 2 puissance 20
dd -1048576,0 ;1048576*cos(pi) 1048576*sin(pi)
dd 0,1048576 ;1048576*cos(pi/2) 1048576*sin(pi/2)
dd 741455,741455 ;1048576*cos(pi/4) 1048576*sin(pi/4)
dd 968758,401273 ;1048576*cos(pi/8) 1048576*sin(pi/8)
dd 1028428,204567 ;1048576*cos(pi/16) 1048576*sin(pi/16)
dd 1043527,102778 ;1048576*cos(pi/32) 1048576*sin(pi/32)
dd 1047313,51451 ;1048576*cos(pi/64) 1048576*sin(pi/64)
dd 1048260,25733 ;1048576*cos(pi/128) 1048576*sin(pi/128)
dd 1048497,12868 ;1048576*cos(pi/256) 1048576*sin(pi/256)
dd 1048556,6434 ;1048576*cos(pi/512) 1048576*sin(pi/512)
dd 1048571,3217 ;1048576*cos(pi/1024) 1048576*sin(pi/1024)
dd 1048575,1608 ;1048576*cos(pi/2048) 1048576*sin(pi/2048)
dd 1048576,804 ;1048576*cos(pi/4096) 1048576*sin(pi/4096)
dd 1048576,402 ;1048576*cos(pi/8192) 1048576*sin(pi/8192)
dd 1048576,201 ;1048576*cos(pi/16384) 1048576*sin(pi/16384)
dd 1048576,101 ;1048576*cos(pi/32768) 1048576*sin(pi/32768)
n resd 1 ;nombre de points
inv resd 1 ;0=transformée directe, -1=transformée inverse
p resd 1 ;nombre de bits pour coder les n points
q resd 1 ;pointeur de la table trigonométrique
k resd 1
hmax resd 1
z0r resd 1 ;valeur initiale du cosinus
z0i resd 1 ;valeur initiale du sinus
zr resd 1 ;1048576*cos(2theta)
zi resd 1 ;1048576*sin(2theta)
foncr resd 1 ;partie réelle de la fonction
fonci resd 1 ;partie imaginaire de la fonction
rzr resd 2 ;foncr*zr
izi resd 2 ;fonci*zi
rzi resd 2 ;foncr*zi
izr resd 2 ;fonci*zr
tmpr resd 1 ;(rzr-izi)/1048576
tmpi resd 1 ;(rzi+izr)/1048576
u resd 131072 ;reserve 2*65536 dword (maximum 65536 points) Le programme pour exploiter les fichiers utilise les API Windows classiques - il doit être plus difficile à retranscrire.
Au lancement il y a un explorateur pour chercher le fichier compilé à utiliser. Le fichier est ensuite analysé et un fichier .wav est créé (et joué)
Pour les curieux
EXTERN ExitProcess
import ExitProcess kernel32.dll
extern GetModuleHandleA
import GetModuleHandleA kernel32.dll
EXTERN CreateFileA
import CreateFileA kernel32.dll
EXTERN ReadFile
import ReadFile kernel32.dll
EXTERN WriteFile
import WriteFile kernel32.dll
EXTERN CloseHandle
import CloseHandle kernel32.dll
EXTERN SetFilePointer
import SetFilePointer kernel32.dll
extern lstrlenA
import lstrlenA kernel32.dll
EXTERN MessageBoxA
import MessageBoxA user32.dll
EXTERN GetOpenFileNameA
import GetOpenFileNameA comdlg32.dll
EXTERN GetSaveFileNameA
import GetSaveFileNameA comdlg32.dll
extern wsprintfA ;définit le symbole externe
import wsprintfA user32.dll ;importe l'adresse de wsprintfA
EXTERN PlaySoundA
import PlaySoundA winmm.dll
extern tfr ;définit le symbole externe
import tfr tfr.dll ;importe l'adresse de wsprintfA
;définition des constantes utilisées
%define NULL 0
%define SW_SHOW 5
%define CS_HREDRAW 2
%define CS_VREDRAW 1
%define IDC_ARROW 0x00007F00
%define COLOR_BTNFACE 0x0000000F
%define WS_TILEDWINDOW 0x00CF0000
%define WS_EX_LEFT 0
%define WM_CREATE 0x00000001
%define WM_DESTROY 0x00000002
%define TRUE 0x00000001
%define FALSE 0x00000000
%define WM_SETFONT 0x00000030
%define WM_QUIT 0x00000012
%define WM_SETFONT 0x00000030
%define WM_SETFONT 0x00000030
%define BS_SOLID 0
%define PS_SOLID 0
%define WM_PAINT 0x0000000F
%define IDI_WINLOGO 0x00007F05
%define IDC_HAND 0x00007F89
%define IDC_CROSS 0x00007F03
%define MB_ICONHAND 0x00000010
%define COLOR_ACTIVECAPTION 0x00000002
%define GENERIC_READ 0x80000000
%define GENERIC_WRITE 0x40000000
%define OPEN_EXISTING 0x00000003
%define CREATE_ALWAYS 0x00000002
%define OPEN_ALWAYS 0x00000004
%define CREATE_NEW 0x00000001
%define OPEN_EXISTING 0x00000003
%define FILE_END 0x00000002
%define MAXSIZE 260
%define OFN_FILEMUSTEXIST 0x00001000
%define OFN_PATHMUSTEXIST 0x00000800
%define OFN_LONGNAMES 0x00200000
%define OFN_EXPLORER 0x00080000
%define OFN_HIDEREADONLY 0x00000004
;définition des structures
struc OPENFILENAME
.lStructSize resd 1
.hwndOwner resd 1
.hInstance resd 1
.lpstrFilter resd 1
.lpstrCustomFilter resd 1
.nMaxCustFilter resd 1
.nFilterIndex resd 1
.lpstrFile resd 1
.nMaxFile resd 1
.lpstrFileTitle resd 1
.nMaxFileTitle resd 1
.lpstrInitialDir resd 1
.lpstrTitle resd 1
.Flags resd 1
.nFileOffset resw 1
.nFileExtension resw 1
.lpstrDefExt resd 1
.lCustData resd 1
.lpfnHook resd 1
.lpTemplateName resd 1
ENDSTRUC
SECTION CODE USE32 CLASS=CODE
..start:
push byte NULL
call [GetModuleHandleA]
mov dword [Instance],eax
select ;selection d'un fichier
mov dword [ofn+OPENFILENAME.lStructSize],dword 76 ;76 octets (19 dword) pour la structure
mov eax,0;[WindowHandle]
mov dword [ofn+OPENFILENAME.hwndOwner],eax
mov eax,[Instance]
mov dword [ofn+OPENFILENAME.hInstance],eax
mov dword [ofn+OPENFILENAME.lpstrFilter],typefich ;type de fichiers à ouvrir
mov dword [ofn+OPENFILENAME.lpstrFile],nomfichier ;adresse où mettre le nom de fichier
mov dword [ofn+OPENFILENAME.nMaxFile],MAXSIZE ;taille maxi du nom
mov dword [ofn+OPENFILENAME.nMaxFile],OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST |OFN_LONGNAMES |OFN_EXPLORER|OFN_HIDEREADONLY
mov dword [ofn+OPENFILENAME.lpstrTitle],messageopen
push dword ofn
call [GetOpenFileNameA]
and eax,eax
jz select
ouvre ;ouverture du fichier
push byte 0
push byte 0
push dword OPEN_EXISTING
push byte 0
push byte 0
push dword GENERIC_READ | GENERIC_WRITE
push dword nomfichier
call [CreateFileA]
mov [hfichier],eax
;lit les données
push byte 0
push dword taille
push dword 4000 ;indique le nombre d'octets à lire
push dword donnees
push dword [hfichier]
call [ReadFile]
push dword [hfichier]
call [CloseHandle]
movzx eax,word[ofn+OPENFILENAME.nFileExtension]
mov [nomfichier+eax],dword 0x00766177 ;change l'extension en .wav
push edi
push esi
push ebp
cld
mov ecx,[taille]
shr ecx,1
xor edx,edx
boucle push ecx
push edx
movzx eax,word[donnees+edx]
cmp al,"O"
je near modoctave
cmp al,"T"
je near modtempo
; cmp al,0
; je near silence
;note+duree
mov [note],al ;sauvegarde la note (al) et la longueur (ah)
shr eax,9 ;bit 8 (bit 0 de ah) dans carry
jnc pasliee
;notes liées
shl eax,1
add [longueur],eax ;rajoute à la durée de la note suivante
jmp suivante
pasliee shl eax,1
add [longueur],eax
cmp [note],byte 0
jz near silence
mov eax,[octave]
imul eax,byte 12 ;décale de 12 demi tons
add eax,[note]
shl eax,1
add eax,frequences-26
mov [addfreq],eax
movzx edx,word[eax]
mov [frequence],edx
;crée la table des fréquences
mov ecx,65536
xor eax,eax
mov edi,travail
rep stosd ;efface
mov eax,dword[timbre]
mov [travail],eax ;constante
mov ecx,1
xor esi,esi
mov edi,32768 ;edi pour symétrique
bcltimbre add esi,[frequence]
cmp esi,16384 ;compare à la fréquence de coupure
ja near Fourier
sub edi,[frequence]
mov eax,[timbre+8*ecx]
mov [travail+8*esi],eax
mov [travail+8*edi],eax
mov eax,[timbre+8*ecx+4]
mov [travail+8*esi+4],eax
neg eax ;les termes en sinus sont inversés
mov [travail+8*edi+4],eax
inc ecx
cmp ecx,16
jb bcltimbre
;transformation de Fourier inverse
Fourier push dword -1
push dword travail
push dword 32768
call [tfr]
mov eax,[longueur]
imul eax,[tempo]
shl eax,4
xor edx,edx
mov [nbpt],edx
mov [amplitude],edx
mov ecx,eax ;nombre d'échantillons dans la durée de la note;
mov edi,[addonnees]
;attaque - croissance de l'amplitude jusqu'à 65536 sur 512 points (16 ms)
attaque mov esi,[nbpt]
and esi,32767
mov eax,[8*esi+travail]
imul dword[amplitude] ;multiplie la forme du signal par l'enveloppe
shr eax,16
stosw
inc dword[nbpt]
cmp [nbpt],dword 512
ja decroissance
add [amplitude],dword 128 ;65536/512
loop attaque
;décroissance décroit linéairement de 65536 à 0 sur la durée de la note
decroissance dec ecx
mov [y0],ecx
xor edx,edx
mov eax,[amplitude]
div ecx
mov [q],eax
mov [x0],edx
mov [x],edx
sub [y0],edx
mov eax,[y0]
mov [y],eax
bcl cmp [y],edx
jg sup
mov eax,[y0]
sub edx,eax
add [y],eax
dec dword[amplitude]
jmp suite
sup mov eax,[x0]
add edx,eax
sub [y],eax
suite mov eax,[q]
sub [amplitude],eax
inc dword[nbpt]
mov esi,[nbpt]
and esi,32767
mov eax,[8*esi+travail]
imul dword[amplitude]
shr eax,16
stosw
loop bcl
finnote mov [longueur],ecx ;efface la longueur
mov [addonnees],edi
;passe à la note suivante
suivante pop edx
inc edx
inc edx
pop ecx
dec ecx
jnz near boucle
sub edi,donnees2
mov [taille2],edi
add edi,36
mov [twav],edi
;création du fichier
pop ebp
pop esi
pop edi
push dword 4 ;SND_MEMORY
push dword 0
push dword entete
call [PlaySoundA] ;lit les données en mémoire
push byte 0
push byte 0
push dword CREATE_ALWAYS
push byte 0
push byte 0
push dword GENERIC_READ | GENERIC_WRITE
push dword nomfichier
call [CreateFileA]
mov [hfichier2],eax
; écriture des 44 premiers octets RIFF
push byte 0
push dword nblus
push byte 44 ;44 octets pour l'en-tête
push dword entete ;ils seront stockés en en-tête
push eax
call [WriteFile]
push byte 0
push dword nblus
push dword [taille2]
push dword donnees2 ;données
push dword [hfichier2]
call [WriteFile]
push dword [hfichier2]
call [CloseHandle]
push byte 0
call [ExitProcess]
modoctave shr eax,8
mov [octave],eax
jmp suivante
modtempo shr eax,8
mov [tempo],eax
jmp suivante
silence mov eax,[longueur]
imul eax,[tempo]
shl eax,3
mov ecx,eax
xor eax,eax
mov edi,[addonnees]
rep stosd
jmp finnote
; pushad
; push ecx
; push dword format
; push dword chaine
; call [wsprintfA]
; add esp,12
; push byte 0
; push dword titre
; push dword chaine
; push byte 0
; call [MessageBoxA]
; popad
;_______________________________________________
SECTION DATA USE32 CLASS=DATA
typefich db "Fichiers sons",0,"*.mus",0,0
messageopen db "Choisissez le fichier son (.mus) à ouvrir",0
messageferm db "Choisissez le nom du fichier son (.mus) à enregistrer",0
ext db "mus",0
format db "%d",0; % début format
; # hexadécimal 0x ou 0X
; l pour long (>0xffffffff)
; i ou d pour donner entier signé
; u pour donner 4294967295 non signé
; X pour hexa en majuscule et x pour minuscule
titre db "Taille du fichier",0
frequences ; do do# ré ré# mi fa fa# sol sol# la la# si
dw 65, 69, 73, 78, 82, 87, 92, 98, 104, 110, 117, 123 ;octave 1
dw 131, 139, 147, 156, 165, 175, 185, 196, 208, 220, 233, 247 ;octave 2
dw 262, 277, 294, 311, 330, 349, 370, 392, 415, 440, 466, 494 ;octave 3
dw 523, 554, 587, 622, 659, 698, 740, 784, 831, 880, 932, 988 ;octave 4
dw 1047,1109,1175,1245,1319,1397,1480,1568,1661,1760,1865,1976 ;octave 5
dw 2093,2217,2349,2489,2637,2794,2960,3136,3322,3520,3729,3951 ;octave 6
timbre dd 0,0
dd 0,-317520000;harmonique1
dd 0,79380000;harmonique2
dd 0,-35280000;harmonique3
dd 0,19845000;harmonique4
dd 0,-12700800;harmonique5
dd 0,8820000;harmonique6
dd 0,-6480000;harmonique7
dd 0,4961250;harmonique8
dd 0,-3920000;harmonique9
dd 0,3175200;harmonique10
dd 0,-2624132;harmonique11
dd 0,2205000;harmonique12
dd 0,-1878817;harmonique13
dd 0,1620000;harmonique14
dd 0,-1411200;harmonique15
addonnees dd donnees2
entete:
RIFF db "RIFF"
twav resd 1 ;taille données format Wave
WAVEfmt db "WAVEfmt "
tformat dd 16 ;nb d'octets pour définir le format
compression dw 1 ;si=1 pas de compression
canaux dw 1 ;nb de canaux
fechant dd 32768 ;fréquence d'échantillonnage
octetps dd 65536 ;nombre d'octets pas seconde
octpech dw 2 ;nombre d'octet par échantillon*nb canaux
bitpech dw 16 ;nombre de bits par échantillon (8,16 ou 24)
chdata db "data" ;pour recherche "da" et "ta"
taille2 resd 1
donnees2 resd 10000000 ;pour donnees fichier wav
chaine resd 3
Instance resd 1
ofn resd 19 ;structure pour sélection fichier à lire
nomfichier resd 20 ;nom fichier lecture avec chemin
hfichier resd 1 ;handle fichier lecture
hfichier2 resd 1 ;handle fichier écriture
nblus resd 1
taille resd 1
donnees resd 1000
octave resd 1
tempo resd 1
addfreq resd 1
frequence resd 1
nbpt resd 1
note resd 1
longueur resd 1
amplitude resd 1
q resd 1
x0 resd 1
y0 resd 1
x resd 1
y resd 1
travail resd 65536 ;pour transformation de FourierPC fixe sous Bionic 64 bits et portable avec Focal 64 bits
Hors ligne
#48 Le 27/05/2013, à 17:56
- amj
Re : [Résolu] Métronome pour mesures composées
Je suis pas sur d'avoir tout suivi
Vive le logiciel libre !! Articles aléatoires sur Wikipédia sur les logiciels libre, sur linux.
Hors ligne
#49 Le 27/05/2013, à 19:54
- philoup44
Re : [Résolu] Métronome pour mesures composées
@ Nasman
On joue pas dans la meme cour
Moi, je comprends 0,01% du shell, et c'est tout
A tout hasard, saurais tu comment faire comprendre au shell, d'exécuter toutes les variables contenues dans rythm ?? ---> #40
@ amj
le script ... ne tient pas compte du temps de chaque sons qui est à déduire du temps de pose
Je pensais également à ça, sans compter le temps que met le shell à interpréter chaques commandes ....
raison pour laquelle , je cherchais comment faire pour se passer de la boucle for ...do ...done
Hors ligne
#50 Le 27/05/2013, à 21:34
- YM
Re : [Résolu] Métronome pour mesures composées
Salut les gars
Je surveille donc ce sujet que j'ai lancé, et évidemment vu mon niveau de programmation la discussion m'échappe totalement !!!
J'espère juste que si vous arrivez à une solution cohérente, l'un de vous aura l'amabilité de faire une synthèse pour débutant...
Je reste étonné qu'il n'existe pas encore d'appli qui ait été développée pour les mesures composées, c'est un outil précieux pour un musicien.
Hors ligne