/*這是以前寫的一個簡單的錄音程序(是dll文件).在此備份.調用時需要映射這幾個消息:

 on_message(mm_wim_open,mmwimopen)
 on_message(mm_wim_data,mmwimdata)
 on_message(mm_wim_close,mmwimclose)
 on_message(mm_wom_close,mmwomclose)
 on_message(mm_wom_open,mmwomopen)
 on_message(mm_wom_done,mmwomdone)
*/

/* .h*/

#include "windows.h"
#include "mmsystem.h"

#pragma comment(lib,"winmm.lib")
#ifdef wavefileex_exports
#define wavefileex_api __declspec(dllexport)
#else
#define wavefileex_api __declspec(dllimport)
#endif

// 森濬岆植 wavefileex.dll 絳堤腔
class wavefileex_api cwavefileex {
public:
 cwavefileex(void);
 cwavefileex(hwnd hwnd);
 ~cwavefileex();
 /* wave length*/
 dword getwavelen_size();
 dword getwavelen_time();
 /* record */
 bool recordwav(lpstr filename,int devno);
 bool stoprecordwav();
 bool playwav(lpstr filename,int sounddevno = -1);
 bool stopplaywav();
 /* select devno */
 void selectdevno(int devno);
 void pausewav();
 /* call back function wavein*/
 void mmwimopen();
 void mmwimdata(wparam wparam,lparam lparam);
 void mmwimclose();
 /* call back function waveout */
 void mmwomopen();
 void mmwomdone(wparam wparam,lparam lparam);
 void mmwomclose();
 /* the handle of play wave */
 void setwnd(hwnd hwnd);
protected:
 bool createwavefile(void);
 void getlasterrormsg(lpctstr flag);
 
 bool write(char* data,dword dwlen);
 void close();

private:
 char m_filename[256];
 waveformatex m_waveformat;
 dword m_wavelength;
 dword dwdatalength;

 hwavein m_hwi;
 hwaveout m_hwo;
 handle m_hfile;
 int m_devno;
 hwnd m_hwnd;
 mmckinfo m_mminfoparent;
 mmckinfo m_mminfochild;

 pwavehdr pwavehdr1 ;
 pwavehdr pwavehdr2;
 wavehdr waveouthdr;
 hmmio m_hm;
 hmmio m_hmmio;
 char* lpdwdata;
 byte* pbuf1;
 byte* pbuf2;
 dword m_dwsize;
 char* psavebuffer;
 char* pnewbuffer;
};

/*

.cpp

*/

#include "stdafx.h"
#include "wavefileex.h"
#include "windows.h"
#include "assert.h"
#include "tchar.h"
#include <malloc.h>

#pragma comment(lib,"user32.lib")

bool apientry dllmain( handle hmodule,
                       dword  ul_reason_for_call,
                       lpvoid lpreserved
      )
{
 switch (ul_reason_for_call)
 {
 case dll_process_attach:
 case dll_thread_attach:
 case dll_thread_detach:
 case dll_process_detach:
  break;
 }
    return true;
}

