[CMAKE]
[reactos.git] / lib / drivers / sound / mmebuddy / mmewrap.c
1 /*
2 * PROJECT: ReactOS Sound System "MME Buddy" Library
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: lib/drivers/sound/mmebuddy/mmewrap.c
5 *
6 * PURPOSE: Interface between MME functions and MME Buddy's own.
7 *
8 * PROGRAMMERS: Andrew Greenwood (silverblade@reactos.org)
9 */
10
11 #include <windows.h>
12 #include <mmsystem.h>
13 #include <mmddk.h>
14 #include <ntddsnd.h>
15 #include <sndtypes.h>
16 #include <mmebuddy.h>
17
18
19 /*
20 Sets the device into running or stopped state
21 */
22
23 MMRESULT
24 MmeSetState(
25 IN DWORD_PTR PrivateHandle,
26 IN BOOL bStart)
27 {
28 MMRESULT Result;
29 PMMFUNCTION_TABLE FunctionTable;
30 PSOUND_DEVICE SoundDevice;
31 PSOUND_DEVICE_INSTANCE SoundDeviceInstance;
32
33 VALIDATE_MMSYS_PARAMETER( PrivateHandle );
34 SoundDeviceInstance = (PSOUND_DEVICE_INSTANCE) PrivateHandle;
35
36 VALIDATE_MMSYS_PARAMETER( IsValidSoundDeviceInstance(SoundDeviceInstance) );
37
38 Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
39 if ( ! MMSUCCESS(Result) )
40 return TranslateInternalMmResult(Result);
41
42 /* Get the function table, and validate it */
43 Result = GetSoundDeviceFunctionTable(SoundDevice, &FunctionTable);
44 if ( ! MMSUCCESS(Result) )
45 return TranslateInternalMmResult(Result);
46
47 SND_ASSERT( FunctionTable->SetState );
48 if ( FunctionTable->SetState == NULL )
49 {
50 /* FIXME */
51 return MMSYSERR_NOTSUPPORTED;
52 }
53 /* Try change state */
54 Result = FunctionTable->SetState(SoundDeviceInstance, bStart);
55
56 return Result;
57 }
58
59 /*
60 Call the client application when something interesting happens (MME API
61 defines "interesting things" as device open, close, and buffer
62 completion.)
63 */
64 VOID
65 NotifyMmeClient(
66 IN PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
67 IN UINT Message,
68 IN DWORD_PTR Parameter)
69 {
70 SND_ASSERT( SoundDeviceInstance );
71
72 SND_TRACE(L"MME client callback - message %d, parameter %d\n",
73 (int) Message,
74 (int) Parameter);
75
76 if ( SoundDeviceInstance->WinMM.ClientCallback )
77 {
78 DriverCallback(SoundDeviceInstance->WinMM.ClientCallback,
79 HIWORD(SoundDeviceInstance->WinMM.Flags),
80 SoundDeviceInstance->WinMM.Handle,
81 Message,
82 SoundDeviceInstance->WinMM.ClientCallbackInstanceData,
83 Parameter,
84 0);
85 }
86 }
87
88 /*
89 This is a helper function to alleviate some of the repetition involved with
90 implementing the various MME message functions.
91 */
92 MMRESULT
93 MmeGetSoundDeviceCapabilities(
94 IN MMDEVICE_TYPE DeviceType,
95 IN DWORD DeviceId,
96 IN PVOID Capabilities,
97 IN DWORD CapabilitiesSize)
98 {
99 PSOUND_DEVICE SoundDevice;
100 MMRESULT Result;
101
102 SND_TRACE(L"MME *_GETCAPS for device %d of type %d\n", DeviceId, DeviceType);
103
104 /* FIXME: Validate device ID */
105 VALIDATE_MMSYS_PARAMETER( Capabilities );
106 VALIDATE_MMSYS_PARAMETER( IS_VALID_SOUND_DEVICE_TYPE(DeviceType) );
107
108 /* Our parameter checks are done elsewhere */
109
110 Result = GetSoundDevice(DeviceType, DeviceId, &SoundDevice);
111
112 if ( ! MMSUCCESS(Result) )
113 return Result;
114
115 return GetSoundDeviceCapabilities(SoundDevice,
116 DeviceId,
117 Capabilities,
118 CapabilitiesSize);
119 }
120
121 MMRESULT
122 MmeOpenDevice(
123 IN MMDEVICE_TYPE DeviceType,
124 IN UINT DeviceId,
125 IN LPWAVEOPENDESC OpenParameters,
126 IN DWORD Flags,
127 OUT DWORD_PTR* PrivateHandle)
128 {
129 MMRESULT Result;
130 UINT Message;
131 PSOUND_DEVICE SoundDevice;
132 PSOUND_DEVICE_INSTANCE SoundDeviceInstance;
133 LPWAVEFORMATEX Format;
134
135 SND_TRACE(L"Opening device");
136
137 VALIDATE_MMSYS_PARAMETER( IS_WAVE_DEVICE_TYPE(DeviceType) ); /* FIXME? wave in too? */
138 VALIDATE_MMSYS_PARAMETER( OpenParameters );
139
140 Result = GetSoundDevice(DeviceType, DeviceId, &SoundDevice);
141 if ( ! MMSUCCESS(Result) )
142 return TranslateInternalMmResult(Result);
143
144 if (DeviceType == WAVE_IN_DEVICE_TYPE || DeviceType == WAVE_OUT_DEVICE_TYPE)
145 {
146 Format = OpenParameters->lpFormat;
147
148 /* Does this device support the format? */
149 Result = QueryWaveDeviceFormatSupport(SoundDevice, Format, sizeof(WAVEFORMATEX));
150 if ( ! MMSUCCESS(Result) )
151 {
152 SND_ERR(L"Format not supported\n");
153 return TranslateInternalMmResult(Result);
154 }
155
156 /* If the caller just wanted to know if a format is supported, end here */
157 if ( Flags & WAVE_FORMAT_QUERY )
158 return MMSYSERR_NOERROR;
159 }
160
161 /* Check that winmm gave us a private handle to fill */
162 VALIDATE_MMSYS_PARAMETER( PrivateHandle );
163
164 /* Create a sound device instance and open the sound device */
165 Result = CreateSoundDeviceInstance(SoundDevice, &SoundDeviceInstance);
166 if ( ! MMSUCCESS(Result) )
167 return TranslateInternalMmResult(Result);
168
169 Result = SetWaveDeviceFormat(SoundDeviceInstance, DeviceId, Format, sizeof(WAVEFORMATEX));
170 if ( ! MMSUCCESS(Result) )
171 {
172 /* TODO: Destroy sound instance */
173 return TranslateInternalMmResult(Result);
174 }
175
176 /* Store the device instance pointer in the private handle */
177 *PrivateHandle = (DWORD_PTR)SoundDeviceInstance;
178
179 /* Store the additional information we were given - FIXME: Need flags! */
180 SetSoundDeviceInstanceMmeData(SoundDeviceInstance,
181 (HDRVR)OpenParameters->hWave, /* works because LPMIXEROPENDESC/etc has also the handle as first member */
182 OpenParameters->dwCallback,
183 OpenParameters->dwInstance,
184 Flags);
185
186 if (DeviceType == WAVE_OUT_DEVICE_TYPE || DeviceType == WAVE_IN_DEVICE_TYPE ||
187 DeviceType == MIDI_OUT_DEVICE_TYPE || DeviceType == MIDI_IN_DEVICE_TYPE)
188 {
189 /* Let the application know the device is open */
190
191 if (DeviceType == WAVE_OUT_DEVICE_TYPE)
192 Message = WOM_OPEN;
193 else if (DeviceType == WAVE_IN_DEVICE_TYPE)
194 Message = WIM_OPEN;
195 else if (DeviceType == MIDI_IN_DEVICE_TYPE)
196 Message = MIM_OPEN;
197 else
198 Message = MOM_OPEN;
199
200 ReleaseEntrypointMutex(DeviceType);
201
202 NotifyMmeClient(SoundDeviceInstance,
203 Message,
204 0);
205
206 AcquireEntrypointMutex(DeviceType);
207 }
208
209 SND_TRACE(L"device now open\n");
210
211 return MMSYSERR_NOERROR;
212 }
213
214 MMRESULT
215 MmeCloseDevice(
216 IN DWORD_PTR PrivateHandle)
217 {
218 MMRESULT Result;
219 PSOUND_DEVICE_INSTANCE SoundDeviceInstance;
220 PSOUND_DEVICE SoundDevice;
221 MMDEVICE_TYPE DeviceType;
222 UINT Message = 0;
223
224 SND_TRACE(L"Closing wave device (WIDM_CLOSE / WODM_CLOSE)\n");
225
226 VALIDATE_MMSYS_PARAMETER( PrivateHandle );
227 SoundDeviceInstance = (PSOUND_DEVICE_INSTANCE) PrivateHandle;
228
229 if ( ! IsValidSoundDeviceInstance(SoundDeviceInstance) )
230 return MMSYSERR_INVALHANDLE;
231
232 Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
233 if ( ! MMSUCCESS(Result) )
234 return TranslateInternalMmResult(Result);
235
236 Result = GetSoundDeviceType(SoundDevice, &DeviceType);
237 if ( ! MMSUCCESS(Result) )
238 return TranslateInternalMmResult(Result);
239
240
241 /* TODO: Check device is stopped! */
242
243
244 if (DeviceType != MIXER_DEVICE_TYPE)
245 {
246 ReleaseEntrypointMutex(DeviceType);
247
248 if (DeviceType == WAVE_OUT_DEVICE_TYPE)
249 Message = WOM_CLOSE;
250 else if (DeviceType == WAVE_IN_DEVICE_TYPE)
251 Message = WIM_CLOSE;
252 else if (DeviceType == MIDI_IN_DEVICE_TYPE)
253 Message = MIM_CLOSE;
254 else if (DeviceType == MIDI_OUT_DEVICE_TYPE)
255 Message = MOM_CLOSE;
256
257 /* TODO: Work with MIDI devices too */
258 NotifyMmeClient(SoundDeviceInstance,
259 Message,
260 0);
261 AcquireEntrypointMutex(DeviceType);
262 }
263
264 Result = DestroySoundDeviceInstance(SoundDeviceInstance);
265
266 return Result;
267 }
268
269 MMRESULT
270 MmeResetWavePlayback(
271 IN DWORD_PTR PrivateHandle)
272 {
273 PSOUND_DEVICE_INSTANCE SoundDeviceInstance;
274
275 SND_TRACE(L"Resetting wave device (WODM_RESET)\n");
276
277 VALIDATE_MMSYS_PARAMETER( PrivateHandle );
278 SoundDeviceInstance = (PSOUND_DEVICE_INSTANCE) PrivateHandle;
279
280 return StopStreaming(SoundDeviceInstance);
281 }
282
283 MMRESULT
284 MmeGetDeviceInterfaceString(
285 IN MMDEVICE_TYPE DeviceType,
286 IN DWORD DeviceId,
287 IN LPWSTR Interface,
288 IN DWORD InterfaceLength,
289 OUT DWORD * InterfaceSize)
290 {
291 MMRESULT Result;
292 PSOUND_DEVICE SoundDevice;
293 PMMFUNCTION_TABLE FunctionTable;
294
295 Result = GetSoundDevice(DeviceType, DeviceId, &SoundDevice);
296 if ( ! MMSUCCESS(Result) )
297 return TranslateInternalMmResult(Result);
298
299 Result = GetSoundDeviceFunctionTable(SoundDevice, &FunctionTable);
300 if ( ! MMSUCCESS(Result) )
301 return TranslateInternalMmResult(Result);
302
303 if ( FunctionTable->GetDeviceInterfaceString == NULL )
304 {
305 /* querying device interface string / size not supported */
306 return MMSYSERR_NOTSUPPORTED;
307 }
308
309 /* Call the driver */
310 Result = FunctionTable->GetDeviceInterfaceString(DeviceType, DeviceId, Interface, InterfaceLength, InterfaceSize);
311
312 return Result;
313 }
314
315
316 MMRESULT
317 MmeGetPosition(
318 IN MMDEVICE_TYPE DeviceType,
319 IN DWORD DeviceId,
320 IN DWORD_PTR PrivateHandle,
321 IN MMTIME* Time,
322 IN DWORD Size)
323 {
324 MMRESULT Result;
325 PSOUND_DEVICE_INSTANCE SoundDeviceInstance;
326 PSOUND_DEVICE SoundDevice;
327 PMMFUNCTION_TABLE FunctionTable;
328
329 VALIDATE_MMSYS_PARAMETER( PrivateHandle );
330 SoundDeviceInstance = (PSOUND_DEVICE_INSTANCE) PrivateHandle;
331
332 if ( ! IsValidSoundDeviceInstance(SoundDeviceInstance) )
333 return MMSYSERR_INVALHANDLE;
334
335 Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
336 if ( ! MMSUCCESS(Result) )
337 return TranslateInternalMmResult(Result);
338
339 if ( Size != sizeof(MMTIME) )
340 return MMSYSERR_INVALPARAM;
341
342 Result = GetSoundDeviceFunctionTable(SoundDevice, &FunctionTable);
343 if ( ! MMSUCCESS(Result) )
344 return TranslateInternalMmResult(Result);
345
346 if ( FunctionTable->GetPos == NULL )
347 {
348 /* This indicates bad practice, really! If you can open, why not close?! */
349 return MMSYSERR_NOTSUPPORTED;
350 }
351
352 /* Call the driver */
353 Result = FunctionTable->GetPos(SoundDeviceInstance, Time);
354
355 return Result;
356 }
357