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

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

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