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

Last change on this file since 2242 was 2242, checked in by phaller, 26 years ago

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