g723_oal_win32.cpp

windows环境下利用IPP库的例子代码

		rt.top+=15;
		rt.bottom+=15;
	}
}

int dtxEnable(HMENU h)
{
	CheckMenuItem(g_hDtxMenu, IDM_SETTINGS_DTXON, MF_CHECKED);
	CheckMenuItem(g_hDtxMenu, IDM_SETTINGS_DTXOFF, MF_UNCHECKED);
	g_dtxEnable=1;
	g_propertiesDisplayed=0;
	return(1);
}

int dtxDisable(HMENU h)
{
	CheckMenuItem(g_hDtxMenu, IDM_SETTINGS_DTXON, MF_UNCHECKED);
	CheckMenuItem(g_hDtxMenu, IDM_SETTINGS_DTXOFF, MF_CHECKED);
	g_dtxEnable=0;
	g_propertiesDisplayed=0;
	return(1);
}

int setBitrate53kbps(HMENU h)
{
	CheckMenuItem(g_hBitrateMenu, IDM_SETTINGS_53KBPS, MF_CHECKED);
	CheckMenuItem(g_hBitrateMenu, IDM_SETTINGS_63KBPS, MF_UNCHECKED);
	g_bitrate=IPP_SPCHBR_5300;
	g_propertiesDisplayed=0;
	return(1);
}

int setBitrate63kbps(HMENU h)
{
	CheckMenuItem(h, IDM_SETTINGS_53KBPS, MF_UNCHECKED);
	CheckMenuItem(h, IDM_SETTINGS_63KBPS, MF_CHECKED);
	g_bitrate=IPP_SPCHBR_6300;
	g_propertiesDisplayed=0;
	return(1);
}

