实时音频采集播放时，一个奇怪的问题，大家能帮我分析一下原因嘛

[Boy_Vc]

我的采集的数据放入一个buffer，CaptureBuffer，播放时，不是从这个缓冲去取数据，而是，从另一个缓冲取，testBuffer（该buffer是同一个工程中其他文件中定义的全局变量），读数据，并且中间没有任何途径使得CaptureBuffer中数据传入testBuffer，（实际上我只是定义了testBuffer，然后在采集播放文件中，作为外部变量引用一下），但奇怪的是我居然也能听到我采集的声音。
我试了一下， 如果把testBuffer直接定义在采集播放文件中，没问题，很正常，听不到声音。
我用的是wave API函数采集播放的。
谢谢！

[Boy_Vc]

mfc建立一个对话框对象，生成一个实例运行采集播放程序：
CPS_PhoneDlg.cpp//注意这里只列了与采集播放有关的函数
/////////////////////////////////////////////////////////////////////////////
// CPS_PhoneDlg dialog

char× recvBuffer；

ATOM AuObjRegisterClass(HINSTANCE hInstance);
HWND MyInitInstance(HINSTANCE hInstance, int nCmdShow);


CPS_PhoneDlg::CPS_PhoneDlg(CWnd* pParent /*=NULL*/)
: CDialog(CPS_PhoneDlg::IDD, pParent)
{
//{{AFX_DATA_INIT(CPS_PhoneDlg)
// NOTE: the ClassWizard will add member initialization here
//}}AFX_DATA_INIT
// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

// chSend = NULL;
// chRecv = NULL;

AuObjRegisterClass(AfxGetInstanceHandle());//注册一个窗口
// Perform application initialization:
//运行这个实例的消息映射
if (!(ChildWinObj = MyInitInstance (AfxGetInstanceHandle(),0)))
MessageBox("Error in initInstance",NULL,MB_OK);

}


CPS_Phone2.cpp
#include "stdafx.h"
#include <windowsx.h>
#include "PS_Phone.h"


#include "winau.h"
#include "socketau.h"

#define MAX_LOADSTRING 100

// Global Variables:

HINSTANCE hInst; // current instance
TCHAR szTitle[MAX_LOADSTRING] = "pitchscale"; // The title bar text
TCHAR szWindowClass[MAX_LOADSTRING] ="pitchscale"; // The title bar text
BOOL pratecaps,pitchcaps = FALSE;
PMHANDLE myPMhdl = NULL;

//
extern bool g_bTesting;

// Forward declarations of functions included in this code module:
ATOM AuObjRegisterClass(HINSTANCE hInstance);
HWND InitInstance(HINSTANCE, int);
LRESULT CALLBACK MyAudioObjWndProc(HWND, UINT, WPARAM, LPARAM);


/*----------------------------------------------------------------
For audio test purpose, creating a single buffer used all the time
-----------------------------------------------------------------*/
unsigned char TestBuffer[AUOUTBUFSIZE];

// FUNCTION: MyRegisterClass()
//
// PURPOSE: Registers the window class.

ATOM AuObjRegisterClass(HINSTANCE hInstance)
{
WNDCLASSEX wcex;

wcex.cbSize = sizeof(WNDCLASSEX);

wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = (WNDPROC)MyAudioObjWndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = NULL;
wcex.hCursor = NULL;
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wcex.lpszMenuName = (LPCSTR)NULL;
wcex.lpszClassName = szWindowClass;
wcex.hIconSm = NULL;

return RegisterClassEx(&wcex);
}

//
// FUNCTION: InitInstance(HANDLE, int)
//
// PURPOSE: Saves instance handle and creates main window
//
// COMMENTS:
//
// In this function, we save the instance handle in a global variable and
// create and display the main program window.
//
HWND MyInitInstance(HINSTANCE hInstance, int nCmdShow)
{
HWND hWnd=(HWND)FALSE;
static char szAppName[] = "AudioCore" ;

hInst = hInstance; // Store instance handle in our global variable

//hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
// CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);

hWnd = CreateWindow(szWindowClass, szTitle, NULL,
CW_USEDEFAULT,CW_USEDEFAULT,200,200, NULL, NULL, hInstance, NULL);

return hWnd;
}



