source: trunk/src/winmm/wavein.cpp

Last change on this file was 21916, checked in by dmik, 14 years ago

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