[VisualC++][audio] g�n�rer un son

Version imprimable

03/06/2008, 10h15
_yeye_

[VisualC++][audio] g�n�rer un son

Bonjour � tous,

Je cherche une lib me permettant de g�n�rer un son.
Par "g�n�rer un son", j'entend un son continu dont je puisse pr�ciser la fr�quence, le volume et la balance.
Toutes les libs que j'ai trouv� ne permettent que de lire des fichiers wav ou autres.
J'ai l'impression que DirectX permet ��, mais �� l'air lourd � g�rer pour si peu.

Bref, des id�es, suggestions, pistes ?

Merci d'avance,
Y�y�
03/06/2008, 11h20
r0d

bonjour,

as-tu jet� un coup d'oeil sur OpenAL?
Sinon effectivement, directX permet de faire �a.
03/06/2008, 16h03
_yeye_

merci,

mais celle-ci a l'air trop haut niveau pour ce que je veux faire : je veux vraiment maitriser ce que j'envoie sur chaque HP. Cette lib est plutot orient�e son 3D on dirait.

Merci quand meme,
Y�y�
03/06/2008, 17h05
Mat.M

Citation:

Envoy� par _yeye_

Par "g�n�rer un son", j'entend un son continu dont je puisse pr�ciser la fr�quence, le volume et la balance.
Toutes les libs que j'ai trouv� ne permettent que de lire des fichiers wav ou autres.
J'ai l'impression que DirectX permet ��, mais �� l'air lourd � g�rer pour si peu.

Regarder les API multim�dias notamment de waveform.
PAr exemple waveOutSetPitch permet de r�gler le pitch
06/06/2008, 18h07
_yeye_

D�sol� d'avoir tard� � r�pondre.
Ca avait l'air interressant, mais �a ne marche pas : ma carte ne g�re apparement pas la gestion du pitch.

Merci quand meme,
Y�y�

Bonjour.

Citation:

Envoy� par _yeye_

J'ai l'impression que DirectX permet ��, mais �� l'air lourd � g�rer pour si peu.

D�sol� de r�agir, mais la lecture d'un format audio n'a rien de comparable � du "si peu".

Essaies d'�crire un programme complet qui g�re la lecture d'un format audio, ne serait-ce que le wave, et tu comprendras de quoi je parle.

De plus voici un exemple de lecture de n'importe quel format audio (� condition d'avoir les codecs audio) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 HRESULT Play(const wstring& wszFile){ CComPtr<IGraphBuilder> pGraph; CComPtr<IMediaControl> pMediaCtrl; CComPtr<IMediaEventEx> pEventEx; if(FAILED(CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, IID_IGraphBuilder, reinterpret_cast<void**>(&pGraph)))) return E_FAIL; if(FAILED(pGraph->RenderFile(wszFile.c_str(), NULL))) return E_FAIL; if(FAILED(pGraph->QueryInterface(IID_IMediaControl, reinterpret_cast<void**>(&pMediaCtrl)))) return E_FAIL; if(FAILED(pGraph->QueryInterface(IID_IMediaEventEx, reinterpret_cast<void**>(&pEventEx)))) return E_FAIL; if(FAILED(pMediaCtrl->Run())) return E_FAIL; long EvCode; pEventEx->WaitForCompletion(INFINITE, &EvCode); return S_OK; }
Une fois que tu as �cris ces 16 lignes de code, il suffit d'une seule ligne de code pour �couter un fichier audio :
Code:

1 2 Play("Mon fichier audio");
Si c'est consid�r� comme du du lourd, alors je ne sait plus quoi dire...

PS : et pour g�rer les balances, volumes et autres, ce ne sont que quelques lignes de plus...

PS2: je reconnais que la fa�on dont DirectShow est pr�sent�e, puisse sembler tr�s compliqu�e. Pourtant, pour des traitements comme tu souhaiterais en faire, elle est tout � fait abordable avec un maximum de possibilit�s. Je pr�pare d'ailleurs des tutoriaux sur le sujet, et le code ci-dessus en fait parti. Le premier est d�j� en ligne, il explique les �tapes de compilation pour cette API :