LRESULT CALLBACK MyAudioObjWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static DWORD T1,Time;

switch (message)
{
case WM_CREATE:

PlayerStatus = PLAY_STATUS; //used for buffer state machine

InitCreate(hWnd);

InitAuOut();


AudioCaps=TRUE;//wave out is prepared

return 0 ;

case WM_DESTROY:

if(AudioCaps)
CloseAll(); //CloseAll() should not be called by destructor

if (pWaveOutHdr) GlobalFreePtr(pWaveOutHdr);
if (pWaveOutHdr2) GlobalFreePtr(pWaveOutHdr2);

pWaveOutHdr = pWaveOutHdr2 = NULL;
//PostQuitMessage(0);
break;

case MM_WOM_CLOSE:
MMWomClose();
return 0;

case MM_WOM_DONE: //the wave out buffer is retured,
// which has been played
{
LPWAVEHDR pw=(LPWAVEHDR)lParam;
MMWomDone(wParam,lParam);
}
return 0;

case MM_WOM_OPEN://wave out device is opened

MMWomOpen(wParam,lParam);

//force size to make believe audio buffer
// control routine, that were are working
//with a new buffer
dwDecBufLen = AUOUTBUFSIZE;

//placed here, bcause we want to start the play back right now

PlaceBufferInLoop();
Time = (unsigned long)(((float)(AUOUTBUFSIZE)/(float)(2*2*44.1))/2);
Sleep(Time); // wait that audiodriver post filled buffer signal in queue
InitAuIn();

return 0;

case MM_WIM_DATA://captured data in wave in buffer already
MMWimData(wParam,lParam);
return 0 ;

case MM_WIM_OPEN:
MMWimOpen(wParam,lParam);
return 0 ;
case MM_WIM_CLOSE:// wave in device is closed
MMWimClose();
return 0 ;

default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}


wavau.cpp

#include "stdafx.h"
#include <windows.h>
#include <windowsx.h>

#include <stdio.h>
#include <math.h>

#include <mmsystem.h>

#include "WinAu.h"
//#include "multhread_send_activex.h"


#define BUFFER_RUNNING 1
#define BUFFER_DEAD 0

#define INIT_VALUE 0
double pi = 3.141592653;



FILE *fplayfile,*frecfile;
BOOL AudioCaps=TRUE;
HWND hParentWnd;
FILE *f1,*f2;


int PlayerStatus=INIT_STATUS;
int SemiToneValue ;

extern PMHANDLE myPMhdl;

//extern varaible for net transfering
//recvBuffer是我的播放数据缓冲区，它是定义在PS_PhoneDlg.cpp中的，char× recvBuffer;
extern char recvBuffer[1];//buffer have been received from net
char test[AUOUTBUFSIZE];
extern bool g_bSendEnable;
extern SOCKET* g_sSend;
extern SOCKADDR_IN* g_RemoteAddr;
int nWavOutOffset = 0;


BOOL MMWimData(WORD wParam, LONG lParam);
BOOL MMWimClose(void);


/****** environnement of low level audio API *********/
BOOL bRecording,bEnding,bTerminating;
int CurrType;
BYTE action;
BYTE WaveOutInit,WaveInInit; // indicate In/out Device status
//13 BYTE flagbuf;
char *pBuffer1,*pBuffer2,*pBuffer3,*pMyInBuffer;
char *pOutBuffer,*pOutBuffer1,*pOutBuffer2; // waveOut buffers
FILE *fin;
char szOpenError[10] ;// = "Err open wave device";
DWORD dwDecBufLen;
HWAVEOUT hWaveOut;
HWAVEIN hWaveIn;
LPWAVEHDR pWaveHdr1,pWaveHdr2,pWaveHdr3;
LPWAVEHDR pWaveHdr;
LPWAVEHDR pWaveOutHdr,pWaveOutHdr2;
PCMWAVEFORMAT pcm;
char FName[256];
// HANDLE hDecEvent;
BOOL PlayBackEnd=FALSE;
/*****************************************************/

