musicplay.cpp

一个基于VC++的音乐播放功能的程序代码

	img00.hwnd = NULL;
	CreateThread( NULL, 0,
				 (LPTHREAD_START_ROUTINE)th_Proc0,
				 NULL, 0, &tid );
	while( !(img00.hwnd) );			// 保持窗口所表示的
}


/******************************************************************************
 * 打开窗口1
******************************************************************************/
void openWindow1(void)
{
	DWORD tid;

	img01.hwnd = NULL;
	CreateThread( NULL, 0,
				 (LPTHREAD_START_ROUTINE)th_Proc1,
				 NULL, 0, &tid );

	while( !(img01.hwnd) );			// 保持窗口所表示的
}


/******************************************************************************
 * oscillatPlay - 演奏音乐
******************************************************************************/
double drand(void)
{
	return (double)rand()/RAND_MAX;
}

double nrand(void)
{
	return  drand()+drand()+drand()+drand()+drand()+drand()+
			drand()+drand()+drand()+drand()+drand()+drand()-6.0;
}

short round(double d)
{
	if (d>0) 
		return (short)(d+0.5);
	else
		return (short)(d-0.5);
}


/******************************************************************************
 * 根据模式频率产生发声数据
******************************************************************************/
void makedata(DWORD dwDataSize, int pattern, double freq, 
			  unsigned char HUGE *lpData)
{
	unsigned long i; 
	double freq2;
	short HUGE *lpData2 = (short HUGE *)lpData;
	if (rec_bits==8)
	{
		for (i=0; i<dwDataSize; i++)
		{
			switch(pattern)
			{
			case 0:/* 模式0 */
				if (fmod(i, rec_freq/freq) < rec_freq/freq/2) 
					lpData[i]=0;
				else 
					lpData[i]=255;
				break;
			case 1:/* 模式1 */
				lpData[i]=fmod(i, rec_freq/freq)/(rec_freq/freq)*255;
				break;
			case 2:/* 模式2 */
				if (fmod(i, rec_freq/freq) < rec_freq/freq/2)
					lpData[i]=fmod(i, rec_freq/freq/2)/(rec_freq/freq/2)*255;
				else
					lpData[i]=255-fmod(i, rec_freq/freq/2)/(rec_freq/freq/2)*255;
				break;
			case 3:/* 模式3 */
				lpData[i]=sin(i*freq/rec_freq*M_PI*2)*127+128;
				break;
			case 4:/* 模式4 */
				lpData[i]=128+nrand()*20;
				break;
			case 5:/* 模式5 */
				freq2=freq*HANON;
				lpData[i]=sin(i*freq /rec_freq*M_PI*2)*63+
						  sin(i*freq2/rec_freq*M_PI*2)*63+128;
				break;
			case 6:/* 模式6 */
				freq2=freq*HANON*HANON;
				lpData[i]=sin(i*freq /rec_freq*M_PI*2)*63+
						  sin(i*freq2/rec_freq*M_PI*2)*63+128;
				break;
			case 7:/* 模式7 */
				freq2=freq*HANON*HANON*HANON*HANON;
				lpData[i]=sin(i*freq /rec_freq*M_PI*2)*63+
						  sin(i*freq2/rec_freq*M_PI*2)*63+128;
				break;
			case 8:/* 模式8 */
				freq2=freq*1.5;
				lpData[i]=sin(i*freq /rec_freq*M_PI*2)*63+
						  sin(i*freq2/rec_freq*M_PI*2)*63+128;
				break;
			case 9:/* 模式9 */
				freq2=freq*2;
				lpData[i]=sin(i*freq /rec_freq*M_PI*2)*63+
						  sin(i*freq2/rec_freq*M_PI*2)*63+128;
				break;
			case 10:/* 模式10 */
				if (dwDataSize/2 <=i && i<=dwDataSize/2+rec_freq/freq) 
					lpData[i]=0;
				else 
					lpData[i]=128;
				break;
			}
		}
	}
	else
	{
		for (i=0; i<dwDataSize/2; i++)
		{
			switch(pattern)
			{
			case 0:/* 模式0 */
				if (fmod(i, rec_freq/freq) < rec_freq/freq/2) 
					lpData2[i]=SHRT_MAX;
				else 
					lpData2[i]=SHRT_MIN;
				break;
			case 1:/* 模式1 */
				lpData2[i]=fmod(i, rec_freq/freq)/(rec_freq/freq)*USHRT_MAX-32768L;
				break;
			case 2:/* 模式2 */
				if (fmod(i, rec_freq/freq) < rec_freq/freq/2)
					lpData2[i] =
						fmod(i, rec_freq/freq/2)/(rec_freq/freq/2)*USHRT_MAX-32768L;
				else
					lpData2[i] =
						32767-fmod(i, rec_freq/freq/2)/(rec_freq/freq/2)*USHRT_MAX;
				break;
			case 3:/* 模式3 */
				lpData2[i]=round(sin(i*freq/rec_freq*M_PI*2)*32767);
				break;
			case 4:/* 模式4 */
				lpData2[i]=nrand()*20*256;
				break;
			case 5:/* 模式5 */
				freq2=freq*HANON;
				lpData2[i]=round(sin(i*freq /rec_freq*M_PI*2)*16383+
								 sin(i*freq2/rec_freq*M_PI*2)*16383);
				break;
			case 6:/* 模式6 */
				freq2=freq*HANON*HANON;
				lpData2[i]=round(sin(i*freq /rec_freq*M_PI*2)*16383+
								 sin(i*freq2/rec_freq*M_PI*2)*16383);
				break;
			case 7:/* 模式7 */
				freq2=freq*HANON*HANON*HANON*HANON;
				lpData2[i]=round(sin(i*freq /rec_freq*M_PI*2)*16383+
								 sin(i*freq2/rec_freq*M_PI*2)*16383);
				break;
			case 8:/* 模式8 */
				freq2=freq*1.5;
				lpData2[i]=round(sin(i*freq /rec_freq*M_PI*2)*16383+
								 sin(i*freq2/rec_freq*M_PI*2)*16383);
				break;
			case 9:/* 模式9 */
				freq2=freq*2;
				lpData2[i]=round(sin(i*freq /rec_freq*M_PI*2)*16383+
								 sin(i*freq2/rec_freq*M_PI*2)*16383);
				break;
			case 10:/* 模式10 */
				if (dwDataSize/4 <=i && i<=dwDataSize/4+rec_freq/freq) 
					lpData2[i]=32767;
				else 
					lpData2[i]=0;
				break;
			}
		}
	}
}