/* 蚚懂翹秞 凳婖勤砓*/
cwavefileex::cwavefileex(hwnd hwnd)
{
 assert(hwnd);
 m_hwnd = hwnd;
 m_devno = -1;
 strcpy(this->m_filename,"");
 m_hfile = 0x00;
 m_hwi   = 0x00;
 m_hwo   = 0x00;
 lpdwdata = 0x00;
 /* */
 m_waveformat.wformattag=wave_format_pcm;
 m_waveformat.nchannels=1;
 m_waveformat.nsamplespersec=8000;
 m_waveformat.navgbytespersec=8000;
 m_waveformat.nblockalign=1;
 m_waveformat.wbitspersample=8; //硌隅翹秞跡宒
 m_waveformat.cbsize=0;

 m_dwsize = 10240;
 m_hmmio = 0x00;
 psavebuffer = 0x00;
 pnewbuffer  = 0x00;

 pwavehdr1 =(wavehdr*)malloc(sizeof(wavehdr));
 pwavehdr2 =(wavehdr*)malloc(sizeof(wavehdr));
 pbuf1 = 0x00;
 pbuf2 = 0x00;

}
/* 蚚懂畦溫 凳婖勤砓*/
cwavefileex::cwavefileex()
{
 m_devno = -1;
 strcpy(this->m_filename,"");

 m_hfile = 0x00;
 m_hwi   = 0x00;
 m_hwo   = 0x00;
 lpdwdata = 0x00;
 /* */
 m_waveformat.wformattag=wave_format_pcm;
 m_waveformat.nchannels=1;
 m_waveformat.nsamplespersec=8000;
 m_waveformat.navgbytespersec=8000;
 m_waveformat.nblockalign=1;
 m_waveformat.wbitspersample=8; //硌隅翹秞跡宒
 m_waveformat.cbsize=0;
 pwavehdr1 =(wavehdr*)malloc(sizeof(wavehdr));
 pwavehdr2 =(wavehdr*)malloc(sizeof(wavehdr));
 pbuf1 = 0x00;
 pbuf2 = 0x00;

 m_hmmio = 0x00;
}
cwavefileex::~cwavefileex()
{
 stopplaywav();
 free(pwavehdr1);
 free(pwavehdr2);
 if(pbuf1 != 0x00)
 {
  delete[] pbuf1;
 }
 if(pbuf2 != 0x00)
  delete[] pbuf2;
 pbuf1 = 0x00;
 pbuf2 = 0x00;
}

void cwavefileex::getlasterrormsg(lpctstr flag)
{
 lpvoid lpmsgbuf;
 formatmessage(format_message_allocate_buffer |
   format_message_from_system |
   format_message_ignore_inserts,
   null,
   getlasterror(),
   makelangid(lang_neutral,
    sublang_default), // default language
   (lptstr) &lpmsgbuf,
   0,
   null );
 messagebox(null,(lpctstr)lpmsgbuf,flag,0);
}
void cwavefileex::selectdevno(int devno)
{
 m_devno = devno;
}
dword cwavefileex::getwavelen_size()
{
 return m_wavelength;
}
dword cwavefileex::getwavelen_time()
{
 return m_wavelength/8000;
}
bool cwavefileex::recordwav(lpstr filename,int devno)
{
 mmresult hr = 0x00;
 assert(filename);
 strcpy(m_filename,filename);
 this->m_devno = devno;

 int devcount = waveingetnumdevs();
 assert(devcount>0);
 assert(devno<devcount);
 hr = waveinopen(&m_hwi,m_devno,
     &m_waveformat,
     (dword)m_hwnd,
     0,
     callback_window);
 if(hr != mmsyserr_noerror )
 {
  messagebox(null,_t("wave in open failed!"),_t("error"),0);
  return false;
 }
 pbuf1 =new byte[m_dwsize];
 if(pbuf1 == null)
  return false;
 if(!pwavehdr1)
  return false;

 pwavehdr1->lpdata = (char*)pbuf1;
 pwavehdr1->dwbufferlength=m_dwsize;
 pwavehdr1->dwbytesrecorded=0;
 pwavehdr1->dwuser=0;
 pwavehdr1->dwflags=0;
 pwavehdr1->dwloops=1;
 pwavehdr1->lpnext=null;
 pwavehdr1->reserved=0;
 
 pbuf2 =new byte[m_dwsize];
 if(pbuf2 == null)
  return false;
 if(!pwavehdr2)
  return false;

 pwavehdr2->lpdata = (char*)pbuf2;
 pwavehdr2->dwbufferlength=m_dwsize;
 pwavehdr2->dwbytesrecorded=0;
 pwavehdr2->dwuser=0;
 pwavehdr2->dwflags=0;
 pwavehdr2->dwloops=1;
 pwavehdr2->lpnext=null;
 pwavehdr2->reserved=0;

 if(!m_hwi)
  return false;
 waveinprepareheader(m_hwi,pwavehdr1,sizeof(wavehdr));
 waveinprepareheader(m_hwi,pwavehdr2,sizeof(wavehdr));
 
 return true;
}

