Salve,

sono ancora preso dalla programmazione di un applicazione console che registri l'audio dal device scelto e ne salvi il contenuto su file in real time.

Il programma deve aprire in input il device scelto, aggiungere buffers alla waveIn e iniziare a registrare. La callback relativa si occuperà di salvare i dati in arrivo.

Questo è la parte principale del mio codice:

mio codice
codice:
int main()
{
	// Definisco la struttura WAVEFORMATEX
	WAVEFORMATEX waveFormat;
	waveFormat.wFormatTag      = WAVE_FORMAT_PCM;
	waveFormat.wBitsPerSample  = 16;
	waveFormat.nChannels       = 1;
	waveFormat.nSamplesPerSec  = 8000;
	waveFormat.nBlockAlign     = (waveFormat.nChannels * waveFormat.wBitsPerSample) / 8;
	waveFormat.nAvgBytesPerSec = (waveFormat.nSamplesPerSec * waveFormat.nBlockAlign);
	waveFormat.cbSize          = 0;

	MMRESULT mmres;   // ...
	HWAVEIN phvi;     // Handle for the input device
	UINT uDevice = 0; // Device id "Gruppo Microfoni"

	// waveInOpen
	mmres = waveInOpen(&phvi,
					uDevice,
					(LPWAVEFORMATEX)&waveFormat,
					(DWORD)waveInProc,
					0,
					CALLBACK_FUNCTION
					);

	// Prepare Buffer

	int i=0;
	int num_buff = 3;
	WAVEHDR *buffer = (WAVEHDR *) malloc(sizeof(WAVEHDR)*num_buff);
	for (i=0; i<num_buff; i++)
	{
		buffer[i].lpData          = (LPSTR) malloc(system_buf_len);
		buffer[i].dwBufferLength  = system_buf_len;
		buffer[i].dwBytesRecorded = 0;
		buffer[i].dwUser          = 0;
		buffer[i].dwFlags         = 0;
		buffer[i].dwLoops         = 0;

		waveInPrepareHeader(phvi, &buffer[i], sizeof(WAVEHDR));
		waveInAddBuffer(phvi, &buffer[i], sizeof(WAVEHDR));
	}
	//waveInStart;
	waveInStart(phvi);
	system("pause");
	//waveInClose;
	waveInClose(phvi);
	return 0;
}
Mi sono imbattuto in un codice simile in rete, dove però viene usata una diversa maniera di allocare i buffers:

altro codice
codice:
	/* Preparing system buffers */

	sb = (WAVEHDR**) malloc(sizeof(WAVEHDR**) * system_buf_num);
	if(!sb)
		goto problem;

    for (i = 0; i < system_buf_num; i++)
        sb[i] = NULL;

    for (i = 0; i < system_buf_num; i++) {
	
		count = i;
        sb[i] = (WAVEHDR*) malloc(sizeof(WAVEHDR));

        if (sb[i] == NULL) {
	       	put_debug_message("malloc() error!\n");
			goto problem;
		}

        sb[i]->lpData = (LPBYTE) malloc(system_buf_len);
        sb[i]->dwBufferLength = system_buf_len;
        sb[i]->dwBytesRecorded = 0;
        sb[i]->dwUser = 0;
        sb[i]->dwFlags = 0;
        sb[i]->dwLoops = 0;

		if(!sb[i]->lpData)
			goto problem;

        if (waveInPrepareHeader(rip->hwi, sb[i], sizeof(WAVEHDR))) {
			put_debug_message("waveInPrepareHeader problem!\n");
			goto problem;
        } 
        if (waveInAddBuffer(rip->hwi, sb[i], sizeof(WAVEHDR))) {
            put_debug_message("waveInAddBuffer problem!\n");
			goto problem;
        } 
    }
Mi domandavo qual'era la differenza sostanziale dei due metodi!

Inoltre nel mio codice posso solo accedere ai dati della struttura solo tramite punto, nell'altro codice invece usano ->. Perchè il compilatore non mi permette lo stesso tipo di accesso? Inoltre la struttura WAVEHDR nel mio codice viene passata per riferimento, nell'altro no

nella riga:
sb = (WAVEHDR**) malloc(sizeof(WAVEHDR**) * system_buf_num);

come viene dichiarato "sb" ?? non credo tramite WAVEHDR *sb!

Grazie