source: trunk/src/winmm/waveoutdart.cpp@ 5448

Last change on this file since 5448 was 5421, checked in by sandervl, 25 years ago

increase nr of dart buffers used by waveout
File size: 23.6 KB
Line 
1/* $Id: waveoutdart.cpp,v 1.2 2001-04-01 12:31:01 sandervl Exp $ */
2
3/*
4 * Wave playback class (DART)
5 *
6 * Copyright 1998-2001 Sander van Leeuwen (sandervl@xs4all.nl)
7 *
8 *
9 * Project Odin Software License can be found in LICENSE.TXT
10 *
11 * Note:
12 * 2000/11/24 PH MCI_MIXSETUP_PARMS->pMixWrite does alter FS: selector!
13 *
14 */
15
16
17/****************************************************************************
18 * Includes *
19 ****************************************************************************/
20
21
22
23#define INCL_BASE
24#define INCL_OS2MM
25#include <os2wrap.h> //Odin32 OS/2 api wrappers
26#include <os2mewrap.h> //Odin32 OS/2 MMPM/2 api wrappers
27#include <stdlib.h>
28#include <string.h>
29#define OS2_ONLY
30#include <win32api.h>
31#include <wprocess.h>
32
33#include "misc.h"
34#include "waveoutdart.h"
35
36#define DBG_LOCALLOG DBG_waveoutdart
37#include "dbglocal.h"
38
39#ifndef min
40#define min(a, b) ((a > b) ? b : a)
41#endif
42
43#ifndef max
44#define max(a, b) ((a > b) ? a : b)
45#endif
46
47LONG APIENTRY WaveOutHandler(ULONG ulStatus, PMCI_MIX_BUFFER pBuffer, ULONG ulFlags);
48
49//TODO: mulaw, alaw & adpcm
50/******************************************************************************/
51/******************************************************************************/
52DartWaveOut::DartWaveOut(LPWAVEFORMATEX pwfx, ULONG fdwOpen, ULONG nCallback, ULONG dwInstance)
53 : WaveOut(pwfx, fdwOpen, nCallback, dwInstance)
54{
55 MCI_GENERIC_PARMS GenericParms;
56 MCI_AMP_OPEN_PARMS AmpOpenParms;
57 APIRET rc;
58
59 curPlayBuf = curFillBuf = curFillPos = curPlayPos = 0;
60 fMixerSetup = FALSE;
61 fUnderrun = FALSE;
62
63 ulBufSize = DART_BUFSIZE;
64
65 MixBuffer = (MCI_MIX_BUFFER *)malloc(PREFILLBUF_DART*sizeof(MCI_MIX_BUFFER));
66 MixSetupParms = (MCI_MIXSETUP_PARMS *)malloc(sizeof(MCI_MIXSETUP_PARMS));
67 BufferParms = (MCI_BUFFER_PARMS *)malloc(sizeof(MCI_BUFFER_PARMS));
68 if(!MixBuffer || !MixSetupParms || !BufferParms) {
69 dprintf(("ERROR: malloc failed!!"));
70 ulError = MMSYSERR_NOMEM;
71 return;
72 }
73
74 // Setup the open structure, pass the playlist and tell MCI_OPEN to use it
75 memset(&AmpOpenParms,0,sizeof(AmpOpenParms));
76
77 AmpOpenParms.usDeviceID = ( USHORT ) 0;
78 AmpOpenParms.pszDeviceType = ( PSZ ) MCI_DEVTYPE_AUDIO_AMPMIX;
79
80 rc = mciSendCommand(0, MCI_OPEN, MCI_WAIT | MCI_OPEN_TYPE_ID | MCI_OPEN_SHAREABLE,
81 (PVOID) &AmpOpenParms, 0);
82
83 DeviceId = AmpOpenParms.usDeviceID;
84 if(rc) {
85 dprintf(("MCI_OPEN failed\n"));
86 mciError(rc);
87 ulError = MMSYSERR_NODRIVER;
88 }
89 if(rc == 0) {
90 //Grab exclusive rights to device instance (NOT entire device)
91 GenericParms.hwndCallback = 0; //Not needed, so set to 0
92 rc = mciSendCommand(DeviceId, MCI_ACQUIREDEVICE, MCI_EXCLUSIVE_INSTANCE,
93 (PVOID)&GenericParms, 0);
94 if(rc) {
95 dprintf(("MCI_ACQUIREDEVICE failed\n"));
96 mciError(rc);
97 ulError = MMSYSERR_NOTENABLED;
98 }
99 }
100 setVolume(volume);
101
102 if(!ulError)
103 callback(WOM_OPEN, 0, 0);
104}
105/******************************************************************************/
106/******************************************************************************/
107DartWaveOut::~DartWaveOut()
108{
109 MCI_GENERIC_PARMS GenericParms;
110
111 State = STATE_STOPPED;
112
113 if(!ulError) {
114 // Generic parameters
115 GenericParms.hwndCallback = 0; //hwndFrame
116
117 // Stop the playback.
118 mciSendCommand(DeviceId, MCI_STOP,MCI_WAIT, (PVOID)&GenericParms,0);
119
120 mciSendCommand(DeviceId, MCI_BUFFER,
121 MCI_WAIT | MCI_DEALLOCATE_MEMORY,
122 (PVOID)&BufferParms, 0);
123
124 // Generic parameters
125 GenericParms.hwndCallback = 0; //hwndFrame
126
127 // Close the device
128 mciSendCommand(DeviceId, MCI_CLOSE, MCI_WAIT, (PVOID)&GenericParms, 0);
129 }
130
131 if(!ulError)
132 {
133 callback(WOM_CLOSE, 0, 0);
134 }
135
136 if(MixBuffer)
137 free(MixBuffer);
138 if(MixSetupParms)
139 free(MixSetupParms);
140 if(BufferParms)
141 free(BufferParms);
142}
143/******************************************************************************/
144/******************************************************************************/
145MMRESULT DartWaveOut::write(LPWAVEHDR pwh, UINT cbwh)
146{
147 MCI_GENERIC_PARMS GenericParms = {0};
148 APIRET rc;
149 int i, buflength;
150
151 queuedbuffers++;
152 if(fMixerSetup == FALSE)
153 {
154 dprintf(("device acquired\n"));
155 /* Set the MixSetupParms data structure to match the loaded file.
156 * This is a global that is used to setup the mixer.
157 */
158 memset(MixSetupParms, 0, sizeof( MCI_MIXSETUP_PARMS ) );
159
160 MixSetupParms->ulBitsPerSample = BitsPerSample;
161 MixSetupParms->ulSamplesPerSec = SampleRate;
162 MixSetupParms->ulFormatTag = MCI_WAVE_FORMAT_PCM;
163 MixSetupParms->ulChannels = nChannels;
164
165 dprintf(("bps %d, sps %d chan %d\n", BitsPerSample, SampleRate, nChannels));
166
167 /* Setup the mixer for playback of wave data
168 */
169 MixSetupParms->ulFormatMode = MCI_PLAY;
170 MixSetupParms->ulDeviceType = MCI_DEVTYPE_WAVEFORM_AUDIO;
171 MixSetupParms->pmixEvent = WaveOutHandler;
172
173 rc = mciSendCommand(DeviceId,
174 MCI_MIXSETUP,
175 MCI_WAIT | MCI_MIXSETUP_INIT,
176 (PVOID)MixSetupParms,
177 0);
178
179 if ( rc != MCIERR_SUCCESS ) {
180 mciError(rc);
181 mciSendCommand(DeviceId, MCI_RELEASEDEVICE, MCI_WAIT,
182 (PVOID)&GenericParms, 0);
183 return(MMSYSERR_NOTSUPPORTED);
184 }
185
186 /*
187 * Set up the BufferParms data structure and allocate
188 * device buffers from the Amp-Mixer
189 */
190 dprintf(("mix setup %d, %d\n", pwh->dwBufferLength, pwh->dwBufferLength));
191
192#if 1
193 int consumerate = getAvgBytesPerSecond();
194 int minbufsize = consumerate/32;
195
196 ulBufSize = pwh->dwBufferLength/2;
197 if(ulBufSize > minbufsize) {
198 dprintf(("set buffer size to %d bytes (org size = %d)", minbufsize, pwh->dwBufferLength));
199 ulBufSize = minbufsize;
200 }
201#else
202 if(pwh->dwBufferLength >= 512 && pwh->dwBufferLength <= 1024)
203 ulBufSize = pwh->dwBufferLength;
204 else ulBufSize = 1024;
205#endif
206
207 MixSetupParms->ulBufferSize = ulBufSize;
208
209 BufferParms->ulNumBuffers = PREFILLBUF_DART;
210 BufferParms->ulBufferSize = MixSetupParms->ulBufferSize;
211 BufferParms->pBufList = MixBuffer;
212
213 for(i=0;i<PREFILLBUF_DART;i++) {
214 MixBuffer[i].ulUserParm = (ULONG)this;
215 }
216
217 rc = mciSendCommand(DeviceId,
218 MCI_BUFFER,
219 MCI_WAIT | MCI_ALLOCATE_MEMORY,
220 (PVOID)BufferParms,
221 0);
222
223 if(ULONG_LOWD(rc) != MCIERR_SUCCESS) {
224 mciError(rc);
225 mciSendCommand(DeviceId, MCI_RELEASEDEVICE, MCI_WAIT,
226 (PVOID)&GenericParms, 0);
227 return(MMSYSERR_NOTSUPPORTED);
228 }
229
230 wmutex.enter(VMUTEX_WAIT_FOREVER);
231 fMixerSetup = TRUE;
232
233 curPlayBuf = curFillBuf = curFillPos = curPlayPos = 0;
234 bytesPlayed = bytesCopied = bytesReturned = 0;
235
236 for(i=0;i<PREFILLBUF_DART;i++) {
237 memset(MixBuffer[i].pBuffer, 0, MixBuffer[i].ulBufferLength);
238 }
239 dprintf(("Dart opened, bufsize = %d\n", MixBuffer[0].ulBufferLength));
240
241 wavehdr = pwh;
242 curhdr = pwh;
243 pwh->lpNext = NULL;
244 pwh->reserved = 0;
245
246 if(State != STATE_STOPPED) {//don't start playback if paused
247 wmutex.leave();
248 return(MMSYSERR_NOERROR);
249 }
250
251 writeBuffer(); //must be called before (re)starting playback
252
253 dprintf(("MixSetupParms = %X\n", MixSetupParms));
254 State = STATE_PLAYING;
255 fUnderrun = FALSE;
256 wmutex.leave();
257
258 //write buffers to DART; starts playback
259 // MCI_MIXSETUP_PARMS->pMixWrite does alter FS: selector!
260 USHORT selTIB = GetFS(); // save current FS selector
261
262 MixSetupParms->pmixWrite(MixSetupParms->ulMixHandle,
263 MixBuffer,
264 PREFILLBUF_DART);
265 SetFS(selTIB); // switch back to the saved FS selector
266
267 dprintf(("Dart playing\n"));
268 }
269 else
270 {
271 pwh->lpNext = NULL;
272 pwh->reserved = 0;
273 wmutex.enter(VMUTEX_WAIT_FOREVER);
274 if(wavehdr) {
275 WAVEHDR *chdr = wavehdr;
276 while(chdr->lpNext) {
277 chdr = chdr->lpNext;
278 }
279 chdr->lpNext = pwh;
280 }
281 else wavehdr = pwh;
282
283 writeBuffer(); //must be called before (re)starting playback
284 wmutex.leave();
285
286 if(State == STATE_STOPPED) {//continue playback
287 restart();
288 }
289 else
290 if(fUnderrun) {
291 dprintf(("Resume playback after underrun"));
292 fUnderrun = FALSE;
293 State = STATE_PLAYING;
294
295 memset(&GenericParms, 0, sizeof(GenericParms));
296
297 // Resume the playback.
298 mciSendCommand(DeviceId, MCI_RESUME, MCI_WAIT, (PVOID)&GenericParms, 0);
299
300 //write buffers to DART; starts playback
301 // MCI_MIXSETUP_PARMS->pMixWrite does alter FS: selector!
302 USHORT selTIB = GetFS(); // save current FS selector
303
304 MixSetupParms->pmixWrite(MixSetupParms->ulMixHandle, &MixBuffer[curPlayBuf], 1);
305
306 SetFS(selTIB); // switch back to the saved FS selector
307 }
308 }
309 return(MMSYSERR_NOERROR);
310}
311/******************************************************************************/
312/******************************************************************************/
313MMRESULT DartWaveOut::pause()
314{
315 MCI_GENERIC_PARMS Params;
316
317 dprintf(("WINMM: DartWaveOut::pause"));
318
319 wmutex.enter(VMUTEX_WAIT_FOREVER);
320 if(State != STATE_PLAYING) {
321 State = STATE_PAUSED;
322 wmutex.leave();
323 return(MMSYSERR_NOERROR);
324 }
325
326 State = STATE_PAUSED;
327 wmutex.leave();
328
329 memset(&Params, 0, sizeof(Params));
330
331 // Pause the playback.
332 mciSendCommand(DeviceId, MCI_PAUSE, MCI_WAIT, (PVOID)&Params, 0);
333
334 return(MMSYSERR_NOERROR);
335}
336/******************************************************************************/
337/******************************************************************************/
338MMRESULT DartWaveOut::stop()
339{
340 MCI_GENERIC_PARMS Params;
341
342 dprintf(("DartWaveOut::stop %s", (State == STATE_PLAYING) ? "playing" : "stopped"));
343 if(State != STATE_PLAYING)
344 return(MMSYSERR_HANDLEBUSY);
345
346 memset(&Params, 0, sizeof(Params));
347
348 // Stop the playback.
349 mciSendCommand(DeviceId, MCI_STOP, MCI_WAIT, (PVOID)&Params, 0);
350
351 State = STATE_STOPPED;
352 fUnderrun = FALSE;
353
354 curPlayBuf = curFillBuf = curFillPos = curPlayPos = 0;
355 bytesPlayed = bytesCopied = bytesReturned = 0;
356
357 return(MMSYSERR_NOERROR);
358}
359/******************************************************************************/
360/******************************************************************************/
361MMRESULT DartWaveOut::reset()
362{
363 MCI_GENERIC_PARMS Params;
364 LPWAVEHDR tmpwavehdr;
365
366 dprintf(("DartWaveOut::reset %s", (State == STATE_PLAYING) ? "playing" : "stopped"));
367 if(State != STATE_PLAYING)
368 return(MMSYSERR_HANDLEBUSY);
369
370 memset(&Params, 0, sizeof(Params));
371
372 // Stop the playback.
373 mciSendCommand(DeviceId, MCI_STOP, MCI_WAIT, (PVOID)&Params, 0);
374
375 dprintf(("Nr of threads blocked on mutex = %d\n", wmutex.getNrBlocked()));
376
377 wmutex.enter(VMUTEX_WAIT_FOREVER);
378 while(wavehdr)
379 {
380 wavehdr->dwFlags |= WHDR_DONE;
381 wavehdr->dwFlags &= ~WHDR_INQUEUE;
382 wavehdr->reserved = 0;
383 tmpwavehdr = wavehdr;
384 wavehdr = wavehdr->lpNext;
385 tmpwavehdr->lpNext = NULL;
386 wmutex.leave();
387
388 callback(WOM_DONE, (ULONG)tmpwavehdr, 0);
389 wmutex.enter(VMUTEX_WAIT_FOREVER);
390 }
391 wavehdr = NULL;
392 State = STATE_STOPPED;
393 fUnderrun = FALSE;
394
395 curPlayBuf = curFillBuf = curFillPos = curPlayPos = 0;
396 bytesPlayed = bytesCopied = bytesReturned = 0;
397 queuedbuffers = 0;
398
399 wmutex.leave();
400 return(MMSYSERR_NOERROR);
401}
402/******************************************************************************/
403/******************************************************************************/
404MMRESULT DartWaveOut::restart()
405{
406 int i, curbuf;
407
408 dprintf(("DartWaveOut::restart"));
409 if(State == STATE_PLAYING)
410 return(MMSYSERR_NOERROR);
411
412 //Only write buffers to dart if mixer has been initialized; if not, then
413 //the first buffer write will do this for us.
414 if(fMixerSetup == TRUE)
415 {
416 wmutex.enter(VMUTEX_WAIT_FOREVER);
417 State = STATE_PLAYING;
418 fUnderrun = FALSE;
419 wmutex.leave();
420 curbuf = curPlayBuf;
421
422 // MCI_MIXSETUP_PARMS->pMixWrite does alter FS: selector!
423 USHORT selTIB = GetFS(); // save current FS selector
424
425 for(i=0;i<PREFILLBUF_DART;i++)
426 {
427 dprintf(("restart: write buffer at %x size %d", MixBuffer[curbuf].pBuffer, MixBuffer[curbuf].ulBufferLength));
428 MixSetupParms->pmixWrite(MixSetupParms->ulMixHandle, &MixBuffer[curbuf], 1);
429 if(++curbuf == PREFILLBUF_DART)
430 curbuf = 0;
431 }
432 SetFS(selTIB); // switch back to the saved FS selector
433 }
434
435 return(MMSYSERR_NOERROR);
436}
437/******************************************************************************/
438/******************************************************************************/
439ULONG DartWaveOut::getPosition()
440{
441 MCI_STATUS_PARMS mciStatus = {0};
442 ULONG rc, nrbytes;
443
444 mciStatus.ulItem = MCI_STATUS_POSITION;
445 rc = mciSendCommand(DeviceId, MCI_STATUS, MCI_STATUS_ITEM|MCI_WAIT, (PVOID)&mciStatus, 0);
446 if((rc & 0xFFFF) == MCIERR_SUCCESS) {
447 nrbytes = (mciStatus.ulReturn * (getAvgBytesPerSecond()/1000));
448 return nrbytes;;
449 }
450 mciError(rc);
451 return 0xFFFFFFFF;
452}
453/******************************************************************************/
454/******************************************************************************/
455BOOL DartWaveOut::queryFormat(ULONG formatTag, ULONG nChannels,
456 ULONG nSamplesPerSec, ULONG wBitsPerSample)
457{
458 MCI_WAVE_GETDEVCAPS_PARMS mciAudioCaps;
459 MCI_GENERIC_PARMS GenericParms;
460 MCI_OPEN_PARMS mciOpenParms; /* open parms for MCI_OPEN */
461 int i, freqbits = 0;
462 ULONG rc, DeviceId;
463 BOOL winrc;
464
465 dprintf(("DartWaveOut::queryFormat %x srate=%d, nchan=%d, bps=%d", formatTag, nSamplesPerSec, nChannels, wBitsPerSample));
466
467 memset(&mciOpenParms, /* Object to fill with zeros. */
468 0, /* Value to place into the object. */
469 sizeof( mciOpenParms ) ); /* How many zero's to use. */
470
471 mciOpenParms.pszDeviceType = (PSZ)MCI_DEVTYPE_WAVEFORM_AUDIO;
472
473 rc = mciSendCommand( (USHORT) 0,
474 MCI_OPEN,
475 MCI_WAIT | MCI_OPEN_TYPE_ID,
476 (PVOID) &mciOpenParms,
477 0);
478 if((rc & 0xFFFF) != MCIERR_SUCCESS) {
479 mciError(rc);
480 return(FALSE);
481 }
482 DeviceId = mciOpenParms.usDeviceID;
483
484 memset( &mciAudioCaps , 0, sizeof(MCI_WAVE_GETDEVCAPS_PARMS));
485
486 mciAudioCaps.ulBitsPerSample = wBitsPerSample;
487 mciAudioCaps.ulFormatTag = DATATYPE_WAVEFORM;
488 mciAudioCaps.ulSamplesPerSec = nSamplesPerSec;
489 mciAudioCaps.ulChannels = nChannels;
490 mciAudioCaps.ulFormatMode = MCI_PLAY;
491 mciAudioCaps.ulItem = MCI_GETDEVCAPS_WAVE_FORMAT;
492
493 rc = mciSendCommand(DeviceId, /* Device ID */
494 MCI_GETDEVCAPS,
495 MCI_WAIT | MCI_GETDEVCAPS_EXTENDED | MCI_GETDEVCAPS_ITEM,
496 (PVOID) &mciAudioCaps,
497 0);
498 if((rc & 0xFFFF) != MCIERR_SUCCESS) {
499 mciError(rc);
500 winrc = FALSE;
501 }
502 else winrc = TRUE;
503
504 // Close the device
505 mciSendCommand(DeviceId,MCI_CLOSE,MCI_WAIT,(PVOID)&GenericParms,0);
506 return(winrc);
507}
508/******************************************************************************/
509/******************************************************************************/
510void DartWaveOut::mciError(ULONG ulError)
511{
512#ifdef DEBUG
513 char szError[256] = "";
514
515 mciGetErrorString(ulError, szError, sizeof(szError));
516 dprintf(("WINMM: DartWaveOut: %s\n", szError));
517#endif
518}
519//******************************************************************************
520//******************************************************************************
521void DartWaveOut::handler(ULONG ulStatus, PMCI_MIX_BUFFER pBuffer, ULONG ulFlags)
522{
523 ULONG buflength;
524 WAVEHDR *whdr, *prevhdr = NULL;
525
526 dprintf2(("WINMM: handler %d; buffers left %d", curPlayBuf, queuedbuffers));
527 if(ulFlags == MIX_STREAM_ERROR) {
528 if(ulStatus == ERROR_DEVICE_UNDERRUN) {
529 dprintf(("WINMM: WaveOut handler UNDERRUN! state %s", (State == STATE_PLAYING) ? "playing" : "stopped"));
530 if(State == STATE_PLAYING) {
531 fUnderrun = TRUE;
532 stop(); //out of buffers, so stop playback
533 }
534 return;
535 }
536 dprintf(("WINMM: WaveOut handler, Unknown error %X\n", ulStatus));
537 return;
538 }
539 if(State != STATE_PLAYING) {
540 return;
541 }
542
543 wmutex.enter(VMUTEX_WAIT_FOREVER);
544
545 bytesPlayed += MixBuffer[curPlayBuf].ulBufferLength;
546
547 if(curPlayBuf == PREFILLBUF_DART-1)
548 curPlayBuf = 0;
549 else curPlayBuf++;
550
551 fUnderrun = FALSE;
552
553 whdr = wavehdr;
554 while(whdr) {
555 if(whdr->reserved == WHDR_DONE)
556 {
557 if(bytesPlayed < bytesReturned + whdr->dwBufferLength) {
558 dprintf2(("Buffer marked done, but not yet played completely (play %d/%d, cop %d, ret %d)", bytesPlayed, getPosition(), bytesCopied, bytesReturned));
559 break; //not yet done
560 }
561
562 dprintf2(("WINMM: handler buf %X done (play %d/%d, cop %d, ret %d)", whdr, bytesPlayed, getPosition(), bytesCopied, bytesReturned));
563 queuedbuffers--;
564
565 whdr->dwFlags &= ~WHDR_INQUEUE;
566 whdr->dwFlags |= WHDR_DONE;
567 whdr->reserved = 0;
568
569 if(prevhdr == NULL)
570 wavehdr = whdr->lpNext;
571 else prevhdr->lpNext = whdr->lpNext;
572
573 whdr->lpNext = NULL;
574
575 bytesReturned += whdr->dwBufferLength;
576 wmutex.leave();
577
578 callback(WOM_DONE, (ULONG)whdr, 0);
579
580 wmutex.enter(VMUTEX_WAIT_FOREVER);
581 }
582 else break;
583
584 prevhdr = whdr;
585 whdr = whdr->lpNext;
586 }
587
588 if(wavehdr == NULL) {
589 //last buffer played -> no new ones -> silence buffer & continue
590 dprintf(("WINMM: WaveOut handler LAST BUFFER PLAYED! state %s (play %d (%d), cop %d, ret %d)", (State == STATE_PLAYING) ? "playing" : "stopped", bytesPlayed, getPosition(), bytesCopied, bytesReturned));
591 if(State == STATE_PLAYING) {
592 fUnderrun = TRUE;
593 pause();
594//// memset(MixBuffer[curPlayBuf].pBuffer, 0, MixBuffer[curPlayBuf].ulBufferLength);
595//// goto sendbuffer;
596 }
597 wmutex.leave();
598 return;
599 }
600
601 writeBuffer();
602
603sendbuffer:
604 wmutex.leave();
605
606 //Transfer buffer to DART
607 // MCI_MIXSETUP_PARMS->pMixWrite does alter FS: selector!
608 USHORT selTIB = GetFS(); // save current FS selector
609 MixSetupParms->pmixWrite(MixSetupParms->ulMixHandle, &MixBuffer[curPlayBuf], 1);
610 SetFS(selTIB); // switch back to the saved FS selector
611
612 dprintf2(("WINMM: handler DONE"));
613}
614/******************************************************************************/
615/******************************************************************************/
616void DartWaveOut::writeBuffer()
617{
618 ULONG buflength;
619
620 if(!fUnderrun && State == STATE_PLAYING && curFillBuf == curPlayBuf) {
621 dprintf2(("writeBuffer: no more room for more audio data"));
622 return; //no room left
623 }
624
625 if(curhdr == NULL)
626 curhdr = wavehdr;
627
628 while(curhdr && (curhdr->reserved == WHDR_DONE)) {
629 curhdr = curhdr->lpNext;
630 }
631
632 if(curhdr == NULL) {
633 return; //no unprocessed buffers left
634 }
635
636 dprintf2(("WINMM: handler cur (%d,%d), fill (%d,%d)\n", curPlayBuf, curPlayPos, curFillBuf, curFillPos));
637
638 while(curhdr) {
639 buflength = min((ULONG)MixBuffer[curFillBuf].ulBufferLength - curPlayPos,
640 (ULONG)curhdr->dwBufferLength - curFillPos);
641 dprintf2(("WINMM: copied %d bytes, cufFillPos = %d, curPlayPos = %d, dwBufferLength = %d\n", buflength, curFillPos, curPlayPos, curhdr->dwBufferLength));
642
643 memcpy((char *)MixBuffer[curFillBuf].pBuffer + curPlayPos,
644 curhdr->lpData + curFillPos, buflength);
645 curPlayPos += buflength;
646 curFillPos += buflength;
647 bytesCopied += buflength;
648
649 if(curFillPos == curhdr->dwBufferLength) {
650 dprintf2(("Buffer %d done ptr %x size %d %x %x %x %x %x %x", curFillBuf, curhdr->lpData, curhdr->dwBufferLength, curhdr->dwBytesRecorded, curhdr->dwUser, curhdr->dwFlags, curhdr->dwLoops, curhdr->lpNext, curhdr->reserved));
651
652 curFillPos = 0;
653 curhdr->reserved = WHDR_DONE;
654 //search for next unprocessed buffer
655 while(curhdr && (curhdr->reserved == WHDR_DONE))
656 curhdr = curhdr->lpNext;
657 }
658 if(curPlayPos == MixBuffer[curFillBuf].ulBufferLength) {
659 curPlayPos = 0;
660 if(++curFillBuf == PREFILLBUF_DART) {
661 curFillBuf = 0;
662 }
663 if(curFillBuf == curPlayBuf)
664 break; //no more room left
665 }
666 }
667}
668/******************************************************************************/
669/******************************************************************************/
670LONG APIENTRY WaveOutHandler(ULONG ulStatus,
671 PMCI_MIX_BUFFER pBuffer,
672 ULONG ulFlags)
673{
674 PTIB2 ptib2;
675 DartWaveOut *dwave;
676
677 ptib2 = (PTIB2)_getTIBvalue(offsetof(TIB, tib_ptib2));
678 if(ptib2 && HIBYTE(ptib2->tib2_ulpri) != PRTYC_TIMECRITICAL) {
679 dprintf(("Setting priority of DART thread to PRTYC_TIMECRITICAL"));
680 DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, 0, 0);
681 }
682 if(pBuffer && pBuffer->ulUserParm)
683 {
684 dwave = (DartWaveOut *)pBuffer->ulUserParm;
685 dwave->handler(ulStatus, pBuffer, ulFlags);
686 }
687 return(TRUE);
688}
689
690/******************************************************************************/
691/******************************************************************************/
692MMRESULT DartWaveOut::setVolume(ULONG ulVol)
693{
694 ULONG ulVolR = (((ulVol & 0xffff0000) >> 16 )*100)/0xFFFF; // Right Volume
695 ULONG ulVolL = ((ulVol& 0x0000ffff)*100)/0xFFFF; // Left Volume
696 MCI_SET_PARMS msp = {0};
697
698 dprintf(("DartWaveOut::setVolume %x %x", ulVolL, ulVolR));
699 volume = ulVol;
700
701// PD: My card (ESS 1868 PnP) driver can't change only
702// one channel Left or Right :-(
703//
704#ifdef GOOD_AUDIO_CARD_DRIVER
705
706 msp.ulAudio = MCI_SET_AUDIO_LEFT;
707 msp.ulLevel = ulVolL;
708
709 mciSendCommand(DeviceId, MCI_SET,
710 MCI_WAIT | MCI_SET_AUDIO | MCI_SET_VOLUME,
711 &msp, 0);
712
713 msp.ulAudio = MCI_SET_AUDIO_RIGHT;
714 msp.ulLevel = ulVolR;
715
716#else
717 msp.ulAudio = MCI_SET_AUDIO_ALL;
718 msp.ulLevel = max(ulVolR,ulVolL);
719#endif
720
721 mciSendCommand(DeviceId, MCI_SET,
722 MCI_WAIT | MCI_SET_AUDIO | MCI_SET_VOLUME,
723 &msp, 0);
724 return 0;
725}
726/******************************************************************************/
727/******************************************************************************/
728
Note: See TracBrowser for help on using the repository browser.