bool cwavefileex::createwavefile(void)
{
 try
 {
  if(this->m_hmmio)
  {
   m_hmmio = 0x00;
  }
  this->m_hmmio = ::mmioopen(this->m_filename,null, mmio_create|mmio_write|mmio_exclusive | mmio_allocbuf);
  if(this->m_hmmio == null)
   return false;
  zeromemory(&m_mminfoparent,sizeof(m_mminfoparent));
  m_mminfoparent.fcctype = mmiofourcc(´w´,´a´,´v´,´e´);

  mmresult mmresult = mmiocreatechunk(this->m_hmmio,&m_mminfoparent,mmio_createriff);
  if(mmresult ==mmioerr_cannotseek)
  {
   getlasterrormsg("mmiofourcc(\"wave 1\")");
   return false;
  }
  if(mmresult ==mmioerr_cannotwrite)
  {
   getlasterrormsg("mmiofourcc(\"wave 2\")");
   return false;
  }

  zeromemory(&m_mminfochild,sizeof(m_mminfochild));
  m_mminfochild.ckid = mmiofourcc(´f´,´m´,´t´,´ ´);
  m_mminfochild.cksize = sizeof(waveformatex)+ m_waveformat.cbsize;

  mmresult = mmiocreatechunk(this->m_hmmio,&m_mminfochild,0);
  if(mmresult ==mmioerr_cannotseek)
  {
   getlasterrormsg("mmiofourcc(\"fmt  1\")");
   return false;
  }
  if(mmresult ==mmioerr_cannotwrite)
  {
   getlasterrormsg("mmiofourcc(\"fmt  2\")");
   return false;
  }
  mmresult = mmiowrite(this->m_hmmio,(char*)&this->m_waveformat, sizeof(waveformatex) + this->m_waveformat.cbsize);
  if(mmresult == -1)
  {
   getlasterrormsg("mmiowrite");
   return false;
  }
  mmresult = mmioascend(this->m_hmmio,&m_mminfochild,0);
  if(mmresult == mmioerr_cannotseek)
  {
   getlasterrormsg("mmioascend _seek");
   return false;
  }
  if(mmresult ==mmioerr_cannotwrite )
  {
   getlasterrormsg("mmioascend _write");
   return false;
  }
  m_mminfochild.ckid = mmiofourcc(´d´,´a´,´t´,´a´);
  mmresult = mmiocreatechunk(this->m_hmmio,&m_mminfochild,0);
  if(mmresult ==mmioerr_cannotseek)
  {
   getlasterrormsg("mmiofourcc(\"data 1\")");
   return false;
  }
  if(mmresult ==mmioerr_cannotwrite)
  {
   getlasterrormsg("mmiofourcc(\"data 2\")");
   return false;
  }
  
  return true;
 }
 catch(...)
 {
  return false;
 }

}
bool cwavefileex::write(char* data,dword dwlen)
{
 dword len= 0;
 len = mmiowrite(this->m_hmmio,data,dwlen);
 if(len <=0 )
  return false;
 
 return true;
}
void cwavefileex::mmwimopen()
{
 try
 {
  psavebuffer = new char[1];
  if(psavebuffer == null)
   return;
  dwdatalength = 0;
  waveinaddbuffer(m_hwi,pwavehdr1,sizeof(wavehdr));
  waveinaddbuffer(m_hwi,pwavehdr2,sizeof(wavehdr));
  waveinstart(m_hwi);
 }
 catch(...)
 {
 }
}
void cwavefileex::mmwimdata(wparam wparam,lparam lparam)
{
 dword numofwritten = 0x00;
 pnewbuffer =(char *) realloc(psavebuffer,
      dwdatalength+((pwavehdr)lparam)->dwbytesrecorded);
 if(pnewbuffer!=null)
 {
  try
  {
   psavebuffer=pnewbuffer;

   copymemory(psavebuffer+dwdatalength,((pwavehdr)lparam)->lpdata,
      ((pwavehdr)lparam)->dwbytesrecorded);
   dwdatalength+=((pwavehdr)lparam)->dwbytesrecorded;

   createwavefile();
   write(psavebuffer,dwdatalength);
   close();
   waveinaddbuffer(m_hwi,(pwavehdr)lparam,sizeof(wavehdr));
  }
  catch(...)
  {
  }
 }
 else
 {
  waveinclose(m_hwi);
 }
}
void cwavefileex::mmwimclose()
{
 waveinunprepareheader(m_hwi,pwavehdr1,sizeof(wavehdr));
 waveinunprepareheader(m_hwi,pwavehdr2,sizeof(wavehdr));
 waveinreset(m_hwi);
 waveinclose(m_hwi);
}
bool cwavefileex::stoprecordwav()
{
 try
 {
  waveinstop(m_hwi);

  if(pbuf1 != 0x00)
   delete[] pbuf1;
  if(pbuf2 != 0x00)
   delete[] pbuf2;
  pbuf1 = 0x00;
  pbuf2 = 0x00;
  return true;
 }
 catch(...)
 {
  return false;
 }
}
bool cwavefileex::playwav(lpstr filename,int sounddevno)
{
 mmckinfo mmckinfoparent;
 mmckinfo mmckinfosubchunk;
 mmresult _mr;
 dword _dwfmtsize = 0x00;
 assert(filename);
 int devcount = waveoutgetnumdevs();
 assert(sounddevno >= -1);
 assert(sounddevno <= devcount);
 //湖羲疏倛恅璃
 try
 {
  stopplaywav();

  m_hm = mmioopen(filename,null,mmio_read);
  if(m_hm == 0x00)
  {
   getlasterrormsg("mmioopen");
   return false;
  }
  //輛?輸ㄛ潰脤湖羲恅璃岆瘁岆wave恅璃
  mmckinfoparent.fcctype = mmiofourcc(´w´,´a´,´v´,´e´);
  _mr = mmiodescend(m_hm,(lpmmckinfo)&mmckinfoparent,null,mmio_findriff);
  if(_mr != mmsyserr_noerror)
  {
   getlasterrormsg("mmiofourcc wave open");
   return false;
  }
  //扆梑 ´fmt´ 輸
  mmckinfosubchunk.ckid = mmiofourcc(´f´,´m´,´t´,´ ´);
  _mr = mmiodescend(m_hm,(lpmmckinfo)&mmckinfosubchunk,(lpmmckinfo)&mmckinfoparent,
       mmio_findchunk);
  if(_mr != mmsyserr_noerror)
  {
   getlasterrormsg("mmiofourcc fmt open");
   return false;
  }
  //鳳腕 ´fmt ´輸腔湮苤ㄛ扠?囀湔
  _dwfmtsize = mmckinfosubchunk.cksize;

  pwaveformatex lpformat = (waveformatex *)&m_waveformat;
  if (!lpformat)
  {
   getlasterrormsg("mmiofourcc lpformat = null open");
   return false;
  }
  if ((unsigned long) mmioread(m_hm, (hpstr)lpformat, _dwfmtsize) !=
  _dwfmtsize)
  {
   getlasterrormsg("mmiofourcc _dwfmtsize = null open");
   return false;
  }
  //燭羲 fmt 輸
  mmioascend(m_hm, &mmckinfosubchunk, 0);
  //扆梑 ´data´ 輸
  mmckinfosubchunk.ckid = mmiofourcc(´d´, ´a´, ´t´, ´a´);
  _mr = mmiodescend(m_hm, &mmckinfosubchunk, &mmckinfoparent,
      mmio_findchunk);
  if (_mr != mmsyserr_noerror)
  {
   getlasterrormsg("mmiofourcc data open");
   return false;
  }
  // 鳳?data輸腔湮苤
  dword _dwdatasize = mmckinfosubchunk.cksize ;
  dword _dwdataoffset = mmckinfosubchunk.dwdataoffset ;
  if( _dwdataoffset== 0l)
  {
   getlasterrormsg("mmiofourcc _dwdataoffset open");
   return false;
  }
  //峈秞?杅擂煦饜囀湔
  lpdwdata = new char[_dwdatasize];
  if(!lpdwdata)
   return false;
  dword lsoundoffset = _dwdataoffset;
  long lsize = mmioseek(m_hm, lsoundoffset, seek_set);
  if (lsize < 0)
  {
   getlasterrormsg("mmiofourcc lsize open");
   return false;
  }

  dword _soundlong = _dwdatasize;
  dword _wavelong = mmioread(m_hm,lpdwdata,_soundlong);
  if(_wavelong<= 0)
   return false;
  m_wavelength = _wavelong;

  mmresult hr = 0x00;
  hr = waveoutopen(&m_hwo,sounddevno,
      &m_waveformat,
      (dword)this->m_hwnd,
      0,
      callback_window);
  if(hr !=mmsyserr_noerror)
  {
   getlasterrormsg("waveoutopen");
   return false;
  }
  return true;
 }
 catch(...)
 {
  return false;
 }
 //mmwomopen();
}