/******************************************************************************
 * 演奏
******************************************************************************/
void oscillatPlay(int pattern, 	double freq)
{
	/*
	"        " pattern=9
	"五度重音" pattern=8
	"三度重音" pattern=7
	"全音重音" pattern=6
	"半音重音" pattern=5
	"正弦波  " pattern=3
	"锯齿波  " pattern=1
	"方形波  " pattern=0
	"三角波  " pattern=2
	"        " pattern=4
	"        " pattern=10
	
	freq     频率
	*/

	HMMIO hmmio;
	MMCKINFO mmckinfoParent, mmckinfoSubchunk;
	HANDLE			hWaveHdr;
	LPWAVEINST		lpWaveInst;
	DWORD			dwFmtSize;
	char			szFileName[ MAX_FILENAME_SIZE ];
	UINT			wResult;
	HANDLE			hFormat;
	PCMWAVEFORMAT	*pFormat;
	DWORD			dwDataSize;
	HANDLE			hWaveInst;
	HANDLE			hData;
	unsigned char HUGE * lpData;
	int				wIndex;
	char			*p;

	dwFmtSize = sizeof(PCMWAVEFORMAT);
	hFormat = LocalAlloc(LMEM_MOVEABLE, LOWORD(dwFmtSize));
	if (!hFormat)
	{
		printf("内存不足\n");
		exit(-1);
	}
	pFormat = (PCMWAVEFORMAT *) LocalLock(hFormat);
	if (!pFormat)
	{
		printf("内存锁定失败\n");
		LocalFree( hFormat );
		exit(-1);
	}

	pFormat->wf.wFormatTag = WAVE_FORMAT_PCM;
	pFormat->wf.nChannels = 1;
	pFormat->wf.nSamplesPerSec = rec_freq;
	pFormat->wf.nBlockAlign = (WORD)(1 * (rec_bits / 8));
	pFormat->wBitsPerSample = rec_bits;
	pFormat->wf.nAvgBytesPerSec = rec_freq * pFormat->wf.nBlockAlign;

	if (waveOutOpen(&hWaveOut, (UINT)WAVE_MAPPER, (LPWAVEFORMATEX)pFormat,
					(DWORD)NULL, 0L, (DWORD)WAVE_FORMAT_QUERY)) 
	{
		LocalUnlock( hFormat );
		LocalFree( hFormat );
		exit(-1);
	}

	dwDataSize = sec * rec_freq * (rec_bits / 8);

	if (waveOutOpen((LPHWAVEOUT)&hWaveOut, (UINT)WAVE_MAPPER, (LPWAVEFORMATEX)pFormat,
			 (UINT)hwndApp, 0L, (DWORD)CALLBACK_WINDOW)) 
	{
		LocalUnlock( hFormat );
		LocalFree( hFormat );
		exit(-1);
	}

	LocalUnlock( hFormat );
	LocalFree( hFormat );

	hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, dwDataSize );
	if (!hData) 
	{
		exit(-1);
	}
	lpData = (unsigned char HUGE *)GlobalLock(hData);
	if (!lpData) 
	{
		GlobalFree( hData );
		exit(-1);
	}

	makedata(dwDataSize, pattern, freq, lpData);

	hWaveHdr = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, (DWORD) sizeof(WAVEHDR));
	if (!hWaveHdr) 
	{
		GlobalUnlock( hData );
		GlobalFree( hData );
		exit(-1);
	}
	lpWaveHdr = (LPWAVEHDR) GlobalLock(hWaveHdr);
	if (!lpWaveHdr) 
	{
		GlobalUnlock( hData );
		GlobalFree( hData );
		GlobalFree( hWaveHdr );
		exit(-1);
	}

	hWaveInst = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, (DWORD) sizeof(WAVEHDR));
	if (!hWaveInst)
	{
		GlobalUnlock( hData );
		GlobalFree( hData );
		GlobalUnlock( hWaveHdr );
		GlobalFree( hWaveHdr );
		exit(-1);
	}
	lpWaveInst = (LPWAVEINST) GlobalLock(hWaveInst);
	if (!lpWaveInst)
	{
		GlobalUnlock( hData );
		GlobalFree( hData );
		GlobalUnlock( hWaveHdr );
		GlobalFree( hWaveHdr );
		GlobalFree( hWaveInst );
		exit(-1);
	}
	lpWaveInst->hWaveInst = hWaveInst;
	lpWaveInst->hWaveHdr = hWaveHdr;
	lpWaveInst->hWaveData = hData;

	lpWaveHdr->lpData = (LPSTR)lpData;
	lpWaveHdr->dwBufferLength = dwDataSize;
	lpWaveHdr->dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP;
	lpWaveHdr->dwLoops = ULONG_MAX;
	lpWaveHdr->dwUser = (DWORD) lpWaveInst;
	if(waveOutPrepareHeader(hWaveOut, lpWaveHdr, sizeof(WAVEHDR)))
	{
		GlobalUnlock( hData );
		GlobalFree( hData );
		GlobalUnlock( hWaveHdr );
		GlobalFree( hWaveHdr );
		GlobalUnlock( hWaveInst );
		GlobalFree( hWaveInst );
		exit(-1);
	}

	wResult = waveOutWrite(hWaveOut, lpWaveHdr, sizeof(WAVEHDR));
	if (wResult != 0)
	{
		waveOutUnprepareHeader( hWaveOut, lpWaveHdr, sizeof(WAVEHDR));
		GlobalUnlock( hData );
		GlobalFree( hData );
		exit(-1);
	}
}


