Contenu | Rechercher | Menus

Annonce

Si vous rencontrez des soucis à rester connecté sur le forum (ou si vous avez perdu votre mot de passe) déconnectez-vous et reconnectez-vous depuis cette page, en cochant la case "Me connecter automatiquement lors de mes prochaines visites".

#26 Le 26/05/2013, à 15:48

amj

Re : [Résolu] Métronome pour mesures composées

Je crois que c'est mieux écris comme ceci smile (j'ai un peu lu la doc et ton script)
j'ai oublier les mesures roll

#!/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, à 15:49)


Vive le logiciel libre !! Articles aléatoires sur Wikipédia sur les logiciels libre, sur linux.

Hors ligne

#27 Le 26/05/2013, à 15: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 0

Hors ligne

#28 Le 26/05/2013, à 16: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, à 16:14)


Vive le logiciel libre !! Articles aléatoires sur Wikipédia sur les logiciels libre, sur linux.

Hors ligne

#29 Le 26/05/2013, à 16:12

philoup44

Re : [Résolu] Métronome pour mesures composées

i=-1 ??

Hors ligne

#30 Le 26/05/2013, à 16:13

amj

Re : [Résolu] Métronome pour mesures composées

philoup44 a écrit :

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, à 16:14)


Vive le logiciel libre !! Articles aléatoires sur Wikipédia sur les logiciels libre, sur linux.

Hors ligne

#31 Le 26/05/2013, à 16: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, à 16:19

amj

Re : [Résolu] Métronome pour mesures composées

philoup44 a écrit :

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, à 16:28

philoup44

Re : [Résolu] Métronome pour mesures composées

cà à l'air de bien fonctionner ce coup ci !! smile
à 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, à 16: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, à 22: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, à 22:37)


Vive le logiciel libre !! Articles aléatoires sur Wikipédia sur les logiciels libre, sur linux.

Hors ligne

#36 Le 26/05/2013, à 23:38

philoup44

Re : [Résolu] Métronome pour mesures composées

J'ai pas saisi la question ... smile tongue

Hors ligne

#37 Le 27/05/2013, à 13:53

amj

Re : [Résolu] Métronome pour mesures composées

Salut smile
Bah je contes faire pour que le 3èm paramètre sois comme ceci

noire-son2 croche-son1 croche-son2 ...etc

mais 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, à 14: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, à 14: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, à 14:15)


PC fixe et portable avec Precise 64 bits

Hors ligne

#40 Le 27/05/2013, à 14: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, à 14:22)

Hors ligne

#41 Le 27/05/2013, à 14:21

philoup44

Re : [Résolu] Métronome pour mesures composées

@ Nasman
intérressant comme base smile

Hors ligne

#42 Le 27/05/2013, à 14: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 et portable avec Precise 64 bits

Hors ligne

#43 Le 27/05/2013, à 16: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 hmm
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.008s

Vive le logiciel libre !! Articles aléatoires sur Wikipédia sur les logiciels libre, sur linux.

Hors ligne

#44 Le 27/05/2013, à 17:00

amj

Re : [Résolu] Métronome pour mesures composées

Nasman a écrit :

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.

J'aime bien la manière dont c'est fait smile
T'aurais pu faire ça en base 13 ça aurait été plus facile à comprendre smile
comme ceci:
sol une octave plus haut aurait été 19
et si 1b
smile
Ça pourrait être intéressant si t'as toujours le code smile


Vive le logiciel libre !! Articles aléatoires sur Wikipédia sur les logiciels libre, sur linux.

Hors ligne

#45 Le 27/05/2013, à 17: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 et portable avec Precise 64 bits

Hors ligne

#46 Le 27/05/2013, à 17: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, à 17:29)


Vive le logiciel libre !! Articles aléatoires sur Wikipédia sur les logiciels libre, sur linux.

Hors ligne

#47 Le 27/05/2013, à 18: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-8

Ce 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 Fourier

PC fixe et portable avec Precise 64 bits

Hors ligne

#48 Le 27/05/2013, à 18:56

amj

Re : [Résolu] Métronome pour mesures composées

Je suis pas sur d'avoir tout suivi roll


Vive le logiciel libre !! Articles aléatoires sur Wikipédia sur les logiciels libre, sur linux.

Hors ligne

#49 Le 27/05/2013, à 20:54

philoup44

Re : [Résolu] Métronome pour mesures composées

@ Nasman
On joue pas dans la meme cour tongue smile
Moi, je comprends 0,01% du shell, et c'est tout tongue
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, à 22: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

Haut de page ↑