Réaliser un vue mètre

Oui silverman, c'est ca...

...Mais en panoramic !!

Du forum anglais, j' ai utilisé le fichier "bass.dll" + le fichier son pour tester. J'ai nettoyé et traduis le programme darkbasic en langage panoramic, et là, patatra!
Darkbasic permet de passer + de 6 paramètres à une dll tandis que Panoramic n'accepte que le passage de 6 paramètres maximum(erreur en ligne 67).
Ce qui est curieux, c'est que la doc de BASS indique 6 paramètres pour "BASS_MusicLoad", mais darkbasic refuse de fonctionner si il n'y en a pas 7. J'ai aussi testé le code darkbasic avec la version 2.4.11 de BASS, et ça fonctionne parfaitement.
Voici le code de test:

Code:: ' bass.dll version 2.4.9
' fichier son : "dontgo93.mod"

' global variable
' DWORD
dim Address%,Mhandle%

dim SampleLength%
SampleLength%=4096

dim memblock1$,memblock2$

' MAKE MEMBLOCK 1,SampleLength ` Return 512 floats
   memblock1$=string$(SampleLength%,chr$(0))

' Address=GET MEMBLOCK PTR(1)
GET_BUFFER_PTR(adr(Address%) , adr(memblock1$))

dim result%
dim result1%

dim BASS_DEVICE_CPSPEAKERS%,FALSE%,BASS_UNICODE%,TRUE%,BASS_SAMPLE_LOOP%

BASS_DEVICE_CPSPEAKERS%=1024
FALSE%=0
BASS_UNICODE%=2147483648
TRUE%=1
BASS_SAMPLE_LOOP%=4

InitBass()
BassPlayMod("dontgo93.mod")

repeat
   '
   result%=dll_call1("BASS_ChannelIsActive",Mhandle%)
   IF result%=0 THEN result1%=dll_call2("BASS_ChannelPlay",Mhandle%,TRUE%)
   '
until scancode=32

BassStopMod()
CloseBass()

END
'
' ##############################################################################
' # #
' # Gestion de la dll "Bass.dll" #
' # #
' ##############################################################################
sub InitBass()
   dll_on "bass.dll"
   result%=dll_call0("BASS_Free")
   Result%=dll_call5("BASS_Init",1,44100,BASS_DEVICE_CPSPEAKERS%,0,0) :' retourne 1
' Result%=dll_call5("BASS_Init",0-1,44100,BASS_DEVICE_CPSPEAKERS%,0,0) :' retourne 1
end_sub

sub BassPlayMod(name$)
if file_exists(name$)=0 then message "fichier son pas trouvé!"
dim_local memblock3$,Info_Address%

' Mhandle%=dll_call7("BASS_MusicLoad",FALSE%,name$,0,0,BASS_UNICODE%,BASS_SAMPLE_LOOP%,0)

   Mhandle%=HANDLE_FORM("dontgo93.mod")
   result%=dll_call2("BASS_ChannelPlay",Mhandle%,TRUE%)

result%=DLL_CALL0("BASS_ErrorGetCode")
MESSAGE "ERREUR : "+STR$(result%)

' memblock3$=string$(100,chr$(0))
' GET_BUFFER_PTR(adr(Info_Address%) , adr(memblock3$))
' Used To debug values and stuff from BASS
' result%=dll_call3("BASS_ChannelGetInfo",Mhandle%,Info_Address%,24)
end_sub

sub BassStopMod()
   result% = dll_call1("BASS_ChannelStop",Mhandle%)
end_sub

sub CloseBass()
   result%=dll_call0("BASS_Free")
end_sub

'
' ##############################################################################
' # #
' # Bibliothèque de SUBs pour gérer des mémoires tampons V1.0 #
' # #
' ##############################################################################
sub READ_BUFFER_BYTE(adr_destination%,adr_source%,buffer_position%)
' BYTE = OCTET(en français)
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un BYTE, 0 < BYTE < 255
   poke adr_destination%,peek(adr_source% + buffer_position%)
end_sub

sub READ_BUFFER_WORD(adr_destination%,adr_source%,buffer_position%)
' WORD = 2 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un WORD, 0 < WORD < 65535
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
end_sub

sub READ_BUFFER_DWORD(adr_destination%,adr_source%,buffer_position%)
' DWORD = 4 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un DWORD, 0 < DWORD < 4294967295
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
   poke adr_destination%+2,peek(adr_source%+2+buffer_position%)
   poke adr_destination%+3,peek(adr_source%+3+buffer_position%)
