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

Last change on this file since 7196 was 7196, checked in by sandervl, 24 years ago

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