http://moldavi.developpez.com/tutorial/diretcshow1/

Les tutoriaux suivants vont bient�t suivre.

Citation:

Je cherche une lib me permettant de g�n�rer un son.
Par "g�n�rer un son", j'entend un son continu dont je puisse pr�ciser la fr�quence, le volume et la balance.

Le programme suivant permet d'envoyer un signal quelconque (dont l'�quation x(t) est donn�e) vers la carte son. Dans l'exemple ci-pr�sent, on g�n�re un son pur (sinuso�de) de fr�quence 1kHz, d'amplitude 100% (1), et de dur�e T = 2 s (2000 ms).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
/* sound_gen.c */
 
#include <stdio.h>
#include <windows.h>
#include <mmsystem.h>
#include <math.h>
#include <limits.h>
#include <stdlib.h>
 
#define WAV_2_PI 6.283185307179586476925286766559 /* 2 * PI */
 
double sin_1000(double t);
char * echantillonner(double (*x)(double), unsigned fe, unsigned T, unsigned * pCount, char ** pBuffer);
MMRESULT wav_open_device(u_int device_id, unsigned fe, HWAVEOUT * ptr);
MMRESULT wav_write(HWAVEOUT hWaveOut, WAVEHDR * pwhdr, char * buffer, DWORD buf_size, u_int nLoops);
MMRESULT wav_cleanup(HWAVEOUT hWaveOut, WAVEHDR * pwhdr);
MMRESULT wav_close_device(HWAVEOUT hWaveOut);
 
int main()
{
    unsigned fe = 44100; /* Frequence d'echantillonnage en Hz */
    HWAVEOUT hWaveOut;
 
    if (wav_open_device(WAVE_MAPPER, fe, &hWaveOut) != MMSYSERR_NOERROR)
        fprintf(stderr, "La fonction wav_open_device a echoue.\n");
    else
    {
        double (*x)(double) = sin_1000; /* Le signal a traiter (x(t)) */
        unsigned T = 2000; /* duree de l'observation en ms (t0 = 0 ms) */
        unsigned N; /* Nombre d'echantillons */
        char * buffer;
 
        if ((echantillonner(x, fe, T, &N, &buffer)) == NULL)
            fprintf(stderr, "La fonction echantillonner a echoue.\n");
        else
        {
            WAVEHDR whdr; /* Requis par wav_write et wav_cleanup */
 
            wav_write(hWaveOut, &whdr, buffer, N, 1);
            printf("Press ENTER to stop.\n");
            getchar();
            wav_cleanup(hWaveOut, &whdr);
 
            free(buffer);
        }
 
        wav_close_device(hWaveOut);
    }
 
    return 0;
}
 
double sin_1000(double t) /* signal sinusoidal de frequence 1kHz */
{
    /* t en ms (=> t / 1000 en s) */
    return sin(WAV_2_PI * 1000 * (t / 1000));
}
 
char * echantillonner(double (*x)(double), unsigned fe, unsigned T, unsigned * pCount, char ** pBuffer)
{
    /* fe : Frequence d'echantillonnage en Hz (=> 1 / fe en s)*/
    /* T : duree de l'observation en ms */
 
    unsigned N; /* Nombre d'echantillons */
    double Te = 1000.0 / fe; /* Periode d'echantillonnage en ms */
    char * buffer;
 
    N = (unsigned)(T / Te);
 
    if ((buffer = malloc(N)) != NULL)
    {
        unsigned k;
 
        /* Le signal x(t) doit etre / -1 <= x(t) <= 1 */
        /* Un echantillon xk = x(k * Te) doit etre tel que 0 <= xk <= UCHAR_MAX */
 
        for(k = 0; k < N; k++)
            buffer[k] = (char)((1 + x(k * Te)) * (UCHAR_MAX / 2));
    }
 
    *pCount = N;
    *pBuffer = buffer;
 
    return *pBuffer;
}
 