end_sub

sub READ_BUFFER_LONG(adr_destination%,adr_source%,buffer_position%)
' LONG = 4 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un LONG, –2147483648 < LONG < 2147483647
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
   poke adr_destination%+2,peek(adr_source%+2+buffer_position%)
   poke adr_destination%+3,peek(adr_source%+3+buffer_position%)
end_sub

sub READ_BUFFER_INT(adr_destination%,adr_source%,buffer_position%)
' INT = 4 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un INTeger, –2147483648 < INT < 2147483647
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
   poke adr_destination%+2,peek(adr_source%+2+buffer_position%)
   poke adr_destination%+3,peek(adr_source%+3+buffer_position%)
end_sub

sub READ_BUFFER_FLOAT(adr_destination%,adr_source%,buffer_position%)
' FLOAT = 8 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un FLOAT, -1,7976931348623157×10^308 < FLOAT < 1,7976931348623157×10^308
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
   poke adr_destination%+2,peek(adr_source%+2+buffer_position%)
   poke adr_destination%+3,peek(adr_source%+3+buffer_position%)
   poke adr_destination%+4,peek(adr_source%+4+buffer_position%)
   poke adr_destination%+5,peek(adr_source%+5+buffer_position%)
   poke adr_destination%+6,peek(adr_source%+6+buffer_position%)
   poke adr_destination%+7,peek(adr_source%+7+buffer_position%)
end_sub

'###############################################################################
sub WRITE_BUFFER_BYTE(adr_destination%,buffer_position%,byte%)
' BYTE = OCTET(en français)
' adr_destination% = adresse destination
' byte% = 0 < BYTE < 255
   poke adr_destination%+buffer_position%,peek(adr(byte%))
end_sub

sub WRITE_BUFFER_WORD(adr_destination%,buffer_position%,word%)
' WORD = 2 BYTEs
' adr_destination% = adresse destination
' word% = 0 < WORD < 65535
   poke adr_destination%+buffer_position%,peek(adr(word%))
   poke adr_destination%+1+buffer_position%,peek(adr(word%)+1)
end_sub

sub WRITE_BUFFER_DWORD(adr_destination%,buffer_position%,dword%)
' DWORD = 4 BYTEs
' adr_destination% = adresse destination
' dword% = 0 < DWORD < 4294967295
   poke adr_destination%+buffer_position%,peek(adr(dword%))
   poke adr_destination%+1+buffer_position%,peek(adr(dword%)+1)
   poke adr_destination%+2+buffer_position%,peek(adr(dword%)+2)
   poke adr_destination%+3+buffer_position%,peek(adr(dword%)+3)
end_sub

sub WRITE_BUFFER_LONG(adr_destination%,buffer_position%,long%)
' LONG = 4 BYTEs
' adr_destination% = adresse destination
' long% = –2147483648 < LONG < 2147483647
   poke adr_destination%+buffer_position%,peek(adr(long%))
   poke adr_destination%+1+buffer_position%,peek(adr(long%)+1)
   poke adr_destination%+2+buffer_position%,peek(adr(long%)+2)
   poke adr_destination%+3+buffer_position%,peek(adr(long%)+3)
end_sub

sub WRITE_BUFFER_INT(adr_destination%,buffer_position%,long%)
' INT = 4 BYTEs
' adr_destination% = adresse destination
' int% = –2147483648 < INT < 2147483647
   poke adr_destination%+buffer_position%,peek(adr(long%))
   poke adr_destination%+1+buffer_position%,peek(adr(long%)+1)
   poke adr_destination%+2+buffer_position%,peek(adr(long%)+2)
   poke adr_destination%+3+buffer_position%,peek(adr(long%)+3)
end_sub

sub WRITE_BUFFER_FLOAT(adr_destination%,buffer_position%,float)
' FLOAT = 8 BYTEs
' adr_destination% = adresse destination
' float = -1,7976931348623157×10^308 < FLOAT < 1,7976931348623157×10^308
   poke adr_destination%+buffer_position%,peek(adr(float))
   poke adr_destination%+1+buffer_position%,peek(adr(float)+1)
   poke adr_destination%+2+buffer_position%,peek(adr(float)+2)
   poke adr_destination%+3+buffer_position%,peek(adr(float)+3)
   poke adr_destination%+4+buffer_position%,peek(adr(float)+4)
   poke adr_destination%+5+buffer_position%,peek(adr(float)+5)
   poke adr_destination%+6+buffer_position%,peek(adr(float)+6)
   poke adr_destination%+7+buffer_position%,peek(adr(float)+7)
