![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to reverse.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / reverse|
Return to reverse.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / reverse |
1.1 root 1: /* reverse.c - WinMain() and WndProc() for REVERSE, along with
2: * initialization and support code.
3: *
4: * REVERSE is a Windows with Multimedia sample application that
5: * illustrates how to use the low-level waveform playback services.
6: * It also shows how to use the multimedia file I/O services to read
7: * data from a WAVE file.
8: *
9: * REVERSE plays a WAVE waveform audio file backwards.
10: *
11: * (C) Copyright Microsoft Corp. 1991, 1992. All rights reserved.
12: *
13: * You have a royalty-free right to use, modify, reproduce and
14: * distribute the Sample Files (and/or any modified version) in
15: * any way you find useful, provided that you agree that
16: * Microsoft has no warranty obligations or liability for any
17: * Sample Application Files which are modified.
18: *
19: */
20:
21: #include <windows.h>
22: #include <mmsystem.h>
23: #include "reverse.h"
24:
25: #define MAX_FILENAME_SIZE 128
26:
27: /* Global variables.
28: */
29: char szAppName[] = "Reverse"; // application name
30: HANDLE hInstApp = NULL; // instance handle
31: HWND hwndApp = NULL; // main window handle
32: HWND hwndName = NULL; // filename window handle
33: HWND hwndPlay = NULL; // "Play" button window handle
34: HWND hwndQuit = NULL; // "Exit" button window handle
35: HWAVEOUT hWaveOut = NULL;
36: LPWAVEHDR lpWaveHdr = NULL;
37: VOID cleanup(LPWAVEINST lpWaveInst);
38:
39:
40: /* WinMain - Entry point for Reverse.
41: */
42: int PASCAL WinMain(HANDLE hInst, HANDLE hPrev, LPSTR szCmdLine, int cmdShow)
43: {
44: MSG msg;
45: WNDCLASS wc;
46:
47: hInstApp = hInst;
48:
49: /* Define and register a window class for the main window.
50: */
51: if (!hPrev)
52: {
53: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
54: wc.hIcon = LoadIcon(hInst, szAppName);
55: wc.lpszMenuName = szAppName;
56: wc.lpszClassName = szAppName;
57: wc.hbrBackground = GetStockObject(LTGRAY_BRUSH);
58: wc.hInstance = hInst;
59: wc.style = 0;
60: wc.lpfnWndProc = WndProc;
61: wc.cbWndExtra = 0;
62: wc.cbClsExtra = 0;
63:
64: if (!RegisterClass(&wc))
65: return FALSE;
66: }
67:
68: /* Create and show the main window.
69: */
70: hwndApp = CreateWindow (szAppName, // class name
71: szAppName, // caption
72: WS_OVERLAPPEDWINDOW, // style bits
73: CW_USEDEFAULT, // x position
74: CW_USEDEFAULT, // y position
75: WMAIN_DX, // x size
76: WMAIN_DY, // y size
77: (HWND)NULL, // parent window
78: (HMENU)NULL, // use class menu
79: (HANDLE)hInst, // instance handle
80: (LPSTR)NULL // no params to pass on
81: );
82: /* Create child windows for the "Play" and "Exit" buttons
83: * and for an edit field to enter filenames.
84: */
85: hwndPlay = CreateWindow( "BUTTON", "Play",
86: WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
87: PLAY_X, PLAY_Y,
88: PLAY_DX, PLAY_DY,
89: hwndApp, (HMENU)IDB_PLAY, hInstApp, NULL );
90: if( !hwndPlay )
91: return( FALSE );
92:
93: hwndQuit = CreateWindow( "BUTTON", "Exit",
94: WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
95: QUIT_X, QUIT_Y,
96: QUIT_DX, QUIT_DY,
97: hwndApp, (HMENU)IDB_QUIT, hInstApp, NULL );
98: if( !hwndQuit )
99: return( FALSE );
100:
101: hwndName = CreateWindow("EDIT","",
102: WS_CHILD|WS_VISIBLE|WS_BORDER|ES_AUTOHSCROLL,
103: NAME_X, NAME_Y,
104: NAME_DX, NAME_DY,
105: hwndApp, (HMENU)IDE_NAME, hInstApp, NULL);
106: if( !hwndName )
107: return( FALSE );
108: SendMessage(hwndName, EM_LIMITTEXT, MAX_FILENAME_SIZE - 1, 0);
109:
110: ShowWindow(hwndApp,cmdShow);
111:
112: /* Add about dialog to system menu.
113: */
114: AppendMenu(GetSystemMenu(hwndApp, NULL),
115: MF_STRING | MF_ENABLED, IDM_ABOUT, "About Reverse...");
116:
117:
118: /* The main message processing loop. Nothing special here.
119: */
120: while (GetMessage(&msg,NULL,0,0))
121: {
122: TranslateMessage(&msg);
123: DispatchMessage(&msg);
124: }
125:
126: return msg.wParam;
127: }
128:
129:
130: /* WndProc - Main window procedure function.
131: */
132: LONG FAR PASCAL WndProc(HWND hWnd, unsigned msg, UINT wParam, LONG lParam)
133: {
134: FARPROC fpfn;
135: LPWAVEINST lpWaveInst;
136:
137: switch (msg)
138: {
139: case WM_DESTROY:
140: if (hWaveOut)
141: {
142: waveOutReset(hWaveOut);
143: waveOutUnprepareHeader(hWaveOut, lpWaveHdr, sizeof(WAVEHDR) );
144: lpWaveInst = (LPWAVEINST) lpWaveHdr->dwUser;
145: cleanup(lpWaveInst);
146: waveOutClose(hWaveOut);
147: }
148: PostQuitMessage(0);
149: break;
150:
151: case WM_SYSCOMMAND:
152: switch (LOWORD(wParam))
153: {
154: case IDM_ABOUT:
155: /* Show ABOUTBOX dialog box.
156: */
157: fpfn = MakeProcInstance((FARPROC)AppAbout, hInstApp); // no op in 32 bit
158: DialogBox(hInstApp, "ABOUTBOX", hWnd, (DLGPROC)fpfn);
159: FreeProcInstance(fpfn);
160: break;
161: }
162: break;
163:
164: /* Process messages sent by the child window controls.
165: */
166: case WM_SETFOCUS:
167: SetFocus(hwndName);
168: return 0;
169:
170: case WM_COMMAND:
171: switch (LOWORD(wParam))
172: {
173: case IDE_NAME: // filename edit control
174: return( 0L );
175:
176: case IDB_PLAY: // "Play" button
177: if (HIWORD(wParam) == BN_CLICKED)
178: ReversePlay();
179: break;
180:
181: case IDB_QUIT: // "Exit" button
182: if (HIWORD(wParam) == BN_CLICKED)
183: PostQuitMessage(0);
184: break;
185: }
186: return( 0L );
187:
188: case MM_WOM_DONE:
189: /* This message indicates a waveform data block has
190: * been played and can be freed. Clean up the preparation
191: * done previously on the header.
192: */
193: waveOutUnprepareHeader( (HWAVEOUT) wParam,
194: (LPWAVEHDR) lParam, sizeof(WAVEHDR) );
195:
196: /* Get a pointer to the instance data, then unlock and free
197: * all memory associated with the data block, including the
198: * memory for the instance data itself.
199: */
200: lpWaveInst = (LPWAVEINST) ((LPWAVEHDR)lParam)->dwUser;
201: cleanup(lpWaveInst);
202: /* Close the waveform output device.
203: */
204: waveOutClose( (HWAVEOUT) wParam );
205:
206: /* Reenable both button controls.
207: */
208: EnableWindow( hwndPlay, TRUE );
209: EnableWindow( hwndQuit, TRUE );
210: SetFocus(hwndName);
211:
212: break;
213: }
214:
215: return DefWindowProc(hWnd,msg,wParam,lParam);
216: }
217:
218:
219: /* AppAbout -- Dialog procedure for ABOUTBOX dialog box.
220: */
221: BOOL FAR PASCAL AppAbout(HWND hDlg, unsigned msg, unsigned wParam, LONG lParam)
222: {
223: switch (msg)
224: {
225: case WM_COMMAND:
226: if (LOWORD(wParam) == IDOK)
227: EndDialog(hDlg,TRUE);
228: break;
229:
230: case WM_INITDIALOG:
231: return TRUE;
232: }
233: return FALSE;
234: }
235:
236: /* ReversePlay - Gets a filename from the edit control, then uses
237: * the multimedia file I/O services to read data from the requested
238: * WAVE file. If the file is a proper WAVE file, ReversePlay() calls
239: * the Interchange() function to reverse the order of the waveform
240: * samples in the file. It then plays the reversed waveform data.
241: *
242: * Note that ReversePlay() only handles a single waveform data block.
243: * If the requested WAVE file will not fit in a single data block, it
244: * will not be played. The size of a single data block depends on the
245: * amount of available system memory.
246: *
247: * Params: void
248: *
249: * Return: void
250: */
251: void ReversePlay()
252: {
253: HANDLE hWaveHdr;
254: LPWAVEINST lpWaveInst;
255: HMMIO hmmio;
256: MMCKINFO mmckinfoParent;
257: MMCKINFO mmckinfoSubchunk;
258: DWORD dwFmtSize;
259: char szFileName[ MAX_FILENAME_SIZE ];
260: HANDLE hFormat;
261: WAVEFORMAT *pFormat;
262: DWORD dwDataSize;
263: HPSTR hpch1, hpch2;
264: WORD wBlockSize;
265: HANDLE hWaveInst;
266: HANDLE hData = NULL;
267: HPSTR lpData = NULL;
268:
269: /* Get the filename from the edit control.
270: */
271: if (!GetWindowText( hwndName, (LPSTR)szFileName, MAX_FILENAME_SIZE))
272: {
273: MessageBox(hwndApp, "Failed to Get Filename",
274: NULL, MB_OK | MB_ICONEXCLAMATION);
275: return;
276: }
277:
278: /* Open the given file for reading using buffered I/O.
279: */
280: if(!(hmmio = mmioOpen(szFileName, NULL, MMIO_READ | MMIO_ALLOCBUF)))
281: {
282: MessageBox(hwndApp, "Failed to open file.",
283: NULL, MB_OK | MB_ICONEXCLAMATION);
284: return;
285: }
286:
287: /* Locate a 'RIFF' chunk with a 'WAVE' form type
288: * to make sure it's a WAVE file.
289: */
290: mmckinfoParent.fccType = mmioFOURCC('W', 'A', 'V', 'E');
291: if (mmioDescend(hmmio, (LPMMCKINFO) &mmckinfoParent, NULL, MMIO_FINDRIFF))
292: {
293: MessageBox(hwndApp, "This is not a WAVE file.",
294: NULL, MB_OK | MB_ICONEXCLAMATION);
295: mmioClose(hmmio, 0);
296: return;
297: }
298:
299: /* Now, find the format chunk (form type 'fmt '). It should be
300: * a subchunk of the 'RIFF' parent chunk.
301: */
302: mmckinfoSubchunk.ckid = mmioFOURCC('f', 'm', 't', ' ');
303: if (mmioDescend(hmmio, &mmckinfoSubchunk, &mmckinfoParent,
304: MMIO_FINDCHUNK))
305: {
306: MessageBox(hwndApp, "WAVE file is corrupted.",
307: NULL, MB_OK | MB_ICONEXCLAMATION);
308: mmioClose(hmmio, 0);
309: return;
310: }
311:
312: /* Get the size of the format chunk, allocate and lock memory for it.
313: */
314: dwFmtSize = mmckinfoSubchunk.cksize;
315: hFormat = LocalAlloc(LMEM_MOVEABLE, LOWORD(dwFmtSize));
316: if (!hFormat)
317: {
318: MessageBox(hwndApp, "Out of memory.",
319: NULL, MB_OK | MB_ICONEXCLAMATION);
320: mmioClose(hmmio, 0);
321: return;
322: }
323: pFormat = (WAVEFORMAT *) LocalLock(hFormat);
324: if (!pFormat)
325: {
326: MessageBox(hwndApp, "Failed to lock memory for format chunk.",
327: NULL, MB_OK | MB_ICONEXCLAMATION);
328: LocalFree( hFormat );
329: mmioClose(hmmio, 0);
330: return;
331: }
332:
333: /* Read the format chunk.
334: */
335: if (mmioRead(hmmio, (HPSTR) pFormat, dwFmtSize) != (LONG) dwFmtSize)
336: {
337: MessageBox(hwndApp, "Failed to read format chunk.",
338: NULL, MB_OK | MB_ICONEXCLAMATION);
339: LocalUnlock( hFormat );
340: LocalFree( hFormat );
341: mmioClose(hmmio, 0);
342: return;
343: }
344:
345: /* Make sure it's a PCM file.
346: */
347: if (pFormat->wFormatTag != WAVE_FORMAT_PCM)
348: {
349: LocalUnlock( hFormat );
350: LocalFree( hFormat );
351: mmioClose(hmmio, 0);
352: MessageBox(hwndApp, "The file is not a PCM file.",
353: NULL, MB_OK | MB_ICONEXCLAMATION);
354: return;
355: }
356:
357: /* Make sure a waveform output device supports this format.
358: */
359: if (waveOutOpen(&hWaveOut, WAVE_MAPPER, (LPWAVEFORMAT)pFormat, NULL, 0L,
360: WAVE_FORMAT_QUERY))
361: {
362: LocalUnlock( hFormat );
363: LocalFree( hFormat );
364: mmioClose(hmmio, 0);
365: MessageBox(hwndApp, "The waveform device can't play this format.",
366: NULL, MB_OK | MB_ICONEXCLAMATION);
367: return;
368: }
369:
370: /* Ascend out of the format subchunk.
371: */
372: mmioAscend(hmmio, &mmckinfoSubchunk, 0);
373:
374: /* Find the data subchunk.
375: */
376: mmckinfoSubchunk.ckid = mmioFOURCC('d', 'a', 't', 'a');
377: if (mmioDescend(hmmio, &mmckinfoSubchunk, &mmckinfoParent,
378: MMIO_FINDCHUNK))
379: {
380: MessageBox(hwndApp, "WAVE file has no data chunk.",
381: NULL, MB_OK | MB_ICONEXCLAMATION);
382: LocalUnlock( hFormat );
383: LocalFree( hFormat );
384: mmioClose(hmmio, 0);
385: return;
386: }
387:
388: /* Get the size of the data subchunk.
389: */
390: dwDataSize = mmckinfoSubchunk.cksize;
391: if (dwDataSize == 0L)
392: {
393: MessageBox(hwndApp, "The data chunk has no data.",
394: NULL, MB_OK | MB_ICONEXCLAMATION);
395: LocalUnlock( hFormat );
396: LocalFree( hFormat );
397: mmioClose(hmmio, 0);
398: return;
399: }
400:
401: /* Open a waveform output device.
402: */
403: if (waveOutOpen((LPHWAVEOUT)&hWaveOut, WAVE_MAPPER,
404: (LPWAVEFORMAT)pFormat, (UINT)hwndApp, 0L, CALLBACK_WINDOW))
405: {
406: MessageBox(hwndApp, "Failed to open waveform output device.",
407: NULL, MB_OK | MB_ICONEXCLAMATION);
408: LocalUnlock( hFormat );
409: LocalFree( hFormat );
410: mmioClose(hmmio, 0);
411: return;
412: }
413:
414: /* Save block alignment info for later use.
415: */
416: wBlockSize = pFormat->nBlockAlign;
417:
418: /* We're done with the format header, free it.
419: */
420: LocalUnlock( hFormat );
421: LocalFree( hFormat );
422:
423: /* Allocate and lock memory for the waveform data.
424: */
425: hData = GlobalAlloc(GMEM_MOVEABLE , dwDataSize );
426: /* GMEM_SHARE is not needed on 32 bits */
427: if (!hData)
428: {
429: MessageBox(hwndApp, "Out of memory.",
430: NULL, MB_OK | MB_ICONEXCLAMATION);
431: mmioClose(hmmio, 0);
432: return;
433: }
434: lpData = GlobalLock(hData);
435: if (!lpData)
436: {
437: MessageBox(hwndApp, "Failed to lock memory for data chunk.",
438: NULL, MB_OK | MB_ICONEXCLAMATION);
439: GlobalFree( hData );
440: mmioClose(hmmio, 0);
441: return;
442: }
443:
444: /* Read the waveform data subchunk.
445: */
446: if(mmioRead(hmmio, (HPSTR) lpData, dwDataSize) != (LONG) dwDataSize)
447: {
448: MessageBox(hwndApp, "Failed to read data chunk.",
449: NULL, MB_OK | MB_ICONEXCLAMATION);
450: GlobalUnlock( hData );
451: GlobalFree( hData );
452: mmioClose(hmmio, 0);
453: return;
454: }
455:
456: /* We're done with the file, close it.
457: */
458: mmioClose(hmmio, 0);
459:
460: /* Reverse the sound for playing.
461: */
462: hpch1 = lpData;
463: hpch2 = lpData + dwDataSize - 1;
464: while (hpch1 < hpch2)
465: {
466: Interchange( hpch1, hpch2, wBlockSize );
467: hpch1 += wBlockSize;
468: hpch2 -= wBlockSize;
469: }
470:
471: /* Allocate a waveform data header. The WAVEHDR must be
472: * globally allocated and locked.
473: */
474: hWaveHdr = GlobalAlloc(GMEM_MOVEABLE, (DWORD) sizeof(WAVEHDR));
475: if (!hWaveHdr)
476: {
477: GlobalUnlock( hData );
478: GlobalFree( hData );
479: MessageBox(hwndApp, "Not enough memory for header.",
480: NULL, MB_OK | MB_ICONEXCLAMATION);
481: return;
482: }
483: lpWaveHdr = (LPWAVEHDR) GlobalLock(hWaveHdr);
484: if (!lpWaveHdr)
485: {
486: GlobalUnlock( hData );
487: GlobalFree( hData );
488: GlobalFree( hWaveHdr );
489: MessageBox(hwndApp, "Failed to lock memory for header.",
490: NULL, MB_OK | MB_ICONEXCLAMATION);
491: return;
492: }
493:
494: /* Allocate and set up instance data for waveform data block.
495: * This information is needed by the routine that frees the
496: * data block after it has been played.
497: */
498: hWaveInst = GlobalAlloc(GMEM_MOVEABLE, (DWORD) sizeof(WAVEHDR));
499: if (!hWaveInst)
500: {
501: GlobalUnlock( hData );
502: GlobalFree( hData );
503: GlobalUnlock( hWaveHdr );
504: GlobalFree( hWaveHdr );
505: MessageBox(hwndApp, "Not enough memory for instance data.",
506: NULL, MB_OK | MB_ICONEXCLAMATION);
507: return;
508: }
509: lpWaveInst = (LPWAVEINST) GlobalLock(hWaveInst);
510: if (!lpWaveInst)
511: {
512: GlobalUnlock( hData );
513: GlobalFree( hData );
514: GlobalUnlock( hWaveHdr );
515: GlobalFree( hWaveHdr );
516: GlobalFree( hWaveInst );
517: MessageBox(hwndApp, "Failed to lock memory for instance data.",
518: NULL, MB_OK | MB_ICONEXCLAMATION);
519: return;
520: }
521: lpWaveInst->hWaveInst = hWaveInst;
522: lpWaveInst->hWaveHdr = hWaveHdr;
523: lpWaveInst->hWaveData = hData;
524:
525: /* Set up WAVEHDR structure and prepare it to be written to wave device.
526: */
527: lpWaveHdr->lpData = lpData;
528: lpWaveHdr->dwBufferLength = dwDataSize;
529: lpWaveHdr->dwFlags = 0L;
530: lpWaveHdr->dwLoops = 0L;
531: lpWaveHdr->dwUser = (DWORD) lpWaveInst;
532: if(waveOutPrepareHeader(hWaveOut, lpWaveHdr, sizeof(WAVEHDR)))
533: {
534: GlobalUnlock( hData );
535: GlobalFree( hData );
536: GlobalUnlock( hWaveHdr );
537: GlobalFree( hWaveHdr );
538: GlobalUnlock( hWaveInst );
539: GlobalFree( hWaveInst );
540: MessageBox(hwndApp, "Unable to prepare wave header.",
541: NULL, MB_OK | MB_ICONEXCLAMATION);
542:
543: return;
544: }
545:
546: /* Then the data block can be sent to the output device.
547: */
548: { MMRESULT mmResult;
549: mmResult = waveOutWrite(hWaveOut, lpWaveHdr, sizeof(WAVEHDR));
550: if (mmResult != 0)
551: {
552: waveOutUnprepareHeader( hWaveOut, lpWaveHdr, sizeof(WAVEHDR));
553: GlobalUnlock( hData );
554: GlobalFree( hData );
555: MessageBox(hwndApp, "Failed to write block to device",
556: NULL, MB_OK | MB_ICONEXCLAMATION);
557: return;
558: }
559: }
560:
561: /* Disable input to the button controls.
562: */
563: EnableWindow(hwndPlay, FALSE);
564: EnableWindow(hwndQuit, FALSE);
565: }
566:
567: /* Interchange - Interchanges two samples at the given positions.
568: *
569: * Params: hpchPos1 - Points to one sample.
570: * hpchPos2 - Points to the other sample.
571: * wLength - The length of a sample in bytes.
572: *
573: * Return: void
574: */
575: void Interchange(HPSTR hpchPos1, HPSTR hpchPos2, unsigned uLength)
576: {
577: unsigned uPlace;
578: BYTE bTemp;
579:
580: for (uPlace = 0; uPlace < uLength; uPlace++)
581: {
582: bTemp = hpchPos1[uPlace];
583: hpchPos1[uPlace] = hpchPos2[uPlace];
584: hpchPos2[uPlace] = bTemp;
585: }
586: }
587:
588: VOID cleanup(LPWAVEINST lpWaveInst)
589: {
590: GlobalUnlock( lpWaveInst->hWaveData );
591: GlobalFree( lpWaveInst->hWaveData );
592: GlobalUnlock( lpWaveInst->hWaveHdr );
593: GlobalFree( lpWaveInst->hWaveHdr );
594: GlobalUnlock( lpWaveInst->hWaveInst );
595: GlobalFree( lpWaveInst->hWaveInst );
596: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.