source: trunk/src/winmm/waveindart.cpp@ 5358

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

Rewrite for DirectAudio interface
File size: 19.0 KB
Line 
1/* $Id: waveindart.cpp,v 1.1 2001-03-23 16:23:44 sandervl Exp $ */
2
3/*
4 * Wave record class
5 *
6 * Copyright 2001 Sander van Leeuwen (sandervl@xs4all.nl)
7 *
8 *
9 * Project Odin Software License can be found in LICENSE.TXT
10 *
11 *
12 */
13
14
15/****************************************************************************
16 * Includes *
17 ****************************************************************************/
18
19
20
21#define INCL_BASE
22#define INCL_OS2MM
23#include <os2wrap.h> //Odin32 OS/2 api wrappers
24#include <os2mewrap.h> //Odin32 OS/2 MMPM/2 api wrappers
25#include <stdlib.h>
26#include <string.h>
27#define OS2_ONLY
28#include <win32api.h>
29#include <wprocess.h>
30
31#include "misc.h"
32#include "waveindart.h"
33
34#define DBG_LOCALLOG DBG_waveindart
35#include "dbglocal.h"
36
37#ifndef min
38#define min(a, b) ((a > b) ? b : a)
39#endif
40
41#ifndef max
42#define max(a, b) ((a > b) ? a : b)
43#endif
44
45LONG APIENTRY WaveInHandler(ULONG ulStatus, PMCI_MIX_BUFFER pBuffer, ULONG ulFlags);
46
47//TODO: mulaw, alaw & adpcm
48/******************************************************************************/
49/******************************************************************************/
50DartWaveIn::DartWaveIn(LPWAVEFORMATEX pwfx, ULONG fdwOpen, ULONG nCallback, ULONG dwInstance)
51 : WaveInOut(pwfx, fdwOpen, nCallback, dwInstance)
52{
53 MCI_GENERIC_PARMS GenericParms;
54 MCI_AMP_OPEN_PARMS AmpOpenParms;
55 APIRET rc;
56
57 fOverrun = FALSE;
58 fMixerSetup = FALSE;
59
60 MixBuffer = (MCI_MIX_BUFFER *)malloc(PREFILLBUF_DART_REC*sizeof(MCI_MIX_BUFFER));
61 MixSetupParms = (MCI_MIXSETUP_PARMS *)malloc(sizeof(MCI_MIXSETUP_PARMS));
62 BufferParms = (MCI_BUFFER_PARMS *)malloc(sizeof(MCI_BUFFER_PARMS));
63 if(!MixBuffer || !MixSetupParms || !BufferParms) {
64 dprintf(("ERROR: malloc failed!!"));
65 ulError = MMSYSERR_NOMEM;
66 return;
67 }
68
69 ulBufSize = DART_BUFSIZE_REC;
70
71 dprintf(("waveInOpen: samplerate %d, numChan %d bps %d (%d), format %x", SampleRate, nChannels, BitsPerSample, pwfx->nBlockAlign, pwfx->wFormatTag));
72 // Setup the open structure, pass the playlist and tell MCI_OPEN to use it
73 memset(&AmpOpenParms,0,sizeof(AmpOpenParms));
74
75 AmpOpenParms.usDeviceID = ( USHORT ) 0;
76 AmpOpenParms.pszDeviceType = ( PSZ ) MCI_DEVTYPE_AUDIO_AMPMIX;
77
78 rc = mciSendCommand(0, MCI_OPEN,
79 MCI_WAIT | MCI_OPEN_TYPE_ID | MCI_OPEN_SHAREABLE,
80 (PVOID) &AmpOpenParms,
81 0);
82 DeviceId = AmpOpenParms.usDeviceID;
83 if(rc) {
84 dprintf(("MCI_OPEN failed\n"));
85 mciError(rc);
86 ulError = MMSYSERR_NODRIVER;
87 }
88 if(rc == 0) {
89 //Grab exclusive rights to device instance (NOT entire device)
90 GenericParms.hwndCallback = 0; //Not needed, so set to 0
91 rc = mciSendCommand(DeviceId, MCI_ACQUIREDEVICE, MCI_EXCLUSIVE_INSTANCE,
92 (PVOID)&GenericParms, 0);
93 if(rc) {
94 dprintf(("MCI_ACQUIREDEVICE failed\n"));
95 mciError(rc);
96 ulError = MMSYSERR_NOTENABLED;
97 }
98 }
99
100 if(!ulError)
101 callback(WIM_OPEN, 0, 0);
102}
103/******************************************************************************/
104/******************************************************************************/
105DartWaveIn::~DartWaveIn()
106{
107 MCI_GENERIC_PARMS GenericParms;
108
109 State = STATE_STOPPED;
110
111 if(!ulError)
112 {
113 // Generic parameters
114 GenericParms.hwndCallback = 0; //hwndFrame
115
116 // Stop recording.
117 mciSendCommand(DeviceId, MCI_STOP,MCI_WAIT, (PVOID)&GenericParms,0);
118
119 mciSendCommand(DeviceId,
120 MCI_BUFFER,
121 MCI_WAIT | MCI_DEALLOCATE_MEMORY,
122 (PVOID)&BufferParms,
123 0);
124
125 // Generic parameters
126 GenericParms.hwndCallback = 0; //hwndFrame
127
128 // Close the device
129 mciSendCommand(DeviceId, MCI_CLOSE, MCI_WAIT, (PVOID)&GenericParms, 0);
130 }
131 if(!ulError)
132 {
133 callback(WIM_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/******************************************************************************/
145/******************************************************************************/
146/******************************************************************************/
147MMRESULT DartWaveIn::start()
148{
149 MCI_GENERIC_PARMS GenericParms = {0};
150 MCI_AMP_OPEN_PARMS AmpOpenParms;
151 MCI_CONNECTOR_PARMS ConnectorParms;
152 MCI_AMP_SET_PARMS AmpSetParms ;
153 APIRET rc;
154 int i, curbuf, buflength;
155
156 dprintf(("DartWaveIn::start"));
157 if(State == STATE_RECORDING)
158 return(MMSYSERR_NOERROR);
159
160 if(fMixerSetup == FALSE)
161 {
162 dprintf(("device acquired\n"));
163 /* Set the MixSetupParms data structure to match the loaded file.
164 * This is a global that is used to setup the mixer.
165 */
166 memset(MixSetupParms, 0, sizeof( MCI_MIXSETUP_PARMS ) );
167
168 MixSetupParms->ulBitsPerSample = BitsPerSample;
169 MixSetupParms->ulSamplesPerSec = SampleRate;
170 MixSetupParms->ulFormatTag = MCI_WAVE_FORMAT_PCM;
171 MixSetupParms->ulChannels = nChannels;
172
173 dprintf(("bps %d, sps %d chan %d\n", BitsPerSample, SampleRate, nChannels));
174
175 /* Setup the mixer for recording of wave data
176 */
177 MixSetupParms->ulFormatMode = MCI_RECORD;
178 MixSetupParms->ulDeviceType = MCI_DEVTYPE_WAVEFORM_AUDIO;
179 MixSetupParms->pmixEvent = WaveInHandler;
180
181 rc = mciSendCommand(DeviceId,
182 MCI_MIXSETUP,
183 MCI_WAIT | MCI_MIXSETUP_INIT,
184 (PVOID)MixSetupParms,
185 0);
186
187 if ( rc != MCIERR_SUCCESS ) {
188 mciError(rc);
189 mciSendCommand(DeviceId, MCI_RELEASEDEVICE, MCI_WAIT,
190 (PVOID)&GenericParms, 0);
191 return(MMSYSERR_NOTSUPPORTED);
192 }
193
194 /*
195 * Set up the BufferParms data structure and allocate
196 * device buffers from the Amp-Mixer
197 */
198
199 int consumerate = getAvgBytesPerSecond();
200 //SvL: Recording usually isn't as sensitive to timing as playback
201 // Dividing by 8 instead of 32 here. Change if necessary.
202 int minbufsize = consumerate/8;
203
204 LPWAVEHDR pwh = wavehdr;
205 if(pwh) {
206 dprintf(("mix setup %d, %d\n", pwh->dwBufferLength, pwh->dwBufferLength));
207
208 ulBufSize = pwh->dwBufferLength/2;
209 if(ulBufSize < minbufsize) {
210 dprintf(("set buffer size to %d bytes (org size = %d)", minbufsize, pwh->dwBufferLength));
211 ulBufSize = minbufsize;
212 }
213 }
214 else ulBufSize = minbufsize;
215
216 MixSetupParms->ulBufferSize = ulBufSize;
217
218 BufferParms->ulNumBuffers = PREFILLBUF_DART_REC;
219 BufferParms->ulBufferSize = MixSetupParms->ulBufferSize;
220 BufferParms->pBufList = MixBuffer;
221
222 for(i=0;i<PREFILLBUF_DART_REC;i++) {
223 MixBuffer[i].ulUserParm = (ULONG)this;
224 }
225
226 rc = mciSendCommand(DeviceId,
227 MCI_BUFFER,
228 MCI_WAIT | MCI_ALLOCATE_MEMORY,
229 (PVOID)BufferParms,
230 0);
231
232 if(ULONG_LOWD(rc) != MCIERR_SUCCESS) {
233 mciError(rc);
234 mciSendCommand(DeviceId, MCI_RELEASEDEVICE, MCI_WAIT,
235 (PVOID)&GenericParms, 0);
236 return(MMSYSERR_NOTSUPPORTED);
237 }
238
239 //TODO: don't do this here. Select line or mic depending on aux settings
240 //(until we really support the mixer extensions anyway)
241 /* Set the connector to 'line in' */
242 memset( &ConnectorParms, '\0', sizeof( MCI_CONNECTOR_PARMS ) );
243 ConnectorParms.ulConnectorType = MCI_LINE_IN_CONNECTOR;
244 rc = mciSendCommand( DeviceId,
245 MCI_CONNECTOR,
246 MCI_WAIT |
247 MCI_ENABLE_CONNECTOR |
248 MCI_CONNECTOR_TYPE,
249 ( PVOID ) &ConnectorParms,
250 0 );
251
252 /* Allow the user to hear what is being recorded
253 * by turning the monitor on
254 */
255 memset( &AmpSetParms, '\0', sizeof( MCI_AMP_SET_PARMS ) );
256 AmpSetParms.ulItem = MCI_AMP_SET_MONITOR;
257 rc = mciSendCommand(DeviceId,
258 MCI_SET,
259 MCI_WAIT | MCI_SET_ON | MCI_SET_ITEM,
260 ( PVOID ) &AmpSetParms,
261 0 );
262
263 wmutex.enter(VMUTEX_WAIT_FOREVER);
264 fMixerSetup = TRUE;
265 }
266
267 for(i=0;i<PREFILLBUF_DART_REC;i++) {
268 memset(MixBuffer[i].pBuffer, 0, MixBuffer[i].ulBufferLength);
269 }
270 dprintf(("Dart opened, bufsize = %d\n", MixBuffer[0].ulBufferLength));
271
272 dprintf(("MixSetupParms = %X\n", MixSetupParms));
273 State = STATE_RECORDING;
274 fOverrun = FALSE;
275 wmutex.leave();
276
277 dprintf(("Dart recording"));
278
279 // Start recording.
280 USHORT selTIB = GetFS(); // save current FS selector
281 MixSetupParms->pmixRead( MixSetupParms->ulMixHandle,
282 &MixBuffer[0],
283 PREFILLBUF_DART_REC);
284 SetFS(selTIB); // switch back to the saved FS selector
285
286 return(MMSYSERR_NOERROR);
287}
288/******************************************************************************/
289/******************************************************************************/
290MMRESULT DartWaveIn::stop()
291{
292 MCI_GENERIC_PARMS Params;
293
294 wmutex.enter(VMUTEX_WAIT_FOREVER);
295 if(State != STATE_RECORDING) {
296 State = STATE_STOPPED;
297 wmutex.leave();
298 return(MMSYSERR_NOERROR);
299 }
300
301 State = STATE_STOPPED;
302 wmutex.leave();
303
304 memset(&Params, 0, sizeof(Params));
305
306 // Stop recording.
307 mciSendCommand(DeviceId, MCI_STOP, MCI_WAIT, (PVOID)&Params, 0);
308
309 return(MMSYSERR_NOERROR);
310}
311/******************************************************************************/
312/******************************************************************************/
313MMRESULT DartWaveIn::reset()
314{
315 MCI_GENERIC_PARMS Params;
316 LPWAVEHDR tmpwavehdr;
317
318 dprintf(("DartWaveIn::reset %s", (State == STATE_RECORDING) ? "recording" : "stopped"));
319 if(State != STATE_RECORDING)
320 return(MMSYSERR_HANDLEBUSY);
321
322 memset(&Params, 0, sizeof(Params));
323
324 // Stop recording
325 mciSendCommand(DeviceId, MCI_STOP, MCI_WAIT, (PVOID)&Params, 0);
326
327 dprintf(("Nr of threads blocked on mutex = %d\n", wmutex.getNrBlocked()));
328
329 wmutex.enter(VMUTEX_WAIT_FOREVER);
330 while(wavehdr)
331 {
332 wavehdr->dwFlags |= WHDR_DONE;
333 wavehdr->dwFlags &= ~WHDR_INQUEUE;
334 tmpwavehdr = wavehdr;
335 wavehdr = wavehdr->lpNext;
336 tmpwavehdr->lpNext = NULL;
337
338 wmutex.leave();
339
340 callback(WIM_DATA, (ULONG)tmpwavehdr, 0);
341
342 wmutex.enter(VMUTEX_WAIT_FOREVER);
343 }
344 wavehdr = NULL;
345 State = STATE_STOPPED;
346 fOverrun = FALSE;
347
348 wmutex.leave();
349 return(MMSYSERR_NOERROR);
350}
351/******************************************************************************/
352/******************************************************************************/
353MMRESULT DartWaveIn::addBuffer(LPWAVEHDR pwh, UINT cbwh)
354{
355 int i;
356
357 wmutex.enter(VMUTEX_WAIT_FOREVER);
358 pwh->lpNext = NULL;
359 pwh->dwBytesRecorded = 0;
360 if(wavehdr) {
361 WAVEHDR *chdr = wavehdr;
362 while(chdr->lpNext) {
363 chdr = chdr->lpNext;
364 }
365 chdr->lpNext = pwh;
366 }
367 else wavehdr = pwh;
368 wmutex.leave();
369
370 return(MMSYSERR_NOERROR);
371}
372/******************************************************************************/
373/******************************************************************************/
374ULONG DartWaveIn::getPosition()
375{
376 MCI_STATUS_PARMS mciStatus = {0};
377 ULONG rc, nrbytes;
378
379 mciStatus.ulItem = MCI_STATUS_POSITION;
380 rc = mciSendCommand(DeviceId, MCI_STATUS, MCI_STATUS_ITEM|MCI_WAIT, (PVOID)&mciStatus, 0);
381 if((rc & 0xFFFF) == MCIERR_SUCCESS) {
382 nrbytes = (mciStatus.ulReturn * (getAvgBytesPerSecond()/1000));
383 return nrbytes;;
384 }
385 mciError(rc);
386 return 0xFFFFFFFF;
387}
388/******************************************************************************/
389/******************************************************************************/
390int DartWaveIn::getNumDevices()
391{
392 MCI_GENERIC_PARMS GenericParms;
393 MCI_AMP_OPEN_PARMS AmpOpenParms;
394 APIRET rc;
395
396 // Setup the open structure, pass the playlist and tell MCI_OPEN to use it
397 memset(&AmpOpenParms,0,sizeof(AmpOpenParms));
398
399 AmpOpenParms.usDeviceID = ( USHORT ) 0;
400 AmpOpenParms.pszDeviceType = ( PSZ ) MCI_DEVTYPE_AUDIO_AMPMIX;
401
402 rc = mciSendCommand(0, MCI_OPEN,
403 MCI_WAIT | MCI_OPEN_TYPE_ID | MCI_OPEN_SHAREABLE,
404 (PVOID) &AmpOpenParms,
405 0);
406
407 if(rc) {
408 return 0; //no devices present
409 }
410
411 // Generic parameters
412 GenericParms.hwndCallback = 0; //hwndFrame
413
414 // Close the device
415 mciSendCommand(AmpOpenParms.usDeviceID, MCI_CLOSE, MCI_WAIT, (PVOID)&GenericParms, 0);
416
417 return 1;
418}
419/******************************************************************************/
420/******************************************************************************/
421BOOL DartWaveIn::queryFormat(ULONG formatTag, ULONG nChannels,
422 ULONG nSamplesPerSec, ULONG wBitsPerSample)
423{
424 MCI_WAVE_GETDEVCAPS_PARMS mciAudioCaps;
425 MCI_GENERIC_PARMS GenericParms;
426 MCI_OPEN_PARMS mciOpenParms; /* open parms for MCI_OPEN */
427 int i, freqbits = 0;
428 ULONG rc, DeviceId;
429 BOOL winrc;
430
431 dprintf(("DartWaveIn::queryFormat %x srate=%d, nchan=%d, bps=%d", formatTag, nSamplesPerSec, nChannels, wBitsPerSample));
432
433 memset(&mciOpenParms, /* Object to fill with zeros. */
434 0, /* Value to place into the object. */
435 sizeof( mciOpenParms ) ); /* How many zero's to use. */
436
437 mciOpenParms.pszDeviceType = (PSZ)MCI_DEVTYPE_WAVEFORM_AUDIO;
438
439 rc = mciSendCommand( (USHORT) 0,
440 MCI_OPEN,
441 MCI_WAIT | MCI_OPEN_TYPE_ID,
442 (PVOID) &mciOpenParms,
443 0);
444 if((rc & 0xFFFF) != MCIERR_SUCCESS) {
445 mciError(rc);
446 return(FALSE);
447 }
448 DeviceId = mciOpenParms.usDeviceID;
449
450 memset( &mciAudioCaps , 0, sizeof(MCI_WAVE_GETDEVCAPS_PARMS));
451
452 mciAudioCaps.ulBitsPerSample = wBitsPerSample;
453 mciAudioCaps.ulFormatTag = DATATYPE_WAVEFORM;
454 mciAudioCaps.ulSamplesPerSec = nSamplesPerSec;
455 mciAudioCaps.ulChannels = nChannels;
456 mciAudioCaps.ulFormatMode = MCI_RECORD;
457 mciAudioCaps.ulItem = MCI_GETDEVCAPS_WAVE_FORMAT;
458
459 rc = mciSendCommand(DeviceId, /* Device ID */
460 MCI_GETDEVCAPS,
461 MCI_WAIT | MCI_GETDEVCAPS_EXTENDED | MCI_GETDEVCAPS_ITEM,
462 (PVOID) &mciAudioCaps,
463 0);
464 if((rc & 0xFFFF) != MCIERR_SUCCESS) {
465 mciError(rc);
466 winrc = FALSE;
467 }
468 else winrc = TRUE;
469
470 // Close the device
471 mciSendCommand(DeviceId,MCI_CLOSE,MCI_WAIT,(PVOID)&GenericParms,0);
472 return(winrc);
473}
474/******************************************************************************/
475/******************************************************************************/
476void DartWaveIn::mciError(ULONG ulError)
477{
478#ifdef DEBUG
479 char szError[256] = "";
480
481 mciGetErrorString(ulError, szError, sizeof(szError));
482 dprintf(("WINMM: DartWaveIn: %s\n", szError));
483#endif
484}
485/******************************************************************************/
486//Simple implementation of recording. We fill up buffers queued by the application
487//until we run out of data or buffers. If we run out of buffers, the recorded data
488//is thrown away. We will continue when when the applications adds more buffers.
489/******************************************************************************/
490void DartWaveIn::handler(ULONG ulStatus, PMCI_MIX_BUFFER pBuffer, ULONG ulFlags)
491{
492 ULONG buflength, bufpos, bytestocopy;
493 WAVEHDR *whdr, *prevhdr = NULL;
494
495 dprintf2(("WINMM: DartWaveIn handler %x\n", pBuffer));
496 if(ulFlags == MIX_STREAM_ERROR) {
497 if(ulStatus == ERROR_DEVICE_OVERRUN) {
498 dprintf(("WINMM: ERROR: WaveIn handler ERROR_DEVICE_OVERRUN!\n"));
499 if(State == STATE_RECORDING) {
500 fOverrun = TRUE;
501 stop(); //out of buffers, so stop playback
502 }
503 return;
504 }
505 dprintf(("WINMM: WaveIn handler, Unknown error %X\n", ulStatus));
506 return;
507 }
508 wmutex.enter(VMUTEX_WAIT_FOREVER);
509
510 whdr = wavehdr;
511 if(whdr == NULL) {
512 wmutex.leave();
513 //last buffer recorded -> no new ones -> overrun
514 //Windows doesn't care -> just continue
515 dprintf(("WINMM: WARNING: WaveIn handler OVERRUN!\n"));
516 return;
517 }
518
519 buflength = pBuffer->ulBufferLength;
520 bufpos = 0;
521 while(buflength) {
522 if(wavehdr) {
523 bytestocopy = min(buflength, wavehdr->dwBufferLength - wavehdr->dwBytesRecorded);
524 if(bytestocopy) {
525 memcpy(wavehdr->lpData + wavehdr->dwBytesRecorded, (char *)pBuffer->pBuffer + bufpos, bytestocopy);
526 }
527 else DebugInt3(); //should never happen
528
529 bufpos += bytestocopy;
530 wavehdr->dwBytesRecorded += bytestocopy;
531 buflength -= bytestocopy;
532
533 if(wavehdr->dwBytesRecorded == wavehdr->dwBufferLength)
534 {
535 dprintf2(("WINMM: DartWaveIn handler buf %X done\n", whdr));
536 whdr->dwFlags |= WHDR_DONE;
537 whdr->dwFlags &= ~WHDR_INQUEUE;
538
539 wavehdr = whdr->lpNext;
540 whdr->lpNext = NULL;
541 wmutex.leave();
542
543 callback(WIM_DATA, (ULONG)whdr, whdr->dwBytesRecorded);
544
545 wmutex.enter(VMUTEX_WAIT_FOREVER);
546 }
547 }
548 else break;
549 }
550 wmutex.leave();
551
552 //Transfer buffer to DART
553 // MCI_MIXSETUP_PARMS->pMixWrite does alter FS: selector!
554 USHORT selTIB = GetFS(); // save current FS selector
555 MixSetupParms->pmixWrite(MixSetupParms->ulMixHandle, pBuffer, 1);
556 SetFS(selTIB); // switch back to the saved FS selector
557}
558/******************************************************************************/
559/******************************************************************************/
560LONG APIENTRY WaveInHandler(ULONG ulStatus,
561 PMCI_MIX_BUFFER pBuffer,
562 ULONG ulFlags)
563{
564 DartWaveIn *dwave;
565
566 if(pBuffer && pBuffer->ulUserParm)
567 {
568 dwave = (DartWaveIn *)pBuffer->ulUserParm;
569 dwave->handler(ulStatus, pBuffer, ulFlags);
570 }
571 return(TRUE);
572}
573/******************************************************************************/
574/******************************************************************************/
575
Note: See TracBrowser for help on using the repository browser.