xref: /reactos/dll/win32/mmdrv/mmdrv.h (revision 8a978a17)
1 /*
2  *
3  * COPYRIGHT:            See COPYING in the top level directory
4  * PROJECT:              ReactOS Multimedia
5  * FILE:                 dll/win32/mmdrv/mmdrv.h
6  * PURPOSE:              Multimedia User Mode Driver (header)
7  * PROGRAMMER:           Andrew Greenwood
8  *                       Aleksey Bragin
9  * UPDATE HISTORY:
10  *                       Jan 30, 2004: Imported into ReactOS tree
11  *                       Jan 10, 2007: Rewritten and tidied up
12  */
13 
14 #ifndef MMDRV_H
15 #define MMDRV_H
16 
17 #include <stdarg.h>
18 
19 #define WIN32_NO_STATUS
20 #include <windef.h>
21 #include <winbase.h>
22 #include <winioctl.h>
23 
24 #include "mmioctl.h"
25 #include "mmddk.h"
26 
27 /* Need to check these */
28 #define MAX_DEVICES             256
29 #define MAX_DEVICE_NAME_LENGTH  256
30 #define MAX_BUFFER_SIZE         1048576
31 #define MAX_WAVE_BYTES          1048576
32 
33 /* Custom flag set when overlapped I/O is done */
34 #define WHDR_COMPLETE 0x80000000
35 
36 
37 /*
38     The kinds of devices which MMSYSTEM/WINMM may request from us.
39 */
40 
41 typedef enum
42 {
43     WaveOutDevice,
44     WaveInDevice,
45     MidiOutDevice,
46     MidiInDevice,
47     AuxDevice
48 } DeviceType;
49 
50 #define IsWaveDevice(devicetype) \
51     ( ( devicetype == WaveOutDevice ) || ( devicetype == WaveInDevice ) )
52 
53 #define IsMidiDevice(devicetype) \
54     ( ( devicetype == MidiOutDevice ) || ( devicetype == MidiInDevice ) )
55 
56 #define IsAuxDevice(devicetype) \
57     ( devicetype == AuxDevice )
58 
59 
60 /*
61     We use these structures to store information regarding open devices. Since
62     the main structure gets destroyed when a device is closed, I call this a
63     "session".
64 */
65 
66 typedef struct
67 {
68     OVERLAPPED overlap;
69     LPWAVEHDR header;
70 } WaveOverlapInfo;
71 
72 /*
73 typedef enum
74 {
75     WaveAddBuffer,
76     WaveClose,
77     WaveReset,
78     WaveRestart,
79     SessionThreadTerminate,
80     InvalidFunction
81 } ThreadFunction;
82 */
83 
84 /* Our own values, used with the session threads */
85 typedef DWORD ThreadFunction;
86 #define DRVM_TERMINATE   0xFFFFFFFE
87 #define DRVM_INVALID     0xFFFFFFFF
88 
89 typedef enum
90 {
91     WavePlaying,
92     WaveStopped,
93     WaveReset,
94     WaveRestart
95 } WaveState;
96 
97 typedef union
98 {
99     PWAVEHDR wave_header;
100     PMIDIHDR midi_header;
101 } MediaHeader;
102 
103 /*
104 typedef union
105 {
106     MediaHeader header;
107 } ThreadParameter;
108 */
109 
110 typedef struct _ThreadInfo
111 {
112     HANDLE handle;
113     HANDLE ready_event;
114     HANDLE go_event;
115 
116     /*ThreadFunction function;*/
117     DWORD function;
118     PVOID parameter;
119 
120     MMRESULT result;
121 } ThreadInfo;
122 
123 typedef struct _LoopInfo
124 {
125     PWAVEHDR head;
126     DWORD iterations;
127 } LoopInfo;
128 
129 typedef struct _SessionInfo
130 {
131     struct _SessionInfo* next;
132 
133     DeviceType device_type;
134     UINT device_id;
135 
136     HANDLE kernel_device_handle;
137 
138     /* These are all the same */
139     union
140     {
141         HDRVR mme_handle;
142         HWAVE mme_wave_handle;
143         HMIDI mme_midi_handle;
144     };
145 
146     /* If playback is paused or not */
147     BOOL is_paused;
148 
149     /* Stuff passed to us from winmm */
150     DWORD_PTR app_user_data;
151     DWORD_PTR callback;
152 
153     DWORD flags;
154 
155     /* Can only be one or the other */
156     union
157     {
158         PWAVEHDR wave_queue;
159         PMIDIHDR midi_queue;
160     };
161 
162     /* Current playback point */
163     //PWAVEHDR next_buffer;
164 
165     /* Where in the current buffer we are */
166     DWORD buffer_position;
167 
168 //    DWORD remaining_bytes;
169 
170     LoopInfo loop;
171 
172     ThreadInfo thread;
173 } SessionInfo;
174 
175 #undef ASSERT
176 #define ASSERT(condition) \
177     if ( ! (condition) ) \
178         DPRINT("ASSERT FAILED: %s\n", #condition);
179 
180 /*
181     MME interface
182 */
183 
184 BOOL
185 NotifyClient(
186     SessionInfo* session_info,
187     DWORD message,
188     DWORD_PTR parameter1,
189     DWORD_PTR parameter2);
190 
191 
192 /*
193     Helpers
194 */
195 
196 MMRESULT
197 ErrorToMmResult(UINT error_code);
198 
199 
200 /* Kernel interface */
201 
202 MMRESULT
203 CobbleDeviceName(
204     DeviceType device_type,
205     UINT device_id,
206     PWCHAR out_device_name);
207 
208 MMRESULT
209 OpenKernelDevice(
210     DeviceType device_type,
211     UINT device_id,
212     DWORD access,
213     HANDLE* handle);
214 
215 VOID
216 CloseKernelDevice(HANDLE device_handle);
217 
218 MMRESULT
219 SetDeviceData(
220     HANDLE device_handle,
221     DWORD ioctl,
222     PBYTE input_buffer,
223     DWORD buffer_size);
224 
225 MMRESULT
226 GetDeviceData(
227     HANDLE device_handle,
228     DWORD ioctl,
229     PBYTE output_buffer,
230     DWORD buffer_size);
231 
232 
233 /* Session management */
234 
235 MMRESULT
236 CreateSession(
237     DeviceType device_type,
238     UINT device_id,
239     SessionInfo** session_info);
240 
241 VOID
242 DestroySession(SessionInfo* session);
243 
244 SessionInfo*
245 GetSession(
246     DeviceType device_type,
247     UINT device_id);
248 
249 MMRESULT
250 StartSessionThread(SessionInfo* session_info);
251 
252 MMRESULT
253 CallSessionThread(
254     SessionInfo* session_info,
255     ThreadFunction function,
256     PVOID thread_parameter);
257 
258 DWORD
259 HandleBySessionThread(
260     DWORD_PTR private_handle,
261     DWORD_PTR message,
262     DWORD_PTR parameter);
263 
264 
265 /* General */
266 
267 DWORD
268 GetDeviceCount(DeviceType device_type);
269 
270 DWORD
271 GetDeviceCapabilities(
272     DeviceType device_type,
273     UINT device_id,
274     DWORD_PTR capabilities,
275     DWORD capabilities_size);
276 
277 DWORD
278 OpenDevice(
279     DeviceType device_type,
280     UINT device_id,
281     PVOID open_descriptor,
282     DWORD flags,
283     DWORD_PTR private_handle);
284 
285 DWORD
286 CloseDevice(
287     DWORD_PTR private_handle);
288 
289 DWORD
290 PauseDevice(
291     DWORD private_handle);
292 
293 DWORD
294 RestartDevice(
295     DWORD private_handle);
296 
297 DWORD
298 ResetDevice(
299     DWORD private_handle);
300 
301 DWORD
302 GetPosition(
303     DWORD private_handle,
304     PMMTIME time,
305     DWORD time_size);
306 
307 DWORD
308 BreakLoop(DWORD private_handle);
309 
310 DWORD
311 QueryWaveFormat(
312     DeviceType device_type,
313     PVOID lpFormat);
314 
315 DWORD
316 WriteWaveBuffer(
317     DWORD_PTR private_handle,
318     PWAVEHDR wave_header,
319     DWORD wave_header_size);
320 
321 
322 
323 
324 
325 /* wave thread */
326 
327 DWORD
328 WaveThread(LPVOID parameter);
329 
330 
331 /* Wave I/O */
332 
333 VOID
334 PerformWaveIO(SessionInfo* session_info);
335 
336 
337 extern CRITICAL_SECTION critical_section;
338 
339 #endif /* MMDRV_H */
340