[Boy_Vc]

void MMWomClose(void)
{
MMRESULT res1,res2; //ct

res1 = waveOutUnprepareHeader(hWaveOut, pWaveOutHdr, sizeof(WAVEHDR));
if( res1 != MMSYSERR_NOERROR ) MessageBox(NULL,"Unprepare header 0 failed\r\n","MMWomClose",MB_OK); //ct

res2 = waveOutUnprepareHeader(hWaveOut, pWaveOutHdr2, sizeof(WAVEHDR));
if( res2 != MMSYSERR_NOERROR ) MessageBox(NULL,"Unprepare header 2 failed\r\n","MMWomClose",MB_OK); //ct

Sleep(0); //give back hand to other threads
Sleep(50); // wait audio thread to release memory

if (pOutBuffer!=NULL) GlobalFreePtr(pOutBuffer);
if (pOutBuffer1!=NULL) GlobalFreePtr(pOutBuffer1);
if (pOutBuffer2!=NULL) GlobalFreePtr(pOutBuffer2);

if (pWaveOutHdr) GlobalFreePtr(pWaveOutHdr);
if (pWaveOutHdr2) GlobalFreePtr(pWaveOutHdr2);
pOutBuffer = pOutBuffer1 = pOutBuffer2 = NULL;
pWaveOutHdr=pWaveOutHdr2=0;
WaveOutInit=0;

return;

} // MMWomClose


/****************************************************************************************************/
// Function : CloseAll()
//
//--- close all opened device
/****************************************************************************************************/

CloseAll()
{
MMRESULT res1,res2;


if(WaveInInit&&(hWaveIn!=NULL))
{
bTerminating = TRUE;

MSG Msg;
Msg.message = NULL;

res1 = waveInStop(hWaveIn); Sleep(100);
while (PeekMessage(&Msg,hParentWnd,MM_WIM_DATA,MM_WIM_DATA,PM_REMOVE))
MMWimData(Msg.wParam,Msg.lParam);

res1 = waveInReset(hWaveIn); Sleep(100);
bEnding = TRUE;


while( (res2=waveInClose(hWaveIn))!= MMSYSERR_NOERROR )
{
res1 = waveInReset(hWaveIn);
MessageBox(NULL,"Audio In not properly closed...\r\n","CloseAll",MB_OK);
}

// there is a call back on this function !!
if( res1 == MMSYSERR_NOERROR ) // do it only if reset was accepted
GetMessage( &Msg,hParentWnd,MM_WIM_CLOSE,MM_WIM_CLOSE);
//if( Msg.message != MM_WIM_CLOSE ) MessageBox(NULL,"Picked a msg != from MM_WIM_CLOSE \r\n","CloseAll",MB_OK); //c14

hWaveIn=NULL;
MMWimClose();
WaveInInit=0;
}

if(WaveOutInit&&(hWaveOut!=NULL)) { //c104
bTerminating = TRUE;
bEnding = TRUE;

// there is a call back on this function !!
res1 = waveOutReset(hWaveOut); //#define MMSYSERR_NOERROR 0


MSG MsgOut;
MsgOut.message = NULL;


if( res1 != MMSYSERR_NOERROR )
MessageBox(NULL,"Reset not properly done \r\n","CloseAll",MB_OK);
while (PeekMessage( &MsgOut,hParentWnd,MM_WOM_DONE,MM_WOM_DONE,PM_REMOVE))
Sleep(50);

//if( Msg.message == MM_WOM_DONE ) MessageBox(NULL,"Picked MM_WOM_DONE msg \r\n","CloseAll",MB_OK); //c14
Sleep(50); // wait
res1 = waveOutReset(hWaveOut); //#define MMSYSERR_NOERROR 0

MMWomClose(); //c27 added here because the call back is not
// working in this case
while( (res2=waveOutClose(hWaveOut))!= MMSYSERR_NOERROR )
{
res1 = waveOutReset(hWaveOut);
MessageBox(NULL,"Audio Out not properly closed","CloseAll",MB_OK);
}

// there is a call back on this function !!
MsgOut.message = NULL;
if( res2 == MMSYSERR_NOERROR ) // do it only if reset was accepted
PeekMessage( &MsgOut,hParentWnd,MM_WOM_CLOSE,MM_WOM_CLOSE,PM_REMOVE);
//if( Msg.message == MM_WOM_CLOSE ) MessageBox(NULL,"Picked MM_WOM_CLOSE msg \r\n","CloseAll",MB_OK); //c14
hWaveOut = NULL;

WaveOutInit=0; //w23
}


return TRUE;
} // CloseAll