void oscillatStop(void)
{
	LPWAVEINST      lpWaveInst;

	waveOutReset(hWaveOut);
	waveOutUnprepareHeader(hWaveOut,lpWaveHdr,sizeof(WAVEHDR));
	waveOutClose(hWaveOut); hWaveOut=NULL;
	lpWaveInst = (LPWAVEINST) lpWaveHdr->dwUser;
	cleanup(lpWaveInst);
}


VOID cleanup(LPWAVEINST lpWaveInst)
{
	GlobalUnlock( lpWaveInst->hWaveData );
	GlobalFree( lpWaveInst->hWaveData );
	GlobalUnlock( lpWaveInst->hWaveHdr );
	GlobalFree( lpWaveInst->hWaveHdr );
	GlobalUnlock( lpWaveInst->hWaveInst );
	GlobalFree( lpWaveInst->hWaveInst );
}


/******************************************************************************
 * HSV二值化
******************************************************************************/
void masuku(BYTE *pRGB1) 
{
	double R, G, B, H, S, V, v, Vflag, vflag;
	int x, y;
	long x_count=0, y_count=0, count=0;
	
	for (y = 0; y < y_size; y++)
	{
		for (x = 0; x < x_size; x++) 
		{
			B = pRGB1[(x + y*x_size)*3];
			G = pRGB1[(x + y*x_size)*3+1];
			R = pRGB1[(x + y*x_size)*3+2];
			
			HSV(&H, &S, &V, B, G, R);
			
			if (V == 0) 
			{
				image1[y_count][x_count++] = 0;
				if (x_count == x_size) 
				{
					x_count = 0;
					y_count++;
				}
			}
			else 
			{
				if (((H >=0 ) && (H <= 30)) && ((S >= 30) && (S <= 255)) 
					&& ((V >= 20) && (V <= 255)))
				{
					image1[y_count][x_count++] = 255;
					if (x_count == x_size)
					{
						x_count = 0;
						y_count++;
					}
				}
				else
				{
					image1[y_count][x_count++] = 0;
					if (x_count == x_size) 
					{
						x_count =0;
						y_count++;
					}
				}
			}
		}
	}
}

