![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to wavedd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / mmedia / mmdrv|
Return to wavedd.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / mmedia / mmdrv |
1.1 root 1: /****************************************************************************
2: *
3: * wavedd.c
4: *
5: * Multimedia kernel driver support component (mmdrv)
6: *
7: * Copyright (c) 1991 Microsoft Corporation. All Rights Reserved.
8: *
9: * Driver for wave input and output devices
10: *
11: * -- Wave driver entry points (wodMessage, widMessage)
12: * -- Auxiliary task (necessary for receiving Apcs and generating
13: * callbacks ASYNCRHONOUSLY)
14: * -- Interface to kernel driver (via DeviceIoControl)
15: *
16: * Note that if any error occurs then the kernel device is closed
17: * and all subsequent calls requiring calls to the kernel device
18: * return error until the device is closed by the application.
19: *
20: * History
21: * 01-Feb-1992 - Robin Speed (RobinSp) wrote it
22: * 04-Feb-1992 - SteveDav reviewed it
23: * 08-Feb-1992 - RobinSp - Redesign to chop up caller's data.
24: * Also does loops so we can remove them from the
25: * kernel driver.
26: *
27: ***************************************************************************/
28:
29: #include "mmdrv.h"
30: #include <ntddwave.h>
31:
32: /*****************************************************************************
33:
34: internal declarations
35:
36: ****************************************************************************/
37:
38: #define D1 dprintf1
39: #define D2 dprintf2
40: #define D3 dprintf3
41:
42: // Stack size for our auxiliary task
43:
44: #define WAVE_STACK_SIZE 300
45:
46: typedef enum {
47: WaveThreadInvalid,
48: WaveThreadAddBuffer,
49: WaveThreadSetState,
50: WaveThreadSetData,
51: WaveThreadGetData,
52: WaveThreadBreakLoop,
53: WaveThreadClose,
54: WaveThreadTerminate
55: } WAVETHREADFUNCTION;
56:
57:
58: #define MAX_BUFFER_SIZE 8192 // Largest buffer we send to device
59: #define MAX_WAVE_BYTES 5*8192 // Max bytes we have queued on was 22000
60:
61: //
62: // Structure to hide our overlapped structure in so we can get some
63: // context on IO completion
64: //
65:
66: typedef struct {
67: OVERLAPPED Ovl;
68: LPWAVEHDR WaveHdr;
69: } WAVEOVL, *PWAVEOVL;
70:
71: // per allocation structure for wave
72: typedef struct tag_WAVEALLOC {
73: struct tag_WAVEALLOC *Next; // Chaining
74: UINT DeviceNumber; // Which device
75: UINT DeviceType; // WaveInput or WaveOutput
76: DWORD dwCallback; // client's callback
77: DWORD dwInstance; // client's instance data
78: DWORD dwFlags; // Open flags
79: HWAVE hWave; // handle for stream
80:
81: HANDLE hDev; // Wave device handle
82: LPWAVEHDR DeviceQueue; // Buffers queued by application
83: LPWAVEHDR NextBuffer; // Next buffer to send to device
84: DWORD BufferPosition; // How far we're into a large buffer
85: DWORD BytesOutstanding;
86: // Bytes being processed by device
87: LPWAVEHDR LoopHead; // Start of loop if any
88: DWORD LoopCount; // Number more loops to go
89:
90: WAVEOVL DummyWaveOvl; // For break loop
91: //
92: HANDLE Event; // Event for driver syncrhonization
93: // and notification of auxiliary
94: // task operation completion.
95: WAVETHREADFUNCTION AuxFunction; // Function for thread to perform
96: union {
97: LPWAVEHDR pHdr; // Buffer to pass in aux task
98: ULONG State; // State to set
99: struct {
100: ULONG Function; // IOCTL to use
101: PBYTE pData; // Data to set or get
102: ULONG DataLen; // Length of data
103: } GetSetData;
104:
105: } AuxParam;
106: // 0 means terminate task.
107: HANDLE AuxEvent1; // Aux thread waits on this
108: HANDLE AuxEvent2; // Caller of Aux thread waits on this
109: HANDLE ThreadHandle; // Handle for thread termination ONLY
110: MMRESULT AuxReturnCode; // Return code from Aux task
111: }WAVEALLOC, *PWAVEALLOC;
112:
113: PWAVEALLOC WaveHandleList; // Our chain of wave handles
114:
115:
116: //
117: // extra flag to track buffer completion
118: //
119:
120: #define WHDR_COMPLETE 0x80000000
121:
122: /*****************************************************************************
123:
124: internal function prototypes
125:
126: ****************************************************************************/
127:
128: STATIC MMRESULT waveGetDevCaps(DWORD id, UINT DeviceType, LPBYTE lpCaps,
129: DWORD dwSize);
130: STATIC DWORD waveThread(LPVOID lpParameter);
131: STATIC void waveCleanUp(PWAVEALLOC pClient);
132: STATIC MMRESULT waveThreadCall(WAVETHREADFUNCTION Function, PWAVEALLOC pClient);
133: STATIC MMRESULT waveSetState(PWAVEALLOC pClient, ULONG State);
134: STATIC MMRESULT waveWrite(LPWAVEHDR pHdr, PWAVEALLOC pClient);
135: STATIC void waveBlockFinished(LPWAVEHDR lpHdr, DWORD MsgId);
136: STATIC void waveCallback(PWAVEALLOC pWave, DWORD msg, DWORD dw1);
137: STATIC void waveCompleteBuffers(PWAVEALLOC pClient);
138: STATIC void waveFreeQ(PWAVEALLOC pClient);
139: STATIC void waveOvl(DWORD dwErrorCode, DWORD BytesTransferred, LPOVERLAPPED pOverlapped);
140:
141: /* Attempt to pre-touch up to MIN(iSize,PRETOUCHLIMIT) bytes on from pb.
142: If AllowFault then keep going to fault the stuff in.
143: Otherwise stop as soon as you notice the clock ticking
144: */
145: //PreTouch(BYTE * pb, int iSize, BOOL AllowFault)
146: //{
147: // DWORD dwTicks = GetTickCount();
148: // int pages = 0;
149: // static int Headway[100];
150: // static int c = 0;
151: // static int TotalTouches = 0;
152: // static int TimesThrough = 0; // number of times this code has run.
153: //
154: // if (iSize > PRETOUCHLIMIT) {
155: // iSize = PRETOUCHLIMIT;
156: // }
157: //
158: // ++TimesThrough;
159: //
160: // // pre-touch the pages but get out if it's taking too long
161: // // (which probably means we took a page fault.
162: // // Touch at least 2 pages as we may want 2 pages per DMA 1/2 buffer.
163: // while (iSize>0) {
164: // volatile BYTE b;
165: // b = *pb;
166: // pb += 4096; // move to next page. Are they ALWAYS 4096?
167: // iSize -= 4096; // and count it off
168: // ++pages;
169: // ++TotalTouches;
170: // if (dwTicks<GetTickCount() && pages>1 && !AllowFault) break;
171: // }
172: // Headway[c] = pages;
173: // ++c;
174: //
175: // if (c==100){
176: // for (c=0; c<=99; c += 10){
177: // dprintf(("%5ld %5ld %5ld %5ld %5ld %5ld %5ld %5ld %5ld %5ld",Headway[c],Headway[c+1],Headway[c+2],Headway[c+3],Headway[c+4],Headway[c+5],Headway[c+6],Headway[c+7],Headway[c+8],Headway[c+9]));
178: // }
179: // dprintf((" "));
180: // c = 0;
181: // }
182: //}
183:
184:
185: /****************************************************************************
186: * @doc INTERNAL
187: *
188: * @api VOID | TerminateWave | Free all wave resources
189: *
190: * @rdesc None
191: ***************************************************************************/
192: VOID TerminateWave(VOID)
193: {
194: #ifdef TERMINATE
195:
196: //
197: // This is all wrong - we need to find out how to terminate threads !
198: //
199:
200: PWAVEALLOC pClient;
201:
202: //
203: // Remove all our threads and their resources
204: //
205:
206: for (pClient = WaveHandleList; pClient != NULL; pClient = pClient->Next) {
207: if (pClient->ThreadHandle) {
208: //
209: // Kill our thread. But be careful ! It may
210: // already have gone away - so don't wait for
211: // it to set its event, just wait for it
212: // to finish
213: //
214:
215: //
216: // Set the function code
217: //
218: pClient->AuxFunction = WaveThreadTerminate;
219:
220: //
221: // Kick off the thread
222: //
223: SetEvent(pClient->AuxEvent1);
224:
225: //
226: // We created our threads with mmTaskCreate so it's
227: // safe to wait on them
228: //
229: WaitForSingleObject(pClient->ThreadHandle, INFINITE);
230: }
231: waveCleanUp(pClient);
232: }
233: #endif
234: }
235:
236: /****************************************************************************
237: * @doc INTERNAL
238: *
239: * @api void | waveGetDevCaps | Get the device capabilities.
240: *
241: * @parm DWORD | id | Device id
242: *
243: * @parm UINT | DeviceType | type of device
244: *
245: * @parm LPBYTE | lpCaps | Far pointer to a WAVEOUTCAPS structure to
246: * receive the information.
247: *
248: * @parm DWORD | dwSize | Size of the WAVEOUTCAPS structure.
249: *
250: * @rdesc MMSYS.. return code.
251: ***************************************************************************/
252: STATIC MMRESULT waveGetDevCaps(DWORD id, UINT DeviceType,
253: LPBYTE lpCaps, DWORD dwSize)
254: {
255: return sndGetData(DeviceType, id, dwSize, lpCaps,
256: IOCTL_WAVE_GET_CAPABILITIES);
257: }
258:
259: /****************************************************************************
260: * @doc INTERNAL
261: *
262: * @api DWORD | waveGetPos | Get the stream position in samples.
263: *
264: * @parm PWAVEALLOC | pClient | Client handle.
265: *
266: * @parm LPMMTIME | lpmmt | Far pointer to an MMTIME structure.
267: *
268: * @parm DWORD | dwSize | Size of the MMTIME structure.
269: *
270: * @rdesc MMSYS... return value.
271: ***************************************************************************/
272: MMRESULT waveGetPos(PWAVEALLOC pClient, LPMMTIME lpmmt, DWORD dwSize)
273: {
274: WAVE_DD_POSITION PositionData;
275: MMRESULT mErr;
276:
277: if (dwSize < sizeof(MMTIME))
278: return MMSYSERR_ERROR;
279:
280: //
281: // Get the current position from the driver
282: //
283: mErr = sndGetHandleData(pClient->hDev,
284: sizeof(PositionData),
285: &PositionData,
286: IOCTL_WAVE_GET_POSITION,
287: pClient->Event);
288:
289: if (mErr == MMSYSERR_NOERROR) {
290: if (lpmmt->wType == TIME_BYTES) {
291: lpmmt->u.cb = PositionData.ByteCount;
292: }
293:
294: // default is samples.
295: else {
296: lpmmt->wType = TIME_SAMPLES;
297: lpmmt->u.sample = PositionData.SampleCount;
298: }
299: }
300:
301: return mErr;
302: }
303:
304: /****************************************************************************
305: * @doc INTERNAL
306: *
307: * @api MMRESULT | waveOpen | Open wave device and set up logical device data
308: * and auxilary task for issuing requests and servicing Apc's
309: *
310: * @parm WAVEDEVTYPE | DeviceType | Whether it's a wave input or output device
311: *
312: * @parm DWORD | id | The device logical id
313: *
314: * @parm DWORD | msg | Input parameter to wodMessage
315: *
316: * @parm DWORD | dwUser | Input parameter to wodMessage - pointer to
317: * application's handle (generated by this routine)
318: *
319: * @parm DWORD | dwParam1 | Input parameter to wodMessage
320: *
321: * @parm DWORD | dwParam2 | Input parameter to wodMessage
322: *
323: * @rdesc wodMessage return code.
324: ***************************************************************************/
325:
326: STATIC MMRESULT waveOpen(UINT DeviceType,
327: DWORD id,
328: DWORD dwUser,
329: DWORD dwParam1,
330: DWORD dwParam2)
331: {
332: PWAVEALLOC pClient; // pointer to client information structure
333: MMRESULT mRet;
334: BOOL Result;
335: DWORD BytesReturned;
336: LPPCMWAVEFORMAT Format;
337:
338: // dwParam1 contains a pointer to a WAVEOPENDESC
339: // dwParam2 contains wave driver specific flags in the LOWORD
340: // and generic driver flags in the HIWORD
341:
342: //
343: // If it's only a query to check if the device supports our format
344: // we :
345: // Open the device
346: // Test the format
347: // Close the device
348: //
349:
350: if (dwParam2 & WAVE_FORMAT_QUERY) {
351: HANDLE hDev;
352:
353: //
354: // See if we can open our device
355: // Only open for read (this should always work for our devices
356: // unless there are system problems).
357: //
358:
359: mRet = sndOpenDev(DeviceType,
360: id,
361: &hDev,
362: GENERIC_READ);
363:
364: if (mRet != MMSYSERR_NOERROR) {
365: return mRet;
366: }
367:
368: //
369: // Check the format
370: //
371: Format = (LPPCMWAVEFORMAT)((LPWAVEOPENDESC)dwParam1)->lpFormat;
372: Result = DeviceIoControl(
373: hDev,
374: IOCTL_WAVE_QUERY_FORMAT,
375: (PVOID)Format,
376: sizeof(PCMWAVEFORMAT) +
377: (Format->wf.wFormatTag == WAVE_FORMAT_PCM ? 0 :
378: *(LPWORD)(Format + 1)),
379: // Input buffer size
380: NULL, // Output buffer
381: 0, // Output buffer size
382: &BytesReturned,
383: NULL);
384:
385:
386: //
387: // Only a query so close the device
388: //
389:
390: CloseHandle(hDev);
391:
392: return Result ? MMSYSERR_NOERROR :
393: GetLastError() == ERROR_NOT_SUPPORTED ? WAVERR_BADFORMAT :
394: sndTranslateStatus();
395: }
396:
397: //
398: // See if we've got this device already in our list (in
399: // which case we have a thread and events for it already made)
400: //
401:
402: EnterCriticalSection(&mmDrvCritSec);
403:
404: for (pClient = WaveHandleList;
405: pClient != NULL;
406: pClient = pClient->Next) {
407: if (pClient->DeviceNumber == id &&
408: pClient->DeviceType == DeviceType) {
409: //
410: // We already have a thread and resources for this device
411: //
412:
413: if (pClient->hDev != INVALID_HANDLE_VALUE) {
414: //
415: // Someone else is using it!
416: //
417:
418: LeaveCriticalSection(&mmDrvCritSec);
419: return MMSYSERR_ALLOCATED;
420: }
421: break;
422: }
423: }
424:
425: //
426: // allocate my per-client structure and zero it (LPTR).
427: //
428:
429: if (pClient == NULL) {
430: pClient = (PWAVEALLOC)HeapAlloc(hHeap, 0, sizeof(WAVEALLOC));
431: if (pClient == NULL) {
432: LeaveCriticalSection(&mmDrvCritSec);
433: return MMSYSERR_NOMEM;
434: }
435:
436: dprintf2(("Creating new device resource for device id %d, type %s",
437: id,
438: DeviceType == WaveInDevice ? "Wave Input" : "Wave Output"));
439:
440: memset((PVOID)pClient, 0, sizeof(WAVEALLOC));
441:
442: //
443: // Add it to the list
444: //
445: pClient->DeviceNumber = id;
446: pClient->DeviceType = DeviceType;
447: pClient->Next = WaveHandleList;
448: WaveHandleList = pClient;
449: }
450:
451:
452: //
453: // and fill it with info
454: //
455:
456: pClient->dwCallback = ((LPWAVEOPENDESC)dwParam1)->dwCallback;
457: pClient->dwInstance = ((LPWAVEOPENDESC)dwParam1)->dwInstance;
458: pClient->hWave = ((LPWAVEOPENDESC)dwParam1)->hWave;
459: pClient->dwFlags = dwParam2;
460:
461: // pClient->hDev is initialized by sndOpenDev
462:
463: pClient->DeviceQueue = NULL;
464: pClient->NextBuffer = NULL;
465: pClient->BufferPosition = 0;
466: pClient->BytesOutstanding = 0;
467: pClient->LoopHead = NULL;
468: pClient->LoopCount = 0;
469:
470: //
471: // See if we can open our device
472: // We could get ERROR_BUSY if someone else is has the device open
473: // for writing.
474: //
475:
476: mRet = sndOpenDev(DeviceType,
477: id,
478: &pClient->hDev,
479: (GENERIC_READ | GENERIC_WRITE));
480:
481: if (mRet != MMSYSERR_NOERROR) {
482:
483: WinAssert(pClient->hDev == INVALID_HANDLE_VALUE);
484: LeaveCriticalSection(&mmDrvCritSec);
485: return mRet;
486: }
487:
488:
489: //
490: // make sure we can handle the format and set it.
491: //
492:
493: Result = DeviceIoControl(
494: pClient->hDev,
495: IOCTL_WAVE_SET_FORMAT,
496: (PVOID)((LPWAVEOPENDESC)dwParam1)->lpFormat,
497: /* BUGBUG NOT GENERAL */sizeof(PCMWAVEFORMAT), // Input buffer size
498: NULL, // Output buffer
499: 0, // Output buffer size
500: &BytesReturned,
501: NULL);
502:
503:
504: if (!Result) {
505: CloseHandle(pClient->hDev);
506: pClient->hDev = INVALID_HANDLE_VALUE;
507: LeaveCriticalSection(&mmDrvCritSec);
508: return GetLastError() == ERROR_NOT_SUPPORTED ? WAVERR_BADFORMAT :
509: sndTranslateStatus();
510: }
511:
512: LeaveCriticalSection(&mmDrvCritSec);
513:
514: //
515: // Create our event for synchronization with the kernel driver
516: //
517:
518: if (!pClient->Event) {
519: pClient->Event = CreateEvent(NULL, FALSE, FALSE, NULL);
520: if (pClient->Event == NULL) {
521: waveCleanUp(pClient);
522: return MMSYSERR_NOMEM;
523: }
524: //
525: // Create our event for our thread to wait on
526: //
527:
528: pClient->AuxEvent1 = CreateEvent(NULL, FALSE, FALSE, NULL);
529: if (!pClient->AuxEvent1) {
530: waveCleanUp(pClient);
531: return MMSYSERR_NOMEM;
532: }
533: //
534: // Create our event for waiting for the auxiliary thread
535: //
536:
537: pClient->AuxEvent2 = CreateEvent(NULL, FALSE, FALSE, NULL);
538: if (!pClient->AuxEvent2) {
539: waveCleanUp(pClient);
540: return MMSYSERR_NOMEM;
541: }
542:
543: //
544: // Create our auxiliary thread for sending buffers to the driver
545: // and collecting Apcs
546: //
547:
548: mRet = mmTaskCreate((LPTASKCALLBACK)waveThread,
549: &pClient->ThreadHandle,
550: (DWORD)pClient);
551:
552: if (mRet != MMSYSERR_NOERROR) {
553: waveCleanUp(pClient);
554: return MMSYSERR_NOMEM;
555: }
556:
557: //
558: // Make sure the thread has really started
559: //
560:
561: WaitForSingleObject(pClient->AuxEvent2, INFINITE);
562: }
563:
564: //
565: // give the client my driver dw
566: //
567: {
568: PWAVEALLOC *pUserHandle;
569: pUserHandle = (PWAVEALLOC *)dwUser;
570: *pUserHandle = pClient;
571: }
572:
573: //
574: // sent client his OPEN callback message
575: //
576: waveCallback(pClient, DeviceType == WaveOutDevice ? WOM_OPEN : WIM_OPEN, 0L);
577:
578: return MMSYSERR_NOERROR;
579: }
580:
581: /****************************************************************************
582: * @doc INTERNAL
583: *
584: * @api void | waveCleanUp | Free resources for a wave device
585: *
586: * @parm PWAVEALLOC | pClient | Pointer to a WAVEALLOC structure describing
587: * resources to be freed.
588: *
589: * @rdesc There is no return value.
590: *
591: * @comm If the pointer to the resource is NULL then the resource has not
592: * been allocated.
593: ***************************************************************************/
594: STATIC void waveCleanUp(PWAVEALLOC pClient)
595: {
596: EnterCriticalSection(&mmDrvCritSec);
597: if (pClient->hDev != INVALID_HANDLE_VALUE) {
598: CloseHandle(pClient->hDev);
599: pClient->hDev = INVALID_HANDLE_VALUE;
600: }
601: if (pClient->AuxEvent1) {
602: CloseHandle(pClient->AuxEvent1);
603: pClient->AuxEvent1 = NULL;
604: }
605: if (pClient->AuxEvent2) {
606: CloseHandle(pClient->AuxEvent2);
607: pClient->AuxEvent2 = NULL;
608: }
609: if (pClient->Event) {
610: CloseHandle(pClient->Event);
611: pClient->Event = NULL;
612: }
613: LeaveCriticalSection(&mmDrvCritSec);
614: }
615:
616:
617: /****************************************************************************
618: * @doc INTERNAL
619: *
620: * @api MMRESULT | waveWrite | Pass a new buffer to the Auxiliary thread for
621: * a wave device.
622: *
623: * @parm LPWAVEHDR | pHdr | Pointer to a wave buffer
624: *
625: * @parm PWAVEALLOC | pClient | The data associated with the logical wave
626: * device.
627: *
628: * @rdesc A MMSYS... type return code for the application.
629: *
630: * @comm The buffer flags are set and the buffer is passed to the auxiliary
631: * device task for processing.
632: ***************************************************************************/
633: STATIC MMRESULT waveWrite(LPWAVEHDR pHdr, PWAVEALLOC pClient)
634: {
635: //
636: // Put the request at the end of our queue.
637: //
638: pHdr->dwFlags |= WHDR_INQUEUE;
639: pHdr->dwFlags &= ~WHDR_DONE;
640: pClient->AuxParam.pHdr = pHdr;
641: return waveThreadCall(WaveThreadAddBuffer, pClient);
642: }
643:
644: /****************************************************************************
645: * @doc INTERNAL
646: *
647: * @api MMRESULT | waveSetState | Set a wave device to a given state
648: * This function is executed on the Auxiliary thread to synchronize
649: * correctly.
650: *
651: * @parm PWAVEALLOC | pClient | The data associated with the logical wave
652: * output device.
653: *
654: * @parm ULONG | State | The new state
655: *
656: * @rdesc A MMSYS... type return code for the application.
657: ***************************************************************************/
658: STATIC MMRESULT waveSetState(PWAVEALLOC pClient, ULONG State)
659: {
660: return sndSetHandleData(pClient->hDev,
661: sizeof(State),
662: &State,
663: IOCTL_WAVE_SET_STATE,
664: pClient->Event);
665: }
666:
667: /****************************************************************************
668: * @doc INTERNAL
669: *
670: * @api void | waveBlockFinished | This function sets the done bit and invokes
671: * the callback function if there is one.
672: *
673: * @parm LPWAVEHDR | lpHdr | Far pointer to the header.
674: *
675: * @rdesc There is no return value.
676: ***************************************************************************/
677: STATIC void waveBlockFinished(LPWAVEHDR lpHdr, DWORD MsgId)
678: {
679: PWAVEALLOC pWav;
680:
681: D3(("blkfin: lpHdr = %x", lpHdr));
682: // Clear our private flag
683: lpHdr->dwFlags &= ~WHDR_COMPLETE;
684:
685: // We are giving the block back to the application. The header is no
686: // longer in our queue, so we reset the WHDR_INQUEUE bit. Also, we
687: // clear our driver specific bit and cauterize the lpNext pointer.
688: lpHdr->dwFlags &= ~WHDR_INQUEUE;
689: lpHdr->lpNext = NULL;
690:
691: pWav = (PWAVEALLOC)(lpHdr->reserved);
692:
693: // set the 'done' bit - note that some people poll this bit.
694: lpHdr->dwFlags |= WHDR_DONE;
695:
696: // invoke the callback function
697: waveCallback(pWav, MsgId, (DWORD)lpHdr);
698: }
699:
700:
701: /****************************************************************************
702: * @doc INTERNAL
703: *
704: * @api MMRESULT | waveThreadCall | Set the function for the thread to perform
705: * and 'call' the thread using the event pair mechanism.
706: *
707: * @parm WAVETHREADFUNCTION | Function | The function to perform
708: *
709: * @parm PWAVEALLOC | Our logical device data
710: *
711: * @rdesc An MMSYS... type return value suitable for returning to the
712: * application
713: *
714: * @comm The AuxParam field in the device data is the 'input' to
715: * the function processing loop in WaveThread().
716: ***************************************************************************/
717: STATIC MMRESULT waveThreadCall(WAVETHREADFUNCTION Function, PWAVEALLOC pClient)
718: {
719: //
720: // Trap any failures
721: //
722: WinAssert(pClient->hDev != INVALID_HANDLE_VALUE);
723:
724: //
725: // Set the function code
726: //
727: pClient->AuxFunction = Function;
728:
729: //
730: // Kick off the thread
731: //
732: SetEvent(pClient->AuxEvent1);
733:
734: //
735: // Wait for it to complete
736: //
737: WaitForSingleObject(pClient->AuxEvent2, INFINITE);
738:
739: //
740: // Return the return code that our task set.
741: //
742: return pClient->AuxReturnCode;
743: }
744:
745: /****************************************************************************
746: * @doc INTERNAL
747: *
748: * @api MMRESULT | wavePartialApc | Called when a partial buffer is complete.
749: *
750: * @parm DWORD | BytesTransferred | Not relevant to us
751: *
752: * @parm LPOVERLAPPED | pOverLapped | Overlapped structure for this callback
753: *
754: * @rdesc None
755: *
756: * @comm The IO status block is freed and the BytesOutstanding count
757: * used to limit the buffers we have locked down is updated (we
758: * know here that parital buffers are all the same size).
759: * Also the byte count for a recording buffer is updated.
760: ***************************************************************************/
761: STATIC void wavePartialOvl(DWORD dwErrorCode, DWORD BytesTransferred, LPOVERLAPPED pOverlapped)
762: {
763: LPWAVEHDR pHdr;
764: PWAVEALLOC pClient;
765:
766: pHdr = ((PWAVEOVL)pOverlapped)->WaveHdr;
767: D3(("wavePartialOvl: pHdr = %x", pHdr));
768:
769: pClient = (PWAVEALLOC)pHdr->reserved;
770:
771: //
772: // We can't trust the IO system to return our buffers in the right
773: // order so we set a flag in the buffer but only complete buffers
774: // at the FRONT of the queue which have the flag set. In fact
775: // we don't process the stuff here - leave that for when we
776: // exit the wait because calling the client's callback can
777: // do nasty things inside and Apc routine
778: //
779:
780: WinAssert(pHdr->dwFlags & WHDR_INQUEUE);
781: WinAssert(!(pHdr->dwFlags & WHDR_COMPLETE));
782:
783: //
784: // Recalculate how many bytes are outstanding on the device
785: //
786:
787: pClient->BytesOutstanding -= MAX_BUFFER_SIZE;
788:
789: //
790: // Work out how much was recorded if we're a recording device
791: //
792:
793: if (pClient->DeviceType == WaveInDevice) {
794: pHdr->dwBytesRecorded += BytesTransferred;
795: }
796:
797: //
798: // Free our Iosb
799: //
800:
801: HeapFree(hHeap, 0, (LPSTR)pOverlapped);
802:
803: }
804:
805:
806:
807: /****************************************************************************
808: * @doc INTERNAL
809: *
810: * @api void | waveOvl | Called when a (user) buffer is complete.
811: *
812: * @parm DWORD | BytesTransferred | Not relevant to us
813: *
814: * @parm LPOVERLAPPED | pOverLapped | Overlapped structure for this callback
815: *
816: * @parm PIO_STATUS_BLOCK | The Io status block we used
817: *
818: * @rdesc None
819: *
820: * @comm The IO status block is freed and the BytesOutstanding count
821: * used to limit the buffers we have locked down is updated (we
822: * know here that parital buffers are all the same size so we
823: * can compute the size of the 'last' buffer for a given user buffer).
824: * Also the byte count for a recording buffer is updated.
825: * The user buffer is marked as 'DONE'.
826: ***************************************************************************/
827: STATIC void waveOvl(DWORD dwErrorCode, DWORD BytesTransferred, LPOVERLAPPED pOverlapped)
828: {
829: PWAVEHDR pHdr;
830: PWAVEALLOC pClient;
831:
832: pHdr = ((PWAVEOVL)pOverlapped)->WaveHdr;
833: D3(("waveOvl: pHdr = %x", pHdr));
834: pClient = (PWAVEALLOC)pHdr->reserved;
835:
836: //
837: // We can't trust the IO system to return our buffers in the right
838: // order so we set a flag in the buffer but only complete buffers
839: // at the FRONT of the queue which have the flag set. In fact
840: // we don't process the stuff here - leave that for when we
841: // exit the wait because calling the client's callback can
842: // do nasty things inside and Apc routine
843: //
844:
845: WinAssert(pHdr->dwFlags & WHDR_INQUEUE);
846: WinAssert(!(pHdr->dwFlags & WHDR_COMPLETE));
847:
848: //
849: // Mark buffer as done unless we're doing more loops with it
850: //
851: pHdr->dwFlags |= WHDR_COMPLETE;
852:
853: //
854: // It's now our duty to see if there were some old loops lying
855: // around earlier in the queue which are vestiges of old loops.
856: //
857:
858: if (pHdr->dwFlags & WHDR_BEGINLOOP) {
859: PWAVEHDR pHdrSearch;
860: for (pHdrSearch = pClient->DeviceQueue ;
861: pHdrSearch != pHdr ;
862: pHdrSearch = pHdrSearch->lpNext) {
863: WinAssert(pHdrSearch != NULL);
864: pHdrSearch->dwFlags |= WHDR_COMPLETE;
865: }
866: }
867: //
868: // Recalculate how many bytes are outstanding on the device
869: //
870:
871: if (pHdr->dwBufferLength) {
872: pClient->BytesOutstanding -= (pHdr->dwBufferLength - 1) %
873: MAX_BUFFER_SIZE + 1;
874: }
875:
876: //
877: // Work out how much was recorded if we're a recording device
878: //
879:
880: if (pClient->DeviceType == WaveInDevice) {
881: pHdr->dwBytesRecorded += BytesTransferred;
882: }
883:
884: //
885: // Free our Iosb
886: //
887:
888: HeapFree(hHeap, 0, (LPSTR)pOverlapped);
889:
890: }
891:
892: /****************************************************************************
893: * @doc INTERNAL
894: *
895: * @api MMRESULT | waveLoopOvl | Called when a (user) buffer is complete.
896: * but the buffer was need for more loops.
897: *
898: * @parm DWORD | BytesTransferred | Not relevant to us
899: *
900: * @parm LPOVERLAPPED | pOverLapped | Overlapped structure for this callback
901: *
902: * @rdesc None
903: *
904: * @comm Same as waveApc but the buffer is not marked complete.
905: ***************************************************************************/
906: STATIC void waveLoopOvl(DWORD dwErrorCode, DWORD BytesTransferred, LPOVERLAPPED pOverlapped)
907: {
908: DWORD dwFlags;
909: PWAVEHDR pHdr;
910:
911: D3(("waveLoopOvl"));
912: pHdr = ((PWAVEOVL)pOverlapped)->WaveHdr;
913:
914: //
915: // Do it this way to avoid falling into a hole if the Apcs are
916: // in the wrong order !!!
917: //
918: dwFlags = pHdr->dwFlags;
919: waveOvl(dwErrorCode, BytesTransferred, pOverlapped);
920: pHdr->dwFlags = dwFlags;
921: }
922:
923: /****************************************************************************
924: * @doc INTERNAL
925: *
926: * @api MMRESULT | waveBreakOvl | Used to chase out a buffer to break a loop.
927: *
928: * @parm DWORD | BytesTransferred | Not relevant to us
929: *
930: * @parm LPOVERLAPPED | pOverLapped | Overlapped structure for this callback
931: *
932: * @rdesc None
933: *
934: * @comm Mark the relevant buffer complete
935: ***************************************************************************/
936: STATIC void waveBreakOvl(DWORD dwErrorCode, DWORD BytesTransferred, LPOVERLAPPED pOverlapped)
937: {
938: D3(("waveBreakOvl"));
939: ((PWAVEOVL)pOverlapped)->WaveHdr->dwFlags |= WHDR_COMPLETE;
940: }
941:
942:
943: /****************************************************************************
944: * @doc INTERNAL
945: *
946: * @api void | waveStart | Send more buffers to the device if possible
947: *
948: * @parm PWAVEALLOC | pClient | The client's handle data
949: *
950: * @rdesc There is no return code.
951: *
952: * @comm The routine is called both when new buffers become available
953: * or when old buffers or parital buffers are completed so
954: * that device can accept more data.
955: *
956: * No more that MAX_WAVE_BYTES in buffers no bigger than
957: * MAX_BUFFER_SIZE are to be outstanding on the device at
958: * any one time.
959: *
960: * An additional complication is that we have to process loops
961: * which means (among other things) that the SAME BUFFER may
962: * appear multiple times in the driver's list (as different
963: * requests). There are no loops for input devices.
964: * Loop buffers complete with Apcs which do not complete them
965: * (except for the final loop iteration) which means that if
966: * we decide unexpectedly to finish a loop (ie by waveOutBreakLoop)
967: * we must 'chase' the loop out with an artificial buffer to
968: * get our Apc going.
969: *
970: ***************************************************************************/
971: STATIC MMRESULT waveStart(PWAVEALLOC pClient)
972: {
973: DWORD dwSize;
974: BOOL Result;
975:
976: //
977: // See if we can fit any more data on the device
978: //
979:
980: WinAssert(pClient->hDev != INVALID_HANDLE_VALUE);
981:
982: while (pClient->NextBuffer) {
983: PWAVEHDR pHdr;
984:
985: pHdr = pClient->NextBuffer;
986:
987: WinAssert(pClient->DeviceQueue != NULL);
988: WinAssert(!(pHdr->dwFlags & (WHDR_DONE | WHDR_COMPLETE)));
989:
990: dwSize = pHdr->dwBufferLength - pClient->BufferPosition;
991: if (dwSize > MAX_BUFFER_SIZE) {
992: dwSize = MAX_BUFFER_SIZE;
993: }
994:
995: if (dwSize + pClient->BytesOutstanding <= MAX_WAVE_BYTES) {
996: //
997: // OK - we can fit another buffer in
998: //
999: // Don't have our overlay structure on the stack for an
1000: // ASYNCHRONOUS IO ! Otherwise the IO subsystem will overwrite
1001: // somebody else's data when the operation completes
1002: //
1003: PWAVEOVL pWaveOvl;
1004:
1005: if (pClient->BufferPosition == 0) {
1006: //
1007: // Start of new buffer
1008: // See if the buffer is the start of a new loop
1009: // (Check not continuation of old one)
1010: //
1011: if (pClient->NextBuffer &&
1012: (pClient->NextBuffer->dwFlags & WHDR_BEGINLOOP) &&
1013: pClient->NextBuffer != pClient->LoopHead) {
1014:
1015: pClient->LoopHead = pClient->NextBuffer;
1016:
1017: pClient->LoopCount = pClient->NextBuffer->dwLoops;
1018:
1019: //
1020: // Loop count is number of times to play
1021: //
1022: if (pClient->LoopCount > 0) {
1023: pClient->LoopCount--;
1024: }
1025: }
1026: //
1027: // See if the loop is actually finished
1028: //
1029: if (pClient->LoopCount == 0) {
1030: pClient->LoopHead = NULL;
1031: }
1032:
1033: }
1034:
1035: pWaveOvl = (PWAVEOVL)HeapAlloc(hHeap, 0, sizeof(*pWaveOvl));
1036:
1037: if (pWaveOvl == NULL) {
1038: return MMSYSERR_NOMEM;
1039: }
1040:
1041: memset((PVOID)pWaveOvl, 0, sizeof(*pWaveOvl));
1042:
1043: pWaveOvl->WaveHdr = pHdr;
1044:
1045: if (pClient->DeviceType == WaveOutDevice) {
1046: Result = WriteFileEx(
1047: pClient->hDev,
1048: (PBYTE)pHdr->lpData + // Output buffer
1049: pClient->BufferPosition,
1050: dwSize,
1051: (LPOVERLAPPED)pWaveOvl, // Overlap structure
1052: pHdr->dwBufferLength !=
1053: pClient->BufferPosition + dwSize ?
1054: wavePartialOvl :
1055: NULL != pClient->LoopHead ?
1056: waveLoopOvl :
1057: waveOvl); // Overlap callback
1058: } else {
1059: Result = ReadFileEx(
1060: pClient->hDev,
1061: (PBYTE)pHdr->lpData + // Output buffer
1062: pClient->BufferPosition,
1063: dwSize,
1064: (LPOVERLAPPED)pWaveOvl, // Overlap structure
1065: pHdr->dwBufferLength !=
1066: pClient->BufferPosition + dwSize ?
1067: wavePartialOvl :
1068: NULL != pClient->LoopHead ?
1069: waveLoopOvl :
1070: waveOvl); // Overlap callback
1071: }
1072:
1073: dprintf3(("Sent %u wave bytes to device, return code %8X",
1074: dwSize, GetLastError()));
1075:
1076: if (!Result && GetLastError() != ERROR_IO_PENDING) {
1077:
1078: //
1079: // Free the Iosb since we won't be getting any callbacks
1080: //
1081: HeapFree(hHeap, 0, (LPSTR)pWaveOvl);
1082:
1083: //
1084: // If the driver has not got any bytes outstanding then
1085: // everything may grind to a halt so release everything
1086: // here and notify 'completion' (ie mark all buffers
1087: // complete). This is unsatisfactory but there's no
1088: // way of telling the application what happenend.
1089: //
1090:
1091: if (pClient->BytesOutstanding == 0) {
1092:
1093: //
1094: // This will cause acknowlegements to be made when
1095: // waveCompleteBuffers is run
1096: //
1097: waveFreeQ(pClient);
1098: }
1099: return sndTranslateStatus();
1100:
1101: } else {
1102: //
1103: // We successfully queued the buffer
1104: // Update our local data
1105: //
1106: pClient->BytesOutstanding += dwSize;
1107: pClient->BufferPosition += dwSize;
1108: if (pClient->BufferPosition == pHdr->dwBufferLength) {
1109: //
1110: // Finished this buffer - move on to the next
1111: //
1112: if (!pClient->LoopHead ||
1113: !(pHdr->dwFlags & WHDR_ENDLOOP)) {
1114: //
1115: // Not end of in a loop so we can free this buffer
1116: //
1117: pClient->NextBuffer = pHdr->lpNext;
1118:
1119: } else {
1120: //
1121: // Finished a loop
1122: //
1123: if (pClient->LoopCount != 0) {
1124: pClient->LoopCount--;
1125: pClient->NextBuffer = pClient->LoopHead;
1126: } else {
1127: //
1128: // Someone's tried to kill us. We have
1129: // to 'chase out' the start of this loop
1130: // so send a dummy (NULL) packet at the
1131: // back of the driver's queue
1132: //
1133:
1134: pClient->DummyWaveOvl.WaveHdr = pClient->LoopHead;
1135:
1136: Result =
1137: WriteFileEx(
1138: pClient->hDev,
1139: (PVOID)pHdr->lpData,
1140: 0,
1141: &pClient->DummyWaveOvl.Ovl, // Static for async
1142: waveBreakOvl);
1143:
1144: if (Result || GetLastError() == ERROR_IO_PENDING) {
1145: pClient->LoopHead = NULL; // Loop complete
1146: pClient->NextBuffer = pHdr->lpNext;
1147: }
1148: }
1149: }
1150: pClient->BufferPosition = 0;
1151: }
1152: }
1153: {
1154: // /* Before we go home, let's just touch ONE page - if there is one */
1155: // PBYTE pb = (PBYTE)pHdr->lpData + pClient->BufferPosition;
1156: // pb = ((DWORD)pb & 0xFFFFF000) + 0x1000; /* find page start of next page */
1157: //
1158: // if ( (PBYTE)pHdr->lpData + pHdr->dwBufferLength > pb )
1159: // PreTouch( pb, 1, FALSE);
1160:
1161: // /* Before we go home, let's just try to pre-touch that which we will soon want */
1162: // PreTouch( (PBYTE)pHdr->lpData + pClient->BufferPosition
1163: // , pHdr->dwBufferLength - pClient->BufferPosition
1164: // , FALSE
1165: // );
1166: }
1167:
1168: } else {
1169: //
1170: // Cannot fit any more bytes in at the moment
1171: //
1172:
1173: // /* Before we go home, let's just try to pre-touch that which we will soon want */
1174: // PreTouch( (PBYTE)pHdr->lpData + pClient->BufferPosition
1175: // , pHdr->dwBufferLength - pClient->BufferPosition
1176: // , FALSE
1177: // );
1178:
1179: /* NOW go home! */
1180: break;
1181: }
1182: }
1183: return MMSYSERR_NOERROR;
1184: }
1185:
1186:
1187: /****************************************************************************
1188: * @doc INTERNAL
1189: *
1190: * @api void | waveCompleteBuffers | Buffer completion routine. This completes
1191: * the work of the Apc routine at below Apc priority. This gets
1192: * round the nasty situations arising when the user's callback
1193: * causes more apcs to run (I strongly suspect this is a kernel
1194: * bug).
1195: *
1196: * @parm PWAVEALLOC | pClient | The client's handle data
1197: *
1198: * @rdesc There is no return code.
1199: ***************************************************************************/
1200: STATIC void waveCompleteBuffers(PWAVEALLOC pClient)
1201: {
1202: //
1203: // Process buffers from the front of our queue unless we're in
1204: // a loop
1205: //
1206:
1207: while (pClient->DeviceQueue &&
1208: (pClient->DeviceQueue->dwFlags & WHDR_COMPLETE)) {
1209:
1210: PWAVEHDR pHdr;
1211:
1212: pHdr = pClient->DeviceQueue;
1213: //
1214: // Release buffer
1215: //
1216: pClient->DeviceQueue = pHdr->lpNext;
1217:
1218:
1219: //
1220: // Complete our buffer - note - this can cause another
1221: // buffer to be marked as complete if the client's
1222: // callback runs into an alertable wait.
1223: //
1224:
1225: waveBlockFinished(pHdr,
1226: pClient->DeviceType == WaveOutDevice ?
1227: WOM_DONE : WIM_DATA);
1228: }
1229:
1230: //
1231: // We might be able to start some more output at this point
1232: //
1233:
1234: waveStart(pClient);
1235: }
1236:
1237:
1238: /****************************************************************************
1239: * @doc INTERNAL
1240: *
1241: * @api void | waveFreeQ | Mark all outstanding buffers complete
1242: *
1243: * @parm PWAVEALLOC | pClient | The client's handle data
1244: *
1245: * @rdesc There is no return code.
1246: ***************************************************************************/
1247: STATIC void waveFreeQ(PWAVEALLOC pClient)
1248: {
1249: PWAVEHDR pHdr;
1250: for (pHdr = pClient->DeviceQueue;
1251: pHdr != NULL;
1252: pHdr = pHdr->lpNext) {
1253: pHdr->dwFlags |= WHDR_COMPLETE;
1254: }
1255: //
1256: // Tidy up next buffer
1257: //
1258: pClient->NextBuffer = NULL;
1259: pClient->BufferPosition = 0;
1260: }
1261:
1262: #if 0
1263: typedef struct {
1264: LPBYTE Addr;
1265: DWORD Len;
1266: } PRETOUCHTHREADPARM;
1267:
1268: /* asynchronous pre-toucher thread */
1269: DWORD PreToucher(DWORD dw)
1270: {
1271: PRETOUCHTHREADPARM * pttp;
1272:
1273: int iSize;
1274: BYTE * pb;
1275:
1276: pttp = (PRETOUCHTHREADPARM *) dw;
1277: iSize = pttp->Len;
1278: pb = pttp->Addr;
1279:
1280: LocalFree(pttp);
1281:
1282: while (iSize>0) {
1283: volatile BYTE b;
1284: b = *pb;
1285: pb += 4096; // move to next page. Are they ALWAYS 4096?
1286: iSize -= 4096; // and count it off
1287: }
1288: dprintf(("All pretouched!"));
1289: return 0;
1290: }
1291: #endif //0
1292:
1293: /****************************************************************************
1294: * @doc INTERNAL
1295: *
1296: * @api DWORD | waveThread | Wave device auxiliary thread.
1297: *
1298: * @parm LPVOID | lpParameter | The thread parameter. In our case this is a
1299: * pointer to our wave device data.
1300: *
1301: * @rdesc Thread return code.
1302: ***************************************************************************/
1303: STATIC DWORD waveThread(LPVOID lpParameter)
1304: {
1305: PWAVEALLOC pClient;
1306: BOOL Terminate;
1307: // DWORD dwThread; // garbage
1308:
1309:
1310: Terminate = FALSE;
1311:
1312: pClient = (PWAVEALLOC)lpParameter;
1313:
1314: //
1315: // Set our thread to high priority so we don't fail to pass
1316: // new buffers to the device
1317: //
1318:
1319: SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
1320:
1321: //
1322: // We start by waiting for something signalling that we've started
1323: // and waiting for something to do.
1324: //
1325:
1326: SetEvent(pClient->AuxEvent2);
1327: WaitForSingleObject(pClient->AuxEvent1, INFINITE);
1328:
1329: //
1330: // Now we're going
1331: //
1332:
1333: for (;;) {
1334: WinAssert(pClient->hDev != INVALID_HANDLE_VALUE);
1335:
1336: //
1337: // Decode function number to perform
1338: //
1339:
1340: switch (pClient->AuxFunction) {
1341: case WaveThreadAddBuffer:
1342: //
1343: // Intialize bytes recorded
1344: //
1345: if (pClient->DeviceType == WaveInDevice) {
1346: pClient->AuxParam.pHdr->dwBytesRecorded = 0;
1347: }
1348:
1349: //
1350: // Add the buffer to our list
1351: //
1352: {
1353: LPWAVEHDR *pHdrSearch;
1354:
1355: pClient->AuxParam.pHdr->lpNext = NULL;
1356:
1357: pHdrSearch = &pClient->DeviceQueue;
1358: while (*pHdrSearch) {
1359: pHdrSearch = &(*pHdrSearch)->lpNext;
1360: }
1361:
1362: *pHdrSearch = pClient->AuxParam.pHdr;
1363: }
1364: // {
1365: // PRETOUCHTHREADPARM * pttp;
1366: //
1367: // pttp = LocalAlloc(LMEM_FIXED,8);
1368: //
1369: // if (pttp!=NULL) {
1370: // pttp->Addr = pClient->AuxParam.pHdr->lpData;
1371: // pttp->Len = pClient->AuxParam.pHdr->dwBufferLength;
1372: // CreateThread(NULL, 0, PreToucher, pttp, 0, &dwThread);
1373: // }
1374: // }
1375: // Would need to declutter the system by WAITing for dead threads at some point???
1376:
1377: //
1378: // See if we can send more to the driver
1379: //
1380: if (pClient->NextBuffer == NULL) {
1381: pClient->NextBuffer = pClient->AuxParam.pHdr;
1382: pClient->BufferPosition = 0;
1383: }
1384:
1385:
1386: // /* Before we waveStart, let's just try to pre-touch that which we will soon want */
1387: // {
1388: // PWAVEHDR pHdr = pClient->NextBuffer;
1389: // DWORD dwTick = GetTickCount();
1390: // PreTouch( (PBYTE)pHdr->lpData + pClient->BufferPosition
1391: // , pHdr->dwBufferLength - pClient->BufferPosition
1392: // , TRUE
1393: // );
1394: // dprintf(("pre-touched out to limit. Took %d mSec", GetTickCount()-dwTick));
1395: // }
1396:
1397: pClient->AuxReturnCode = waveStart(pClient);
1398: break;
1399:
1400: case WaveThreadSetState:
1401: //
1402: // We have to make sure at least ONE buffer gets
1403: // completed if we're doing input and it's input.
1404: //
1405:
1406:
1407:
1408: //
1409: // Set Device state. By issuing state changes on THIS
1410: // thread the calling thread can be sure that all Apc's
1411: // generated by buffer completions will complete
1412: // BEFORE this function completes.
1413: //
1414:
1415: pClient->AuxReturnCode =
1416: waveSetState(pClient, pClient->AuxParam.State);
1417:
1418:
1419: //
1420: // Free the rest of our buffers if we're resetting
1421: //
1422:
1423: if (pClient->AuxParam.State == WAVE_DD_RESET) {
1424: //
1425: // Cancel any loops
1426: //
1427: pClient->LoopHead = NULL;
1428:
1429: //
1430: // This function must ALWAYS succeed
1431: // Note that waveSetState closes the device on failure
1432: //
1433: pClient->AuxReturnCode = MMSYSERR_NOERROR;
1434:
1435: //
1436: // Check this worked (even if the driver's OK the
1437: // IO subsystem can fail)
1438: //
1439: WinAssert(pClient->BytesOutstanding == 0);
1440:
1441: //
1442: // Free all buffers
1443: //
1444: waveFreeQ(pClient);
1445:
1446: } else {
1447: if (pClient->DeviceType == WaveInDevice &&
1448: pClient->AuxReturnCode == MMSYSERR_NOERROR) {
1449:
1450: if (pClient->AuxParam.State == WAVE_DD_STOP) {
1451: //
1452: // We're sort of stuck - we want to complete this
1453: // buffer but we've got it tied up in the device
1454: // We'll reset it here although this erroneously
1455: // sets the position to 0
1456: //
1457: if (pClient->DeviceQueue) {
1458: while (!(pClient->DeviceQueue->dwFlags & WHDR_COMPLETE) &&
1459: pClient->BytesOutstanding != 0) {
1460: waveSetState(pClient, WAVE_DD_RECORD);
1461: pClient->AuxReturnCode =
1462: waveSetState(pClient, WAVE_DD_STOP);
1463: if (pClient->AuxReturnCode != MMSYSERR_NOERROR) {
1464: break;
1465: }
1466: }
1467: if (pClient->AuxReturnCode == MMSYSERR_NOERROR) {
1468: pClient->DeviceQueue->dwFlags |= WHDR_COMPLETE;
1469: //
1470: // Tidy up next buffer
1471: //
1472: if (pClient->NextBuffer ==
1473: pClient->DeviceQueue) {
1474: pClient->NextBuffer =
1475: pClient->DeviceQueue->lpNext;
1476: pClient->BufferPosition = 0;
1477: }
1478: }
1479: }
1480: } else {
1481: //
1482: // If recording restore some buffers if necessary
1483: //
1484: if (pClient->AuxParam.State == WAVE_DD_RECORD) {
1485: pClient->AuxReturnCode = waveStart(pClient);
1486: }
1487: }
1488: }
1489: }
1490: break;
1491:
1492: case WaveThreadGetData:
1493: {
1494: pClient->AuxReturnCode =
1495: sndGetHandleData(pClient->hDev,
1496: pClient->AuxParam.GetSetData.DataLen,
1497: pClient->AuxParam.GetSetData.pData,
1498: pClient->AuxParam.GetSetData.Function,
1499: pClient->Event);
1500: }
1501: break;
1502:
1503: case WaveThreadSetData:
1504: {
1505: pClient->AuxReturnCode =
1506: sndSetHandleData(pClient->hDev,
1507: pClient->AuxParam.GetSetData.DataLen,
1508: pClient->AuxParam.GetSetData.pData,
1509: pClient->AuxParam.GetSetData.Function,
1510: pClient->Event);
1511: }
1512: break;
1513:
1514: case WaveThreadBreakLoop:
1515: if (pClient->LoopHead) {
1516: //
1517: // If we're in a loop then exit the loop at the
1518: // end of the next iteration.
1519: //
1520:
1521: pClient->LoopCount = 0;
1522: }
1523: pClient->AuxReturnCode = MMSYSERR_NOERROR;
1524: break;
1525:
1526: case WaveThreadClose:
1527: //
1528: // Try to complete.
1529: // If we're completed all our buffers then we can.
1530: // otherwise we can't
1531: //
1532: if (pClient->DeviceQueue == NULL) {
1533: pClient->AuxReturnCode = MMSYSERR_NOERROR;
1534: } else {
1535: pClient->AuxReturnCode = WAVERR_STILLPLAYING;
1536: }
1537: break;
1538:
1539: case WaveThreadTerminate:
1540: Terminate = TRUE;
1541: break;
1542:
1543:
1544: default:
1545: WinAssert(FALSE); // Invalid call
1546: break;
1547: }
1548: //
1549: // Trap invalid callers
1550: //
1551: pClient->AuxFunction = WaveThreadInvalid;
1552:
1553: //
1554: // See if any Apcs need completing
1555: //
1556: waveCompleteBuffers(pClient);
1557:
1558: //
1559: // Complete ? - don't set the event here.
1560: //
1561: if (Terminate) {
1562: return 1;
1563: }
1564:
1565: //
1566: // Release the thread caller
1567: //
1568: SetEvent(pClient->AuxEvent2);
1569:
1570: //
1571: // Wait for more !
1572: //
1573:
1574: while (WaitForSingleObjectEx(pClient->AuxEvent1, INFINITE, TRUE) ==
1575: WAIT_IO_COMPLETION) {
1576: waveCompleteBuffers(pClient);
1577: }
1578: }
1579:
1580: return 1; // Satisfy the compiler !
1581: }
1582:
1583:
1584:
1585: /****************************************************************************
1586: * @doc INTERNAL
1587: *
1588: * @api void | waveCallback | This calls DriverCallback for a WAVEHDR.
1589: *
1590: * @parm PWAVEALLOC | pWave | Pointer to wave device.
1591: *
1592: * @parm DWORD | msg | The message.
1593: *
1594: * @parm DWORD | dw1 | message DWORD (dw2 is always set to 0).
1595: *
1596: * @rdesc There is no return value.
1597: ***************************************************************************/
1598: void waveCallback(PWAVEALLOC pWave, DWORD msg, DWORD dw1)
1599: {
1600:
1601: // invoke the callback function, if it exists. dwFlags contains
1602: // wave driver specific flags in the LOWORD and generic driver
1603: // flags in the HIWORD
1604:
1605: if (pWave->dwCallback)
1606: DriverCallback(pWave->dwCallback, // user's callback DWORD
1607: HIWORD(pWave->dwFlags), // callback flags
1608: pWave->hWave, // handle to the wave device
1609: msg, // the message
1610: pWave->dwInstance, // user's instance data
1611: dw1, // first DWORD
1612: 0L); // second DWORD
1613: }
1614:
1615:
1616:
1617: /****************************************************************************
1618:
1619: This function conforms to the standard Wave input driver message proc
1620: (widMessage), which is documented in mmddk.d.
1621:
1622: ****************************************************************************/
1623: DWORD APIENTRY widMessage(DWORD id, DWORD msg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
1624: {
1625: PWAVEALLOC pInClient;
1626: MMRESULT mRet;
1627:
1628: switch (msg) {
1629:
1630: case WIDM_GETNUMDEVS:
1631: D2(("WIDM_GETNUMDEVS"));
1632: return sndGetNumDevs(WaveInDevice);
1633:
1634: case WIDM_GETDEVCAPS:
1635: D2(("WIDM_GETDEVCAPS"));
1636: return waveGetDevCaps(id, WaveInDevice, (LPBYTE)dwParam1,
1637: (DWORD)dwParam2);
1638:
1639: case WIDM_OPEN:
1640: D2(("WIDM_OPEN"));
1641: return waveOpen(WaveInDevice, id, dwUser, dwParam1, dwParam2);
1642:
1643: case WIDM_CLOSE:
1644: D2(("WIDM_CLOSE"));
1645: pInClient = (PWAVEALLOC)dwUser;
1646:
1647: //
1648: // Call our task to see if it's ready to complete
1649: //
1650: mRet = waveThreadCall(WaveThreadClose, pInClient);
1651: if (mRet != MMSYSERR_NOERROR) {
1652: return mRet;
1653: }
1654:
1655: waveCallback(pInClient, WIM_CLOSE, 0L);
1656:
1657: //
1658: // Close our device
1659: //
1660: if (pInClient->hDev != INVALID_HANDLE_VALUE) {
1661: CloseHandle(pInClient->hDev);
1662: EnterCriticalSection(&mmDrvCritSec);
1663: pInClient->hDev = INVALID_HANDLE_VALUE;
1664: LeaveCriticalSection(&mmDrvCritSec);
1665: }
1666:
1667: return MMSYSERR_NOERROR;
1668:
1669: case WIDM_ADDBUFFER:
1670: D2(("WIDM_ADDBUFFER"));
1671: WinAssert(dwParam1 != 0);
1672: WinAssert(!(((LPWAVEHDR)dwParam1)->dwFlags & ~(WHDR_INQUEUE|WHDR_DONE|WHDR_PREPARED|WHDR_BEGINLOOP|WHDR_ENDLOOP)));
1673:
1674: ((LPWAVEHDR)dwParam1)->dwFlags &= (WHDR_INQUEUE|WHDR_DONE|WHDR_PREPARED);
1675:
1676: WinAssert(((LPWAVEHDR)dwParam1)->dwFlags & WHDR_PREPARED);
1677:
1678: // check if it's been prepared
1679: if (!(((LPWAVEHDR)dwParam1)->dwFlags & WHDR_PREPARED))
1680: return WAVERR_UNPREPARED;
1681:
1682: WinAssert(!(((LPWAVEHDR)dwParam1)->dwFlags & WHDR_INQUEUE));
1683:
1684: // if it is already in our Q, then we cannot do this
1685: if ( ((LPWAVEHDR)dwParam1)->dwFlags & WHDR_INQUEUE )
1686: return ( WAVERR_STILLPLAYING );
1687:
1688: // store the pointer to my WAVEALLOC structure in the wavehdr
1689: pInClient = (PWAVEALLOC)dwUser;
1690: ((LPWAVEHDR)dwParam1)->reserved = (DWORD)(LPSTR)pInClient;
1691:
1692: return waveWrite((LPWAVEHDR)dwParam1, pInClient);
1693:
1694: case WIDM_STOP:
1695: D2(("WIDM_PAUSE"));
1696: pInClient = (PWAVEALLOC)dwUser;
1697: pInClient->AuxParam.State = WAVE_DD_STOP;
1698: return waveThreadCall(WaveThreadSetState, pInClient);
1699:
1700: case WIDM_START:
1701: D2(("WIDM_RESTART"));
1702: pInClient = (PWAVEALLOC)dwUser;
1703: pInClient->AuxParam.State = WAVE_DD_RECORD;
1704: return waveThreadCall(WaveThreadSetState, pInClient);
1705:
1706: case WIDM_RESET:
1707: D2(("WIDM_RESET"));
1708: pInClient = (PWAVEALLOC)dwUser;
1709: pInClient->AuxParam.State = WAVE_DD_RESET;
1710: return waveThreadCall(WaveThreadSetState, pInClient);
1711:
1712: case WIDM_GETPOS:
1713: D2(("WIDM_GETPOS"));
1714: pInClient = (PWAVEALLOC)dwUser;
1715: return waveGetPos(pInClient, (LPMMTIME)dwParam1, dwParam2);
1716:
1717: default:
1718: return MMSYSERR_NOTSUPPORTED;
1719: }
1720:
1721: //
1722: // Should not get here
1723: //
1724:
1725: WinAssert(0);
1726: return MMSYSERR_NOTSUPPORTED;
1727: }
1728:
1729: /****************************************************************************
1730:
1731: This function conforms to the standard Wave output driver message proc
1732: (wodMessage), which is documented in mmddk.h.
1733:
1734: ****************************************************************************/
1735: DWORD APIENTRY wodMessage(DWORD id, DWORD msg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
1736: {
1737: PWAVEALLOC pOutClient;
1738: MMRESULT mRet;
1739:
1740: switch (msg) {
1741: case WODM_GETNUMDEVS:
1742: D2(("WODM_GETNUMDEVS"));
1743: return sndGetNumDevs(WaveOutDevice);
1744:
1745: case WODM_GETDEVCAPS:
1746: D2(("WODM_GETDEVCAPS"));
1747: return waveGetDevCaps(id, WaveOutDevice, (LPBYTE)dwParam1,
1748: (DWORD)dwParam2);
1749:
1750: case WODM_OPEN:
1751: D2(("WODM_OPEN"));
1752: return waveOpen(WaveOutDevice, id, dwUser, dwParam1, dwParam2);
1753:
1754: case WODM_CLOSE:
1755: D2(("WODM_CLOSE"));
1756: pOutClient = (PWAVEALLOC)dwUser;
1757:
1758: //
1759: // Call our task to see if it's ready to complete
1760: //
1761: mRet = waveThreadCall(WaveThreadClose, pOutClient);
1762: if (mRet != MMSYSERR_NOERROR) {
1763: return mRet;
1764: }
1765:
1766: waveCallback(pOutClient, WOM_CLOSE, 0L);
1767:
1768: //
1769: // Close our device
1770: //
1771: if (pOutClient->hDev != INVALID_HANDLE_VALUE) {
1772: CloseHandle(pOutClient->hDev);
1773:
1774: EnterCriticalSection(&mmDrvCritSec);
1775: pOutClient->hDev = INVALID_HANDLE_VALUE;
1776: LeaveCriticalSection(&mmDrvCritSec);
1777: }
1778:
1779: return MMSYSERR_NOERROR;
1780:
1781: case WODM_WRITE:
1782: D2(("WODM_WRITE"));
1783: WinAssert(dwParam1 != 0);
1784: WinAssert(!(((LPWAVEHDR)dwParam1)->dwFlags &
1785: ~(WHDR_INQUEUE|WHDR_DONE|WHDR_PREPARED|
1786: WHDR_BEGINLOOP|WHDR_ENDLOOP)));
1787:
1788: ((LPWAVEHDR)dwParam1)->dwFlags &=
1789: (WHDR_INQUEUE|WHDR_DONE|WHDR_PREPARED|
1790: WHDR_BEGINLOOP|WHDR_ENDLOOP);
1791:
1792: WinAssert(((LPWAVEHDR)dwParam1)->dwFlags & WHDR_PREPARED);
1793:
1794: // check if it's been prepared
1795: if (!(((LPWAVEHDR)dwParam1)->dwFlags & WHDR_PREPARED))
1796: return WAVERR_UNPREPARED;
1797:
1798: WinAssert(!(((LPWAVEHDR)dwParam1)->dwFlags & WHDR_INQUEUE));
1799:
1800: // if it is already in our Q, then we cannot do this
1801: if ( ((LPWAVEHDR)dwParam1)->dwFlags & WHDR_INQUEUE )
1802: return ( WAVERR_STILLPLAYING );
1803:
1804: // store the pointer to my WAVEALLOC structure in the wavehdr
1805: pOutClient = (PWAVEALLOC)dwUser;
1806: ((LPWAVEHDR)dwParam1)->reserved = (DWORD)(LPSTR)pOutClient;
1807:
1808: return waveWrite((LPWAVEHDR)dwParam1, pOutClient);
1809:
1810:
1811: case WODM_PAUSE:
1812: D2(("WODM_PAUSE"));
1813: pOutClient = (PWAVEALLOC)dwUser;
1814: pOutClient->AuxParam.State = WAVE_DD_STOP;
1815: return waveThreadCall(WaveThreadSetState, pOutClient);
1816:
1817: case WODM_RESTART:
1818: D2(("WODM_RESTART"));
1819: pOutClient = (PWAVEALLOC)dwUser;
1820: pOutClient->AuxParam.State = WAVE_DD_PLAY;
1821: return waveThreadCall(WaveThreadSetState, pOutClient);
1822:
1823: case WODM_RESET:
1824: D2(("WODM_RESET"));
1825: pOutClient = (PWAVEALLOC)dwUser;
1826: pOutClient->AuxParam.State = WAVE_DD_RESET;
1827: return waveThreadCall(WaveThreadSetState, pOutClient);
1828:
1829: case WODM_BREAKLOOP:
1830: pOutClient = (PWAVEALLOC)dwUser;
1831: D2(("WODM_BREAKLOOP"));
1832: return waveThreadCall(WaveThreadBreakLoop, pOutClient);
1833:
1834:
1835: case WODM_GETPOS:
1836: D2(("WODM_GETPOS"));
1837: pOutClient = (PWAVEALLOC)dwUser;
1838: return waveGetPos(pOutClient, (LPMMTIME)dwParam1, dwParam2);
1839:
1840: case WODM_SETPITCH:
1841: D2(("WODM_SETPITCH"));
1842: pOutClient = (PWAVEALLOC)dwUser;
1843: pOutClient->AuxParam.GetSetData.pData = *(PBYTE *)&dwParam1;
1844: pOutClient->AuxParam.GetSetData.DataLen = sizeof(DWORD);
1845: pOutClient->AuxParam.GetSetData.Function = IOCTL_WAVE_SET_PITCH;
1846: return waveThreadCall(WaveThreadSetData, pOutClient);
1847:
1848: case WODM_SETVOLUME:
1849: D2(("WODM_SETVOLUME"));
1850: //pOutClient = (PWAVEALLOC)dwUser;
1851: //pOutClient->AuxParam.GetSetData.pData = *(PBYTE *)&dwParam1;
1852: //pOutClient->AuxParam.GetSetData.DataLen = sizeof(DWORD);
1853: //pOutClient->AuxParam.GetSetData.Function = IOCTL_WAVE_SET_VOLUME;
1854: //return waveThreadCall(WaveThreadSetData, pOutClient);
1855:
1856: {
1857: //
1858: // Translate to device volume structure
1859: //
1860:
1861: WAVE_DD_VOLUME Volume;
1862: Volume.Left = LOWORD(dwParam1) << 16;
1863: Volume.Right = HIWORD(dwParam1) << 16;
1864:
1865: return sndSetData(WaveOutDevice, id, sizeof(Volume),
1866: (PBYTE)&Volume, IOCTL_WAVE_SET_VOLUME);
1867: }
1868:
1869:
1870: case WODM_SETPLAYBACKRATE:
1871: D2(("WODM_SETPLAYBACKRATE"));
1872: pOutClient = (PWAVEALLOC)dwUser;
1873: pOutClient->AuxParam.GetSetData.pData = *(PBYTE *)&dwParam1;
1874: pOutClient->AuxParam.GetSetData.DataLen = sizeof(DWORD);
1875: pOutClient->AuxParam.GetSetData.Function =
1876: IOCTL_WAVE_SET_PLAYBACK_RATE;
1877: return waveThreadCall(WaveThreadSetData, pOutClient);
1878:
1879: case WODM_GETPITCH:
1880: D2(("WODM_GETPITCH"));
1881: pOutClient = (PWAVEALLOC)dwUser;
1882: pOutClient->AuxParam.GetSetData.pData = *(PBYTE *)&dwParam1;
1883: pOutClient->AuxParam.GetSetData.DataLen = sizeof(DWORD);
1884: pOutClient->AuxParam.GetSetData.Function = IOCTL_WAVE_GET_PITCH;
1885: return waveThreadCall(WaveThreadGetData, pOutClient);
1886:
1887: case WODM_GETVOLUME:
1888: D2(("WODM_GETVOLUME"));
1889: //pOutClient = (PWAVEALLOC)dwUser;
1890: //pOutClient->AuxParam.GetSetData.pData = *(PBYTE *)&dwParam1;
1891: //pOutClient->AuxParam.GetSetData.DataLen = sizeof(DWORD);
1892: //pOutClient->AuxParam.GetSetData.Function = IOCTL_WAVE_GET_VOLUME;
1893: //return waveThreadCall(WaveThreadGetData, pOutClient);
1894:
1895: {
1896: //
1897: // Translate to device volume structure
1898: //
1899:
1900: WAVE_DD_VOLUME Volume;
1901: DWORD rc;
1902:
1903: rc = sndGetData(WaveOutDevice, id, sizeof(Volume),
1904: (PBYTE)&Volume, IOCTL_WAVE_GET_VOLUME);
1905:
1906: if (rc == MMSYSERR_NOERROR) {
1907: *(LPDWORD)dwParam1 =
1908: (DWORD)MAKELONG(HIWORD(Volume.Left),
1909: HIWORD(Volume.Right));
1910: }
1911:
1912: return rc;
1913: }
1914:
1915: case WODM_GETPLAYBACKRATE:
1916: D2(("WODM_GETPLAYBACKRATE"));
1917: pOutClient = (PWAVEALLOC)dwUser;
1918: pOutClient->AuxParam.GetSetData.pData = *(PBYTE *)&dwParam1;
1919: pOutClient->AuxParam.GetSetData.DataLen = sizeof(DWORD);
1920: pOutClient->AuxParam.GetSetData.Function =
1921: IOCTL_WAVE_GET_PLAYBACK_RATE;
1922: return waveThreadCall(WaveThreadGetData, pOutClient);
1923:
1924: default:
1925: return MMSYSERR_NOTSUPPORTED;
1926: }
1927:
1928: //
1929: // Should not get here
1930: //
1931:
1932: WinAssert(0);
1933: return MMSYSERR_NOTSUPPORTED;
1934: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.