[C++ Win32] waveInStart

[gianvituzzi]

si ma infatti sono gli ultimi, credo di essere vicino alla stesura di un codide seppur ridotto ma che mi faccia vcapire bene il funzionamento!

alla fine quella di sopra lo riscritta così:

void CALLBACK waveInProc(HWAVEIN hwi,UINT uMsg,DWORD dwInstance,DWORD dwParam1,DWORD dwParam2)
{
	switch(uMsg)
	{
	case WIM_DATA:
		MessageBox(0,"WIN_DATA","waveInProc",MB_OK);
		break;
	case WIM_OPEN:
		MessageBox(0,"WIN_OPEN","waveInProc",MB_OK);
		break;
	case WIM_CLOSE:
		MessageBox(0,"WIN_CLOSE","waveInProc",MB_OK);
		break;
	}
}

[gianvituzzi]

secondo voi è meglio un'approccio alla CALLBACK di tipo /event/ (usando quindi CreateEvent etc..) oppure questa di tipo /function/ ?? parlo di stabilità e performane del programma...

[oregon]

Originariamente inviato da gianvituzzi
secondo voi è meglio un'approccio alla CALLBACK di tipo /event/ (usando quindi CreateEvent etc..) oppure questa di tipo /function/ ?? parlo di stabilità e performane del programma...

Non si puà dire che uno dei due sia più stabile o performante ... semmai c'è' da dire che, con l'event, si presuppone che si lavori con più thread.

[gianvituzzi]

ho modificato la callback in questo modo:

void CALLBACK waveInProc(HWAVEIN hwi,UINT uMsg,DWORD dwInstance,DWORD dwParam1,DWORD dwParam2)
{
	WAVEHDR* pWaveHdr;
	switch(uMsg)
	{
	case MM_WIM_DATA:
		pWaveHdr = ((WAVEHDR*)dwParam1 );
		std::cout << "MM_WIN_DATA" << std::endl;
		std::cout << "dwFlags: " << pWaveHdr->dwFlags << std::endl;
		std::cout << "dwBytesRecorded: " << pWaveHdr->dwBytesRecorded << std::endl;
		std::cout << "lpData: " << pWaveHdr->lpData << std::endl;
		break;
	case MM_WIM_OPEN:
		std::cout << "MM_WIN_OPEN" << std::endl;
		break;
	case MM_WIM_CLOSE:
		std::cout << "MM_WIN_CLOSE" << std::endl;
		break;
	}
}

sembra che vengano registrati 4096 bytes di audio...ma lpdata è vuoto

[oregon]

[QUOTE]Originariamente inviato da gianvituzzi

ma lpdata è vuoto

Vuoto? lpData è un puntatore ... che vuol dire che è "vuoto" ?

Hai esaminato i valori in memoria a partire dal puntatore? Ovvero cosa contiene

pWaveHdr->lpData[0]
pWaveHdr->lpData[1]
...

Scusa gianvituzzi, ma mi sembra che ti manchino le basi del C ... dovresti approfondire questi argomenti prima di addentrarti nella programmazione con le API (che spesso lavorano con strutture complesse e presuppongono la padronanza di certi argomenti ...).

[gianvituzzi]

Originariamente inviato da oregon
Non si puà dire che uno dei due sia più stabile o performante ... semmai c'è' da dire che, con l'event, si presuppone che si lavori con più thread.

ma posso anche usare una CALLBACK_WINDOW, in questro caso dovrei aspettarmi il messaggio in:

LRESULT CALLBACK MyWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);

[oregon]

Originariamente inviato da gianvituzzi
ma posso anche usare una CALLBACK_WINDOW, in questro caso dovrei aspettarmi il messaggio in:

LRESULT CALLBACK MyWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);

