--- /dev/null
+// \8b\9e
+#include "CInputWave.h"
+
+
+#include <iostream>
+#include <Windows.h>
+#include <MMSystem.h>
+//#include <tchar.h>
+
+////////////////////////////////////////////////////////////////////////////////
+// \83R\83\93\83X\83g\83\89\83N\83^
+////////////////////////////////////////////////////////////////////////////////
+CInputWave::CInputWave()
+{
+ // Wave\83f\83o\83C\83X\83n\83\93\83h\83\8b
+ m_hWaveIn = 0;
+
+ // \83L\83\85\81[\82É\8ai\94[\82·\82é\90\94
+ m_MaxNumberOfBuffer = 3;
+ m_NumberOfBufferInQueue = 0;
+
+ // Wave\83w\83b\83_\81[
+ m_WaveHeaders.resize(m_MaxNumberOfBuffer);
+ m_CurrentWaveHeader = m_WaveHeaders.begin();
+ m_NextWaveHeader = m_WaveHeaders.begin();
+
+ m_pDataFullCallBackFunction = NULL;
+
+ m_pWaveData = NULL;
+
+ // \83f\83o\83C\83X\82ð\83I\81[\83v\83\93\82µ\82Ä\82¢\82é
+ m_isOpen = false;
+ // \93ü\97Í\92\86
+ m_isInput = false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// \83f\83X\83g\83\89\83N\83^
+////////////////////////////////////////////////////////////////////////////////
+CInputWave::~CInputWave()
+{
+ close();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// \93ü\97Í\83f\83o\83C\83X\82Ì\8fó\91Ô\82ð\92m\82ç\82¹\82é\83R\81[\83\8b\83o\83b\83N\8aÖ\90\94
+////////////////////////////////////////////////////////////////////////////////
+void CALLBACK CInputWave::waveInProc(HWAVEIN in_hWaveIn, UINT in_Message, DWORD in_Instance, DWORD in_Param1, DWORD in_Param2)
+{
+ // waveInOpen\8e\9e\82Éin_Instance\82É\83N\83\89\83X\82Ì\83|\83C\83\93\83^\82ð\8ai\94[\82µ\82Ä\82¨\82
+
+ CInputWave* a_pInputWave = reinterpret_cast<CInputWave*>(in_Instance);
+ a_pInputWave->callbackWave(in_hWaveIn, in_Message, in_Instance, in_Param1, in_Param2);
+}
+
+void CInputWave::callbackWave(HWAVEIN in_hWaveIn, UINT in_Message, DWORD in_Instance, DWORD in_Param1, DWORD in_Param2)
+{
+ // \83\81\83b\83Z\81[\83W\82Ì\8eí\97Þ\82²\82Æ\82Ì\8f\88\97\9d\82ð\8ds\82¤
+ switch(in_Message){
+ // \83f\83o\83C\83X\82ª waveInClose \8aÖ\90\94\82Å\83N\83\8d\81[\83Y\82³\82ê\82½\82Æ\82«\82É\91\97\90M\82³\82ê\82Ü\82·\81B
+ case WIM_CLOSE:
+ std::cout << "WIM_CLOSE" << std::endl;
+ break;
+
+ // \83f\83o\83C\83X\82ª\81AwaveInAddBuffer \8aÖ\90\94\82Å\91\97\90M\82³\82ê\82½\83f\81[\83^\83u\83\8d\83b\83N\82Ì\8f\88\97\9d\82ð\8fI\97¹\82µ\82½\82Æ\82«\82É\91\97\90M\82³\82ê\82Ü\82·\81B
+ case WIM_DATA:
+ std::cout << "WIM_DATA" << std::endl;
+ // \98^\89¹\83t\83\89\83O\82ª\97§\82Á\82Ä\82¢\82é\8fê\8d\87\82Í\83o\83b\83t\83@\82ð\89Á\82¦\82é
+ m_NumberOfBufferInQueue--;
+ // \83w\83b\83_\81[\8cã\8f\88\97\9d
+ waveInUnprepareHeader(m_hWaveIn, &(*m_CurrentWaveHeader), sizeof(WAVEHDR));
+
+ m_pWaveData->nextWriteBuffer();
+
+ // \97Ê\8eq\89»\83r\83b\83g\90\94\82ª8\83r\83b\83g\82Ì\8fê\8d\87\82Í\81A0\81`255 \82Ì\94Í\88Í\82Å\90U\95\9d\92l\82ð\95\\8c»\82µ\82Ü\82·\81B128 \82ª\92\86\90S(\90U\95\9d\82È\82µ)\82Å\82·\81B
+ // 16\83r\83b\83g\82Ì\8fê\8d\87\82Í\81A-32768\81`32767 \82Ì\94Í\88Í\82Å\90U\95\9d\92l\82ð\95\\8c»\82µ\82Ü\82·\81B0 \82ª\92\86\90S(\90U\95\9d\82È\82µ)\82Å\82·\81B
+ //for(unsigned int i = 0; i < m_CurrentWaveHeader->dwBufferLength; i++){
+ // char* p = &m_CurrentWaveHeader->lpData[i];
+ // *p = static_cast<unsigned char>((static_cast<unsigned char>(*p) - 128) * 1.5) + 128;
+ //}
+ if(m_pDataFullCallBackFunction != NULL){
+ (*m_pDataFullCallBackFunction)(&(*m_CurrentWaveHeader));
+ }
+
+ m_CurrentWaveHeader++;
+ if(m_CurrentWaveHeader == m_WaveHeaders.end()){
+ m_CurrentWaveHeader = m_WaveHeaders.begin();
+ }
+ try{
+ if(m_isInput){
+ start();
+ }
+ else{
+ m_isInput = false;
+ }
+ }
+ catch(...){
+ m_isInput = false;
+ }
+ break;
+
+ // \83f\83o\83C\83X\82ª waveInOpen \8aÖ\90\94\82Å\83I\81[\83v\83\93\82³\82ê\82½\82Æ\82«\82É\91\97\90M\82³\82ê\82Ü\82·\81B
+ case WIM_OPEN:
+ std::cout << "WIM_OPEN" << std::endl;
+ break;
+ default:
+ throw "error: WAVE Call Back";
+ break;
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// \8f\89\8aú\89»
+////////////////////////////////////////////////////////////////////////////////
+void CInputWave::initialize()
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// \83f\83o\83C\83X\82ð\8aJ\82
+////////////////////////////////////////////////////////////////////////////////
+bool CInputWave::open()
+{
+ // \98A\91±\82Å\8dÄ\90¶\82·\82é\8fê\8d\87\82Í\83_\83u\83\8b\83o\83b\83t\83@\82ð\8eg\97p\82·\82é\81H
+
+ // open a wave device handle
+ // \81¦\8aJ\82\83f\83o\83C\83X\82à\88ø\90\94\82Å\8ew\92è\82Å\82«\82é\82æ\82¤\82É\82·\82é
+ if(waveInOpen(&m_hWaveIn, WAVE_MAPPER, m_pWaveData->getWaveFormat(), reinterpret_cast<DWORD>(waveInProc), reinterpret_cast<DWORD>(this), CALLBACK_FUNCTION) != MMSYSERR_NOERROR) {
+ throw "failer open wave device handle";
+ return false;
+ }
+
+ m_isOpen = true;
+
+ return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// \83f\83o\83C\83X\82ð\95Â\82¶\82é
+////////////////////////////////////////////////////////////////////////////////
+bool CInputWave::close()
+{
+ stop();
+
+ if(m_isOpen){
+ m_isOpen = false;
+ // close a wave device handle
+ waveInClose(m_hWaveIn);
+ }
+ return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// add wave buffer in queue
+////////////////////////////////////////////////////////////////////////////////
+bool CInputWave::addWaveBuffer()
+{
+ while(m_NumberOfBufferInQueue < m_MaxNumberOfBuffer){
+ WAVEHDR& a_rWaveHeader = *m_NextWaveHeader;
+ a_rWaveHeader.lpData = m_pWaveData->getWriteBuffer();
+ a_rWaveHeader.dwBufferLength = m_pWaveData->getWriteBufferSize();
+ a_rWaveHeader.dwFlags = 0;
+ m_NextWaveHeader++;
+ if(m_NextWaveHeader == m_WaveHeaders.end()){
+ m_NextWaveHeader = m_WaveHeaders.begin();
+ }
+
+ // initialize a wave header
+ // must use this function for initialize, because not open wave header structure
+ switch(waveInPrepareHeader(m_hWaveIn, &a_rWaveHeader, sizeof(WAVEHDR))){
+ // \90¬\8c÷
+ case MMSYSERR_NOERROR:
+ break;
+
+ // \95Ê\82Ì\83X\83\8c\83b\83h\82ª\83n\83\93\83h\83\8b\82ð\8eg\97p\92\86\82Å\82 \82é
+ case MMSYSERR_HANDLEBUSY:
+ throw "waveInPrepareHeader: \95Ê\82Ì\83X\83\8c\83b\83h\82ª\83n\83\93\83h\83\8b\82ð\8eg\97p\92\86\82Å\82 \82é ";
+ break;
+ // \83f\83o\83C\83X\83n\83\93\83h\83\8b\82ª\96³\8cø\82Å\82 \82é
+ case MMSYSERR_INVALHANDLE:
+ throw "waveInPrepareHeader: \83f\83o\83C\83X\83n\83\93\83h\83\8b\82ª\96³\8cø\82Å\82 \82é";
+ break;
+ // \83f\83o\83C\83X\83h\83\89\83C\83o\82ª\82È\82¢
+ case MMSYSERR_NODRIVER:
+ throw "waveInPrepareHeader:\83f\83o\83C\83X\83h\83\89\83C\83o\82ª\82È\82¢";
+ break;
+ // \83\81\83\82\83\8a\82ð\8a\84\82è\93\96\82Ä\82ç\82ê\82È\82¢\81A\82Ü\82½\82Í\83\8d\83b\83N\82Å\82«\82È\82¢
+ case MMSYSERR_NOMEM:
+ throw "waveInPrepareHeader: \83\81\83\82\83\8a\82ð\8a\84\82è\93\96\82Ä\82ç\82ê\82È\82¢\81A\82Ü\82½\82Í\83\8d\83b\83N\82Å\82«\82È\82¢";
+ break;
+ }
+
+ // take a buffer for wave
+ switch(waveInAddBuffer(m_hWaveIn, &a_rWaveHeader, sizeof(WAVEHDR))){
+ // \90¬\8c÷
+ case MMSYSERR_NOERROR:
+ break;
+
+ // \95Ê\82Ì\83X\83\8c\83b\83h\82ª\83n\83\93\83h\83\8b\82ð\8eg\97p\92\86\82Å\82 \82é
+ case MMSYSERR_HANDLEBUSY:
+ throw "waveInAddBuffer: \95Ê\82Ì\83X\83\8c\83b\83h\82ª\83n\83\93\83h\83\8b\82ð\8eg\97p\92\86\82Å\82 \82é";
+ break;
+
+ // \83f\83o\83C\83X\83n\83\93\83h\83\8b\82ª\96³\8cø\82Å\82 \82é
+ case MMSYSERR_INVALHANDLE:
+ throw "waveInAddBuffer: \83f\83o\83C\83X\83n\83\93\83h\83\8b\82ª\96³\8cø\82Å\82 \82é";
+ break;
+
+ // \83f\83o\83C\83X\83h\83\89\83C\83o\82ª\82È\82¢
+ case MMSYSERR_NODRIVER:
+ throw "waveInAddBuffer: \83f\83o\83C\83X\83h\83\89\83C\83o\82ª\82È\82¢";
+ break;
+
+ // \83\81\83\82\83\8a\82ð\8a\84\82è\93\96\82Ä\82ç\82ê\82È\82¢\81A\82Ü\82½\82Í\83\8d\83b\83N\82Å\82«\82È\82¢
+ case MMSYSERR_NOMEM:
+ throw "waveInAddBuffer: \83\81\83\82\83\8a\82ð\8a\84\82è\93\96\82Ä\82ç\82ê\82È\82¢\81A\82Ü\82½\82Í\83\8d\83b\83N\82Å\82«\82È\82¢";
+ break;
+
+ // \83o\83b\83t\83@\82ª\8f\80\94õ\82³\82ê\82Ä\82¢\82È\82¢
+ case WAVERR_UNPREPARED:
+ throw "waveInAddBuffer: \83o\83b\83t\83@\82ª\8f\80\94õ\82³\82ê\82Ä\82¢\82È\82¢";
+ break;
+
+ }
+ m_NumberOfBufferInQueue++;
+ }
+ return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// \93ü\97Í\81i\98^\89¹\81j\82ð\8aJ\8en\82·\82é
+////////////////////////////////////////////////////////////////////////////////
+bool CInputWave::start()
+{
+ // \83f\83o\83C\83X\82ð\8aJ\82¢\82Ä\82¢\82È\82¢\82È\82çfalse\82ð\95Ô\82·
+ if(!m_isOpen){
+ return false;
+ }
+
+ // \83o\83b\83t\83@\82ð\89Á\82¦\82é
+ addWaveBuffer();
+
+ switch(waveInStart(m_hWaveIn)){
+ // \90¬\8c÷
+ case MMSYSERR_NOERROR:
+ break;
+
+ // \8ew\92è\82³\82ê\82½\83f\83o\83C\83X\83n\83\93\83h\83\8b\82Í\96³\8cø\82Å\82·\81B
+ case MMSYSERR_INVALHANDLE:
+ break;
+
+ // \83f\83o\83C\83X\83h\83\89\83C\83o\82ª\91¶\8dÝ\82µ\82Ü\82¹\82ñ\81B
+ case MMSYSERR_NODRIVER:
+ break;
+
+ // \83\81\83\82\83\8a\82ð\8a\84\82è\93\96\82Ä\82ç\82ê\82È\82¢\82©\81A\82Ü\82½\82Í\83\8d\83b\83N\82Å\82«\82Ü\82¹\82ñ\81B
+ case MMSYSERR_NOMEM:
+ break;
+ }
+ m_isInput = true;
+ return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// \93ü\97Í\81i\98^\89¹\81j\82ð\92â\8e~\82·\82é
+////////////////////////////////////////////////////////////////////////////////
+bool CInputWave::stop()
+{
+ // \98^\89¹\92\86\82Å\82È\82¢\82È\82çfalse\82ð\95Ô\82·
+ if(!m_isInput){
+ return false;
+ }
+
+ m_isInput = false;
+ waveInStop(m_hWaveIn);
+
+
+ return true;
+}
+
--- /dev/null
+// \8b\9e
+#ifndef INC_CInputWave
+#define INC_CInputWave
+
+// \83C\83\93\83N\83\8b\81[\83h\82Í\95K\82¸\95K\97v\82È\95¨\82¾\82¯
+// \93à\95\94\82Å\97\98\97p\82·\82é\82¾\82¯\82Ì\95¨\82Í\83\\81[\83X\82É\8bL\8fq
+
+// \8aÖ\90\94\96¼\82Í\83\8d\81[\83\8f\83L\83\83\83\81\83\8b\83P\81[\83X\82Æ\82·\82é
+
+
+#include "CWaveData.h"
+#include <list>
+
+
+typedef void (*DataFullCallBack)(WAVEHDR*);
+
+////////////////////////////////////////////////////////////////////////////////
+// CInputWave
+////////////////////////////////////////////////////////////////////////////////
+class CInputWave
+{
+ ////////////////////////////////////////////////////////////////////////////////
+ // \83\81\83\93\83o\95Ï\90\94
+ ////////////////////////////////////////////////////////////////////////////////
+private:
+ // Wave\83f\83o\83C\83X\83n\83\93\83h\83\8b
+ HWAVEIN m_hWaveIn;
+ // Wave\83w\83b\83_\81[
+ typedef std::list<WAVEHDR> WaveHeaderTable;
+ WaveHeaderTable m_WaveHeaders;
+ WaveHeaderTable::iterator m_CurrentWaveHeader;
+ WaveHeaderTable::iterator m_NextWaveHeader;
+ // Wave\83f\81[\83^
+ CWaveData* m_pWaveData;
+
+ // \8aÖ\90\94\83|\83C\83\93\83^
+ DataFullCallBack m_pDataFullCallBackFunction;
+
+ // \83f\83o\83C\83X\82ð\83I\81[\83v\83\93\82µ\82Ä\82¢\82é
+ bool m_isOpen;
+ // \98^\89¹\92\86
+ bool m_isInput;
+ // \83L\83\85\81[\82É\89Á\82¦\82é\83o\83b\83t\83@\90\94
+ int m_MaxNumberOfBuffer;
+ // \83L\83\85\81[\82É\89Á\82¦\82Ä\82¢\82é\83o\83b\83t\83@\90\94
+ int m_NumberOfBufferInQueue;
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // \83R\83\93\83X\83g\83\89\83N\83^
+ ////////////////////////////////////////////////////////////////////////////////
+public:
+ CInputWave();
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // \83f\83X\83g\83\89\83N\83^
+ ////////////////////////////////////////////////////////////////////////////////
+public:
+ virtual ~CInputWave();
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // static\8aÖ\90\94\81A\83R\81[\83\8b\83o\83b\83N\8aÖ\90\94
+ ////////////////////////////////////////////////////////////////////////////////
+ // \93ü\97Í\83f\83o\83C\83X\82Ì\8fó\91Ô\82ð\92m\82ç\82¹\82é\83R\81[\83\8b\83o\83b\83N\8aÖ\90\94
+ static void CALLBACK waveInProc(HWAVEIN in_hWaveIn, UINT in_Message, DWORD in_Instance, DWORD in_Param1, DWORD in_Param2);
+ void callbackWave(HWAVEIN in_hWaveIn, UINT in_Message, DWORD in_Instance, DWORD in_Param1, DWORD in_Param2);
+
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // \91\80\8dì\83\81\83\\83b\83h
+ ////////////////////////////////////////////////////////////////////////////////
+public:
+ // \8f\89\8aú\89»
+ void initialize();
+ // \83f\83o\83C\83X\82ð\8aJ\82
+ bool open();
+ // \83f\83o\83C\83X\82ð\95Â\82¶\82é
+ bool close();
+protected:
+ // add wave buffer in queue
+ bool addWaveBuffer();
+public:
+ // \93ü\97Í\81i\98^\89¹\81j\82ð\8aJ\8en\82·\82é
+ bool start();
+ // \93ü\97Í\81i\98^\89¹\81j\82ð\92â\8e~\82·\82é
+ bool stop();
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // \91®\90«\83\81\83\\83b\83h
+ ////////////////////////////////////////////////////////////////////////////////
+public:
+ void setWaveData(CWaveData* io_pWaveData)
+ {
+ m_pWaveData = io_pWaveData;
+ }
+
+ void setDataFullCallBack(DataFullCallBack in_pDataFullCallBack)
+ {
+ m_pDataFullCallBackFunction = in_pDataFullCallBack;
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // \83C\83e\83\8c\81[\83V\83\87\83\93
+ ////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////
+ // \8fó\91Ô
+ ////////////////////////////////////////////////////////////////////////////////
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // \89\89\8eZ\8eq
+ ////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////
+ // \8f\83\90\88\89¼\91z\8aÖ\90\94\81A\92è\8b`\82Ì\82Ý\81i\94ñ\8eÀ\91\95\92ñ\8b\9f\81j
+ ////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////
+ // \93à\95\94\83N\83\89\83X
+ ////////////////////////////////////////////////////////////////////////////////
+
+
+};
+
+#endif //INC_CInputWave
--- /dev/null
+// \8b\9e
+#include "COutputWave.h"
+
+
+#include <iostream>
+#include <Windows.h>
+#include <MMSystem.h>
+//#include <tchar.h>
+
+
+////////////////////////////////////////////////////////////////////////////////
+// \83R\83\93\83X\83g\83\89\83N\83^
+////////////////////////////////////////////////////////////////////////////////
+COutputWave::COutputWave()
+{
+ // Wave\83f\83o\83C\83X\83n\83\93\83h\83\8b
+ m_hWaveOut = 0;
+
+ // \83L\83\85\81[\82É\8ai\94[\82·\82é\90\94
+ m_MaxNumberOfBuffer = 2;
+ m_NumberOfBufferInQueue = 0;
+
+
+ // Wave\83w\83b\83_\81[
+ m_WaveHeaders.resize(m_MaxNumberOfBuffer);
+ m_CurrentWaveHeader = m_WaveHeaders.begin();
+ m_NextWaveHeader = m_WaveHeaders.begin();
+
+ // Wave\83f\81[\83^
+ m_pWaveData = NULL;
+
+ // \83f\83o\83C\83X\82ð\83I\81[\83v\83\93\82µ\82Ä\82¢\82é
+ m_isOpen = false;
+ // \8dÄ\90¶\92\86
+ m_isOutput = false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// \83f\83X\83g\83\89\83N\83^
+////////////////////////////////////////////////////////////////////////////////
+COutputWave::~COutputWave()
+{
+ close();
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// \8fo\97Í\83f\83o\83C\83X\82Ì\8fó\91Ô\82ð\92m\82ç\82¹\82é\83R\81[\83\8b\83o\83b\83N\8aÖ\90\94
+////////////////////////////////////////////////////////////////////////////////
+void CALLBACK COutputWave::waveOutProc(HWAVEOUT in_hWaveOut, UINT in_Message, DWORD in_Instance, DWORD in_Param1, DWORD in_Param2)
+{
+ // waveInOpen\8e\9e\82Éin_Instance\82É\83N\83\89\83X\82Ì\83|\83C\83\93\83^\82ð\8ai\94[\82µ\82Ä\82¨\82
+
+ COutputWave* a_pOutputWave = reinterpret_cast<COutputWave*>(in_Instance);
+ a_pOutputWave->callbackWave(in_hWaveOut, in_Message, in_Instance, in_Param1, in_Param2);
+}
+
+void COutputWave::callbackWave(HWAVEOUT in_hWaveOut, UINT in_Message, DWORD in_Instance, DWORD in_Param1, DWORD in_Param2)
+{
+ // \83\81\83b\83Z\81[\83W\82Ì\8eí\97Þ\82²\82Æ\82Ì\8f\88\97\9d\82ð\8ds\82¤
+ switch(in_Message){
+ // \83f\83o\83C\83X\82ª waveOutClose \8aÖ\90\94\82Å\83N\83\8d\81[\83Y\82³\82ê\82½\82Æ\82«\82É\91\97\90M\82³\82ê\82Ü\82·\81B
+ case WOM_CLOSE:
+ std::cout << "WOM_CLOSE" << std::endl;
+ break;
+
+ // \83f\83o\83C\83X\83h\83\89\83C\83o\82ª\81AwaveOutWrite \8aÖ\90\94\82Å\91\97\90M\82³\82ê\82½\83f\81[\83^\83u\83\8d\83b\83N\82Ì\8f\88\97\9d\82ð\8fI\97¹\82µ\82½\82Æ\82«\82É\91\97\90M\82³\82ê\82Ü\82·\81B
+ case WOM_DONE:
+ std::cout << "WOM_DATA" << std::endl;
+ // \8dÄ\90¶\83t\83\89\83O\82ª\97§\82Á\82Ä\82¢\82é\8fê\8d\87\82Í\83o\83b\83t\83@\82ð\89Á\82¦\82é
+ m_NumberOfBufferInQueue--;
+ // \83w\83b\83_\81[\8cã\8f\88\97\9d
+ waveOutUnprepareHeader(m_hWaveOut, &(*m_CurrentWaveHeader), sizeof(WAVEHDR));
+ m_CurrentWaveHeader++;
+ if(m_CurrentWaveHeader == m_WaveHeaders.end()){
+ m_CurrentWaveHeader = m_WaveHeaders.begin();
+ }
+ try{
+ if(m_isOutput){
+ start();
+ }
+ else{
+ m_isOutput = false;
+ }
+ }
+ catch(...){
+ m_isOutput = false;
+ }
+ break;
+
+ // \83f\83o\83C\83X\82ª waveOutOpen \8aÖ\90\94\82Å\83I\81[\83v\83\93\82³\82ê\82½\82Æ\82«\82É\91\97\90M\82³\82ê\82Ü\82·\81B
+ case WOM_OPEN:
+ std::cout << "WOM_OPEN" << std::endl;
+ break;
+ default:
+ throw "error: WAVE Call Back";
+ break;
+ }
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// \8f\89\8aú\89»
+////////////////////////////////////////////////////////////////////////////////
+void COutputWave::initialize()
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// \83f\83o\83C\83X\82ð\8aJ\82
+////////////////////////////////////////////////////////////////////////////////
+bool COutputWave::open()
+{
+ // \83f\83o\83C\83X\82ð\8aJ\82
+ // \8aJ\82\83f\83o\83C\83X\82à\88ø\90\94\82Å\8ew\92è\82Å\82«\82é\82æ\82¤\82É\82·\82é
+ if(waveOutOpen(&m_hWaveOut, WAVE_MAPPER, m_pWaveData->getWaveFormat(), reinterpret_cast<DWORD>(waveOutProc), reinterpret_cast<DWORD>(this), CALLBACK_FUNCTION) != MMSYSERR_NOERROR) {
+ //MessageBox(NULL, TEXT("WAVE\83f\83o\83C\83X\82Ì\83I\81[\83v\83\93\82É\8e¸\94s\82µ\82Ü\82µ\82½\81B"), NULL, MB_ICONWARNING);
+ throw "WAVE\83f\83o\83C\83X\82Ì\83I\81[\83v\83\93\82É\8e¸\94s\82µ\82Ü\82µ\82½\81B";
+ return false;
+ }
+
+ m_isOpen = true;
+
+ return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// \83f\83o\83C\83X\82ð\95Â\82¶\82é
+////////////////////////////////////////////////////////////////////////////////
+bool COutputWave::close()
+{
+ if(m_isOpen){
+ m_isOpen = false;
+ // \83f\83o\83C\83X\83N\83\8d\81[\83Y\8aÖ\90\94
+ waveOutClose(m_hWaveOut);
+ }
+ return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// add wave buffer in queue
+////////////////////////////////////////////////////////////////////////////////
+bool COutputWave::addWaveBuffer()
+{
+ while(m_NumberOfBufferInQueue < m_MaxNumberOfBuffer){
+ WAVEHDR& a_rWaveHeader = *m_NextWaveHeader;
+ a_rWaveHeader.lpData = m_pWaveData->getReadBuffer();
+ a_rWaveHeader.dwBufferLength = m_pWaveData->getReadBufferSize();
+ a_rWaveHeader.dwFlags = 0;
+ m_NextWaveHeader++;
+ if(m_NextWaveHeader == m_WaveHeaders.end()){
+ m_NextWaveHeader = m_WaveHeaders.begin();
+ }
+
+ m_pWaveData->nextReadBuffer();
+
+ if(a_rWaveHeader.lpData == NULL){
+ return false;
+ }
+
+ // \83w\83b\83_\81[\82ð\8f\80\94õ\82·\82é
+ waveOutPrepareHeader(m_hWaveOut, &a_rWaveHeader, sizeof(WAVEHDR));
+
+ m_NumberOfBufferInQueue++;
+ }
+ return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// \8fo\97Í\81i\8dÄ\90¶\81j\82ð\8aJ\8en\82·\82é
+////////////////////////////////////////////////////////////////////////////////
+bool COutputWave::start()
+{
+ // \83f\83o\83C\83X\82ð\8aJ\82¢\82Ä\82¢\82È\82¢\82È\82çfalse\82ð\95Ô\82·
+ if(!m_isOpen){
+ return false;
+ }
+
+ while(m_NumberOfBufferInQueue < m_MaxNumberOfBuffer){
+ WAVEHDR& a_rWaveHeader = *m_NextWaveHeader;
+ a_rWaveHeader.lpData = m_pWaveData->getReadBuffer();
+ a_rWaveHeader.dwBufferLength = m_pWaveData->getReadBufferSize();
+ a_rWaveHeader.dwFlags = 0;
+ m_NextWaveHeader++;
+ if(m_NextWaveHeader == m_WaveHeaders.end()){
+ m_NextWaveHeader = m_WaveHeaders.begin();
+ }
+
+ m_pWaveData->nextReadBuffer();
+
+ if(a_rWaveHeader.lpData == NULL){
+ return false;
+ }
+
+ // \83w\83b\83_\81[\82ð\8f\80\94õ\82·\82é
+ waveOutPrepareHeader(m_hWaveOut, &a_rWaveHeader, sizeof(WAVEHDR));
+
+ // \8fo\97Í\81i\8dÄ\90¶\81j\82ð\8aJ\8en\82·\82é
+ waveOutWrite(m_hWaveOut, &a_rWaveHeader, sizeof(WAVEHDR));
+ m_isOutput = true;
+
+ m_NumberOfBufferInQueue++;
+ }
+
+ return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// \8fo\97Í\81i\8dÄ\90¶\81j\82ð\92â\8e~\82·\82é
+////////////////////////////////////////////////////////////////////////////////
+bool COutputWave::stop()
+{
+ // \8dÄ\90¶\92\86\82Å\82È\82¢\8fê\8d\87false\82ð\95Ô\82·
+ if(!m_isOutput){
+ return false;
+ }
+
+ waveOutReset(m_hWaveOut);
+ m_isOutput = false;
+
+ return true;
+}
--- /dev/null
+// \8b\9e
+#ifndef INC_COutputWave
+#define INC_COutputWave
+
+// \83C\83\93\83N\83\8b\81[\83h\82Í\95K\82¸\95K\97v\82È\95¨\82¾\82¯
+// \93à\95\94\82Å\97\98\97p\82·\82é\82¾\82¯\82Ì\95¨\82Í\83\\81[\83X\82É\8bL\8fq
+
+// \8aÖ\90\94\96¼\82Í\83\8d\81[\83\8f\83L\83\83\83\81\83\8b\83P\81[\83X\82Æ\82·\82é
+
+
+#include "CWaveData.h"
+
+#include <list>
+
+////////////////////////////////////////////////////////////////////////////////
+// COutputWave
+////////////////////////////////////////////////////////////////////////////////
+class COutputWave
+{
+ ////////////////////////////////////////////////////////////////////////////////
+ // \83\81\83\93\83o\95Ï\90\94
+ ////////////////////////////////////////////////////////////////////////////////
+private:
+ // Wave\83f\83o\83C\83X\83n\83\93\83h\83\8b
+ HWAVEOUT m_hWaveOut;
+ // Wave\83w\83b\83_\81[
+ typedef std::list<WAVEHDR> WaveHeaderTable;
+ WaveHeaderTable m_WaveHeaders;
+ WaveHeaderTable::iterator m_CurrentWaveHeader;
+ WaveHeaderTable::iterator m_NextWaveHeader;
+ // Wave\83f\81[\83^
+ CWaveData* m_pWaveData;
+
+ // \83f\83o\83C\83X\82ð\83I\81[\83v\83\93\82µ\82Ä\82¢\82é
+ bool m_isOpen;
+ // \8dÄ\90¶\92\86
+ bool m_isOutput;
+ // \83L\83\85\81[\82É\89Á\82¦\82é\83o\83b\83t\83@\90\94
+ int m_MaxNumberOfBuffer;
+ // \83L\83\85\81[\82É\89Á\82¦\82Ä\82¢\82é\83o\83b\83t\83@\90\94
+ int m_NumberOfBufferInQueue;
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // \83R\83\93\83X\83g\83\89\83N\83^
+ ////////////////////////////////////////////////////////////////////////////////
+public:
+ COutputWave();
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // \83f\83X\83g\83\89\83N\83^
+ ////////////////////////////////////////////////////////////////////////////////
+public:
+ virtual ~COutputWave();
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // static\8aÖ\90\94\81A\83R\81[\83\8b\83o\83b\83N\8aÖ\90\94
+ ////////////////////////////////////////////////////////////////////////////////
+ // \8fo\97Í\83f\83o\83C\83X\82Ì\8fó\91Ô\82ð\92m\82ç\82¹\82é\83R\81[\83\8b\83o\83b\83N\8aÖ\90\94
+ static void CALLBACK waveOutProc(HWAVEOUT in_hWaveOut, UINT in_Message, DWORD in_Instance, DWORD in_Param1, DWORD in_Param2);
+ void callbackWave(HWAVEOUT in_hWaveOut, UINT in_Message, DWORD in_Instance, DWORD in_Param1, DWORD in_Param2);
+
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // \91\80\8dì\83\81\83\\83b\83h
+ ////////////////////////////////////////////////////////////////////////////////
+public:
+ // \8f\89\8aú\89»
+ void initialize();
+ // \83f\83o\83C\83X\82ð\8aJ\82
+ bool open();
+ // \83f\83o\83C\83X\82ð\95Â\82¶\82é
+ bool close();
+protected:
+ // add wave buffer in queue
+ bool addWaveBuffer();
+public:
+ // \8fo\97Í\81i\8dÄ\90¶\81j\82ð\8aJ\8en\82·\82é
+ bool start();
+ // \8fo\97Í\81i\8dÄ\90¶\81j\82ð\92â\8e~\82·\82é
+ bool stop();
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // \91®\90«\83\81\83\\83b\83h
+ ////////////////////////////////////////////////////////////////////////////////
+public:
+ void setWaveData(CWaveData* io_pWaveData)
+ {
+ m_pWaveData = io_pWaveData;
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // \83C\83e\83\8c\81[\83V\83\87\83\93
+ ////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////
+ // \8fó\91Ô
+ ////////////////////////////////////////////////////////////////////////////////
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // \89\89\8eZ\8eq
+ ////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////
+ // \8f\83\90\88\89¼\91z\8aÖ\90\94\81A\92è\8b`\82Ì\82Ý\81i\94ñ\8eÀ\91\95\92ñ\8b\9f\81j
+ ////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////
+ // \93à\95\94\83N\83\89\83X
+ ////////////////////////////////////////////////////////////////////////////////
+
+
+};
+
+#endif //INC_COutputWave
--- /dev/null
+// \8b\9e
+
+#include "CWaveData.h"
+
+#include <windows.h>
+#include <tchar.h>
+
+////////////////////////////////////////////////////////////////////////////////
+// \83R\83\93\83X\83g\83\89\83N\83^
+////////////////////////////////////////////////////////////////////////////////
+CWaveData::CWaveData()
+{
+ // Wave\83t\83H\81[\83}\83b\83g
+ m_WaveFormat.wFormatTag = WAVE_FORMAT_PCM;
+ m_WaveFormat.nChannels = 1;
+ m_WaveFormat.nSamplesPerSec = 22050;
+ m_WaveFormat.wBitsPerSample = 8;
+ m_WaveFormat.nBlockAlign = m_WaveFormat.wBitsPerSample / 8 * m_WaveFormat.nChannels;
+ m_WaveFormat.nAvgBytesPerSec = m_WaveFormat.nSamplesPerSec * m_WaveFormat.nBlockAlign;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// \83f\83X\83g\83\89\83N\83^
+////////////////////////////////////////////////////////////////////////////////
+CWaveData::~CWaveData()
+{
+ freeBuffer();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// \8f\89\8aú\89»
+////////////////////////////////////////////////////////////////////////////////
+void CWaveData::initialize()
+{
+ // \8c»\8fó\83t\83H\81[\83}\83b\83g\82Í\8c\88\82ß\82¤\82¿
+ m_WaveFormat.wFormatTag = WAVE_FORMAT_PCM;
+ m_WaveFormat.nChannels = 1;
+ m_WaveFormat.nSamplesPerSec = 22050;
+ m_WaveFormat.wBitsPerSample = 8;
+ m_WaveFormat.nBlockAlign = m_WaveFormat.wBitsPerSample / 8 * m_WaveFormat.nChannels;
+ m_WaveFormat.nAvgBytesPerSec = m_WaveFormat.nSamplesPerSec * m_WaveFormat.nBlockAlign;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// \83o\83b\83t\83@\82ð\8am\95Û
+////////////////////////////////////////////////////////////////////////////////
+bool CWaveData::allocBuffer(int in_BufferNumber, DWORD in_RecorMilliSecond)
+{
+ if(in_BufferNumber < 1 || in_RecorMilliSecond == 0){
+ return false;
+ }
+
+ if(m_WaveBuffers.empty()){
+ // free
+ if(!freeBuffer()){
+ return false;
+ }
+ }
+
+ for(int i = 0; i < in_BufferNumber; i++){
+ StructWaveBuffer tempWaveBuffer;
+ tempWaveBuffer.m_RecorMilliSecond = in_RecorMilliSecond;
+ tempWaveBuffer.m_BufferSize = m_WaveFormat.nAvgBytesPerSec * in_RecorMilliSecond / 1000;
+ tempWaveBuffer.m_pWaveBuffer = new char[tempWaveBuffer.m_BufferSize];
+
+ m_WaveBuffers.push_back(tempWaveBuffer);
+ }
+
+ // \93Ç\82Ý\8eæ\82è\83o\83b\83t\83@\82Æ\8f\91\82«\8d\9e\82Ý\83o\83b\83t\83@\82ð\8ew\92è\82µ\82Ä\82¨\82
+ m_ReadOfWaveBuffers = m_WaveBuffers.begin();
+ m_WriteOfWaveBuffers = m_WaveBuffers.begin();
+
+ return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// \83o\83b\83t\83@\82ð\89ð\95ú
+////////////////////////////////////////////////////////////////////////////////
+bool CWaveData::freeBuffer()
+{
+ if(!m_WaveBuffers.empty()){
+ WaveBufferTable::iterator tempIterator = m_WaveBuffers.begin();
+ while(tempIterator != m_WaveBuffers.end()){
+ delete tempIterator->m_pWaveBuffer;
+ tempIterator++;
+ }
+ }
+ return true;
+}
--- /dev/null
+// \8b\9e
+#ifndef INC_CWaveData
+#define INC_CWaveData
+
+
+#include <list>
+#include <Windows.h>
+
+
+// \83C\83\93\83N\83\8b\81[\83h\82Í\95K\82¸\95K\97v\82È\95¨\82¾\82¯
+// \93à\95\94\82Å\97\98\97p\82·\82é\82¾\82¯\82Ì\95¨\82Í\83\\81[\83X\82É\8bL\8fq
+
+// \8aÖ\90\94\96¼\82Í\83\8d\81[\83\8f\83L\83\83\83\81\83\8b\83P\81[\83X\82Æ\82·\82é
+
+
+// wave buffer struct
+struct StructWaveBuffer
+{
+ // \83o\83b\83t\83@\82Ö\82Ì\83|\83C\83\93\83^
+ char* m_pWaveBuffer;
+ // \98^\89¹\8e\9e\8aÔ [\83~\83\8a\95b]
+ DWORD m_RecorMilliSecond;
+ // \83o\83b\83t\83@\83T\83C\83Y [byte]
+ DWORD m_BufferSize;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// CWaveData
+// Wave\83f\81[\83^\82ð\88µ\82¤\83N\83\89\83X
+// \83o\83b\83t\83@\82Ì\8aÇ\97\9d\81i\8am\95Û\82Æ\89ð\95ú\81j\82ð\8ds\82¤
+// \83L\83\85\81[\82ð\97p\82¢\82Ä\83o\83b\83t\83@\8aÇ\97\9d\82ð\8ds\82¤
+////////////////////////////////////////////////////////////////////////////////
+class CWaveData
+{
+ ////////////////////////////////////////////////////////////////////////////////
+ // \83\81\83\93\83o\95Ï\90\94
+ ////////////////////////////////////////////////////////////////////////////////
+private:
+ // wave format
+ WAVEFORMATEX m_WaveFormat;
+
+
+ // typedef wave buffer table type
+ typedef std::list<StructWaveBuffer> WaveBufferTable;
+ // wave buffer table
+ WaveBufferTable m_WaveBuffers;
+
+ // read iterator
+ WaveBufferTable::iterator m_ReadOfWaveBuffers;
+ // write iterator
+ WaveBufferTable::iterator m_WriteOfWaveBuffers;
+
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // \83R\83\93\83X\83g\83\89\83N\83^
+ ////////////////////////////////////////////////////////////////////////////////
+public:
+ CWaveData();
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // \83f\83X\83g\83\89\83N\83^
+ ////////////////////////////////////////////////////////////////////////////////
+public:
+ ~CWaveData();
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // static\8aÖ\90\94\81A\83R\81[\83\8b\83o\83b\83N\8aÖ\90\94
+ ////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////
+ // \91\80\8dì\83\81\83\\83b\83h
+ ////////////////////////////////////////////////////////////////////////////////
+public:
+ // \8f\89\8aú\89»
+ void initialize();
+ // \83o\83b\83t\83@\82ð\8am\95Û
+ bool allocBuffer(int in_BufferNumber, DWORD in_RecorMilliSecond);
+ // \83o\83b\83t\83@\82ð\89ð\95ú
+ bool freeBuffer();
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // \91®\90«\83\81\83\\83b\83h
+ ////////////////////////////////////////////////////////////////////////////////
+public:
+ bool empty()
+ {
+ if(m_ReadOfWaveBuffers == m_WriteOfWaveBuffers){
+ return true;
+ }
+ return false;
+ }
+
+ // Wave\83t\83H\81[\83}\83b\83g\82Ö\82Ì\83|\83C\83\93\83^\82ð\8eæ\93¾\82·\82é
+ const WAVEFORMATEX* getWaveFormat()
+ {
+ return &m_WaveFormat;
+ }
+
+ // \93Ç\82Ý\8eæ\82è\83o\83b\83t\83@\97p\8aÖ\90\94
+ // Wave\83o\83b\83t\83@\82Ì\93Ç\82Ý\8eæ\82è\83|\83C\83\93\83^\82ð\8eæ\93¾\82·\82é
+ char* getReadBuffer()
+ {
+ // \83o\83b\83t\83@\82ª\8bó\82È\82çNULL\82ð\95Ô\82·
+ if(empty()){
+ return NULL;
+ }
+
+ return m_ReadOfWaveBuffers->m_pWaveBuffer;
+ }
+
+ // \8e\9f\82Ì\93Ç\82Ý\8eæ\82è\83o\83b\83t\83@\82ð\8eæ\93¾\82·\82é
+ char* nextReadBuffer()
+ {
+ // \83o\83b\83t\83@\82ª\8bó\82È\82çNULL\82ð\95Ô\82·
+ if(empty()){
+ return NULL;
+ }
+
+ m_ReadOfWaveBuffers++;
+ if(m_ReadOfWaveBuffers == m_WaveBuffers.end()){
+ m_ReadOfWaveBuffers = m_WaveBuffers.begin();
+ }
+ return m_ReadOfWaveBuffers->m_pWaveBuffer;
+ }
+
+ // \93Ç\82Ý\8d\9e\82Ý\83o\83b\83t\83@\83T\83C\83Y\82ð\8eæ\93¾\82·\82é
+ DWORD getReadBufferSize()
+ {
+ return m_ReadOfWaveBuffers->m_BufferSize;
+ }
+
+ // \8f\91\82«\8d\9e\82Ý\83o\83b\83t\83@\97p\8aÖ\90\94
+ // Wave\83o\83b\83t\83@\82Ì\8f\91\82«\8d\9e\82Ý\83|\83C\83\93\83^\82ð\8eæ\93¾\82·\82é
+ char* getWriteBuffer()
+ {
+ return m_WriteOfWaveBuffers->m_pWaveBuffer;
+ }
+
+ // \8e\9f\82Ì\8f\91\82«\8d\9e\82Ý\83o\83b\83t\83@\82ð\8eæ\93¾\82·\82é
+ char* nextWriteBuffer()
+ {
+ WaveBufferTable::iterator a_NextWriteOfWaveBuffer = m_WriteOfWaveBuffers;
+ a_NextWriteOfWaveBuffer++;
+ if(a_NextWriteOfWaveBuffer == m_WaveBuffers.end()){
+ a_NextWriteOfWaveBuffer = m_WaveBuffers.begin();
+ }
+ if(a_NextWriteOfWaveBuffer == m_ReadOfWaveBuffers){
+ // \8f\91\82«\8d\9e\82Ý\83|\83C\83\93\83^\82ª\93Ç\82Ý\8d\9e\82Ý\83|\83C\83\93\83^\82É\92Ç\82¢\82Â\82\82½\82ßNULL\82ð\95Ô\82·
+ return NULL;
+ }
+ m_WriteOfWaveBuffers = a_NextWriteOfWaveBuffer;
+ return m_WriteOfWaveBuffers->m_pWaveBuffer;
+ }
+
+ // \8f\91\82«\8d\9e\82Ý\83o\83b\83t\83@\83T\83C\83Y\82ð\8eæ\93¾\82·\82é
+ DWORD getWriteBufferSize()
+ {
+ return m_WriteOfWaveBuffers->m_BufferSize;
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // \83C\83e\83\8c\81[\83V\83\87\83\93
+ ////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////
+ // \8fó\91Ô
+ ////////////////////////////////////////////////////////////////////////////////
+
+ ////////////////////////////////////////////////////////////////////////////////
+ // \89\89\8eZ\8eq
+ ////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////
+ // \8f\83\90\88\89¼\91z\8aÖ\90\94\81A\92è\8b`\82Ì\82Ý\81i\94ñ\8eÀ\91\95\92ñ\8b\9f\81j
+ ////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////
+ // \93à\95\94\83N\83\89\83X
+ ////////////////////////////////////////////////////////////////////////////////
+
+
+};
+
+#endif //INC_CWaveData
#include <iostream>
#include <string>
+CClientModel* g_pointer;
+
+void DataFullCallBackFunction(WAVEHDR* io_WaveHeader)
+{
+ /*
+ if(!g_pointer->m_WaveDataOfInput.empty()){
+ // \83R\83s\81[\8f\80\94õ
+ const char* p1 = g_pointer->m_WaveDataOfInput.getReadBuffer();
+ char* p2 = g_pointer->m_WaveDataOfOutput.getWriteBuffer();
+ const char* const p1_end = p1 + g_pointer->m_WaveDataOfInput.getReadBufferSize();
+ const char* const p2_end = p2 + g_pointer->m_WaveDataOfOutput.getWriteBufferSize();
+ while(p1 != p1_end || p2 != p2_end){
+ *p2 = *p1;
+ p1++;
+ p2++;
+ }
+ g_pointer->m_WaveDataOfInput.nextReadBuffer();
+ g_pointer->m_WaveDataOfOutput.nextWriteBuffer();
+ g_pointer->m_OutputWave.start();
+ }
+ */
+}
+
////////////////////////////////////////////////////////////////////////////////
// constructor
////////////////////////////////////////////////////////////////////////////////
CClientModel::CClientModel()
{
+ g_pointer = this;
}
////////////////////////////////////////////////////////////////////////////////
bool CClientModel::initialize()
{
m_Connection.initialize();
+
+ // \83o\83b\83t\83@\83T\83C\83Y1000\81A\98^\89¹\8e\9e\8aÔ100ms
+ m_WaveDataOfInput.initialize();
+ m_WaveDataOfInput.allocBuffer(1000, 1600);
+
+ m_WaveDataOfOutput.initialize();
+ m_WaveDataOfOutput.allocBuffer(1000, 1600);
+
+ // \8c»\8fóbuffer_size\82ª160\82Ì\94{\90\94\82Å\82È\82¯\82ê\82Î\81A\88³\8fk\82Ì\8aÖ\8cW\8fã\82»\82Ì\8aÔ\82É\83m\83C\83Y\82ª\93ü\82é
+ // buffer_size = 22050 * bitrate / 8 * channel * time / 1000;
+ // buffer_size \82ª160\82Ì\94{\90\94
+
+ // \88ê\94Ê\93I\82É\82Í\83o\83b\83t\83@\82Í\98A\91±\82µ\82Ä\82¢\82é\82½\82ß\81A\8dD\82«\82È\88Ê\92u\82Å\90Ø\82é\82±\82Æ\82ª\89Â\94\\82¾\82ª\81A\8c»\8fó\82Ì
+ // \8dì\82è\82Å\82Í\83o\83b\83t\83@\82ð\83\8a\83\93\83O\83o\83b\83t\83@\82Æ\82µ\82Ä\95ª\8a\84\82µ\82Ä\82¢\82é\82½\82ß\81A\8dD\82«\82È\88Ê\92u\82Å\90Ø\82é\82±\82Æ\82ª\82Å\82«\82È\82¢\81B
+ // \82æ\82Á\82Ä\81A\8d¡\8cã\82Í\83o\83b\83t\83@\82ð\8dD\82«\82È\8aÔ\8au\82Å\90Ø\82é\82±\82Æ\82ª\89Â\94\\82È\8dì\82è\82É\82·\82é\95K\97v\82ª\82 \82é\81B
+
+ m_InputWave.initialize();
+ m_InputWave.setWaveData(&m_WaveDataOfInput);
+ m_InputWave.setDataFullCallBack(&DataFullCallBackFunction);
+ if(!m_InputWave.open()){
+ return 0;
+ }
+
+ m_OutputWave.initialize();
+ m_OutputWave.setWaveData(&m_WaveDataOfOutput);
+ if(!m_OutputWave.open()){
+ return 0;
+ }
return true;
}
// \83\8d\83O\83C\83\93\8f\88\97\9d
else if(a_rEvent == "LOGIN"){
m_Connection.login(m_LoginName.c_str());
+ m_InputWave.start();
+ m_OutputWave.start();
}
// \83\8d\83O\83A\83E\83g
else if(a_rEvent == "LOGOUT"){
+ m_InputWave.stop();
+ m_OutputWave.stop();
m_Connection.logout();
}
// \8dÀ\95W\8eæ\93¾
m_Events.pop_front();
}
- // \89¹\90º\82ð\8d\87\90¬
+ // \89¹\90º\93ü\97Í
+
+ // \83f\81[\83^\91\97\90M\81i\88ê\94Ê\83R\83}\83\93\83h\81A\83A\83N\83V\83\87\83\93\83R\83}\83\93\83h\81A\89¹\90º\81j
+
+ // \89¹\90º\8fo\97Í
+ if(!m_WaveDataOfInput.empty()){
+ std::cout << "not empty" << std::endl;
+ // \83R\83s\81[\8f\80\94õ
+ const char* p1 = m_WaveDataOfInput.getReadBuffer();
+ char* p2 = m_WaveDataOfOutput.getWriteBuffer();
+ const char* const p1_end = p1 + m_WaveDataOfInput.getReadBufferSize();
+ const char* const p2_end = p2 + m_WaveDataOfOutput.getWriteBufferSize();
+ while(p1 != p1_end || p2 != p2_end){
+ *p2 = *p1;
+ p1++;
+ p2++;
+ }
+ m_WaveDataOfInput.nextReadBuffer();
+ m_WaveDataOfOutput.nextWriteBuffer();
+ m_OutputWave.start();
+ }
+
- // \8eæ\93¾\83R\83}\83\93\83h\82É\91Î\82µ\82Ä\83f\81[\83^\91\97\90M
return true;
}
+
#include "../../common/Data.h"
//#include "../../common/CConnection.h"
#include "../../common/CClientConnection.h"
+#include "../../common/CInputWave.h"
+#include "../../common/COutputWave.h"
+#include "../../common/CWaveData.h"
#include <list>
// \92Ê\90M\83N\83\89\83X
CClientConnection m_Connection;
+public:
+ // \89¹\90º\83N\83\89\83X
+ CInputWave m_InputWave;
+ COutputWave m_OutputWave;
+ // \89¹\90º\83f\81[\83^
+ // \93ü\97Í\97p
+ CWaveData m_WaveDataOfInput;
+ // \8fo\97Í\97p
+ CWaveData m_WaveDataOfOutput;
+
std::list<std::string> m_Events;
// \83\8d\83O\83C\83\93\96¼
////////////////////////////////////////////////////////////////////////////////
// static\8aÖ\90\94\81A\83R\81[\83\8b\83o\83b\83N\8aÖ\90\94
////////////////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////////////////
+
+ ////////////////////////////////////////////////////////////////////////////////
// \91\80\8dì\83\81\83\\83b\83h
////////////////////////////////////////////////////////////////////////////////
public:
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="..\..\common\CClientConnection.cpp" />
+ <ClCompile Include="..\..\common\CInputWave.cpp" />
+ <ClCompile Include="..\..\common\COutputWave.cpp" />
<ClCompile Include="..\..\common\CSocket.cpp" />
<ClCompile Include="..\..\common\CThread.cpp" />
+ <ClCompile Include="..\..\common\CWaveData.cpp" />
<ClCompile Include="CClient.cpp" />
<ClCompile Include="CClientModel.cpp" />
<ClCompile Include="CClientUI.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\..\common\CClientConnection.h" />
+ <ClInclude Include="..\..\common\CInputWave.h" />
+ <ClInclude Include="..\..\common\COutputWave.h" />
<ClInclude Include="..\..\common\CRingBuffer.h" />
<ClInclude Include="..\..\common\CSocket.h" />
<ClInclude Include="..\..\common\CThread.h" />
+ <ClInclude Include="..\..\common\CWaveData.h" />
<ClInclude Include="..\..\common\Data.h" />
<ClInclude Include="..\..\common\Environment.h" />
<ClInclude Include="CClient.h" />