source: trunk/src/winmm/waveout.cpp@ 2172

Last change on this file since 2172 was 2168, checked in by sandervl, 26 years ago

RP's waveOutOpen bugfixes
File size: 12.4 KB
Line 
1/* $Id: waveout.cpp,v 1.7 1999-12-20 22:22:07 sandervl Exp $ */
2#undef DEBUG
3/*
4 * Wave out MM apis
5 *
6 * Copyright 1998 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 * Includes *
16 ****************************************************************************/
17
18#include <os2win.h>
19#include <mmsystem.h>
20#include <odinwrap.h>
21
22#include <string.h>
23#include <stdio.h>
24#include <string.h>
25#include <unicode.h>
26
27#include "dwaveout.h"
28#include "misc.h"
29#include "winmm.h"
30
31ODINDEBUGCHANNEL(WINMM-WAVEOUT)
32
33
34/******************************************************************************/
35/******************************************************************************/
36ODINFUNCTION6(MMRESULT, waveOutOpen,
37 LPHWAVEOUT, phwo,
38 UINT, uDeviceID,
39 const LPWAVEFORMATEX, pwfx,
40 DWORD, dwCallback,
41 DWORD, dwInstance,
42 DWORD, fdwOpen)
43{
44 MMRESULT rc;
45
46 if(pwfx == NULL)
47 return(WAVERR_BADFORMAT);
48
49 if(phwo == NULL)
50 return(MMSYSERR_INVALPARAM);
51
52 if(fdwOpen == WAVE_FORMAT_QUERY) {
53 if(DartWaveOut::queryFormat(pwfx->wFormatTag, pwfx->nChannels,
54 pwfx->nSamplesPerSec, pwfx->nBlockAlign) == TRUE) {
55 return(MMSYSERR_NOERROR);
56 }
57 else return(WAVERR_BADFORMAT);
58 }
59
60 if(fdwOpen == CALLBACK_WINDOW) {
61 *phwo = (HWAVEOUT)new DartWaveOut(pwfx, (HWND)dwCallback);
62 }
63 else
64 if(fdwOpen == CALLBACK_FUNCTION) {
65 *phwo = (HWAVEOUT)new DartWaveOut(pwfx, dwCallback, dwInstance);
66 }
67 else *phwo = (HWAVEOUT)new DartWaveOut(pwfx);
68
69 if(*phwo == NULL) {
70 return(MMSYSERR_NODRIVER);
71 }
72
73 rc = ((DartWaveOut *)*phwo)->getError();
74 if(rc != MMSYSERR_NOERROR) {
75 delete (DartWaveOut *)*phwo;
76 return(rc);
77 }
78 return(MMSYSERR_NOERROR);
79}
80/******************************************************************************/
81/******************************************************************************/
82ODINFUNCTION3(MMRESULT, waveOutWrite,
83 HWAVEOUT, hwo,
84 LPWAVEHDR, pwh,
85 UINT, cbwh)
86{
87 DartWaveOut *dwave = (DartWaveOut *)hwo;
88
89 if(DartWaveOut::find(dwave) == TRUE)
90 {
91 if(!(pwh->dwFlags & WHDR_PREPARED) || pwh->lpData == NULL)
92 return WAVERR_UNPREPARED;
93
94 if(pwh->dwFlags & WHDR_INQUEUE)
95 return WAVERR_STILLPLAYING;
96
97 pwh->dwFlags |= WHDR_INQUEUE;
98 pwh->dwFlags &= ~WHDR_DONE;
99
100 return(dwave->write(pwh, cbwh));
101 }
102 else
103 return(MMSYSERR_INVALHANDLE);
104}
105/******************************************************************************/
106/******************************************************************************/
107ODINFUNCTION1(MMRESULT, waveOutReset,
108 HWAVEOUT, hwaveout)
109{
110 DartWaveOut *dwave = (DartWaveOut *)hwaveout;
111
112 if(DartWaveOut::find(dwave) == TRUE)
113 return(dwave->reset());
114 else
115 return(MMSYSERR_INVALHANDLE);
116}
117/******************************************************************************/
118/******************************************************************************/
119ODINFUNCTION1(MMRESULT, waveOutBreakLoop,
120 HWAVEOUT, hwaveout)
121{
122 DartWaveOut *dwave = (DartWaveOut *)hwaveout;
123
124 dprintf(("WINMM:waveOutBreakLoop (implemented as reset) %X\n", hwaveout));
125 if(DartWaveOut::find(dwave) == TRUE)
126 return(dwave->reset());
127 else
128 return(MMSYSERR_INVALHANDLE);
129}
130/******************************************************************************/
131/******************************************************************************/
132ODINFUNCTION1(MMRESULT, waveOutClose,
133 HWAVEOUT, hwaveout)
134{
135 DartWaveOut *dwave = (DartWaveOut *)hwaveout;
136
137 if(DartWaveOut::find(dwave) == TRUE)
138 {
139 if(dwave->getState() == STATE_PLAYING)
140 return(WAVERR_STILLPLAYING);
141
142 delete dwave;
143 return(MMSYSERR_NOERROR);
144 }
145 else
146 return(MMSYSERR_INVALHANDLE);
147}
148/******************************************************************************/
149/******************************************************************************/
150ODINFUNCTION1(MMRESULT, waveOutPause,
151 HWAVEOUT, hwaveout)
152{
153 DartWaveOut *dwave = (DartWaveOut *)hwaveout;
154
155 if(DartWaveOut::find(dwave) == TRUE)
156 return(dwave->pause());
157 else
158 return(MMSYSERR_INVALHANDLE);
159}
160/******************************************************************************/
161/******************************************************************************/
162ODINFUNCTION1(MMRESULT, waveOutRestart,
163 HWAVEOUT, hwaveout)
164{
165 DartWaveOut *dwave = (DartWaveOut *)hwaveout;
166
167 if(DartWaveOut::find(dwave) == TRUE)
168 return(dwave->restart());
169 else
170 return(MMSYSERR_INVALHANDLE);
171}
172/******************************************************************************/
173/******************************************************************************/
174ODINFUNCTION3(MMRESULT, waveOutPrepareHeader,
175 HWAVEOUT, hwo,
176 LPWAVEHDR, pwh,
177 UINT, cbwh)
178{
179 DartWaveOut *dwave = (DartWaveOut *)hwo;
180
181 if(DartWaveOut::find(dwave) == TRUE)
182 {
183 if(pwh->dwFlags & WHDR_INQUEUE)
184 return WAVERR_STILLPLAYING;
185
186 pwh->dwFlags |= WHDR_PREPARED;
187 pwh->dwFlags &= ~WHDR_DONE;
188 pwh->lpNext = NULL;
189 return(MMSYSERR_NOERROR);
190 }
191 else
192 return(MMSYSERR_INVALHANDLE);
193}
194/******************************************************************************/
195/******************************************************************************/
196ODINFUNCTION3(MMRESULT, waveOutUnprepareHeader,
197 HWAVEOUT, hwo,
198 LPWAVEHDR, pwh,
199 UINT, cbwh)
200{
201 DartWaveOut *dwave = (DartWaveOut *)hwo;
202
203 if(DartWaveOut::find(dwave) == TRUE)
204 {
205 if(pwh->dwFlags & WHDR_INQUEUE)
206 return WAVERR_STILLPLAYING;
207
208 pwh->dwFlags &= ~WHDR_PREPARED;
209 pwh->dwFlags |= WHDR_DONE;
210 return(MMSYSERR_NOERROR);
211 }
212 else
213 return(MMSYSERR_INVALHANDLE);
214}
215/******************************************************************************/
216/******************************************************************************/
217ODINFUNCTION3(MMRESULT, waveOutGetPosition,
218 HWAVEOUT, hwo,
219 LPMMTIME, pmmt,
220 UINT, cbmmt)
221{
222 DartWaveOut *dwave = (DartWaveOut *)hwo;
223 dprintf(("WINMM:waveOutGetPosition - not implemented\n"));
224 if(DartWaveOut::find(dwave) == TRUE)
225 return(MMSYSERR_NOERROR);
226 else
227 return(MMSYSERR_INVALHANDLE);
228}
229/******************************************************************************/
230/******************************************************************************/
231ODINFUNCTION3(MMRESULT, waveOutGetDevCapsA,
232 UINT, uDeviceID,
233 LPWAVEOUTCAPSA, pwoc,
234 UINT, cbwoc)
235{
236 dprintf(("WINMM:waveOutGetDevCapsA"));
237
238 if(DartWaveOut::getNumDevices() == 0) {
239 memset(pwoc, 0, sizeof(*pwoc));
240 return MMSYSERR_NODRIVER;
241 }
242
243 // we have to fill in this thing
244 pwoc->wMid = 0; /* manufacturer ID */
245 pwoc->wPid = 0; /* product ID */
246 pwoc->vDriverVersion = 0x0001; /* version of the driver */
247 strcpy( pwoc->szPname, "OS/2 DART Wave Out" ); /* product name */
248 pwoc->dwFormats = WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 |
249 WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16 |
250 WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 |
251 WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
252 WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 |
253 WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16;
254
255 pwoc->wChannels = 2; /* number of sources supported */
256 pwoc->wReserved1 = 0; /* packing */
257 pwoc->dwSupport = WAVECAPS_LRVOLUME | WAVECAPS_VOLUME;
258
259 return MMSYSERR_NOERROR;
260}
261/******************************************************************************/
262/******************************************************************************/
263ODINFUNCTION3(MMRESULT, waveOutGetDevCapsW,
264 UINT, uDeviceID,
265 LPWAVEOUTCAPSW, pwoc,
266 UINT, cbwoc)
267{
268 dprintf(("WINMM:waveOutGetDevCapsW"));
269
270 if(DartWaveOut::getNumDevices() == 0) {
271 memset(pwoc, 0, sizeof(*pwoc));
272 return MMSYSERR_NODRIVER;
273 }
274 // we have to fill in this thing
275 pwoc->wMid = 0; /* manufacturer ID */
276 pwoc->wPid = 0; /* product ID */
277 pwoc->vDriverVersion = 0x0001; /* version of the driver */
278 AsciiToUnicode( "OS/2 DART Wave Out", pwoc->szPname ); /* product name */
279 pwoc->dwFormats = WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 |
280 WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16 |
281 WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 |
282 WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
283 WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 |
284 WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16;
285
286 pwoc->wChannels = 2; /* number of sources supported */
287 pwoc->wReserved1 = 0; /* packing */
288 pwoc->dwSupport = WAVECAPS_LRVOLUME | WAVECAPS_VOLUME;
289
290 return MMSYSERR_NOERROR;
291}
292/******************************************************************************/
293/******************************************************************************/
294ODINFUNCTION0(UINT, waveOutGetNumDevs)
295{
296 return DartWaveOut::getNumDevices();
297}
298/******************************************************************************/
299/******************************************************************************/
300ODINFUNCTION3(MMRESULT, waveOutGetErrorTextA,
301 MMRESULT, wError,
302 LPSTR, lpText,
303 UINT, cchText)
304{
305 char * theMsg = getWinmmMsg( wError );
306 if ( theMsg )
307 strncpy( lpText, theMsg, cchText );
308 else
309 {
310 char errMsg[100];
311 sprintf( errMsg, "Unknown error number %d", wError );
312 strncpy( lpText, errMsg, cchText );
313 }
314 return MMSYSERR_NOERROR;
315}
316
317ODINFUNCTION3(MMRESULT, waveOutGetErrorTextW,
318 MMRESULT, wError,
319 LPWSTR, lpText,
320 UINT, cchText)
321{
322 char * theMsg = getWinmmMsg( wError );
323 if ( theMsg )
324 AsciiToUnicode( theMsg, lpText );
325 else
326 {
327 char errMsg[100];
328 sprintf( errMsg, "Unknown error number %d", wError );
329 AsciiToUnicode( errMsg, lpText );
330 }
331 return MMSYSERR_NOERROR;
332}
333
334ODINFUNCTION2(MMRESULT, waveOutGetID,
335 HWAVEOUT, hwo,
336 LPUINT, puDeviceID)
337{
338 DartWaveOut *dwave = (DartWaveOut *)hwo;
339 if(DartWaveOut::find(dwave) == TRUE)
340 {
341 *puDeviceID = 1;
342 return MMSYSERR_NOERROR;
343 }
344 else
345 return(MMSYSERR_INVALHANDLE);
346}
347
348ODINFUNCTION2(MMRESULT, waveOutGetPitch,
349 HWAVEOUT, hwo,
350 LPDWORD, pdwPitch)
351{
352 DartWaveOut *dwave = (DartWaveOut *)hwo;
353 if(DartWaveOut::find(dwave) == TRUE)
354 return MMSYSERR_NOTSUPPORTED;
355 else
356 return(MMSYSERR_INVALHANDLE);
357}
358
359ODINFUNCTION2(MMRESULT, waveOutSetPitch,
360 HWAVEOUT, hwo,
361 DWORD, dwPitch)
362{
363 DartWaveOut *dwave = (DartWaveOut *)hwo;
364 if(DartWaveOut::find(dwave) == TRUE)
365 return MMSYSERR_NOTSUPPORTED;
366 else
367 return(MMSYSERR_INVALHANDLE);
368}
369
370ODINFUNCTION2(MMRESULT, waveOutGetVolume,
371 HWAVEOUT, hwo,
372 LPDWORD, pdwVolume)
373{
374 DartWaveOut *dwave = (DartWaveOut *)hwo;
375 if(DartWaveOut::find(dwave) == TRUE)
376 {
377 return MMSYSERR_NOTSUPPORTED;
378 }
379 else
380 return(MMSYSERR_INVALHANDLE);
381}
382
383ODINFUNCTION2(MMRESULT, waveOutSetVolume,
384 HWAVEOUT, hwo,
385 DWORD, dwVolume)
386{
387 DartWaveOut *dwave = (DartWaveOut *)hwo;
388 if(DartWaveOut::find(dwave) == TRUE)
389 {
390 return MMSYSERR_NOTSUPPORTED;
391 }
392 else
393 return(MMSYSERR_INVALHANDLE);
394}
395
396ODINFUNCTION2(MMRESULT, waveOutGetPlaybackRate,
397 HWAVEOUT, hwo,
398 LPDWORD, pdwRate)
399{
400 DartWaveOut *dwave = (DartWaveOut *)hwo;
401 if(DartWaveOut::find(dwave) == TRUE)
402 {
403 return MMSYSERR_NOTSUPPORTED;
404 }
405 else
406 return(MMSYSERR_INVALHANDLE);
407}
408
409ODINFUNCTION2(MMRESULT, waveOutSetPlaybackRate,
410 HWAVEOUT, hwo,
411 DWORD, dwRate)
412{
413 DartWaveOut *dwave = (DartWaveOut *)hwo;
414 if(DartWaveOut::find(dwave) == TRUE)
415 {
416 return MMSYSERR_NOTSUPPORTED;
417 }
418 else
419 return(MMSYSERR_INVALHANDLE);
420}
421
422ODINFUNCTION4(MMRESULT, waveOutMessage,
423 HWAVEOUT, hwo,
424 UINT, uMsg,
425 DWORD, dw1,
426 DWORD, dw2)
427{
428 DartWaveOut *dwave = (DartWaveOut *)hwo;
429 if(DartWaveOut::find(dwave) == TRUE)
430 {
431 return MMSYSERR_NOTSUPPORTED;
432 }
433 else
434 return(MMSYSERR_INVALHANDLE);
435}
436
437
Note: See TracBrowser for help on using the repository browser.