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

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

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