In quel caso devi indicare un handle ad una window e processare i messaggi nella normale funzione in cui sono processati i messaggi per la window in questione (non in un'altra window proc).

Dato che la window proc utilizzata è quella che processa i messaggi per la visualizzazione della window, questo metodo non è consigliabile perchè il flusso audio sarebbe influenzato (e viceversa) dalle operazioni di visualizzazione della window.

Non so cosa tu voglia fare (oltre a studiare le API), ma sarebbe meglio utilizzare un secondo thread e l'oggetto Event.

[gianvituzzi]

dato che poi devo fare un'applicazione di tipo console l'unica scelta non può che essere CALLBACK_EVENT! anche perchè: (da msdn)

Applications should not call any system-defined functions from inside a callback function, except ...".

[gianvituzzi]

cmq sto facendo delle prove sulla callback, mi risulta veramente strano che il messaggio mandato dal sistema non corrisponda a nessuna delle costanti predefinite per WAVE HEADER:

void CALLBACK waveInProc(HWAVEIN hwi,UINT uMsg,DWORD dwInstance,DWORD dwParam1,DWORD dwParam2)
{
	WAVEHDR* pWaveHdr;
	switch(uMsg)
	{
	case MM_WIM_DATA:
		pWaveHdr = ((WAVEHDR*)dwParam1 );
		switch(pWaveHdr->dwFlags)
		{
		case WHDR_BEGINLOOP:
			std::cout << "WHDR_BEGINLOOP" << std::endl;
			break;
		case WHDR_DONE:
			std::cout << "WHDR_DONE" << std::endl;
			break;
		case WHDR_ENDLOOP:
			std::cout << "WHDR_ENDLOOP" << std::endl;
			break;
		case WHDR_INQUEUE:
			std::cout << "WHDR_INQUEUE" << std::endl;
			break;
		case WHDR_PREPARED:
			std::cout << "WHDR_PREPARED" << std::endl;
			break;
		case 3:
			std::cout << "tre" << std::endl;
			break;
		}
		std::cout << "MM_WIN_DATA" << std::endl;
		std::cout << "dwFlags: " << pWaveHdr->dwFlags << std::endl;
		std::cout << "dwBytesRecorded: " << pWaveHdr->dwBytesRecorded << std::endl;
		std::cout << "dwuser: " << pWaveHdr->dwUser << std::endl;
		std::cout << "lpData: " << sizeof(pWaveHdr->lpData) << std::endl;
		break;
	case MM_WIM_OPEN:
		std::cout << "MM_WIN_OPEN" << std::endl;
		break;
	case MM_WIM_CLOSE:
		std::cout << "MM_WIN_CLOSE" << std::endl;
		break;
	}
}

anzi ho fatto caso che mi ritorna "3" che non so a cosa si riferisca!

[gianvituzzi]

ho cambiato ancora la callback, questo è il codice di tutto il programmino fino adesso:

#include <windows.h>
#pragma comment (lib, "winmm.lib")
#include <mmsystem.h>
#include <iostream>
#include <stdlib.h> // Define "system" function
#include <string>
#define system_buf_len 32768

void CALLBACK waveInProc(HWAVEIN hwi,UINT uMsg,DWORD dwInstance,DWORD dwParam1,DWORD dwParam2);
bool addbuffer(WAVEHDR *pWaveHdr);


int main()
{
	// Definisco la struttura WAVEFORMATEX
	WAVEFORMATEX waveFormat;
	waveFormat.wFormatTag      = WAVE_FORMAT_PCM;
	waveFormat.wBitsPerSample  = 16;
	waveFormat.nChannels       = 1;
	waveFormat.nSamplesPerSec  = 44100;
	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 = 20;
	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);

	//waveInClose;
	waveInClose(phvi);
	system("pause");
	return 0;
}

void CALLBACK waveInProc(HWAVEIN hwi,UINT uMsg,DWORD dwInstance,DWORD dwParam1,DWORD dwParam2)
{
	WAVEHDR* pWaveHdr;
	switch(uMsg)
	{
	case MM_WIM_DATA:
		pWaveHdr = ((WAVEHDR*)dwParam1);
		if (pWaveHdr && hwi)
		{
			if (pWaveHdr->dwFlags && WHDR_DONE == WHDR_DONE)
			{
				pWaveHdr->dwFlags = 0;
				waveInUnprepareHeader(hwi, pWaveHdr, sizeof(WAVEHDR));
				if (pWaveHdr->dwBytesRecorded > 0)
				{
					addbuffer(pWaveHdr);
				}
				delete[] pWaveHdr->lpData;
				pWaveHdr->lpData = NULL;
			}
		}
		break;

	case MM_WIM_OPEN:
		std::cout << "MM_WIN_OPEN" << std::endl;
		break;
	case MM_WIM_CLOSE:
		std::cout << "MM_WIN_CLOSE" << std::endl;
		break;
	}
}

bool addbuffer(WAVEHDR *pWaveHdr)
{
	std::cout << pWaveHdr->dwBytesRecorded << std::endl;
	std::cout << pWaveHdr->lpData << std::endl;
	return true;
}

verso l'ultimo la funzione addbuffer mi ritorna i bytes registrati (32768) e dei caratteri binari (molti non printable) che presumo sia l'audio grezzo.

Ora. Il programma alloca 20 buffer e li passa alla wave API che provvede a riempirli...come posso creare un meccanismo infinito che venga stoppato da me? così che posso fare un flusso continuo...

grazie