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

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

Add: added ODINWRAP support for WINMM
File size: 12.1 KB
Line 
1/* $Id: waveout.cpp,v 1.4 1999-08-19 18:46:05 phaller Exp $ */
2
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 - not implemented\n"));
237 // we have to fill in this thing
238 pwoc->wMid = 0; /* manufacturer ID */
239 pwoc->wPid = 0; /* product ID */
240 pwoc->vDriverVersion = 0x0001; /* version of the driver */
241 strcpy( pwoc->szPname, "OS/2 DART Wave Out" ); /* product name */
242 pwoc->dwFormats = WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 |
243 WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16 |
244 WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 |
245 WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
246 WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 |
247 WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16;
248
249 pwoc->wChannels = 2; /* number of sources supported */
250 pwoc->wReserved1 = 0; /* packing */
251 pwoc->dwSupport = WAVECAPS_LRVOLUME | WAVECAPS_VOLUME;
252
253 return MMSYSERR_NOERROR;
254}
255/******************************************************************************/
256/******************************************************************************/
257ODINFUNCTION3(MMRESULT, waveOutGetDevCapsW,
258 UINT, uDeviceID,
259 LPWAVEOUTCAPSW, pwoc,
260 UINT, cbwoc)
261{
262 dprintf(("WINMM:waveOutGetDevCapsW - not implemented\n"));
263 // we have to fill in this thing
264 pwoc->wMid = 0; /* manufacturer ID */
265 pwoc->wPid = 0; /* product ID */
266 pwoc->vDriverVersion = 0x0001; /* version of the driver */
267 AsciiToUnicode( "OS/2 DART Wave Out", pwoc->szPname ); /* product name */
268 pwoc->dwFormats = WAVE_FORMAT_1M08 | WAVE_FORMAT_1S08 |
269 WAVE_FORMAT_1M16 | WAVE_FORMAT_1S16 |
270 WAVE_FORMAT_2M08 | WAVE_FORMAT_2S08 |
271 WAVE_FORMAT_2M16 | WAVE_FORMAT_2S16 |
272 WAVE_FORMAT_4M08 | WAVE_FORMAT_4S08 |
273 WAVE_FORMAT_4M16 | WAVE_FORMAT_4S16;
274
275 pwoc->wChannels = 2; /* number of sources supported */
276 pwoc->wReserved1 = 0; /* packing */
277 pwoc->dwSupport = WAVECAPS_LRVOLUME | WAVECAPS_VOLUME;
278
279 return MMSYSERR_NOERROR;
280}
281/******************************************************************************/
282/******************************************************************************/
283ODINFUNCTION0(UINT, waveOutGetNumDevs)
284{
285 return 1;
286}
287/******************************************************************************/
288/******************************************************************************/
289ODINFUNCTION3(MMRESULT, waveOutGetErrorTextA,
290 MMRESULT, wError,
291 LPSTR, lpText,
292 UINT, cchText)
293{
294 char * theMsg = getWinmmMsg( wError );
295 if ( theMsg )
296 strncpy( lpText, theMsg, cchText );
297 else
298 {
299 char errMsg[100];
300 sprintf( errMsg, "Unknown error number %d", wError );
301 strncpy( lpText, errMsg, cchText );
302 }
303 return MMSYSERR_NOERROR;
304}
305
306ODINFUNCTION3(MMRESULT, waveOutGetErrorTextW,
307 MMRESULT, wError,
308 LPWSTR, lpText,
309 UINT, cchText)
310{
311 char * theMsg = getWinmmMsg( wError );
312 if ( theMsg )
313 AsciiToUnicode( theMsg, lpText );
314 else
315 {
316 char errMsg[100];
317 sprintf( errMsg, "Unknown error number %d", wError );
318 AsciiToUnicode( errMsg, lpText );
319 }
320 return MMSYSERR_NOERROR;
321}
322
323ODINFUNCTION2(MMRESULT, waveOutGetID,
324 HWAVEOUT, hwo,
325 LPUINT, puDeviceID)
326{
327 DartWaveOut *dwave = (DartWaveOut *)hwo;
328 if(DartWaveOut::find(dwave) == TRUE)
329 {
330 *puDeviceID = 1;
331 return MMSYSERR_NOERROR;
332 }
333 else
334 return(MMSYSERR_INVALHANDLE);
335}
336
337ODINFUNCTION2(MMRESULT, waveOutGetPitch,
338 HWAVEOUT, hwo,
339 LPDWORD, pdwPitch)
340{
341 DartWaveOut *dwave = (DartWaveOut *)hwo;
342 if(DartWaveOut::find(dwave) == TRUE)
343 return MMSYSERR_NOTSUPPORTED;
344 else
345 return(MMSYSERR_INVALHANDLE);
346}
347
348ODINFUNCTION2(MMRESULT, waveOutSetPitch,
349 HWAVEOUT, hwo,
350 DWORD, dwPitch)
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, waveOutGetVolume,
360 HWAVEOUT, hwo,
361 LPDWORD, pdwVolume)
362{
363 DartWaveOut *dwave = (DartWaveOut *)hwo;
364 if(DartWaveOut::find(dwave) == TRUE)
365 {
366 return MMSYSERR_NOTSUPPORTED;
367 }
368 else
369 return(MMSYSERR_INVALHANDLE);
370}
371
372ODINFUNCTION2(MMRESULT, waveOutSetVolume,
373 HWAVEOUT, hwo,
374 DWORD, dwVolume)
375{
376 DartWaveOut *dwave = (DartWaveOut *)hwo;
377 if(DartWaveOut::find(dwave) == TRUE)
378 {
379 return MMSYSERR_NOTSUPPORTED;
380 }
381 else
382 return(MMSYSERR_INVALHANDLE);
383}
384
385ODINFUNCTION2(MMRESULT, waveOutGetPlaybackRate,
386 HWAVEOUT, hwo,
387 LPDWORD, pdwRate)
388{
389 DartWaveOut *dwave = (DartWaveOut *)hwo;
390 if(DartWaveOut::find(dwave) == TRUE)
391 {
392 return MMSYSERR_NOTSUPPORTED;
393 }
394 else
395 return(MMSYSERR_INVALHANDLE);
396}
397
398ODINFUNCTION2(MMRESULT, waveOutSetPlaybackRate,
399 HWAVEOUT, hwo,
400 DWORD, dwRate)
401{
402 DartWaveOut *dwave = (DartWaveOut *)hwo;
403 if(DartWaveOut::find(dwave) == TRUE)
404 {
405 return MMSYSERR_NOTSUPPORTED;
406 }
407 else
408 return(MMSYSERR_INVALHANDLE);
409}
410
411ODINFUNCTION4(MMRESULT, waveOutMessage,
412 HWAVEOUT, hwo,
413 UINT, uMsg,
414 DWORD, dw1,
415 DWORD, dw2)
416{
417 DartWaveOut *dwave = (DartWaveOut *)hwo;
418 if(DartWaveOut::find(dwave) == TRUE)
419 {
420 return MMSYSERR_NOTSUPPORTED;
421 }
422 else
423 return(MMSYSERR_INVALHANDLE);
424}
425
426
Note: See TracBrowser for help on using the repository browser.