MMRESULT wav_open_device(u_int device_id, unsigned fe, HWAVEOUT * ptr)
{
    WAVEFORMATEX wfex;
 
    wfex.wFormatTag      = WAVE_FORMAT_PCM;
    wfex.cbSize          = 0;
    wfex.nChannels       = 1; /* Mono. 2 = Stereo */
    wfex.wBitsPerSample  = CHAR_BIT; /* Nombre de bits par echantillon */
    wfex.nBlockAlign     = (wfex.nChannels * wfex.wBitsPerSample) / CHAR_BIT;
    wfex.nSamplesPerSec  = fe;
    wfex.nAvgBytesPerSec = fe * wfex.nBlockAlign;
 
    return waveOutOpen(ptr, device_id, &wfex, 0, 0, 0);
}
 
MMRESULT wav_write(HWAVEOUT hWaveOut, WAVEHDR * pwhdr, char * buffer, DWORD cbBuffer, u_int nLoops)
{
    ZeroMemory(pwhdr, sizeof(*pwhdr));
    pwhdr->lpData = buffer;
    pwhdr->dwBufferLength = cbBuffer;
    pwhdr->dwLoops = nLoops;
 
    waveOutPrepareHeader(hWaveOut, pwhdr, sizeof(*pwhdr));
    return waveOutWrite(hWaveOut, pwhdr, sizeof(*pwhdr));
}
 
MMRESULT wav_cleanup(HWAVEOUT hWaveOut, WAVEHDR * pwhdr)
{
    waveOutUnprepareHeader(hWaveOut, pwhdr, sizeof(*pwhdr));
    return waveOutReset(hWaveOut);
}
 
MMRESULT wav_close_device(HWAVEOUT hWaveOut)
{
    return waveOutClose(hWaveOut);
}

- Il faut se lier avec winmm.lib
- C'est du C (d�sol�), mais tu peux facilement l'adapter pour le C++
- C'est le genre de code qu'on utilise pour impl�menter les fonctions permettant de lire un fichier wav (ouvrir le fichier, lire le son, fermer le fichier)

08/06/2008, 16h02
_yeye_

moldavi -> hum, je ne voulais absolument pas d�nigrer la programmation audio, mais utiliser DirectX juste pour �mettre un bip me semblait disproportionn�. Je jetterai un �il sur tes tutos

Melem -> tr�s int�ressant, faudra que j'�pluche �� demain. Si en plus le buffer permet de pr�ciser le volume sur chaque canal (gauche et droit) alors bingo, c'est exactement ce que je cherche :o)

Merci � tous les 2,
Y�y�
09/06/2008, 09h17
Melem
Citation:

Envoy� par _yeye_

Melem -> tr�s int�ressant, faudra que j'�pluche �a demain. Si en plus le buffer permet de pr�ciser le volume sur chaque canal (gauche et droit) alors bingo, c'est exactement ce que je cherche :o)

Le volume sur chaque canal ... les signaux que tu envoies sur chaque canal ne sont m�me pas n�cessairement les m�mes ! Le volume est contr�l� par l'amplitude du signal. L'exemple est en mono, mais il n'y a pas grand chose � changer pour passer au st�r�o : modifier la valeur de wfex.nChannels (2 pour st�r�o) puis fournir un buffer ad�quat :
Code:

1 2 3 4 5 6 7 buffer[0] = left[0]; buffer[1] = right[0]; buffer[2] = left[1]; buffer[3] = right[1]; etc.
10/06/2008, 16h04
_yeye_

Ca l'air de marcher plutot pas mal.
Un truc bizarre quand meme : si j'envoie un signal � gauche et rien � droite (tout � z�ro), j'entend quand meme l�g�rement le signal � droite (et vice-versa) ... mais bon, l�ger, hein !

Par contre, pour faire varier la fr�quence en live va falloir que je triture le buffer pendant qu'il est lu .... hum, �a va �tre chaud �a 8O

Merci en tout cas,
Y�y