1 +/***********************************************************************\ 2 +* mmsystem.d * 3 +* * 4 +* Windows API header module * 5 +* * 6 +* Translated from MinGW Windows headers * 7 +* * 8 +* Placed into public domain * 9 +\***********************************************************************/ 1 10 module win32.mmsystem; 11 +pragma(lib, "winmm.lib"); 2 12 3 -// Translated from Microsoft Platform SDK August 2001 Edition 4 -// by Y.Tomino (demoonlit@inter7.jp) 13 +/* The #defines MAKEFOURCC, mmioFOURCC, sndAlias are used to define 14 + * compile-time constants, so they are implemented as templates. 15 + */ 5 16 6 -import win32.winbase; 17 +private import win32.w32api, win32.windef, win32.winver; 7 18 8 -// #ifndef _INC_MMSYSTEM 9 -// #define _INC_MMSYSTEM 10 - 11 -// #ifdef _WIN32 12 19 align(1): 13 -// #else 14 -// #ifndef RC_INVOKED 15 -// #... 16 -// #endif 17 -// #endif 18 - 19 -// #ifdef __cplusplus 20 -// extern "C" { /* Assume C declarations for C++ */ 21 -// #endif /* __cplusplus */ 22 - 23 -// #ifdef _WIN32 24 -// #ifndef _WINMM_ 25 -// #define WINMMAPI DECLSPEC_IMPORT 26 -// #else 27 -// #... 28 -// #endif 29 -// #define _loadds 30 -// #define _huge 31 -// #else 32 -// #... 33 -// #endif 34 - 35 -// #ifdef _MAC 36 -// #... 37 -// #endif //_MAC 38 - 39 -enum : uint { MAXPNAMELEN = 32 } 40 -enum : uint { MAXERRORLENGTH = 256 } 41 -enum : uint { MAX_JOYSTICKOEMVXDNAME = 260 } 42 - 43 -// #if (WINVER <= 0x0400) 44 -// #ifndef MM_MICROSOFT 45 -// #... 46 -// #endif 47 - 48 -// #ifndef MM_MIDI_MAPPER 49 -// #... 50 -// #... 51 -// #... 52 -// #... 53 -// #... 54 -// #... 55 -// #... 56 -// #... 57 -// #... 58 -// #... 59 -// #... 60 -// #endif 61 -// #endif 62 - 63 -// #ifdef _WIN32 64 -alias UINT MMVERSION; 65 -// #else 66 -// ... 67 -// #endif 20 + 21 +const MAXPNAMELEN = 32; 22 +const MAXERRORLENGTH = 256; 23 +const MAX_JOYSTICKOEMVXDNAME = 260; 24 + 25 +const TIME_MS = 1; 26 +const TIME_SAMPLES = 2; 27 +const TIME_BYTES = 4; 28 +const TIME_SMPTE = 8; 29 +const TIME_MIDI = 16; 30 +const TIME_TICKS = 32; 31 + 32 +template MAKEFOURCC(char c0, char c1, char c2, char c3) 33 +{ 34 + const DWORD MAKEFOURCC = c0 | (c1<<8) | (c2<<16) | (cast(DWORD)c3 <<24); 35 +} 36 + 37 +template mmioFOURCC(char c0, char c1, char c2, char c3) 38 +{ 39 + const DWORD mmioFOURCC = c0 | (c1<<8) | (c2<<16) | (cast(DWORD)c3 <<24); 40 +} 41 + 42 +enum { 43 + MM_JOY1MOVE = 0x3A0, 44 + MM_JOY2MOVE, 45 + MM_JOY1ZMOVE, 46 + MM_JOY2ZMOVE, // = 0x3A3 47 + MM_JOY1BUTTONDOWN = 0x3B5, 48 + MM_JOY2BUTTONDOWN, 49 + MM_JOY1BUTTONUP, 50 + MM_JOY2BUTTONUP, 51 + MM_MCINOTIFY, // = 0x3B9 52 + MM_WOM_OPEN = 0x3BB, 53 + MM_WOM_CLOSE, 54 + MM_WOM_DONE, 55 + MM_WIM_OPEN, 56 + MM_WIM_CLOSE, 57 + MM_WIM_DATA, 58 + MM_MIM_OPEN, 59 + MM_MIM_CLOSE, 60 + MM_MIM_DATA, 61 + MM_MIM_LONGDATA, 62 + MM_MIM_ERROR, 63 + MM_MIM_LONGERROR, 64 + MM_MOM_OPEN, 65 + MM_MOM_CLOSE, 66 + MM_MOM_DONE, // = 0x3C9 67 + MM_DRVM_OPEN = 0x3D0, 68 + MM_DRVM_CLOSE, 69 + MM_DRVM_DATA, 70 + MM_DRVM_ERROR, 71 + MM_STREAM_OPEN, 72 + MM_STREAM_CLOSE, 73 + MM_STREAM_DONE, 74 + MM_STREAM_ERROR, // = 0x3D7 75 + MM_MOM_POSITIONCB = 0x3CA, 76 + MM_MCISIGNAL, 77 + MM_MIM_MOREDATA, // = 0x3CC 78 + MM_MIXM_LINE_CHANGE = 0x3D0, 79 + MM_MIXM_CONTROL_CHANGE = 0x3D1 80 +} 81 + 82 +const MMSYSERR_BASE = 0; 83 +const WAVERR_BASE = 32; 84 +const MIDIERR_BASE = 64; 85 +const TIMERR_BASE = 96; 86 +const JOYERR_BASE = 160; 87 +const MCIERR_BASE = 256; 88 +const MIXERR_BASE = 1024; 89 +const MCI_STRING_OFFSET = 512; 90 +const MCI_VD_OFFSET = 1024; 91 +const MCI_CD_OFFSET = 1088; 92 +const MCI_WAVE_OFFSET = 1152; 93 +const MCI_SEQ_OFFSET = 1216; 94 + 95 +enum { 96 + MMSYSERR_NOERROR = 0, 97 + MMSYSERR_ERROR = MMSYSERR_BASE+1, 98 + MMSYSERR_BADDEVICEID, 99 + MMSYSERR_NOTENABLED, 100 + MMSYSERR_ALLOCATED, 101 + MMSYSERR_INVALHANDLE, 102 + MMSYSERR_NODRIVER, 103 + MMSYSERR_NOMEM, 104 + MMSYSERR_NOTSUPPORTED, 105 + MMSYSERR_BADERRNUM, 106 + MMSYSERR_INVALFLAG, 107 + MMSYSERR_INVALPARAM, 108 + MMSYSERR_HANDLEBUSY, 109 + MMSYSERR_INVALIDALIAS, 110 + MMSYSERR_BADDB, 111 + MMSYSERR_KEYNOTFOUND, 112 + MMSYSERR_READERROR, 113 + MMSYSERR_WRITEERROR, 114 + MMSYSERR_DELETEERROR, 115 + MMSYSERR_VALNOTFOUND, 116 + MMSYSERR_NODRIVERCB, // = MMSYSERR_BASE+20 117 + MMSYSERR_LASTERROR = MMSYSERR_NODRIVERCB 118 +} 119 + 120 +enum { 121 + DRV_LOAD = 1, 122 + DRV_ENABLE, 123 + DRV_OPEN, 124 + DRV_CLOSE, 125 + DRV_DISABLE, 126 + DRV_FREE, 127 + DRV_CONFIGURE, 128 + DRV_QUERYCONFIGURE, 129 + DRV_INSTALL, 130 + DRV_REMOVE, 131 + DRV_EXITSESSION, 132 + DRV_POWER 133 +} 134 + 135 +const DRV_RESERVED = 0x800; 136 +const DRV_USER = 0x4000; 137 + 138 +const DRVCNF_CANCEL = 0; 139 +const DRVCNF_OK = 1; 140 +const DRVCNF_RESTART = 2; 141 +const DRV_CANCEL = DRVCNF_CANCEL; 142 +const DRV_OK = DRVCNF_OK; 143 +const DRV_RESTART = DRVCNF_RESTART; 144 +const DRV_MCI_FIRST = DRV_RESERVED; 145 +const DRV_MCI_LAST = DRV_RESERVED + 0xFFF; 146 + 147 +const CALLBACK_TYPEMASK = 0x70000; 148 +const CALLBACK_NULL = 0; 149 +const CALLBACK_WINDOW = 0x10000; 150 +const CALLBACK_TASK = 0x20000; 151 +const CALLBACK_FUNCTION = 0x30000; 152 +const CALLBACK_THREAD = CALLBACK_TASK; 153 +const CALLBACK_EVENT = 0x50000; 154 + 155 +const SND_SYNC=0; 156 +const SND_ASYNC=1; 157 +const SND_NODEFAULT=2; 158 +const SND_MEMORY=4; 159 +const SND_LOOP=8; 160 +const SND_NOSTOP=16; 161 +const SND_NOWAIT=0x2000; 162 +const SND_ALIAS=0x10000; 163 +const SND_ALIAS_ID=0x110000; 164 +const SND_FILENAME=0x20000; 165 +const SND_RESOURCE=0x40004; 166 +const SND_PURGE=0x40; 167 +const SND_APPLICATION=0x80; 168 +const SND_ALIAS_START=0; 169 + 170 +template sndAlias(char c0, char c1) 171 +{ 172 + const DWORD sndAlias = SND_ALIAS_START + c0 | (c1<<8); 173 +} 174 + 175 +const SND_ALIAS_SYSTEMASTERISK = sndAlias!('S','*'); 176 +const SND_ALIAS_SYSTEMQUESTION = sndAlias!('S','?'); 177 +const SND_ALIAS_SYSTEMHAND = sndAlias!('S','H'); 178 +const SND_ALIAS_SYSTEMEXIT = sndAlias!('S','E'); 179 +const SND_ALIAS_SYSTEMSTART = sndAlias!('S','S'); 180 +const SND_ALIAS_SYSTEMWELCOME = sndAlias!('S','W'); 181 +const SND_ALIAS_SYSTEMEXCLAMATION = sndAlias!('S','!'); 182 +const SND_ALIAS_SYSTEMDEFAULT = sndAlias!('S','D'); 183 + 184 +enum { 185 + WAVERR_BADFORMAT = (WAVERR_BASE + 0), 186 + WAVERR_STILLPLAYING, 187 + WAVERR_UNPREPARED, 188 + WAVERR_SYNC, // = WAVERR_BASE + 3; 189 + WAVERR_LASTERROR = WAVERR_SYNC 190 +} 191 + 192 +const WOM_OPEN = MM_WOM_OPEN; 193 +const WOM_CLOSE = MM_WOM_CLOSE; 194 +const WOM_DONE = MM_WOM_DONE; 195 +const WIM_OPEN = MM_WIM_OPEN; 196 +const WIM_CLOSE = MM_WIM_CLOSE; 197 +const WIM_DATA = MM_WIM_DATA; 198 + 199 +const UINT WAVE_MAPPER= -1; // FIXME: This doesn't make sense! 200 +const WAVE_FORMAT_QUERY=1; 201 +const WAVE_ALLOWSYNC=2; 202 +const WAVE_MAPPED=4; 203 +const WAVE_FORMAT_DIRECT=8; 204 +const WAVE_FORMAT_DIRECT_QUERY=(WAVE_FORMAT_QUERY|WAVE_FORMAT_DIRECT); 205 +const WHDR_DONE=1; 206 +const WHDR_PREPARED=2; 207 +const WHDR_BEGINLOOP=4; 208 +const WHDR_ENDLOOP=8; 209 +const WHDR_INQUEUE=16; 210 + 211 +const WAVECAPS_PITCH=1; 212 +const WAVECAPS_PLAYBACKRATE=2; 213 +const WAVECAPS_VOLUME=4; 214 +const WAVECAPS_LRVOLUME=8; 215 +const WAVECAPS_SYNC=16; 216 +const WAVECAPS_SAMPLEACCURATE=32; 217 +const WAVECAPS_DIRECTSOUND=64; 218 + 219 +const WAVE_INVALIDFORMAT=0; 220 +const WAVE_FORMAT_1M08=1; 221 +const WAVE_FORMAT_1S08=2; 222 +const WAVE_FORMAT_1M16=4; 223 +const WAVE_FORMAT_1S16=8; 224 +const WAVE_FORMAT_2M08=16; 225 +const WAVE_FORMAT_2S08=32; 226 +const WAVE_FORMAT_2M16=64; 227 +const WAVE_FORMAT_2S16=128; 228 +const WAVE_FORMAT_4M08=256; 229 +const WAVE_FORMAT_4S08=512; 230 +const WAVE_FORMAT_4M16=1024; 231 +const WAVE_FORMAT_4S16=2048; 232 +const WAVE_FORMAT_PCM=1; 233 + 234 +enum { 235 + MIDIERR_UNPREPARED = MIDIERR_BASE, 236 + MIDIERR_STILLPLAYING, 237 + MIDIERR_NOMAP, 238 + MIDIERR_NOTREADY, 239 + MIDIERR_NODEVICE, 240 + MIDIERR_INVALIDSETUP, 241 + MIDIERR_BADOPENMODE, 242 + MIDIERR_DONT_CONTINUE, // = MIDIERR_BASE+7 243 + MIDIERR_LASTERROR = MIDIERR_DONT_CONTINUE 244 +} 245 + 246 +const MIDIPATCHSIZE=128; 247 + 248 +const MIM_OPEN=MM_MIM_OPEN; 249 +const MIM_CLOSE=MM_MIM_CLOSE; 250 +const MIM_DATA=MM_MIM_DATA; 251 +const MIM_LONGDATA=MM_MIM_LONGDATA; 252 +const MIM_ERROR=MM_MIM_ERROR; 253 +const MIM_LONGERROR=MM_MIM_LONGERROR; 254 +const MOM_OPEN=MM_MOM_OPEN; 255 +const MOM_CLOSE=MM_MOM_CLOSE; 256 +const MOM_DONE=MM_MOM_DONE; 257 +const MIM_MOREDATA=MM_MIM_MOREDATA; 258 +const MOM_POSITIONCB=MM_MOM_POSITIONCB; 259 + 260 +const UINT MIDIMAPPER= -1; // FIXME: uint is nonsense for this! 261 +const UINT MIDI_MAPPER= -1; // FIXME: uint is nonsense for this! 262 +const MIDI_IO_STATUS=32; 263 +const MIDI_CACHE_ALL=1; 264 +const MIDI_CACHE_BESTFIT=2; 265 +const MIDI_CACHE_QUERY=3; 266 +const MIDI_UNCACHE=4; 267 +const MOD_MIDIPORT=1; 268 +const MOD_SYNTH=2; 269 +const MOD_SQSYNTH=3; 270 +const MOD_FMSYNTH=4; 271 +const MOD_MAPPER=5; 272 +const MIDICAPS_VOLUME=1; 273 +const MIDICAPS_LRVOLUME=2; 274 +const MIDICAPS_CACHE=4; 275 +const MIDICAPS_STREAM=8; 276 +const MHDR_DONE=1; 277 +const MHDR_PREPARED=2; 278 +const MHDR_INQUEUE=4; 279 +const MHDR_ISSTRM=8; 280 +const MEVT_F_SHORT=0; 281 +const MEVT_F_LONG=0x80000000; 282 +const MEVT_F_CALLBACK=0x40000000; 283 + 284 +BYTE MEVT_EVENTTYPE(DWORD x) { return cast(BYTE)((x>>24) &0xFF); } 285 +DWORD MEVT_EVENTPARM(DWORD x) { return x & 0xFFFFFF; } 286 + 287 +const MEVT_SHORTMSG=0; 288 +const MEVT_TEMPO=1; 289 +const MEVT_NOP=2; 290 + 291 +const BYTE MEVT_LONGMSG = 0x80; 292 +const BYTE MEVT_COMMENT = 0x82; 293 +const BYTE MEVT_VERSION = 0x84; 294 + 295 +const MIDISTRM_ERROR = -2; 296 + 297 +const MIDIPROP_SET = 0x80000000; 298 +const MIDIPROP_GET = 0x40000000; 299 +const MIDIPROP_TIMEDIV = 1; 300 +const MIDIPROP_TEMPO = 2; 301 + 302 +const UINT AUX_MAPPER = -1; 303 + 304 +const AUXCAPS_CDAUDIO=1; 305 +const AUXCAPS_AUXIN=2; 306 +const AUXCAPS_VOLUME=1; 307 +const AUXCAPS_LRVOLUME=2; 308 +const MIXER_SHORT_NAME_CHARS=16; 309 +const MIXER_LONG_NAME_CHARS=64; 310 +const MIXERR_INVALLINE=MIXERR_BASE; 311 +const MIXERR_INVALCONTROL=(MIXERR_BASE+1); 312 +const MIXERR_INVALVALUE=(MIXERR_BASE+2); 313 +const MIXERR_LASTERROR=(MIXERR_BASE+2); 314 + 315 +const MIXER_OBJECTF_HANDLE=0x80000000; 316 +const MIXER_OBJECTF_MIXER=0; 317 +const MIXER_OBJECTF_HMIXER=(MIXER_OBJECTF_HANDLE|MIXER_OBJECTF_MIXER); 318 +const MIXER_OBJECTF_WAVEOUT=0x10000000; 319 +const MIXER_OBJECTF_HWAVEOUT=(MIXER_OBJECTF_HANDLE|MIXER_OBJECTF_WAVEOUT); 320 +const MIXER_OBJECTF_WAVEIN=0x20000000; 321 +const MIXER_OBJECTF_HWAVEIN=(MIXER_OBJECTF_HANDLE|MIXER_OBJECTF_WAVEIN); 322 +const MIXER_OBJECTF_MIDIOUT=0x30000000; 323 +const MIXER_OBJECTF_HMIDIOUT=(MIXER_OBJECTF_HANDLE|MIXER_OBJECTF_MIDIOUT); 324 +const MIXER_OBJECTF_MIDIIN=0x40000000; 325 +const MIXER_OBJECTF_HMIDIIN=(MIXER_OBJECTF_HANDLE|MIXER_OBJECTF_MIDIIN); 326 +const MIXER_OBJECTF_AUX=0x50000000; 327 + 328 +const MIXERLINE_LINEF_ACTIVE=1; 329 +const MIXERLINE_LINEF_DISCONNECTED=0x8000; 330 +const MIXERLINE_LINEF_SOURCE=0x80000000; 331 + 332 +const MIXERLINE_COMPONENTTYPE_DST_FIRST=0; 333 +const MIXERLINE_COMPONENTTYPE_DST_UNDEFINED=MIXERLINE_COMPONENTTYPE_DST_FIRST; 334 +const MIXERLINE_COMPONENTTYPE_DST_DIGITAL=(MIXERLINE_COMPONENTTYPE_DST_FIRST+1); 335 +const MIXERLINE_COMPONENTTYPE_DST_LINE=(MIXERLINE_COMPONENTTYPE_DST_FIRST+2); 336 +const MIXERLINE_COMPONENTTYPE_DST_MONITOR=(MIXERLINE_COMPONENTTYPE_DST_FIRST+3); 337 +const MIXERLINE_COMPONENTTYPE_DST_SPEAKERS=(MIXERLINE_COMPONENTTYPE_DST_FIRST+4); 338 +const MIXERLINE_COMPONENTTYPE_DST_HEADPHONES=(MIXERLINE_COMPONENTTYPE_DST_FIRST+5); 339 +const MIXERLINE_COMPONENTTYPE_DST_TELEPHONE=(MIXERLINE_COMPONENTTYPE_DST_FIRST+6); 340 +const MIXERLINE_COMPONENTTYPE_DST_WAVEIN=(MIXERLINE_COMPONENTTYPE_DST_FIRST+7); 341 +const MIXERLINE_COMPONENTTYPE_DST_VOICEIN=(MIXERLINE_COMPONENTTYPE_DST_FIRST+8); 342 +const MIXERLINE_COMPONENTTYPE_DST_LAST=(MIXERLINE_COMPONENTTYPE_DST_FIRST+8); 343 +const MIXERLINE_COMPONENTTYPE_SRC_FIRST=0x1000; 344 +const MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED=MIXERLINE_COMPONENTTYPE_SRC_FIRST; 345 +const MIXERLINE_COMPONENTTYPE_SRC_DIGITAL=(MIXERLINE_COMPONENTTYPE_SRC_FIRST+1); 346 +const MIXERLINE_COMPONENTTYPE_SRC_LINE=(MIXERLINE_COMPONENTTYPE_SRC_FIRST+2); 347 +const MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE=(MIXERLINE_COMPONENTTYPE_SRC_FIRST+3); 348 +const MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER=(MIXERLINE_COMPONENTTYPE_SRC_FIRST+4); 349 +const MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC=(MIXERLINE_COMPONENTTYPE_SRC_FIRST+5); 350 +const MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE=(MIXERLINE_COMPONENTTYPE_SRC_FIRST+6); 351 +const MIXERLINE_COMPONENTTYPE_SRC_PCSPEAKER=(MIXERLINE_COMPONENTTYPE_SRC_FIRST+7); 352 +const MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT=(MIXERLINE_COMPONENTTYPE_SRC_FIRST+8); 353 +const MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY=(MIXERLINE_COMPONENTTYPE_SRC_FIRST+9); 354 +const MIXERLINE_COMPONENTTYPE_SRC_ANALOG=(MIXERLINE_COMPONENTTYPE_SRC_FIRST+10); 355 +const MIXERLINE_COMPONENTTYPE_SRC_LAST=(MIXERLINE_COMPONENTTYPE_SRC_FIRST+10); 356 + 357 +enum { 358 + MIXERLINE_TARGETTYPE_UNDEFINED = 0, 359 + MIXERLINE_TARGETTYPE_WAVEOUT, 360 + MIXERLINE_TARGETTYPE_WAVEIN, 361 + MIXERLINE_TARGETTYPE_MIDIOUT, 362 + MIXERLINE_TARGETTYPE_MIDIIN, 363 + MIXERLINE_TARGETTYPE_AUX // =5 364 +} 365 + 366 +const MIXER_GETLINEINFOF_DESTINATION=0; 367 +const MIXER_GETLINEINFOF_SOURCE=1; 368 +const MIXER_GETLINEINFOF_LINEID=2; 369 +const MIXER_GETLINEINFOF_COMPONENTTYPE=3; 370 +const MIXER_GETLINEINFOF_TARGETTYPE=4; 371 +const MIXER_GETLINEINFOF_QUERYMASK=15; 372 + 373 +const MIXERCONTROL_CONTROLF_UNIFORM=1; 374 +const MIXERCONTROL_CONTROLF_MULTIPLE=2; 375 +const MIXERCONTROL_CONTROLF_DISABLED=0x80000000; 376 +const MIXERCONTROL_CT_CLASS_MASK=0xF0000000; 377 +const MIXERCONTROL_CT_CLASS_CUSTOM=0; 378 +const MIXERCONTROL_CT_CLASS_METER=0x10000000; 379 +const MIXERCONTROL_CT_CLASS_SWITCH=0x20000000; 380 +const MIXERCONTROL_CT_CLASS_NUMBER=0x30000000; 381 +const MIXERCONTROL_CT_CLASS_SLIDER=0x40000000; 382 +const MIXERCONTROL_CT_CLASS_FADER=0x50000000; 383 +const MIXERCONTROL_CT_CLASS_TIME=0x60000000; 384 +const MIXERCONTROL_CT_CLASS_LIST=0x70000000; 385 +const MIXERCONTROL_CT_SUBCLASS_MASK=0xF000000; 386 +const MIXERCONTROL_CT_SC_SWITCH_BOOLEAN=0; 387 +const MIXERCONTROL_CT_SC_SWITCH_BUTTON=0x1000000; 388 +const MIXERCONTROL_CT_SC_METER_POLLED=0; 389 +const MIXERCONTROL_CT_SC_TIME_MICROSECS=0; 390 +const MIXERCONTROL_CT_SC_TIME_MILLISECS=0x1000000; 391 +const MIXERCONTROL_CT_SC_LIST_SINGLE=0; 392 +const MIXERCONTROL_CT_SC_LIST_MULTIPLE=0x1000000; 393 +const MIXERCONTROL_CT_UNITS_MASK=0xFF0000; 394 +const MIXERCONTROL_CT_UNITS_CUSTOM=0; 395 +const MIXERCONTROL_CT_UNITS_BOOLEAN=0x10000; 396 +const MIXERCONTROL_CT_UNITS_SIGNED=0x20000; 397 +const MIXERCONTROL_CT_UNITS_UNSIGNED=0x30000; 398 +const MIXERCONTROL_CT_UNITS_DECIBELS=0x40000; 399 +const MIXERCONTROL_CT_UNITS_PERCENT=0x50000; 400 + 401 +const MIXERCONTROL_CONTROLTYPE_CUSTOM=(MIXERCONTROL_CT_CLASS_CUSTOM|MIXERCONTROL_CT_UNITS_CUSTOM); 402 +const MIXERCONTROL_CONTROLTYPE_BOOLEANMETER=(MIXERCONTROL_CT_CLASS_METER|MIXERCONTROL_CT_SC_METER_POLLED|MIXERCONTROL_CT_UNITS_BOOLEAN); 403 +const MIXERCONTROL_CONTROLTYPE_SIGNEDMETER=(MIXERCONTROL_CT_CLASS_METER|MIXERCONTROL_CT_SC_METER_POLLED|MIXERCONTROL_CT_UNITS_SIGNED); 404 +const MIXERCONTROL_CONTROLTYPE_PEAKMETER=(MIXERCONTROL_CONTROLTYPE_SIGNEDMETER+1); 405 +const MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER=(MIXERCONTROL_CT_CLASS_METER|MIXERCONTROL_CT_SC_METER_POLLED|MIXERCONTROL_CT_UNITS_UNSIGNED); 406 +const MIXERCONTROL_CONTROLTYPE_BOOLEAN=(MIXERCONTROL_CT_CLASS_SWITCH|MIXERCONTROL_CT_SC_SWITCH_BOOLEAN|MIXERCONTROL_CT_UNITS_BOOLEAN); 407 +const MIXERCONTROL_CONTROLTYPE_ONOFF=(MIXERCONTROL_CONTROLTYPE_BOOLEAN+1); 408 +const MIXERCONTROL_CONTROLTYPE_MUTE=(MIXERCONTROL_CONTROLTYPE_BOOLEAN+2); 409 +const MIXERCONTROL_CONTROLTYPE_MONO=(MIXERCONTROL_CONTROLTYPE_BOOLEAN+3); 410 +const MIXERCONTROL_CONTROLTYPE_LOUDNESS=(MIXERCONTROL_CONTROLTYPE_BOOLEAN+4); 411 +const MIXERCONTROL_CONTROLTYPE_STEREOENH=(MIXERCONTROL_CONTROLTYPE_BOOLEAN+5); 412 +const MIXERCONTROL_CONTROLTYPE_BUTTON=(MIXERCONTROL_CT_CLASS_SWITCH|MIXERCONTROL_CT_SC_SWITCH_BUTTON|MIXERCONTROL_CT_UNITS_BOOLEAN); 413 +const MIXERCONTROL_CONTROLTYPE_DECIBELS=(MIXERCONTROL_CT_CLASS_NUMBER|MIXERCONTROL_CT_UNITS_DECIBELS); 414 +const MIXERCONTROL_CONTROLTYPE_SIGNED=(MIXERCONTROL_CT_CLASS_NUMBER|MIXERCONTROL_CT_UNITS_SIGNED); 415 +const MIXERCONTROL_CONTROLTYPE_UNSIGNED=(MIXERCONTROL_CT_CLASS_NUMBER|MIXERCONTROL_CT_UNITS_UNSIGNED); 416 +const MIXERCONTROL_CONTROLTYPE_PERCENT=(MIXERCONTROL_CT_CLASS_NUMBER|MIXERCONTROL_CT_UNITS_PERCENT); 417 +const MIXERCONTROL_CONTROLTYPE_SLIDER=(MIXERCONTROL_CT_CLASS_SLIDER|MIXERCONTROL_CT_UNITS_SIGNED); 418 +const MIXERCONTROL_CONTROLTYPE_PAN=(MIXERCONTROL_CONTROLTYPE_SLIDER+1); 419 +const MIXERCONTROL_CONTROLTYPE_QSOUNDPAN=(MIXERCONTROL_CONTROLTYPE_SLIDER+2); 420 +const MIXERCONTROL_CONTROLTYPE_FADER=(MIXERCONTROL_CT_CLASS_FADER|MIXERCONTROL_CT_UNITS_UNSIGNED); 421 +const MIXERCONTROL_CONTROLTYPE_VOLUME=(MIXERCONTROL_CONTROLTYPE_FADER+1); 422 +const MIXERCONTROL_CONTROLTYPE_BASS=(MIXERCONTROL_CONTROLTYPE_FADER+2); 423 +const MIXERCONTROL_CONTROLTYPE_TREBLE=(MIXERCONTROL_CONTROLTYPE_FADER+3); 424 +const MIXERCONTROL_CONTROLTYPE_EQUALIZER=(MIXERCONTROL_CONTROLTYPE_FADER+4); 425 +const MIXERCONTROL_CONTROLTYPE_SINGLESELECT=(MIXERCONTROL_CT_CLASS_LIST|MIXERCONTROL_CT_SC_LIST_SINGLE|MIXERCONTROL_CT_UNITS_BOOLEAN); 426 +const MIXERCONTROL_CONTROLTYPE_MUX=(MIXERCONTROL_CONTROLTYPE_SINGLESELECT+1); 427 +const MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT=(MIXERCONTROL_CT_CLASS_LIST|MIXERCONTROL_CT_SC_LIST_MULTIPLE|MIXERCONTROL_CT_UNITS_BOOLEAN); 428 +const MIXERCONTROL_CONTROLTYPE_MIXER=(MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT+1); 429 +const MIXERCONTROL_CONTROLTYPE_MICROTIME=(MIXERCONTROL_CT_CLASS_TIME|MIXERCONTROL_CT_SC_TIME_MICROSECS|MIXERCONTROL_CT_UNITS_UNSIGNED); 430 +const MIXERCONTROL_CONTROLTYPE_MILLITIME=(MIXERCONTROL_CT_CLASS_TIME|MIXERCONTROL_CT_SC_TIME_MILLISECS|MIXERCONTROL_CT_UNITS_UNSIGNED); 431 + 432 +const MIXER_GETLINECONTROLSF_ALL=0; 433 +const MIXER_GETLINECONTROLSF_ONEBYID=1; 434 +const MIXER_GETLINECONTROLSF_ONEBYTYPE=2; 435 +const MIXER_GETLINECONTROLSF_QUERYMASK=15; 436 +const MIXER_GETCONTROLDETAILSF_VALUE=0; 437 +const MIXER_GETCONTROLDETAILSF_LISTTEXT=1; 438 +const MIXER_GETCONTROLDETAILSF_QUERYMASK=15; 439 +const MIXER_SETCONTROLDETAILSF_VALUE=0; 440 +const MIXER_SETCONTROLDETAILSF_CUSTOM=1; 441 +const MIXER_SETCONTROLDETAILSF_QUERYMASK=15; 442 + 443 +const TIMERR_NOERROR=0; 444 +const TIMERR_NOCANDO=(TIMERR_BASE+1); 445 +const TIMERR_STRUCT=(TIMERR_BASE+33); 446 +const TIME_ONESHOT=0; 447 +const TIME_PERIODIC=1; 448 +const TIME_CALLBACK_FUNCTION=0; 449 +const TIME_CALLBACK_EVENT_SET=16; 450 +const TIME_CALLBACK_EVENT_PULSE=32; 451 + 452 +static if (WINVER >= 0x0501) { 453 + 454 +const TIME_KILL_SYNCHRONOUS=0x0100; 455 + 456 +} 457 + 458 +const JOYERR_NOERROR = 0; 459 +const JOYERR_PARMS=(JOYERR_BASE+5); 460 +const JOYERR_NOCANDO=(JOYERR_BASE+6); 461 +const JOYERR_UNPLUGGED=(JOYERR_BASE+7); 462 + 463 +const JOY_BUTTON1=1; 464 +const JOY_BUTTON2=2; 465 +const JOY_BUTTON3=4; 466 +const JOY_BUTTON4=8; 467 +const JOY_BUTTON1CHG=256; 468 +const JOY_BUTTON2CHG=512; 469 +const JOY_BUTTON3CHG=1024; 470 +const JOY_BUTTON4CHG=2048; 471 +const JOY_BUTTON5=257; 472 +const JOY_BUTTON6=513; 473 +const JOY_BUTTON7=1025; 474 +const JOY_BUTTON8=2049; 475 +const JOY_BUTTON9=256; 476 +const JOY_BUTTON10=512; 477 +const JOY_BUTTON11=1024; 478 +const JOY_BUTTON12=2048; 479 +const JOY_BUTTON13=4096; 480 +const JOY_BUTTON14=8192; 481 +const JOY_BUTTON15=16384; 482 +const JOY_BUTTON16=32768; 483 +const JOY_BUTTON17=65536; 484 +const JOY_BUTTON18=0x20000; 485 +const JOY_BUTTON19=0x40000; 486 +const JOY_BUTTON20=0x80000; 487 +const JOY_BUTTON21=0x100000; 488 +const JOY_BUTTON22=0x200000; 489 +const JOY_BUTTON23=0x400000; 490 +const JOY_BUTTON24=0x800000; 491 +const JOY_BUTTON25=0x1000000; 492 +const JOY_BUTTON26=0x2000000; 493 +const JOY_BUTTON27=0x4000000; 494 +const JOY_BUTTON28=0x8000000; 495 +const JOY_BUTTON29=0x10000000; 496 +const JOY_BUTTON30=0x20000000; 497 +const JOY_BUTTON31=0x40000000; 498 +const JOY_BUTTON32=0x80000000; 499 + 500 +enum : DWORD { 501 + JOY_POVCENTERED = -1, 502 + JOY_POVFORWARD = 0, 503 + JOY_POVBACKWARD = 18000, 504 + JOY_POVLEFT = 27000, 505 + JOY_POVRIGHT = 9000 506 +} 507 + 508 +const DWORD 509 + JOY_RETURNX = 0x00000001, 510 + JOY_RETURNY = 0x00000002, 511 + JOY_RETURNZ = 0x00000004, 512 + JOY_RETURNR = 0x00000008, 513 + JOY_RETURNU = 0x00000010, 514 + JOY_RETURNV = 0x00000020, 515 + JOY_RETURNPOV = 0x00000040, 516 + JOY_RETURNBUTTONS = 0x00000080, 517 + JOY_RETURNRAWDATA = 0x00000100, 518 + JOY_RETURNPOVCTS = 0x00000200, 519 + JOY_RETURNCENTERED = 0x00000400, 520 + JOY_USEDEADZONE = 0x00000800, 521 + JOY_RETURNALL = JOY_RETURNX | JOY_RETURNY | JOY_RETURNZ | JOY_RETURNR 522 + | JOY_RETURNU | JOY_RETURNV | JOY_RETURNPOV 523 + | JOY_RETURNBUTTONS, 524 + JOY_CAL_READALWAYS = 0x00010000, 525 + JOY_CAL_READXYONLY = 0x00020000, 526 + JOY_CAL_READ3 = 0x00040000, 527 + JOY_CAL_READ4 = 0x00080000, 528 + JOY_CAL_READXONLY = 0x00100000, 529 + JOY_CAL_READYONLY = 0x00200000, 530 + JOY_CAL_READ5 = 0x00400000, 531 + JOY_CAL_READ6 = 0x00800000, 532 + JOY_CAL_READZONLY = 0x01000000, 533 + JOY_CAL_READRONLY = 0x02000000, 534 + JOY_CAL_READUONLY = 0x04000000, 535 + JOY_CAL_READVONLY = 0x08000000; 536 + 537 +const JOYSTICKID1=0; 538 +const JOYSTICKID2=1; 539 + 540 +const JOYCAPS_HASZ=1; 541 +const JOYCAPS_HASR=2; 542 +const JOYCAPS_HASU=4; 543 +const JOYCAPS_HASV=8; 544 +const JOYCAPS_HASPOV=16; 545 +const JOYCAPS_POV4DIR=32; 546 +const JOYCAPS_POVCTS=64; 547 + 548 +const MMIOERR_BASE=256; 549 +const MMIOERR_FILENOTFOUND=(MMIOERR_BASE+1); 550 +const MMIOERR_OUTOFMEMORY=(MMIOERR_BASE+2); 551 +const MMIOERR_CANNOTOPEN=(MMIOERR_BASE+3); 552 +const MMIOERR_CANNOTCLOSE=(MMIOERR_BASE+4); 553 +const MMIOERR_CANNOTREAD=(MMIOERR_BASE+5); 554 +const MMIOERR_CANNOTWRITE=(MMIOERR_BASE+6); 555 +const MMIOERR_CANNOTSEEK=(MMIOERR_BASE+7); 556 +const MMIOERR_CANNOTEXPAND=(MMIOERR_BASE+8); 557 +const MMIOERR_CHUNKNOTFOUND=(MMIOERR_BASE+9); 558 +const MMIOERR_UNBUFFERED=(MMIOERR_BASE+10); 559 +const MMIOERR_PATHNOTFOUND=(MMIOERR_BASE+11); 560 +const MMIOERR_ACCESSDENIED=(MMIOERR_BASE+12); 561 +const MMIOERR_SHARINGVIOLATION=(MMIOERR_BASE+13); 562 +const MMIOERR_NETWORKERROR=(MMIOERR_BASE+14); 563 +const MMIOERR_TOOMANYOPENFILES=(MMIOERR_BASE+15); 564 +const MMIOERR_INVALIDFILE=(MMIOERR_BASE+16); 565 + 566 +const CFSEPCHAR='+'; 567 + 568 +const MMIO_RWMODE=3; 569 +const MMIO_SHAREMODE=0x70; 570 +const MMIO_CREATE=0x1000; 571 +const MMIO_PARSE=256; 572 +const MMIO_DELETE=512; 573 +const MMIO_EXIST=0x4000; 574 +const MMIO_ALLOCBUF=0x10000; 575 +const MMIO_GETTEMP=0x20000; 576 +const MMIO_DIRTY=0x10000000; 577 +const MMIO_READ=0; 578 +const MMIO_WRITE=1; 579 +const MMIO_READWRITE=2; 580 +const MMIO_COMPAT=0; 581 +const MMIO_EXCLUSIVE=16; 582 +const MMIO_DENYWRITE=32; 583 +const MMIO_DENYREAD=0x30; 584 +const MMIO_DENYNONE=64; 585 +const MMIO_FHOPEN=16; 586 +const MMIO_EMPTYBUF=16; 587 +const MMIO_TOUPPER=16; 588 +const MMIO_INSTALLPROC=0x10000; 589 +const MMIO_GLOBALPROC=0x10000000; 590 +const MMIO_REMOVEPROC=0x20000; 591 +const MMIO_UNICODEPROC=0x1000000; 592 +const MMIO_FINDPROC=0x40000; 593 +const MMIO_FINDCHUNK=16; 594 +const MMIO_FINDRIFF=32; 595 +const MMIO_FINDLIST=64; 596 +const MMIO_CREATERIFF=32; 597 +const MMIO_CREATELIST=64; 598 +const MMIOM_READ=MMIO_READ; 599 +const MMIOM_WRITE=MMIO_WRITE; 600 +const MMIOM_SEEK=2; 601 +const MMIOM_OPEN=3; 602 +const MMIOM_CLOSE=4; 603 +const MMIOM_WRITEFLUSH=5; 604 +const MMIOM_RENAME=6; 605 +const MMIOM_USER=0x8000; 606 + 607 +const FOURCC_RIFF = mmioFOURCC!('R', 'I', 'F', 'F'); 608 +const FOURCC_LIST = mmioFOURCC!('L', 'I', 'S', 'T'); 609 +const FOURCC_DOS = mmioFOURCC!('D', 'O', 'S', ' '); 610 +const FOURCC_MEM = mmioFOURCC!('M', 'E', 'M', ' '); 611 + 612 +const MMIO_DEFAULTBUFFER=8192; 613 + 614 +enum { 615 + MCIERR_INVALID_DEVICE_ID = MCIERR_BASE + 1, 616 + MCIERR_UNRECOGNIZED_KEYWORD = MCIERR_BASE + 3, 617 + MCIERR_UNRECOGNIZED_COMMAND = MCIERR_BASE + 5, 618 + MCIERR_HARDWARE, 619 + MCIERR_INVALID_DEVICE_NAME, 620 + MCIERR_OUT_OF_MEMORY, 621 + MCIERR_DEVICE_OPEN, 622 + MCIERR_CANNOT_LOAD_DRIVER, 623 + MCIERR_MISSING_COMMAND_STRING, 624 + MCIERR_PARAM_OVERFLOW, 625 + MCIERR_MISSING_STRING_ARGUMENT, 626 + MCIERR_BAD_INTEGER, 627 + MCIERR_PARSER_INTERNAL, 628 + MCIERR_DRIVER_INTERNAL, 629 + MCIERR_MISSING_PARAMETER, 630 + MCIERR_UNSUPPORTED_FUNCTION, 631 + MCIERR_FILE_NOT_FOUND, 632 + MCIERR_DEVICE_NOT_READY, 633 + MCIERR_INTERNAL, 634 + MCIERR_DRIVER, 635 + MCIERR_CANNOT_USE_ALL, 636 + MCIERR_MULTIPLE, 637 + MCIERR_EXTENSION_NOT_FOUND, 638 + MCIERR_OUTOFRANGE, // = MCIERR_BASE+26 639 + MCIERR_FLAGS_NOT_COMPATIBLE = MCIERR_BASE + 28, 640 + MCIERR_FILE_NOT_SAVED = MCIERR_BASE + 30, 641 + MCIERR_DEVICE_TYPE_REQUIRED, 642 + MCIERR_DEVICE_LOCKED, 643 + MCIERR_DUPLICATE_ALIAS, 644 + MCIERR_BAD_CONSTANT, 645 + MCIERR_MUST_USE_SHAREABLE, 646 + MCIERR_MISSING_DEVICE_NAME, 647 + MCIERR_BAD_TIME_FORMAT, 648 + MCIERR_NO_CLOSING_QUOTE, 649 + MCIERR_DUPLICATE_FLAGS, 650 + MCIERR_INVALID_FILE, 651 + MCIERR_NULL_PARAMETER_BLOCK, 652 + MCIERR_UNNAMED_RESOURCE, 653 + MCIERR_NEW_REQUIRES_ALIAS, 654 + MCIERR_NOTIFY_ON_AUTO_OPEN, 655 + MCIERR_NO_ELEMENT_ALLOWED, 656 + MCIERR_NONAPPLICABLE_FUNCTION, 657 + MCIERR_ILLEGAL_FOR_AUTO_OPEN, 658 + MCIERR_FILENAME_REQUIRED, 659 + MCIERR_EXTRA_CHARACTERS, 660 + MCIERR_DEVICE_NOT_INSTALLED, 661 + MCIERR_GET_CD, 662 + MCIERR_SET_CD, 663 + MCIERR_SET_DRIVE, 664 + MCIERR_DEVICE_LENGTH, 665 + MCIERR_DEVICE_ORD_LENGTH, 666 + MCIERR_NO_INTEGER, // = MCIERR_BASE + 56 667 + MCIERR_WAVE_OUTPUTSINUSE = MCIERR_BASE + 64, 668 + MCIERR_WAVE_SETOUTPUTINUSE, 669 + MCIERR_WAVE_INPUTSINUSE, 670 + MCIERR_WAVE_SETINPUTINUSE, 671 + MCIERR_WAVE_OUTPUTUNSPECIFIED, 672 + MCIERR_WAVE_INPUTUNSPECIFIED, 673 + MCIERR_WAVE_OUTPUTSUNSUITABLE, 674 + MCIERR_WAVE_SETOUTPUTUNSUITABLE, 675 + MCIERR_WAVE_INPUTSUNSUITABLE, 676 + MCIERR_WAVE_SETINPUTUNSUITABLE, // = MCIERR_BASE + 73 677 + MCIERR_SEQ_DIV_INCOMPATIBLE = MCIERR_BASE + 80, 678 + MCIERR_SEQ_PORT_INUSE, 679 + MCIERR_SEQ_PORT_NONEXISTENT, 680 + MCIERR_SEQ_PORT_MAPNODEVICE, 681 + MCIERR_SEQ_PORT_MISCERROR, 682 + MCIERR_SEQ_TIMER, 683 + MCIERR_SEQ_PORTUNSPECIFIED, 684 + MCIERR_SEQ_NOMIDIPRESENT, // = MCIERR_BASE + 87 685 + MCIERR_NO_WINDOW = MCIERR_BASE + 90, 686 + MCIERR_CREATEWINDOW, 687 + MCIERR_FILE_READ, 688 + MCIERR_FILE_WRITE, 689 + MCIERR_NO_IDENTITY // = MCIERR_BASE + 94 690 +} 691 +const MCIERR_CUSTOM_DRIVER_BASE = MCIERR_BASE + 256; 692 + 693 +const MCI_FIRST=DRV_MCI_FIRST; 694 +const MCI_OPEN=0x803; 695 +const MCI_CLOSE=0x804; 696 +const MCI_ESCAPE=0x805; 697 +const MCI_PLAY=0x806; 698 +const MCI_SEEK=0x807; 699 +const MCI_STOP=0x808; 700 +const MCI_PAUSE=0x809; 701 +const MCI_INFO=0x80A; 702 +const MCI_GETDEVCAPS=0x80B; 703 +const MCI_SPIN=0x80C; 704 +const MCI_SET=0x80D; 705 +const MCI_STEP=0x80E; 706 +const MCI_RECORD=0x80F; 707 +const MCI_SYSINFO=0x810; 708 +const MCI_BREAK=0x811; 709 +const MCI_SAVE=0x813; 710 +const MCI_STATUS=0x814; 711 +const MCI_CUE=0x830; 712 +const MCI_REALIZE=0x840; 713 +const MCI_WINDOW=0x841; 714 +const MCI_PUT=0x842; 715 +const MCI_WHERE=0x843; 716 +const MCI_FREEZE=0x844; 717 +const MCI_UNFREEZE=0x845; 718 +const MCI_LOAD=0x850; 719 +const MCI_CUT=0x851; 720 +const MCI_COPY=0x852; 721 +const MCI_PASTE=0x853; 722 +const MCI_UPDATE=0x854; 723 +const MCI_RESUME=0x855; 724 +const MCI_DELETE=0x856; 725 +const MCI_USER_MESSAGES=(DRV_MCI_FIRST+0x400); 726 +const MCI_LAST=0xFFF; 727 + 728 +const MCIDEVICEID MCI_ALL_DEVICE_ID = -1; 729 + 730 +const MCI_DEVTYPE_VCR=513; 731 +const MCI_DEVTYPE_VIDEODISC=514; 732 +const MCI_DEVTYPE_OVERLAY=515; 733 +const MCI_DEVTYPE_CD_AUDIO=516; 734 +const MCI_DEVTYPE_DAT=517; 735 +const MCI_DEVTYPE_SCANNER=518; 736 +const MCI_DEVTYPE_ANIMATION=519; 737 +const MCI_DEVTYPE_DIGITAL_VIDEO=520; 738 +const MCI_DEVTYPE_OTHER=521; 739 +const MCI_DEVTYPE_WAVEFORM_AUDIO=522; 740 +const MCI_DEVTYPE_SEQUENCER=523; 741 +const MCI_DEVTYPE_FIRST=MCI_DEVTYPE_VCR; 742 +const MCI_DEVTYPE_LAST=MCI_DEVTYPE_SEQUENCER; 743 +const MCI_DEVTYPE_FIRST_USER=0x1000; 744 +const MCI_MODE_NOT_READY=(MCI_STRING_OFFSET+12); 745 +const MCI_MODE_STOP=(MCI_STRING_OFFSET+13); 746 +const MCI_MODE_PLAY=(MCI_STRING_OFFSET+14); 747 +const MCI_MODE_RECORD=(MCI_STRING_OFFSET+15); 748 +const MCI_MODE_SEEK=(MCI_STRING_OFFSET+16); 749 +const MCI_MODE_PAUSE=(MCI_STRING_OFFSET+17); 750 +const MCI_MODE_OPEN=(MCI_STRING_OFFSET+18); 751 +const MCI_FORMAT_MILLISECONDS=0; 752 +const MCI_FORMAT_HMS=1; 753 +const MCI_FORMAT_MSF=2; 754 +const MCI_FORMAT_FRAMES=3; 755 +const MCI_FORMAT_SMPTE_24=4; 756 +const MCI_FORMAT_SMPTE_25=5; 757 +const MCI_FORMAT_SMPTE_30=6; 758 +const MCI_FORMAT_SMPTE_30DROP=7; 759 +const MCI_FORMAT_BYTES=8; 760 +const MCI_FORMAT_SAMPLES=9; 761 +const MCI_FORMAT_TMSF=10; 762 + 763 + 764 + 765 + 766 +// Macros 767 +BYTE MCI_HMS_HOUR(DWORD t) { return cast(BYTE)(t); } 768 +BYTE MCI_HMS_MINUTE(DWORD t) { return cast(BYTE)(t>>>8); } 769 +BYTE MCI_HMS_SECOND(DWORD t) { return cast(BYTE)( t>>>16); } 770 +DWORD MCI_MAKE_HMS(BYTE h, BYTE m, BYTE s) { return h |(m<<8)|(cast(DWORD)(s)<<16); } 771 +DWORD MCI_MAKE_MSF(BYTE m, BYTE s, BYTE f) { return m |(s<<8)|(cast(DWORD)(f)<<16); } 772 +DWORD MCI_MAKE_TMSF(BYTE t, BYTE m, BYTE s, BYTE f) { 773 + return t |(m<<8)|(s<<16)|(cast(DWORD)(f)<< 24); } 774 + 775 +BYTE MCI_MSF_MINUTE(DWORD t) { return cast(BYTE)(t); } 776 +BYTE MCI_MSF_SECOND(DWORD t) { return cast(BYTE)(t >>> 8); } 777 +BYTE MCI_MSF_FRAME(DWORD t) { return cast(BYTE)(t >>> 16); } 778 + 779 +BYTE MCI_TMSF_TRACK(DWORD t) { return cast(BYTE)(t); } 780 +BYTE MCI_TMSF_MINUTE(DWORD t) { return cast(BYTE)(t>>8); } 781 +BYTE MCI_TMSF_SECOND(DWORD t) { return cast(BYTE)(t>>16); } 782 +BYTE MCI_TMSF_FRAME(DWORD t) { return cast(BYTE)(t>>24); } 783 + 784 + 785 +const MCI_NOTIFY_SUCCESSFUL=1; 786 +const MCI_NOTIFY_SUPERSEDED=2; 787 +const MCI_NOTIFY_ABORTED=4; 788 +const MCI_NOTIFY_FAILURE=8; 789 +const MCI_NOTIFY=1; 790 +const MCI_WAIT=2; 791 +const MCI_FROM=4; 792 +const MCI_TO=8; 793 +const MCI_TRACK=16; 794 +const MCI_OPEN_SHAREABLE=256; 795 +const MCI_OPEN_ELEMENT=512; 796 +const MCI_OPEN_ALIAS=1024; 797 +const MCI_OPEN_ELEMENT_ID=2048; 798 +const MCI_OPEN_TYPE_ID=0x1000; 799 +const MCI_OPEN_TYPE=0x2000; 800 +const MCI_SEEK_TO_START=256; 801 +const MCI_SEEK_TO_END=512; 802 +const MCI_STATUS_ITEM=256; 803 +const MCI_STATUS_START=512; 804 +const MCI_STATUS_LENGTH=1; 805 +const MCI_STATUS_POSITION=2; 806 +const MCI_STATUS_NUMBER_OF_TRACKS=3; 807 +const MCI_STATUS_MODE=4; 808 +const MCI_STATUS_MEDIA_PRESENT=5; 809 +const MCI_STATUS_TIME_FORMAT=6; 810 +const MCI_STATUS_READY=7; 811 +const MCI_STATUS_CURRENT_TRACK=8; 812 +const MCI_INFO_PRODUCT=256; 813 +const MCI_INFO_FILE=512; 814 +const MCI_INFO_MEDIA_UPC=1024; 815 +const MCI_INFO_MEDIA_IDENTITY=2048; 816 +const MCI_INFO_NAME=0x1000; 817 +const MCI_INFO_COPYRIGHT=0x2000; 818 + 819 +const MCI_GETDEVCAPS_ITEM=256; 820 +const MCI_GETDEVCAPS_CAN_RECORD=1; 821 +const MCI_GETDEVCAPS_HAS_AUDIO=2; 822 +const MCI_GETDEVCAPS_HAS_VIDEO=3; 823 +const MCI_GETDEVCAPS_DEVICE_TYPE=4; 824 +const MCI_GETDEVCAPS_USES_FILES=5; 825 +const MCI_GETDEVCAPS_COMPOUND_DEVICE=6; 826 +const MCI_GETDEVCAPS_CAN_EJECT=7; 827 +const MCI_GETDEVCAPS_CAN_PLAY=8; 828 +const MCI_GETDEVCAPS_CAN_SAVE=9; 829 + 830 +const MCI_SYSINFO_QUANTITY=256; 831 +const MCI_SYSINFO_OPEN=512; 832 +const MCI_SYSINFO_NAME=1024; 833 +const MCI_SYSINFO_INSTALLNAME=2048; 834 +const MCI_SET_DOOR_OPEN=256; 835 +const MCI_SET_DOOR_CLOSED=512; 836 +const MCI_SET_TIME_FORMAT=1024; 837 +const MCI_SET_AUDIO=2048; 838 +const MCI_SET_VIDEO=0x1000; 839 +const MCI_SET_ON=0x2000; 840 +const MCI_SET_OFF=0x4000; 841 + 842 +const MCI_SET_AUDIO_ALL=0; 843 +const MCI_SET_AUDIO_LEFT=1; 844 +const MCI_SET_AUDIO_RIGHT=2; 845 + 846 +const MCI_BREAK_KEY=256; 847 +const MCI_BREAK_HWND=512; 848 +const MCI_BREAK_OFF=1024; 849 + 850 +const MCI_RECORD_INSERT=256; 851 +const MCI_RECORD_OVERWRITE=512; 852 +const MCI_SAVE_FILE=256; 853 +const MCI_LOAD_FILE=256; 854 + 855 +const MCI_VD_MODE_PARK=(MCI_VD_OFFSET+1); 856 +const MCI_VD_MEDIA_CLV=(MCI_VD_OFFSET+2); 857 +const MCI_VD_MEDIA_CAV=(MCI_VD_OFFSET+3); 858 +const MCI_VD_MEDIA_OTHER=(MCI_VD_OFFSET+4); 859 + 860 +const MCI_VD_FORMAT_TRACK=0x4001; 861 +const MCI_VD_PLAY_REVERSE=0x10000; 862 +const MCI_VD_PLAY_FAST=0x20000; 863 +const MCI_VD_PLAY_SPEED=0x40000; 864 +const MCI_VD_PLAY_SCAN=0x80000; 865 +const MCI_VD_PLAY_SLOW=0x100000; 866 +const MCI_VD_SEEK_REVERSE=0x10000; 867 +const MCI_VD_STATUS_SPEED=0x4002; 868 +const MCI_VD_STATUS_FORWARD=0x4003; 869 +const MCI_VD_STATUS_MEDIA_TYPE=0x4004; 870 +const MCI_VD_STATUS_SIDE=0x4005; 871 +const MCI_VD_STATUS_DISC_SIZE=0x4006; 872 +const MCI_VD_GETDEVCAPS_CLV=0x10000; 873 +const MCI_VD_GETDEVCAPS_CAV=0x20000; 874 +const MCI_VD_SPIN_UP=0x10000; 875 +const MCI_VD_SPIN_DOWN=0x20000; 876 +const MCI_VD_GETDEVCAPS_CAN_REVERSE=0x4002; 877 +const MCI_VD_GETDEVCAPS_FAST_RATE=0x4003; 878 +const MCI_VD_GETDEVCAPS_SLOW_RATE=0x4004; 879 +const MCI_VD_GETDEVCAPS_NORMAL_RATE=0x4005; 880 +const MCI_VD_STEP_FRAMES=0x10000; 881 +const MCI_VD_STEP_REVERSE=0x20000; 882 +const MCI_VD_ESCAPE_STRING=256; 883 + 884 +const MCI_CDA_STATUS_TYPE_TRACK=0x4001; 885 +const MCI_CDA_TRACK_AUDIO=MCI_CD_OFFSET; 886 +const MCI_CDA_TRACK_OTHER=(MCI_CD_OFFSET+1); 887 + 888 +const MCI_WAVE_PCM=MCI_WAVE_OFFSET; 889 +const MCI_WAVE_MAPPER=(MCI_WAVE_OFFSET+1); 890 +const MCI_WAVE_OPEN_BUFFER=0x10000; 891 +const MCI_WAVE_SET_FORMATTAG=0x10000; 892 +const MCI_WAVE_SET_CHANNELS=0x20000; 893 +const MCI_WAVE_SET_SAMPLESPERSEC=0x40000; 894 +const MCI_WAVE_SET_AVGBYTESPERSEC=0x80000; 895 +const MCI_WAVE_SET_BLOCKALIGN=0x100000; 896 +const MCI_WAVE_SET_BITSPERSAMPLE=0x200000; 897 +const MCI_WAVE_INPUT=0x400000; 898 +const MCI_WAVE_OUTPUT=0x800000; 899 +const MCI_WAVE_STATUS_FORMATTAG=0x4001; 900 +const MCI_WAVE_STATUS_CHANNELS=0x4002; 901 +const MCI_WAVE_STATUS_SAMPLESPERSEC=0x4003; 902 +const MCI_WAVE_STATUS_AVGBYTESPERSEC=0x4004; 903 +const MCI_WAVE_STATUS_BLOCKALIGN=0x4005; 904 +const MCI_WAVE_STATUS_BITSPERSAMPLE=0x4006; 905 +const MCI_WAVE_STATUS_LEVEL=0x4007; 906 +const MCI_WAVE_SET_ANYINPUT=0x4000000; 907 +const MCI_WAVE_SET_ANYOUTPUT=0x8000000; 908 +const MCI_WAVE_GETDEVCAPS_INPUTS=0x4001; 909 +const MCI_WAVE_GETDEVCAPS_OUTPUTS=0x4002; 910 + 911 +const MCI_SEQ_DIV_PPQN=MCI_SEQ_OFFSET; 912 +const MCI_SEQ_DIV_SMPTE_24=(MCI_SEQ_OFFSET+1); 913 +const MCI_SEQ_DIV_SMPTE_25=(MCI_SEQ_OFFSET+2); 914 +const MCI_SEQ_DIV_SMPTE_30DROP=(MCI_SEQ_OFFSET+3); 915 +const MCI_SEQ_DIV_SMPTE_30=(MCI_SEQ_OFFSET+4); 916 +const MCI_SEQ_FORMAT_SONGPTR=0x4001; 917 +const MCI_SEQ_FILE=0x4002; 918 +const MCI_SEQ_MIDI=0x4003; 919 +const MCI_SEQ_SMPTE=0x4004; 920 +const MCI_SEQ_NONE=65533; 921 +const MCI_SEQ_MAPPER=65535; 922 + 923 +const MCI_SEQ_STATUS_TEMPO=0x4002; 924 +const MCI_SEQ_STATUS_PORT=0x4003; 925 +const MCI_SEQ_STATUS_SLAVE=0x4007; 926 +const MCI_SEQ_STATUS_MASTER=0x4008; 927 +const MCI_SEQ_STATUS_OFFSET=0x4009; 928 +const MCI_SEQ_STATUS_DIVTYPE=0x400A; 929 +const MCI_SEQ_STATUS_NAME=0x400B; 930 +const MCI_SEQ_STATUS_COPYRIGHT=0x400C; 931 + 932 +const MCI_SEQ_SET_TEMPO=0x10000; 933 +const MCI_SEQ_SET_PORT=0x20000; 934 +const MCI_SEQ_SET_SLAVE=0x40000; 935 +const MCI_SEQ_SET_MASTER=0x80000; 936 +const MCI_SEQ_SET_OFFSET=0x1000000; 937 + 938 +const MCI_ANIM_OPEN_WS=0x10000; 939 +const MCI_ANIM_OPEN_PARENT=0x20000; 940 +const MCI_ANIM_OPEN_NOSTATIC=0x40000; 941 +const MCI_ANIM_PLAY_SPEED=0x10000; 942 +const MCI_ANIM_PLAY_REVERSE=0x20000; 943 +const MCI_ANIM_PLAY_FAST=0x40000; 944 +const MCI_ANIM_PLAY_SLOW=0x80000; 945 +const MCI_ANIM_PLAY_SCAN=0x100000; 946 +const MCI_ANIM_STEP_REVERSE=0x10000; 947 +const MCI_ANIM_STEP_FRAMES=0x20000; 948 +const MCI_ANIM_STATUS_SPEED=0x4001; 949 +const MCI_ANIM_STATUS_FORWARD=0x4002; 950 +const MCI_ANIM_STATUS_HWND=0x4003; 951 +const MCI_ANIM_STATUS_HPAL=0x4004; 952 +const MCI_ANIM_STATUS_STRETCH=0x4005; 953 +const MCI_ANIM_INFO_TEXT=0x10000; 954 + 955 +const MCI_ANIM_GETDEVCAPS_CAN_REVERSE=0x4001; 956 +const MCI_ANIM_GETDEVCAPS_FAST_RATE=0x4002; 957 +const MCI_ANIM_GETDEVCAPS_SLOW_RATE=0x4003; 958 +const MCI_ANIM_GETDEVCAPS_NORMAL_RATE=0x4004; 959 +const MCI_ANIM_GETDEVCAPS_PALETTES=0x4006; 960 +const MCI_ANIM_GETDEVCAPS_CAN_STRETCH=0x4007; 961 +const MCI_ANIM_GETDEVCAPS_MAX_WINDOWS=0x4008; 962 + 963 +const MCI_ANIM_REALIZE_NORM=0x10000; 964 +const MCI_ANIM_REALIZE_BKGD=0x20000; 965 + 966 +const MCI_ANIM_WINDOW_HWND=0x10000; 967 +const MCI_ANIM_WINDOW_STATE=0x40000; 968 +const MCI_ANIM_WINDOW_TEXT=0x80000; 969 +const MCI_ANIM_WINDOW_ENABLE_STRETCH=0x100000; 970 +const MCI_ANIM_WINDOW_DISABLE_STRETCH=0x200000; 971 +const MCI_ANIM_WINDOW_DEFAULT=0x0; 972 + 973 +const MCI_ANIM_RECT=0x10000; 974 +const MCI_ANIM_PUT_SOURCE=0x20000; 975 +const MCI_ANIM_PUT_DESTINATION=0x40000; 976 +const MCI_ANIM_WHERE_SOURCE=0x20000; 977 +const MCI_ANIM_WHERE_DESTINATION=0x40000; 978 +const MCI_ANIM_UPDATE_HDC=0x20000; 979 + 980 +const MCI_OVLY_OPEN_WS=0x10000; 981 +const MCI_OVLY_OPEN_PARENT=0x20000; 982 +const MCI_OVLY_STATUS_HWND=0x4001; 983 +const MCI_OVLY_STATUS_STRETCH=0x4002; 984 +const MCI_OVLY_INFO_TEXT=0x10000; 985 +const MCI_OVLY_GETDEVCAPS_CAN_STRETCH=0x4001; 986 +const MCI_OVLY_GETDEVCAPS_CAN_FREEZE=0x4002; 987 +const MCI_OVLY_GETDEVCAPS_MAX_WINDOWS=0x4003; 988 +const MCI_OVLY_WINDOW_HWND=0x10000; 989 +const MCI_OVLY_WINDOW_STATE=0x40000; 990 +const MCI_OVLY_WINDOW_TEXT=0x80000; 991 +const MCI_OVLY_WINDOW_ENABLE_STRETCH=0x100000; 992 +const MCI_OVLY_WINDOW_DISABLE_STRETCH=0x200000; 993 +const MCI_OVLY_WINDOW_DEFAULT=0x0; 994 +const MCI_OVLY_RECT=0x10000; 995 +const MCI_OVLY_PUT_SOURCE=0x20000; 996 +const MCI_OVLY_PUT_DESTINATION=0x40000; 997 +const MCI_OVLY_PUT_FRAME=0x80000; 998 +const MCI_OVLY_PUT_VIDEO=0x100000; 999 +const MCI_OVLY_WHERE_SOURCE=0x20000; 1000 +const MCI_OVLY_WHERE_DESTINATION=0x40000; 1001 +const MCI_OVLY_WHERE_FRAME=0x80000; 1002 +const MCI_OVLY_WHERE_VIDEO=0x100000; 1003 + 1004 +const NEWTRANSPARENT=3; 1005 +const QUERYROPSUPPORT=40; 1006 +const SELECTDIB=41; 1007 + 1008 +LONG DIBINDEX(WORD n) { 1009 + return MAKELONG(n,0x10FF); 1010 +} 1011 +const CAPS1=94; 1012 +const C1_TRANSPARENT=1; 1013 + 1014 +const SEEK_SET=0; 1015 +const SEEK_CUR=1; 1016 +const SEEK_END=2; 1017 + 1018 +alias DWORD MCIERROR; 1019 +alias UINT MCIDEVICEID; 1020 +alias UINT function (MCIDEVICEID,DWORD) YIELDPROC; 1021 +alias UINT MMVERSION; 68 1022 alias UINT MMRESULT; 69 1023 70 -// #define _MMRESULT_ 71 - 72 -alias UINT* LPUINT; 73 - 74 -struct mmtime_tag { 75 - UINT wType; 76 -union { 77 - DWORD ms; 78 - DWORD sample; 79 - DWORD cb; 80 - DWORD ticks; 81 - 82 -struct { 83 - BYTE hour; 84 - BYTE min; 85 - BYTE sec; 86 - BYTE frame; 87 - BYTE fps; 88 - BYTE dummy; 89 -// #ifdef _WIN32 90 - BYTE pad[2]; 91 -// #endif 92 -} 93 - 94 -struct { 95 - DWORD songptrpos; 96 -} 97 - 98 -} 99 - 100 -} 101 -alias mmtime_tag MMTIME; 102 -alias mmtime_tag* PMMTIME; 103 -alias mmtime_tag* NPMMTIME; 104 -alias mmtime_tag* LPMMTIME; 105 - 106 -enum : uint { TIME_MS = 0x0001 } 107 -enum : uint { TIME_SAMPLES = 0x0002 } 108 -enum : uint { TIME_BYTES = 0x0004 } 109 -enum : uint { TIME_SMPTE = 0x0008 } 110 -enum : uint { TIME_MIDI = 0x0010 } 111 -enum : uint { TIME_TICKS = 0x0020 } 112 - 113 -uint MAKEFOURCC(ubyte ch0, ubyte ch1, ubyte ch2, ubyte ch3){ return ch0 | (ch1 << 8) | (ch2 << 16) | (ch3 << 24); } 114 - 115 -enum : uint { MM_JOY1MOVE = 0x3A0 } 116 -enum : uint { MM_JOY2MOVE = 0x3A1 } 117 -enum : uint { MM_JOY1ZMOVE = 0x3A2 } 118 -enum : uint { MM_JOY2ZMOVE = 0x3A3 } 119 -enum : uint { MM_JOY1BUTTONDOWN = 0x3B5 } 120 -enum : uint { MM_JOY2BUTTONDOWN = 0x3B6 } 121 -enum : uint { MM_JOY1BUTTONUP = 0x3B7 } 122 -enum : uint { MM_JOY2BUTTONUP = 0x3B8 } 123 - 124 -enum : uint { MM_MCINOTIFY = 0x3B9 } 125 - 126 -enum : uint { MM_WOM_OPEN = 0x3BB } 127 -enum : uint { MM_WOM_CLOSE = 0x3BC } 128 -enum : uint { MM_WOM_DONE = 0x3BD } 129 - 130 -enum : uint { MM_WIM_OPEN = 0x3BE } 131 -enum : uint { MM_WIM_CLOSE = 0x3BF } 132 -enum : uint { MM_WIM_DATA = 0x3C0 } 133 - 134 -enum : uint { MM_MIM_OPEN = 0x3C1 } 135 -enum : uint { MM_MIM_CLOSE = 0x3C2 } 136 -enum : uint { MM_MIM_DATA = 0x3C3 } 137 -enum : uint { MM_MIM_LONGDATA = 0x3C4 } 138 -enum : uint { MM_MIM_ERROR = 0x3C5 } 139 -enum : uint { MM_MIM_LONGERROR = 0x3C6 } 140 - 141 -enum : uint { MM_MOM_OPEN = 0x3C7 } 142 -enum : uint { MM_MOM_CLOSE = 0x3C8 } 143 -enum : uint { MM_MOM_DONE = 0x3C9 } 144 - 145 -// #ifndef MM_DRVM_OPEN 146 -enum : uint { MM_DRVM_OPEN = 0x3D0 } 147 -enum : uint { MM_DRVM_CLOSE = 0x3D1 } 148 -enum : uint { MM_DRVM_DATA = 0x3D2 } 149 -enum : uint { MM_DRVM_ERROR = 0x3D3 } 150 -// #endif 151 - 152 -enum : uint { MM_STREAM_OPEN = 0x3D4 } 153 -enum : uint { MM_STREAM_CLOSE = 0x3D5 } 154 -enum : uint { MM_STREAM_DONE = 0x3D6 } 155 -enum : uint { MM_STREAM_ERROR = 0x3D7 } 156 - 157 -// #if(WINVER >= 0x0400) 158 -enum : uint { MM_MOM_POSITIONCB = 0x3CA } 159 - 160 -// #ifndef MM_MCISIGNAL 161 -enum : uint { MM_MCISIGNAL = 0x3CB } 162 -// #endif 163 - 164 -enum : uint { MM_MIM_MOREDATA = 0x3CC } 165 - 166 -// #endif /* WINVER >= 0x0400 */ 167 -enum : uint { MM_MIXM_LINE_CHANGE = 0x3D0 } 168 -enum : uint { MM_MIXM_CONTROL_CHANGE = 0x3D1 } 169 - 170 -enum : uint { MMSYSERR_BASE = 0 } 171 -enum : uint { WAVERR_BASE = 32 } 172 -enum : uint { MIDIERR_BASE = 64 } 173 -enum : uint { TIMERR_BASE = 96 } 174 -enum : uint { JOYERR_BASE = 160 } 175 -enum : uint { MCIERR_BASE = 256 } 176 -enum : uint { MIXERR_BASE = 1024 } 177 - 178 -enum : uint { MCI_STRING_OFFSET = 512 } 179 -enum : uint { MCI_VD_OFFSET = 1024 } 180 -enum : uint { MCI_CD_OFFSET = 1088 } 181 -enum : uint { MCI_WAVE_OFFSET = 1152 } 182 -enum : uint { MCI_SEQ_OFFSET = 1216 } 183 - 184 -enum : uint { MMSYSERR_NOERROR = 0 } 185 -enum : uint { MMSYSERR_ERROR = MMSYSERR_BASE + 1 } 186 -enum : uint { MMSYSERR_BADDEVICEID = MMSYSERR_BASE + 2 } 187 -enum : uint { MMSYSERR_NOTENABLED = MMSYSERR_BASE + 3 } 188 -enum : uint { MMSYSERR_ALLOCATED = MMSYSERR_BASE + 4 } 189 -enum : uint { MMSYSERR_INVALHANDLE = MMSYSERR_BASE + 5 } 190 -enum : uint { MMSYSERR_NODRIVER = MMSYSERR_BASE + 6 } 191 -enum : uint { MMSYSERR_NOMEM = MMSYSERR_BASE + 7 } 192 -enum : uint { MMSYSERR_NOTSUPPORTED = MMSYSERR_BASE + 8 } 193 -enum : uint { MMSYSERR_BADERRNUM = MMSYSERR_BASE + 9 } 194 -enum : uint { MMSYSERR_INVALFLAG = MMSYSERR_BASE + 10 } 195 -enum : uint { MMSYSERR_INVALPARAM = MMSYSERR_BASE + 11 } 196 -enum : uint { MMSYSERR_HANDLEBUSY = MMSYSERR_BASE + 12 } 197 - 198 -enum : uint { MMSYSERR_INVALIDALIAS = MMSYSERR_BASE + 13 } 199 -enum : uint { MMSYSERR_BADDB = MMSYSERR_BASE + 14 } 200 -enum : uint { MMSYSERR_KEYNOTFOUND = MMSYSERR_BASE + 15 } 201 -enum : uint { MMSYSERR_READERROR = MMSYSERR_BASE + 16 } 202 -enum : uint { MMSYSERR_WRITEERROR = MMSYSERR_BASE + 17 } 203 -enum : uint { MMSYSERR_DELETEERROR = MMSYSERR_BASE + 18 } 204 -enum : uint { MMSYSERR_VALNOTFOUND = MMSYSERR_BASE + 19 } 205 -enum : uint { MMSYSERR_NODRIVERCB = MMSYSERR_BASE + 20 } 206 -enum : uint { MMSYSERR_MOREDATA = MMSYSERR_BASE + 21 } 207 -enum : uint { MMSYSERR_LASTERROR = MMSYSERR_BASE + 21 } 208 - 209 -// #if (WINVER < 0x030a) || defined(_WIN32) 210 -alias void* HDRVR; 211 -// #endif /* ifdef WINVER < 0x030a */ 212 - 213 -// #ifndef MMNODRV 214 - 215 -// #ifdef _WIN32 1024 +struct MMTIME { 1025 + UINT wType; 1026 + union { 1027 + DWORD ms; 1028 + DWORD sample; 1029 + DWORD cb; 1030 + DWORD ticks; 1031 + struct smpte { 1032 + BYTE hour; 1033 + BYTE min; 1034 + BYTE sec; 1035 + BYTE frame; 1036 + BYTE fps; 1037 + BYTE dummy; 1038 + BYTE pad[2]; 1039 + }; 1040 + struct midi { 1041 + DWORD songptrpos; 1042 + } 1043 + } 1044 +} 1045 +alias MMTIME* PMMTIME, LPMMTIME; 1046 + 1047 +alias HANDLE HDRVR; 1048 + 1049 +struct DRVCONFIGINFO { 1050 + DWORD dwDCISize; 1051 + LPCWSTR lpszDCISectionName; 1052 + LPCWSTR lpszDCIAliasName; 1053 +} 1054 +alias DRVCONFIGINFO * PDRVCONFIGINFO, LPDRVCONFIGINFO; 1055 + 216 1056 struct DRVCONFIGINFOEX { 217 - DWORD dwDCISize; 218 - LPCWSTR lpszDCISectionName; 219 - LPCWSTR lpszDCIAliasName; 220 - DWORD dnDevNode; 221 -} 222 -alias DRVCONFIGINFOEX* PDRVCONFIGINFOEX; 223 -alias DRVCONFIGINFOEX* NPDRVCONFIGINFOEX; 224 -alias DRVCONFIGINFOEX* LPDRVCONFIGINFOEX; 225 - 226 -// #else 227 -// ... 228 -// #endif 229 - 230 -// #if (WINVER < 0x030a) || defined(_WIN32) 231 - 232 -// #ifndef DRV_LOAD 233 - 234 -enum : uint { DRV_LOAD = 0x0001 } 235 -enum : uint { DRV_ENABLE = 0x0002 } 236 -enum : uint { DRV_OPEN = 0x0003 } 237 -enum : uint { DRV_CLOSE = 0x0004 } 238 -enum : uint { DRV_DISABLE = 0x0005 } 239 -enum : uint { DRV_FREE = 0x0006 } 240 -enum : uint { DRV_CONFIGURE = 0x0007 } 241 -enum : uint { DRV_QUERYCONFIGURE = 0x0008 } 242 -enum : uint { DRV_INSTALL = 0x0009 } 243 -enum : uint { DRV_REMOVE = 0x000A } 244 -enum : uint { DRV_EXITSESSION = 0x000B } 245 -enum : uint { DRV_POWER = 0x000F } 246 -enum : uint { DRV_RESERVED = 0x0800 } 247 -enum : uint { DRV_USER = 0x4000 } 248 - 249 -// #ifdef _WIN32 250 -struct tagDRVCONFIGINFO { 251 - DWORD dwDCISize; 252 - LPCWSTR lpszDCISectionName; 253 - LPCWSTR lpszDCIAliasName; 254 -} 255 -alias tagDRVCONFIGINFO DRVCONFIGINFO; 256 -alias tagDRVCONFIGINFO* PDRVCONFIGINFO; 257 -alias tagDRVCONFIGINFO* NPDRVCONFIGINFO; 258 -alias tagDRVCONFIGINFO* LPDRVCONFIGINFO; 259 - 260 -// #else 261 -// ... 262 -// #endif 263 - 264 -enum : uint { DRVCNF_CANCEL = 0x0000 } 265 -enum : uint { DRVCNF_OK = 0x0001 } 266 -enum : uint { DRVCNF_RESTART = 0x0002 } 267 - 268 -// #ifdef _WIN32 269 - 270 -extern(Windows) alias LRESULT function(DWORD_PTR, HDRVR, UINT, LPARAM, LPARAM) DRIVERPROC; 271 - 272 -extern(Windows) export LRESULT CloseDriver(HDRVR hDriver, LPARAM lParam1, LPARAM lParam2); 273 -extern(Windows) export HDRVR OpenDriver(LPCWSTR szDriverName, LPCWSTR szSectionName, LPARAM lParam2); 274 -extern(Windows) export LRESULT SendDriverMessage(HDRVR hDriver, UINT message, LPARAM lParam1, LPARAM lParam2); 275 -extern(Windows) export HMODULE DrvGetModuleHandle(HDRVR hDriver); 276 -extern(Windows) export HMODULE GetDriverModuleHandle(HDRVR hDriver); 277 -extern(Windows) export LRESULT DefDriverProc(DWORD_PTR dwDriverIdentifier, HDRVR hdrvr, UINT uMsg, LPARAM lParam1, LPARAM lParam2); 278 -// #else 279 -// ... 280 -// #... 281 -// #endif /* ifdef _WIN32 */ 282 -// #endif /* DRV_LOAD */ 283 -// #endif /* ifdef (WINVER < 0x030a) || defined(_WIN32) */ 284 - 285 -// #if (WINVER >= 0x030a) 286 - 287 -alias DRVCNF_CANCEL DRV_CANCEL; 288 -alias DRVCNF_OK DRV_OK; 289 -alias DRVCNF_RESTART DRV_RESTART; 290 - 291 -// #endif /* ifdef WINVER >= 0x030a */ 292 - 293 -alias DRV_RESERVED DRV_MCI_FIRST; 294 -enum : uint { DRV_MCI_LAST = DRV_RESERVED + 0xFFF } 295 - 296 -// #endif /* ifndef MMNODRV */ 297 - 298 -enum : uint { CALLBACK_TYPEMASK = 0x00070000 } 299 -enum : uint { CALLBACK_NULL = 0x00000000 } 300 -enum : uint { CALLBACK_WINDOW = 0x00010000 } 301 -enum : uint { CALLBACK_TASK = 0x00020000 } 302 -enum : uint { CALLBACK_FUNCTION = 0x00030000 } 303 -// #ifdef _WIN32 304 -enum : uint { CALLBACK_THREAD = CALLBACK_TASK } 305 -enum : uint { CALLBACK_EVENT = 0x00050000 } 306 -// #endif 307 -// typedef void (CALLBACK DRVCALLBACK)(HDRVR hdrvr, UINT uMsg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2); 308 - 309 -extern(Windows) alias void function(HDRVR hdrvr, UINT uMsg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2) LPDRVCALLBACK; 310 -// #ifdef _WIN32 311 -alias LPDRVCALLBACK PDRVCALLBACK; 312 -// #endif 313 - 314 -// #ifndef MMNOMMSYSTEM 315 - 316 -// #if (WINVER <= 0x030A) 317 -// ... 318 -// #endif 319 -// #ifdef _WIN32 320 -alias OutputDebugString OutputDebugStr; 321 -// #else 322 -// ... 323 -// #endif 324 - 325 -// #endif /* ifndef MMNOMMSYSTEM */ 326 - 327 -// #ifndef MMNOSOUND 328 - 329 -// #ifdef _WIN32 330 - 331 -extern(Windows) export BOOL sndPlaySoundA(LPCSTR pszSound, UINT fuSound); 332 -extern(Windows) export BOOL sndPlaySoundW(LPCWSTR pszSound, UINT fuSound); 333 -// #ifdef UNICODE 334 -alias sndPlaySoundW sndPlaySound; 335 -// #else 336 -// #... 337 -// #endif // !UNICODE 338 - 339 -// #else 340 -// ... 341 -// #endif 342 - 343 -enum : uint { SND_SYNC = 0x0000 } 344 -enum : uint { SND_ASYNC = 0x0001 } 345 -enum : uint { SND_NODEFAULT = 0x0002 } 346 -enum : uint { SND_MEMORY = 0x0004 } 347 -enum : uint { SND_LOOP = 0x0008 } 348 -enum : uint { SND_NOSTOP = 0x0010 } 349 - 350 -enum : uint { SND_NOWAIT = 0x00002000 } 351 -enum : uint { SND_ALIAS = 0x00010000 } 352 -enum : uint { SND_ALIAS_ID = 0x00110000 } 353 -enum : uint { SND_FILENAME = 0x00020000 } 354 -enum : uint { SND_RESOURCE = 0x00040004 } 355 -// #if(WINVER >= 0x0400) 356 -enum : uint { SND_PURGE = 0x0040 } 357 -enum : uint { SND_APPLICATION = 0x0080 } 358 -// #endif /* WINVER >= 0x0400 */ 359 - 360 -enum : uint { SND_ALIAS_START = 0 } 361 - 362 -// #ifdef _WIN32 363 -// #define sndAlias(ch0, ch1) (SND_ALIAS_START + (DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8)) 364 - 365 -// #define SND_ALIAS_SYSTEMASTERISK sndAlias('S', '*') 366 -// #define SND_ALIAS_SYSTEMQUESTION sndAlias('S', '?') 367 -// #define SND_ALIAS_SYSTEMHAND sndAlias('S', 'H') 368 -// #define SND_ALIAS_SYSTEMEXIT sndAlias('S', 'E') 369 -// #define SND_ALIAS_SYSTEMSTART sndAlias('S', 'S') 370 -// #define SND_ALIAS_SYSTEMWELCOME sndAlias('S', 'W') 371 -// #define SND_ALIAS_SYSTEMEXCLAMATION sndAlias('S', '!') 372 -// #define SND_ALIAS_SYSTEMDEFAULT sndAlias('S', 'D') 373 - 374 -extern(Windows) export BOOL PlaySoundA(LPCSTR pszSound, HMODULE hmod, DWORD fdwSound); 375 -extern(Windows) export BOOL PlaySoundW(LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound); 376 -// #ifdef UNICODE 377 -alias PlaySoundW PlaySound; 378 -// #else 379 -// #... 380 -// #endif // !UNICODE 381 - 382 -// #else 383 -// ... 384 -// #endif 385 - 386 -// #endif /* ifndef MMNOSOUND */ 387 - 388 -// #ifndef MMNOWAVE 389 - 390 -enum : uint { WAVERR_BADFORMAT = WAVERR_BASE + 0 } 391 -enum : uint { WAVERR_STILLPLAYING = WAVERR_BASE + 1 } 392 -enum : uint { WAVERR_UNPREPARED = WAVERR_BASE + 2 } 393 -enum : uint { WAVERR_SYNC = WAVERR_BASE + 3 } 394 -enum : uint { WAVERR_LASTERROR = WAVERR_BASE + 3 } 395 - 396 -alias void* HWAVE; 397 -alias void* HWAVEIN; 398 -alias void* HWAVEOUT; 1057 + DWORD dwDCISize; 1058 + LPCWSTR lpszDCISectionName; 1059 + LPCWSTR lpszDCIAliasName; 1060 + DWORD dnDevNode; 1061 +} 1062 +alias DRVCONFIGINFOEX* PDRVCONFIGINFOEX, LPDRVCONFIGINFOEX; 1063 + 1064 +extern(Windows): 1065 + 1066 +/+FIXME: I couldn't find these in MSDN. 1067 +alias void function (HDRVR,UINT,DWORD,DWORD,DWORD) DRVCALLBACK; 1068 +LRESULT DRIVERPROC (DWORD,HDRVR,UINT,LPARAM,LPARAM); 1069 +alias DRVCALLBACK* LPDRVCALLBACK, PDRVCALLBACK; 1070 + 1071 +alias DRVCALLBACK WAVECALLBACK; 1072 +alias WAVECALLBACK* LPWAVECALLBACK; 1073 + 1074 +alias DRVCALLBACK MIDICALLBACK; 1075 +alias MIDICALLBACK* LPMIDICALLBACK; 1076 + 1077 ++/ 1078 + 1079 +alias HANDLE HWAVE; 1080 +alias HANDLE HWAVEIN; 1081 +alias HANDLE HWAVEOUT; 1082 + 399 1083 alias HWAVEIN* LPHWAVEIN; 400 1084 alias HWAVEOUT* LPHWAVEOUT; 401 -// typedef DRVCALLBACK WAVECALLBACK; 402 -alias LPDRVCALLBACK LPWAVECALLBACK; 403 - 404 -alias MM_WOM_OPEN WOM_OPEN; 405 -alias MM_WOM_CLOSE WOM_CLOSE; 406 -alias MM_WOM_DONE WOM_DONE; 407 -alias MM_WIM_OPEN WIM_OPEN; 408 -alias MM_WIM_CLOSE WIM_CLOSE; 409 -alias MM_WIM_DATA WIM_DATA; 410 - 411 -enum : uint { WAVE_MAPPER = cast(UINT)-1 } 412 - 413 -enum : uint { WAVE_FORMAT_QUERY = 0x0001 } 414 -enum : uint { WAVE_ALLOWSYNC = 0x0002 } 415 -// #if(WINVER >= 0x0400) 416 -enum : uint { WAVE_MAPPED = 0x0004 } 417 -enum : uint { WAVE_FORMAT_DIRECT = 0x0008 } 418 -enum : uint { WAVE_FORMAT_DIRECT_QUERY = WAVE_FORMAT_QUERY | WAVE_FORMAT_DIRECT } 419 -// #endif /* WINVER >= 0x0400 */ 420 - 421 -struct wavehdr_tag { 422 - LPSTR lpData; 423 - DWORD dwBufferLength; 424 - DWORD dwBytesRecorded; 425 - DWORD_PTR dwUser; 426 - DWORD dwFlags; 427 - DWORD dwLoops; 428 - wavehdr_tag *lpNext; 429 - DWORD_PTR reserved; 430 -} 431 -alias wavehdr_tag WAVEHDR; 432 -alias wavehdr_tag* PWAVEHDR; 433 -alias wavehdr_tag* NPWAVEHDR; 434 -alias wavehdr_tag* LPWAVEHDR; 435 - 436 -enum : uint { WHDR_DONE = 0x00000001 } 437 -enum : uint { WHDR_PREPARED = 0x00000002 } 438 -enum : uint { WHDR_BEGINLOOP = 0x00000004 } 439 -enum : uint { WHDR_ENDLOOP = 0x00000008 } 440 -enum : uint { WHDR_INQUEUE = 0x00000010 } 441 - 442 -// #ifdef _WIN32 443 - 444 -struct tagWAVEOUTCAPSA { 445 - WORD wMid; 446 - WORD wPid; 447 - MMVERSION vDriverVersion; 448 - CHAR szPname[MAXPNAMELEN]; 449 - DWORD dwFormats; 450 - WORD wChannels; 451 - WORD wReserved1; 452 - DWORD dwSupport; 453 -} 454 -alias tagWAVEOUTCAPSA WAVEOUTCAPSA; 455 -alias tagWAVEOUTCAPSA* PWAVEOUTCAPSA; 456 -alias tagWAVEOUTCAPSA* NPWAVEOUTCAPSA; 457 -alias tagWAVEOUTCAPSA* LPWAVEOUTCAPSA; 458 - 459 -struct tagWAVEOUTCAPSW { 460 - WORD wMid; 461 - WORD wPid; 462 - MMVERSION vDriverVersion; 463 - WCHAR szPname[MAXPNAMELEN]; 464 - DWORD dwFormats; 465 - WORD wChannels; 466 - WORD wReserved1; 467 - DWORD dwSupport; 468 -} 469 -alias tagWAVEOUTCAPSW WAVEOUTCAPSW; 470 -alias tagWAVEOUTCAPSW* PWAVEOUTCAPSW; 471 -alias tagWAVEOUTCAPSW* NPWAVEOUTCAPSW; 472 -alias tagWAVEOUTCAPSW* LPWAVEOUTCAPSW; 473 - 474 -// #ifdef UNICODE 475 -alias WAVEOUTCAPSW WAVEOUTCAPS; 476 -alias PWAVEOUTCAPSW PWAVEOUTCAPS; 477 -alias NPWAVEOUTCAPSW NPWAVEOUTCAPS; 478 -alias LPWAVEOUTCAPSW LPWAVEOUTCAPS; 479 -// #else 480 -// ... 481 -// #endif // UNICODE 482 -struct tagWAVEOUTCAPS2A { 483 - WORD wMid; 484 - WORD wPid; 485 - MMVERSION vDriverVersion; 486 - CHAR szPname[MAXPNAMELEN]; 487 - DWORD dwFormats; 488 - WORD wChannels; 489 - WORD wReserved1; 490 - DWORD dwSupport; 491 - GUID ManufacturerGuid; 492 - GUID ProductGuid; 493 - GUID NameGuid; 494 -} 495 -alias tagWAVEOUTCAPS2A WAVEOUTCAPS2A; 496 -alias tagWAVEOUTCAPS2A* PWAVEOUTCAPS2A; 497 -alias tagWAVEOUTCAPS2A* NPWAVEOUTCAPS2A; 498 -alias tagWAVEOUTCAPS2A* LPWAVEOUTCAPS2A; 499 - 500 -struct tagWAVEOUTCAPS2W { 501 - WORD wMid; 502 - WORD wPid; 503 - MMVERSION vDriverVersion; 504 - WCHAR szPname[MAXPNAMELEN]; 505 - DWORD dwFormats; 506 - WORD wChannels; 507 - WORD wReserved1; 508 - DWORD dwSupport; 509 - GUID ManufacturerGuid; 510 - GUID ProductGuid; 511 - GUID NameGuid; 512 -} 513 -alias tagWAVEOUTCAPS2W WAVEOUTCAPS2W; 514 -alias tagWAVEOUTCAPS2W* PWAVEOUTCAPS2W; 515 -alias tagWAVEOUTCAPS2W* NPWAVEOUTCAPS2W; 516 -alias tagWAVEOUTCAPS2W* LPWAVEOUTCAPS2W; 517 - 518 -// #ifdef UNICODE 519 -alias WAVEOUTCAPS2W WAVEOUTCAPS2; 520 -alias PWAVEOUTCAPS2W PWAVEOUTCAPS2; 521 -alias NPWAVEOUTCAPS2W NPWAVEOUTCAPS2; 522 -alias LPWAVEOUTCAPS2W LPWAVEOUTCAPS2; 523 -// #else 524 -// ... 525 -// #endif // UNICODE 526 - 527 -// #else 528 -// ... 529 -// #endif 530 - 531 -enum : uint { WAVECAPS_PITCH = 0x0001 } 532 -enum : uint { WAVECAPS_PLAYBACKRATE = 0x0002 } 533 -enum : uint { WAVECAPS_VOLUME = 0x0004 } 534 -enum : uint { WAVECAPS_LRVOLUME = 0x0008 } 535 -enum : uint { WAVECAPS_SYNC = 0x0010 } 536 -enum : uint { WAVECAPS_SAMPLEACCURATE = 0x0020 } 537 - 538 -// #ifdef _WIN32 539 - 540 -struct tagWAVEINCAPSA { 541 - WORD wMid; 542 - WORD wPid; 543 - MMVERSION vDriverVersion; 544 - CHAR szPname[MAXPNAMELEN]; 545 - DWORD dwFormats; 546 - WORD wChannels; 547 - WORD wReserved1; 548 -} 549 -alias tagWAVEINCAPSA WAVEINCAPSA; 550 -alias tagWAVEINCAPSA* PWAVEINCAPSA; 551 -alias tagWAVEINCAPSA* NPWAVEINCAPSA; 552 -alias tagWAVEINCAPSA* LPWAVEINCAPSA; 553 - 554 -struct tagWAVEINCAPSW { 555 - WORD wMid; 556 - WORD wPid; 557 - MMVERSION vDriverVersion; 558 - WCHAR szPname[MAXPNAMELEN]; 559 - DWORD dwFormats; 560 - WORD wChannels; 561 - WORD wReserved1; 562 -} 563 -alias tagWAVEINCAPSW WAVEINCAPSW; 564 -alias tagWAVEINCAPSW* PWAVEINCAPSW; 565 -alias tagWAVEINCAPSW* NPWAVEINCAPSW; 566 -alias tagWAVEINCAPSW* LPWAVEINCAPSW; 567 - 568 -// #ifdef UNICODE 569 -alias WAVEINCAPSW WAVEINCAPS; 570 -alias PWAVEINCAPSW PWAVEINCAPS; 571 -alias NPWAVEINCAPSW NPWAVEINCAPS; 572 -alias LPWAVEINCAPSW LPWAVEINCAPS; 573 -// #else 574 -// ... 575 -// #endif // UNICODE 576 -struct tagWAVEINCAPS2A { 577 - WORD wMid; 578 - WORD wPid; 579 - MMVERSION vDriverVersion; 580 - CHAR szPname[MAXPNAMELEN]; 581 - DWORD dwFormats; 582 - WORD wChannels; 583 - WORD wReserved1; 584 - GUID ManufacturerGuid; 585 - GUID ProductGuid; 586 - GUID NameGuid; 587 -} 588 -alias tagWAVEINCAPS2A WAVEINCAPS2A; 589 -alias tagWAVEINCAPS2A* PWAVEINCAPS2A; 590 -alias tagWAVEINCAPS2A* NPWAVEINCAPS2A; 591 -alias tagWAVEINCAPS2A* LPWAVEINCAPS2A; 592 - 593 -struct tagWAVEINCAPS2W { 594 - WORD wMid; 595 - WORD wPid; 596 - MMVERSION vDriverVersion; 597 - WCHAR szPname[MAXPNAMELEN]; 598 - DWORD dwFormats; 599 - WORD wChannels; 600 - WORD wReserved1; 601 - GUID ManufacturerGuid; 602 - GUID ProductGuid; 603 - GUID NameGuid; 604 -} 605 -alias tagWAVEINCAPS2W WAVEINCAPS2W; 606 -alias tagWAVEINCAPS2W* PWAVEINCAPS2W; 607 -alias tagWAVEINCAPS2W* NPWAVEINCAPS2W; 608 -alias tagWAVEINCAPS2W* LPWAVEINCAPS2W; 609 - 610 -// #ifdef UNICODE 611 -alias WAVEINCAPS2W WAVEINCAPS2; 612 -alias PWAVEINCAPS2W PWAVEINCAPS2; 613 -alias NPWAVEINCAPS2W NPWAVEINCAPS2; 614 -alias LPWAVEINCAPS2W LPWAVEINCAPS2; 615 -// #else 616 -// ... 617 -// #endif // UNICODE 618 - 619 -// #else 620 -// ... 621 -// #endif 622 - 623 -enum : uint { WAVE_INVALIDFORMAT = 0x00000000 } 624 -enum : uint { WAVE_FORMAT_1M08 = 0x00000001 } 625 -enum : uint { WAVE_FORMAT_1S08 = 0x00000002 } 626 -enum : uint { WAVE_FORMAT_1M16 = 0x00000004 } 627 -enum : uint { WAVE_FORMAT_1S16 = 0x00000008 } 628 -enum : uint { WAVE_FORMAT_2M08 = 0x00000010 } 629 -enum : uint { WAVE_FORMAT_2S08 = 0x00000020 } 630 -enum : uint { WAVE_FORMAT_2M16 = 0x00000040 } 631 -enum : uint { WAVE_FORMAT_2S16 = 0x00000080 } 632 -enum : uint { WAVE_FORMAT_4M08 = 0x00000100 } 633 -enum : uint { WAVE_FORMAT_4S08 = 0x00000200 } 634 -enum : uint { WAVE_FORMAT_4M16 = 0x00000400 } 635 -enum : uint { WAVE_FORMAT_4S16 = 0x00000800 } 636 - 637 -enum : uint { WAVE_FORMAT_44M08 = 0x00000100 } 638 -enum : uint { WAVE_FORMAT_44S08 = 0x00000200 } 639 -enum : uint { WAVE_FORMAT_44M16 = 0x00000400 } 640 -enum : uint { WAVE_FORMAT_44S16 = 0x00000800 } 641 -enum : uint { WAVE_FORMAT_48M08 = 0x00001000 } 642 -enum : uint { WAVE_FORMAT_48S08 = 0x00002000 } 643 -enum : uint { WAVE_FORMAT_48M16 = 0x00004000 } 644 -enum : uint { WAVE_FORMAT_48S16 = 0x00008000 } 645 -enum : uint { WAVE_FORMAT_96M08 = 0x00010000 } 646 -enum : uint { WAVE_FORMAT_96S08 = 0x00020000 } 647 -enum : uint { WAVE_FORMAT_96M16 = 0x00040000 } 648 -enum : uint { WAVE_FORMAT_96S16 = 0x00080000 } 649 - 650 -// #ifndef WAVE_FORMAT_PCM 651 - 652 -struct waveformat_tag { 653 - WORD wFormatTag; 654 - WORD nChannels; 655 - DWORD nSamplesPerSec; 656 - DWORD nAvgBytesPerSec; 657 - WORD nBlockAlign; 658 -} 659 -alias waveformat_tag WAVEFORMAT; 660 -alias waveformat_tag* PWAVEFORMAT; 661 -alias waveformat_tag* NPWAVEFORMAT; 662 -alias waveformat_tag* LPWAVEFORMAT; 663 - 664 -enum : uint { WAVE_FORMAT_PCM = 1 } 665 - 666 -struct pcmwaveformat_tag { 667 - WAVEFORMAT wf; 668 - WORD wBitsPerSample; 669 -} 670 -alias pcmwaveformat_tag PCMWAVEFORMAT; 671 -alias pcmwaveformat_tag* PPCMWAVEFORMAT; 672 -alias pcmwaveformat_tag* NPPCMWAVEFORMAT; 673 -alias pcmwaveformat_tag* LPPCMWAVEFORMAT; 674 - 675 -// #endif /* WAVE_FORMAT_PCM */ 676 - 677 -// #ifndef _WAVEFORMATEX_ 678 -// #define _WAVEFORMATEX_ 679 - 680 -struct tWAVEFORMATEX { 681 - WORD wFormatTag; 682 - WORD nChannels; 683 - DWORD nSamplesPerSec; 684 - DWORD nAvgBytesPerSec; 685 - WORD nBlockAlign; 686 - WORD wBitsPerSample; 687 - WORD cbSize; 688 - 689 -} 690 -alias tWAVEFORMATEX WAVEFORMATEX; 691 -alias tWAVEFORMATEX* PWAVEFORMATEX; 692 -alias tWAVEFORMATEX* NPWAVEFORMATEX; 693 -alias tWAVEFORMATEX* LPWAVEFORMATEX; 694 - 695 -// #endif /* _WAVEFORMATEX_ */ 696 -alias WAVEFORMATEX* LPCWAVEFORMATEX; 697 - 698 -extern(Windows) export UINT waveOutGetNumDevs(); 699 - 700 -// #ifdef _WIN32 701 - 702 -extern(Windows) export MMRESULT waveOutGetDevCapsA(UINT_PTR uDeviceID, LPWAVEOUTCAPSA pwoc, UINT cbwoc); 703 -extern(Windows) export MMRESULT waveOutGetDevCapsW(UINT_PTR uDeviceID, LPWAVEOUTCAPSW pwoc, UINT cbwoc); 704 -// #ifdef UNICODE 705 -alias waveOutGetDevCapsW waveOutGetDevCaps; 706 -// #else 707 -// #... 708 -// #endif // !UNICODE 709 - 710 -// #else 711 -// ... 712 -// #endif 713 - 714 -// #if (WINVER >= 0x0400) 715 -extern(Windows) export MMRESULT waveOutGetVolume(HWAVEOUT hwo, LPDWORD pdwVolume); 716 -extern(Windows) export MMRESULT waveOutSetVolume(HWAVEOUT hwo, DWORD dwVolume); 717 -// #else 718 -// ... 719 -// #endif 720 - 721 -// #ifdef _WIN32 722 - 723 -extern(Windows) export MMRESULT waveOutGetErrorTextA(MMRESULT mmrError, LPSTR pszText, UINT cchText); 724 -extern(Windows) export MMRESULT waveOutGetErrorTextW(MMRESULT mmrError, LPWSTR pszText, UINT cchText); 725 -// #ifdef UNICODE 726 -alias waveOutGetErrorTextW waveOutGetErrorText; 727 -// #else 728 -// #... 729 -// #endif // !UNICODE 730 - 731 -// #else 732 -// ... 733 -// #endif 734 - 735 -extern(Windows) export MMRESULT waveOutOpen(LPHWAVEOUT phwo, UINT uDeviceID, 736 - LPCWAVEFORMATEX pwfx, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen); 737 - 738 -extern(Windows) export MMRESULT waveOutClose(HWAVEOUT hwo); 739 -extern(Windows) export MMRESULT waveOutPrepareHeader(HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh); 740 -extern(Windows) export MMRESULT waveOutUnprepareHeader(HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh); 741 -extern(Windows) export MMRESULT waveOutWrite(HWAVEOUT hwo, LPWAVEHDR pwh, UINT cbwh); 742 -extern(Windows) export MMRESULT waveOutPause(HWAVEOUT hwo); 743 -extern(Windows) export MMRESULT waveOutRestart(HWAVEOUT hwo); 744 -extern(Windows) export MMRESULT waveOutReset(HWAVEOUT hwo); 745 -extern(Windows) export MMRESULT waveOutBreakLoop(HWAVEOUT hwo); 746 -extern(Windows) export MMRESULT waveOutGetPosition(HWAVEOUT hwo, LPMMTIME pmmt, UINT cbmmt); 747 -extern(Windows) export MMRESULT waveOutGetPitch(HWAVEOUT hwo, LPDWORD pdwPitch); 748 -extern(Windows) export MMRESULT waveOutSetPitch(HWAVEOUT hwo, DWORD dwPitch); 749 -extern(Windows) export MMRESULT waveOutGetPlaybackRate(HWAVEOUT hwo, LPDWORD pdwRate); 750 -extern(Windows) export MMRESULT waveOutSetPlaybackRate(HWAVEOUT hwo, DWORD dwRate); 751 -extern(Windows) export MMRESULT waveOutGetID(HWAVEOUT hwo, LPUINT puDeviceID); 752 - 753 -// #if (WINVER >= 0x030a) 754 -// #ifdef _WIN32 755 -extern(Windows) export MMRESULT waveOutMessage(HWAVEOUT hwo, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2); 756 -// #else 757 -// ... 758 -// #endif 759 -// #endif /* ifdef WINVER >= 0x030a */ 760 - 761 -extern(Windows) export UINT waveInGetNumDevs(); 762 - 763 -// #ifdef _WIN32 764 - 765 -extern(Windows) export MMRESULT waveInGetDevCapsA(UINT_PTR uDeviceID, LPWAVEINCAPSA pwic, UINT cbwic); 766 -extern(Windows) export MMRESULT waveInGetDevCapsW(UINT_PTR uDeviceID, LPWAVEINCAPSW pwic, UINT cbwic); 767 -// #ifdef UNICODE 768 -alias waveInGetDevCapsW waveInGetDevCaps; 769 -// #else 770 -// #... 771 -// #endif // !UNICODE 772 - 773 -// #else 774 -// ... 775 -// #endif 776 - 777 -// #ifdef _WIN32 778 - 779 -extern(Windows) export MMRESULT waveInGetErrorTextA(MMRESULT mmrError, LPSTR pszText, UINT cchText); 780 -extern(Windows) export MMRESULT waveInGetErrorTextW(MMRESULT mmrError, LPWSTR pszText, UINT cchText); 781 -// #ifdef UNICODE 782 -alias waveInGetErrorTextW waveInGetErrorText; 783 -// #else 784 -// #... 785 -// #endif // !UNICODE 786 - 787 -// #else 788 -// ... 789 -// #endif 790 - 791 -extern(Windows) export MMRESULT waveInOpen(LPHWAVEIN phwi, UINT uDeviceID, 792 - LPCWAVEFORMATEX pwfx, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen); 793 - 794 -extern(Windows) export MMRESULT waveInClose(HWAVEIN hwi); 795 -extern(Windows) export MMRESULT waveInPrepareHeader(HWAVEIN hwi, LPWAVEHDR pwh, UINT cbwh); 796 -extern(Windows) export MMRESULT waveInUnprepareHeader(HWAVEIN hwi, LPWAVEHDR pwh, UINT cbwh); 797 -extern(Windows) export MMRESULT waveInAddBuffer(HWAVEIN hwi, LPWAVEHDR pwh, UINT cbwh); 798 -extern(Windows) export MMRESULT waveInStart(HWAVEIN hwi); 799 -extern(Windows) export MMRESULT waveInStop(HWAVEIN hwi); 800 -extern(Windows) export MMRESULT waveInReset(HWAVEIN hwi); 801 -extern(Windows) export MMRESULT waveInGetPosition(HWAVEIN hwi, LPMMTIME pmmt, UINT cbmmt); 802 -extern(Windows) export MMRESULT waveInGetID(HWAVEIN hwi, LPUINT puDeviceID); 803 - 804 -// #if (WINVER >= 0x030a) 805 -// #ifdef _WIN32 806 -extern(Windows) export MMRESULT waveInMessage(HWAVEIN hwi, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2); 807 -// #else 808 -// ... 809 -// #endif 810 -// #endif /* ifdef WINVER >= 0x030a */ 811 - 812 -// #endif /* ifndef MMNOWAVE */ 813 - 814 -// #ifndef MMNOMIDI 815 - 816 -enum : uint { MIDIERR_UNPREPARED = MIDIERR_BASE + 0 } 817 -enum : uint { MIDIERR_STILLPLAYING = MIDIERR_BASE + 1 } 818 -enum : uint { MIDIERR_NOMAP = MIDIERR_BASE + 2 } 819 -enum : uint { MIDIERR_NOTREADY = MIDIERR_BASE + 3 } 820 -enum : uint { MIDIERR_NODEVICE = MIDIERR_BASE + 4 } 821 -enum : uint { MIDIERR_INVALIDSETUP = MIDIERR_BASE + 5 } 822 -enum : uint { MIDIERR_BADOPENMODE = MIDIERR_BASE + 6 } 823 -enum : uint { MIDIERR_DONT_CONTINUE = MIDIERR_BASE + 7 } 824 -enum : uint { MIDIERR_LASTERROR = MIDIERR_BASE + 7 } 825 - 826 -alias void* HMIDI; 827 -alias void* HMIDIIN; 828 -alias void* HMIDIOUT; 829 -alias void* HMIDISTRM; 1085 + 1086 +struct WAVEHDR { 1087 + LPSTR lpData; 1088 + DWORD dwBufferLength; 1089 + DWORD dwBytesRecorded; 1090 + DWORD dwUser; 1091 + DWORD dwFlags; 1092 + DWORD dwLoops; 1093 + WAVEHDR *lpNext; 1094 + DWORD reserved; 1095 +} 1096 +alias WAVEHDR* PWAVEHDR, LPWAVEHDR; 1097 + 1098 +struct WAVEOUTCAPSA { 1099 + WORD wMid; 1100 + WORD wPid; 1101 + MMVERSION vDriverVersion; 1102 + CHAR szPname[MAXPNAMELEN]; 1103 + DWORD dwFormats; 1104 + WORD wChannels; 1105 + WORD wReserved1; 1106 + DWORD dwSupport; 1107 +} 1108 +alias WAVEOUTCAPSA* PWAVEOUTCAPSA, LPWAVEOUTCAPSA; 1109 + 1110 +struct WAVEOUTCAPSW { 1111 + WORD wMid; 1112 + WORD wPid; 1113 + MMVERSION vDriverVersion; 1114 + WCHAR szPname[MAXPNAMELEN]; 1115 + DWORD dwFormats; 1116 + WORD wChannels; 1117 + WORD wReserved1; 1118 + DWORD dwSupport; 1119 +} 1120 +alias WAVEOUTCAPSW* PWAVEOUTCAPSW, LPWAVEOUTCAPSW; 1121 + 1122 +struct WAVEINCAPSA { 1123 + WORD wMid; 1124 + WORD wPid; 1125 + MMVERSION vDriverVersion; 1126 + CHAR szPname[MAXPNAMELEN]; 1127 + DWORD dwFormats; 1128 + WORD wChannels; 1129 + WORD wReserved1; 1130 +} 1131 +alias WAVEINCAPSA* PWAVEINCAPSA, LPWAVEINCAPSA; 1132 + 1133 +struct WAVEINCAPSW { 1134 + WORD wMid; 1135 + WORD wPid; 1136 + MMVERSION vDriverVersion; 1137 + WCHAR szPname[MAXPNAMELEN]; 1138 + DWORD dwFormats; 1139 + WORD wChannels; 1140 + WORD wReserved1; 1141 +} 1142 +alias WAVEINCAPSW* PWAVEINCAPSW, LPWAVEINCAPSW; 1143 + 1144 +struct WAVEFORMAT { 1145 + WORD wFormatTag; 1146 + WORD nChannels; 1147 + DWORD nSamplesPerSec; 1148 + DWORD nAvgBytesPerSec; 1149 + WORD nBlockAlign; 1150 +} 1151 +alias WAVEFORMAT* PWAVEFORMAT, LPWAVEFORMAT; 1152 + 1153 +struct PCMWAVEFORMAT { 1154 + WAVEFORMAT wf; 1155 + WORD wBitsPerSample; 1156 +} 1157 +alias PCMWAVEFORMAT* PPCMWAVEFORMAT, LPPCMWAVEFORMAT; 1158 + 1159 +struct WAVEFORMATEX { 1160 + WORD wFormatTag; 1161 + WORD nChannels; 1162 + DWORD nSamplesPerSec; 1163 + DWORD nAvgBytesPerSec; 1164 + WORD nBlockAlign; 1165 + WORD wBitsPerSample; 1166 + WORD cbSize; 1167 +} 1168 +alias WAVEFORMATEX* PWAVEFORMATEX, LPWAVEFORMATEX; 1169 +alias CPtr!(WAVEFORMATEX) LPCWAVEFORMATEX; 1170 + 1171 +alias HANDLE HMIDI; 1172 +alias HANDLE HMIDIIN; 1173 +alias HANDLE HMIDIOUT; 1174 +alias HANDLE HMIDISTRM; 1175 + 830 1176 alias HMIDI* LPHMIDI; 831 1177 alias HMIDIIN* LPHMIDIIN; 832 1178 alias HMIDIOUT* LPHMIDIOUT; 833 1179 alias HMIDISTRM* LPHMIDISTRM; 834 -// typedef DRVCALLBACK MIDICALLBACK; 835 -alias LPDRVCALLBACK LPMIDICALLBACK; 836 -enum : uint { MIDIPATCHSIZE = 128 } 1180 + 837 1181 alias WORD PATCHARRAY[MIDIPATCHSIZE]; 838 1182 alias WORD* LPPATCHARRAY; 839 1183 alias WORD KEYARRAY[MIDIPATCHSIZE]; 840 1184 alias WORD* LPKEYARRAY; 841 1185 842 -alias MM_MIM_OPEN MIM_OPEN; 843 -alias MM_MIM_CLOSE MIM_CLOSE; 844 -alias MM_MIM_DATA MIM_DATA; 845 -alias MM_MIM_LONGDATA MIM_LONGDATA; 846 -alias MM_MIM_ERROR MIM_ERROR; 847 -alias MM_MIM_LONGERROR MIM_LONGERROR; 848 -alias MM_MOM_OPEN MOM_OPEN; 849 -alias MM_MOM_CLOSE MOM_CLOSE; 850 -alias MM_MOM_DONE MOM_DONE; 851 - 852 -// #if(WINVER >= 0x0400) 853 -alias MM_MIM_MOREDATA MIM_MOREDATA; 854 -alias MM_MOM_POSITIONCB MOM_POSITIONCB; 855 -// #endif /* WINVER >= 0x0400 */ 856 - 857 -enum : uint { MIDIMAPPER = cast(UINT)-1 } 858 -enum : uint { MIDI_MAPPER = cast(UINT)-1 } 1186 +struct MIDIOUTCAPSA { 1187 + WORD wMid; 1188 + WORD wPid; 1189 + MMVERSION vDriverVersion; 1190 + CHAR szPname[MAXPNAMELEN]; 1191 + WORD wTechnology; 1192 + WORD wVoices; 1193 + WORD wNotes; 1194 + WORD wChannelMask; 1195 + DWORD dwSupport; 1196 +} 1197 +alias MIDIOUTCAPSA* PMIDIOUTCAPSA, LPMIDIOUTCAPSA; 1198 + 1199 +struct MIDIOUTCAPSW { 1200 + WORD wMid; 1201 + WORD wPid; 1202 + MMVERSION vDriverVersion; 1203 + WCHAR szPname[MAXPNAMELEN]; 1204 + WORD wTechnology; 1205 + WORD wVoices; 1206 + WORD wNotes; 1207 + WORD wChannelMask; 1208 + DWORD dwSupport; 1209 +} 1210 +alias MIDIOUTCAPSW* PMIDIOUTCAPSW, LPMIDIOUTCAPSW; 1211 + 1212 +struct MIDIINCAPSA { 1213 + WORD wMid; 1214 + WORD wPid; 1215 + MMVERSION vDriverVersion; 1216 + CHAR szPname[MAXPNAMELEN]; 1217 + DWORD dwSupport; 1218 +} 1219 +alias MIDIINCAPSA* PMIDIINCAPSA, LPMIDIINCAPSA; 1220 + 1221 +struct MIDIINCAPSW { 1222 + WORD wMid; 1223 + WORD wPid; 1224 + MMVERSION vDriverVersion; 1225 + WCHAR szPname[MAXPNAMELEN]; 1226 + DWORD dwSupport; 1227 +} 1228 +alias MIDIINCAPSW* PMIDIINCAPSW, LPMIDIINCAPSW; 1229 + 1230 +struct MIDIHDR { 1231 + LPSTR lpData; 1232 + DWORD dwBufferLength; 1233 + DWORD dwBytesRecorded; 1234 + DWORD dwUser; 1235 + DWORD dwFlags; 1236 + MIDIHDR *lpNext; 1237 + DWORD reserved; 1238 + DWORD dwOffset; 1239 + DWORD dwReserved[8]; 1240 +} 1241 +alias MIDIHDR* PMIDIHDR, LPMIDIHDR; 1242 + 1243 +struct MIDIEVENT { 1244 + DWORD dwDeltaTime; 1245 + DWORD dwStreamID; 1246 + DWORD dwEvent; 1247 + DWORD dwParms[1]; 1248 +} 1249 + 1250 +struct MIDISTRMBUFFVER { 1251 + DWORD dwVersion; 1252 + DWORD dwMid; 1253 + DWORD dwOEMVersion; 1254 +} 1255 + 1256 +struct MIDIPROPTIMEDIV { 1257 + DWORD cbStruct; 1258 + DWORD dwTimeDiv; 1259 +} 1260 +alias MIDIPROPTIMEDIV* LPMIDIPROPTIMEDIV; 1261 + 1262 +struct MIDIPROPTEMPO { 1263 + DWORD cbStruct; 1264 + DWORD dwTempo; 1265 +} 1266 +alias MIDIPROPTEMPO* LPMIDIPROPTEMPO; 1267 + 1268 +struct AUXCAPSA { 1269 + WORD wMid; 1270 + WORD wPid; 1271 + MMVERSION vDriverVersion; 1272 + CHAR szPname[MAXPNAMELEN]; 1273 + WORD wTechnology; 1274 + WORD wReserved1; 1275 + DWORD dwSupport; 1276 +} 1277 +alias AUXCAPSA* PAUXCAPSA, LPAUXCAPSA; 1278 + 1279 +struct AUXCAPSW { 1280 + WORD wMid; 1281 + WORD wPid; 1282 + MMVERSION vDriverVersion; 1283 + WCHAR szPname[MAXPNAMELEN]; 1284 + WORD wTechnology; 1285 + WORD wReserved1; 1286 + DWORD dwSupport; 1287 +} 1288 +alias AUXCAPSW* PAUXCAPSW, LPAUXCAPSW; 1289 + 1290 +alias HANDLE HMIXEROBJ; 1291 +alias HMIXEROBJ* LPHMIXEROBJ; 1292 + 1293 +alias HANDLE HMIXER; 1294 +alias HMIXER* LPHMIXER; 1295 + 1296 +struct MIXERCAPSA { 1297 + WORD wMid; 1298 + WORD wPid; 1299 + MMVERSION vDriverVersion; 1300 + CHAR szPname[MAXPNAMELEN]; 1301 + DWORD fdwSupport; 1302 + DWORD cDestinations; 1303 +} 1304 +alias MIXERCAPSA* PMIXERCAPSA, LPMIXERCAPSA; 1305 + 1306 +struct MIXERCAPSW { 1307 + WORD wMid; 1308 + WORD wPid; 1309 + MMVERSION vDriverVersion; 1310 + WCHAR szPname[MAXPNAMELEN]; 1311 + DWORD fdwSupport; 1312 + DWORD cDestinations; 1313 +} 1314 +alias MIXERCAPSW* PMIXERCAPSW, LPMIXERCAPSW; 1315 + 1316 +struct MIXERLINEA { 1317 + DWORD cbStruct; 1318 + DWORD dwDestination; 1319 + DWORD dwSource; 1320 + DWORD dwLineID; 1321 + DWORD fdwLine; 1322 + DWORD dwUser; 1323 + DWORD dwComponentType; 1324 + DWORD cChannels; 1325 + DWORD cConnections; 1326 + DWORD cControls; 1327 + CHAR szShortName[MIXER_SHORT_NAME_CHARS]; 1328 + CHAR szName[MIXER_LONG_NAME_CHARS]; 1329 + struct Target { 1330 + DWORD dwType; 1331 + DWORD dwDeviceID; 1332 + WORD wMid; 1333 + WORD wPid; 1334 + MMVERSION vDriverVersion; 1335 + CHAR szPname[MAXPNAMELEN]; 1336 + } 1337 +} 1338 +alias MIXERLINEA* PMIXERLINEA, LPMIXERLINEA; 1339 + 1340 +struct MIXERLINEW { 1341 + DWORD cbStruct; 1342 + DWORD dwDestination; 1343 + DWORD dwSource; 1344 + DWORD dwLineID; 1345 + DWORD fdwLine; 1346 + DWORD dwUser; 1347 + DWORD dwComponentType; 1348 + DWORD cChannels; 1349 + DWORD cConnections; 1350 + DWORD cControls; 1351 + WCHAR szShortName[MIXER_SHORT_NAME_CHARS]; 1352 + WCHAR szName[MIXER_LONG_NAME_CHARS]; 1353 + struct Target { 1354 + DWORD dwType; 1355 + DWORD dwDeviceID; 1356 + WORD wMid; 1357 + WORD wPid; 1358 + MMVERSION vDriverVersion; 1359 + WCHAR szPname[MAXPNAMELEN]; 1360 + } 1361 +} 1362 +alias MIXERLINEW* PMIXERLINEW, LPMIXERLINEW; 1363 + 1364 +struct MIXERCONTROLA { 1365 + DWORD cbStruct; 1366 + DWORD dwControlID; 1367 + DWORD dwControlType; 1368 + DWORD fdwControl; 1369 + DWORD cMultipleItems; 1370 + CHAR szShortName[MIXER_SHORT_NAME_CHARS]; 1371 + CHAR szName[MIXER_LONG_NAME_CHARS]; 1372 + union _Bounds { 1373 + struct { 1374 + LONG lMinimum; 1375 + LONG lMaximum; 1376 + } 1377 + struct { 1378 + DWORD dwMinimum; 1379 + DWORD dwMaximum; 1380 + } 1381 + DWORD dwReserved[6]; 1382 + } 1383 + _Bounds Bounds; 1384 + union _Metrics { 1385 + DWORD cSteps; 1386 + DWORD cbCustomData; 1387 + DWORD dwReserved[6]; 1388 + } 1389 + _Metrics Metrics; 1390 +} 1391 +alias MIXERCONTROLA* PMIXERCONTROLA, LPMIXERCONTROLA; 1392 + 1393 +struct MIXERCONTROLW { 1394 + DWORD cbStruct; 1395 + DWORD dwControlID; 1396 + DWORD dwControlType; 1397 + DWORD fdwControl; 1398 + DWORD cMultipleItems; 1399 + WCHAR szShortName[MIXER_SHORT_NAME_CHARS]; 1400 + WCHAR szName[MIXER_LONG_NAME_CHARS]; 1401 + union _Bounds { 1402 + struct { 1403 + LONG lMinimum; 1404 + LONG lMaximum; 1405 + } 1406 + struct { 1407 + DWORD dwMinimum; 1408 + DWORD dwMaximum; 1409 + } 1410 + DWORD dwReserved[6]; 1411 + } 1412 + _Bounds Bounds; 1413 + union _Metrics { 1414 + DWORD cSteps; 1415 + DWORD cbCustomData; 1416 + DWORD dwReserved[6]; 1417 + } 1418 + _Metrics Metrics; 1419 +} 1420 + 1421 +alias MIXERCONTROLW* PMIXERCONTROLW, LPMIXERCONTROLW; 1422 + 1423 +struct MIXERLINECONTROLSA { 1424 + DWORD cbStruct; 1425 + DWORD dwLineID; 1426 + union { 1427 + DWORD dwControlID; 1428 + DWORD dwControlType; 1429 + } 1430 + DWORD cControls; 1431 + DWORD cbmxctrl; 1432 + LPMIXERCONTROLA pamxctrl; 1433 +} 1434 +alias MIXERLINECONTROLSA* PMIXERLINECONTROLSA, LPMIXERLINECONTROLSA; 1435 + 1436 +struct MIXERLINECONTROLSW { 1437 + DWORD cbStruct; 1438 + DWORD dwLineID; 1439 + union { 1440 + DWORD dwControlID; 1441 + DWORD dwControlType; 1442 + } 1443 + DWORD cControls; 1444 + DWORD cbmxctrl; 1445 + LPMIXERCONTROLW pamxctrl; 1446 +} 1447 +alias MIXERLINECONTROLSW* PMIXERLINECONTROLSW, LPMIXERLINECONTROLSW; 1448 + 1449 +struct MIXERCONTROLDETAILS { 1450 + DWORD cbStruct; 1451 + DWORD dwControlID; 1452 + DWORD cChannels; 1453 + union { 1454 + HWND hwndOwner; 1455 + DWORD cMultipleItems; 1456 + } 1457 + DWORD cbDetails; 1458 + PVOID paDetails; 1459 +} 1460 +alias MIXERCONTROLDETAILS* PMIXERCONTROLDETAILS, LPMIXERCONTROLDETAILS; 1461 + 1462 +struct MIXERCONTROLDETAILS_LISTTEXTA { 1463 + DWORD dwParam1; 1464 + DWORD dwParam2; 1465 + CHAR szName[MIXER_LONG_NAME_CHARS]; 1466 +} 1467 +alias MIXERCONTROLDETAILS_LISTTEXTA* PMIXERCONTROLDETAILS_LISTTEXTA,LPMIXERCONTROLDETAILS_LISTTEXTA; 1468 + 1469 +struct MIXERCONTROLDETAILS_LISTTEXTW { 1470 + DWORD dwParam1; 1471 + DWORD dwParam2; 1472 + WCHAR szName[MIXER_LONG_NAME_CHARS]; 1473 +} 1474 +alias MIXERCONTROLDETAILS_LISTTEXTW* PMIXERCONTROLDETAILS_LISTTEXTW,LPMIXERCONTROLDETAILS_LISTTEXTW; 1475 + 1476 +struct MIXERCONTROLDETAILS_BOOLEAN { 1477 + LONG fValue; 1478 +} 1479 +alias MIXERCONTROLDETAILS_BOOLEAN* PMIXERCONTROLDETAILS_BOOLEAN, LPMIXERCONTROLDETAILS_BOOLEAN; 1480 + 1481 +struct MIXERCONTROLDETAILS_SIGNED { 1482 + LONG lValue; 1483 +} 1484 +alias MIXERCONTROLDETAILS_SIGNED* PMIXERCONTROLDETAILS_SIGNED, LPMIXERCONTROLDETAILS_SIGNED; 1485 + 1486 +struct MIXERCONTROLDETAILS_UNSIGNED { 1487 + DWORD dwValue; 1488 +} 1489 +alias MIXERCONTROLDETAILS_UNSIGNED* PMIXERCONTROLDETAILS_UNSIGNED, LPMIXERCONTROLDETAILS_UNSIGNED; 1490 + 1491 +alias void function (UINT,UINT,DWORD,DWORD,DWORD) LPTIMECALLBACK; 1492 + 1493 +struct TIMECAPS { 1494 + UINT wPeriodMin; 1495 + UINT wPeriodMax; 1496 +} 1497 +alias TIMECAPS* PTIMECAPS, LPTIMECAPS; 1498 + 1499 +struct JOYCAPSA { 1500 + WORD wMid; 1501 + WORD wPid; 1502 + CHAR szPname[MAXPNAMELEN]; 1503 + UINT wXmin; 1504 + UINT wXmax; 1505 + UINT wYmin; 1506 + UINT wYmax; 1507 + UINT wZmin; 1508 + UINT wZmax; 1509 + UINT wNumButtons; 1510 + UINT wPeriodMin; 1511 + UINT wPeriodMax; 1512 + UINT wRmin; 1513 + UINT wRmax; 1514 + UINT wUmin; 1515 + UINT wUmax; 1516 + UINT wVmin; 1517 + UINT wVmax; 1518 + UINT wCaps; 1519 + UINT wMaxAxes; 1520 + UINT wNumAxes; 1521 + UINT wMaxButtons; 1522 + CHAR szRegKey[MAXPNAMELEN]; 1523 + CHAR szOEMVxD[MAX_JOYSTICKOEMVXDNAME]; 1524 +} 1525 +alias JOYCAPSA* PJOYCAPSA, LPJOYCAPSA; 1526 + 1527 +struct JOYCAPSW { 1528 + WORD wMid; 1529 + WORD wPid; 1530 + WCHAR szPname[MAXPNAMELEN]; 1531 + UINT wXmin; 1532 + UINT wXmax; 1533 + UINT wYmin; 1534 + UINT wYmax; 1535 + UINT wZmin; 1536 + UINT wZmax; 1537 + UINT wNumButtons; 1538 + UINT wPeriodMin; 1539 + UINT wPeriodMax; 1540 + UINT wRmin; 1541 + UINT wRmax; 1542 + UINT wUmin; 1543 + UINT wUmax; 1544 + UINT wVmin; 1545 + UINT wVmax; 1546 + UINT wCaps; 1547 + UINT wMaxAxes; 1548 + UINT wNumAxes; 1549 + UINT wMaxButtons; 1550 + WCHAR szRegKey[MAXPNAMELEN]; 1551 + WCHAR szOEMVxD[MAX_JOYSTICKOEMVXDNAME]; 1552 +} 1553 +alias JOYCAPSW* PJOYCAPSW, LPJOYCAPSW; 1554 + 1555 +struct JOYINFO { 1556 + UINT wXpos; 1557 + UINT wYpos; 1558 + UINT wZpos; 1559 + UINT wButtons; 1560 +} 1561 +alias JOYINFO* PJOYINFO, LPJOYINFO; 1562 + 1563 +struct JOYINFOEX { 1564 + DWORD dwSize; 1565 + DWORD dwFlags; 1566 + DWORD dwXpos; 1567 + DWORD dwYpos; 1568 + DWORD dwZpos; 1569 + DWORD dwRpos; 1570 + DWORD dwUpos; 1571 + DWORD dwVpos; 1572 + DWORD dwButtons; 1573 + DWORD dwButtonNumber; 1574 + DWORD dwPOV; 1575 + DWORD dwReserved1; 1576 + DWORD dwReserved2; 1577 +} 1578 +alias JOYINFOEX* PJOYINFOEX, LPJOYINFOEX; 1579 + 1580 +alias DWORD FOURCC; 1581 +alias char* HPSTR; 1582 + 1583 +alias HANDLE HMMIO; 1584 + 1585 +alias LRESULT function (LPSTR,UINT,LPARAM,LPARAM) LPMMIOPROC; 1586 + 1587 +struct MMIOINFO { 1588 + DWORD dwFlags; 1589 + FOURCC fccIOProc; 1590 + LPMMIOPROC pIOProc; 1591 + UINT wErrorRet; 1592 + HTASK htask; 1593 + LONG cchBuffer; 1594 + HPSTR pchBuffer; 1595 + HPSTR pchNext; 1596 + HPSTR pchEndRead; 1597 + HPSTR pchEndWrite; 1598 + LONG lBufOffset; 1599 + LONG lDiskOffset; 1600 + DWORD adwInfo[3]; 1601 + DWORD dwReserved1; 1602 + DWORD dwReserved2; 1603 + HMMIO hmmio; 1604 +} 1605 +alias MMIOINFO* PMMIOINFO, LPMMIOINFO; 1606 +alias CPtr!(MMIOINFO) LPCMMIOINFO; 1607 + 1608 +struct MMCKINFO { 1609 + FOURCC ckid; 1610 + DWORD cksize; 1611 + FOURCC fccType; 1612 + DWORD dwDataOffset; 1613 + DWORD dwFlags; 1614 +} 1615 +alias MMCKINFO* PMMCKINFO, LPMMCKINFO; 1616 +alias CPtr!(MMCKINFO) LPCMMCKINFO; 1617 + 1618 +struct MCI_GENERIC_PARMS { 1619 + DWORD dwCallback; 1620 +} 1621 +alias MCI_GENERIC_PARMS* PMCI_GENERIC_PARMS, LPMCI_GENERIC_PARMS; 1622 + 1623 +struct MCI_OPEN_PARMSA { 1624 + DWORD dwCallback; 1625 + MCIDEVICEID wDeviceID; 1626 + LPCSTR lpstrDeviceType; 1627 + LPCSTR lpstrElementName; 1628 + LPCSTR lpstrAlias; 1629 +} 1630 +alias MCI_OPEN_PARMSA* PMCI_OPEN_PARMSA, LPMCI_OPEN_PARMSA; 1631 + 1632 +struct MCI_OPEN_PARMSW { 1633 + DWORD dwCallback; 1634 + MCIDEVICEID wDeviceID; 1635 + LPCWSTR lpstrDeviceType; 1636 + LPCWSTR lpstrElementName; 1637 + LPCWSTR lpstrAlias; 1638 +} 1639 +alias MCI_OPEN_PARMSW* PMCI_OPEN_PARMSW, LPMCI_OPEN_PARMSW; 1640 + 1641 +struct MCI_PLAY_PARMS { 1642 + DWORD dwCallback; 1643 + DWORD dwFrom; 1644 + DWORD dwTo; 1645 +} 1646 +alias MCI_PLAY_PARMS* PMCI_PLAY_PARMS, LPMCI_PLAY_PARMS; 1647 + 1648 +struct MCI_SEEK_PARMS { 1649 + DWORD dwCallback; 1650 + DWORD dwTo; 1651 +} 1652 +alias MCI_SEEK_PARMS* PMCI_SEEK_PARMS, LPMCI_SEEK_PARMS; 1653 + 1654 +struct MCI_STATUS_PARMS { 1655 + DWORD dwCallback; 1656 + DWORD dwReturn; 1657 + DWORD dwItem; 1658 + DWORD dwTrack; 1659 +} 1660 +alias MCI_STATUS_PARMS* PMCI_STATUS_PARMS, LPMCI_STATUS_PARMS; 1661 + 1662 +struct MCI_INFO_PARMSA { 1663 + DWORD dwCallback; 1664 + LPSTR lpstrReturn; 1665 + DWORD dwRetSize; 1666 +} 1667 +alias MCI_INFO_PARMSA* LPMCI_INFO_PARMSA; 1668 + 1669 +struct MCI_INFO_PARMSW { 1670 + DWORD dwCallback; 1671 + LPWSTR lpstrReturn; 1672 + DWORD dwRetSize; 1673 +} 1674 +alias MCI_INFO_PARMSW* LPMCI_INFO_PARMSW; 1675 + 1676 +struct MCI_GETDEVCAPS_PARMS { 1677 + DWORD dwCallback; 1678 + DWORD dwReturn; 1679 + DWORD dwItem; 1680 +} 1681 +alias MCI_GETDEVCAPS_PARMS* PMCI_GETDEVCAPS_PARMS, LPMCI_GETDEVCAPS_PARMS; 1682 + 1683 +struct MCI_SYSINFO_PARMSA { 1684 + DWORD dwCallback; 1685 + LPSTR lpstrReturn; 1686 + DWORD dwRetSize; 1687 + DWORD dwNumber; 1688 + UINT wDeviceType; 1689 +} 1690 +alias MCI_SYSINFO_PARMSA* PMCI_SYSINFO_PARMSA, LPMCI_SYSINFO_PARMSA; 1691 + 1692 +struct MCI_SYSINFO_PARMSW { 1693 + DWORD dwCallback; 1694 + LPWSTR lpstrReturn; 1695 + DWORD dwRetSize; 1696 + DWORD dwNumber; 1697 + UINT wDeviceType; 1698 +} 1699 +alias MCI_SYSINFO_PARMSW* PMCI_SYSINFO_PARMSW, LPMCI_SYSINFO_PARMSW; 1700 + 1701 +struct MCI_SET_PARMS { 1702 + DWORD dwCallback; 1703 + DWORD dwTimeFormat; 1704 + DWORD dwAudio; 1705 +} 1706 +alias MCI_SET_PARMS* PMCI_SET_PARMS, LPMCI_SET_PARMS; 1707 + 1708 +struct MCI_BREAK_PARMS { 1709 + DWORD dwCallback; 1710 + int nVirtKey; 1711 + HWND hwndBreak; 1712 +} 1713 +alias MCI_BREAK_PARMS* PMCI_BREAK_PARMS, LPMCI_BREAK_PARMS; 1714 + 1715 +struct MCI_SAVE_PARMSA { 1716 + DWORD dwCallback; 1717 + LPCSTR lpfilename; 1718 +} 1719 +alias MCI_SAVE_PARMSA* PMCI_SAVE_PARMSA, LPMCI_SAVE_PARMSA; 1720 + 1721 +struct MCI_SAVE_PARMSW { 1722 + DWORD dwCallback; 1723 + LPCWSTR lpfilename; 1724 +} 1725 +alias MCI_SAVE_PARMSW* PMCI_SAVE_PARMSW, LPMCI_SAVE_PARMSW; 1726 + 1727 +struct MCI_LOAD_PARMSA { 1728 + DWORD dwCallback; 1729 + LPCSTR lpfilename; 1730 +} 1731 +alias MCI_LOAD_PARMSA* PMCI_LOAD_PARMSA, LPMCI_LOAD_PARMSA; 1732 + 1733 +struct MCI_LOAD_PARMSW { 1734 + DWORD dwCallback; 1735 + LPCWSTR lpfilename; 1736 +} 1737 +alias MCI_LOAD_PARMSW* PMCI_LOAD_PARMSW, LPMCI_LOAD_PARMSW; 1738 + 1739 +struct MCI_RECORD_PARMS { 1740 + DWORD dwCallback; 1741 + DWORD dwFrom; 1742 + DWORD dwTo; 1743 +} 1744 +alias MCI_RECORD_PARMS* LPMCI_RECORD_PARMS; 1745 + 1746 +struct MCI_VD_PLAY_PARMS { 1747 + DWORD dwCallback; 1748 + DWORD dwFrom; 1749 + DWORD dwTo; 1750 + DWORD dwSpeed; 1751 +} 1752 +alias MCI_VD_PLAY_PARMS* PMCI_VD_PLAY_PARMS, LPMCI_VD_PLAY_PARMS; 1753 + 1754 +struct MCI_VD_STEP_PARMS { 1755 + DWORD dwCallback; 1756 + DWORD dwFrames; 1757 +} 1758 +alias MCI_VD_STEP_PARMS* PMCI_VD_STEP_PARMS, LPMCI_VD_STEP_PARMS; 1759 + 1760 +struct MCI_VD_ESCAPE_PARMSA { 1761 + DWORD dwCallback; 1762 + LPCSTR lpstrCommand; 1763 +} 1764 +alias MCI_VD_ESCAPE_PARMSA* PMCI_VD_ESCAPE_PARMSA, LPMCI_VD_ESCAPE_PARMSA; 1765 + 1766 +struct MCI_VD_ESCAPE_PARMSW { 1767 + DWORD dwCallback; 1768 + LPCWSTR lpstrCommand; 1769 +} 1770 +alias MCI_VD_ESCAPE_PARMSW* PMCI_VD_ESCAPE_PARMSW, LPMCI_VD_ESCAPE_PARMSW; 1771 + 1772 +struct MCI_WAVE_OPEN_PARMSA { 1773 + DWORD dwCallback; 1774 + MCIDEVICEID wDeviceID; 1775 + LPCSTR lpstrDeviceType; 1776 + LPCSTR lpstrElementName; 1777 + LPCSTR lpstrAlias; 1778 + DWORD dwBufferSeconds; 1779 +} 1780 +alias MCI_WAVE_OPEN_PARMSA* PMCI_WAVE_OPEN_PARMSA, LPMCI_WAVE_OPEN_PARMSA; 1781 + 1782 +struct MCI_WAVE_OPEN_PARMSW { 1783 + DWORD dwCallback; 1784 + MCIDEVICEID wDeviceID; 1785 + LPCWSTR lpstrDeviceType; 1786 + LPCWSTR lpstrElementName; 1787 + LPCWSTR lpstrAlias; 1788 + DWORD dwBufferSeconds; 1789 +} 1790 +alias MCI_WAVE_OPEN_PARMSW* PMCI_WAVE_OPEN_PARMSW, LPMCI_WAVE_OPEN_PARMSW; 1791 + 1792 +struct MCI_WAVE_DELETE_PARMS { 1793 + DWORD dwCallback; 1794 + DWORD dwFrom; 1795 + DWORD dwTo; 1796 +} 1797 +alias MCI_WAVE_DELETE_PARMS* PMCI_WAVE_DELETE_PARMS, LPMCI_WAVE_DELETE_PARMS; 1798 + 1799 +struct MCI_WAVE_SET_PARMS { 1800 + DWORD dwCallback; 1801 + DWORD dwTimeFormat; 1802 + DWORD dwAudio; 1803 + UINT wInput; 1804 + UINT wOutput; 1805 + WORD wFormatTag; 1806 + WORD wReserved2; 1807 + WORD nChannels; 1808 + WORD wReserved3; 1809 + DWORD nSamplesPerSec; 1810 + DWORD nAvgBytesPerSec; 1811 + WORD nBlockAlign; 1812 + WORD wReserved4; 1813 + WORD wBitsPerSample; 1814 + WORD wReserved5; 1815 +} 1816 +alias MCI_WAVE_SET_PARMS* PMCI_WAVE_SET_PARMS, LPMCI_WAVE_SET_PARMS; 1817 + 1818 +extern (Windows): 1819 +LRESULT CloseDriver(HDRVR,LONG,LONG); 1820 +HDRVR OpenDriver(LPCWSTR,LPCWSTR,LONG); 1821 +LRESULT SendDriverMessage(HDRVR,UINT,LONG,LONG); 1822 +HMODULE DrvGetModuleHandle(HDRVR); 1823 +HMODULE GetDriverModuleHandle(HDRVR); 1824 +LRESULT DefDriverProc(DWORD,HDRVR,UINT,LPARAM,LPARAM); 1825 +UINT mmsystemGetVersion(); 1826 +// FIXME: I believe this next line is a mistake 1827 +//alias OutputDebugString OutputDebugStr; 1828 +BOOL sndPlaySoundA(LPCSTR,UINT); 1829 +BOOL sndPlaySoundW(LPCWSTR,UINT); 1830 +BOOL PlaySoundA(LPCSTR,HMODULE,DWORD); 1831 +BOOL PlaySoundW(LPCWSTR,HMODULE,DWORD); 1832 +UINT waveOutGetNumDevs(); 1833 +MMRESULT waveOutGetDevCapsA(UINT,LPWAVEOUTCAPSA,UINT); 1834 +MMRESULT waveOutGetDevCapsW(UINT,LPWAVEOUTCAPSW,UINT); 1835 +MMRESULT waveOutGetVolume(HWAVEOUT,PDWORD); 1836 +MMRESULT waveOutSetVolume(HWAVEOUT,DWORD); 1837 +MMRESULT waveOutGetErrorTextA(MMRESULT,LPSTR,UINT); 1838 +MMRESULT waveOutGetErrorTextW(MMRESULT,LPWSTR,UINT); 1839 +MMRESULT waveOutOpen(LPHWAVEOUT,UINT,LPCWAVEFORMATEX,DWORD,DWORD,DWORD); 1840 +MMRESULT waveOutClose(HWAVEOUT); 1841 +MMRESULT waveOutPrepareHeader(HWAVEOUT,LPWAVEHDR,UINT); 1842 +MMRESULT waveOutUnprepareHeader(HWAVEOUT,LPWAVEHDR,UINT); 1843 +MMRESULT waveOutWrite(HWAVEOUT,LPWAVEHDR,UINT); 1844 +MMRESULT waveOutPause(HWAVEOUT); 1845 +MMRESULT waveOutRestart(HWAVEOUT); 1846 +MMRESULT waveOutReset(HWAVEOUT); 1847 +MMRESULT waveOutBreakLoop(HWAVEOUT); 1848 +MMRESULT waveOutGetPosition(HWAVEOUT,LPMMTIME,UINT); 1849 +MMRESULT waveOutGetPitch(HWAVEOUT,PDWORD); 1850 +MMRESULT waveOutSetPitch(HWAVEOUT,DWORD); 1851 +MMRESULT waveOutGetPlaybackRate(HWAVEOUT,PDWORD); 1852 +MMRESULT waveOutSetPlaybackRate(HWAVEOUT,DWORD); 1853 +MMRESULT waveOutGetID(HWAVEOUT,LPUINT); 1854 +MMRESULT waveOutMessage(HWAVEOUT,UINT,DWORD,DWORD); 1855 +UINT waveInGetNumDevs(); 1856 +MMRESULT waveInGetDevCapsA(UINT,LPWAVEINCAPSA,UINT); 1857 +MMRESULT waveInGetDevCapsW(UINT,LPWAVEINCAPSW,UINT); 1858 +MMRESULT waveInGetErrorTextA(MMRESULT,LPSTR,UINT); 1859 +MMRESULT waveInGetErrorTextW(MMRESULT,LPWSTR,UINT); 1860 +MMRESULT waveInOpen(LPHWAVEIN,UINT,LPCWAVEFORMATEX,DWORD,DWORD,DWORD); 1861 +MMRESULT waveInClose(HWAVEIN); 1862 +MMRESULT waveInPrepareHeader(HWAVEIN,LPWAVEHDR,UINT); 1863 +MMRESULT waveInUnprepareHeader(HWAVEIN,LPWAVEHDR,UINT); 1864 +MMRESULT waveInAddBuffer(HWAVEIN,LPWAVEHDR,UINT); 1865 +MMRESULT waveInStart(HWAVEIN); 1866 +MMRESULT waveInStop(HWAVEIN); 1867 +MMRESULT waveInReset(HWAVEIN); 1868 +MMRESULT waveInGetPosition(HWAVEIN,LPMMTIME,UINT); 1869 +MMRESULT waveInGetID(HWAVEIN,LPUINT); 1870 +MMRESULT waveInMessage(HWAVEIN,UINT,DWORD,DWORD); 1871 +UINT midiOutGetNumDevs(); 1872 +MMRESULT midiStreamOpen(LPHMIDISTRM,LPUINT,DWORD,DWORD,DWORD,DWORD); 1873 +MMRESULT midiStreamClose(HMIDISTRM); 1874 +MMRESULT midiStreamProperty(HMIDISTRM,LPBYTE,DWORD); 1875 +MMRESULT midiStreamPosition(HMIDISTRM,LPMMTIME,UINT); 1876 +MMRESULT midiStreamOut(HMIDISTRM,LPMIDIHDR,UINT); 1877 +MMRESULT midiStreamPause(HMIDISTRM); 1878 +MMRESULT midiStreamRestart(HMIDISTRM); 1879 +MMRESULT midiStreamStop(HMIDISTRM); 1880 +MMRESULT midiConnect(HMIDI,HMIDIOUT,PVOID); 1881 +MMRESULT midiDisconnect(HMIDI,HMIDIOUT,PVOID); 1882 +MMRESULT midiOutGetDevCapsA(UINT,LPMIDIOUTCAPSA,UINT); 1883 +MMRESULT midiOutGetDevCapsW(UINT,LPMIDIOUTCAPSW,UINT); 1884 +MMRESULT midiOutGetVolume(HMIDIOUT,PDWORD); 1885 +MMRESULT midiOutSetVolume(HMIDIOUT,DWORD); 1886 +MMRESULT midiOutGetErrorTextA(MMRESULT,LPSTR,UINT); 1887 +MMRESULT midiOutGetErrorTextW(MMRESULT,LPWSTR,UINT); 1888 +MMRESULT midiOutOpen(LPHMIDIOUT,UINT,DWORD,DWORD,DWORD); 1889 +MMRESULT midiOutClose(HMIDIOUT); 1890 +MMRESULT midiOutPrepareHeader(HMIDIOUT,LPMIDIHDR,UINT); 1891 +MMRESULT midiOutUnprepareHeader(HMIDIOUT,LPMIDIHDR,UINT); 1892 +MMRESULT midiOutShortMsg(HMIDIOUT,DWORD); 1893 +MMRESULT midiOutLongMsg(HMIDIOUT,LPMIDIHDR,UINT); 1894 +MMRESULT midiOutReset(HMIDIOUT); 1895 +MMRESULT midiOutCachePatches(HMIDIOUT,UINT,LPWORD,UINT); 1896 +MMRESULT midiOutCacheDrumPatches(HMIDIOUT,UINT,LPWORD,UINT); 1897 +MMRESULT midiOutGetID(HMIDIOUT,LPUINT); 1898 +MMRESULT midiOutMessage(HMIDIOUT,UINT,DWORD,DWORD); 1899 +UINT midiInGetNumDevs(); 1900 +MMRESULT midiInGetDevCapsA(UINT,LPMIDIINCAPSA,UINT); 1901 +MMRESULT midiInGetDevCapsW(UINT,LPMIDIINCAPSW,UINT); 1902 +MMRESULT midiInGetErrorTextA(MMRESULT,LPSTR,UINT); 1903 +MMRESULT midiInGetErrorTextW(MMRESULT,LPWSTR,UINT); 1904 +MMRESULT midiInOpen(LPHMIDIIN,UINT,DWORD,DWORD,DWORD); 1905 +MMRESULT midiInClose(HMIDIIN); 1906 +MMRESULT midiInPrepareHeader(HMIDIIN,LPMIDIHDR,UINT); 1907 +MMRESULT midiInUnprepareHeader(HMIDIIN,LPMIDIHDR,UINT); 1908 +MMRESULT midiInAddBuffer(HMIDIIN,LPMIDIHDR,UINT); 1909 +MMRESULT midiInStart(HMIDIIN); 1910 +MMRESULT midiInStop(HMIDIIN); 1911 +MMRESULT midiInReset(HMIDIIN); 1912 +MMRESULT midiInGetID(HMIDIIN,LPUINT); 1913 +MMRESULT midiInMessage(HMIDIIN,UINT,DWORD,DWORD); 1914 +UINT auxGetNumDevs(); 1915 +MMRESULT auxGetDevCapsA(UINT,LPAUXCAPSA,UINT); 1916 +MMRESULT auxGetDevCapsW(UINT,LPAUXCAPSW,UINT); 1917 +MMRESULT auxSetVolume(UINT,DWORD); 1918 +MMRESULT auxGetVolume(UINT,PDWORD); 1919 +MMRESULT auxOutMessage(UINT,UINT,DWORD,DWORD); 1920 +UINT mixerGetNumDevs(); 1921 +MMRESULT mixerGetDevCapsA(UINT,LPMIXERCAPSA,UINT); 1922 +MMRESULT mixerGetDevCapsW(UINT,LPMIXERCAPSW,UINT); 1923 +MMRESULT mixerOpen(LPHMIXER,UINT,DWORD,DWORD,DWORD); 1924 +MMRESULT mixerClose(HMIXER); 1925 +DWORD mixerMessage(HMIXER,UINT,DWORD,DWORD); 1926 +MMRESULT mixerGetLineInfoA(HMIXEROBJ,LPMIXERLINEA,DWORD); 1927 +MMRESULT mixerGetLineInfoW(HMIXEROBJ,LPMIXERLINEW,DWORD); 1928 +MMRESULT mixerGetID(HMIXEROBJ,PUINT,DWORD); 1929 +MMRESULT mixerGetLineControlsA(HMIXEROBJ,LPMIXERLINECONTROLSA,DWORD); 1930 +MMRESULT mixerGetLineControlsW(HMIXEROBJ,LPMIXERLINECONTROLSW,DWORD); 1931 +MMRESULT mixerGetControlDetailsA(HMIXEROBJ,LPMIXERCONTROLDETAILS,DWORD); 1932 +MMRESULT mixerGetControlDetailsW(HMIXEROBJ,LPMIXERCONTROLDETAILS,DWORD); 1933 +MMRESULT mixerSetControlDetails(HMIXEROBJ,LPMIXERCONTROLDETAILS,DWORD); 1934 +MMRESULT timeGetSystemTime(LPMMTIME,UINT); 1935 +DWORD timeGetTime(); 1936 +MMRESULT timeSetEvent(UINT,UINT,LPTIMECALLBACK,DWORD,UINT); 1937 +MMRESULT timeKillEvent(UINT); 1938 +MMRESULT timeGetDevCaps(LPTIMECAPS,UINT); 1939 +MMRESULT timeBeginPeriod(UINT); 1940 +MMRESULT timeEndPeriod(UINT); 1941 +UINT joyGetNumDevs(); 1942 +MMRESULT joyGetDevCapsA(UINT,LPJOYCAPSA,UINT); 1943 +MMRESULT joyGetDevCapsW(UINT,LPJOYCAPSW,UINT); 1944 +MMRESULT joyGetPos(UINT,LPJOYINFO); 1945 +MMRESULT joyGetPosEx(UINT,LPJOYINFOEX); 1946 +MMRESULT joyGetThreshold(UINT,LPUINT); 1947 +MMRESULT joyReleaseCapture(UINT); 1948 +MMRESULT joySetCapture(HWND,UINT,UINT,BOOL); 1949 +MMRESULT joySetThreshold(UINT,UINT); 1950 +FOURCC mmioStringToFOURCCA(LPCSTR,UINT); 1951 +FOURCC mmioStringToFOURCCW(LPCWSTR,UINT); 1952 +LPMMIOPROC mmioInstallIOProcA(FOURCC,LPMMIOPROC,DWORD); 1953 +LPMMIOPROC mmioInstallIOProcW(FOURCC,LPMMIOPROC,DWORD); 1954 +HMMIO mmioOpenA(LPSTR,LPMMIOINFO,DWORD); 1955 +HMMIO mmioOpenW(LPWSTR,LPMMIOINFO,DWORD); 1956 +MMRESULT mmioRenameA(LPCSTR,LPCSTR,LPCMMIOINFO,DWORD); 1957 +MMRESULT mmioRenameW(LPCWSTR,LPCWSTR,LPCMMIOINFO,DWORD); 1958 +MMRESULT mmioClose(HMMIO,UINT); 1959 +LONG mmioRead(HMMIO,HPSTR,LONG); 1960 +LONG mmioWrite(HMMIO,LPCSTR,LONG); 1961 +LONG mmioSeek(HMMIO,LONG,int); 1962 +MMRESULT mmioGetInfo(HMMIO,LPMMIOINFO,UINT); 1963 +MMRESULT mmioSetInfo(HMMIO,LPCMMIOINFO,UINT); 1964 +MMRESULT mmioSetBuffer(HMMIO,LPSTR,LONG,UINT); 1965 +MMRESULT mmioFlush(HMMIO,UINT); 1966 +MMRESULT mmioAdvance(HMMIO,LPMMIOINFO,UINT); 1967 +LRESULT mmioSendMessage(HMMIO,UINT,LPARAM,LPARAM); 1968 +MMRESULT mmioDescend(HMMIO,LPMMCKINFO, CPtr!(MMCKINFO),UINT); 1969 +MMRESULT mmioAscend(HMMIO,LPMMCKINFO,UINT); 1970 +MMRESULT mmioCreateChunk(HMMIO,LPMMCKINFO,UINT); 1971 +MCIERROR mciSendCommandA(MCIDEVICEID,UINT,DWORD,DWORD); 1972 +MCIERROR mciSendCommandW(MCIDEVICEID,UINT,DWORD,DWORD); 1973 +MCIERROR mciSendStringA(LPCSTR,LPSTR,UINT,HWND); 1974 +MCIERROR mciSendStringW(LPCWSTR,LPWSTR,UINT,HWND); 1975 +MCIDEVICEID mciGetDeviceIDA(LPCSTR); 1976 +MCIDEVICEID mciGetDeviceIDW(LPCWSTR); 1977 +MCIDEVICEID mciGetDeviceIDFromElementIDA(DWORD,LPCSTR); 1978 +MCIDEVICEID mciGetDeviceIDFromElementIDW(DWORD,LPCWSTR); 1979 +BOOL mciGetErrorStringA(MCIERROR,LPSTR,UINT); 1980 +BOOL mciGetErrorStringW(MCIERROR,LPWSTR,UINT); 1981 +BOOL mciSetYieldProc(MCIDEVICEID,YIELDPROC,DWORD); 1982 +HTASK mciGetCreatorTask(MCIDEVICEID); 1983 +YIELDPROC mciGetYieldProc(MCIDEVICEID,PDWORD); 1984 + 1985 +struct MCI_SEQ_SET_PARMS { 1986 + DWORD dwCallback; 1987 + DWORD dwTimeFormat; 1988 + DWORD dwAudio; 1989 + DWORD dwTempo; 1990 + DWORD dwPort; 1991 + DWORD dwSlave; 1992 + DWORD dwMaster; 1993 + DWORD dwOffset; 1994 +} 1995 +alias MCI_SEQ_SET_PARMS* PMCI_SEQ_SET_PARMS, LPMCI_SEQ_SET_PARMS; 1996 + 1997 +struct MCI_ANIM_OPEN_PARMSA { 1998 + DWORD dwCallback; 1999 + MCIDEVICEID wDeviceID; 2000 + LPCSTR lpstrDeviceType; 2001 + LPCSTR lpstrElementName; 2002 + LPCSTR lpstrAlias; 2003 + DWORD dwStyle; 2004 + HWND hWndParent; 2005 +} 2006 +alias MCI_ANIM_OPEN_PARMSA* PMCI_ANIM_OPEN_PARMSA, LPMCI_ANIM_OPEN_PARMSA; 2007 + 2008 +struct MCI_ANIM_OPEN_PARMSW { 2009 + DWORD dwCallback; 2010 + MCIDEVICEID wDeviceID; 2011 + LPCWSTR lpstrDeviceType; 2012 + LPCWSTR lpstrElementName; 2013 + LPCWSTR lpstrAlias; 2014 + DWORD dwStyle; 2015 + HWND hWndParent; 2016 +} 2017 +alias MCI_ANIM_OPEN_PARMSW* PMCI_ANIM_OPEN_PARMSW, LPMCI_ANIM_OPEN_PARMSW; 2018 + 2019 +struct MCI_ANIM_PLAY_PARMS { 2020 + DWORD dwCallback; 2021 + DWORD dwFrom; 2022 + DWORD dwTo; 2023 + DWORD dwSpeed; 2024 +} 2025 +alias MCI_ANIM_PLAY_PARMS* PMCI_ANIM_PLAY_PARMS, LPMCI_ANIM_PLAY_PARMS; 2026 + 2027 +struct MCI_ANIM_STEP_PARMS { 2028 + DWORD dwCallback; 2029 + DWORD dwFrames; 2030 +} 2031 +alias MCI_ANIM_STEP_PARMS* PMCI_ANIM_STEP_PARMS, LPMCI_ANIM_STEP_PARMS; 2032 + 2033 +struct MCI_ANIM_WINDOW_PARMSA { 2034 + DWORD dwCallback; 2035 + HWND hWnd; 2036 + UINT nCmdShow; 2037 + LPCSTR lpstrText; 2038 +} 2039 +alias MCI_ANIM_WINDOW_PARMSA* PMCI_ANIM_WINDOW_PARMSA, LPMCI_ANIM_WINDOW_PARMSA; 2040 + 2041 +struct MCI_ANIM_WINDOW_PARMSW { 2042 + DWORD dwCallback; 2043 + HWND hWnd; 2044 + UINT nCmdShow; 2045 + LPCWSTR lpstrText; 2046 +} 2047 +alias MCI_ANIM_WINDOW_PARMSW* PMCI_ANIM_WINDOW_PARMSW, LPMCI_ANIM_WINDOW_PARMSW; 2048 + 2049 +struct MCI_ANIM_RECT_PARMS { 2050 + DWORD dwCallback; 2051 + //#ifdef MCI_USE_OFFEXT 2052 + // POINT ptOffset; 2053 + // POINT ptExtent; 2054 + //#else 2055 + RECT rc; 2056 + //#endif 2057 +} 2058 +alias MCI_ANIM_RECT_PARMS* PMCI_ANIM_RECT_PARMS, LPMCI_ANIM_RECT_PARMS; 2059 + 2060 +struct MCI_ANIM_UPDATE_PARMS { 2061 + DWORD dwCallback; 2062 + RECT rc; 2063 + HDC hDC; 2064 +} 2065 +alias MCI_ANIM_UPDATE_PARMS* PMCI_ANIM_UPDATE_PARMS, LPMCI_ANIM_UPDATE_PARMS; 2066 + 2067 +struct MCI_OVLY_OPEN_PARMSA { 2068 + DWORD dwCallback; 2069 + MCIDEVICEID wDeviceID; 2070 + LPCSTR lpstrDeviceType; 2071 + LPCSTR lpstrElementName; 2072 + LPCSTR lpstrAlias; 2073 + DWORD dwStyle; 2074 + HWND hWndParent; 2075 +} 2076 +alias MCI_OVLY_OPEN_PARMSA* PMCI_OVLY_OPEN_PARMSA, LPMCI_OVLY_OPEN_PARMSA; 2077 + 2078 +struct MCI_OVLY_OPEN_PARMSW { 2079 + DWORD dwCallback; 2080 + MCIDEVICEID wDeviceID; 2081 + LPCWSTR lpstrDeviceType; 2082 + LPCWSTR lpstrElementName; 2083 + LPCWSTR lpstrAlias; 2084 + DWORD dwStyle; 2085 + HWND hWndParent; 2086 +} 2087 +alias MCI_OVLY_OPEN_PARMSW* PMCI_OVLY_OPEN_PARMSW, LPMCI_OVLY_OPEN_PARMSW; 859 2088 860 -// #if(WINVER >= 0x0400) 861 - 862 -enum : uint { MIDI_IO_STATUS = 0x00000020 } 863 -// #endif /* WINVER >= 0x0400 */ 2089 +struct MCI_OVLY_WINDOW_PARMSA { 2090 + DWORD dwCallback; 2091 + HWND hWnd; 2092 + UINT nCmdShow; 2093 + LPCSTR lpstrText; 2094 +} 2095 +alias MCI_OVLY_WINDOW_PARMSA* PMCI_OVLY_WINDOW_PARMSA, LPMCI_OVLY_WINDOW_PARMSA; 864 2096 865 -enum : uint { MIDI_CACHE_ALL = 1 } 866 -enum : uint { MIDI_CACHE_BESTFIT = 2 } 867 -enum : uint { MIDI_CACHE_QUERY = 3 } 868 -enum : uint { MIDI_UNCACHE = 4 } 869 - 870 -// #ifdef _WIN32 871 - 872 -struct tagMIDIOUTCAPSA { 873 - WORD wMid; 874 - WORD wPid; 875 - MMVERSION vDriverVersion; 876 - CHAR szPname[MAXPNAMELEN]; 877 - WORD wTechnology; 878 - WORD wVoices; 879 - WORD wNotes; 880 - WORD wChannelMask; 881 - DWORD dwSupport; 2097 +struct MCI_OVLY_WINDOW_PARMSW { 2098 + DWORD dwCallback; 2099 + HWND hWnd; 2100 + UINT nCmdShow; 2101 + LPCWSTR lpstrText; 882 2102 } 883 -alias tagMIDIOUTCAPSA MIDIOUTCAPSA; 884 -alias tagMIDIOUTCAPSA* PMIDIOUTCAPSA; 885 -alias tagMIDIOUTCAPSA* NPMIDIOUTCAPSA; 886 -alias tagMIDIOUTCAPSA* LPMIDIOUTCAPSA; 2103 +alias MCI_OVLY_WINDOW_PARMSW* PMCI_OVLY_WINDOW_PARMSW, LPMCI_OVLY_WINDOW_PARMSW; 887 2104 888 -struct tagMIDIOUTCAPSW { 889 - WORD wMid; 890 - WORD wPid; 891 - MMVERSION vDriverVersion; 892 - WCHAR szPname[MAXPNAMELEN]; 893 - WORD wTechnology; 894 - WORD wVoices; 895 - WORD wNotes; 896 - WORD wChannelMask; 897 - DWORD dwSupport; 2105 +struct MCI_OVLY_RECT_PARMS { 2106 + DWORD dwCallback; 2107 + //#ifdef MCI_USE_OFFEXT 2108 + // POINT ptOffset; 2109 + // POINT ptExtent; 2110 + //#else 2111 + RECT rc; 2112 + //#endif 898 2113 } 899 -alias tagMIDIOUTCAPSW MIDIOUTCAPSW; 900 -alias tagMIDIOUTCAPSW* PMIDIOUTCAPSW; 901 -alias tagMIDIOUTCAPSW* NPMIDIOUTCAPSW; 902 -alias tagMIDIOUTCAPSW* LPMIDIOUTCAPSW; 2114 +alias MCI_OVLY_RECT_PARMS* PMCI_OVLY_RECT_PARMS, LPMCI_OVLY_RECT_PARMS; 903 2115 904 -// #ifdef UNICODE 905 -alias MIDIOUTCAPSW MIDIOUTCAPS; 906 -alias PMIDIOUTCAPSW PMIDIOUTCAPS; 907 -alias NPMIDIOUTCAPSW NPMIDIOUTCAPS; 908 -alias LPMIDIOUTCAPSW LPMIDIOUTCAPS; 909 -// #else 910 -// ... 911 -// #endif // UNICODE 912 -struct tagMIDIOUTCAPS2A { 913 - WORD wMid; 914 - WORD wPid; 915 - MMVERSION vDriverVersion; 916 - CHAR szPname[MAXPNAMELEN]; 917 - WORD wTechnology; 918 - WORD wVoices; 919 - WORD wNotes; 920 - WORD wChannelMask; 921 - DWORD dwSupport; 922 - GUID ManufacturerGuid; 923 - GUID ProductGuid; 924 - GUID NameGuid; 2116 +struct MCI_OVLY_SAVE_PARMSA { 2117 + DWORD dwCallback; 2118 + LPCSTR lpfilename; 2119 + RECT rc; 925 2120 } 926 -alias tagMIDIOUTCAPS2A MIDIOUTCAPS2A; 927 -alias tagMIDIOUTCAPS2A* PMIDIOUTCAPS2A; 928 -alias tagMIDIOUTCAPS2A* NPMIDIOUTCAPS2A; 929 -alias tagMIDIOUTCAPS2A* LPMIDIOUTCAPS2A; 2121 +alias MCI_OVLY_SAVE_PARMSA* PMCI_OVLY_SAVE_PARMSA, LPMCI_OVLY_SAVE_PARMSA; 930 2122 931 -struct tagMIDIOUTCAPS2W { 932 - WORD wMid; 933 - WORD wPid; 934 - MMVERSION vDriverVersion; 935 - WCHAR szPname[MAXPNAMELEN]; 936 - WORD wTechnology; 937 - WORD wVoices; 938 - WORD wNotes; 939 - WORD wChannelMask; 940 - DWORD dwSupport; 941 - GUID ManufacturerGuid; 942 - GUID ProductGuid; 943 - GUID NameGuid; 944 -} 945 -alias tagMIDIOUTCAPS2W MIDIOUTCAPS2W; 946 -alias tagMIDIOUTCAPS2W* PMIDIOUTCAPS2W; 947 -alias tagMIDIOUTCAPS2W* NPMIDIOUTCAPS2W; 948 -alias tagMIDIOUTCAPS2W* LPMIDIOUTCAPS2W; 949 - 950 -// #ifdef UNICODE 951 -alias MIDIOUTCAPS2W MIDIOUTCAPS2; 952 -alias PMIDIOUTCAPS2W PMIDIOUTCAPS2; 953 -alias NPMIDIOUTCAPS2W NPMIDIOUTCAPS2; 954 -alias LPMIDIOUTCAPS2W LPMIDIOUTCAPS2; 955 -// #else 956 -// ... 957 -// #endif // UNICODE 958 - 959 -// #else 960 -// ... 961 -// #endif 962 - 963 -enum : uint { MOD_MIDIPORT = 1 } 964 -enum : uint { MOD_SYNTH = 2 } 965 -enum : uint { MOD_SQSYNTH = 3 } 966 -enum : uint { MOD_FMSYNTH = 4 } 967 -enum : uint { MOD_MAPPER = 5 } 968 -enum : uint { MOD_WAVETABLE = 6 } 969 -enum : uint { MOD_SWSYNTH = 7 } 970 - 971 -enum : uint { MIDICAPS_VOLUME = 0x0001 } 972 -enum : uint { MIDICAPS_LRVOLUME = 0x0002 } 973 -enum : uint { MIDICAPS_CACHE = 0x0004 } 974 -// #if(WINVER >= 0x0400) 975 -enum : uint { MIDICAPS_STREAM = 0x0008 } 976 -// #endif /* WINVER >= 0x0400 */ 977 - 978 -// #ifdef _WIN32 979 - 980 -struct tagMIDIINCAPSA { 981 - WORD wMid; 982 - WORD wPid; 983 - MMVERSION vDriverVersion; 984 - CHAR szPname[MAXPNAMELEN]; 985 -// #if (WINVER >= 0x0400) 986 - DWORD dwSupport; 987 -// #endif 2123 +struct MCI_OVLY_SAVE_PARMSW { 2124 + DWORD dwCallback; 2125 + LPCWSTR lpfilename; 2126 + RECT rc; 988 2127 } 989 -alias tagMIDIINCAPSA MIDIINCAPSA; 990 -alias tagMIDIINCAPSA* PMIDIINCAPSA; 991 -alias tagMIDIINCAPSA* NPMIDIINCAPSA; 992 -alias tagMIDIINCAPSA* LPMIDIINCAPSA; 2128 +alias MCI_OVLY_SAVE_PARMSW* PMCI_OVLY_SAVE_PARMSW, LPMCI_OVLY_SAVE_PARMSW; 993 2129 994 -struct tagMIDIINCAPSW { 995 - WORD wMid; 996 - WORD wPid; 997 - MMVERSION vDriverVersion; 998 - WCHAR szPname[MAXPNAMELEN]; 999 -// #if (WINVER >= 0x0400) 1000 - DWORD dwSupport; 1001 -// #endif 1002 -} 1003 -alias tagMIDIINCAPSW MIDIINCAPSW; 1004 -alias tagMIDIINCAPSW* PMIDIINCAPSW; 1005 -alias tagMIDIINCAPSW* NPMIDIINCAPSW; 1006 -alias tagMIDIINCAPSW* LPMIDIINCAPSW; 1007 - 1008 -// #ifdef UNICODE 1009 -alias MIDIINCAPSW MIDIINCAPS; 1010 -alias PMIDIINCAPSW PMIDIINCAPS; 1011 -alias NPMIDIINCAPSW NPMIDIINCAPS; 1012 -alias LPMIDIINCAPSW LPMIDIINCAPS; 1013 -// #else 1014 -// ... 1015 -// #endif // UNICODE 1016 -struct tagMIDIINCAPS2A { 1017 - WORD wMid; 1018 - WORD wPid; 1019 - MMVERSION vDriverVersion; 1020 - CHAR szPname[MAXPNAMELEN]; 1021 -// #if (WINVER >= 0x0400) 1022 - DWORD dwSupport; 1023 -// #endif 1024 - GUID ManufacturerGuid; 1025 - GUID ProductGuid; 1026 - GUID NameGuid; 1027 -} 1028 -alias tagMIDIINCAPS2A MIDIINCAPS2A; 1029 -alias tagMIDIINCAPS2A* PMIDIINCAPS2A; 1030 -alias tagMIDIINCAPS2A* NPMIDIINCAPS2A; 1031 -alias tagMIDIINCAPS2A* LPMIDIINCAPS2A; 1032 - 1033 -struct tagMIDIINCAPS2W { 1034 - WORD wMid; 1035 - WORD wPid; 1036 - MMVERSION vDriverVersion; 1037 - WCHAR szPname[MAXPNAMELEN]; 1038 -// #if (WINVER >= 0x0400) 1039 - DWORD dwSupport; 1040 -// #endif 1041 - GUID ManufacturerGuid; 1042 - GUID ProductGuid; 1043 - GUID NameGuid; 1044 -} 1045 -alias tagMIDIINCAPS2W MIDIINCAPS2W; 1046 -alias tagMIDIINCAPS2W* PMIDIINCAPS2W; 1047 -alias tagMIDIINCAPS2W* NPMIDIINCAPS2W; 1048 -alias tagMIDIINCAPS2W* LPMIDIINCAPS2W; 1049 - 1050 -// #ifdef UNICODE 1051 -alias MIDIINCAPS2W MIDIINCAPS2; 1052 -alias PMIDIINCAPS2W PMIDIINCAPS2; 1053 -alias NPMIDIINCAPS2W NPMIDIINCAPS2; 1054 -alias LPMIDIINCAPS2W LPMIDIINCAPS2; 1055 -// #else 1056 -// ... 1057 -// #endif // UNICODE 1058 - 1059 -// #else 1060 -// ... 1061 -// #if (WINVER >= 0x0400) 1062 -// ... 1063 -// #endif 1064 -// ... 1065 -// #endif 1066 - 1067 -struct midihdr_tag { 1068 - LPSTR lpData; 1069 - DWORD dwBufferLength; 1070 - DWORD dwBytesRecorded; 1071 - DWORD_PTR dwUser; 1072 - DWORD dwFlags; 1073 - midihdr_tag *lpNext; 1074 - DWORD_PTR reserved; 1075 -// #if (WINVER >= 0x0400) 1076 - DWORD dwOffset; 1077 - DWORD_PTR dwReserved[8]; 1078 -// #endif 1079 -} 1080 -alias midihdr_tag MIDIHDR; 1081 -alias midihdr_tag* PMIDIHDR; 1082 -alias midihdr_tag* NPMIDIHDR; 1083 -alias midihdr_tag* LPMIDIHDR; 1084 - 1085 -// #if(WINVER >= 0x0400) 1086 -struct midievent_tag { 1087 - DWORD dwDeltaTime; 1088 - DWORD dwStreamID; 1089 - DWORD dwEvent; 1090 - DWORD dwParms[1]; 1091 -} 1092 -alias midievent_tag MIDIEVENT; 1093 - 1094 -struct midistrmbuffver_tag { 1095 - DWORD dwVersion; 1096 - DWORD dwMid; 1097 - DWORD dwOEMVersion; 1098 -} 1099 -alias midistrmbuffver_tag MIDISTRMBUFFVER; 1100 - 1101 -// #endif /* WINVER >= 0x0400 */ 1102 - 1103 -enum : uint { MHDR_DONE = 0x00000001 } 1104 -enum : uint { MHDR_PREPARED = 0x00000002 } 1105 -enum : uint { MHDR_INQUEUE = 0x00000004 } 1106 -enum : uint { MHDR_ISSTRM = 0x00000008 } 1107 -// #if(WINVER >= 0x0400) 1108 - 1109 -enum : uint { MEVT_F_SHORT = 0x00000000 } 1110 -enum : uint { MEVT_F_LONG = 0x80000000 } 1111 -enum : uint { MEVT_F_CALLBACK = 0x40000000 } 1112 - 1113 -// #define MEVT_EVENTTYPE(x) ((BYTE)(((x)>>24)&0xFF)) 1114 -// #define MEVT_EVENTPARM(x) ((DWORD)((x)&0x00FFFFFFL)) 1115 - 1116 -enum : uint { MEVT_SHORTMSG = cast(BYTE)0x00 } 1117 -enum : uint { MEVT_TEMPO = cast(BYTE)0x01 } 1118 -enum : uint { MEVT_NOP = cast(BYTE)0x02 } 1119 - 1120 -enum : uint { MEVT_LONGMSG = cast(BYTE)0x80 } 1121 -enum : uint { MEVT_COMMENT = cast(BYTE)0x82 } 1122 -enum : uint { MEVT_VERSION = cast(BYTE)0x84 } 1123 - 1124 -enum { MIDISTRM_ERROR = -2 } 1125 - 1126 -enum : uint { MIDIPROP_SET = 0x80000000 } 1127 -enum : uint { MIDIPROP_GET = 0x40000000 } 1128 - 1129 -enum : uint { MIDIPROP_TIMEDIV = 0x00000001 } 1130 -enum : uint { MIDIPROP_TEMPO = 0x00000002 } 1131 - 1132 -struct midiproptimediv_tag { 1133 - DWORD cbStruct; 1134 - DWORD dwTimeDiv; 2130 +struct MCI_OVLY_LOAD_PARMSA { 2131 + DWORD dwCallback; 2132 + LPCSTR lpfilename; 2133 + RECT rc; 1135 2134 } 1136 -alias midiproptimediv_tag MIDIPROPTIMEDIV; 1137 -alias midiproptimediv_tag* LPMIDIPROPTIMEDIV; 2135 +alias MCI_OVLY_LOAD_PARMSA* PMCI_OVLY_LOAD_PARMSA, LPMCI_OVLY_LOAD_PARMSA; 1138 2136 1139 -struct midiproptempo_tag { 1140 - DWORD cbStruct; 1141 - DWORD dwTempo; 1142 -} 1143 -alias midiproptempo_tag MIDIPROPTEMPO; 1144 -alias midiproptempo_tag* LPMIDIPROPTEMPO; 1145 - 1146 -// #endif /* WINVER >= 0x0400 */ 1147 - 1148 -extern(Windows) export UINT midiOutGetNumDevs(); 1149 -// #if(WINVER >= 0x0400) 1150 -extern(Windows) export MMRESULT midiStreamOpen(LPHMIDISTRM phms, LPUINT puDeviceID, DWORD cMidi, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen); 1151 -extern(Windows) export MMRESULT midiStreamClose(HMIDISTRM hms); 1152 - 1153 -extern(Windows) export MMRESULT midiStreamProperty(HMIDISTRM hms, LPBYTE lppropdata, DWORD dwProperty); 1154 -extern(Windows) export MMRESULT midiStreamPosition(HMIDISTRM hms, LPMMTIME lpmmt, UINT cbmmt); 1155 - 1156 -extern(Windows) export MMRESULT midiStreamOut(HMIDISTRM hms, LPMIDIHDR pmh, UINT cbmh); 1157 -extern(Windows) export MMRESULT midiStreamPause(HMIDISTRM hms); 1158 -extern(Windows) export MMRESULT midiStreamRestart(HMIDISTRM hms); 1159 -extern(Windows) export MMRESULT midiStreamStop(HMIDISTRM hms); 1160 - 1161 -// #ifdef _WIN32 1162 -extern(Windows) export MMRESULT midiConnect(HMIDI hmi, HMIDIOUT hmo, LPVOID pReserved); 1163 -extern(Windows) export MMRESULT midiDisconnect(HMIDI hmi, HMIDIOUT hmo, LPVOID pReserved); 1164 -// #endif 1165 -// #endif /* WINVER >= 0x0400 */ 1166 - 1167 -// #ifdef _WIN32 1168 - 1169 -extern(Windows) export MMRESULT midiOutGetDevCapsA(UINT_PTR uDeviceID, LPMIDIOUTCAPSA pmoc, UINT cbmoc); 1170 -extern(Windows) export MMRESULT midiOutGetDevCapsW(UINT_PTR uDeviceID, LPMIDIOUTCAPSW pmoc, UINT cbmoc); 1171 -// #ifdef UNICODE 1172 -alias midiOutGetDevCapsW midiOutGetDevCaps; 1173 -// #else 1174 -// #... 1175 -// #endif // !UNICODE 1176 - 1177 -// #else 1178 -// ... 1179 -// #endif 1180 - 1181 -// #if (WINVER >= 0x0400) 1182 -extern(Windows) export MMRESULT midiOutGetVolume(HMIDIOUT hmo, LPDWORD pdwVolume); 1183 -extern(Windows) export MMRESULT midiOutSetVolume(HMIDIOUT hmo, DWORD dwVolume); 1184 -// #else 1185 -// ... 1186 -// #endif 1187 - 1188 -// #ifdef _WIN32 1189 - 1190 -extern(Windows) export MMRESULT midiOutGetErrorTextA(MMRESULT mmrError, LPSTR pszText, UINT cchText); 1191 -extern(Windows) export MMRESULT midiOutGetErrorTextW(MMRESULT mmrError, LPWSTR pszText, UINT cchText); 1192 -// #ifdef UNICODE 1193 -alias midiOutGetErrorTextW midiOutGetErrorText; 1194 -// #else 1195 -// #... 1196 -// #endif // !UNICODE 1197 - 1198 -// #else 1199 -// ... 1200 -// #endif 1201 - 1202 -extern(Windows) export MMRESULT midiOutOpen(LPHMIDIOUT phmo, UINT uDeviceID, 1203 - DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen); 1204 -extern(Windows) export MMRESULT midiOutClose(HMIDIOUT hmo); 1205 -extern(Windows) export MMRESULT midiOutPrepareHeader(HMIDIOUT hmo, LPMIDIHDR pmh, UINT cbmh); 1206 -extern(Windows) export MMRESULT midiOutUnprepareHeader(HMIDIOUT hmo, LPMIDIHDR pmh, UINT cbmh); 1207 -extern(Windows) export MMRESULT midiOutShortMsg(HMIDIOUT hmo, DWORD dwMsg); 1208 -extern(Windows) export MMRESULT midiOutLongMsg(HMIDIOUT hmo, LPMIDIHDR pmh, UINT cbmh); 1209 -extern(Windows) export MMRESULT midiOutReset(HMIDIOUT hmo); 1210 -extern(Windows) export MMRESULT midiOutCachePatches(HMIDIOUT hmo, UINT uBank, LPWORD pwpa, UINT fuCache); 1211 -extern(Windows) export MMRESULT midiOutCacheDrumPatches(HMIDIOUT hmo, UINT uPatch, LPWORD pwkya, UINT fuCache); 1212 -extern(Windows) export MMRESULT midiOutGetID(HMIDIOUT hmo, LPUINT puDeviceID); 1213 - 1214 -// #if (WINVER >= 0x030a) 1215 -// #ifdef _WIN32 1216 -extern(Windows) export MMRESULT midiOutMessage(HMIDIOUT hmo, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2); 1217 -// #else 1218 -// ... 1219 -// #endif 1220 -// #endif /* ifdef WINVER >= 0x030a */ 1221 - 1222 -extern(Windows) export UINT midiInGetNumDevs(); 1223 - 1224 -// #ifdef _WIN32 1225 - 1226 -extern(Windows) export MMRESULT midiInGetDevCapsA(UINT_PTR uDeviceID, LPMIDIINCAPSA pmic, UINT cbmic); 1227 -extern(Windows) export MMRESULT midiInGetDevCapsW(UINT_PTR uDeviceID, LPMIDIINCAPSW pmic, UINT cbmic); 1228 -// #ifdef UNICODE 1229 -alias midiInGetDevCapsW midiInGetDevCaps; 1230 -// #else 1231 -// #... 1232 -// #endif // !UNICODE 1233 -extern(Windows) export MMRESULT midiInGetErrorTextA(MMRESULT mmrError, LPSTR pszText, UINT cchText); 1234 -extern(Windows) export MMRESULT midiInGetErrorTextW(MMRESULT mmrError, LPWSTR pszText, UINT cchText); 1235 -// #ifdef UNICODE 1236 -alias midiInGetErrorTextW midiInGetErrorText; 1237 -// #else 1238 -// #... 1239 -// #endif // !UNICODE 1240 - 1241 -// #else 1242 -// ... 1243 -// #endif 1244 - 1245 -extern(Windows) export MMRESULT midiInOpen(LPHMIDIIN phmi, UINT uDeviceID, 1246 - DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen); 1247 -extern(Windows) export MMRESULT midiInClose(HMIDIIN hmi); 1248 -extern(Windows) export MMRESULT midiInPrepareHeader(HMIDIIN hmi, LPMIDIHDR pmh, UINT cbmh); 1249 -extern(Windows) export MMRESULT midiInUnprepareHeader(HMIDIIN hmi, LPMIDIHDR pmh, UINT cbmh); 1250 -extern(Windows) export MMRESULT midiInAddBuffer(HMIDIIN hmi, LPMIDIHDR pmh, UINT cbmh); 1251 -extern(Windows) export MMRESULT midiInStart(HMIDIIN hmi); 1252 -extern(Windows) export MMRESULT midiInStop(HMIDIIN hmi); 1253 -extern(Windows) export MMRESULT midiInReset(HMIDIIN hmi); 1254 -extern(Windows) export MMRESULT midiInGetID(HMIDIIN hmi, LPUINT puDeviceID); 1255 - 1256 -// #if (WINVER >= 0x030a) 1257 -// #ifdef _WIN32 1258 -extern(Windows) export MMRESULT midiInMessage(HMIDIIN hmi, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2); 1259 -// #else 1260 -// ... 1261 -// #endif 1262 -// #endif /* ifdef WINVER >= 0x030a */ 1263 - 1264 -// #endif /* ifndef MMNOMIDI */ 1265 - 1266 -// #ifndef MMNOAUX 1267 - 1268 -enum : uint { AUX_MAPPER = cast(UINT)-1 } 1269 - 1270 -// #ifdef _WIN32 1271 - 1272 -struct tagAUXCAPSA { 1273 - WORD wMid; 1274 - WORD wPid; 1275 - MMVERSION vDriverVersion; 1276 - CHAR szPname[MAXPNAMELEN]; 1277 - WORD wTechnology; 1278 - WORD wReserved1; 1279 - DWORD dwSupport; 1280 -} 1281 -alias tagAUXCAPSA AUXCAPSA; 1282 -alias tagAUXCAPSA* PAUXCAPSA; 1283 -alias tagAUXCAPSA* NPAUXCAPSA; 1284 -alias tagAUXCAPSA* LPAUXCAPSA; 1285 - 1286 -struct tagAUXCAPSW { 1287 - WORD wMid; 1288 - WORD wPid; 1289 - MMVERSION vDriverVersion; 1290 - WCHAR szPname[MAXPNAMELEN]; 1291 - WORD wTechnology; 1292 - WORD wReserved1; 1293 - DWORD dwSupport; 1294 -} 1295 -alias tagAUXCAPSW AUXCAPSW; 1296 -alias tagAUXCAPSW* PAUXCAPSW; 1297 -alias tagAUXCAPSW* NPAUXCAPSW; 1298 -alias tagAUXCAPSW* LPAUXCAPSW; 1299 - 1300 -// #ifdef UNICODE 1301 -alias AUXCAPSW AUXCAPS; 1302 -alias PAUXCAPSW PAUXCAPS; 1303 -alias NPAUXCAPSW NPAUXCAPS; 1304 -alias LPAUXCAPSW LPAUXCAPS; 1305 -// #else 1306 -// ... 1307 -// #endif // UNICODE 1308 -struct tagAUXCAPS2A { 1309 - WORD wMid; 1310 - WORD wPid; 1311 - MMVERSION vDriverVersion; 1312 - CHAR szPname[MAXPNAMELEN]; 1313 - WORD wTechnology; 1314 - WORD wReserved1; 1315 - DWORD dwSupport; 1316 - GUID ManufacturerGuid; 1317 - GUID ProductGuid; 1318 - GUID NameGuid; 1319 -} 1320 -alias tagAUXCAPS2A AUXCAPS2A; 1321 -alias tagAUXCAPS2A* PAUXCAPS2A; 1322 -alias tagAUXCAPS2A* NPAUXCAPS2A; 1323 -alias tagAUXCAPS2A* LPAUXCAPS2A; 1324 - 1325 -struct tagAUXCAPS2W { 1326 - WORD wMid; 1327 - WORD wPid; 1328 - MMVERSION vDriverVersion; 1329 - WCHAR szPname[MAXPNAMELEN]; 1330 - WORD wTechnology; 1331 - WORD wReserved1; 1332 - DWORD dwSupport; 1333 - GUID ManufacturerGuid; 1334 - GUID ProductGuid; 1335 - GUID NameGuid; 1336 -} 1337 -alias tagAUXCAPS2W AUXCAPS2W; 1338 -alias tagAUXCAPS2W* PAUXCAPS2W; 1339 -alias tagAUXCAPS2W* NPAUXCAPS2W; 1340 -alias tagAUXCAPS2W* LPAUXCAPS2W; 1341 - 1342 -// #ifdef UNICODE 1343 -alias AUXCAPS2W AUXCAPS2; 1344 -alias PAUXCAPS2W PAUXCAPS2; 1345 -alias NPAUXCAPS2W NPAUXCAPS2; 1346 -alias LPAUXCAPS2W LPAUXCAPS2; 1347 -// #else 1348 -// ... 1349 -// #endif // UNICODE 1350 - 1351 -// #else 1352 -// ... 1353 -// #endif 1354 - 1355 -enum : uint { AUXCAPS_CDAUDIO = 1 } 1356 -enum : uint { AUXCAPS_AUXIN = 2 } 1357 - 1358 -enum : uint { AUXCAPS_VOLUME = 0x0001 } 1359 -enum : uint { AUXCAPS_LRVOLUME = 0x0002 } 1360 - 1361 -extern(Windows) export UINT auxGetNumDevs(); 1362 -// #ifdef _WIN32 1363 - 1364 -extern(Windows) export MMRESULT auxGetDevCapsA(UINT_PTR uDeviceID, LPAUXCAPSA pac, UINT cbac); 1365 -extern(Windows) export MMRESULT auxGetDevCapsW(UINT_PTR uDeviceID, LPAUXCAPSW pac, UINT cbac); 1366 -// #ifdef UNICODE 1367 -alias auxGetDevCapsW auxGetDevCaps; 1368 -// #else 1369 -// #... 1370 -// #endif // !UNICODE 1371 - 1372 -// #else 1373 -// ... 1374 -// #endif 1375 -extern(Windows) export MMRESULT auxSetVolume(UINT uDeviceID, DWORD dwVolume); 1376 -extern(Windows) export MMRESULT auxGetVolume(UINT uDeviceID, LPDWORD pdwVolume); 1377 - 1378 -// #if (WINVER >= 0x030a) 1379 -// #ifdef _WIN32 1380 -extern(Windows) export MMRESULT auxOutMessage(UINT uDeviceID, UINT uMsg, DWORD_PTR dw1, DWORD_PTR dw2); 1381 -// #else 1382 -// ... 1383 -// #endif 1384 -// #endif /* ifdef WINVER >= 0x030a */ 1385 - 1386 -// #endif /* ifndef MMNOAUX */ 1387 - 1388 -// #ifndef MMNOMIXER 1389 - 1390 -alias void* HMIXEROBJ; 1391 -alias HMIXEROBJ* LPHMIXEROBJ; 1392 - 1393 -alias void* HMIXER; 1394 -alias HMIXER* LPHMIXER; 1395 - 1396 -enum : uint { MIXER_SHORT_NAME_CHARS = 16 } 1397 -enum : uint { MIXER_LONG_NAME_CHARS = 64 } 1398 - 1399 -enum : uint { MIXERR_INVALLINE = MIXERR_BASE + 0 } 1400 -enum : uint { MIXERR_INVALCONTROL = MIXERR_BASE + 1 } 1401 -enum : uint { MIXERR_INVALVALUE = MIXERR_BASE + 2 } 1402 -enum : uint { MIXERR_LASTERROR = MIXERR_BASE + 2 } 1403 - 1404 -enum : uint { MIXER_OBJECTF_HANDLE = 0x80000000 } 1405 -enum : uint { MIXER_OBJECTF_MIXER = 0x00000000 } 1406 -enum : uint { MIXER_OBJECTF_HMIXER = MIXER_OBJECTF_HANDLE|MIXER_OBJECTF_MIXER } 1407 -enum : uint { MIXER_OBJECTF_WAVEOUT = 0x10000000 } 1408 -enum : uint { MIXER_OBJECTF_HWAVEOUT = MIXER_OBJECTF_HANDLE|MIXER_OBJECTF_WAVEOUT } 1409 -enum : uint { MIXER_OBJECTF_WAVEIN = 0x20000000 } 1410 -enum : uint { MIXER_OBJECTF_HWAVEIN = MIXER_OBJECTF_HANDLE|MIXER_OBJECTF_WAVEIN } 1411 -enum : uint { MIXER_OBJECTF_MIDIOUT = 0x30000000 } 1412 -enum : uint { MIXER_OBJECTF_HMIDIOUT = MIXER_OBJECTF_HANDLE|MIXER_OBJECTF_MIDIOUT } 1413 -enum : uint { MIXER_OBJECTF_MIDIIN = 0x40000000 } 1414 -enum : uint { MIXER_OBJECTF_HMIDIIN = MIXER_OBJECTF_HANDLE|MIXER_OBJECTF_MIDIIN } 1415 -enum : uint { MIXER_OBJECTF_AUX = 0x50000000 } 1416 - 1417 -extern(Windows) export UINT mixerGetNumDevs(); 1418 - 1419 -// #ifdef _WIN32 1420 - 1421 -struct tagMIXERCAPSA { 1422 - WORD wMid; 1423 - WORD wPid; 1424 - MMVERSION vDriverVersion; 1425 - CHAR szPname[MAXPNAMELEN]; 1426 - DWORD fdwSupport; 1427 - DWORD cDestinations; 2137 +struct MCI_OVLY_LOAD_PARMSW { 2138 + DWORD dwCallback; 2139 + LPCWSTR lpfilename; 2140 + RECT rc; 1428 2141 } 1429 -alias tagMIXERCAPSA MIXERCAPSA; 1430 -alias tagMIXERCAPSA* PMIXERCAPSA; 1431 -alias tagMIXERCAPSA* LPMIXERCAPSA; 2142 +alias MCI_OVLY_LOAD_PARMSW* PMCI_OVLY_LOAD_PARMSW, LPMCI_OVLY_LOAD_PARMSW; 1432 2143 1433 -struct tagMIXERCAPSW { 1434 - WORD wMid; 1435 - WORD wPid; 1436 - MMVERSION vDriverVersion; 1437 - WCHAR szPname[MAXPNAMELEN]; 1438 - DWORD fdwSupport; 1439 - DWORD cDestinations; 1440 -} 1441 -alias tagMIXERCAPSW MIXERCAPSW; 1442 -alias tagMIXERCAPSW* PMIXERCAPSW; 1443 -alias tagMIXERCAPSW* LPMIXERCAPSW; 2144 +version(Unicode) { 2145 + alias WAVEOUTCAPSW WAVEOUTCAPS; 2146 + alias WAVEINCAPSW WAVEINCAPS; 2147 + alias MIDIOUTCAPSW MIDIOUTCAPS; 2148 + alias MIDIINCAPSW MIDIINCAPS; 2149 + alias AUXCAPSW AUXCAPS; 2150 + alias MIXERCAPSW MIXERCAPS; 2151 + alias MIXERLINEW MIXERLINE; 2152 + alias MIXERCONTROLA MIXERCONTROL; 2153 + alias MIXERLINECONTROLSW MIXERLINECONTROLS; 2154 + alias MIXERCONTROLDETAILS_LISTTEXTW MIXERCONTROLDETAILS_LISTTEXT; 2155 + alias JOYCAPSW JOYCAPS; 2156 + alias MCI_OPEN_PARMSW MCI_OPEN_PARMS; 2157 + alias MCI_INFO_PARMSW MCI_INFO_PARMS; 2158 + alias MCI_SYSINFO_PARMSW MCI_SYSINFO_PARMS; 2159 + alias MCI_SAVE_PARMSW MCI_SAVE_PARMS; 2160 + alias MCI_LOAD_PARMSW MCI_LOAD_PARMS; 2161 + alias MCI_VD_ESCAPE_PARMSW MCI_VD_ESCAPE_PARMS; 2162 + alias MCI_WAVE_OPEN_PARMSW MCI_WAVE_OPEN_PARMS; 2163 + alias MCI_ANIM_OPEN_PARMSW MCI_ANIM_OPEN_PARMS; 2164 + alias MCI_ANIM_WINDOW_PARMSW MCI_ANIM_WINDOW_PARMS; 2165 + alias MCI_OVLY_OPEN_PARMSW MCI_OVLY_OPEN_PARMS; 2166 + alias MCI_OVLY_WINDOW_PARMSW MCI_OVLY_WINDOW_PARMS; 2167 + alias MCI_OVLY_SAVE_PARMSW MCI_OVLY_SAVE_PARMS; 1444 2168 1445 -// #ifdef UNICODE 1446 -alias MIXERCAPSW MIXERCAPS; 1447 -alias PMIXERCAPSW PMIXERCAPS; 1448 -alias LPMIXERCAPSW LPMIXERCAPS; 1449 -// #else 1450 -// ... 1451 -// #endif // UNICODE 1452 -struct tagMIXERCAPS2A { 1453 - WORD wMid; 1454 - WORD wPid; 1455 - MMVERSION vDriverVersion; 1456 - CHAR szPname[MAXPNAMELEN]; 1457 - DWORD fdwSupport; 1458 - DWORD cDestinations; 1459 - GUID ManufacturerGuid; 1460 - GUID ProductGuid; 1461 - GUID NameGuid; 1462 -} 1463 -alias tagMIXERCAPS2A MIXERCAPS2A; 1464 -alias tagMIXERCAPS2A* PMIXERCAPS2A; 1465 -alias tagMIXERCAPS2A* LPMIXERCAPS2A; 1466 - 1467 -struct tagMIXERCAPS2W { 1468 - WORD wMid; 1469 - WORD wPid; 1470 - MMVERSION vDriverVersion; 1471 - WCHAR szPname[MAXPNAMELEN]; 1472 - DWORD fdwSupport; 1473 - DWORD cDestinations; 1474 - GUID ManufacturerGuid; 1475 - GUID ProductGuid; 1476 - GUID NameGuid; 1477 -} 1478 -alias tagMIXERCAPS2W MIXERCAPS2W; 1479 -alias tagMIXERCAPS2W* PMIXERCAPS2W; 1480 -alias tagMIXERCAPS2W* LPMIXERCAPS2W; 2169 + alias sndPlaySoundW sndPlaySound; 2170 + alias PlaySoundW PlaySound; 2171 + alias waveOutGetDevCapsW waveOutGetDevCaps; 2172 + alias waveOutGetErrorTextW waveOutGetErrorText; 2173 + alias waveInGetDevCapsW waveInGetDevCaps; 2174 + alias waveInGetErrorTextW waveInGetErrorText; 2175 + alias midiOutGetDevCapsW midiOutGetDevCaps; 2176 + alias midiOutGetErrorTextW midiOutGetErrorText; 2177 + alias midiInGetDevCapsW midiInGetDevCaps; 2178 + alias midiInGetErrorTextW midiInGetErrorText; 2179 + alias auxGetDevCapsW auxGetDevCaps; 2180 + alias mixerGetDevCapsW mixerGetDevCaps; 2181 + alias mixerGetLineInfoW mixerGetLineInfo; 2182 + alias mixerGetLineControlsW mixerGetLineControls; 2183 + alias mixerGetControlDetailsW mixerGetControlDetails; 2184 + alias joyGetDevCapsW joyGetDevCaps; 2185 + alias mmioInstallIOProcW mmioInstallIOProc; 2186 + alias mmioStringToFOURCCW mmioStringToFOURCC; 2187 + alias mmioOpenW mmioOpen; 2188 + alias mmioRenameW mmioRename; 2189 + alias mciSendCommandW mciSendCommand; 2190 + alias mciSendStringW mciSendString; 2191 + alias mciGetDeviceIDW mciGetDeviceID; 2192 + alias mciGetDeviceIDFromElementIDW mciGetDeviceIDFromElementID; 2193 + alias mciGetErrorStringW mciGetErrorString; 1481 2194 1482 -// #ifdef UNICODE 1483 -alias MIXERCAPS2W MIXERCAPS2; 1484 -alias PMIXERCAPS2W PMIXERCAPS2; 1485 -alias LPMIXERCAPS2W LPMIXERCAPS2; 1486 -// #else 1487 -// ... 1488 -// #endif // UNICODE 1489 - 1490 -// #else 1491 -// ... 1492 -// #endif 1493 - 1494 -// #ifdef _WIN32 1495 - 1496 -extern(Windows) export MMRESULT mixerGetDevCapsA(UINT_PTR uMxId, LPMIXERCAPSA pmxcaps, UINT cbmxcaps); 1497 -extern(Windows) export MMRESULT mixerGetDevCapsW(UINT_PTR uMxId, LPMIXERCAPSW pmxcaps, UINT cbmxcaps); 1498 -// #ifdef UNICODE 1499 -alias mixerGetDevCapsW mixerGetDevCaps; 1500 -// #else 1501 -// #... 1502 -// #endif // !UNICODE 1503 - 1504 -// #else 1505 -// ... 1506 -// #endif 1507 - 1508 -extern(Windows) export MMRESULT mixerOpen(LPHMIXER phmx, UINT uMxId, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen); 1509 - 1510 -extern(Windows) export MMRESULT mixerClose(HMIXER hmx); 1511 - 1512 -extern(Windows) export DWORD mixerMessage(HMIXER hmx, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2); 2195 +} else { 2196 + alias WAVEOUTCAPSA WAVEOUTCAPS; 2197 + alias WAVEINCAPSA WAVEINCAPS; 2198 + alias MIDIOUTCAPSA MIDIOUTCAPS; 2199 + alias MIDIINCAPSA MIDIINCAPS; 2200 + alias AUXCAPSA AUXCAPS; 2201 + alias MIXERCAPSA MIXERCAPS; 2202 + alias MIXERLINEA MIXERLINE; 2203 + alias MIXERCONTROLA MIXERCONTROL; 2204 + alias MIXERLINECONTROLSA MIXERLINECONTROLS; 2205 + alias MIXERCONTROLDETAILS_LISTTEXTA MIXERCONTROLDETAILS_LISTTEXT; 2206 + alias JOYCAPSA JOYCAPS; 2207 + alias MCI_OPEN_PARMSA MCI_OPEN_PARMS; 2208 + alias MCI_INFO_PARMSA MCI_INFO_PARMS; 2209 + alias MCI_SYSINFO_PARMSA MCI_SYSINFO_PARMS; 2210 + alias MCI_SAVE_PARMSA MCI_SAVE_PARMS; 2211 + alias MCI_LOAD_PARMSA MCI_LOAD_PARMS; 2212 + alias MCI_VD_ESCAPE_PARMSA MCI_VD_ESCAPE_PARMS; 2213 + alias MCI_WAVE_OPEN_PARMSA MCI_WAVE_OPEN_PARMS; 2214 + alias MCI_ANIM_OPEN_PARMSA MCI_ANIM_OPEN_PARMS; 2215 + alias MCI_ANIM_WINDOW_PARMSA MCI_ANIM_WINDOW_PARMS; 2216 + alias MCI_OVLY_OPEN_PARMSA MCI_OVLY_OPEN_PARMS; 2217 + alias MCI_OVLY_WINDOW_PARMSA MCI_OVLY_WINDOW_PARMS; 2218 + alias MCI_OVLY_SAVE_PARMSA MCI_OVLY_SAVE_PARMS; 1513 2219 1514 -// #ifdef _WIN32 1515 - 1516 -struct tagMIXERLINEA { 1517 - DWORD cbStruct; 1518 - DWORD dwDestination; 1519 - DWORD dwSource; 1520 - DWORD dwLineID; 1521 - DWORD fdwLine; 1522 - DWORD_PTR dwUser; 1523 - DWORD dwComponentType; 1524 - DWORD cChannels; 1525 - DWORD cConnections; 1526 - DWORD cControls; 1527 - CHAR szShortName[MIXER_SHORT_NAME_CHARS]; 1528 - CHAR szName[MIXER_LONG_NAME_CHARS]; 1529 -struct { 1530 - DWORD dwType; 1531 - DWORD dwDeviceID; 1532 - WORD wMid; 1533 - WORD wPid; 1534 - MMVERSION vDriverVersion; 1535 - CHAR szPname[MAXPNAMELEN]; 1536 -} 1537 - 1538 -} 1539 -alias tagMIXERLINEA MIXERLINEA; 1540 -alias tagMIXERLINEA* PMIXERLINEA; 1541 -alias tagMIXERLINEA* LPMIXERLINEA; 1542 - 1543 -struct tagMIXERLINEW { 1544 - DWORD cbStruct; 1545 - DWORD dwDestination; 1546 - DWORD dwSource; 1547 - DWORD dwLineID; 1548 - DWORD fdwLine; 1549 - DWORD_PTR dwUser; 1550 - DWORD dwComponentType; 1551 - DWORD cChannels; 1552 - DWORD cConnections; 1553 - DWORD cControls; 1554 - WCHAR szShortName[MIXER_SHORT_NAME_CHARS]; 1555 - WCHAR szName[MIXER_LONG_NAME_CHARS]; 1556 -struct { 1557 - DWORD dwType; 1558 - DWORD dwDeviceID; 1559 - WORD wMid; 1560 - WORD wPid; 1561 - MMVERSION vDriverVersion; 1562 - WCHAR szPname[MAXPNAMELEN]; 1563 -} 1564 - 1565 -} 1566 -alias tagMIXERLINEW MIXERLINEW; 1567 -alias tagMIXERLINEW* PMIXERLINEW; 1568 -alias tagMIXERLINEW* LPMIXERLINEW; 1569 - 1570 -// #ifdef UNICODE 1571 -alias MIXERLINEW MIXERLINE; 1572 -alias PMIXERLINEW PMIXERLINE; 1573 -alias LPMIXERLINEW LPMIXERLINE; 1574 -// #else 1575 -// ... 1576 -// #endif // UNICODE 1577 - 1578 -// #else 1579 -// ... 1580 -// #endif 1581 - 1582 -enum : uint { MIXERLINE_LINEF_ACTIVE = 0x00000001 } 1583 -enum : uint { MIXERLINE_LINEF_DISCONNECTED = 0x00008000 } 1584 -enum : uint { MIXERLINE_LINEF_SOURCE = 0x80000000 } 1585 - 1586 -enum : uint { MIXERLINE_COMPONENTTYPE_DST_FIRST = 0x00000000 } 1587 -enum : uint { MIXERLINE_COMPONENTTYPE_DST_UNDEFINED = MIXERLINE_COMPONENTTYPE_DST_FIRST + 0 } 1588 -enum : uint { MIXERLINE_COMPONENTTYPE_DST_DIGITAL = MIXERLINE_COMPONENTTYPE_DST_FIRST + 1 } 1589 -enum : uint { MIXERLINE_COMPONENTTYPE_DST_LINE = MIXERLINE_COMPONENTTYPE_DST_FIRST + 2 } 1590 -enum : uint { MIXERLINE_COMPONENTTYPE_DST_MONITOR = MIXERLINE_COMPONENTTYPE_DST_FIRST + 3 } 1591 -enum : uint { MIXERLINE_COMPONENTTYPE_DST_SPEAKERS = MIXERLINE_COMPONENTTYPE_DST_FIRST + 4 } 1592 -enum : uint { MIXERLINE_COMPONENTTYPE_DST_HEADPHONES = MIXERLINE_COMPONENTTYPE_DST_FIRST + 5 } 1593 -enum : uint { MIXERLINE_COMPONENTTYPE_DST_TELEPHONE = MIXERLINE_COMPONENTTYPE_DST_FIRST + 6 } 1594 -enum : uint { MIXERLINE_COMPONENTTYPE_DST_WAVEIN = MIXERLINE_COMPONENTTYPE_DST_FIRST + 7 } 1595 -enum : uint { MIXERLINE_COMPONENTTYPE_DST_VOICEIN = MIXERLINE_COMPONENTTYPE_DST_FIRST + 8 } 1596 -enum : uint { MIXERLINE_COMPONENTTYPE_DST_LAST = MIXERLINE_COMPONENTTYPE_DST_FIRST + 8 } 1597 - 1598 -enum : uint { MIXERLINE_COMPONENTTYPE_SRC_FIRST = 0x00001000 } 1599 -enum : uint { MIXERLINE_COMPONENTTYPE_SRC_UNDEFINED = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 0 } 1600 -enum : uint { MIXERLINE_COMPONENTTYPE_SRC_DIGITAL = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 1 } 1601 -enum : uint { MIXERLINE_COMPONENTTYPE_SRC_LINE = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 2 } 1602 -enum : uint { MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 3 } 1603 -enum : uint { MIXERLINE_COMPONENTTYPE_SRC_SYNTHESIZER = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 4 } 1604 -enum : uint { MIXERLINE_COMPONENTTYPE_SRC_COMPACTDISC = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 5 } 1605 -enum : uint { MIXERLINE_COMPONENTTYPE_SRC_TELEPHONE = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 6 } 1606 -enum : uint { MIXERLINE_COMPONENTTYPE_SRC_PCSPEAKER = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 7 } 1607 -enum : uint { MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 8 } 1608 -enum : uint { MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 9 } 1609 -enum : uint { MIXERLINE_COMPONENTTYPE_SRC_ANALOG = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 10 } 1610 -enum : uint { MIXERLINE_COMPONENTTYPE_SRC_LAST = MIXERLINE_COMPONENTTYPE_SRC_FIRST + 10 } 1611 - 1612 -enum : uint { MIXERLINE_TARGETTYPE_UNDEFINED = 0 } 1613 -enum : uint { MIXERLINE_TARGETTYPE_WAVEOUT = 1 } 1614 -enum : uint { MIXERLINE_TARGETTYPE_WAVEIN = 2 } 1615 -enum : uint { MIXERLINE_TARGETTYPE_MIDIOUT = 3 } 1616 -enum : uint { MIXERLINE_TARGETTYPE_MIDIIN = 4 } 1617 -enum : uint { MIXERLINE_TARGETTYPE_AUX = 5 } 1618 - 1619 -// #ifdef _WIN32 1620 - 1621 -extern(Windows) export MMRESULT mixerGetLineInfoA(HMIXEROBJ hmxobj, LPMIXERLINEA pmxl, DWORD fdwInfo); 1622 -extern(Windows) export MMRESULT mixerGetLineInfoW(HMIXEROBJ hmxobj, LPMIXERLINEW pmxl, DWORD fdwInfo); 1623 -// #ifdef UNICODE 1624 -alias mixerGetLineInfoW mixerGetLineInfo; 1625 -// #else 1626 -// #... 1627 -// #endif // !UNICODE 1628 - 1629 -// #else 1630 -// ... 1631 -// #endif 1632 - 1633 -enum : uint { MIXER_GETLINEINFOF_DESTINATION = 0x00000000 } 1634 -enum : uint { MIXER_GETLINEINFOF_SOURCE = 0x00000001 } 1635 -enum : uint { MIXER_GETLINEINFOF_LINEID = 0x00000002 } 1636 -enum : uint { MIXER_GETLINEINFOF_COMPONENTTYPE = 0x00000003 } 1637 -enum : uint { MIXER_GETLINEINFOF_TARGETTYPE = 0x00000004 } 1638 - 1639 -enum : uint { MIXER_GETLINEINFOF_QUERYMASK = 0x0000000F } 1640 - 1641 -extern(Windows) export MMRESULT mixerGetID(HMIXEROBJ hmxobj, UINT *puMxId, DWORD fdwId); 1642 - 1643 -// #ifdef _WIN32 1644 - 1645 -struct tagMIXERCONTROLA { 1646 - DWORD cbStruct; 1647 - DWORD dwControlID; 1648 - DWORD dwControlType; 1649 - DWORD fdwControl; 1650 - DWORD cMultipleItems; 1651 - CHAR szShortName[MIXER_SHORT_NAME_CHARS]; 1652 - CHAR szName[MIXER_LONG_NAME_CHARS]; 1653 -union _0 { 1654 -struct { 1655 - LONG lMinimum; 1656 - LONG lMaximum; 1657 -} 1658 - 1659 -struct { 1660 - DWORD dwMinimum; 1661 - DWORD dwMaximum; 1662 -} 1663 - 1664 - DWORD dwReserved[6]; 1665 -} 1666 -_0 Bounds; 1667 - 1668 -union _1 { 1669 - DWORD cSteps; 1670 - DWORD cbCustomData; 1671 - DWORD dwReserved[6]; 1672 -} 1673 -_1 Metrics; 1674 - 1675 -} 1676 -alias tagMIXERCONTROLA MIXERCONTROLA; 1677 -alias tagMIXERCONTROLA* PMIXERCONTROLA; 1678 -alias tagMIXERCONTROLA* LPMIXERCONTROLA; 1679 - 1680 -struct tagMIXERCONTROLW { 1681 - DWORD cbStruct; 1682 - DWORD dwControlID; 1683 - DWORD dwControlType; 1684 - DWORD fdwControl; 1685 - DWORD cMultipleItems; 1686 - WCHAR szShortName[MIXER_SHORT_NAME_CHARS]; 1687 - WCHAR szName[MIXER_LONG_NAME_CHARS]; 1688 -union _2 { 1689 -struct { 1690 - LONG lMinimum; 1691 - LONG lMaximum; 1692 -} 1693 - 1694 -struct { 1695 - DWORD dwMinimum; 1696 - DWORD dwMaximum; 1697 -} 1698 - 1699 - DWORD dwReserved[6]; 1700 -} 1701 -_2 Bounds; 1702 - 1703 -union _3 { 1704 - DWORD cSteps; 1705 - DWORD cbCustomData; 1706 - DWORD dwReserved[6]; 1707 -} 1708 -_3 Metrics; 1709 - 1710 -} 1711 -alias tagMIXERCONTROLW MIXERCONTROLW; 1712 -alias tagMIXERCONTROLW* PMIXERCONTROLW; 1713 -alias tagMIXERCONTROLW* LPMIXERCONTROLW; 1714 - 1715 -// #ifdef UNICODE 1716 -alias MIXERCONTROLW MIXERCONTROL; 1717 -alias PMIXERCONTROLW PMIXERCONTROL; 1718 -alias LPMIXERCONTROLW LPMIXERCONTROL; 1719 -// #else 1720 -// ... 1721 -// #endif // UNICODE 1722 - 1723 -// #else 1724 -// ... 1725 -// #endif 1726 - 1727 -enum : uint { MIXERCONTROL_CONTROLF_UNIFORM = 0x00000001 } 1728 -enum : uint { MIXERCONTROL_CONTROLF_MULTIPLE = 0x00000002 } 1729 -enum : uint { MIXERCONTROL_CONTROLF_DISABLED = 0x80000000 } 1730 - 1731 -enum : uint { MIXERCONTROL_CT_CLASS_MASK = 0xF0000000 } 1732 -enum : uint { MIXERCONTROL_CT_CLASS_CUSTOM = 0x00000000 } 1733 -enum : uint { MIXERCONTROL_CT_CLASS_METER = 0x10000000 } 1734 -enum : uint { MIXERCONTROL_CT_CLASS_SWITCH = 0x20000000 } 1735 -enum : uint { MIXERCONTROL_CT_CLASS_NUMBER = 0x30000000 } 1736 -enum : uint { MIXERCONTROL_CT_CLASS_SLIDER = 0x40000000 } 1737 -enum : uint { MIXERCONTROL_CT_CLASS_FADER = 0x50000000 } 1738 -enum : uint { MIXERCONTROL_CT_CLASS_TIME = 0x60000000 } 1739 -enum : uint { MIXERCONTROL_CT_CLASS_LIST = 0x70000000 } 1740 - 1741 -enum : uint { MIXERCONTROL_CT_SUBCLASS_MASK = 0x0F000000 } 1742 - 1743 -enum : uint { MIXERCONTROL_CT_SC_SWITCH_BOOLEAN = 0x00000000 } 1744 -enum : uint { MIXERCONTROL_CT_SC_SWITCH_BUTTON = 0x01000000 } 1745 - 1746 -enum : uint { MIXERCONTROL_CT_SC_METER_POLLED = 0x00000000 } 1747 - 1748 -enum : uint { MIXERCONTROL_CT_SC_TIME_MICROSECS = 0x00000000 } 1749 -enum : uint { MIXERCONTROL_CT_SC_TIME_MILLISECS = 0x01000000 } 1750 - 1751 -enum : uint { MIXERCONTROL_CT_SC_LIST_SINGLE = 0x00000000 } 1752 -enum : uint { MIXERCONTROL_CT_SC_LIST_MULTIPLE = 0x01000000 } 1753 - 1754 -enum : uint { MIXERCONTROL_CT_UNITS_MASK = 0x00FF0000 } 1755 -enum : uint { MIXERCONTROL_CT_UNITS_CUSTOM = 0x00000000 } 1756 -enum : uint { MIXERCONTROL_CT_UNITS_BOOLEAN = 0x00010000 } 1757 -enum : uint { MIXERCONTROL_CT_UNITS_SIGNED = 0x00020000 } 1758 -enum : uint { MIXERCONTROL_CT_UNITS_UNSIGNED = 0x00030000 } 1759 -enum : uint { MIXERCONTROL_CT_UNITS_DECIBELS = 0x00040000 } 1760 -enum : uint { MIXERCONTROL_CT_UNITS_PERCENT = 0x00050000 } 1761 - 1762 -enum : uint { MIXERCONTROL_CONTROLTYPE_CUSTOM = MIXERCONTROL_CT_CLASS_CUSTOM | MIXERCONTROL_CT_UNITS_CUSTOM } 1763 -enum : uint { MIXERCONTROL_CONTROLTYPE_BOOLEANMETER = MIXERCONTROL_CT_CLASS_METER | MIXERCONTROL_CT_SC_METER_POLLED | MIXERCONTROL_CT_UNITS_BOOLEAN } 1764 -enum : uint { MIXERCONTROL_CONTROLTYPE_SIGNEDMETER = MIXERCONTROL_CT_CLASS_METER | MIXERCONTROL_CT_SC_METER_POLLED | MIXERCONTROL_CT_UNITS_SIGNED } 1765 -enum : uint { MIXERCONTROL_CONTROLTYPE_PEAKMETER = MIXERCONTROL_CONTROLTYPE_SIGNEDMETER + 1 } 1766 -enum : uint { MIXERCONTROL_CONTROLTYPE_UNSIGNEDMETER = MIXERCONTROL_CT_CLASS_METER | MIXERCONTROL_CT_SC_METER_POLLED | MIXERCONTROL_CT_UNITS_UNSIGNED } 1767 -enum : uint { MIXERCONTROL_CONTROLTYPE_BOOLEAN = MIXERCONTROL_CT_CLASS_SWITCH | MIXERCONTROL_CT_SC_SWITCH_BOOLEAN | MIXERCONTROL_CT_UNITS_BOOLEAN } 1768 -enum : uint { MIXERCONTROL_CONTROLTYPE_ONOFF = MIXERCONTROL_CONTROLTYPE_BOOLEAN + 1 } 1769 -enum : uint { MIXERCONTROL_CONTROLTYPE_MUTE = MIXERCONTROL_CONTROLTYPE_BOOLEAN + 2 } 1770 -enum : uint { MIXERCONTROL_CONTROLTYPE_MONO = MIXERCONTROL_CONTROLTYPE_BOOLEAN + 3 } 1771 -enum : uint { MIXERCONTROL_CONTROLTYPE_LOUDNESS = MIXERCONTROL_CONTROLTYPE_BOOLEAN + 4 } 1772 -enum : uint { MIXERCONTROL_CONTROLTYPE_STEREOENH = MIXERCONTROL_CONTROLTYPE_BOOLEAN + 5 } 1773 -enum : uint { MIXERCONTROL_CONTROLTYPE_BASS_BOOST = MIXERCONTROL_CONTROLTYPE_BOOLEAN + 0x00002277 } 1774 -enum : uint { MIXERCONTROL_CONTROLTYPE_BUTTON = MIXERCONTROL_CT_CLASS_SWITCH | MIXERCONTROL_CT_SC_SWITCH_BUTTON | MIXERCONTROL_CT_UNITS_BOOLEAN } 1775 -enum : uint { MIXERCONTROL_CONTROLTYPE_DECIBELS = MIXERCONTROL_CT_CLASS_NUMBER | MIXERCONTROL_CT_UNITS_DECIBELS } 1776 -enum : uint { MIXERCONTROL_CONTROLTYPE_SIGNED = MIXERCONTROL_CT_CLASS_NUMBER | MIXERCONTROL_CT_UNITS_SIGNED } 1777 -enum : uint { MIXERCONTROL_CONTROLTYPE_UNSIGNED = MIXERCONTROL_CT_CLASS_NUMBER | MIXERCONTROL_CT_UNITS_UNSIGNED } 1778 -enum : uint { MIXERCONTROL_CONTROLTYPE_PERCENT = MIXERCONTROL_CT_CLASS_NUMBER | MIXERCONTROL_CT_UNITS_PERCENT } 1779 -enum : uint { MIXERCONTROL_CONTROLTYPE_SLIDER = MIXERCONTROL_CT_CLASS_SLIDER | MIXERCONTROL_CT_UNITS_SIGNED } 1780 -enum : uint { MIXERCONTROL_CONTROLTYPE_PAN = MIXERCONTROL_CONTROLTYPE_SLIDER + 1 } 1781 -enum : uint { MIXERCONTROL_CONTROLTYPE_QSOUNDPAN = MIXERCONTROL_CONTROLTYPE_SLIDER + 2 } 1782 -enum : uint { MIXERCONTROL_CONTROLTYPE_FADER = MIXERCONTROL_CT_CLASS_FADER | MIXERCONTROL_CT_UNITS_UNSIGNED } 1783 -enum : uint { MIXERCONTROL_CONTROLTYPE_VOLUME = MIXERCONTROL_CONTROLTYPE_FADER + 1 } 1784 -enum : uint { MIXERCONTROL_CONTROLTYPE_BASS = MIXERCONTROL_CONTROLTYPE_FADER + 2 } 1785 -enum : uint { MIXERCONTROL_CONTROLTYPE_TREBLE = MIXERCONTROL_CONTROLTYPE_FADER + 3 } 1786 -enum : uint { MIXERCONTROL_CONTROLTYPE_EQUALIZER = MIXERCONTROL_CONTROLTYPE_FADER + 4 } 1787 -enum : uint { MIXERCONTROL_CONTROLTYPE_SINGLESELECT = MIXERCONTROL_CT_CLASS_LIST | MIXERCONTROL_CT_SC_LIST_SINGLE | MIXERCONTROL_CT_UNITS_BOOLEAN } 1788 -enum : uint { MIXERCONTROL_CONTROLTYPE_MUX = MIXERCONTROL_CONTROLTYPE_SINGLESELECT + 1 } 1789 -enum : uint { MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT = MIXERCONTROL_CT_CLASS_LIST | MIXERCONTROL_CT_SC_LIST_MULTIPLE | MIXERCONTROL_CT_UNITS_BOOLEAN } 1790 -enum : uint { MIXERCONTROL_CONTROLTYPE_MIXER = MIXERCONTROL_CONTROLTYPE_MULTIPLESELECT + 1 } 1791 -enum : uint { MIXERCONTROL_CONTROLTYPE_MICROTIME = MIXERCONTROL_CT_CLASS_TIME | MIXERCONTROL_CT_SC_TIME_MICROSECS | MIXERCONTROL_CT_UNITS_UNSIGNED } 1792 -enum : uint { MIXERCONTROL_CONTROLTYPE_MILLITIME = MIXERCONTROL_CT_CLASS_TIME | MIXERCONTROL_CT_SC_TIME_MILLISECS | MIXERCONTROL_CT_UNITS_UNSIGNED } 1793 - 1794 -// #ifdef _WIN32 1795 - 1796 -struct tagMIXERLINECONTROLSA { 1797 - DWORD cbStruct; 1798 - DWORD dwLineID; 1799 -union { 1800 - DWORD dwControlID; 1801 - DWORD dwControlType; 1802 -} 1803 - 1804 - DWORD cControls; 1805 - DWORD cbmxctrl; 1806 - LPMIXERCONTROLA pamxctrl; 1807 -} 1808 -alias tagMIXERLINECONTROLSA MIXERLINECONTROLSA; 1809 -alias tagMIXERLINECONTROLSA* PMIXERLINECONTROLSA; 1810 -alias tagMIXERLINECONTROLSA* LPMIXERLINECONTROLSA; 1811 - 1812 -struct tagMIXERLINECONTROLSW { 1813 - DWORD cbStruct; 1814 - DWORD dwLineID; 1815 -union { 1816 - DWORD dwControlID; 1817 - DWORD dwControlType; 1818 -} 1819 - 1820 - DWORD cControls; 1821 - DWORD cbmxctrl; 1822 - LPMIXERCONTROLW pamxctrl; 1823 -} 1824 -alias tagMIXERLINECONTROLSW MIXERLINECONTROLSW; 1825 -alias tagMIXERLINECONTROLSW* PMIXERLINECONTROLSW; 1826 -alias tagMIXERLINECONTROLSW* LPMIXERLINECONTROLSW; 1827 - 1828 -// #ifdef UNICODE 1829 -alias MIXERLINECONTROLSW MIXERLINECONTROLS; 1830 -alias PMIXERLINECONTROLSW PMIXERLINECONTROLS; 1831 -alias LPMIXERLINECONTROLSW LPMIXERLINECONTROLS; 1832 -// #else 1833 -// ... 1834 -// #endif // UNICODE 1835 - 1836 -// #else 1837 -// ... 1838 -// #endif 1839 - 1840 -// #ifdef _WIN32 1841 - 1842 -extern(Windows) export MMRESULT mixerGetLineControlsA(HMIXEROBJ hmxobj, LPMIXERLINECONTROLSA pmxlc, DWORD fdwControls); 1843 -extern(Windows) export MMRESULT mixerGetLineControlsW(HMIXEROBJ hmxobj, LPMIXERLINECONTROLSW pmxlc, DWORD fdwControls); 1844 -// #ifdef UNICODE 1845 -alias mixerGetLineControlsW mixerGetLineControls; 1846 -// #else 1847 -// #... 1848 -// #endif // !UNICODE 1849 - 1850 -// #else 1851 -// ... 1852 -// #endif 1853 - 1854 -enum : uint { MIXER_GETLINECONTROLSF_ALL = 0x00000000 } 1855 -enum : uint { MIXER_GETLINECONTROLSF_ONEBYID = 0x00000001 } 1856 -enum : uint { MIXER_GETLINECONTROLSF_ONEBYTYPE = 0x00000002 } 1857 - 1858 -enum : uint { MIXER_GETLINECONTROLSF_QUERYMASK = 0x0000000F } 1859 - 1860 -struct tMIXERCONTROLDETAILS { 1861 - DWORD cbStruct; 1862 - DWORD dwControlID; 1863 - DWORD cChannels; 1864 -union { 1865 - HWND hwndOwner; 1866 - DWORD cMultipleItems; 2220 + alias sndPlaySoundA sndPlaySound; 2221 + alias PlaySoundA PlaySound; 2222 + alias waveOutGetDevCapsA waveOutGetDevCaps; 2223 + alias waveOutGetErrorTextA waveOutGetErrorText; 2224 + alias waveInGetDevCapsA waveInGetDevCaps; 2225 + alias waveInGetErrorTextA waveInGetErrorText; 2226 + alias midiOutGetDevCapsA midiOutGetDevCaps; 2227 + alias midiOutGetErrorTextA midiOutGetErrorText; 2228 + alias midiInGetDevCapsA midiInGetDevCaps; 2229 + alias midiInGetErrorTextA midiInGetErrorText; 2230 + alias auxGetDevCapsA auxGetDevCaps; 2231 + alias mixerGetDevCapsA mixerGetDevCaps; 2232 + alias mixerGetLineInfoA mixerGetLineInfo; 2233 + alias mixerGetLineControlsA mixerGetLineControls; 2234 + alias mixerGetControlDetailsA mixerGetControlDetails; 2235 + alias joyGetDevCapsA joyGetDevCaps; 2236 + alias mmioInstallIOProcA mmioInstallIOProc; 2237 + alias mmioStringToFOURCCA mmioStringToFOURCC; 2238 + alias mmioOpenA mmioOpen; 2239 + alias mmioRenameA mmioRename; 2240 + alias mciSendCommandA mciSendCommand; 2241 + alias mciSendStringA mciSendString; 2242 + alias mciGetDeviceIDA mciGetDeviceID; 2243 + alias mciGetDeviceIDFromElementIDA mciGetDeviceIDFromElementID; 2244 + alias mciGetErrorStringA mciGetErrorString; 1867 2245 } 1868 2246 1869 - DWORD cbDetails; 1870 - LPVOID paDetails; 1871 -} 1872 -alias tMIXERCONTROLDETAILS MIXERCONTROLDETAILS; 1873 -alias tMIXERCONTROLDETAILS* PMIXERCONTROLDETAILS; 1874 -alias tMIXERCONTROLDETAILS* LPMIXERCONTROLDETAILS; 1875 - 1876 -// #ifdef _WIN32 1877 - 1878 -struct tagMIXERCONTROLDETAILS_LISTTEXTA { 1879 - DWORD dwParam1; 1880 - DWORD dwParam2; 1881 - CHAR szName[MIXER_LONG_NAME_CHARS]; 1882 -} 1883 -alias tagMIXERCONTROLDETAILS_LISTTEXTA MIXERCONTROLDETAILS_LISTTEXTA; 1884 -alias tagMIXERCONTROLDETAILS_LISTTEXTA* PMIXERCONTROLDETAILS_LISTTEXTA; 1885 -alias tagMIXERCONTROLDETAILS_LISTTEXTA* LPMIXERCONTROLDETAILS_LISTTEXTA; 1886 - 1887 -struct tagMIXERCONTROLDETAILS_LISTTEXTW { 1888 - DWORD dwParam1; 1889 - DWORD dwParam2; 1890 - WCHAR szName[MIXER_LONG_NAME_CHARS]; 1891 -} 1892 -alias tagMIXERCONTROLDETAILS_LISTTEXTW MIXERCONTROLDETAILS_LISTTEXTW; 1893 -alias tagMIXERCONTROLDETAILS_LISTTEXTW* PMIXERCONTROLDETAILS_LISTTEXTW; 1894 -alias tagMIXERCONTROLDETAILS_LISTTEXTW* LPMIXERCONTROLDETAILS_LISTTEXTW; 1895 - 1896 -// #ifdef UNICODE 1897 -alias MIXERCONTROLDETAILS_LISTTEXTW MIXERCONTROLDETAILS_LISTTEXT; 1898 -alias PMIXERCONTROLDETAILS_LISTTEXTW PMIXERCONTROLDETAILS_LISTTEXT; 1899 -alias LPMIXERCONTROLDETAILS_LISTTEXTW LPMIXERCONTROLDETAILS_LISTTEXT; 1900 -// #else 1901 -// ... 1902 -// #endif // UNICODE 1903 - 1904 -// #else 1905 -// ... 1906 -// #endif 1907 - 1908 -struct tMIXERCONTROLDETAILS_BOOLEAN { 1909 - LONG fValue; 1910 -} 1911 -alias tMIXERCONTROLDETAILS_BOOLEAN MIXERCONTROLDETAILS_BOOLEAN; 1912 -alias tMIXERCONTROLDETAILS_BOOLEAN* PMIXERCONTROLDETAILS_BOOLEAN; 1913 -alias tMIXERCONTROLDETAILS_BOOLEAN* LPMIXERCONTROLDETAILS_BOOLEAN; 1914 - 1915 -struct tMIXERCONTROLDETAILS_SIGNED { 1916 - LONG lValue; 1917 -} 1918 -alias tMIXERCONTROLDETAILS_SIGNED MIXERCONTROLDETAILS_SIGNED; 1919 -alias tMIXERCONTROLDETAILS_SIGNED* PMIXERCONTROLDETAILS_SIGNED; 1920 -alias tMIXERCONTROLDETAILS_SIGNED* LPMIXERCONTROLDETAILS_SIGNED; 1921 - 1922 -struct tMIXERCONTROLDETAILS_UNSIGNED { 1923 - DWORD dwValue; 1924 -} 1925 -alias tMIXERCONTROLDETAILS_UNSIGNED MIXERCONTROLDETAILS_UNSIGNED; 1926 -alias tMIXERCONTROLDETAILS_UNSIGNED* PMIXERCONTROLDETAILS_UNSIGNED; 1927 -alias tMIXERCONTROLDETAILS_UNSIGNED* LPMIXERCONTROLDETAILS_UNSIGNED; 1928 - 1929 -// #ifdef _WIN32 1930 - 1931 -extern(Windows) export MMRESULT mixerGetControlDetailsA(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails); 1932 -extern(Windows) export MMRESULT mixerGetControlDetailsW(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails); 1933 -// #ifdef UNICODE 1934 -alias mixerGetControlDetailsW mixerGetControlDetails; 1935 -// #else 1936 -// #... 1937 -// #endif // !UNICODE 1938 - 1939 -// #else 1940 -// ... 1941 -// #endif 1942 - 1943 -enum : uint { MIXER_GETCONTROLDETAILSF_VALUE = 0x00000000 } 1944 -enum : uint { MIXER_GETCONTROLDETAILSF_LISTTEXT = 0x00000001 } 1945 - 1946 -enum : uint { MIXER_GETCONTROLDETAILSF_QUERYMASK = 0x0000000F } 1947 - 1948 -extern(Windows) export MMRESULT mixerSetControlDetails(HMIXEROBJ hmxobj, LPMIXERCONTROLDETAILS pmxcd, DWORD fdwDetails); 1949 - 1950 -enum : uint { MIXER_SETCONTROLDETAILSF_VALUE = 0x00000000 } 1951 -enum : uint { MIXER_SETCONTROLDETAILSF_CUSTOM = 0x00000001 } 1952 - 1953 -enum : uint { MIXER_SETCONTROLDETAILSF_QUERYMASK = 0x0000000F } 1954 - 1955 -// #endif /* ifndef MMNOMIXER */ 1956 - 1957 -// #ifndef MMNOTIMER 1958 - 1959 -enum : uint { TIMERR_NOERROR = 0 } 1960 -enum : uint { TIMERR_NOCANDO = TIMERR_BASE+1 } 1961 -enum : uint { TIMERR_STRUCT = TIMERR_BASE+33 } 1962 - 1963 -// typedef void (CALLBACK TIMECALLBACK)(UINT uTimerID, UINT uMsg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2); 1964 - 1965 -extern(Windows) alias void function(UINT uTimerID, UINT uMsg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2) LPTIMECALLBACK; 1966 - 1967 -enum : uint { TIME_ONESHOT = 0x0000 } 1968 -enum : uint { TIME_PERIODIC = 0x0001 } 1969 - 1970 -// #ifdef _WIN32 1971 -enum : uint { TIME_CALLBACK_FUNCTION = 0x0000 } 1972 -enum : uint { TIME_CALLBACK_EVENT_SET = 0x0010 } 1973 -enum : uint { TIME_CALLBACK_EVENT_PULSE = 0x0020 } 1974 -// #endif 1975 - 1976 -// #if WINVER >= 0x0501 1977 -enum : uint { TIME_KILL_SYNCHRONOUS = 0x0100 } 1978 - 1979 -// #endif // WINVER >= 0x0501 1980 - 1981 -struct timecaps_tag { 1982 - UINT wPeriodMin; 1983 - UINT wPeriodMax; 1984 -} 1985 -alias timecaps_tag TIMECAPS; 1986 -alias timecaps_tag* PTIMECAPS; 1987 -alias timecaps_tag* NPTIMECAPS; 1988 -alias timecaps_tag* LPTIMECAPS; 1989 - 1990 -extern(Windows) export MMRESULT timeGetSystemTime(LPMMTIME pmmt, UINT cbmmt); 1991 -extern(Windows) export DWORD timeGetTime(); 1992 -extern(Windows) export MMRESULT timeSetEvent(UINT uDelay, UINT uResolution, 1993 - LPTIMECALLBACK fptc, DWORD_PTR dwUser, UINT fuEvent); 1994 -extern(Windows) export MMRESULT timeKillEvent(UINT uTimerID); 1995 -extern(Windows) export MMRESULT timeGetDevCaps(LPTIMECAPS ptc, UINT cbtc); 1996 -extern(Windows) export MMRESULT timeBeginPeriod(UINT uPeriod); 1997 -extern(Windows) export MMRESULT timeEndPeriod(UINT uPeriod); 1998 - 1999 -// #endif /* ifndef MMNOTIMER */ 2000 - 2001 -// #ifndef MMNOJOY 2002 - 2003 -enum : uint { JOYERR_NOERROR = 0 } 2004 -enum : uint { JOYERR_PARMS = JOYERR_BASE+5 } 2005 -enum : uint { JOYERR_NOCANDO = JOYERR_BASE+6 } 2006 -enum : uint { JOYERR_UNPLUGGED = JOYERR_BASE+7 } 2007 - 2008 -enum : uint { JOY_BUTTON1 = 0x0001 } 2009 -enum : uint { JOY_BUTTON2 = 0x0002 } 2010 -enum : uint { JOY_BUTTON3 = 0x0004 } 2011 -enum : uint { JOY_BUTTON4 = 0x0008 } 2012 -enum : uint { JOY_BUTTON1CHG = 0x0100 } 2013 -enum : uint { JOY_BUTTON2CHG = 0x0200 } 2014 -enum : uint { JOY_BUTTON3CHG = 0x0400 } 2015 -enum : uint { JOY_BUTTON4CHG = 0x0800 } 2016 - 2017 -enum : uint { JOY_BUTTON5 = 0x00000010 } 2018 -enum : uint { JOY_BUTTON6 = 0x00000020 } 2019 -enum : uint { JOY_BUTTON7 = 0x00000040 } 2020 -enum : uint { JOY_BUTTON8 = 0x00000080 } 2021 -enum : uint { JOY_BUTTON9 = 0x00000100 } 2022 -enum : uint { JOY_BUTTON10 = 0x00000200 } 2023 -enum : uint { JOY_BUTTON11 = 0x00000400 } 2024 -enum : uint { JOY_BUTTON12 = 0x00000800 } 2025 -enum : uint { JOY_BUTTON13 = 0x00001000 } 2026 -enum : uint { JOY_BUTTON14 = 0x00002000 } 2027 -enum : uint { JOY_BUTTON15 = 0x00004000 } 2028 -enum : uint { JOY_BUTTON16 = 0x00008000 } 2029 -enum : uint { JOY_BUTTON17 = 0x00010000 } 2030 -enum : uint { JOY_BUTTON18 = 0x00020000 } 2031 -enum : uint { JOY_BUTTON19 = 0x00040000 } 2032 -enum : uint { JOY_BUTTON20 = 0x00080000 } 2033 -enum : uint { JOY_BUTTON21 = 0x00100000 } 2034 -enum : uint { JOY_BUTTON22 = 0x00200000 } 2035 -enum : uint { JOY_BUTTON23 = 0x00400000 } 2036 -enum : uint { JOY_BUTTON24 = 0x00800000 } 2037 -enum : uint { JOY_BUTTON25 = 0x01000000 } 2038 -enum : uint { JOY_BUTTON26 = 0x02000000 } 2039 -enum : uint { JOY_BUTTON27 = 0x04000000 } 2040 -enum : uint { JOY_BUTTON28 = 0x08000000 } 2041 -enum : uint { JOY_BUTTON29 = 0x10000000 } 2042 -enum : uint { JOY_BUTTON30 = 0x20000000 } 2043 -enum : uint { JOY_BUTTON31 = 0x40000000 } 2044 -enum : uint { JOY_BUTTON32 = 0x80000000 } 2045 - 2046 -enum : WORD { JOY_POVCENTERED = cast(WORD)-1 } 2047 -enum : uint { JOY_POVFORWARD = 0 } 2048 -enum : uint { JOY_POVRIGHT = 9000 } 2049 -enum : uint { JOY_POVBACKWARD = 18000 } 2050 -enum : uint { JOY_POVLEFT = 27000 } 2051 - 2052 -enum : uint { JOY_RETURNX = 0x00000001 } 2053 -enum : uint { JOY_RETURNY = 0x00000002 } 2054 -enum : uint { JOY_RETURNZ = 0x00000004 } 2055 -enum : uint { JOY_RETURNR = 0x00000008 } 2056 -enum : uint { JOY_RETURNU = 0x00000010 } 2057 -enum : uint { JOY_RETURNV = 0x00000020 } 2058 -enum : uint { JOY_RETURNPOV = 0x00000040 } 2059 -enum : uint { JOY_RETURNBUTTONS = 0x00000080 } 2060 -enum : uint { JOY_RETURNRAWDATA = 0x00000100 } 2061 -enum : uint { JOY_RETURNPOVCTS = 0x00000200 } 2062 -enum : uint { JOY_RETURNCENTERED = 0x00000400 } 2063 -enum : uint { JOY_USEDEADZONE = 0x00000800 } 2064 -enum : uint { JOY_RETURNALL = JOY_RETURNX | JOY_RETURNY | JOY_RETURNZ | JOY_RETURNR | JOY_RETURNU | JOY_RETURNV | JOY_RETURNPOV | JOY_RETURNBUTTONS } 2065 -enum : uint { JOY_CAL_READALWAYS = 0x00010000 } 2066 -enum : uint { JOY_CAL_READXYONLY = 0x00020000 } 2067 -enum : uint { JOY_CAL_READ3 = 0x00040000 } 2068 -enum : uint { JOY_CAL_READ4 = 0x00080000 } 2069 -enum : uint { JOY_CAL_READXONLY = 0x00100000 } 2070 -enum : uint { JOY_CAL_READYONLY = 0x00200000 } 2071 -enum : uint { JOY_CAL_READ5 = 0x00400000 } 2072 -enum : uint { JOY_CAL_READ6 = 0x00800000 } 2073 -enum : uint { JOY_CAL_READZONLY = 0x01000000 } 2074 -enum : uint { JOY_CAL_READRONLY = 0x02000000 } 2075 -enum : uint { JOY_CAL_READUONLY = 0x04000000 } 2076 -enum : uint { JOY_CAL_READVONLY = 0x08000000 } 2077 - 2078 -enum : uint { JOYSTICKID1 = 0 } 2079 -enum : uint { JOYSTICKID2 = 1 } 2080 - 2081 -enum : uint { JOYCAPS_HASZ = 0x0001 } 2082 -enum : uint { JOYCAPS_HASR = 0x0002 } 2083 -enum : uint { JOYCAPS_HASU = 0x0004 } 2084 -enum : uint { JOYCAPS_HASV = 0x0008 } 2085 -enum : uint { JOYCAPS_HASPOV = 0x0010 } 2086 -enum : uint { JOYCAPS_POV4DIR = 0x0020 } 2087 -enum : uint { JOYCAPS_POVCTS = 0x0040 } 2088 - 2089 -// #ifdef _WIN32 2090 - 2091 -struct tagJOYCAPSA { 2092 - WORD wMid; 2093 - WORD wPid; 2094 - CHAR szPname[MAXPNAMELEN]; 2095 - UINT wXmin; 2096 - UINT wXmax; 2097 - UINT wYmin; 2098 - UINT wYmax; 2099 - UINT wZmin; 2100 - UINT wZmax; 2101 - UINT wNumButtons; 2102 - UINT wPeriodMin; 2103 - UINT wPeriodMax; 2104 -// #if (WINVER >= 0x0400) 2105 - UINT wRmin; 2106 - UINT wRmax; 2107 - UINT wUmin; 2108 - UINT wUmax; 2109 - UINT wVmin; 2110 - UINT wVmax; 2111 - UINT wCaps; 2112 - UINT wMaxAxes; 2113 - UINT wNumAxes; 2114 - UINT wMaxButtons; 2115 - CHAR szRegKey[MAXPNAMELEN]; 2116 - CHAR szOEMVxD[MAX_JOYSTICKOEMVXDNAME]; 2117 -// #endif 2118 -} 2119 -alias tagJOYCAPSA JOYCAPSA; 2120 -alias tagJOYCAPSA* PJOYCAPSA; 2121 -alias tagJOYCAPSA* NPJOYCAPSA; 2122 -alias tagJOYCAPSA* LPJOYCAPSA; 2123 - 2124 -struct tagJOYCAPSW { 2125 - WORD wMid; 2126 - WORD wPid; 2127 - WCHAR szPname[MAXPNAMELEN]; 2128 - UINT wXmin; 2129 - UINT wXmax; 2130 - UINT wYmin; 2131 - UINT wYmax; 2132 - UINT wZmin; 2133 - UINT wZmax; 2134 - UINT wNumButtons; 2135 - UINT wPeriodMin; 2136 - UINT wPeriodMax; 2137 -// #if (WINVER >= 0x0400) 2138 - UINT wRmin; 2139 - UINT wRmax; 2140 - UINT wUmin; 2141 - UINT wUmax; 2142 - UINT wVmin; 2143 - UINT wVmax; 2144 - UINT wCaps; 2145 - UINT wMaxAxes; 2146 - UINT wNumAxes; 2147 - UINT wMaxButtons; 2148 - WCHAR szRegKey[MAXPNAMELEN]; 2149 - WCHAR szOEMVxD[MAX_JOYSTICKOEMVXDNAME]; 2150 -// #endif 2151 -} 2152 -alias tagJOYCAPSW JOYCAPSW; 2153 -alias tagJOYCAPSW* PJOYCAPSW; 2154 -alias tagJOYCAPSW* NPJOYCAPSW; 2155 -alias tagJOYCAPSW* LPJOYCAPSW; 2156 - 2157 -// #ifdef UNICODE 2158 -alias JOYCAPSW JOYCAPS; 2159 -alias PJOYCAPSW PJOYCAPS; 2160 -alias NPJOYCAPSW NPJOYCAPS; 2161 -alias LPJOYCAPSW LPJOYCAPS; 2162 -// #else 2163 -// ... 2164 -// #endif // UNICODE 2165 -struct tagJOYCAPS2A { 2166 - WORD wMid; 2167 - WORD wPid; 2168 - CHAR szPname[MAXPNAMELEN]; 2169 - UINT wXmin; 2170 - UINT wXmax; 2171 - UINT wYmin; 2172 - UINT wYmax; 2173 - UINT wZmin; 2174 - UINT wZmax; 2175 - UINT wNumButtons; 2176 - UINT wPeriodMin; 2177 - UINT wPeriodMax; 2178 - UINT wRmin; 2179 - UINT wRmax; 2180 - UINT wUmin; 2181 - UINT wUmax; 2182 - UINT wVmin; 2183 - UINT wVmax; 2184 - UINT wCaps; 2185 - UINT wMaxAxes; 2186 - UINT wNumAxes; 2187 - UINT wMaxButtons; 2188 - CHAR szRegKey[MAXPNAMELEN]; 2189 - CHAR szOEMVxD[MAX_JOYSTICKOEMVXDNAME]; 2190 - GUID ManufacturerGuid; 2191 - GUID ProductGuid; 2192 - GUID NameGuid; 2193 -} 2194 -alias tagJOYCAPS2A JOYCAPS2A; 2195 -alias tagJOYCAPS2A* PJOYCAPS2A; 2196 -alias tagJOYCAPS2A* NPJOYCAPS2A; 2197 -alias tagJOYCAPS2A* LPJOYCAPS2A; 2198 - 2199 -struct tagJOYCAPS2W { 2200 - WORD wMid; 2201 - WORD wPid; 2202 - WCHAR szPname[MAXPNAMELEN]; 2203 - UINT wXmin; 2204 - UINT wXmax; 2205 - UINT wYmin; 2206 - UINT wYmax; 2207 - UINT wZmin; 2208 - UINT wZmax; 2209 - UINT wNumButtons; 2210 - UINT wPeriodMin; 2211 - UINT wPeriodMax; 2212 - UINT wRmin; 2213 - UINT wRmax; 2214 - UINT wUmin; 2215 - UINT wUmax; 2216 - UINT wVmin; 2217 - UINT wVmax; 2218 - UINT wCaps; 2219 - UINT wMaxAxes; 2220 - UINT wNumAxes; 2221 - UINT wMaxButtons; 2222 - WCHAR szRegKey[MAXPNAMELEN]; 2223 - WCHAR szOEMVxD[MAX_JOYSTICKOEMVXDNAME]; 2224 - GUID ManufacturerGuid; 2225 - GUID ProductGuid; 2226 - GUID NameGuid; 2227 -} 2228 -alias tagJOYCAPS2W JOYCAPS2W; 2229 -alias tagJOYCAPS2W* PJOYCAPS2W; 2230 -alias tagJOYCAPS2W* NPJOYCAPS2W; 2231 -alias tagJOYCAPS2W* LPJOYCAPS2W; 2232 - 2233 -// #ifdef UNICODE 2234 -alias JOYCAPS2W JOYCAPS2; 2235 -alias PJOYCAPS2W PJOYCAPS2; 2236 -alias NPJOYCAPS2W NPJOYCAPS2; 2237 -alias LPJOYCAPS2W LPJOYCAPS2; 2238 -// #else 2239 -// ... 2240 -// #endif // UNICODE 2241 - 2242 -// #else 2243 -// ... 2244 -// #if (WINVER >= 0x0400) 2245 -// ... 2246 -// #endif 2247 -// ... 2248 -// #endif 2249 - 2250 -struct joyinfo_tag { 2251 - UINT wXpos; 2252 - UINT wYpos; 2253 - UINT wZpos; 2254 - UINT wButtons; 2255 -} 2256 -alias joyinfo_tag JOYINFO; 2257 -alias joyinfo_tag* PJOYINFO; 2258 -alias joyinfo_tag* NPJOYINFO; 2259 -alias joyinfo_tag* LPJOYINFO; 2260 - 2261 -// #if(WINVER >= 0x0400) 2262 -struct joyinfoex_tag { 2263 - DWORD dwSize; 2264 - DWORD dwFlags; 2265 - DWORD dwXpos; 2266 - DWORD dwYpos; 2267 - DWORD dwZpos; 2268 - DWORD dwRpos; 2269 - DWORD dwUpos; 2270 - DWORD dwVpos; 2271 - DWORD dwButtons; 2272 - DWORD dwButtonNumber; 2273 - DWORD dwPOV; 2274 - DWORD dwReserved1; 2275 - DWORD dwReserved2; 2276 -} 2277 -alias joyinfoex_tag JOYINFOEX; 2278 -alias joyinfoex_tag* PJOYINFOEX; 2279 -alias joyinfoex_tag* NPJOYINFOEX; 2280 -alias joyinfoex_tag* LPJOYINFOEX; 2281 - 2282 -// #endif /* WINVER >= 0x0400 */ 2283 - 2284 -extern(Windows) export UINT joyGetNumDevs(); 2285 -// #ifdef _WIN32 2286 - 2287 -extern(Windows) export MMRESULT joyGetDevCapsA(UINT_PTR uJoyID, LPJOYCAPSA pjc, UINT cbjc); 2288 -extern(Windows) export MMRESULT joyGetDevCapsW(UINT_PTR uJoyID, LPJOYCAPSW pjc, UINT cbjc); 2289 -// #ifdef UNICODE 2290 -alias joyGetDevCapsW joyGetDevCaps; 2291 -// #else 2292 -// #... 2293 -// #endif // !UNICODE 2294 - 2295 -// #else 2296 -// ... 2297 -// #endif 2298 -extern(Windows) export MMRESULT joyGetPos(UINT uJoyID, LPJOYINFO pji); 2299 - 2300 -// #if(WINVER >= 0x0400) 2301 -extern(Windows) export MMRESULT joyGetPosEx(UINT uJoyID, LPJOYINFOEX pji); 2302 -// #endif /* WINVER >= 0x0400 */ 2303 - 2304 -extern(Windows) export MMRESULT joyGetThreshold(UINT uJoyID, LPUINT puThreshold); 2305 -extern(Windows) export MMRESULT joyReleaseCapture(UINT uJoyID); 2306 -extern(Windows) export MMRESULT joySetCapture(HWND hwnd, UINT uJoyID, UINT uPeriod, 2307 - BOOL fChanged); 2308 -extern(Windows) export MMRESULT joySetThreshold(UINT uJoyID, UINT uThreshold); 2309 - 2310 -// #endif /* ifndef MMNOJOY */ 2311 - 2312 -// #ifndef MMNOMMIO 2313 - 2314 -enum : uint { MMIOERR_BASE = 256 } 2315 -enum : uint { MMIOERR_FILENOTFOUND = MMIOERR_BASE + 1 } 2316 -enum : uint { MMIOERR_OUTOFMEMORY = MMIOERR_BASE + 2 } 2317 -enum : uint { MMIOERR_CANNOTOPEN = MMIOERR_BASE + 3 } 2318 -enum : uint { MMIOERR_CANNOTCLOSE = MMIOERR_BASE + 4 } 2319 -enum : uint { MMIOERR_CANNOTREAD = MMIOERR_BASE + 5 } 2320 -enum : uint { MMIOERR_CANNOTWRITE = MMIOERR_BASE + 6 } 2321 -enum : uint { MMIOERR_CANNOTSEEK = MMIOERR_BASE + 7 } 2322 -enum : uint { MMIOERR_CANNOTEXPAND = MMIOERR_BASE + 8 } 2323 -enum : uint { MMIOERR_CHUNKNOTFOUND = MMIOERR_BASE + 9 } 2324 -enum : uint { MMIOERR_UNBUFFERED = MMIOERR_BASE + 10 } 2325 -enum : uint { MMIOERR_PATHNOTFOUND = MMIOERR_BASE + 11 } 2326 -enum : uint { MMIOERR_ACCESSDENIED = MMIOERR_BASE + 12 } 2327 -enum : uint { MMIOERR_SHARINGVIOLATION = MMIOERR_BASE + 13 } 2328 -enum : uint { MMIOERR_NETWORKERROR = MMIOERR_BASE + 14 } 2329 -enum : uint { MMIOERR_TOOMANYOPENFILES = MMIOERR_BASE + 15 } 2330 -enum : uint { MMIOERR_INVALIDFILE = MMIOERR_BASE + 16 } 2331 - 2332 -const char CFSEPCHAR = '+'; 2333 - 2334 -alias DWORD FOURCC; 2335 -alias char* HPSTR; 2336 -alias void* HMMIO; 2337 -// typedef LRESULT (CALLBACK MMIOPROC)(LPSTR lpmmioinfo, UINT uMsg, LPARAM lParam1, LPARAM lParam2); 2338 -extern(Windows) alias LRESULT function(LPSTR lpmmioinfo, UINT uMsg, LPARAM lParam1, LPARAM lParam2) LPMMIOPROC; 2339 - 2340 -struct _MMIOINFO { 2341 - 2342 - DWORD dwFlags; 2343 - FOURCC fccIOProc; 2344 - LPMMIOPROC pIOProc; 2345 - UINT wErrorRet; 2346 - HTASK htask; 2347 - 2348 - LONG cchBuffer; 2349 - HPSTR pchBuffer; 2350 - HPSTR pchNext; 2351 - HPSTR pchEndRead; 2352 - HPSTR pchEndWrite; 2353 - LONG lBufOffset; 2354 - 2355 - LONG lDiskOffset; 2356 - DWORD adwInfo[3]; 2357 - 2358 - DWORD dwReserved1; 2359 - DWORD dwReserved2; 2360 - HMMIO hmmio; 2361 -} 2362 -alias _MMIOINFO MMIOINFO; 2363 -alias _MMIOINFO* PMMIOINFO; 2364 -alias _MMIOINFO* NPMMIOINFO; 2365 -alias _MMIOINFO* LPMMIOINFO; 2366 - 2367 -alias MMIOINFO* LPCMMIOINFO; 2368 - 2369 -struct _MMCKINFO { 2370 - FOURCC ckid; 2371 - DWORD cksize; 2372 - FOURCC fccType; 2373 - DWORD dwDataOffset; 2374 - DWORD dwFlags; 2375 -} 2376 -alias _MMCKINFO MMCKINFO; 2377 -alias _MMCKINFO* PMMCKINFO; 2378 -alias _MMCKINFO* NPMMCKINFO; 2379 -alias _MMCKINFO* LPMMCKINFO; 2380 - 2381 -alias MMCKINFO* LPCMMCKINFO; 2382 - 2383 -enum : uint { MMIO_RWMODE = 0x00000003 } 2384 -enum : uint { MMIO_SHAREMODE = 0x00000070 } 2385 - 2386 -enum : uint { MMIO_CREATE = 0x00001000 } 2387 -enum : uint { MMIO_PARSE = 0x00000100 } 2388 -enum : uint { MMIO_DELETE = 0x00000200 } 2389 -enum : uint { MMIO_EXIST = 0x00004000 } 2390 -enum : uint { MMIO_ALLOCBUF = 0x00010000 } 2391 -enum : uint { MMIO_GETTEMP = 0x00020000 } 2392 - 2393 -enum : uint { MMIO_DIRTY = 0x10000000 } 2394 - 2395 -enum : uint { MMIO_READ = 0x00000000 } 2396 -enum : uint { MMIO_WRITE = 0x00000001 } 2397 -enum : uint { MMIO_READWRITE = 0x00000002 } 2398 - 2399 -enum : uint { MMIO_COMPAT = 0x00000000 } 2400 -enum : uint { MMIO_EXCLUSIVE = 0x00000010 } 2401 -enum : uint { MMIO_DENYWRITE = 0x00000020 } 2402 -enum : uint { MMIO_DENYREAD = 0x00000030 } 2403 -enum : uint { MMIO_DENYNONE = 0x00000040 } 2404 - 2405 -enum : uint { MMIO_FHOPEN = 0x0010 } 2406 -enum : uint { MMIO_EMPTYBUF = 0x0010 } 2407 -enum : uint { MMIO_TOUPPER = 0x0010 } 2408 -enum : uint { MMIO_INSTALLPROC = 0x00010000 } 2409 -enum : uint { MMIO_GLOBALPROC = 0x10000000 } 2410 -enum : uint { MMIO_REMOVEPROC = 0x00020000 } 2411 -enum : uint { MMIO_UNICODEPROC = 0x01000000 } 2412 -enum : uint { MMIO_FINDPROC = 0x00040000 } 2413 -enum : uint { MMIO_FINDCHUNK = 0x0010 } 2414 -enum : uint { MMIO_FINDRIFF = 0x0020 } 2415 -enum : uint { MMIO_FINDLIST = 0x0040 } 2416 -enum : uint { MMIO_CREATERIFF = 0x0020 } 2417 -enum : uint { MMIO_CREATELIST = 0x0040 } 2418 - 2419 -alias MMIO_READ MMIOM_READ; 2420 -alias MMIO_WRITE MMIOM_WRITE; 2421 -enum : uint { MMIOM_SEEK = 2 } 2422 -enum : uint { MMIOM_OPEN = 3 } 2423 -enum : uint { MMIOM_CLOSE = 4 } 2424 -enum : uint { MMIOM_WRITEFLUSH = 5 } 2425 - 2426 -// #if (WINVER >= 0x030a) 2427 -enum : uint { MMIOM_RENAME = 6 } 2428 -// #endif /* ifdef WINVER >= 0x030a */ 2429 - 2430 -enum : uint { MMIOM_USER = 0x8000 } 2431 - 2432 -// #define FOURCC_RIFF mmioFOURCC('R', 'I', 'F', 'F') 2433 -// #define FOURCC_LIST mmioFOURCC('L', 'I', 'S', 'T') 2434 - 2435 -// #define FOURCC_DOS mmioFOURCC('D', 'O', 'S', ' ') 2436 -// #define FOURCC_MEM mmioFOURCC('M', 'E', 'M', ' ') 2437 - 2438 -// #ifndef SEEK_SET 2439 -enum : uint { SEEK_SET = 0 } 2440 -enum : uint { SEEK_CUR = 1 } 2441 -enum : uint { SEEK_END = 2 } 2442 -// #endif /* ifndef SEEK_SET */ 2443 - 2444 -enum : uint { MMIO_DEFAULTBUFFER = 8192 } 2445 - 2446 -// #define mmioFOURCC(ch0, ch1, ch2, ch3) MAKEFOURCC(ch0, ch1, ch2, ch3) 2447 - 2448 -// #ifdef _WIN32 2449 - 2450 -extern(Windows) export FOURCC mmioStringToFOURCCA(LPCSTR sz, UINT uFlags); 2451 -extern(Windows) export FOURCC mmioStringToFOURCCW(LPCWSTR sz, UINT uFlags); 2452 -// #ifdef UNICODE 2453 -alias mmioStringToFOURCCW mmioStringToFOURCC; 2454 -// #else 2455 -// #... 2456 -// #endif // !UNICODE 2457 -extern(Windows) export LPMMIOPROC mmioInstallIOProcA(FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags); 2458 -extern(Windows) export LPMMIOPROC mmioInstallIOProcW(FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags); 2459 -// #ifdef UNICODE 2460 -alias mmioInstallIOProcW mmioInstallIOProc; 2461 -// #else 2462 -// #... 2463 -// #endif // !UNICODE 2464 -extern(Windows) export HMMIO mmioOpenA(LPSTR pszFileName, LPMMIOINFO pmmioinfo, DWORD fdwOpen); 2465 -extern(Windows) export HMMIO mmioOpenW(LPWSTR pszFileName, LPMMIOINFO pmmioinfo, DWORD fdwOpen); 2466 -// #ifdef UNICODE 2467 -alias mmioOpenW mmioOpen; 2468 -// #else 2469 -// #... 2470 -// #endif // !UNICODE 2471 -extern(Windows) export MMRESULT mmioRenameA(LPCSTR pszFileName, LPCSTR pszNewFileName, LPCMMIOINFO pmmioinfo, DWORD fdwRename); 2472 -extern(Windows) export MMRESULT mmioRenameW(LPCWSTR pszFileName, LPCWSTR pszNewFileName, LPCMMIOINFO pmmioinfo, DWORD fdwRename); 2473 -// #ifdef UNICODE 2474 -alias mmioRenameW mmioRename; 2475 -// #else 2476 -// #... 2477 -// #endif // !UNICODE 2478 -// #else 2479 -// ... 2480 -// #if (WINVER >= 0x030a) 2481 -// ... 2482 -// #endif /* ifdef WINVER >= 0x030a */ 2483 -// #endif 2484 - 2485 -extern(Windows) export MMRESULT mmioClose(HMMIO hmmio, UINT fuClose); 2486 -extern(Windows) export LONG mmioRead(HMMIO hmmio, HPSTR pch, LONG cch); 2487 -extern(Windows) export LONG mmioWrite(HMMIO hmmio, char * pch, LONG cch); 2488 -extern(Windows) export LONG mmioSeek(HMMIO hmmio, LONG lOffset, int iOrigin); 2489 -extern(Windows) export MMRESULT mmioGetInfo(HMMIO hmmio, LPMMIOINFO pmmioinfo, UINT fuInfo); 2490 -extern(Windows) export MMRESULT mmioSetInfo(HMMIO hmmio, LPCMMIOINFO pmmioinfo, UINT fuInfo); 2491 -extern(Windows) export MMRESULT mmioSetBuffer(HMMIO hmmio, LPSTR pchBuffer, LONG cchBuffer, 2492 - UINT fuBuffer); 2493 -extern(Windows) export MMRESULT mmioFlush(HMMIO hmmio, UINT fuFlush); 2494 -extern(Windows) export MMRESULT mmioAdvance(HMMIO hmmio, LPMMIOINFO pmmioinfo, UINT fuAdvance); 2495 -extern(Windows) export LRESULT mmioSendMessage(HMMIO hmmio, UINT uMsg, 2496 - LPARAM lParam1, LPARAM lParam2); 2497 -extern(Windows) export MMRESULT mmioDescend(HMMIO hmmio, LPMMCKINFO pmmcki, 2498 - MMCKINFO * pmmckiParent, UINT fuDescend); 2499 -extern(Windows) export MMRESULT mmioAscend(HMMIO hmmio, LPMMCKINFO pmmcki, UINT fuAscend); 2500 -extern(Windows) export MMRESULT mmioCreateChunk(HMMIO hmmio, LPMMCKINFO pmmcki, UINT fuCreate); 2501 - 2502 -// #endif /* ifndef MMNOMMIO */ 2503 - 2504 -// #ifndef MMNOMCI 2505 - 2506 -// #ifndef _MCIERROR_ /* MCIERROR is defined in some post 3.1 apps */ 2507 -// #define _MCIERROR_ 2508 -alias DWORD MCIERROR; 2509 -// #endif 2510 - 2511 -// #ifndef _MCIDEVICEID_ /* Same with MCIDEVICEID */ 2512 -// #define _MCIDEVICEID_ 2513 -alias UINT MCIDEVICEID; 2514 -// #endif 2515 - 2516 -extern(Windows) alias UINT function(MCIDEVICEID mciId, DWORD dwYieldData) YIELDPROC; 2517 - 2518 -// #ifdef _WIN32 2519 - 2520 -extern(Windows) export MCIERROR mciSendCommandA(MCIDEVICEID mciId, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2); 2521 -extern(Windows) export MCIERROR mciSendCommandW(MCIDEVICEID mciId, UINT uMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2); 2522 -// #ifdef UNICODE 2523 -alias mciSendCommandW mciSendCommand; 2524 -// #else 2525 -// #... 2526 -// #endif // !UNICODE 2527 -extern(Windows) export MCIERROR mciSendStringA(LPCSTR lpstrCommand, LPSTR lpstrReturnString, UINT uReturnLength, HWND hwndCallback); 2528 -extern(Windows) export MCIERROR mciSendStringW(LPCWSTR lpstrCommand, LPWSTR lpstrReturnString, UINT uReturnLength, HWND hwndCallback); 2529 -// #ifdef UNICODE 2530 -alias mciSendStringW mciSendString; 2531 -// #else 2532 -// #... 2533 -// #endif // !UNICODE 2534 -extern(Windows) export MCIDEVICEID mciGetDeviceIDA(LPCSTR pszDevice); 2535 -extern(Windows) export MCIDEVICEID mciGetDeviceIDW(LPCWSTR pszDevice); 2536 -// #ifdef UNICODE 2537 -alias mciGetDeviceIDW mciGetDeviceID; 2538 -// #else 2539 -// #... 2540 -// #endif // !UNICODE 2541 -extern(Windows) export MCIDEVICEID mciGetDeviceIDFromElementIDA(DWORD dwElementID, LPCSTR lpstrType ); 2542 -extern(Windows) export MCIDEVICEID mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType ); 2543 -// #ifdef UNICODE 2544 -alias mciGetDeviceIDFromElementIDW mciGetDeviceIDFromElementID; 2545 -// #else 2546 -// #... 2547 -// #endif // !UNICODE 2548 -extern(Windows) export BOOL mciGetErrorStringA(MCIERROR mcierr, LPSTR pszText, UINT cchText); 2549 -extern(Windows) export BOOL mciGetErrorStringW(MCIERROR mcierr, LPWSTR pszText, UINT cchText); 2550 -// #ifdef UNICODE 2551 -alias mciGetErrorStringW mciGetErrorString; 2552 -// #else 2553 -// #... 2554 -// #endif // !UNICODE 2555 - 2556 -// #else 2557 -// ... 2558 -// #endif 2559 - 2560 -extern(Windows) export BOOL mciSetYieldProc(MCIDEVICEID mciId, YIELDPROC fpYieldProc, 2561 - DWORD dwYieldData); 2562 - 2563 -// #if (WINVER >= 0x030a) 2564 -extern(Windows) export HTASK mciGetCreatorTask(MCIDEVICEID mciId); 2565 -extern(Windows) export YIELDPROC mciGetYieldProc(MCIDEVICEID mciId, LPDWORD pdwYieldData); 2566 -// #endif /* ifdef WINVER >= 0x030a */ 2567 - 2568 -// #if (WINVER < 0x030a) 2569 -// ... 2570 -// #endif /* ifdef WINVER < 0x030a */ 2571 - 2572 -enum : uint { MCIERR_INVALID_DEVICE_ID = MCIERR_BASE + 1 } 2573 -enum : uint { MCIERR_UNRECOGNIZED_KEYWORD = MCIERR_BASE + 3 } 2574 -enum : uint { MCIERR_UNRECOGNIZED_COMMAND = MCIERR_BASE + 5 } 2575 -enum : uint { MCIERR_HARDWARE = MCIERR_BASE + 6 } 2576 -enum : uint { MCIERR_INVALID_DEVICE_NAME = MCIERR_BASE + 7 } 2577 -enum : uint { MCIERR_OUT_OF_MEMORY = MCIERR_BASE + 8 } 2578 -enum : uint { MCIERR_DEVICE_OPEN = MCIERR_BASE + 9 } 2579 -enum : uint { MCIERR_CANNOT_LOAD_DRIVER = MCIERR_BASE + 10 } 2580 -enum : uint { MCIERR_MISSING_COMMAND_STRING = MCIERR_BASE + 11 } 2581 -enum : uint { MCIERR_PARAM_OVERFLOW = MCIERR_BASE + 12 } 2582 -enum : uint { MCIERR_MISSING_STRING_ARGUMENT = MCIERR_BASE + 13 } 2583 -enum : uint { MCIERR_BAD_INTEGER = MCIERR_BASE + 14 } 2584 -enum : uint { MCIERR_PARSER_INTERNAL = MCIERR_BASE + 15 } 2585 -enum : uint { MCIERR_DRIVER_INTERNAL = MCIERR_BASE + 16 } 2586 -enum : uint { MCIERR_MISSING_PARAMETER = MCIERR_BASE + 17 } 2587 -enum : uint { MCIERR_UNSUPPORTED_FUNCTION = MCIERR_BASE + 18 } 2588 -enum : uint { MCIERR_FILE_NOT_FOUND = MCIERR_BASE + 19 } 2589 -enum : uint { MCIERR_DEVICE_NOT_READY = MCIERR_BASE + 20 } 2590 -enum : uint { MCIERR_INTERNAL = MCIERR_BASE + 21 } 2591 -enum : uint { MCIERR_DRIVER = MCIERR_BASE + 22 } 2592 -enum : uint { MCIERR_CANNOT_USE_ALL = MCIERR_BASE + 23 } 2593 -enum : uint { MCIERR_MULTIPLE = MCIERR_BASE + 24 } 2594 -enum : uint { MCIERR_EXTENSION_NOT_FOUND = MCIERR_BASE + 25 } 2595 -enum : uint { MCIERR_OUTOFRANGE = MCIERR_BASE + 26 } 2596 -enum : uint { MCIERR_FLAGS_NOT_COMPATIBLE = MCIERR_BASE + 28 } 2597 -enum : uint { MCIERR_FILE_NOT_SAVED = MCIERR_BASE + 30 } 2598 -enum : uint { MCIERR_DEVICE_TYPE_REQUIRED = MCIERR_BASE + 31 } 2599 -enum : uint { MCIERR_DEVICE_LOCKED = MCIERR_BASE + 32 } 2600 -enum : uint { MCIERR_DUPLICATE_ALIAS = MCIERR_BASE + 33 } 2601 -enum : uint { MCIERR_BAD_CONSTANT = MCIERR_BASE + 34 } 2602 -enum : uint { MCIERR_MUST_USE_SHAREABLE = MCIERR_BASE + 35 } 2603 -enum : uint { MCIERR_MISSING_DEVICE_NAME = MCIERR_BASE + 36 } 2604 -enum : uint { MCIERR_BAD_TIME_FORMAT = MCIERR_BASE + 37 } 2605 -enum : uint { MCIERR_NO_CLOSING_QUOTE = MCIERR_BASE + 38 } 2606 -enum : uint { MCIERR_DUPLICATE_FLAGS = MCIERR_BASE + 39 } 2607 -enum : uint { MCIERR_INVALID_FILE = MCIERR_BASE + 40 } 2608 -enum : uint { MCIERR_NULL_PARAMETER_BLOCK = MCIERR_BASE + 41 } 2609 -enum : uint { MCIERR_UNNAMED_RESOURCE = MCIERR_BASE + 42 } 2610 -enum : uint { MCIERR_NEW_REQUIRES_ALIAS = MCIERR_BASE + 43 } 2611 -enum : uint { MCIERR_NOTIFY_ON_AUTO_OPEN = MCIERR_BASE + 44 } 2612 -enum : uint { MCIERR_NO_ELEMENT_ALLOWED = MCIERR_BASE + 45 } 2613 -enum : uint { MCIERR_NONAPPLICABLE_FUNCTION = MCIERR_BASE + 46 } 2614 -enum : uint { MCIERR_ILLEGAL_FOR_AUTO_OPEN = MCIERR_BASE + 47 } 2615 -enum : uint { MCIERR_FILENAME_REQUIRED = MCIERR_BASE + 48 } 2616 -enum : uint { MCIERR_EXTRA_CHARACTERS = MCIERR_BASE + 49 } 2617 -enum : uint { MCIERR_DEVICE_NOT_INSTALLED = MCIERR_BASE + 50 } 2618 -enum : uint { MCIERR_GET_CD = MCIERR_BASE + 51 } 2619 -enum : uint { MCIERR_SET_CD = MCIERR_BASE + 52 } 2620 -enum : uint { MCIERR_SET_DRIVE = MCIERR_BASE + 53 } 2621 -enum : uint { MCIERR_DEVICE_LENGTH = MCIERR_BASE + 54 } 2622 -enum : uint { MCIERR_DEVICE_ORD_LENGTH = MCIERR_BASE + 55 } 2623 -enum : uint { MCIERR_NO_INTEGER = MCIERR_BASE + 56 } 2624 - 2625 -enum : uint { MCIERR_WAVE_OUTPUTSINUSE = MCIERR_BASE + 64 } 2626 -enum : uint { MCIERR_WAVE_SETOUTPUTINUSE = MCIERR_BASE + 65 } 2627 -enum : uint { MCIERR_WAVE_INPUTSINUSE = MCIERR_BASE + 66 } 2628 -enum : uint { MCIERR_WAVE_SETINPUTINUSE = MCIERR_BASE + 67 } 2629 -enum : uint { MCIERR_WAVE_OUTPUTUNSPECIFIED = MCIERR_BASE + 68 } 2630 -enum : uint { MCIERR_WAVE_INPUTUNSPECIFIED = MCIERR_BASE + 69 } 2631 -enum : uint { MCIERR_WAVE_OUTPUTSUNSUITABLE = MCIERR_BASE + 70 } 2632 -enum : uint { MCIERR_WAVE_SETOUTPUTUNSUITABLE = MCIERR_BASE + 71 } 2633 -enum : uint { MCIERR_WAVE_INPUTSUNSUITABLE = MCIERR_BASE + 72 } 2634 -enum : uint { MCIERR_WAVE_SETINPUTUNSUITABLE = MCIERR_BASE + 73 } 2635 - 2636 -enum : uint { MCIERR_SEQ_DIV_INCOMPATIBLE = MCIERR_BASE + 80 } 2637 -enum : uint { MCIERR_SEQ_PORT_INUSE = MCIERR_BASE + 81 } 2638 -enum : uint { MCIERR_SEQ_PORT_NONEXISTENT = MCIERR_BASE + 82 } 2639 -enum : uint { MCIERR_SEQ_PORT_MAPNODEVICE = MCIERR_BASE + 83 } 2640 -enum : uint { MCIERR_SEQ_PORT_MISCERROR = MCIERR_BASE + 84 } 2641 -enum : uint { MCIERR_SEQ_TIMER = MCIERR_BASE + 85 } 2642 -enum : uint { MCIERR_SEQ_PORTUNSPECIFIED = MCIERR_BASE + 86 } 2643 -enum : uint { MCIERR_SEQ_NOMIDIPRESENT = MCIERR_BASE + 87 } 2644 - 2645 -enum : uint { MCIERR_NO_WINDOW = MCIERR_BASE + 90 } 2646 -enum : uint { MCIERR_CREATEWINDOW = MCIERR_BASE + 91 } 2647 -enum : uint { MCIERR_FILE_READ = MCIERR_BASE + 92 } 2648 -enum : uint { MCIERR_FILE_WRITE = MCIERR_BASE + 93 } 2649 - 2650 -enum : uint { MCIERR_NO_IDENTITY = MCIERR_BASE + 94 } 2651 - 2652 -enum : uint { MCIERR_CUSTOM_DRIVER_BASE = MCIERR_BASE + 256 } 2653 - 2654 -alias DRV_MCI_FIRST MCI_FIRST; 2655 - 2656 -enum : uint { MCI_OPEN = 0x0803 } 2657 -enum : uint { MCI_CLOSE = 0x0804 } 2658 -enum : uint { MCI_ESCAPE = 0x0805 } 2659 -enum : uint { MCI_PLAY = 0x0806 } 2660 -enum : uint { MCI_SEEK = 0x0807 } 2661 -enum : uint { MCI_STOP = 0x0808 } 2662 -enum : uint { MCI_PAUSE = 0x0809 } 2663 -enum : uint { MCI_INFO = 0x080A } 2664 -enum : uint { MCI_GETDEVCAPS = 0x080B } 2665 -enum : uint { MCI_SPIN = 0x080C } 2666 -enum : uint { MCI_SET = 0x080D } 2667 -enum : uint { MCI_STEP = 0x080E } 2668 -enum : uint { MCI_RECORD = 0x080F } 2669 -enum : uint { MCI_SYSINFO = 0x0810 } 2670 -enum : uint { MCI_BREAK = 0x0811 } 2671 -enum : uint { MCI_SAVE = 0x0813 } 2672 -enum : uint { MCI_STATUS = 0x0814 } 2673 -enum : uint { MCI_CUE = 0x0830 } 2674 -enum : uint { MCI_REALIZE = 0x0840 } 2675 -enum : uint { MCI_WINDOW = 0x0841 } 2676 -enum : uint { MCI_PUT = 0x0842 } 2677 -enum : uint { MCI_WHERE = 0x0843 } 2678 -enum : uint { MCI_FREEZE = 0x0844 } 2679 -enum : uint { MCI_UNFREEZE = 0x0845 } 2680 -enum : uint { MCI_LOAD = 0x0850 } 2681 -enum : uint { MCI_CUT = 0x0851 } 2682 -enum : uint { MCI_COPY = 0x0852 } 2683 -enum : uint { MCI_PASTE = 0x0853 } 2684 -enum : uint { MCI_UPDATE = 0x0854 } 2685 -enum : uint { MCI_RESUME = 0x0855 } 2686 -enum : uint { MCI_DELETE = 0x0856 } 2687 - 2688 -enum : uint { MCI_USER_MESSAGES = DRV_MCI_FIRST + 0x400 } 2689 -enum : uint { MCI_LAST = 0x0FFF } 2690 - 2691 -enum : uint { MCI_ALL_DEVICE_ID = cast(MCIDEVICEID)-1 } 2692 - 2693 -enum : uint { MCI_DEVTYPE_VCR = 513 } 2694 -enum : uint { MCI_DEVTYPE_VIDEODISC = 514 } 2695 -enum : uint { MCI_DEVTYPE_OVERLAY = 515 } 2696 -enum : uint { MCI_DEVTYPE_CD_AUDIO = 516 } 2697 -enum : uint { MCI_DEVTYPE_DAT = 517 } 2698 -enum : uint { MCI_DEVTYPE_SCANNER = 518 } 2699 -enum : uint { MCI_DEVTYPE_ANIMATION = 519 } 2700 -enum : uint { MCI_DEVTYPE_DIGITAL_VIDEO = 520 } 2701 -enum : uint { MCI_DEVTYPE_OTHER = 521 } 2702 -enum : uint { MCI_DEVTYPE_WAVEFORM_AUDIO = 522 } 2703 -enum : uint { MCI_DEVTYPE_SEQUENCER = 523 } 2704 - 2705 -alias MCI_DEVTYPE_VCR MCI_DEVTYPE_FIRST; 2706 -alias MCI_DEVTYPE_SEQUENCER MCI_DEVTYPE_LAST; 2707 - 2708 -enum : uint { MCI_DEVTYPE_FIRST_USER = 0x1000 } 2709 - 2710 -enum : uint { MCI_MODE_NOT_READY = MCI_STRING_OFFSET + 12 } 2711 -enum : uint { MCI_MODE_STOP = MCI_STRING_OFFSET + 13 } 2712 -enum : uint { MCI_MODE_PLAY = MCI_STRING_OFFSET + 14 } 2713 -enum : uint { MCI_MODE_RECORD = MCI_STRING_OFFSET + 15 } 2714 -enum : uint { MCI_MODE_SEEK = MCI_STRING_OFFSET + 16 } 2715 -enum : uint { MCI_MODE_PAUSE = MCI_STRING_OFFSET + 17 } 2716 -enum : uint { MCI_MODE_OPEN = MCI_STRING_OFFSET + 18 } 2717 - 2718 -enum : uint { MCI_FORMAT_MILLISECONDS = 0 } 2719 -enum : uint { MCI_FORMAT_HMS = 1 } 2720 -enum : uint { MCI_FORMAT_MSF = 2 } 2721 -enum : uint { MCI_FORMAT_FRAMES = 3 } 2722 -enum : uint { MCI_FORMAT_SMPTE_24 = 4 } 2723 -enum : uint { MCI_FORMAT_SMPTE_25 = 5 } 2724 -enum : uint { MCI_FORMAT_SMPTE_30 = 6 } 2725 -enum : uint { MCI_FORMAT_SMPTE_30DROP = 7 } 2726 -enum : uint { MCI_FORMAT_BYTES = 8 } 2727 -enum : uint { MCI_FORMAT_SAMPLES = 9 } 2728 -enum : uint { MCI_FORMAT_TMSF = 10 } 2729 - 2730 -// #define MCI_MSF_MINUTE(msf) ((BYTE)(msf)) 2731 -// #define MCI_MSF_SECOND(msf) ((BYTE)(((WORD)(msf)) >> 8)) 2732 -// #define MCI_MSF_FRAME(msf) ((BYTE)((msf)>>16)) 2733 - 2734 -// #define MCI_MAKE_MSF(m, s, f) ((DWORD)(((BYTE)(m) | ((WORD)(s)<<8)) | (((DWORD)(BYTE)(f))<<16))) 2735 - 2736 -// #define MCI_TMSF_TRACK(tmsf) ((BYTE)(tmsf)) 2737 -// #define MCI_TMSF_MINUTE(tmsf) ((BYTE)(((WORD)(tmsf)) >> 8)) 2738 -// #define MCI_TMSF_SECOND(tmsf) ((BYTE)((tmsf)>>16)) 2739 -// #define MCI_TMSF_FRAME(tmsf) ((BYTE)((tmsf)>>24)) 2740 - 2741 -// #define MCI_MAKE_TMSF(t, m, s, f) ((DWORD)(((BYTE)(t) | ((WORD)(m)<<8)) | (((DWORD)(BYTE)(s) | ((WORD)(f)<<8))<<16))) 2742 - 2743 -// #define MCI_HMS_HOUR(hms) ((BYTE)(hms)) 2744 -// #define MCI_HMS_MINUTE(hms) ((BYTE)(((WORD)(hms)) >> 8)) 2745 -// #define MCI_HMS_SECOND(hms) ((BYTE)((hms)>>16)) 2746 - 2747 -// #define MCI_MAKE_HMS(h, m, s) ((DWORD)(((BYTE)(h) | ((WORD)(m)<<8)) | (((DWORD)(BYTE)(s))<<16))) 2748 - 2749 -enum : uint { MCI_NOTIFY_SUCCESSFUL = 0x0001 } 2750 -enum : uint { MCI_NOTIFY_SUPERSEDED = 0x0002 } 2751 -enum : uint { MCI_NOTIFY_ABORTED = 0x0004 } 2752 -enum : uint { MCI_NOTIFY_FAILURE = 0x0008 } 2753 - 2754 -enum : uint { MCI_NOTIFY = 0x00000001 } 2755 -enum : uint { MCI_WAIT = 0x00000002 } 2756 -enum : uint { MCI_FROM = 0x00000004 } 2757 -enum : uint { MCI_TO = 0x00000008 } 2758 -enum : uint { MCI_TRACK = 0x00000010 } 2759 - 2760 -enum : uint { MCI_OPEN_SHAREABLE = 0x00000100 } 2761 -enum : uint { MCI_OPEN_ELEMENT = 0x00000200 } 2762 -enum : uint { MCI_OPEN_ALIAS = 0x00000400 } 2763 -enum : uint { MCI_OPEN_ELEMENT_ID = 0x00000800 } 2764 -enum : uint { MCI_OPEN_TYPE_ID = 0x00001000 } 2765 -enum : uint { MCI_OPEN_TYPE = 0x00002000 } 2766 - 2767 -enum : uint { MCI_SEEK_TO_START = 0x00000100 } 2768 -enum : uint { MCI_SEEK_TO_END = 0x00000200 } 2769 - 2770 -enum : uint { MCI_STATUS_ITEM = 0x00000100 } 2771 -enum : uint { MCI_STATUS_START = 0x00000200 } 2772 - 2773 -enum : uint { MCI_STATUS_LENGTH = 0x00000001 } 2774 -enum : uint { MCI_STATUS_POSITION = 0x00000002 } 2775 -enum : uint { MCI_STATUS_NUMBER_OF_TRACKS = 0x00000003 } 2776 -enum : uint { MCI_STATUS_MODE = 0x00000004 } 2777 -enum : uint { MCI_STATUS_MEDIA_PRESENT = 0x00000005 } 2778 -enum : uint { MCI_STATUS_TIME_FORMAT = 0x00000006 } 2779 -enum : uint { MCI_STATUS_READY = 0x00000007 } 2780 -enum : uint { MCI_STATUS_CURRENT_TRACK = 0x00000008 } 2781 - 2782 -enum : uint { MCI_INFO_PRODUCT = 0x00000100 } 2783 -enum : uint { MCI_INFO_FILE = 0x00000200 } 2784 -enum : uint { MCI_INFO_MEDIA_UPC = 0x00000400 } 2785 -enum : uint { MCI_INFO_MEDIA_IDENTITY = 0x00000800 } 2786 -enum : uint { MCI_INFO_NAME = 0x00001000 } 2787 -enum : uint { MCI_INFO_COPYRIGHT = 0x00002000 } 2788 - 2789 -enum : uint { MCI_GETDEVCAPS_ITEM = 0x00000100 } 2790 - 2791 -enum : uint { MCI_GETDEVCAPS_CAN_RECORD = 0x00000001 } 2792 -enum : uint { MCI_GETDEVCAPS_HAS_AUDIO = 0x00000002 } 2793 -enum : uint { MCI_GETDEVCAPS_HAS_VIDEO = 0x00000003 } 2794 -enum : uint { MCI_GETDEVCAPS_DEVICE_TYPE = 0x00000004 } 2795 -enum : uint { MCI_GETDEVCAPS_USES_FILES = 0x00000005 } 2796 -enum : uint { MCI_GETDEVCAPS_COMPOUND_DEVICE = 0x00000006 } 2797 -enum : uint { MCI_GETDEVCAPS_CAN_EJECT = 0x00000007 } 2798 -enum : uint { MCI_GETDEVCAPS_CAN_PLAY = 0x00000008 } 2799 -enum : uint { MCI_GETDEVCAPS_CAN_SAVE = 0x00000009 } 2800 - 2801 -enum : uint { MCI_SYSINFO_QUANTITY = 0x00000100 } 2802 -enum : uint { MCI_SYSINFO_OPEN = 0x00000200 } 2803 -enum : uint { MCI_SYSINFO_NAME = 0x00000400 } 2804 -enum : uint { MCI_SYSINFO_INSTALLNAME = 0x00000800 } 2805 - 2806 -enum : uint { MCI_SET_DOOR_OPEN = 0x00000100 } 2807 -enum : uint { MCI_SET_DOOR_CLOSED = 0x00000200 } 2808 -enum : uint { MCI_SET_TIME_FORMAT = 0x00000400 } 2809 -enum : uint { MCI_SET_AUDIO = 0x00000800 } 2810 -enum : uint { MCI_SET_VIDEO = 0x00001000 } 2811 -enum : uint { MCI_SET_ON = 0x00002000 } 2812 -enum : uint { MCI_SET_OFF = 0x00004000 } 2813 - 2814 -enum : uint { MCI_SET_AUDIO_ALL = 0x00000000 } 2815 -enum : uint { MCI_SET_AUDIO_LEFT = 0x00000001 } 2816 -enum : uint { MCI_SET_AUDIO_RIGHT = 0x00000002 } 2817 - 2818 -enum : uint { MCI_BREAK_KEY = 0x00000100 } 2819 -enum : uint { MCI_BREAK_HWND = 0x00000200 } 2820 -enum : uint { MCI_BREAK_OFF = 0x00000400 } 2821 - 2822 -enum : uint { MCI_RECORD_INSERT = 0x00000100 } 2823 -enum : uint { MCI_RECORD_OVERWRITE = 0x00000200 } 2824 - 2825 -enum : uint { MCI_SAVE_FILE = 0x00000100 } 2826 - 2827 -enum : uint { MCI_LOAD_FILE = 0x00000100 } 2828 - 2829 -struct tagMCI_GENERIC_PARMS { 2830 - DWORD_PTR dwCallback; 2831 -} 2832 -alias tagMCI_GENERIC_PARMS MCI_GENERIC_PARMS; 2833 -alias tagMCI_GENERIC_PARMS* PMCI_GENERIC_PARMS; 2834 -alias tagMCI_GENERIC_PARMS* LPMCI_GENERIC_PARMS; 2835 - 2836 -// #ifdef _WIN32 2837 - 2838 -struct tagMCI_OPEN_PARMSA { 2839 - DWORD_PTR dwCallback; 2840 - MCIDEVICEID wDeviceID; 2841 - LPCSTR lpstrDeviceType; 2842 - LPCSTR lpstrElementName; 2843 - LPCSTR lpstrAlias; 2844 -} 2845 -alias tagMCI_OPEN_PARMSA MCI_OPEN_PARMSA; 2846 -alias tagMCI_OPEN_PARMSA* PMCI_OPEN_PARMSA; 2847 -alias tagMCI_OPEN_PARMSA* LPMCI_OPEN_PARMSA; 2848 - 2849 -struct tagMCI_OPEN_PARMSW { 2850 - DWORD_PTR dwCallback; 2851 - MCIDEVICEID wDeviceID; 2852 - LPCWSTR lpstrDeviceType; 2853 - LPCWSTR lpstrElementName; 2854 - LPCWSTR lpstrAlias; 2855 -} 2856 -alias tagMCI_OPEN_PARMSW MCI_OPEN_PARMSW; 2857 -alias tagMCI_OPEN_PARMSW* PMCI_OPEN_PARMSW; 2858 -alias tagMCI_OPEN_PARMSW* LPMCI_OPEN_PARMSW; 2859 - 2860 -// #ifdef UNICODE 2861 -alias MCI_OPEN_PARMSW MCI_OPEN_PARMS; 2862 -alias PMCI_OPEN_PARMSW PMCI_OPEN_PARMS; 2863 -alias LPMCI_OPEN_PARMSW LPMCI_OPEN_PARMS; 2864 -// #else 2865 -// ... 2866 -// #endif // UNICODE 2867 - 2868 -// #else 2869 -// ... 2870 -// #endif 2871 - 2872 -struct tagMCI_PLAY_PARMS { 2873 - DWORD_PTR dwCallback; 2874 - DWORD dwFrom; 2875 - DWORD dwTo; 2876 -} 2877 -alias tagMCI_PLAY_PARMS MCI_PLAY_PARMS; 2878 -alias tagMCI_PLAY_PARMS* PMCI_PLAY_PARMS; 2879 -alias tagMCI_PLAY_PARMS* LPMCI_PLAY_PARMS; 2880 - 2881 -struct tagMCI_SEEK_PARMS { 2882 - DWORD_PTR dwCallback; 2883 - DWORD dwTo; 2884 -} 2885 -alias tagMCI_SEEK_PARMS MCI_SEEK_PARMS; 2886 -alias tagMCI_SEEK_PARMS* PMCI_SEEK_PARMS; 2887 -alias tagMCI_SEEK_PARMS* LPMCI_SEEK_PARMS; 2888 - 2889 -struct tagMCI_STATUS_PARMS { 2890 - DWORD_PTR dwCallback; 2891 - DWORD_PTR dwReturn; 2892 - DWORD dwItem; 2893 - DWORD dwTrack; 2894 -} 2895 -alias tagMCI_STATUS_PARMS MCI_STATUS_PARMS; 2896 -alias tagMCI_STATUS_PARMS* PMCI_STATUS_PARMS; 2897 -alias tagMCI_STATUS_PARMS* LPMCI_STATUS_PARMS; 2898 - 2899 -// #ifdef _WIN32 2900 - 2901 -struct tagMCI_INFO_PARMSA { 2902 - DWORD_PTR dwCallback; 2903 - LPSTR lpstrReturn; 2904 - DWORD dwRetSize; 2905 -} 2906 -alias tagMCI_INFO_PARMSA MCI_INFO_PARMSA; 2907 -alias tagMCI_INFO_PARMSA* LPMCI_INFO_PARMSA; 2908 - 2909 -struct tagMCI_INFO_PARMSW { 2910 - DWORD_PTR dwCallback; 2911 - LPWSTR lpstrReturn; 2912 - DWORD dwRetSize; 2913 -} 2914 -alias tagMCI_INFO_PARMSW MCI_INFO_PARMSW; 2915 -alias tagMCI_INFO_PARMSW* LPMCI_INFO_PARMSW; 2916 - 2917 -// #ifdef UNICODE 2918 -alias MCI_INFO_PARMSW MCI_INFO_PARMS; 2919 -alias LPMCI_INFO_PARMSW LPMCI_INFO_PARMS; 2920 -// #else 2921 -// ... 2922 -// #endif // UNICODE 2923 - 2924 -// #else 2925 -// ... 2926 -// #endif 2927 - 2928 -struct tagMCI_GETDEVCAPS_PARMS { 2929 - DWORD_PTR dwCallback; 2930 - DWORD dwReturn; 2931 - DWORD dwItem; 2932 -} 2933 -alias tagMCI_GETDEVCAPS_PARMS MCI_GETDEVCAPS_PARMS; 2934 -alias tagMCI_GETDEVCAPS_PARMS* PMCI_GETDEVCAPS_PARMS; 2935 -alias tagMCI_GETDEVCAPS_PARMS* LPMCI_GETDEVCAPS_PARMS; 2936 - 2937 -// #ifdef _WIN32 2938 - 2939 -struct tagMCI_SYSINFO_PARMSA { 2940 - DWORD_PTR dwCallback; 2941 - LPSTR lpstrReturn; 2942 - DWORD dwRetSize; 2943 - DWORD dwNumber; 2944 - UINT wDeviceType; 2945 -} 2946 -alias tagMCI_SYSINFO_PARMSA MCI_SYSINFO_PARMSA; 2947 -alias tagMCI_SYSINFO_PARMSA* PMCI_SYSINFO_PARMSA; 2948 -alias tagMCI_SYSINFO_PARMSA* LPMCI_SYSINFO_PARMSA; 2949 - 2950 -struct tagMCI_SYSINFO_PARMSW { 2951 - DWORD_PTR dwCallback; 2952 - LPWSTR lpstrReturn; 2953 - DWORD dwRetSize; 2954 - DWORD dwNumber; 2955 - UINT wDeviceType; 2956 -} 2957 -alias tagMCI_SYSINFO_PARMSW MCI_SYSINFO_PARMSW; 2958 -alias tagMCI_SYSINFO_PARMSW* PMCI_SYSINFO_PARMSW; 2959 -alias tagMCI_SYSINFO_PARMSW* LPMCI_SYSINFO_PARMSW; 2960 - 2961 -// #ifdef UNICODE 2962 -alias MCI_SYSINFO_PARMSW MCI_SYSINFO_PARMS; 2963 -alias PMCI_SYSINFO_PARMSW PMCI_SYSINFO_PARMS; 2964 -alias LPMCI_SYSINFO_PARMSW LPMCI_SYSINFO_PARMS; 2965 -// #else 2966 -// ... 2967 -// #endif // UNICODE 2968 -// #else 2969 -// ... 2970 -// #endif 2971 - 2972 -struct tagMCI_SET_PARMS { 2973 - DWORD_PTR dwCallback; 2974 - DWORD dwTimeFormat; 2975 - DWORD dwAudio; 2976 -} 2977 -alias tagMCI_SET_PARMS MCI_SET_PARMS; 2978 -alias tagMCI_SET_PARMS* PMCI_SET_PARMS; 2979 -alias tagMCI_SET_PARMS* LPMCI_SET_PARMS; 2980 - 2981 -struct tagMCI_BREAK_PARMS { 2982 - DWORD_PTR dwCallback; 2983 -// #ifdef _WIN32 2984 - int nVirtKey; 2985 - HWND hwndBreak; 2986 -// #else 2987 -// ... 2988 -// #endif 2989 -} 2990 -alias tagMCI_BREAK_PARMS MCI_BREAK_PARMS; 2991 -alias tagMCI_BREAK_PARMS* PMCI_BREAK_PARMS; 2992 -alias tagMCI_BREAK_PARMS* LPMCI_BREAK_PARMS; 2993 - 2994 -// #ifdef _WIN32 2995 - 2996 -struct tagMCI_SAVE_PARMSA { 2997 - DWORD_PTR dwCallback; 2998 - LPCSTR lpfilename; 2999 -} 3000 -alias tagMCI_SAVE_PARMSA MCI_SAVE_PARMSA; 3001 -alias tagMCI_SAVE_PARMSA* PMCI_SAVE_PARMSA; 3002 -alias tagMCI_SAVE_PARMSA* LPMCI_SAVE_PARMSA; 3003 - 3004 -struct tagMCI_SAVE_PARMSW { 3005 - DWORD_PTR dwCallback; 3006 - LPCWSTR lpfilename; 3007 -} 3008 -alias tagMCI_SAVE_PARMSW MCI_SAVE_PARMSW; 3009 -alias tagMCI_SAVE_PARMSW* PMCI_SAVE_PARMSW; 3010 -alias tagMCI_SAVE_PARMSW* LPMCI_SAVE_PARMSW; 3011 - 3012 -// #ifdef UNICODE 3013 -alias MCI_SAVE_PARMSW MCI_SAVE_PARMS; 3014 -alias PMCI_SAVE_PARMSW PMCI_SAVE_PARMS; 3015 -alias LPMCI_SAVE_PARMSW LPMCI_SAVE_PARMS; 3016 -// #else 3017 -// ... 3018 -// #endif // UNICODE 3019 - 3020 -// #else 3021 -// ... 3022 -// #endif 3023 - 3024 -// #ifdef _WIN32 3025 - 3026 -struct tagMCI_LOAD_PARMSA { 3027 - DWORD_PTR dwCallback; 3028 - LPCSTR lpfilename; 3029 -} 3030 -alias tagMCI_LOAD_PARMSA MCI_LOAD_PARMSA; 3031 -alias tagMCI_LOAD_PARMSA* PMCI_LOAD_PARMSA; 3032 -alias tagMCI_LOAD_PARMSA* LPMCI_LOAD_PARMSA; 3033 - 3034 -struct tagMCI_LOAD_PARMSW { 3035 - DWORD_PTR dwCallback; 3036 - LPCWSTR lpfilename; 3037 -} 3038 -alias tagMCI_LOAD_PARMSW MCI_LOAD_PARMSW; 3039 -alias tagMCI_LOAD_PARMSW* PMCI_LOAD_PARMSW; 3040 -alias tagMCI_LOAD_PARMSW* LPMCI_LOAD_PARMSW; 3041 - 3042 -// #ifdef UNICODE 3043 -alias MCI_LOAD_PARMSW MCI_LOAD_PARMS; 3044 -alias PMCI_LOAD_PARMSW PMCI_LOAD_PARMS; 3045 -alias LPMCI_LOAD_PARMSW LPMCI_LOAD_PARMS; 3046 -// #else 3047 -// ... 3048 -// #endif // UNICODE 3049 - 3050 -// #else 3051 -// ... 3052 -// #endif 3053 - 3054 -struct tagMCI_RECORD_PARMS { 3055 - DWORD_PTR dwCallback; 3056 - DWORD dwFrom; 3057 - DWORD dwTo; 3058 -} 3059 -alias tagMCI_RECORD_PARMS MCI_RECORD_PARMS; 3060 -alias tagMCI_RECORD_PARMS* LPMCI_RECORD_PARMS; 3061 - 3062 -enum : uint { MCI_VD_MODE_PARK = MCI_VD_OFFSET + 1 } 3063 - 3064 -enum : uint { MCI_VD_MEDIA_CLV = MCI_VD_OFFSET + 2 } 3065 -enum : uint { MCI_VD_MEDIA_CAV = MCI_VD_OFFSET + 3 } 3066 -enum : uint { MCI_VD_MEDIA_OTHER = MCI_VD_OFFSET + 4 } 3067 - 3068 -enum : uint { MCI_VD_FORMAT_TRACK = 0x4001 } 3069 - 3070 -enum : uint { MCI_VD_PLAY_REVERSE = 0x00010000 } 3071 -enum : uint { MCI_VD_PLAY_FAST = 0x00020000 } 3072 -enum : uint { MCI_VD_PLAY_SPEED = 0x00040000 } 3073 -enum : uint { MCI_VD_PLAY_SCAN = 0x00080000 } 3074 -enum : uint { MCI_VD_PLAY_SLOW = 0x00100000 } 3075 - 3076 -enum : uint { MCI_VD_SEEK_REVERSE = 0x00010000 } 3077 - 3078 -enum : uint { MCI_VD_STATUS_SPEED = 0x00004002 } 3079 -enum : uint { MCI_VD_STATUS_FORWARD = 0x00004003 } 3080 -enum : uint { MCI_VD_STATUS_MEDIA_TYPE = 0x00004004 } 3081 -enum : uint { MCI_VD_STATUS_SIDE = 0x00004005 } 3082 -enum : uint { MCI_VD_STATUS_DISC_SIZE = 0x00004006 } 3083 - 3084 -enum : uint { MCI_VD_GETDEVCAPS_CLV = 0x00010000 } 3085 -enum : uint { MCI_VD_GETDEVCAPS_CAV = 0x00020000 } 3086 - 3087 -enum : uint { MCI_VD_SPIN_UP = 0x00010000 } 3088 -enum : uint { MCI_VD_SPIN_DOWN = 0x00020000 } 3089 - 3090 -enum : uint { MCI_VD_GETDEVCAPS_CAN_REVERSE = 0x00004002 } 3091 -enum : uint { MCI_VD_GETDEVCAPS_FAST_RATE = 0x00004003 } 3092 -enum : uint { MCI_VD_GETDEVCAPS_SLOW_RATE = 0x00004004 } 3093 -enum : uint { MCI_VD_GETDEVCAPS_NORMAL_RATE = 0x00004005 } 3094 - 3095 -enum : uint { MCI_VD_STEP_FRAMES = 0x00010000 } 3096 -enum : uint { MCI_VD_STEP_REVERSE = 0x00020000 } 3097 - 3098 -enum : uint { MCI_VD_ESCAPE_STRING = 0x00000100 } 3099 - 3100 -struct tagMCI_VD_PLAY_PARMS { 3101 - DWORD_PTR dwCallback; 3102 - DWORD dwFrom; 3103 - DWORD dwTo; 3104 - DWORD dwSpeed; 3105 -} 3106 -alias tagMCI_VD_PLAY_PARMS MCI_VD_PLAY_PARMS; 3107 -alias tagMCI_VD_PLAY_PARMS* PMCI_VD_PLAY_PARMS; 3108 -alias tagMCI_VD_PLAY_PARMS* LPMCI_VD_PLAY_PARMS; 3109 - 3110 -struct tagMCI_VD_STEP_PARMS { 3111 - DWORD_PTR dwCallback; 3112 - DWORD dwFrames; 3113 -} 3114 -alias tagMCI_VD_STEP_PARMS MCI_VD_STEP_PARMS; 3115 -alias tagMCI_VD_STEP_PARMS* PMCI_VD_STEP_PARMS; 3116 -alias tagMCI_VD_STEP_PARMS* LPMCI_VD_STEP_PARMS; 3117 - 3118 -// #ifdef _WIN32 3119 - 3120 -struct tagMCI_VD_ESCAPE_PARMSA { 3121 - DWORD_PTR dwCallback; 3122 - LPCSTR lpstrCommand; 3123 -} 3124 -alias tagMCI_VD_ESCAPE_PARMSA MCI_VD_ESCAPE_PARMSA; 3125 -alias tagMCI_VD_ESCAPE_PARMSA* PMCI_VD_ESCAPE_PARMSA; 3126 -alias tagMCI_VD_ESCAPE_PARMSA* LPMCI_VD_ESCAPE_PARMSA; 3127 - 3128 -struct tagMCI_VD_ESCAPE_PARMSW { 3129 - DWORD_PTR dwCallback; 3130 - LPCWSTR lpstrCommand; 3131 -} 3132 -alias tagMCI_VD_ESCAPE_PARMSW MCI_VD_ESCAPE_PARMSW; 3133 -alias tagMCI_VD_ESCAPE_PARMSW* PMCI_VD_ESCAPE_PARMSW; 3134 -alias tagMCI_VD_ESCAPE_PARMSW* LPMCI_VD_ESCAPE_PARMSW; 3135 - 3136 -// #ifdef UNICODE 3137 -alias MCI_VD_ESCAPE_PARMSW MCI_VD_ESCAPE_PARMS; 3138 -alias PMCI_VD_ESCAPE_PARMSW PMCI_VD_ESCAPE_PARMS; 3139 -alias LPMCI_VD_ESCAPE_PARMSW LPMCI_VD_ESCAPE_PARMS; 3140 -// #else 3141 -// ... 3142 -// #endif // UNICODE 3143 - 3144 -// #else 3145 -// ... 3146 -// #endif 3147 - 3148 -enum : uint { MCI_CDA_STATUS_TYPE_TRACK = 0x00004001 } 3149 - 3150 -enum : uint { MCI_CDA_TRACK_AUDIO = MCI_CD_OFFSET + 0 } 3151 -enum : uint { MCI_CDA_TRACK_OTHER = MCI_CD_OFFSET + 1 } 3152 - 3153 -enum : uint { MCI_WAVE_PCM = MCI_WAVE_OFFSET + 0 } 3154 -enum : uint { MCI_WAVE_MAPPER = MCI_WAVE_OFFSET + 1 } 3155 - 3156 -enum : uint { MCI_WAVE_OPEN_BUFFER = 0x00010000 } 3157 - 3158 -enum : uint { MCI_WAVE_SET_FORMATTAG = 0x00010000 } 3159 -enum : uint { MCI_WAVE_SET_CHANNELS = 0x00020000 } 3160 -enum : uint { MCI_WAVE_SET_SAMPLESPERSEC = 0x00040000 } 3161 -enum : uint { MCI_WAVE_SET_AVGBYTESPERSEC = 0x00080000 } 3162 -enum : uint { MCI_WAVE_SET_BLOCKALIGN = 0x00100000 } 3163 -enum : uint { MCI_WAVE_SET_BITSPERSAMPLE = 0x00200000 } 3164 - 3165 -enum : uint { MCI_WAVE_INPUT = 0x00400000 } 3166 -enum : uint { MCI_WAVE_OUTPUT = 0x00800000 } 3167 - 3168 -enum : uint { MCI_WAVE_STATUS_FORMATTAG = 0x00004001 } 3169 -enum : uint { MCI_WAVE_STATUS_CHANNELS = 0x00004002 } 3170 -enum : uint { MCI_WAVE_STATUS_SAMPLESPERSEC = 0x00004003 } 3171 -enum : uint { MCI_WAVE_STATUS_AVGBYTESPERSEC = 0x00004004 } 3172 -enum : uint { MCI_WAVE_STATUS_BLOCKALIGN = 0x00004005 } 3173 -enum : uint { MCI_WAVE_STATUS_BITSPERSAMPLE = 0x00004006 } 3174 -enum : uint { MCI_WAVE_STATUS_LEVEL = 0x00004007 } 3175 - 3176 -enum : uint { MCI_WAVE_SET_ANYINPUT = 0x04000000 } 3177 -enum : uint { MCI_WAVE_SET_ANYOUTPUT = 0x08000000 } 3178 - 3179 -enum : uint { MCI_WAVE_GETDEVCAPS_INPUTS = 0x00004001 } 3180 -enum : uint { MCI_WAVE_GETDEVCAPS_OUTPUTS = 0x00004002 } 3181 - 3182 -// #ifdef _WIN32 3183 - 3184 -struct tagMCI_WAVE_OPEN_PARMSA { 3185 - DWORD_PTR dwCallback; 3186 - MCIDEVICEID wDeviceID; 3187 - LPCSTR lpstrDeviceType; 3188 - LPCSTR lpstrElementName; 3189 - LPCSTR lpstrAlias; 3190 - DWORD dwBufferSeconds; 3191 -} 3192 -alias tagMCI_WAVE_OPEN_PARMSA MCI_WAVE_OPEN_PARMSA; 3193 -alias tagMCI_WAVE_OPEN_PARMSA* PMCI_WAVE_OPEN_PARMSA; 3194 -alias tagMCI_WAVE_OPEN_PARMSA* LPMCI_WAVE_OPEN_PARMSA; 3195 - 3196 -struct tagMCI_WAVE_OPEN_PARMSW { 3197 - DWORD_PTR dwCallback; 3198 - MCIDEVICEID wDeviceID; 3199 - LPCWSTR lpstrDeviceType; 3200 - LPCWSTR lpstrElementName; 3201 - LPCWSTR lpstrAlias; 3202 - DWORD dwBufferSeconds; 3203 -} 3204 -alias tagMCI_WAVE_OPEN_PARMSW MCI_WAVE_OPEN_PARMSW; 3205 -alias tagMCI_WAVE_OPEN_PARMSW* PMCI_WAVE_OPEN_PARMSW; 3206 -alias tagMCI_WAVE_OPEN_PARMSW* LPMCI_WAVE_OPEN_PARMSW; 3207 - 3208 -// #ifdef UNICODE 3209 -alias MCI_WAVE_OPEN_PARMSW MCI_WAVE_OPEN_PARMS; 3210 -alias PMCI_WAVE_OPEN_PARMSW PMCI_WAVE_OPEN_PARMS; 3211 -alias LPMCI_WAVE_OPEN_PARMSW LPMCI_WAVE_OPEN_PARMS; 3212 -// #else 3213 -// ... 3214 -// #endif // UNICODE 3215 - 3216 -// #else 3217 -// ... 3218 -// #endif 3219 - 3220 -struct tagMCI_WAVE_DELETE_PARMS { 3221 - DWORD_PTR dwCallback; 3222 - DWORD dwFrom; 3223 - DWORD dwTo; 3224 -} 3225 -alias tagMCI_WAVE_DELETE_PARMS MCI_WAVE_DELETE_PARMS; 3226 -alias tagMCI_WAVE_DELETE_PARMS* PMCI_WAVE_DELETE_PARMS; 3227 -alias tagMCI_WAVE_DELETE_PARMS* LPMCI_WAVE_DELETE_PARMS; 3228 - 3229 -struct tagMCI_WAVE_SET_PARMS { 3230 - DWORD_PTR dwCallback; 3231 - DWORD dwTimeFormat; 3232 - DWORD dwAudio; 3233 -// #ifdef _WIN32 3234 - UINT wInput; 3235 - UINT wOutput; 3236 -// #else 3237 -// ... 3238 -// #endif 3239 - WORD wFormatTag; 3240 - WORD wReserved2; 3241 - WORD nChannels; 3242 - WORD wReserved3; 3243 - DWORD nSamplesPerSec; 3244 - DWORD nAvgBytesPerSec; 3245 - WORD nBlockAlign; 3246 - WORD wReserved4; 3247 - WORD wBitsPerSample; 3248 - WORD wReserved5; 3249 -} 3250 -alias tagMCI_WAVE_SET_PARMS MCI_WAVE_SET_PARMS; 3251 -alias tagMCI_WAVE_SET_PARMS* PMCI_WAVE_SET_PARMS; 3252 -alias tagMCI_WAVE_SET_PARMS* LPMCI_WAVE_SET_PARMS; 3253 - 3254 -enum : uint { MCI_SEQ_DIV_PPQN = 0 + MCI_SEQ_OFFSET } 3255 -enum : uint { MCI_SEQ_DIV_SMPTE_24 = 1 + MCI_SEQ_OFFSET } 3256 -enum : uint { MCI_SEQ_DIV_SMPTE_25 = 2 + MCI_SEQ_OFFSET } 3257 -enum : uint { MCI_SEQ_DIV_SMPTE_30DROP = 3 + MCI_SEQ_OFFSET } 3258 -enum : uint { MCI_SEQ_DIV_SMPTE_30 = 4 + MCI_SEQ_OFFSET } 3259 - 3260 -enum : uint { MCI_SEQ_FORMAT_SONGPTR = 0x4001 } 3261 -enum : uint { MCI_SEQ_FILE = 0x4002 } 3262 -enum : uint { MCI_SEQ_MIDI = 0x4003 } 3263 -enum : uint { MCI_SEQ_SMPTE = 0x4004 } 3264 -enum : uint { MCI_SEQ_NONE = 65533 } 3265 -enum : uint { MCI_SEQ_MAPPER = 65535 } 3266 - 3267 -enum : uint { MCI_SEQ_STATUS_TEMPO = 0x00004002 } 3268 -enum : uint { MCI_SEQ_STATUS_PORT = 0x00004003 } 3269 -enum : uint { MCI_SEQ_STATUS_SLAVE = 0x00004007 } 3270 -enum : uint { MCI_SEQ_STATUS_MASTER = 0x00004008 } 3271 -enum : uint { MCI_SEQ_STATUS_OFFSET = 0x00004009 } 3272 -enum : uint { MCI_SEQ_STATUS_DIVTYPE = 0x0000400A } 3273 -enum : uint { MCI_SEQ_STATUS_NAME = 0x0000400B } 3274 -enum : uint { MCI_SEQ_STATUS_COPYRIGHT = 0x0000400C } 3275 - 3276 -enum : uint { MCI_SEQ_SET_TEMPO = 0x00010000 } 3277 -enum : uint { MCI_SEQ_SET_PORT = 0x00020000 } 3278 -enum : uint { MCI_SEQ_SET_SLAVE = 0x00040000 } 3279 -enum : uint { MCI_SEQ_SET_MASTER = 0x00080000 } 3280 -enum : uint { MCI_SEQ_SET_OFFSET = 0x01000000 } 3281 - 3282 -struct tagMCI_SEQ_SET_PARMS { 3283 - DWORD_PTR dwCallback; 3284 - DWORD dwTimeFormat; 3285 - DWORD dwAudio; 3286 - DWORD dwTempo; 3287 - DWORD dwPort; 3288 - DWORD dwSlave; 3289 - DWORD dwMaster; 3290 - DWORD dwOffset; 3291 -} 3292 -alias tagMCI_SEQ_SET_PARMS MCI_SEQ_SET_PARMS; 3293 -alias tagMCI_SEQ_SET_PARMS* PMCI_SEQ_SET_PARMS; 3294 -alias tagMCI_SEQ_SET_PARMS* LPMCI_SEQ_SET_PARMS; 3295 - 3296 -enum : uint { MCI_ANIM_OPEN_WS = 0x00010000 } 3297 -enum : uint { MCI_ANIM_OPEN_PARENT = 0x00020000 } 3298 -enum : uint { MCI_ANIM_OPEN_NOSTATIC = 0x00040000 } 3299 - 3300 -enum : uint { MCI_ANIM_PLAY_SPEED = 0x00010000 } 3301 -enum : uint { MCI_ANIM_PLAY_REVERSE = 0x00020000 } 3302 -enum : uint { MCI_ANIM_PLAY_FAST = 0x00040000 } 3303 -enum : uint { MCI_ANIM_PLAY_SLOW = 0x00080000 } 3304 -enum : uint { MCI_ANIM_PLAY_SCAN = 0x00100000 } 3305 - 3306 -enum : uint { MCI_ANIM_STEP_REVERSE = 0x00010000 } 3307 -enum : uint { MCI_ANIM_STEP_FRAMES = 0x00020000 } 3308 - 3309 -enum : uint { MCI_ANIM_STATUS_SPEED = 0x00004001 } 3310 -enum : uint { MCI_ANIM_STATUS_FORWARD = 0x00004002 } 3311 -enum : uint { MCI_ANIM_STATUS_HWND = 0x00004003 } 3312 -enum : uint { MCI_ANIM_STATUS_HPAL = 0x00004004 } 3313 -enum : uint { MCI_ANIM_STATUS_STRETCH = 0x00004005 } 3314 - 3315 -enum : uint { MCI_ANIM_INFO_TEXT = 0x00010000 } 3316 - 3317 -enum : uint { MCI_ANIM_GETDEVCAPS_CAN_REVERSE = 0x00004001 } 3318 -enum : uint { MCI_ANIM_GETDEVCAPS_FAST_RATE = 0x00004002 } 3319 -enum : uint { MCI_ANIM_GETDEVCAPS_SLOW_RATE = 0x00004003 } 3320 -enum : uint { MCI_ANIM_GETDEVCAPS_NORMAL_RATE = 0x00004004 } 3321 -enum : uint { MCI_ANIM_GETDEVCAPS_PALETTES = 0x00004006 } 3322 -enum : uint { MCI_ANIM_GETDEVCAPS_CAN_STRETCH = 0x00004007 } 3323 -enum : uint { MCI_ANIM_GETDEVCAPS_MAX_WINDOWS = 0x00004008 } 3324 - 3325 -enum : uint { MCI_ANIM_REALIZE_NORM = 0x00010000 } 3326 -enum : uint { MCI_ANIM_REALIZE_BKGD = 0x00020000 } 3327 - 3328 -enum : uint { MCI_ANIM_WINDOW_HWND = 0x00010000 } 3329 -enum : uint { MCI_ANIM_WINDOW_STATE = 0x00040000 } 3330 -enum : uint { MCI_ANIM_WINDOW_TEXT = 0x00080000 } 3331 -enum : uint { MCI_ANIM_WINDOW_ENABLE_STRETCH = 0x00100000 } 3332 -enum : uint { MCI_ANIM_WINDOW_DISABLE_STRETCH = 0x00200000 } 3333 - 3334 -enum : uint { MCI_ANIM_WINDOW_DEFAULT = 0x00000000 } 3335 - 3336 -enum : uint { MCI_ANIM_RECT = 0x00010000 } 3337 -enum : uint { MCI_ANIM_PUT_SOURCE = 0x00020000 } 3338 -enum : uint { MCI_ANIM_PUT_DESTINATION = 0x00040000 } 3339 - 3340 -enum : uint { MCI_ANIM_WHERE_SOURCE = 0x00020000 } 3341 -enum : uint { MCI_ANIM_WHERE_DESTINATION = 0x00040000 } 3342 - 3343 -enum : uint { MCI_ANIM_UPDATE_HDC = 0x00020000 } 3344 - 3345 -// #ifdef _WIN32 3346 - 3347 -struct tagMCI_ANIM_OPEN_PARMSA { 3348 - DWORD_PTR dwCallback; 3349 - MCIDEVICEID wDeviceID; 3350 - LPCSTR lpstrDeviceType; 3351 - LPCSTR lpstrElementName; 3352 - LPCSTR lpstrAlias; 3353 - DWORD dwStyle; 3354 - HWND hWndParent; 3355 -} 3356 -alias tagMCI_ANIM_OPEN_PARMSA MCI_ANIM_OPEN_PARMSA; 3357 -alias tagMCI_ANIM_OPEN_PARMSA* PMCI_ANIM_OPEN_PARMSA; 3358 -alias tagMCI_ANIM_OPEN_PARMSA* LPMCI_ANIM_OPEN_PARMSA; 3359 - 3360 -struct tagMCI_ANIM_OPEN_PARMSW { 3361 - DWORD_PTR dwCallback; 3362 - MCIDEVICEID wDeviceID; 3363 - LPCWSTR lpstrDeviceType; 3364 - LPCWSTR lpstrElementName; 3365 - LPCWSTR lpstrAlias; 3366 - DWORD dwStyle; 3367 - HWND hWndParent; 3368 -} 3369 -alias tagMCI_ANIM_OPEN_PARMSW MCI_ANIM_OPEN_PARMSW; 3370 -alias tagMCI_ANIM_OPEN_PARMSW* PMCI_ANIM_OPEN_PARMSW; 3371 -alias tagMCI_ANIM_OPEN_PARMSW* LPMCI_ANIM_OPEN_PARMSW; 3372 - 3373 -// #ifdef UNICODE 3374 -alias MCI_ANIM_OPEN_PARMSW MCI_ANIM_OPEN_PARMS; 3375 -alias PMCI_ANIM_OPEN_PARMSW PMCI_ANIM_OPEN_PARMS; 3376 -alias LPMCI_ANIM_OPEN_PARMSW LPMCI_ANIM_OPEN_PARMS; 3377 -// #else 3378 -// ... 3379 -// #endif // UNICODE 3380 - 3381 -// #else 3382 -// ... 3383 -// #endif 3384 - 3385 -struct tagMCI_ANIM_PLAY_PARMS { 3386 - DWORD_PTR dwCallback; 3387 - DWORD dwFrom; 3388 - DWORD dwTo; 3389 - DWORD dwSpeed; 3390 -} 3391 -alias tagMCI_ANIM_PLAY_PARMS MCI_ANIM_PLAY_PARMS; 3392 -alias tagMCI_ANIM_PLAY_PARMS* PMCI_ANIM_PLAY_PARMS; 3393 -alias tagMCI_ANIM_PLAY_PARMS* LPMCI_ANIM_PLAY_PARMS; 3394 - 3395 -struct tagMCI_ANIM_STEP_PARMS { 3396 - DWORD_PTR dwCallback; 3397 - DWORD dwFrames; 3398 -} 3399 -alias tagMCI_ANIM_STEP_PARMS MCI_ANIM_STEP_PARMS; 3400 -alias tagMCI_ANIM_STEP_PARMS* PMCI_ANIM_STEP_PARMS; 3401 -alias tagMCI_ANIM_STEP_PARMS* LPMCI_ANIM_STEP_PARMS; 3402 - 3403 -// #ifdef _WIN32 3404 - 3405 -struct tagMCI_ANIM_WINDOW_PARMSA { 3406 - DWORD_PTR dwCallback; 3407 - HWND hWnd; 3408 - UINT nCmdShow; 3409 - LPCSTR lpstrText; 3410 -} 3411 -alias tagMCI_ANIM_WINDOW_PARMSA MCI_ANIM_WINDOW_PARMSA; 3412 -alias tagMCI_ANIM_WINDOW_PARMSA* PMCI_ANIM_WINDOW_PARMSA; 3413 -alias tagMCI_ANIM_WINDOW_PARMSA* LPMCI_ANIM_WINDOW_PARMSA; 3414 - 3415 -struct tagMCI_ANIM_WINDOW_PARMSW { 3416 - DWORD_PTR dwCallback; 3417 - HWND hWnd; 3418 - UINT nCmdShow; 3419 - LPCWSTR lpstrText; 3420 -} 3421 -alias tagMCI_ANIM_WINDOW_PARMSW MCI_ANIM_WINDOW_PARMSW; 3422 -alias tagMCI_ANIM_WINDOW_PARMSW* PMCI_ANIM_WINDOW_PARMSW; 3423 -alias tagMCI_ANIM_WINDOW_PARMSW* LPMCI_ANIM_WINDOW_PARMSW; 3424 - 3425 -// #ifdef UNICODE 3426 -alias MCI_ANIM_WINDOW_PARMSW MCI_ANIM_WINDOW_PARMS; 3427 -alias PMCI_ANIM_WINDOW_PARMSW PMCI_ANIM_WINDOW_PARMS; 3428 -alias LPMCI_ANIM_WINDOW_PARMSW LPMCI_ANIM_WINDOW_PARMS; 3429 -// #else 3430 -// ... 3431 -// #endif // UNICODE 3432 - 3433 -// #else 3434 -// ... 3435 -// #endif 3436 - 3437 -struct tagMCI_ANIM_RECT_PARMS { 3438 - DWORD_PTR dwCallback; 3439 -// #ifdef MCI_USE_OFFEXT 3440 -// ... 3441 -// #else /* ifdef MCI_USE_OFFEXT */ 3442 - RECT rc; 3443 -// #endif /* ifdef MCI_USE_OFFEXT */ 3444 -} 3445 -alias tagMCI_ANIM_RECT_PARMS MCI_ANIM_RECT_PARMS; 3446 - 3447 -alias MCI_ANIM_RECT_PARMS* PMCI_ANIM_RECT_PARMS; 3448 -alias MCI_ANIM_RECT_PARMS* LPMCI_ANIM_RECT_PARMS; 3449 - 3450 -struct tagMCI_ANIM_UPDATE_PARMS { 3451 - DWORD_PTR dwCallback; 3452 - RECT rc; 3453 - HDC hDC; 3454 -} 3455 -alias tagMCI_ANIM_UPDATE_PARMS MCI_ANIM_UPDATE_PARMS; 3456 -alias tagMCI_ANIM_UPDATE_PARMS* PMCI_ANIM_UPDATE_PARMS; 3457 -alias tagMCI_ANIM_UPDATE_PARMS* LPMCI_ANIM_UPDATE_PARMS; 3458 - 3459 -enum : uint { MCI_OVLY_OPEN_WS = 0x00010000 } 3460 -enum : uint { MCI_OVLY_OPEN_PARENT = 0x00020000 } 3461 - 3462 -enum : uint { MCI_OVLY_STATUS_HWND = 0x00004001 } 3463 -enum : uint { MCI_OVLY_STATUS_STRETCH = 0x00004002 } 3464 - 3465 -enum : uint { MCI_OVLY_INFO_TEXT = 0x00010000 } 3466 - 3467 -enum : uint { MCI_OVLY_GETDEVCAPS_CAN_STRETCH = 0x00004001 } 3468 -enum : uint { MCI_OVLY_GETDEVCAPS_CAN_FREEZE = 0x00004002 } 3469 -enum : uint { MCI_OVLY_GETDEVCAPS_MAX_WINDOWS = 0x00004003 } 3470 - 3471 -enum : uint { MCI_OVLY_WINDOW_HWND = 0x00010000 } 3472 -enum : uint { MCI_OVLY_WINDOW_STATE = 0x00040000 } 3473 -enum : uint { MCI_OVLY_WINDOW_TEXT = 0x00080000 } 3474 -enum : uint { MCI_OVLY_WINDOW_ENABLE_STRETCH = 0x00100000 } 3475 -enum : uint { MCI_OVLY_WINDOW_DISABLE_STRETCH = 0x00200000 } 3476 - 3477 -enum : uint { MCI_OVLY_WINDOW_DEFAULT = 0x00000000 } 3478 - 3479 -enum : uint { MCI_OVLY_RECT = 0x00010000 } 3480 -enum : uint { MCI_OVLY_PUT_SOURCE = 0x00020000 } 3481 -enum : uint { MCI_OVLY_PUT_DESTINATION = 0x00040000 } 3482 -enum : uint { MCI_OVLY_PUT_FRAME = 0x00080000 } 3483 -enum : uint { MCI_OVLY_PUT_VIDEO = 0x00100000 } 3484 - 3485 -enum : uint { MCI_OVLY_WHERE_SOURCE = 0x00020000 } 3486 -enum : uint { MCI_OVLY_WHERE_DESTINATION = 0x00040000 } 3487 -enum : uint { MCI_OVLY_WHERE_FRAME = 0x00080000 } 3488 -enum : uint { MCI_OVLY_WHERE_VIDEO = 0x00100000 } 3489 - 3490 -// #ifdef _WIN32 3491 - 3492 -struct tagMCI_OVLY_OPEN_PARMSA { 3493 - DWORD_PTR dwCallback; 3494 - MCIDEVICEID wDeviceID; 3495 - LPCSTR lpstrDeviceType; 3496 - LPCSTR lpstrElementName; 3497 - LPCSTR lpstrAlias; 3498 - DWORD dwStyle; 3499 - HWND hWndParent; 3500 -} 3501 -alias tagMCI_OVLY_OPEN_PARMSA MCI_OVLY_OPEN_PARMSA; 3502 -alias tagMCI_OVLY_OPEN_PARMSA* PMCI_OVLY_OPEN_PARMSA; 3503 -alias tagMCI_OVLY_OPEN_PARMSA* LPMCI_OVLY_OPEN_PARMSA; 3504 - 3505 -struct tagMCI_OVLY_OPEN_PARMSW { 3506 - DWORD_PTR dwCallback; 3507 - MCIDEVICEID wDeviceID; 3508 - LPCWSTR lpstrDeviceType; 3509 - LPCWSTR lpstrElementName; 3510 - LPCWSTR lpstrAlias; 3511 - DWORD dwStyle; 3512 - HWND hWndParent; 3513 -} 3514 -alias tagMCI_OVLY_OPEN_PARMSW MCI_OVLY_OPEN_PARMSW; 3515 -alias tagMCI_OVLY_OPEN_PARMSW* PMCI_OVLY_OPEN_PARMSW; 3516 -alias tagMCI_OVLY_OPEN_PARMSW* LPMCI_OVLY_OPEN_PARMSW; 3517 - 3518 -// #ifdef UNICODE 3519 -alias MCI_OVLY_OPEN_PARMSW MCI_OVLY_OPEN_PARMS; 3520 -alias PMCI_OVLY_OPEN_PARMSW PMCI_OVLY_OPEN_PARMS; 3521 -alias LPMCI_OVLY_OPEN_PARMSW LPMCI_OVLY_OPEN_PARMS; 3522 -// #else 3523 -// ... 3524 -// #endif // UNICODE 3525 - 3526 -// #else 3527 -// ... 3528 -// #endif 3529 - 3530 -// #ifdef _WIN32 3531 - 3532 -struct tagMCI_OVLY_WINDOW_PARMSA { 3533 - DWORD_PTR dwCallback; 3534 - HWND hWnd; 3535 - UINT nCmdShow; 3536 - LPCSTR lpstrText; 3537 -} 3538 -alias tagMCI_OVLY_WINDOW_PARMSA MCI_OVLY_WINDOW_PARMSA; 3539 -alias tagMCI_OVLY_WINDOW_PARMSA* PMCI_OVLY_WINDOW_PARMSA; 3540 -alias tagMCI_OVLY_WINDOW_PARMSA* LPMCI_OVLY_WINDOW_PARMSA; 3541 - 3542 -struct tagMCI_OVLY_WINDOW_PARMSW { 3543 - DWORD_PTR dwCallback; 3544 - HWND hWnd; 3545 - UINT nCmdShow; 3546 - LPCWSTR lpstrText; 3547 -} 3548 -alias tagMCI_OVLY_WINDOW_PARMSW MCI_OVLY_WINDOW_PARMSW; 3549 -alias tagMCI_OVLY_WINDOW_PARMSW* PMCI_OVLY_WINDOW_PARMSW; 3550 -alias tagMCI_OVLY_WINDOW_PARMSW* LPMCI_OVLY_WINDOW_PARMSW; 3551 - 3552 -// #ifdef UNICODE 3553 -alias MCI_OVLY_WINDOW_PARMSW MCI_OVLY_WINDOW_PARMS; 3554 -alias PMCI_OVLY_WINDOW_PARMSW PMCI_OVLY_WINDOW_PARMS; 3555 -alias LPMCI_OVLY_WINDOW_PARMSW LPMCI_OVLY_WINDOW_PARMS; 3556 -// #else 3557 -// ... 3558 -// #endif // UNICODE 3559 -// #else 3560 -// ... 3561 -// #endif 3562 - 3563 -struct tagMCI_OVLY_RECT_PARMS { 3564 - DWORD_PTR dwCallback; 3565 -// #ifdef MCI_USE_OFFEXT 3566 -// ... 3567 -// #else /* ifdef MCI_USE_OFFEXT */ 3568 - RECT rc; 3569 -// #endif /* ifdef MCI_USE_OFFEXT */ 3570 -} 3571 -alias tagMCI_OVLY_RECT_PARMS MCI_OVLY_RECT_PARMS; 3572 -alias tagMCI_OVLY_RECT_PARMS* PMCI_OVLY_RECT_PARMS; 3573 -alias tagMCI_OVLY_RECT_PARMS* LPMCI_OVLY_RECT_PARMS; 3574 - 3575 -// #ifdef _WIN32 3576 - 3577 -struct tagMCI_OVLY_SAVE_PARMSA { 3578 - DWORD_PTR dwCallback; 3579 - LPCSTR lpfilename; 3580 - RECT rc; 3581 -} 3582 -alias tagMCI_OVLY_SAVE_PARMSA MCI_OVLY_SAVE_PARMSA; 3583 -alias tagMCI_OVLY_SAVE_PARMSA* PMCI_OVLY_SAVE_PARMSA; 3584 -alias tagMCI_OVLY_SAVE_PARMSA* LPMCI_OVLY_SAVE_PARMSA; 3585 - 3586 -struct tagMCI_OVLY_SAVE_PARMSW { 3587 - DWORD_PTR dwCallback; 3588 - LPCWSTR lpfilename; 3589 - RECT rc; 3590 -} 3591 -alias tagMCI_OVLY_SAVE_PARMSW MCI_OVLY_SAVE_PARMSW; 3592 -alias tagMCI_OVLY_SAVE_PARMSW* PMCI_OVLY_SAVE_PARMSW; 3593 -alias tagMCI_OVLY_SAVE_PARMSW* LPMCI_OVLY_SAVE_PARMSW; 3594 - 3595 -// #ifdef UNICODE 3596 -alias MCI_OVLY_SAVE_PARMSW MCI_OVLY_SAVE_PARMS; 3597 -alias PMCI_OVLY_SAVE_PARMSW PMCI_OVLY_SAVE_PARMS; 3598 -alias LPMCI_OVLY_SAVE_PARMSW LPMCI_OVLY_SAVE_PARMS; 3599 -// #else 3600 -// ... 3601 -// #endif // UNICODE 3602 -// #else 3603 -// ... 3604 -// #endif 3605 - 3606 -// #ifdef _WIN32 3607 - 3608 -struct tagMCI_OVLY_LOAD_PARMSA { 3609 - DWORD_PTR dwCallback; 3610 - LPCSTR lpfilename; 3611 - RECT rc; 3612 -} 3613 -alias tagMCI_OVLY_LOAD_PARMSA MCI_OVLY_LOAD_PARMSA; 3614 -alias tagMCI_OVLY_LOAD_PARMSA* PMCI_OVLY_LOAD_PARMSA; 3615 -alias tagMCI_OVLY_LOAD_PARMSA* LPMCI_OVLY_LOAD_PARMSA; 3616 - 3617 -struct tagMCI_OVLY_LOAD_PARMSW { 3618 - DWORD_PTR dwCallback; 3619 - LPCWSTR lpfilename; 3620 - RECT rc; 3621 -} 3622 -alias tagMCI_OVLY_LOAD_PARMSW MCI_OVLY_LOAD_PARMSW; 3623 -alias tagMCI_OVLY_LOAD_PARMSW* PMCI_OVLY_LOAD_PARMSW; 3624 -alias tagMCI_OVLY_LOAD_PARMSW* LPMCI_OVLY_LOAD_PARMSW; 3625 - 3626 -// #ifdef UNICODE 3627 -alias MCI_OVLY_LOAD_PARMSW MCI_OVLY_LOAD_PARMS; 3628 -alias PMCI_OVLY_LOAD_PARMSW PMCI_OVLY_LOAD_PARMS; 3629 -alias LPMCI_OVLY_LOAD_PARMSW LPMCI_OVLY_LOAD_PARMS; 3630 -// #else 3631 -// ... 3632 -// #endif // UNICODE 3633 -// #else 3634 -// ... 3635 -// #endif 3636 - 3637 -// #endif /* ifndef MMNOMCI */ 3638 - 3639 -// #ifndef NEWTRANSPARENT 3640 -enum : uint { NEWTRANSPARENT = 3 } 3641 - 3642 -enum : uint { QUERYROPSUPPORT = 40 } 3643 -// #endif /* ifndef NEWTRANSPARENT */ 3644 - 3645 -enum : uint { SELECTDIB = 41 } 3646 -// #define DIBINDEX(n) MAKELONG((n),0x10FF) 3647 - 3648 -// #ifndef SC_SCREENSAVE 3649 - 3650 -enum : uint { SC_SCREENSAVE = 0xF140 } 3651 - 3652 -// #endif /* ifndef SC_SCREENSAVE */ 3653 - 3654 -// #ifdef __cplusplus 3655 -// } 3656 -// #endif /* __cplusplus */ 3657 - 3658 -// #ifdef _WIN32 3659 -align: 3660 -// #else 3661 -// #ifndef RC_INVOKED 3662 -// #... 3663 -// #endif 3664 -// #endif 3665 - 3666 -// #endif /* _INC_MMSYSTEM */ 3667 - 2247 +alias WAVEOUTCAPS* PWAVEOUTCAPS, LPWAVEOUTCAPS; 2248 +alias WAVEINCAPS* PWAVEINCAPS, LPWAVEINCAPS; 2249 +alias MIDIOUTCAPS* PMIDIOUTCAPS, LPMIDIOUTCAPS; 2250 +alias MIDIINCAPS* PMIDIINCAPS, LPMIDIINCAPS; 2251 +alias AUXCAPS* PAUXCAPS, LPAUXCAPS; 2252 +alias MIXERCAPS* PMIXERCAPS, LPMIXERCAPS; 2253 +alias MIXERLINE* PMIXERLINE, LPMIXERLINE; 2254 +alias MIXERCONTROL* PMIXERCONTROL, LPMIXERCONTROL; 2255 +alias MIXERLINECONTROLS* PMIXERLINECONTROLS, LPMIXERLINECONTROLS; 2256 +alias MIXERCONTROLDETAILS_LISTTEXT* PMIXERCONTROLDETAILS_LISTTEXT, LPMIXERCONTROLDETAILS_LISTTEXT; 2257 +alias JOYCAPS* PJOYCAPS, LPJOYCAPS; 2258 +alias MCI_OPEN_PARMS* PMCI_OPEN_PARMS, LPMCI_OPEN_PARMS; 2259 +alias MCI_INFO_PARMS* LPMCI_INFO_PARMS; 2260 +alias MCI_SYSINFO_PARMS* PMCI_SYSINFO_PARMS, LPMCI_SYSINFO_PARMS; 2261 +alias MCI_SAVE_PARMS* PMCI_SAVE_PARMS, LPMCI_SAVE_PARMS; 2262 +alias MCI_LOAD_PARMS* PMCI_LOAD_PARMS, LPMCI_LOAD_PARMS; 2263 +alias MCI_VD_ESCAPE_PARMS* PMCI_VD_ESCAPE_PARMS, LPMCI_VD_ESCAPE_PARMS; 2264 +alias MCI_WAVE_OPEN_PARMS* PMCI_WAVE_OPEN_PARMS, LPMCI_WAVE_OPEN_PARMS; 2265 +alias MCI_ANIM_OPEN_PARMS* PMCI_ANIM_OPEN_PARMS, LPMCI_ANIM_OPEN_PARMS; 2266 +alias MCI_ANIM_WINDOW_PARMS* PMCI_ANIM_WINDOW_PARMS, LPMCI_ANIM_WINDOW_PARMS; 2267 +alias MCI_OVLY_OPEN_PARMS* PMCI_OVLY_OPEN_PARMS, LPMCI_OVLY_OPEN_PARMS; 2268 +alias MCI_OVLY_WINDOW_PARMS* PMCI_OVLY_WINDOW_PARMS, LPMCI_OVLY_WINDOW_PARMS; 2269 +alias MCI_OVLY_SAVE_PARMS* PMCI_OVLY_SAVE_PARMS, LPMCI_OVLY_SAVE_PARMS;