/****************************************************************************************************/
// Function : InitAuOut
/****************************************************************************************************/


DWORD InitAuOut()
{

if (WaveOutInit==1) return NULL;

//--- set format of recording
pcm.wf.wFormatTag = WAVE_FORMAT_PCM;
pcm.wf.nChannels = 2;
pcm.wf.nSamplesPerSec = 44100;
pcm.wf.nAvgBytesPerSec = 176400; //16000;

pcm.wf.nBlockAlign = 4;
pcm.wBitsPerSample = 16;
// 8000Hz 16bit resolution


//16--- prepare pOutBuffer
pOutBuffer = (char *)GlobalAllocPtr(GHND|GMEM_SHARE,AUOUTBUFSIZE);
if (pOutBuffer==NULL) return NULL;
memset(pOutBuffer,0,AUOUTBUFSIZE);

pWaveOutHdr =(LPWAVEHDR)GlobalAllocPtr(GHND|GMEM_SHARE,sizeof(WAVEHDR));
if (pWaveOutHdr==NULL)
{ GlobalFreePtr(pOutBuffer); pOutBuffer=NULL; return NULL; }

//16--- prepare pOutBuffer1
pOutBuffer1 = (char *)GlobalAllocPtr(GHND|GMEM_SHARE,AUOUTBUFSIZE);
if (pOutBuffer1==NULL)
{
GlobalFreePtr(pWaveOutHdr); pWaveOutHdr = NULL;
GlobalFreePtr(pOutBuffer); pOutBuffer=NULL; return NULL;
}
memset(pOutBuffer1,0,AUOUTBUFSIZE);

pWaveOutHdr2 =(LPWAVEHDR)GlobalAllocPtr(GHND|GMEM_SHARE,sizeof(WAVEHDR));
if (pWaveOutHdr==NULL)
{
GlobalFreePtr(pOutBuffer1); pOutBuffer1=NULL;
GlobalFreePtr(pWaveOutHdr); pWaveOutHdr = NULL;
GlobalFreePtr(pOutBuffer); pOutBuffer=NULL; return NULL;
}

action=8;
//--- Open Wave Out device
if(waveOutOpen(&hWaveOut,WAVE_MAPPER,(struct tWAVEFORMATEX *)&pcm.wf,(UINT)hParentWnd,0L,CALLBACK_WINDOW))
{
MessageBeep(MB_OK | MB_ICONEXCLAMATION);
GlobalFreePtr(pOutBuffer1); pOutBuffer1 = NULL;
GlobalFreePtr(pWaveOutHdr2); pWaveOutHdr2 = NULL;
GlobalFreePtr(pOutBuffer); pOutBuffer = NULL;
GlobalFreePtr(pWaveOutHdr); pWaveOutHdr = NULL;
WaveOutInit = 0;
return NULL;
}

//Initialise the receive buffer from net
// memset(recvBuffer,0,sizeof(recvBuffer));

dwDecBufLen = 0;

WaveOutInit = 1;
return 0;
} // void InitAuOut()

/****************************************************************************************************/
// Function : InitCreate
/****************************************************************************************************/

//Initialise the params
void InitCreate(HWND h)
{

CurrType=2;
dwDecBufLen=0;
WaveOutInit= WaveInInit = 0;
// pBuffer1 = pBuffer2 = pBuffer3 = NULL; //c27
pOutBuffer = pOutBuffer1=pOutBuffer2=NULL;
pBuffer1,pBuffer2,pBuffer3,pMyInBuffer = NULL;
hParentWnd=h;
bTerminating=FALSE;
} // InitCreate