/* Callback for CPU utilization display */
VOID CALLBACK PerfDisplayTimer(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
{
	if (idEvent==PERF_TIMER_ID)
	{
		ShowPerformance(hwnd);

		if (!g_propertiesDisplayed)
		{
			g_propertiesDisplayed=1;
			DisplayStreamProperties(g_filename,g_dtxEnable,g_bitrate);
			if (g_G723Done)
			{
				KillTimer(g_hwnd,PERF_TIMER_ID);
				ClearStreamProperties();
			}
		}
	}
}

void DisplayStreamProperties(TCHAR *InputFile, 
							 int dtxEnable, 
							 int bitrate)
{
	int i;
	TCHAR *dstr[]={_T("DTX: Off"),_T("DTX: On")};
	TCHAR *bstr[]={_T("Rate: 5.3 kbps"),_T("Rate: 6.3 kbps")};
	TCHAR tstr[MAXFN];
	RECT rt;
	HDC hdc;

	/* Clear prompt */
	hdc = GetDC(g_hwnd);
	rt.left=TXT_LEFT; rt.right=280; rt.top=GUI_TOP; rt.bottom=60;
	sprintf(tstr,_T("                                                          "));
	for(i=0;i<20;i++)
	{
		DrawText(hdc,tstr,-1,&rt,DT_LEFT);
		rt.top+=5; rt.bottom+=5;
	}

	/* display filename */
	i=strlen(InputFile);
	while(InputFile[i]!='\\')
		i--;
	sprintf(tstr,_T("%s\0"),&(InputFile[i+1]));
	rt.left=TXT_LEFT; rt.right=280; rt.top=GUI_TOP; rt.bottom=60;
	DrawText(hdc,tstr,-1,&rt,DT_LEFT);

	/* display stream properties */
	sprintf(tstr,_T("%s\0"),bstr[bitrate==IPP_SPCHBR_6300]);
	rt.top+=15; rt.bottom+=15;
	DrawText(hdc,tstr,-1,&rt,DT_LEFT);
	sprintf(tstr,_T("%s\0"),dstr[dtxEnable]);
	rt.top+=15; rt.bottom+=15;
	DrawText(hdc,tstr,-1,&rt,DT_LEFT);
} 

void ClearStreamProperties()
{
	int i;
	RECT rt;
	HDC hdc;
	TCHAR tstr[MAXFN];

	/* Clear filename */
	hdc = GetDC(g_hwnd);
	rt.left=TXT_LEFT; rt.right=280; rt.top=GUI_TOP; rt.bottom=110;
	sprintf(tstr,_T("                                                         "));
	for(i=0;i<25;i++)
	{
		DrawText(hdc,tstr,-1,&rt,DT_LEFT);
		rt.top+=5; rt.bottom+=5;
	}
	rt.left=TXT_LEFT; rt.right=280; rt.top=GUI_TOP; rt.bottom=110;
	sprintf(tstr,_T("Please choose a PCM input stream"));
	DrawText(hdc,tstr,-1,&rt,DT_LEFT);
} 

// Get test vector configuration file path 
LRESULT CALLBACK GetTVPath_G723(HWND hWnd, TCHAR *tvPath)
{
	OPENFILENAME	ofn;									  
	DWORD zsize;
	static TCHAR pszName[256];
	TCHAR title[MAXFN];
	HWND hWndd;

	/* Init ofn */
	zsize=sizeof(ofn);
	strcpy(pszName,_T("g723.cfg"));
	memset(&ofn,0,zsize);
	ofn.hwndOwner=hWnd;
	ofn.lStructSize=zsize;
	ofn.lpstrFilter=_T("Test Configuration Files (*.cfg)\0*.cfg\0\0");
	ofn.lpstrFile=pszName;
	ofn.nMaxFile=MAXFN;
	strcpy(title,_T("Select Test Vector Configuration File\0"));
	ofn.lpstrTitle=title;

	/* Request test vector path from user */
	if (GetOpenFileName(&ofn))
	{
		strcpy(tvPath,(TCHAR *)ofn.lpstrFile);
		hWndd=GetActiveWindow();
		EndDialog(hWndd,0);
		return TRUE;
	}
	return FALSE;
}


// Load and parse test vector configuration file
int ReadTestConfigFile_G723(TCHAR *tvpath, int *NumVect, 
					   TCHAR ***tv, int **type, int **hpf, 
					   int **postfilt, IppSpchBitRate **rate,
					   int **vad)
{
	int i;
	FILE *fcfg;
	TCHAR tstr[MAXSTR], type_s[MAXSTR], rate_s[MAXSTR], hpf_s[MAXSTR], pf_s[MAXSTR], vad_s[MAXSTR];
	
	/* Open config file/trap file errors */
	fcfg=FOPEN_TV(tvpath,_T("rt"));
	if (fcfg==NULL)
		return(0);

	/* Get number of test vectors */
	fscanf(fcfg,_T("%d\n"),NumVect);

	/* Allocate space for test vector name string and parameter tables */
	*tv=(TCHAR **)malloc(*NumVect*sizeof(TCHAR *));
	for(i=0;i<*NumVect;i++)
		(*tv)[i]=(TCHAR *)malloc(MAXSTR*sizeof(TCHAR));
	*type=(int *)malloc(*NumVect*sizeof(int));
	*hpf=(int *)malloc(*NumVect*sizeof(int));
	*postfilt=(int *)malloc(*NumVect*sizeof(int));
	*rate=(IppSpchBitRate *)malloc(*NumVect*sizeof(IppSpchBitRate));
	*vad=(int *)malloc(*NumVect*sizeof(int));

	/* Skip comment/label line */
	fgets(tstr,MAXSTR,fcfg);

	/* Load test vector configurations, line-by-line */
	for(i=0;i<*NumVect;i++)
	{
		/* Read raw text */
		fscanf(fcfg,_T("%s\t%s\t%s\t%s\t%s\t%s\n"),(*tv)[i],type_s,rate_s,vad_s,hpf_s,pf_s);

		/* Convert raw text to test configuration parameters */
		/* Bit rate */
		if (strcmp(rate_s,_T("6.3\0"))==0)
			(*rate)[i]=IPP_SPCHBR_6300;
		else
			(*rate)[i]=IPP_SPCHBR_5300;

		/* VAD enable */
		if (strcmp(vad_s,_T("on\0"))==0)
			(*vad)[i]=1;
		else
			(*vad)[i]=0;

		/* Highpass filter */
		(*hpf)[i] = ~(strcmp(hpf_s,_T("on\0")))&0x1; 

		/* Postfilter */
		(*postfilt)[i] = ~(strcmp(pf_s,_T("on\0")))&0x1; 

		/* UUT */
		if (strcmp(type_s,_T("encoder\0"))==0)
			(*type)[i]=TV_ENCODER;
		else if (strcmp(type_s,_T("decoder\0"))==0)
			(*type)[i]=TV_DECODER;
		else if (strcmp(type_s,_T("decoder_crc\0"))==0)
			(*type)[i]=TV_CRC_DECODER;
		else
			(*type)[i]=TV_MIX_ENCODER;
	}

	/* Close config file */
	fclose(fcfg);

	/* Success */
	return(1);
}

// Run test vector compliance tests for all vectors and configurations
// specified in the .cfg file
int TestCodecCompliance_G723(int testsel, TCHAR *cfgfile, HWND hWnd)
{
	int i, result, TestPass=1, TestIncomplete=0;
	RECT rt;
	HDC hdc;
	COLORREF black;
	int NumTv;
	TCHAR **tv;
	int *tv_type;
	int *tv_hpf;
	int *tv_pf;
	int *tv_vad;
	IppSpchBitRate *tv_rate;
	TCHAR tvpath[MAXFN];

	hdc = GetDC(CTW_HANDLE);
	rt.left=70; rt.right=240; rt.top=GUI_TV_TOP; rt.bottom=120;
	black=GetTextColor(hdc);

	/* Test title */
	if (testsel==ENCODER_TEST)
		sprintf(g_tstr,_T("Testing encoder . . .\0"));
	else
		sprintf(g_tstr,_T("Testing decoder . . .\0"));
	DrawText(hdc,g_tstr,-1,&rt,DT_LEFT);
	rt.top+=25; rt.bottom+=25;

	if (ReadTestConfigFile_G723(cfgfile,&NumTv,&tv,&tv_type,&tv_hpf,&tv_pf,&tv_rate,&tv_vad)==0)
	{
		MessageBox(NULL,_T("Unable to open .cfg file!"),_T("Error"),MB_OK|MB_ICONERROR);
		return(0);
	}

	/* Extract leading path from config file name */
	for(i=strlen(cfgfile)-1;(cfgfile[i]!='\\'&&i>=0);i--) ;
	strncpy(tvpath,cfgfile,i);
	tvpath[i]='\0';

	/* Run specified test for each of NumTv test vectors */
	for (i=0;i<NumTv;i++)
	{
		if ( (testsel==DECODER_TEST)&&((tv_type[i]==TV_DECODER)||(tv_type[i]==TV_CRC_DECODER)) || 
			 (testsel==ENCODER_TEST)&&((tv_type[i]==TV_ENCODER)||(tv_type[i]==TV_MIX_ENCODER)) )
		{
			SetTextColor(hdc,BLUE);
			sprintf(g_tstr,_T("Now Testing:  %s\0"), tv[i]);
			rt.left=70;
			DrawText(hdc,g_tstr,-1,&rt,DT_LEFT);
			g_err=0;
			if (testsel==DECODER_TEST)
				result=RunTestVector_G723(tvpath, tv[i], tv_type[i], tv_rate[i], tv_pf[i], tv_vad[i]);
			else
				result=RunTestVector_G723(tvpath, tv[i], tv_type[i], tv_rate[i], tv_hpf[i], tv_vad[i]);
			SetTextColor(hdc,black);
			sprintf(g_tstr,_T("%s                                    "), tv[i]);
			rt.left=70;
			DrawText(hdc,g_tstr,-1,&rt,DT_LEFT);
			rt.left=150;
			switch (result)
			{
				case TV_PASS:
					SetTextColor(hdc,GREEN);
					sprintf(g_tstr,_T("Pass\0"));
					break;
				case TV_FAIL:
					SetTextColor(hdc,RED);
					sprintf(g_tstr,_T("Fail (%d)\0"),g_err);
					TestPass=0;
					break;
				case TV_MISSING:
					SetTextColor(hdc,RED);
					sprintf(g_tstr,_T("Missing\0"));
					TestIncomplete=1;
					TestPass=0;
					break;
			}
			DrawText(hdc,g_tstr,-1,&rt,DT_LEFT);
			rt.top+=15; rt.bottom+=15;
		}
	}
	rt.top+=15; rt.bottom+=15;
	sprintf(g_tstr,_T("RESULT:"));
	SetTextColor(hdc,black);
	rt.left=70;
	DrawText(hdc,g_tstr,-1,&rt,DT_LEFT);
	if ((i!=0)&&TestPass)
	{
		sprintf(g_tstr,_T("PASS\0"));
		SetTextColor(hdc,GREEN);
	}
	else if ((i==0)||TestIncomplete)
	{
		sprintf(g_tstr,_T("INCOMPLETE"));
		SetTextColor(hdc,YELLOW);
	}
	else
	{
		sprintf(g_tstr,_T("FAIL"));
		SetTextColor(hdc,RED);
	}
	rt.left=150;
	DrawText(hdc,g_tstr,-1,&rt,DT_LEFT);

	/* zindex of continue button may change if this dialog is modified 
	   in the resource editor */
	HWND ContinueButton;
	ContinueButton=GetWindow(GetForegroundWindow(),GW_CHILD); 
	ShowWindow(ContinueButton,SW_SHOW); 

	/* Release dynamic storage used for test vector parameters */
	for(i=0;i<NumTv;i++)
		free(tv[i]);
	free(tv);
	free(tv_type);
	free(tv_hpf);
	free(tv_pf);
	free(tv_rate);

	/* Test session successfully completed */
	return(1);
}

/* Run an individual test vector */
int RunTestVector_G723(TCHAR *path, TCHAR *name, int type, IppSpchBitRate rate, int filterEnable, int vadEnable)
{
	int i,j,frames;
	Ipp8u y[30],ytst[30];
	Ipp16s x[IPP_G723_FRAME_LEN],xtst[IPP_G723_FRAME_LEN],c;
	TCHAR fnx[MAXFN],fny[MAXFN],fnc[MAXFN];	/* Uncompressed, compressed, and reference filenames */
	HANDLE fhx,fhy,fhc;							/* Uncompressed, compressed, and reference file handles */
	IppG723DecoderState DecoderState;			/* G.723.1 test vector decoder state */
	IppG723EncoderState EncoderState;			/* G.723.1 test vector encoder state */
	DWORD len,bytesread;						
	int status=TV_PASS;
	int StreamBytes, xStreamBytes;
	IppPcmStream speech;
	IppBitstream bitstream;

	/* Init filenames */
	strcpy(fnx,path);
	strcat(fnx,_T("\\"));
	strcat(fnx,name);
	if ((type==TV_ENCODER)||(type==TV_MIX_ENCODER))
		strcat(fnx,_T(".tin"));				/* Test vector extensions in accordance with ITU conventions */
	else
		strcat(fnx,_T(".rou"));
	strcpy(fny,path);
	strcat(fny,_T("\\"));
	strcat(fny,name);
	if ((type==TV_ENCODER)||(type==TV_MIX_ENCODER))
		strcat(fny,_T(".rco"));
	else
		strcat(fny,_T(".tco"));

	/* Open CRC file for CRC tests */
	if (type==TV_CRC_DECODER)
	{
		strcpy(fnc,path);
		strcat(fnc,_T("\\"));
		strcat(fnc,name);
		strcat(fnc,_T(".crc"));
		fhc=CreateFile((LPCTSTR)fnc,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_READONLY,NULL);
	}

	/* Open rate control file for mixed-rate encoder tests */
	if (type==TV_MIX_ENCODER)
	{
		strcpy(fnc,path);
		strcat(fnc,_T("\\"));
		strcat(fnc,name);
		strcat(fnc,_T(".rat"));
		fhc=CreateFile((LPCTSTR)fnc,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_READONLY,NULL);
	}

	/* Open test bitstream and reference output vector */
	fhx=CreateFile((LPCTSTR)fnx,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_READONLY,NULL);
	fhy=CreateFile((LPCTSTR)fny,GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_READONLY,NULL);

	/* Verify presence of required test and reference vectors */
	if ((fhx==INVALID_HANDLE_VALUE)||(fhy==INVALID_HANDLE_VALUE))
		return(status=TV_MISSING);
	if ((type==TV_CRC_DECODER)&&(fhc==INVALID_HANDLE_VALUE))
		return(status=TV_MISSING);
	if ((type==TV_MIX_ENCODER)&&(fhc==INVALID_HANDLE_VALUE))
		return(status=TV_MISSING);

	/* Determine file length and number of frames */
	len=GetFileSize(fhx,NULL);
	frames=len/(sizeof(Ipp16s)*IPP_G723_FRAME_LEN);

	/* Init unit under test */
	if ((type==TV_ENCODER)||(type==TV_MIX_ENCODER))
	{
		EncoderInit_G723(&EncoderState);
	}
	else
	{
		DecoderInit_G723(&DecoderState);
	}

	/* Determine number of compressed stream bytes per frame */
	switch(rate)
	{
		case IPP_SPCHBR_5300:
			StreamBytes=xStreamBytes=20;
			break;
		case IPP_SPCHBR_6300:
			StreamBytes=xStreamBytes=24;
			break;
	}

	/* Run test - read test bitstream, decode, compare against reference */
	for(i=0;i<frames;i++)
	{
		StreamBytes=xStreamBytes;
		/* Read test and reference vectors */
		ReadFile(fhx, (LPVOID) x, IPP_G723_FRAME_LEN*sizeof(Ipp16s), &bytesread, NULL); 
		ReadFile(fhy, (LPVOID) y, 1, &bytesread, NULL);
		switch(y[0]&0x3)
		{
			case 3:
				StreamBytes=1;
				break;
			case 2:
				StreamBytes=4;
				break;
			case 1:
				StreamBytes=20;
				break;
			case 0:
				StreamBytes=24;
				break;
			default:
				break;
		}
		ReadFile(fhy, (LPVOID) &(y[1]), StreamBytes-1, &bytesread, NULL);
				
		/* Run normal or CRC test */
		if (type==TV_CRC_DECODER)
			ReadFile(fhc, (LPVOID) &c, sizeof(Ipp16s), &bytesread, NULL); 
		else
			c=0; 

		/* Run externally rate-controlled test */
		if (type==TV_MIX_ENCODER)
		{
			ReadFile(fhc, (LPVOID) &c, sizeof(Ipp8s), &bytesread, NULL); 
			if (c==0)
				rate=IPP_SPCHBR_6300;
			else
				rate=IPP_SPCHBR_5300;
		}

		/* Generate test output */
		if ((type==TV_ENCODER)||(type==TV_MIX_ENCODER))
		{
			speech.pBuf=(Ipp16s *)x;
			bitstream.pBuf=(Ipp8u *)ytst;
			Encode_G723_16s8u(&speech,&bitstream,rate,vadEnable,filterEnable,&EncoderState);
		}
		else
		{
			speech.pBuf=(Ipp16s *)xtst;
			bitstream.pBuf=(Ipp8u *)y;
			Decode_G723_8u16s(&bitstream,&speech,c,filterEnable,&DecoderState);
		}

		/* Compare test output against reference output */
		if ((type==TV_ENCODER)||(type==TV_MIX_ENCODER))
		{
			for(j=0;j<StreamBytes;j++)
				if (ytst[j]!=y[j])
				{
					LogEncoderError_G723(i,j,y[j],ytst[j]);
					status=TV_FAIL;
				}
		}
		else
		{
			for(j=0;j<IPP_G723_FRAME_LEN;j++)
				if (xtst[j]!=x[j])
				{
					LogDecoderError_G723(i,j,x[j],xtst[j]);
					status=TV_FAIL;
				}
		}
	}

	/* Close files */
	CloseHandle(fhx);
	CloseHandle(fhy);
	if ((type==TV_CRC_DECODER)||(type==TV_MIX_ENCODER))
		CloseHandle(fhc);
	return(status);
}

/* Accumulate decoder errors */
void LogDecoderError_G723(int frame, int byte, Ipp16s expected, Ipp16s actual)
{
	g_err++;
}

/* Accumulate encoder errors */
void LogEncoderError_G723(int frame, int byte, Ipp8u expected, Ipp8u actual)
{
	g_err++;
}