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