/****************************************************************************************************/
// Function : MMWomOpen
//
// case MM_WOM_OPEN, callback by window, when the output device be opened
/****************************************************************************************************/

MMWomOpen(WPARAM wParam, LPARAM lParam)
{

if ( (action<2) || (!WaveOutInit)) return 0;

// set and prepare wave 1st output header
pWaveOutHdr->lpData = pOutBuffer;
pWaveOutHdr->dwBufferLength = 0;
pWaveOutHdr->dwBytesRecorded = 0L;
pWaveOutHdr->dwFlags = 0; // WHDR_DONE;
pWaveOutHdr->lpNext = NULL;
pWaveOutHdr->dwLoops = WHDR_BEGINLOOP | WHDR_ENDLOOP ;//circle buffer
pWaveOutHdr->reserved= 0L;

// set and prepare wave 1st output header
memcpy(pWaveOutHdr2,pWaveOutHdr,sizeof(WAVEHDR)); // this operation must be done before preparation andf write op.
pWaveOutHdr2->lpData = pOutBuffer1;


bEnding = FALSE;

return TRUE;
} // MMWomOpen

[Boy_Vc]

void MMWomDone(WPARAM wParam, LPARAM lParam)
{
LPWAVEHDR pw=(LPWAVEHDR)lParam;

waveOutUnprepareHeader(hWaveOut, pw, sizeof(WAVEHDR));

if( dwDecBufLen > AUOUTBUFSIZE )
Sleep(1);
while((dwDecBufLen < AUOUTBUFSIZE )&&(PlayerStatus == PLAY_STATUS))
{
Sleep(0);
Sleep(13);
}

if( (PlayerStatus != PLAY_STATUS) && (dwDecBufLen==0) )
{
pw->dwUser=BUFFER_DEAD;
return;
}
pw->dwBufferLength = dwDecBufLen;
pw->dwLoops = 0;
pw->dwBytesRecorded = 0L;
pw->dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP; // WHDR_DONE;
pw->lpNext = NULL;
pw->reserved = 0L;

//recvBuffer即为外部引用的变量，定义在PS_PhoneDlg.cpp中
memcpy(pw->lpData,recvBuffer+nWavOutOffset,dwDecBufLen);
nWavOutOffset += dwDecBufLen;
nWavOutOffset %= (2*AUOUTBUFSIZE);
// now, applying special processing

waveOutPrepareHeader(hWaveOut,pw,sizeof(WAVEHDR));
waveOutWrite(hWaveOut,pw,sizeof(WAVEHDR));


}// MMWomDone() end

void WaitBufferToDie(void)
{
while( pWaveOutHdr->dwUser != BUFFER_DEAD )
Sleep(20);
while( pWaveOutHdr2->dwUser != BUFFER_DEAD )
Sleep(20);

Sleep(1);
}


void PlaceBufferInLoop(void)
{
//now prepare empty buffer and pass them to audio driver
pWaveOutHdr->dwBufferLength = pWaveOutHdr2->dwBufferLength = AUOUTBUFSIZE;

//clean buffers content before re-launching playback
memset(pWaveOutHdr->lpData,0,AUOUTBUFSIZE);
memset(pWaveOutHdr2->lpData,0,AUOUTBUFSIZE);

pWaveOutHdr->dwUser=BUFFER_RUNNING;
pWaveOutHdr2->dwUser=BUFFER_RUNNING;

if( MMSYSERR_NOERROR != waveOutPrepareHeader(hWaveOut, pWaveOutHdr, sizeof(WAVEHDR)))
MessageBeep(MB_OK | MB_ICONEXCLAMATION);
if( MMSYSERR_NOERROR != waveOutWrite(hWaveOut, pWaveOutHdr, sizeof(WAVEHDR)) )
MessageBeep(MB_OK | MB_ICONEXCLAMATION);


if( MMSYSERR_NOERROR != waveOutPrepareHeader(hWaveOut, pWaveOutHdr2, sizeof(WAVEHDR)))
MessageBeep(MB_OK | MB_ICONEXCLAMATION);
if( MMSYSERR_NOERROR != waveOutWrite(hWaveOut, pWaveOutHdr2, sizeof(WAVEHDR)))
MessageBeep(MB_OK | MB_ICONEXCLAMATION);

}


