source: trunk/src/winmm/wavein.cpp@ 5272

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

Added preliminary wavein support
File size: 12.5 KB
Line 
1/* $Id: wavein.cpp,v 1.6 2001-02-27 21:13:59 sandervl Exp $ */
2
3/*
4 * Wave in stubs
5 *
6 * Copyright 1998 Joel Troster
7 *
8 *
9 * Project Odin Software License can be found in LICENSE.TXT
10 *
11 */
12
13
14/****************************************************************************
15 * Includes *
16 ****************************************************************************/
17
18#include <os2win.h>
19#include <mmsystem.h>
20#include <odinwrap.h>
21#include <stdio.h>
22#include <string.h>
23#include <misc.h>
24#include <unicode.h>
25
26#include "winmm.h"
27#include "dwavein.h"
28
29#define DBG_LOCALLOG DBG_wavein
30#include "dbglocal.h"
31
32
33ODINDEBUGCHANNEL(WINMM-WAVEIN)
34
35/******************************************************************************/
36/******************************************************************************/
37ODINFUNCTION6(MMRESULT, waveInOpen,
38 LPHWAVEIN, phwi,
39 UINT, uDeviceID,
40 const LPWAVEFORMATEX, pwfx,
41 DWORD, dwCallback,
42 DWORD, dwInstance,
43 DWORD, fdwOpen)
44{
45 MMRESULT rc;
46
47 if(pwfx == NULL)
48 return(WAVERR_BADFORMAT);
49
50 if(fdwOpen == WAVE_FORMAT_QUERY) {
51 if(DartWaveIn::queryFormat(pwfx->wFormatTag, pwfx->nChannels, pwfx->nSamplesPerSec,
52 pwfx->wBitsPerSample) == TRUE) {
53 return(MMSYSERR_NOERROR);
54 }
55 else return(WAVERR_BADFORMAT);
56 }
57
58 if(phwi == NULL)
59 return(MMSYSERR_INVALPARAM);
60
61 if(fdwOpen == CALLBACK_WINDOW) {
62 *phwi = (HWAVEOUT)new DartWaveIn(pwfx, (HWND)dwCallback);
63 }
64 else
65 if(fdwOpen == CALLBACK_FUNCTION)
66 {
67 //@@@PH 1999/12/28 save valid FS: to win32 TIB
68 *phwi = (HWAVEOUT)new DartWaveIn(pwfx, dwCallback, dwInstance, GetFS());
69 }
70 else *phwi = (HWAVEOUT)new DartWaveIn(pwfx);
71
72 if(*phwi == NULL) {
73 return(MMSYSERR_NODRIVER);
74 }
75
76 rc = ((DartWaveIn *)*phwi)->getError();
77 if(rc != MMSYSERR_NOERROR) {
78 delete (DartWaveIn *)*phwi;
79 return(rc);
80 }
81 return(MMSYSERR_NOERROR);
82}
83/******************************************************************************/
84/******************************************************************************/
85ODINFUNCTION1(MMRESULT, waveInClose,
86 HWAVEIN, hwi)
87{
88 DartWaveIn *dwave = (DartWaveIn *)hwi;
89
90 if(DartWaveIn::find(dwave) == TRUE)
91 {
92 if(dwave->getState() == STATE_RECORDING)
93 return(WAVERR_STILLPLAYING);
94
95 delete dwave;
96 return(MMSYSERR_NOERROR);
97 }
98 else return(MMSYSERR_INVALHANDLE);
99}
100/******************************************************************************/
101/******************************************************************************/
102ODINFUNCTION1(MMRESULT, waveInReset,
103 HWAVEIN, hwi)
104{
105 DartWaveIn *dwave = (DartWaveIn *)hwi;
106
107 if(DartWaveIn::find(dwave) == TRUE)
108 return(dwave->reset());
109 else return(MMSYSERR_INVALHANDLE);
110}
111/******************************************************************************/
112/******************************************************************************/
113ODINFUNCTION1(MMRESULT, waveInStart,
114 HWAVEIN, hwi)
115{
116 DartWaveIn *dwave = (DartWaveIn *)hwi;
117
118 if(DartWaveIn::find(dwave) == TRUE)
119 return(dwave->start());
120 else return(MMSYSERR_INVALHANDLE);
121}
122/******************************************************************************/
123/******************************************************************************/
124ODINFUNCTION1(MMRESULT, waveInStop,
125 HWAVEIN, hwi)
126{
127 DartWaveIn *dwave = (DartWaveIn *)hwi;
128
129 if(DartWaveIn::find(dwave) == TRUE)
130 return(dwave->stop());
131 else return(MMSYSERR_INVALHANDLE);
132}
133/******************************************************************************/
134/******************************************************************************/
135ODINFUNCTION3(MMRESULT, waveInGetPosition,
136 HWAVEIN, hwi,
137 LPMMTIME, pmmt,
138 UINT, cbmmt)
139{
140 DartWaveIn *dwave = (DartWaveIn *)hwi;
141
142 if(pmmt == NULL)
143 return MMSYSERR_INVALPARAM;
144
145 if(DartWaveIn::find(dwave) == TRUE)
146 {
147 ULONG position;
148
149 position = dwave->getPosition();
150 if(position == -1) {
151 return MMSYSERR_HANDLEBUSY; //todo correct error value
152 }
153 switch (pmmt->wType) {
154 case TIME_BYTES:
155 pmmt->u.cb = position;
156 break;
157 case TIME_SAMPLES:
158 pmmt->u.sample = position * 8 / dwave->getBitsPerSample();
159 break;
160 case TIME_SMPTE:
161 {
162 ULONG timeval = position / (dwave->getAvgBytesPerSecond() / 1000);
163 pmmt->u.smpte.hour = timeval / 108000;
164 timeval -= pmmt->u.smpte.hour * 108000;
165 pmmt->u.smpte.min = timeval / 1800;
166 timeval -= pmmt->u.smpte.min * 1800;
167 pmmt->u.smpte.sec = timeval / 30;
168 timeval -= pmmt->u.smpte.sec * 30;
169 pmmt->u.smpte.frame = timeval;
170 pmmt->u.smpte.fps = 30;
171 break;
172 }
173 default:
174 dprintf(("waveInGetPosition: Format %d not supported ! use TIME_MS !\n", pmmt->wType));
175 pmmt->wType = TIME_MS;
176 case TIME_MS:
177 pmmt->u.ms = position / (dwave->getAvgBytesPerSecond() / 1000);
178 dprintf(("WINMM:waveInGetPosition: TIME_MS pos=%d ms=%d time=%d", position, pmmt->u.ms, GetCurrentTime()));
179 break;
180 }
181 return MMSYSERR_NOERROR;
182 }
183 else return(MMSYSERR_INVALHANDLE);
184}
185/******************************************************************************/
186/******************************************************************************/
187ODINFUNCTION3(MMRESULT, waveInAddBuffer,
188 HWAVEIN, hwi,
189 LPWAVEHDR, pwh,
190 UINT, cbwh)
191{
192 DartWaveIn *dwave = (DartWaveIn *)hwi;
193
194 if(DartWaveIn::find(dwave) == TRUE)
195 {
196 if(!(pwh->dwFlags & WHDR_PREPARED) || pwh->lpData == NULL)
197 return WAVERR_UNPREPARED;
198
199 if(pwh->dwFlags & WHDR_INQUEUE)
200 return WAVERR_STILLPLAYING;
201
202 pwh->dwFlags |= WHDR_INQUEUE;
203 pwh->dwFlags &= ~WHDR_DONE;
204
205 dprintf(("waveInAddBuffer %x %d %x", pwh->lpData, pwh->dwBufferLength, pwh->dwFlags));
206 return(dwave->addBuffer(pwh, cbwh));
207 }
208 else return(MMSYSERR_INVALHANDLE);
209}
210/******************************************************************************/
211/******************************************************************************/
212ODINFUNCTION3(MMRESULT, waveInPrepareHeader,
213 HWAVEIN, hwi,
214 LPWAVEHDR, pwh,
215 UINT, cbwh)
216{
217 DartWaveIn *dwave = (DartWaveIn *)hwi;
218
219 if(DartWaveIn::find(dwave) == TRUE)
220 {
221 if(pwh->dwFlags & WHDR_INQUEUE)
222 return WAVERR_STILLPLAYING;
223
224 pwh->dwFlags |= WHDR_PREPARED;
225 pwh->dwFlags &= ~WHDR_DONE;
226 pwh->lpNext = NULL;
227 return(MMSYSERR_NOERROR);
228 }
229 else return(MMSYSERR_INVALHANDLE);
230}
231/******************************************************************************/
232/******************************************************************************/
233ODINFUNCTION3(MMRESULT, waveInUnprepareHeader,
234 HWAVEIN, hwi,
235 LPWAVEHDR, pwh,
236 UINT, cbwh)
237{
238 DartWaveIn *dwave = (DartWaveIn *)hwi;
239
240 if(DartWaveIn::find(dwave) == TRUE)
241 {
242 if(pwh->dwFlags & WHDR_INQUEUE)
243 return WAVERR_STILLPLAYING;
244
245 pwh->dwFlags &= ~WHDR_PREPARED;
246 pwh->dwFlags |= WHDR_DONE;
247 return(MMSYSERR_NOERROR);
248 }
249 else return(MMSYSERR_INVALHANDLE);
250}
251/******************************************************************************/
252/******************************************************************************/
253ODINFUNCTION3(MMRESULT, waveInGetDevCapsA,
254 UINT, uDeviceID,
255 LPWAVEINCAPSA, pwic,
256 UINT, cbwic)
257{
258 if(DartWaveIn::getNumDevices() == 0) {
259 memset(pwic, 0, sizeof(*pwic));
260 return MMSYSERR_NODRIVER;
261 }
262
263 // we have to fill in this thing
264 pwic->wMid = 0; /* manufacturer ID */
265 pwic->wPid = 0; /* product ID */
266 pwic->vDriverVersion = 0x0001; /* version of the driver */
267 strcpy( pwic->szPname, "OS/2 DART Wave In" ); /* product name */
268 pwic->dwFormats = WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 |
269 WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16 |
270 WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 |
271 WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
272 WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 |
273 WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16;
274
275 pwic->wChannels = 2; /* number of sources supported */
276 pwic->wReserved1 = 0; /* packing */
277
278 return MMSYSERR_NOERROR;
279}
280/******************************************************************************/
281/******************************************************************************/
282ODINFUNCTION3(MMRESULT, waveInGetDevCapsW,
283 UINT, uDeviceID,
284 LPWAVEINCAPSW, pwic,
285 UINT, cbwic)
286{
287 if(DartWaveIn::getNumDevices() == 0) {
288 memset(pwic, 0, sizeof(*pwic));
289 return MMSYSERR_NODRIVER;
290 }
291 // we have to fill in this thing
292 pwic->wMid = 0; /* manufacturer ID */
293 pwic->wPid = 0; /* product ID */
294 pwic->vDriverVersion = 0x0001; /* version of the driver */
295 lstrcpyW(pwic->szPname, (LPCWSTR)L"OS/2 DART Wave In"); /* product name */
296 pwic->dwFormats = WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 |
297 WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16 |
298 WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 |
299 WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
300 WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 |
301 WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16;
302
303 pwic->wChannels = 2; /* number of sources supported */
304 pwic->wReserved1 = 0; /* packing */
305
306 return MMSYSERR_NOERROR;
307}
308/******************************************************************************/
309/******************************************************************************/
310ODINFUNCTION3(MMRESULT, waveInGetErrorTextA,
311 MMRESULT, wError,
312 LPSTR, lpText,
313 UINT, cchText)
314{
315 dprintf(("WINMM:waveInGetErrorTextA(%d)\n", wError ));
316 char * theMsg = getWinmmMsg( wError );
317 if ( theMsg )
318 strncpy( lpText, theMsg, cchText );
319 else
320 {
321 char errMsg[100];
322 sprintf( errMsg, "Unknown error number %d", wError );
323 strncpy( lpText, errMsg, cchText );
324 }
325 return MMSYSERR_NOERROR;
326}
327/******************************************************************************/
328/******************************************************************************/
329ODINFUNCTION3(MMRESULT, waveInGetErrorTextW,
330 MMRESULT, wError,
331 LPWSTR, lpText,
332 UINT, cchText)
333{
334 dprintf(("WINMM:waveInGetErrorTextW(%d) - stub\n", wError ));
335 char * theMsg = getWinmmMsg( wError );
336 if ( theMsg )
337 AsciiToUnicode( theMsg, lpText );
338 else
339 {
340 char errMsg[100];
341 sprintf( errMsg, "Unknown error number %d", wError );
342 AsciiToUnicode( errMsg, lpText );
343 }
344 return MMSYSERR_NOERROR;
345}
346/******************************************************************************/
347/******************************************************************************/
348ODINFUNCTION2(MMRESULT, waveInGetID,
349 HWAVEIN, hwi,
350 LPUINT, puDeviceID)
351{
352 DartWaveIn *dwave = (DartWaveIn *)hwi;
353 if(DartWaveIn::find(dwave) == TRUE)
354 {
355 *puDeviceID = 1;
356 return MMSYSERR_NOERROR;
357 }
358 else return(MMSYSERR_INVALHANDLE);
359}
360/******************************************************************************/
361/******************************************************************************/
362ODINFUNCTION0(UINT, waveInGetNumDevs)
363{
364 return DartWaveIn::getNumDevices();
365}
366/******************************************************************************/
367/******************************************************************************/
368ODINFUNCTION4(MMRESULT, waveInMessage,
369 HWAVEIN, hwi,
370 UINT, uMsg,
371 DWORD, dw1,
372 DWORD, dw2)
373{
374 dprintf(("WINMM:waveInMessage - stub\n"));
375
376 DartWaveIn *dwave = (DartWaveIn *)hwi;
377 if(DartWaveIn::find(dwave) == TRUE)
378 {
379 return MMSYSERR_NOTSUPPORTED;
380 }
381 else
382 return(MMSYSERR_INVALHANDLE);
383}
384/******************************************************************************/
385/******************************************************************************/
386
Note: See TracBrowser for help on using the repository browser.