www.pudn.com > audiocapture.zip > AudioCap.cpp, change:2001-04-20,size:4213b


//--------------------------------------------------------------------------- 
#include <vcl.h> 
#pragma hdrstop 
 
#include "AudioCap.h" 
 
//--------------------------------------------------------------------------- 
#pragma package(smart_init) 
 
 
CAudioCap::CAudioCap(char *Nombre,DWORD FrecMuestreo,WORD Resolucion) 
{ 
  m_Buffer=NULL; 
  m_TamBuffer=4192; 
 
  //Crea el Objeto WaveFile. 
  m_WaveFile=new CWaveFile(Nombre,FrecMuestreo,Resolucion,m_TamBuffer); 
 
  //Abre el dispositivo de entrada. 
  m_Format.wFormatTag=WAVE_FORMAT_PCM; 
  m_Format.nChannels=1; 
  m_Format.nSamplesPerSec=FrecMuestreo; 
  m_Format.wBitsPerSample=Resolucion; 
  m_Format.nBlockAlign=m_Format.nChannels*m_Format.wBitsPerSample/8; 
  m_Format.nAvgBytesPerSec=m_Format.wBitsPerSample*m_Format.nBlockAlign; 
 
  //Para CALLBACK. 
  //Abre el dispositivo. 
  m_hr=waveInOpen(&m_WaveIn, 
                  WAVE_MAPPER, 
                  &m_Format, 
                  (DWORD)(VOID *)waveInProc, 
                  0, 
                  CALLBACK_FUNCTION); 
 
  if(m_hr!=MMSYSERR_NOERROR) 
    throw("No se puede abrir el dispositivo de entrada de audio"); 
} 
 
 
//Cierra el dispositivo de captura de Audio y el fichero WAV. 
CAudioCap::~CAudioCap() 
{ 
  // ¡¡¡¡¡CUIDADOOOOO!!!!!! 
  // Esta llamada hay que hacerla en Windows 98 pero NO EN WINDOWS 2000!!!!!!!!! 
  //Marca cualquier Buffer pendiente como "DONE". 
  //waveInReset(m_WaveIn); 
 
  //Cierra el Dispositivo de Captura de Audio. 
  waveInClose(m_WaveIn); 
 
  free(m_Buffer); 
 
  delete m_WaveFile; 
} 
 
//El driver de captura llama a esta función cuando ha completado el buffer con los datos. 
void CALLBACK CAudioCap::waveInProc(HWAVEIN hwi, UINT msg, DWORD dwInstance, DWORD Param1, DWORD Param2) 
{ 
  WAVEHDR   *WaveStruct; 
  CWaveFile *File; 
  HWAVEIN   WaveIn; 
  DATACALLBACK *Datos; 
 
  switch(msg) 
    { 
     //Mensaje enviado por el Driver cuando ha terminado de rellenar el Buffer. 
     //lParam es un puntero a WAVEHDR. 
     //El dwUser apunta a los datos de DATACALLBACK. 
     //El miembro dwBytesRecorded indica cuantos bytes se han grabado en el Buffer. 
     case MM_WIM_DATA: //Se toma la estructura WAVEDHR. 
                       WaveStruct=(WAVEHDR *)Param1; 
 
                       //Se toma el nombre del fichero y el handle del disp. de entrad. 
                       Datos=(DATACALLBACK *)WaveStruct->dwUser; 
 
                       //Se añaden los datos al fichero WAV. 
                       Datos->WaveFile->AddSample((byte *)WaveStruct->lpData); 
 
                       //Envía otro buffer al driver de captura. 
                       //Se reutiliza el mismo Buffer. 
                       waveInUnprepareHeader(Datos->WaveIn,WaveStruct,sizeof(WAVEHDR)); 
                       waveInPrepareHeader(Datos->WaveIn,WaveStruct,sizeof(WAVEHDR)); 
                       waveInAddBuffer(Datos->WaveIn,WaveStruct,sizeof(WAVEHDR)); 
                       break; 
    } 
} 
 
//Comienza la captura de sonido. 
void CAudioCap::Start() 
{ 
  //Prepara los datos a pasar a la función de callback. 
  m_DatosCallback.WaveFile=m_WaveFile; 
  m_DatosCallback.WaveIn=m_WaveIn; 
 
  //Prepara el Buffer. 
  //Antes de llamar a waveInPrepareHeader hay que establecer el valor de los campos 
  //lpData, dwBufferLength y dwFlags=0. 
  m_Buffer=(byte *)malloc(m_TamBuffer); 
 
  //Pasa los datos a la función CALLBACK. 
  //m_WaveData.dwUser=(unsigned long)m_WaveFile; 
  m_WaveData.dwUser=(DWORD)&m_DatosCallback; 
  m_WaveData.lpData=(char *)m_Buffer; 
  m_WaveData.dwBufferLength=m_TamBuffer; 
  m_WaveData.dwFlags=0; 
  m_hr=waveInPrepareHeader(m_WaveIn,&m_WaveData,sizeof(WAVEHDR)); 
 
  if(m_hr!=MMSYSERR_NOERROR) 
    throw("Error en Buffers de captura de audio"); 
 
  //Envía un Buffer a Driver para que este comience a usarlo cuando se llame a waveStart. 
  m_hr=waveInAddBuffer(m_WaveIn,&m_WaveData,sizeof(m_WaveData)); 
  if(m_hr!=MMSYSERR_NOERROR) 
    ShowMessage("Error en AddBuffer"); 
 
  //Comienza la captura. 
  m_hr=waveInStart(m_WaveIn); 
  if(m_hr!=MMSYSERR_NOERROR) 
    ShowMessage("Error en Start"); 
} 
 
 
//Para la captura de sonido. 
void CAudioCap::Stop(void) 
{ 
  waveInStop(m_WaveIn); 
}