DWORD InitAuIn(void)
{
int i;

// alloc 2 headers of buffer
pWaveHdr1 =(LPWAVEHDR)GlobalAllocPtr(GHND|GMEM_SHARE,sizeof(WAVEHDR));
pWaveHdr2 =(LPWAVEHDR)GlobalAllocPtr(GHND|GMEM_SHARE,sizeof(WAVEHDR));


//--- alloc memory for buffer 1,2 which will be passed to the Input Device in MMWimOpen

pBuffer1 =(char *)GlobalAllocPtr(GHND|GMEM_SHARE,AUINBUFSIZE);
if(pBuffer1 == NULL) {
MessageBeep(MB_ICONEXCLAMATION);
return TRUE;
}
pBuffer2 =(char *)GlobalAllocPtr(GHND|GMEM_SHARE, AUINBUFSIZE);
if(pBuffer2 == NULL) {
GlobalFreePtr(pBuffer1);
MessageBeep(MB_ICONEXCLAMATION);
return TRUE;
}

pMyInBuffer =(char *)GlobalAllocPtr(GHND|GMEM_SHARE,AUINBUFSIZE);
if(pMyInBuffer == NULL) {
GlobalFreePtr(pBuffer1);
GlobalFreePtr(pBuffer2);
//GlobalFreePtr(pBuffer3);
MessageBeep(MB_ICONEXCLAMATION);
return TRUE;
}

//if necessary
pcm.wf.wFormatTag = WAVE_FORMAT_PCM;
pcm.wf.nChannels = 2;
pcm.wf.nSamplesPerSec = 44100;
pcm.wf.nAvgBytesPerSec = 176400;

pcm.wf.nBlockAlign = 4;
pcm.wBitsPerSample = 16;

if (hWaveIn==NULL)
if(i=waveInOpen(&hWaveIn,WAVE_MAPPER,(struct tWAVEFORMATEX *)&pcm.wf,(UINT)hParentWnd, 0L,(LONG) CALLBACK_WINDOW))
{ // Wave Device opening fails, release allocated memory
GlobalFreePtr(pBuffer1);
GlobalFreePtr(pBuffer2);
GlobalFreePtr(pMyInBuffer);
//13 flagbuf=0;
MessageBeep(MB_ICONEXCLAMATION);
MessageBox(hParentWnd, "waveInOpen error", "RecBegin", MB_ICONEXCLAMATION | MB_OK);
return TRUE;
} // if(i=waveInOpen
WaveInInit=TRUE;
return TRUE;

}


BOOL MMWimOpen(WPARAM wParam, LPARAM lParam)
{
MMRESULT result;

//----------------------------------------------------------------
// prepare first data buffer, and add into wavein device
pWaveHdr1->lpData = pBuffer1;
pWaveHdr1->dwBufferLength = AUINBUFSIZE;
pWaveHdr1->dwBytesRecorded = 0L;
pWaveHdr1->dwUser = 0L;

pWaveHdr1->dwFlags = 0L;
pWaveHdr1->dwLoops = 1L;
pWaveHdr1->lpNext = NULL;
pWaveHdr1->reserved = 0L;

*pWaveHdr2=*pWaveHdr1; // ensure header content copy from the 1st header



result=waveInPrepareHeader(hWaveIn, pWaveHdr1, sizeof(WAVEHDR));
result=waveInAddBuffer(hWaveIn, pWaveHdr1, sizeof(WAVEHDR));

//----------------------------------------------------------------
// prepare second data buffer, and add into wavein device
pWaveHdr2->lpData = (char *)pBuffer2;
pWaveHdr2->dwFlags = 0l;

result=waveInPrepareHeader(hWaveIn, pWaveHdr2, sizeof(WAVEHDR));
result=waveInAddBuffer(hWaveIn, pWaveHdr2, sizeof(WAVEHDR));

//----------------------------------------------------------------

// start recording
bRecording = TRUE;
bEnding = FALSE;
//dwDataLength=0;
waveInStart(hWaveIn);

return TRUE;
} // MMWimOpen