bool cwavefileex::stopplaywav()
{
 try
 {
  if(m_hm!=0x00)
  {
   mmioclose(m_hm,null);
   m_hm = 0x00;
  }
  if(m_hwo != 0x00)
  {
   waveoutreset(m_hwo);
   waveoutclose(m_hwo);
   m_hwo = null;
  }
  if(lpdwdata != 0x00)
  {
   delete[] lpdwdata;
   lpdwdata = null;
  }
  return true;
 }
 catch(...)
 {
  return false;
 }
}
void cwavefileex::mmwomopen()
{
 try
 {
  if(lpdwdata == null)
   return;
  waveouthdr.lpdata    = (char*)lpdwdata;
  waveouthdr.dwbufferlength  = m_wavelength;
  waveouthdr.dwbytesrecorded  =0;
  waveouthdr.dwuser    =0;
  waveouthdr.dwflags    =whdr_beginloop|whdr_endloop;
  waveouthdr.dwloops    =1;
  waveouthdr.lpnext    =null;
  waveouthdr.reserved    =0;

  waveoutprepareheader(m_hwo,&waveouthdr,sizeof(wavehdr));
  if(waveoutwrite(m_hwo,&waveouthdr,sizeof(wavehdr)) != mmsyserr_noerror)
  {
   getlasterrormsg("waveoutwrite");
  }
  }
 catch(...)
 {
 }
}
void cwavefileex::mmwomdone(wparam wparam,lparam lparam)
{
 waveoutunprepareheader(m_hwo,&waveouthdr,sizeof(wavehdr));
 waveoutreset(m_hwo);

}
void cwavefileex::mmwomclose()
{
 try
 {
  waveoutunprepareheader(m_hwo,pwavehdr1,sizeof(pwavehdr1));
  waveoutunprepareheader(m_hwo,pwavehdr2,sizeof(pwavehdr2));
  m_hwo=null;
  free(pwavehdr1);
  free(pwavehdr2);
  delete[] pbuf1;
  delete[] pbuf2;
  pwavehdr1 = null;
  pwavehdr2 = null;
  pbuf1   = null;
  pbuf2     = null;
 }
 catch(...)
 {
 }
}
void cwavefileex::close()
{
 if(this->m_hmmio)
 {
  mmioascend(this->m_hmmio,&this->m_mminfochild,0);
  mmioascend(this->m_hmmio,&this->m_mminfoparent,0);
  mmioclose(this->m_hmmio,0);
  this->m_hmmio = 0x0;
 }
}
void cwavefileex::pausewav()
{
 static bool _bpause = true;
 if(_bpause )
 {
  ::waveoutpause(m_hwo);
 }
 else
 {
  ::waveoutrestart(m_hwo);
 }
 _bpause = !_bpause;
}
void cwavefileex::setwnd(hwnd hwnd)
{
 this->m_hwnd = hwnd;
}