end_sub

'###############################################################################
sub BUFFER_SIZE(adr_destination%,buffer_ptr%)
' retouve la taille du buffer
   poke adr_destination%,peek(buffer_ptr%-4)
   poke adr_destination%+1,peek(buffer_ptr%-3)
   poke adr_destination%+2,peek(buffer_ptr%-2)
   poke adr_destination%+3,peek(buffer_ptr%-1)
end_sub

sub FILL_BUFFER(buffer_ptr%,value%)
' uniquement des BYTEs
dim_local size%,i
   value%=bin_and(value%,255)
   BUFFER_SIZE(adr(size%),buffer_ptr%)
   size%=size%-1
   for i=0 to size%
   poke buffer_ptr%+i,value%
   next i
end_sub

sub CLEAR_BUFFER(buffer_ptr%)
' effacer un buffer revient à le remplir de 0
   FILL_BUFFER(buffer_ptr%,0)
end_sub

sub DISPLAY_BUFFER(buffer_ptr%,c$)
' affiche le contenu du buffer
dim_local buffer_position%,i,value,tmp%,tmp,j,k
   buffer_position%=0
   c$=upper$(c$)
   for i=1 to len(c$)
   value=asc(mid$(c$,i,1))
   select value
   case 66
   tmp%=0
   READ_BUFFER_BYTE(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+1
   print tmp%

   case 68
   tmp%=0
   READ_BUFFER_DWORD(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+4
   print tmp%

   case 70
   tmp=0
   READ_BUFFER_FLOAT(adr(tmp),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+8
   k=0 : for j=0 to 7 : k=k+peek(adr(tmp)+j) : next j
   if k=2040
   print "NaN"
   else
   print tmp
   end_if

   case 73
   tmp%=0
   READ_BUFFER_INT(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+4
   print tmp%

   case 76
   tmp%=0
   READ_BUFFER_LONG(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+4
   print tmp%

   case 87
   tmp%=0
   READ_BUFFER_WORD(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+2
   print tmp%
   end_select
   next i
end_sub

sub GET_BUFFER_PTR(adr_destination%,adr_source%)
' retrouve l'adresse du pointeur
   poke adr_destination%,peek(adr_source%)
   poke adr_destination%+1,peek(adr_source%+1)
   poke adr_destination%+2,peek(adr_source%+2)
   poke adr_destination%+3,peek(adr_source%+3)
end_sub

sub DEBUG(adr%, tai%)
dim_local i,k
   print
   for i=0 to tai%-1
   k=peek(adr%+i)
   if k<16
   print "0";hex$(k);" ";
   else
   print hex$(k);" ";
   end_if
   next i
   print
   for i=0 to tai%-1
   k=peek(adr%+i)
   print chr$(k);" ";
   next i
   print
end_sub

EDIT: corrigé erreur dans le code

EDIT2: en 2019, j'ai trouvé le moyen de contourner le pb des 6 paramètres, voir ici

Je pense que l'on peut concourner le probleme avec cela :

Mhandle%=HANDLE_FORM("dontgo93.mod")

En fait c'est une fonction de paroramic qui récupére un handle non panoramic.
Dans le cas présent il s'agit du handle su lecture du fichier son.

Est ce bien cela que tu voulais ?

PS : j'ai mis cette chaîne mais en fait il s'agit de ce que retourne le lecteur dans le titre de sa fenêtre.

(nb: mis code de test ci-dessus à jour)

Helas non, c'est la fonction "BASS_MusicLoad" qui attribue un handle, et elle a besoin de certains paramètres pour faire ça.
HANDLE_FORM récupère le handle d'un form, pas d'une fonction dll.

EDIT: je ne vais plus pouvoir m'occuper de ça car je n'aurai pas accès à mon ordi cette semaine, mais avec le code que j'ai posté, ça te fait un exemple pour utiliser les dll.

Merci de t'être penché sur mon problème, silverman.

Je vais tenter de creuser dans toutes ces infos maintenant a disposition.
Merci encore.

J'ai regardé un peu bass.dll. Tu ne peux l'utiliser pour faire un VU-mètre que si tu l'utilises pur jouer me morceau (musique, son, vidéo, ...). Ce n'est que dans ce cas que le "canal" est défini pour bass.dll et que tu peux de brancher dessus pour obtenir des informations. Alors; veux-tu écrire toi-même en player entier en Panoramic utilisant bass.dll ? Vaste tâche !

Ce week-end j'étais très occupé, mais j'ai commencé à chercher ce que l'on peut faire pour obtenir le niveau ne vomume, quelque soit le player utilisé. Cela devrait te permettre de faire un VU-mètre indépendant. Patience...

Merci Klaus

silverman avait donc raison...
A moins que ce ne soit réalisable a partir de la dll windows : winmm.dll ?

Ne te précipite pas Klaus, il n'y a aucun caractére d'urgence.
Il s'agit plutot d'un objet pour le fun...

Cela dit, ce week end a était propice a la recherche sur les dlls.
J'y ai appris encore quelques petites choses et c'est bien comme cela !!

As tu vu les programmes que j'ai trouvé pour l'usage des dlls ?

Bonjour à tous! Smile

Oui bass.dll est très intéressante mais difficile à exploiter.
Par contre winmm.dll me parait bien à plusieurs niveaux:
- on peut jouer des morceaux de musique de manière synchrone ou asynchrone
- on a accès à des fonctions midi
- on doit pouvoir mixer plusieurs sons
- on peut contrôler un joystick (ça c'est bien pour les jeux en 2D ou 3D!)
- on doit pouvoir aussi exporter les sons en fichiers wav (ça, ça m'intéresse fortement!)
Et il doit y avoir plein d'autres fonctions encore.
Malheureusement, tout ce que je trouve comme doc c'est un peu du chinois pour moi! Je ne suis pas spécialiste des dll.
@ Klaus (sans te commander), il serait bien que tu jettes un coup d'œil sur cette dll qui pourrait apporter pas mal de chose à Panoramic. Mais prend ton temps. Comme dit minibug, tout ça c'est pour le fun! Cool

A+

Bonjour a tous !

@Bignono :
As tu regardé cette rubrique que j'ai ouverte récement :

https://panoramic.1fr1.net/t4191-recuperer-des-infos-dans-les-dlls

Tu verra des liens concernant des infos sur les API et DLL de windows.

Perso, j'ai installé l'APIGUIDE et c'est vrai qu'il y a beaucoup d'infos !

Bon courage....
drunken

Oui, je connais tout ça.

J'ai placé une version d'essai de KGF.dll sur le WebDav, avec 3 nouvelles fonctions:

Code:: res% = dll_call0("ConnectToMidiSpeakerControl")
res% = dll_call0("GetMidiSpeakerSoundLevel")
res% = dll_call0("CloseMidiSpeakerControl")

Et voici une petite démo qui l'utilise:

Code:: label tick, close0

dim res%, volumeL%, volumeR%, solution%

on_close 0,close0
dll_on "KGF.dll"

alpha 11 : top 11,10 : left 11,10 : caption 11,"Volume:"
alpha 12 : top 12,30 : left 12,10

alpha 31 : top 31,60 : left 31,10 : caption 31,"Résultat:"
alpha 32 : top 32,80 : left 32,10

res% = dll_call0("ConnectToMidiSpeakerControl")
if res%<0
message "Erreur en connexion: "+str$(res%)
end
end_if

timer 1 : timer_interval 1,100 : on_timer 1,tick

end

tick:
timer_off 1
res% = dll_call0("GetMidiSpeakerSoundLevel")
caption 12,str$(res%)
timer_on 1
return

close0:
res% = dll_call0("CloseMidiSpeakerControl")
return

Mais, et il y a un "mais": cela dépend entièrement de ta carte son. Certaines cartes son (et leurs drivers) on un "mètre", d'autres non. La fonction de connexion cherche la ligne su haut-parleur et tente de localiser le mètre. Chez moi, il n'y en a pas; et donc, la fonction termine avec le code retour -4. Voici les codes erreur retournées:

Code:: 0 = ok

-1 = Can't find speaker line
-2 = Can't get source line
-3 = Can't find wave out device
-4 = Can't find peak meter control

Comme c'est une version d'essai, je n'ai pas changé le numéro de version de LGF.dll.

Si, comme moi, tu obtiens le code -4, tu ne pourras pas impléemnter un VU-mètre directement, avec les API de Windows. Quelque soit la DLL utilisée. Il faudra réaliser ton propre player et mesurer le son que tu envoies sur le haut-parleur, à la source et non à la sortie du haut-parleur. Désolé.

A mon avis tu va chercher une solution Klaus, non ? Enfin s'il n'y a pas de "mètre" sur la carte son, il y a sans doute une autre solution car Windows affiche une variation d'intensité pour toutes les cartes. Il doit donc y avoir une solution même s'il elle est complexe à trouver (on le saurait si c'était ça qui arrétait un Klaus lancé sur un sujet de recherche Wink

)

Merci pour tes recherches Klaus :

Je viens de faire le test et j'obtiens aussi -4

Si je comprends bien ça prend en charge uniquement le son MIDI :

Citation :: res% = dll_call0("ConnectToMidiSpeakerControl")
res% = dll_call0("GetMidiSpeakerSoundLevel")
res% = dll_call0("CloseMidiSpeakerControl")

(En même temps Klaus vient de se lancer dans l'exploration de ces possibilités, il va peut être trouver un nouvel angle d'attaque ?)

Je viens de placer sur le WebDav, dossier DLLs, un petit programme de démo nommé test_VU.exe. Essaie de le faire marcher et dis-moi ce que tu en penses... Il prend les valeurs "peak" en stéréo sur le canal d'entrée...

EDIT

Et tant que tu y es, teste aussi test_VU_bis.exe, stp. C'est la même chose, avec une limitation des valeurs en moins, au cas où...

Je viens de tester :
Je fais marcher un fichier .mp3
J’ai exécuté
test_Vu.exe : OK
test_Vu_bis : pas de réaction

J'ai essayé aussi avec ce code.
(Cliquez sur PLAY / PAUSE)

Code:: rem ============================================================================
dim res%, WB%, url$
top 0,(screen_y - height(0))/2 : left 0,(screen_x - width(0))/2
dll_on "c:\users\acer\desktop\dll\KGF.dll"
url$ = "http://www.radioclassique.fr/player-export.html"
WB% = dll_call1("WB_Create",handle(0))
res% = dll_call5("WB_Locate",WB%,20,50,560,200)
res% = dll_call2("WB_Url",WB%,adr(url$))
execute_wait "c:\users\acer\desktop\test_VU.exe"
end
rem ============================================================================

test_Vu.exe : OK
test_Vu_bis : pas de réaction!

Bonjour a tous !!!

@Klaus :
Tout d'abord, merci pour ta réactivité.

Concernant les 2 vu mètre, si j'ai bien compris, il s'agit de 2 vu mètre qui mesurent le niveau sonore en enregistrement.

Au départ mon niveau d'enregistrement étant désactivé, je n'avais aucun visuel sur les 2.
Ensuite, j'ai activé le niveau d'enregistrement et je l'ai mis a moitié.
Là, les 2 vu mètre qui fonctionnent. Le second semble plus sensible que le premier.

Pour moi, cela fonctionne mais par contre c'est seulement en enregistrement !
drunken

Pour l'instant. Je pense qu'à terme connaissant Klaus, t uauras le choix de ce sur quoi portera la valeur retournée (soit l'entrée, soit une des sorties sons) s'il trouve comment faire tout ça mais vu ce qu'il a déjà trouvé en quelques heures de boulot, je pense que ça viendra bientôt...

PS: Bravo Klaus, encore un sujet qui avance bien, bien que pas forcément évident à la base... et en plus tu travailles sans doute déjà sur quelque chose en parallèle ... c'est assez phénoménal quand même (et ce sans vouloir flatter ton égo car je sais que ça tu t'en fiches...)

Quelques précisions sur les deux versions de la petite maquette que j'ai soumise à vos tests:
- c'est écrit entièrement en Delphi, et donc transposable en fonctions DLL pour KGF.dll
- graphiquement, le VU-mètre est largement paramétrable: position, dimensions, orientation, mono/stéréo, aspect graphique etc
- actuellement, c'est l'entrée audio du "mixer" de Windows qui est surveillée. Cela devrait donc agir sur tout ce qui est envoyé vers les hauts-parleurs, puisque tout doit rentrer dans le mixer pour ensuite être dirigé vers une sortie quelconque (haut-parleurs internes ou externes, enregistrement dans un fichier ou sur CD, etc)
- les deux programmes mesurent l'intensité des canaux gauche et droite. En version mono, le programme utilisera la moyenne arithmétique entre ces deux valeurs (actuellement, on est bien en stéréo)
- les valeurs mesurées sont des entiers compris entre 0 (silence) et 32535 (volume maxi), dans les deux programmes
- l'affichage par le composant graphique réagit à des valeurs entre 0 et 100, dans les deux programmes
- dans test_VU.exe, les valeurs mesurées sont "projetées" par une proportionnalité dans l'intervalle 0..100, alors que test_VU_bis.exe envoie les valeurs brutes au composant graphique
- le composant graphique peut être configuré en 1, 2 ou 3 couleurs. Actuellement, c'est en 3 couleurs: vert pour le domaine normal, jaune pour le domaine proche de la saturation et rouge au-delà. Les limites de ces domaines, actuellement choisies aléatoirement, sont modifiables en cours d'exécution.

Je voulais surtout connaître la réactivité de ces programmes, et la vraisemblance du résultat, par rapport à l'impression intuitive qu'on peut avoir. Pour ma part, test_VU.exe semble être le meilleur, ce qui me paraît probable puisqu'il y a projection de l'intervalle des valeurs d'entrée sur l'intervalle des valeurs affichables. Mais on ne sait jamais - ces choses sont souvent subjectives.

Voilà. Si c'est une solution satisfaisante et si cela résiste à des tests avec différents sons, musiques etc, je peux, sans problème, faire 2 choses, à priori totalement indépendantes, et utilisables séparément ou en couple:
1. réalisation d'un jeu de fonctions très restreint pour la surveillance audio: connexion, récupération du niveau sonore et déconnexion
2. réalisation d'un objet graphique "VU-mètre" hautement paramétrable (quelques dizaines de paramètres possibles)

La surveillance pourra être utilisée seule, avec d'autres systèmes d'affichage comme un cadran à aiguilles, un affichage en LEDs 7 segments etc. L'utilisation de l'objet graphique proposé ici est parfaitement optionnelle.

@Jicehel:

Citation :: Bravo Klaus, encore un sujet qui avance bien, bien que pas forcément évident à la base... et en plus tu travailles sans doute déjà sur quelque chose en parallèle ... c'est assez phénoménal quand même (et ce sans vouloir flatter ton égo car je sais que ça tu t'en fiches...)

Oui, je travaille sur autre chose en parallèle et qui est autrement plus difficile. Mais ça avance, et vous aurez bientôt des nouvelles. Cela concerne les PICTURE... Et en ce qui concerne mon égo, je n'ai pas besoin qu'on le flatte, il se porte assez bien comme ça. Cependant, il est vrai qu'un compliment fait toujours plaisir, et je t'en remercie sincèrement.

Citation :: 1. réalisation d'un jeu de fonctions très restreint pour la surveillance audio: connexion, récupération du niveau sonore et déconnexion
2. réalisation d'un objet graphique "VU-mètre" hautement paramétrable (quelques dizaines de paramètres possibles)

Pour ma part le premier me suffit. Wink

Ne serait il pas plus facile d'utiliser winmm.dll, car elle contient déjà ces fonctions non ?
j'avais fais quelques avancés dans ce sens...
Mais ne m'y connaissant pas suffisamment dans le fonctionnement des dlls, je n'ai pas réussi a aller jusqu'au bout.
drunken

Je vais à nouveau me plonger dans cette dll. Mais j'avais essayé de l'utiliser et je n'y suis pas arrivé. Et c''est pourquoi j'utilise de façon interne uafdll.dll...

Bonjour Klaus !

Je comprends mieux.

De mon coté, j'ai cherché a utiliser bass.dll mais silverman m'a dissuadé lorsqu'il m'a expliqué qu'il fallait que le son soit chargé depuis cette même dll.

Ce qui du coup perd tout son intéret dans notre cas, puisque l'on veux un vu mètre qui réagisse directement a la sortie de la carte son. Wink

Tiens, essaie test_VU_ter.exe sur mon WebDav, dossier DLLs, et dis-moi ce que tu en penses. La détection est la même, seul l'affichage change...

Bonjour Klaus, Smile

Je viens d'essayer test_VU_ter.exe. Je le trouve super! Et vu tous les réglages qu'il y a c'est facilement paramétrable. Très fort! Il faudrait juste rajouter un affichage avec des leds comme dans les 2 programmes précédents que l'on puisse les mettre horizontalement, verticalement ou en demi cercle. Attendons de voir ce qu'en pense notre ami minibug puisque la première demande vient de lui Cool

.
A+

» Dessin de VU-metre analogique
» Caractères à obtenir à partir du clavier
» Comment réaliser un écran radar