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

Last change on this file since 10173 was 10173, checked in by sandervl, 22 years ago

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