/******************************************************************************
 * 边缘跟踪
******************************************************************************/
int obtain_contour(int x_start, int y_start, unsigned char image[y_size][x_size])
{
	int x, y;
	int xs, ys;
	int code, num;
	int i, counter, detect;
	
	counter = 0;
	for (i = 0; i < 8; i++) 
	{
		xs = x_start + Freeman[i][0];
		ys = y_start + Freeman[i][1];
		if ((xs >= 0) && (xs < x_size) && (ys >= 0) && (ys < y_size) 
			&& (image[ys][xs] == 255)) 
		{
			counter++;
		}
	}
	
	if (counter == 0) 
	{
		num = 1;
	}
	else 
	{
		num = -1;
		x = x_start;
		y = y_start;
		code = 0;
		
		ch_x[0] = x_size;
		ch_x[1] = 0;
		ch_y[0] = 0;
		ch_y[1] = y_size;
		
		do
		{
			detect = 0;
			code = code - 3;
			
			if (code < 0) 
			{
				code = code + 8;
			}
			
			do 
			{
				xs = x + Freeman[code][0];
				ys = y + Freeman[code][1];
				
				if ((xs >= 0) && (xs < x_size) && (ys >= 0) 
					&& (ys < y_size) && (image[ys][xs] == 255)) 
				{
					detect = 1;
					num++;
					if (num > MAX_CNTR) 
					{
						return(-1);
					}
					
					chain_code[num] = code;
					x = xs;
					y = ys;
					
					if (ch_x[0] > x) 
					{
						ch_x[0] = x;
					}
					else if (ch_x[1] < x) 
					{
						ch_x[1] = x;
					}
					
					if (ch_y[0] < y) 
					{
						ch_y[0] = y;
					}
					else if (ch_y[1] > y) 
					{
						ch_y[1] = y;
					}
				}
				
				code++;
				
				if (code > 7) 
				{
					code = 0;
				}
			}while (detect == 0);
		}while ((x != x_start) || (y != y_start));

		num = num + 2;
	}

	return (num);
}


/******************************************************************************
 * 去除边缘跟踪后周长小于一定阈值的部分
******************************************************************************/
int remove_areas(BYTE *pRGB1)
{
	int threshold=50;
	int num, x, y, xs, ys, i, mid, hani_x, hani_y;
	int fill_value;
	int N[3], check_x[3][2], check_y[3][2];
	int kao_x[2], kao_y[2], right_x[2], right_y[2];
	int left_x[2], left_y[2], flag1, flag2, s;
	unsigned char image2[y_size][x_size];
	long count=0;
	double wid_x, wid_y, dot_x, dot_y, line;
	int DO, LE, MI, FA, SO, RA, SI, DO1[2], left[6];
	WORD leftVol = 0xffff;
	WORD rightVol = 0xffff;
	long volume;
	MMRESULT rc;
	
	for (y = 0; y < y_size; y++) 
	{
		for (x = 0; x < x_size; x++) 
		{
			image2[y][x] = 0;
		}
	}
	
	for (i = 0; i < 3; i++)
	{
		N[i] = 0;
		check_x[i][0] = x_size;
		check_x[i][1] = 0;
		check_y[i][0] = 0;
		check_y[i][1] = y_size;
	}

	for (y = 0; y < y_size; y++)
	{
		for (x = 0; x < x_size; x++)
		{
			if (image1[y][x] == 255) 
			{
				num = obtain_contour(x, y, image1);
				if (num != -1)