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

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

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