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

Last change on this file since 4 was 4, checked in by ktk, 26 years ago

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