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

Last change on this file since 8955 was 8955, checked in by sandervl, 23 years ago

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