BOOL MMWimData(WORD wParam, LONG lParam)
{

int poss=0;
int CountRec=0;


//---- Get the data pointer of the waveHdr, copy it to a buffer and then
//--- add the used buffer to the device again
pWaveHdr =(LPWAVEHDR)lParam;
char *pb = pWaveHdr->lpData;


if( bEnding ) return FALSE;

if( (!WaveInInit)|| !hWaveIn )
{
//PostMessage(hwnd,MM_WIM_DATA,wParam,lParam);
return FALSE;
}

memcpy(pMyInBuffer,pb,pWaveHdr->dwBytesRecorded); //01

if( bTerminating ) return FALSE;

// add in used data buffer into device again
pWaveHdr->dwBufferLength = AUINBUFSIZE;
pWaveHdr->dwBytesRecorded = 0L;
pWaveHdr->dwUser = 0L;
waveInAddBuffer(hWaveIn, pWaveHdr, sizeof(WAVEHDR));

return TRUE;
} // MMWimData



BOOL MMWimClose(void)
{
// close recording action and clear data buffer
//c27 waveInUnprepareHeader can't be called after WaveInClose ...
//waveInUnprepareHeader(hWaveIn, pWaveHdr1, sizeof(WAVEHDR));
if( pBuffer1 ) GlobalFreePtr(pBuffer1);

//waveInUnprepareHeader(hWaveIn, pWaveHdr2, sizeof(WAVEHDR));
if( pBuffer2 ) GlobalFreePtr(pBuffer2);

//waveInUnprepareHeader(hWaveIn, pWaveHdr3, sizeof(WAVEHDR));
if( pBuffer3 ) GlobalFreePtr(pBuffer3);
if( pMyInBuffer) GlobalFreePtr(pMyInBuffer);


pBuffer1 = pBuffer2 = pBuffer3 = pMyInBuffer = NULL;
bRecording = FALSE;
WaveInInit = 0;

return TRUE;
} // MMWimClose()

//------------------------------------


wavau.h
#ifndef WinAu_H_
#define WinAu_H_

#include <mmsystem.h>

// for audio plaback adjustment
#define AUOUTBUFSIZE 0x900 * 10 //(130,6.. ms )
#define AUINBUFSIZE AUOUTBUFSIZE

// coming definition void for pacemaker plugin usage
// Defines How many samples are processed at a time

#define SAMPLECHUNK 144
// Input buffer for reading samples (note that one sample occupies 4 bytes)
#define INBUFSIZE (SAMPLECHUNK * 4)


#define OUTBUFSIZE (INBUFSIZE)

#define PLAY_STATUS -1
#define INIT_STATUS 3


//
// Global variables
//

extern int PlayerStatus;
extern BOOL AudioCaps;
extern LPWAVEHDR pWaveOutHdr;
extern LPWAVEHDR pWaveOutHdr2;
extern DWORD dwDecBufLen;


//
// Function prototypes
//
void InitCreate(HWND h);
DWORD InitAuOut();
BOOL CloseAll();
void MMWomClose(void);
void MMWomDone(WPARAM wParam, LPARAM lParam);
BOOL MMWomOpen(WPARAM wParam, LPARAM lParam);
void PlaceBufferInLoop(void);
DWORD InitAuIn(void);
BOOL MMWimData(WORD wParam, LONG lParam);
BOOL MMWimOpen(WPARAM wParam, LPARAM lParam);
BOOL MMWimClose(void);

//pitch_shift function
void PShiftAudioSignal(short * bufferToProcessPtr,int ItsLength,int SemiToneVal);


#endif//winau_H_

[lcp]

能不能把source code贴上来呀？
比较容易分析。

[gzl2000]

等

[lcp]

搂主：
您好！

请把出错的文件的源代码，和出错提示贴出来，一起看看。

做项目是很辛苦的，尤其是调试阶段，互相支持吧。
Lcp