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

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

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