![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mmsystem.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / h|
Return to mmsystem.h CVS log | Up to [WindowsNT SDKs] / mstools / h |
1.1 root 1: #ifndef _MMSYSTEM_
2: #define _MMSYSTEM_
3:
4: /**************************************************************************/
5:
6: /*++ BUILD Version: 0002 Increment this if a change has global effects
7:
8: Copyright (c) 1990-91, Microsoft Corporation
9:
10: Module Name:
11:
12: mmsystem.h
13:
14: Abstract:
15:
16: This include file defines all the support for Multimedia applications.
17:
18: mmsystem.h must be included IMMEDIATELY AFTER windows.h
19:
20: 24-Apr-91 MMTIME structure added. NigelT.
21: 3-Dec-91 Wholesale changes. LaurieGr.
22: 30-Jan-92 Avoid things only in portwin32 LPARAM,HFILE,WPARAM LaurieGr
23: 19-Feb-92 Brave attempt to avoid collisions with rest of NT LaurieGr
24: 26-Feb-92 RobinSp moved across to mmsystem.h
25: 10-Apr-92 StephenE added Unicode support
26:
27: --*/
28:
29: /* If defined, the following flags inhibit inclusion
30: * of the indicated items:
31: *
32: * MMNODRV - Installable driver support
33: * MMNOSOUND - Sound support
34: * MMNOWAVE - Waveform support
35: * MMNOMIDI - MIDI support
36: * MMNOAUX - Auxiliary audio support
37: * MMNOTIMER - Timer support
38: * MMNOJOY - Joystick support
39: * MMNOMCI - MCI support
40: * MMNOMMIO - Multimedia file I/O support
41: * MMNOMMSYSTEM - General MMSYSTEM functions
42: */
43:
44: /****************************************************************************
45: * Multimedia Systems Window Messages
46: ****************************************************************************/
47:
48: #ifndef WM_MM_RESERVED_FIRST
49: // taken from windows.h
50: /* The following message range reserved for multi-media */
51: #define WM_MM_RESERVED_FIRST 0x3A0
52: #define WM_MM_RESERVED_LAST 0x3DF
53: #endif
54:
55:
56: #define MAXPNAMELEN 32 // max product name length (including NULL)
57: #define MAXERRORLENGTH 128 // max error text length (including final NULL)
58:
59: // general data types
60: typedef UINT MMVERSION; // major (high byte), minor (low byte)
61: typedef UINT MMRESULT; // error return code, 0 means no error
62: // call as if(err=xxxx(...)) Error(err); else
63: typedef DWORD MCIERROR; // error return code, 0 means no error
64:
65: /***************************************************************************
66: * Multimedia time
67: ***************************************************************************/
68: typedef struct tagMMTIME {
69: UINT wType; // the contents of the union
70: union {
71: DWORD ms; // milliseconds
72: DWORD sample; // samples
73: DWORD cb; // byte count
74: struct { // SMPTE
75: BYTE hour; // hours
76: BYTE min; // minutes (min is also a macro, so what?)
77: BYTE sec; // seconds
78: BYTE frame; // frames
79: BYTE fps; // frames per second (24, 25, 29(30 drop) or 30)
80: BYTE dummy;
81: } smpte;
82: struct { // MIDI
83: DWORD songptrpos; // song pointer position
84: } midi;
85: } u;
86: } MMTIME;
87: typedef MMTIME *PMMTIME;
88: typedef MMTIME *NPMMTIME;
89: typedef MMTIME *LPMMTIME;
90:
91: // values for wType field in MMTIME struct
92: #define TIME_MS 0x0001 // time in Milliseconds
93: #define TIME_SAMPLES 0x0002 // number of wave samples
94: #define TIME_BYTES 0x0004 // current byte offset
95: #define TIME_SMPTE 0x0008 // SMPTE time
96: #define TIME_MIDI 0x0010 // MIDI time
97:
98: /****************************************************************************
99: * Multimedia Window Messages
100: ****************************************************************************/
101:
102: #define MM_JOY1MOVE 0x3A0 // joystick
103: #define MM_JOY2MOVE 0x3A1
104: #define MM_JOY1ZMOVE 0x3A2
105: #define MM_JOY2ZMOVE 0x3A3
106: #define MM_JOY1BUTTONDOWN 0x3B5
107: #define MM_JOY2BUTTONDOWN 0x3B6
108: #define MM_JOY1BUTTONUP 0x3B7
109: #define MM_JOY2BUTTONUP 0x3B8
110:
111: #define MM_MCINOTIFY 0x3B9 // MCI
112: #define MM_MCISYSTEM_STRING 0x3CA
113:
114: #define MM_WOM_OPEN 0x3BB // waveform output
115: #define MM_WOM_CLOSE 0x3BC
116: #define MM_WOM_DONE 0x3BD
117:
118: #define MM_WIM_OPEN 0x3BE // waveform input
119: #define MM_WIM_CLOSE 0x3BF
120: #define MM_WIM_DATA 0x3C0
121:
122: #define MM_MIM_OPEN 0x3C1 // MIDI input
123: #define MM_MIM_CLOSE 0x3C2
124: #define MM_MIM_DATA 0x3C3
125: #define MM_MIM_LONGDATA 0x3C4
126: #define MM_MIM_ERROR 0x3C5
127: #define MM_MIM_LONGERROR 0x3C6
128:
129: #define MM_MOM_OPEN 0x3C7 // MIDI output
130: #define MM_MOM_CLOSE 0x3C8
131: #define MM_MOM_DONE 0x3C9
132:
133:
134: /****************************************************************************
135:
136: String resource number bases (internal use)
137:
138: ****************************************************************************/
139:
140: #define MMSYSERR_BASE 0
141: #define WAVERR_BASE 32
142: #define MIDIERR_BASE 64
143: #define TIMERR_BASE 96 // was 128, changed to match Win 31 Sonic
144: #define JOYERR_BASE 160
145: #define MCIERR_BASE 256
146:
147: #define MCI_STRING_OFFSET 512 // if this number is changed you MUST
148: // alter the MCI_DEVTYPE_... list below
149: #define MCI_VD_OFFSET 1024
150: #define MCI_CD_OFFSET 1088
151: #define MCI_WAVE_OFFSET 1152
152: #define MCI_SEQ_OFFSET 1216
153:
154: /****************************************************************************
155:
156: General error return values
157:
158: ****************************************************************************/
159:
160: #define MMSYSERR_NOERROR 0 // no error
161: #define MMSYSERR_ERROR (MMSYSERR_BASE + 1) // unspecified error
162: #define MMSYSERR_BADDEVICEID (MMSYSERR_BASE + 2) // device ID out of range
163: #define MMSYSERR_NOTENABLED (MMSYSERR_BASE + 3) // driver failed enable
164: #define MMSYSERR_ALLOCATED (MMSYSERR_BASE + 4) // device already allocated
165: #define MMSYSERR_INVALHANDLE (MMSYSERR_BASE + 5) // device handle is invalid
166: #define MMSYSERR_NODRIVER (MMSYSERR_BASE + 6) // no device driver present
167: #define MMSYSERR_NOMEM (MMSYSERR_BASE + 7) // memory allocation error
168: #define MMSYSERR_NOTSUPPORTED (MMSYSERR_BASE + 8) // function isn't supported
169: #define MMSYSERR_BADERRNUM (MMSYSERR_BASE + 9) // error value out of range
170: #define MMSYSERR_INVALFLAG (MMSYSERR_BASE + 10) // invalid flag passed
171: #define MMSYSERR_INVALPARAM (MMSYSERR_BASE + 11) // invalid parameter passed
172: #define MMSYSERR_HANDLEBUSY (MMSYSERR_BASE + 12) // handle being used
173: // simultaneously on another
174: // thread (eg callback)
175: #define MMSYSERR_INVALIDALIAS (MMSYSERR_BASE + 13) // "Specified alias not found in WIN.INI
176: #define MMSYSERR_LASTERROR (MMSYSERR_BASE + 13) // last error in range
177:
178:
179: #ifndef MMNODRV
180: /****************************************************************************
181:
182: Installable driver support
183:
184: ****************************************************************************/
185:
186: typedef HANDLE HDRVR;
187:
188: #ifndef DRV_LOAD
189:
190: /* Driver messages */
191: #define DRV_LOAD 0x0001
192: #define DRV_ENABLE 0x0002
193: #define DRV_OPEN 0x0003
194: #define DRV_CLOSE 0x0004
195: #define DRV_DISABLE 0x0005
196: #define DRV_FREE 0x0006
197: #define DRV_CONFIGURE 0x0007
198: #define DRV_QUERYCONFIGURE 0x0008
199: #define DRV_INSTALL 0x0009
200: #define DRV_REMOVE 0x000A
201: #define DRV_EXITSESSION 0x000B
202: #define DRV_POWER 0x000F
203: #define DRV_RESERVED 0x0800
204: #define DRV_USER 0x4000
205:
206: /* LPARAM of DRV_CONFIGURE message */
207: typedef struct tagDRVCONFIGINFO {
208: DWORD dwDCISize;
209: LPCWSTR lpszDCISectionName;
210: LPCWSTR lpszDCIAliasName;
211: } DRVCONFIGINFO;
212: typedef DRVCONFIGINFO *PDRVCONFIGINFO;
213: typedef DRVCONFIGINFO *NPDRVCONFIGINFO;
214: typedef DRVCONFIGINFO *LPDRVCONFIGINFO;
215: /* Supported return values for DRV_CONFIGURE message */
216: #define DRVCNF_CANCEL 0x0000
217: #define DRVCNF_OK 0x0001
218: #define DRVCNF_RESTART 0x0002
219:
220:
221: // return values from DriverProc() function
222: #define DRV_CANCEL DRVCNF_CANCEL
223: #define DRV_OK DRVCNF_OK
224: #define DRV_RESTART DRVCNF_RESTART
225:
226: // installable driver function prototypes
227: LRESULT APIENTRY DrvClose(HDRVR hDriver, LONG lParam1, LONG lParam2);
228: HDRVR APIENTRY DrvOpen( LPCWSTR szDriverName, LPCWSTR szSectionName,
229: LONG lParam2);
230: LRESULT APIENTRY DrvSendMessage( HDRVR hDriver, UINT message, LONG lParam1,
231: LONG lParam2);
232: HANDLE APIENTRY DrvGetModuleHandle( HDRVR hDriver );
233:
234: #define DRV_MCI_FIRST DRV_RESERVED
235: #define DRV_MCI_LAST (DRV_RESERVED + 0xFFF)
236:
237: #endif
238: #endif //ifndef MMNODRV
239:
240:
241: /****************************************************************************
242:
243: Driver callback support
244:
245: ****************************************************************************/
246:
247: // flags used with waveOutOpen(), waveInOpen(), midiInOpen(), and
248: // midiOutOpen() to specify the type of the dwCallback parameter.
249: #define CALLBACK_TYPEMASK 0x00070000l // callback type mask
250: #define CALLBACK_NULL 0x00000000l // no callback
251: #define CALLBACK_WINDOW 0x00010000l // dwCallback is a HWND
252: #define CALLBACK_TASK 0x00020000l // dwCallback is a HTASK
253: #define CALLBACK_FUNCTION 0x00030000l // dwCallback is a FARPROC
254:
255: #ifndef MMNODRV //ifndef MMNODRV
256:
257: // driver callback prototypes
258: typedef void DRVCALLBACK
259: (HDRVR h, UINT msg, DWORD dwUser, DWORD dw1, DWORD dw2);
260:
261: typedef DRVCALLBACK *PDRVCALLBACK;
262: typedef DRVCALLBACK *LPDRVCALLBACK;
263:
264: #endif //ifndef MMNODRV
265:
266: /****************************************************************************
267:
268: Manufacturer and product IDs
269:
270: Used with wMid and wPid fields in WAVEOUTCAPS, WAVEINCAPS,
271: MIDIOUTCAPS, MIDIINCAPS, AUXCAPS, JOYCAPS structures.
272:
273: ****************************************************************************/
274:
275: // manufacturer IDs
276: #define MM_MICROSOFT 1 // Microsoft Corp.
277:
278: // product IDs
279: #define MM_MIDI_MAPPER 1 // MIDI Mapper
280: #define MM_WAVE_MAPPER 2 // Wave Mapper
281:
282: #define MM_SNDBLST_MIDIOUT 3 // Sound Blaster MIDI output port
283: #define MM_SNDBLST_MIDIIN 4 // Sound Blaster MIDI input port
284: #define MM_SNDBLST_SYNTH 5 // Sound Blaster internal synthesizer
285: #define MM_SNDBLST_WAVEOUT 6 // Sound Blaster waveform output
286: #define MM_SNDBLST_WAVEIN 7 // Sound Blaster waveform input
287:
288: #define MM_ADLIB 9 // Ad Lib-compatible synthesizer
289:
290: #define MM_MPU401_MIDIOUT 10 // MPU401-compatible MIDI output port
291: #define MM_MPU401_MIDIIN 11 // MPU401-compatible MIDI input port
292:
293: #define MM_PC_JOYSTICK 12 // Joystick adapter
294:
295:
296: /****************************************************************************
297: * General MMSYSTEM support
298: ****************************************************************************/
299:
300: UINT APIENTRY mmsystemGetVersion(VOID);
301:
302: // We should point people to using OutputDebugString
303: #define OutputDebugStr OutputDebugString
304: #ifndef OutputDebugStr
305: VOID APIENTRY OutputDebugStr(LPCSTR);
306: #endif
307:
308:
309: /****************************************************************************
310: * Sound support
311: * Note: It may be fairly obvious that there are two very similar looking
312: * API calls to provide high level sound support. The major difference is
313: * that PlaySound takes a module handle. The position is to be reviewed.
314: ****************************************************************************/
315:
316: BOOL APIENTRY sndPlaySoundA( LPCSTR lpszSoundName, UINT uFlags );
317: BOOL APIENTRY sndPlaySoundW( LPCWSTR lpszSoundName, UINT uFlags );
318:
319: #ifdef UNICODE
320: #define sndPlaySound sndPlaySoundW
321: #else
322: #define sndPlaySound sndPlaySoundA
323: #endif
324:
325: // flag values for uFlags parameter
326: /**** These are the Win3.1 values ***
327: * #define SND_SYNC 0x0000 // play synchronously (default)
328: * #define SND_ASYNC 0x0001 // play asynchronously
329: * #define SND_NODEFAULT 0x0002 // don't use default sound
330: * #define SND_MEMORY 0x0004 // lpszSoundName points to a memory file
331: * #define SND_LOOP 0x0008 // loop the sound until next sndPlaySound
332: * #define SND_NOSTOP 0x0010 // don't stop any currently playing sound
333: * NT defines some additional flags.
334: **************/
335:
336: #define SND_SYNC 0x00000000 // play synchronously (default)
337: #define SND_ASYNC 0x00000001 // play asynchronously
338:
339: #define SND_NODEFAULT 0x00000002 // silence not default, if sound not found
340:
341: #define SND_MEMORY 0x00000004 // lpszSoundName points to a memory file
342: #define SND_ALIAS 0x00010000 // name is a WIN.INI [sounds] entry
343: #define SND_FILENAME 0x00020000 // name is a file name
344: #define SND_RESOURCE 0x00040004 // name is a resource name or atom
345: #define SND_ALIAS_ID 0x00110000 // name is a WIN.INI [sounds] entry identifier
346:
347: #define SND_ALIAS_ID 0x00110000 // name is a WIN.INI [sounds] entry identifier
348: #define SND_ALIAS_START 0 // must be > 4096 to keep strings in same section of resource file
349:
350: // sndAlias creates the alias identifier
351: #define sndAlias( ch0, ch1 ) \
352: ( SND_ALIAS_START + (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ))
353:
354: #define SND_ALIAS_SYSTEMASTERISK sndAlias('S', '*')
355: #define SND_ALIAS_SYSTEMQUESTION sndAlias('S', '?')
356: #define SND_ALIAS_SYSTEMHAND sndAlias('S', 'H')
357: #define SND_ALIAS_SYSTEMEXIT sndAlias('S', 'E')
358: #define SND_ALIAS_SYSTEMSTART sndAlias('S', 'S')
359: #define SND_ALIAS_SYSTEMWELCOME sndAlias('S', 'W')
360: #define SND_ALIAS_SYSTEMEXCLAMATION sndAlias('S', '!')
361: #define SND_ALIAS_SYSTEMDEFAULT sndAlias('S', 'D')
362:
363: // 00000004 bit off means behaviour as 3.1 with SND_MEMORY not set
364: // ??? Needs better definition
365:
366: #define SND_LOOP 0x00000008 // loop the sound until next sndPlaySound
367: #define SND_NOSTOP 0x00000010 // don't stop any currently playing sound
368: #define SND_VALID 0x0000001F // valid flags /* ;Internal */
369:
370: #define SND_NOWAIT 0x00002000 // don't wait if the driver is busy
371:
372: #define SND_VALIDFLAGS 0x0017201F // Set of valid flag bits. Anything outside
373: // this range will raise an error
374: #define SND_RESERVED 0xFF000000 // In particular these flags are reserved
375:
376: #define SND_TYPE_MASK 0x00170007
377:
378: /****************************************************************************/
379:
380: BOOL APIENTRY PlaySoundA( LPCSTR lpszName, HANDLE hModule, DWORD dwFlags );
381: BOOL APIENTRY PlaySoundW( LPCWSTR lpszName, HANDLE hModule, DWORD dwFlags );
382:
383: #ifdef UNICODE
384: #define PlaySound PlaySoundW
385: #else
386: #define PlaySound PlaySoundA
387: #endif
388:
389: #ifndef MMNOWAVE
390: /****************************************************************************
391:
392: Waveform audio support
393:
394: ****************************************************************************/
395:
396: // waveform audio error return values
397: #define WAVERR_BADFORMAT (WAVERR_BASE + 0) // unsupported wave format
398: #define WAVERR_STILLPLAYING (WAVERR_BASE + 1) // still something playing
399: #define WAVERR_UNPREPARED (WAVERR_BASE + 2) // header not prepared
400: #define WAVERR_SYNC (WAVERR_BASE + 3) // device is synchronous
401: #define WAVERR_LASTERROR (WAVERR_BASE + 3) // last error in range
402:
403: // waveform audio data types
404: typedef HANDLE HWAVE;
405: typedef HWAVE HWAVEIN;
406: typedef HWAVE HWAVEOUT;
407: typedef HWAVEIN *LPHWAVEIN;
408: typedef HWAVEOUT *LPHWAVEOUT;
409: typedef DRVCALLBACK WAVECALLBACK;
410: typedef WAVECALLBACK *LPWAVECALLBACK;
411:
412: // wave callback messages
413: #define WOM_OPEN MM_WOM_OPEN
414: #define WOM_CLOSE MM_WOM_CLOSE
415: #define WOM_DONE MM_WOM_DONE
416: #define WIM_OPEN MM_WIM_OPEN
417: #define WIM_CLOSE MM_WIM_CLOSE
418: #define WIM_DATA MM_WIM_DATA
419:
420: // device ID for wave device mapper
421: #define WAVE_MAPPER (-1)
422:
423: // flags for dwFlags parameter in waveOutOpen() and waveInOpen()
424: #define WAVE_FORMAT_QUERY 0x00000001
425: #define WAVE_ALLOWSYNC 0x00000002
426: #define WAVE_VALID 0x00000003 /* ;Internal */
427:
428: // wave data block header
429: typedef struct wavehdr_tag {
430: LPSTR lpData; // pointer to locked data buffer
431: DWORD dwBufferLength; // length of data buffer
432: DWORD dwBytesRecorded; // used for input only
433: DWORD dwUser; // for client's use
434: DWORD dwFlags; // assorted flags (see defines)
435: DWORD dwLoops; // loop control counter
436: struct wavehdr_tag * lpNext; // reserved for driver
437: DWORD reserved; // reserved for driver
438: } WAVEHDR;
439: typedef WAVEHDR *PWAVEHDR;
440: typedef WAVEHDR *NPWAVEHDR;
441: typedef WAVEHDR *LPWAVEHDR;
442:
443: // flags for dwFlags field of WAVEHDR
444: #define WHDR_DONE 0x00000001 // done bit
445: #define WHDR_PREPARED 0x00000002 // set if this header has been prepared
446: #define WHDR_BEGINLOOP 0x00000004 // loop start block
447: #define WHDR_ENDLOOP 0x00000008 // loop end block
448: #define WHDR_INQUEUE 0x00000010 // reserved for driver
449: #define WHDR_VALID 0x0000001F // valid flags /* ;Internal */
450:
451: // waveform output device capabilities structure (ASCII )
452: typedef struct tagWAVEOUTCAPSA {
453: WORD wMid; // manufacturer ID
454: WORD wPid; // product ID
455: MMVERSION vDriverVersion; // version of the driver
456: CHAR szPname[MAXPNAMELEN]; // product name (NULL terminated string)
457: DWORD dwFormats; // formats supported
458: WORD wChannels; // number of sources supported
459: DWORD dwSupport; // functionality supported by driver
460: } WAVEOUTCAPSA;
461:
462: // waveform output device capabilities structure (UNICODE )
463: typedef struct tagWAVEOUTCAPSW {
464: WORD wMid; // manufacturer ID
465: WORD wPid; // product ID
466: MMVERSION vDriverVersion; // version of the driver
467: WCHAR szPname[MAXPNAMELEN]; // product name (NULL terminated string)
468: DWORD dwFormats; // formats supported
469: WORD wChannels; // number of sources supported
470: DWORD dwSupport; // functionality supported by driver
471: } WAVEOUTCAPSW;
472:
473: typedef WAVEOUTCAPSA *PWAVEOUTCAPSA;
474: typedef WAVEOUTCAPSA *NPWAVEOUTCAPSA;
475: typedef WAVEOUTCAPSA *LPWAVEOUTCAPSA;
476:
477: typedef WAVEOUTCAPSW *PWAVEOUTCAPSW;
478: typedef WAVEOUTCAPSW *NPWAVEOUTCAPSW;
479: typedef WAVEOUTCAPSW *LPWAVEOUTCAPSW;
480:
481: #ifdef UNICODE
482: #define WAVEOUTCAPS WAVEOUTCAPSW
483: #define NPWAVEOUTCAPS NPWAVEOUTCAPSW
484: #define LPWAVEOUTCAPS LPWAVEOUTCAPSW
485: #else
486: #define WAVEOUTCAPS WAVEOUTCAPSA
487: #define NPWAVEOUTCAPS NPWAVEOUTCAPSA
488: #define LPWAVEOUTCAPS LPWAVEOUTCAPSA
489: #endif
490:
491:
492: // flags for dwSupport field of WAVEOUTCAPS
493: #define WAVECAPS_PITCH 0x00000001 // supports pitch control
494: #define WAVECAPS_PLAYBACKRATE 0x00000002 // supports playback rate control
495: #define WAVECAPS_VOLUME 0x00000004 // supports volume control
496: #define WAVECAPS_LRVOLUME 0x00000008 // separate left-right volume control
497: #define WAVECAPS_SYNC 0x00000010
498:
499: // waveform input device capabilities structure (ASCII)
500: typedef struct tagWAVEINCAPSA {
501: WORD wMid; // manufacturer ID
502: WORD wPid; // product ID
503: MMVERSION vDriverVersion; // version of the driver
504: CHAR szPname[MAXPNAMELEN]; // product name (NULL terminated string)
505: DWORD dwFormats; // formats supported
506: WORD wChannels; // number of channels supported
507: } WAVEINCAPSA, *PWAVEINCAPSA, *LPWAVEINCAPSA;
508:
509: // waveform input device capabilities structure (UNICODE)
510: typedef struct tagWAVEINCAPSW {
511: WORD wMid; // manufacturer ID
512: WORD wPid; // product ID
513: MMVERSION vDriverVersion; // version of the driver
514: WCHAR szPname[MAXPNAMELEN]; // product name (NULL terminated string)
515: DWORD dwFormats; // formats supported
516: WORD wChannels; // number of channels supported
517: } WAVEINCAPSW, *PWAVEINCAPSW, *LPWAVEINCAPSW;
518:
519: #ifdef UNICODE
520: #define WAVEINCAPS WAVEINCAPSW
521: #define LPWAVEINCAPS LPWAVEINCAPSW
522: #define PWAVEINCAPS PWAVEINCAPSW
523: #else
524: #define WAVEINCAPS WAVEINCAPSA
525: #define PWAVEINCAPS PWAVEINCAPSA
526: #define LPWAVEINCAPS LPWAVEINCAPSA
527: #endif
528:
529: // defines for dwFormat field of WAVEINCAPS and WAVEOUTCAPS
530: #define WAVE_INVALIDFORMAT 0x00000000 // invalid format
531: #define WAVE_FORMAT_1M08 0x00000001 // 11.025 kHz, Mono, 8-bit
532: #define WAVE_FORMAT_1S08 0x00000002 // 11.025 kHz, Stereo, 8-bit
533: #define WAVE_FORMAT_1M16 0x00000004 // 11.025 kHz, Mono, 16-bit
534: #define WAVE_FORMAT_1S16 0x00000008 // 11.025 kHz, Stereo, 16-bit
535: #define WAVE_FORMAT_2M08 0x00000010 // 22.05 kHz, Mono, 8-bit
536: #define WAVE_FORMAT_2S08 0x00000020 // 22.05 kHz, Stereo, 8-bit
537: #define WAVE_FORMAT_2M16 0x00000040 // 22.05 kHz, Mono, 16-bit
538: #define WAVE_FORMAT_2S16 0x00000080 // 22.05 kHz, Stereo, 16-bit
539: #define WAVE_FORMAT_4M08 0x00000100 // 44.1 kHz, Mono, 8-bit
540: #define WAVE_FORMAT_4S08 0x00000200 // 44.1 kHz, Stereo, 8-bit
541: #define WAVE_FORMAT_4M16 0x00000400 // 44.1 kHz, Mono, 16-bit
542: #define WAVE_FORMAT_4S16 0x00000800 // 44.1 kHz, Stereo, 16-bit
543:
544: // flags for wFormatTag field of WAVEFORMAT
545: #define WAVE_FORMAT_PCM 1 // Needed in resource files
546:
547: #ifndef RC_INVOKED // RC gets upset by #pragma pack()
548:
549: // general waveform format (information common to all formats)
550: // as read from a file. See Multimedia file formats in Programmer Reference
551: #pragma pack(2) // File format is not double word aligned
552: typedef struct {
553: WORD wFormatTag; // format type
554: WORD nChannels; // number of channels (i.e. mono, stereo, etc.)
555: DWORD nSamplesPerSec; // sample rate
556: DWORD nAvgBytesPerSec; // for buffer estimation
557: WORD nBlockAlign; // block size of data
558: } WAVEFORMAT;
559: typedef WAVEFORMAT *PWAVEFORMAT;
560: typedef WAVEFORMAT *NPWAVEFORMAT;
561: typedef WAVEFORMAT *LPWAVEFORMAT;
562: // NOTE: The fields in the structure above are copied into
563: // the MCI_WAVE_SET_PARMS structure during execution
564:
565: // specific waveform format for PCM data
566: typedef struct tagPCMWAVEFORMAT {
567: WAVEFORMAT wf;
568: WORD wBitsPerSample; // corresponds to MCI_WAVE_SET_.... structure
569: } PCMWAVEFORMAT;
570: typedef PCMWAVEFORMAT *PPCMWAVEFORMAT;
571: typedef PCMWAVEFORMAT *NPPCMWAVEFORMAT;
572: typedef PCMWAVEFORMAT *LPPCMWAVEFORMAT;
573:
574: #pragma pack() // revert to command line packing
575:
576: // waveform audio function prototypes
577: UINT APIENTRY waveOutGetNumDevs(VOID);
578:
579: MMRESULT APIENTRY waveOutGetDevCapsA(UINT uDeviceID, LPWAVEOUTCAPSA lpCaps,
580: UINT uSize);
581: MMRESULT APIENTRY waveOutGetDevCapsW(UINT uDeviceID, LPWAVEOUTCAPSW lpCaps,
582: UINT uSize);
583: #ifdef UNICODE
584: #define waveOutGetDevCaps waveOutGetDevCapsW
585: #else
586: #define waveOutGetDevCaps waveOutGetDevCapsA
587: #endif
588:
589: MMRESULT APIENTRY waveOutGetVolume(UINT uDeviceID, LPDWORD lpdwVolume);
590: MMRESULT APIENTRY waveOutSetVolume(UINT uDeviceID, DWORD dwVolume);
591:
592: MMRESULT APIENTRY waveOutGetErrorTextA(MMRESULT err, LPSTR lpText, UINT uSize);
593: MMRESULT APIENTRY waveOutGetErrorTextW(MMRESULT err, LPWSTR lpText, UINT uSize);
594: #ifdef UNICODE
595: #define waveOutGetErrorText waveOutGetErrorTextW
596: #else
597: #define waveOutGetErrorText waveOutGetErrorTextA
598: #endif
599:
600: MMRESULT APIENTRY waveOutOpen(LPHWAVEOUT lphWaveOut, UINT uDeviceID,
601: LPWAVEFORMAT lpFormat, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags);
602: MMRESULT APIENTRY waveOutClose(HWAVEOUT hWaveOut);
603: MMRESULT APIENTRY waveOutPrepareHeader(HWAVEOUT hWaveOut,
604: LPWAVEHDR lpWaveOutHdr, UINT uSize);
605: MMRESULT APIENTRY waveOutUnprepareHeader(HWAVEOUT hWaveOut,
606: LPWAVEHDR lpWaveOutHdr, UINT uSize);
607: MMRESULT APIENTRY waveOutWrite(HWAVEOUT hWaveOut, LPWAVEHDR lpWaveOutHdr,
608: UINT uSize);
609: MMRESULT APIENTRY waveOutPause(HWAVEOUT hWaveOut);
610: MMRESULT APIENTRY waveOutRestart(HWAVEOUT hWaveOut);
611: MMRESULT APIENTRY waveOutReset(HWAVEOUT hWaveOut);
612: MMRESULT APIENTRY waveOutBreakLoop(HWAVEOUT hWaveOut);
613: MMRESULT APIENTRY waveOutGetPosition(HWAVEOUT hWaveOut, LPMMTIME lpInfo,
614: UINT uSize);
615: MMRESULT APIENTRY waveOutGetPitch(HWAVEOUT hWaveOut, LPDWORD lpdwPitch);
616: MMRESULT APIENTRY waveOutSetPitch(HWAVEOUT hWaveOut, DWORD dwPitch);
617: MMRESULT APIENTRY waveOutGetPlaybackRate(HWAVEOUT hWaveOut, LPDWORD lpdwRate);
618: MMRESULT APIENTRY waveOutSetPlaybackRate(HWAVEOUT hWaveOut, DWORD dwRate);
619: MMRESULT APIENTRY waveOutGetID(HWAVEOUT hWaveOut, PUINT lpuDeviceID);
620: MMRESULT APIENTRY waveOutMessage(HWAVEOUT hWaveOut, UINT msg, DWORD dw1, DWORD dw2);
621: UINT APIENTRY waveInGetNumDevs(VOID);
622:
623: MMRESULT APIENTRY waveInGetDevCapsA(UINT uDeviceID, LPWAVEINCAPSA lpCaps,
624: UINT uSize);
625: MMRESULT APIENTRY waveInGetDevCapsW(UINT uDeviceID, LPWAVEINCAPSW lpCaps,
626: UINT uSize);
627: #ifdef UNICODE
628: #define waveInGetDevCaps waveInGetDevCapsW
629: #else
630: #define waveInGetDevCaps waveInGetDevCapsA
631: #endif
632:
633:
634: MMRESULT APIENTRY waveInGetErrorTextA(MMRESULT err, LPSTR lpText, UINT uSize);
635: MMRESULT APIENTRY waveInGetErrorTextW(MMRESULT err, LPWSTR lpText, UINT uSize);
636: #ifdef UNICODE
637: #define waveInGetErrorText waveInGetErrorTextW
638: #else
639: #define waveInGetErrorText waveInGetErrorTextA
640: #endif
641:
642: MMRESULT APIENTRY waveInOpen(LPHWAVEIN lphWaveIn, UINT uDeviceID,
643: LPWAVEFORMAT lpFormat, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags);
644: MMRESULT APIENTRY waveInClose(HWAVEIN hWaveIn);
645: MMRESULT APIENTRY waveInPrepareHeader(HWAVEIN hWaveIn,
646: LPWAVEHDR lpWaveInHdr, UINT uSize);
647: MMRESULT APIENTRY waveInUnprepareHeader(HWAVEIN hWaveIn,
648: LPWAVEHDR lpWaveInHdr, UINT uSize);
649: MMRESULT APIENTRY waveInAddBuffer(HWAVEIN hWaveIn,
650: LPWAVEHDR lpWaveInHdr, UINT uSize);
651: MMRESULT APIENTRY waveInStart(HWAVEIN hWaveIn);
652: MMRESULT APIENTRY waveInStop(HWAVEIN hWaveIn);
653: MMRESULT APIENTRY waveInReset(HWAVEIN hWaveIn);
654: MMRESULT APIENTRY waveInGetPosition(HWAVEIN hWaveIn, LPMMTIME lpInfo,
655: UINT uSize);
656: MMRESULT APIENTRY waveInGetID(HWAVEIN hWaveIn, PUINT lpuDeviceID);
657: MMRESULT APIENTRY waveInMessage(HWAVEIN hWaveIn, UINT msg, DWORD dw1, DWORD dw2);
658:
659: #endif /* RC_INVOKED */
660: #endif //ifndef MMNOWAVE
661:
662: #ifndef MMNOMIDI
663: /****************************************************************************
664:
665: MIDI audio support
666:
667: ****************************************************************************/
668:
669: // MIDI error return values
670: #define MIDIERR_UNPREPARED (MIDIERR_BASE + 0) /* header not prepared */
671: #define MIDIERR_STILLPLAYING (MIDIERR_BASE + 1) /* still something playing */
672: #define MIDIERR_NOMAP (MIDIERR_BASE + 2) /* no current map */
673: #define MIDIERR_NOTREADY (MIDIERR_BASE + 3) /* hardware is still busy */
674: #define MIDIERR_NODEVICE (MIDIERR_BASE + 4) /* port no longer connected */
675: #define MIDIERR_INVALIDSETUP (MIDIERR_BASE + 5) /* invalid setup */
676: #define MIDIERR_LASTERROR (MIDIERR_BASE + 5) /* last error in range */
677:
678: // MIDI audio data types
679: typedef HANDLE HMIDI;
680: typedef HMIDI HMIDIIN;
681: typedef HMIDI HMIDIOUT;
682: typedef HMIDIIN *LPHMIDIIN;
683: typedef HMIDIOUT *LPHMIDIOUT;
684: typedef DRVCALLBACK MIDICALLBACK;
685: typedef MIDICALLBACK *LPMIDICALLBACK;
686: #define MIDIPATCHSIZE 128
687: typedef WORD PATCHARRAY[MIDIPATCHSIZE];
688: typedef WORD *LPPATCHARRAY;
689: typedef WORD KEYARRAY[MIDIPATCHSIZE];
690: typedef WORD *LPKEYARRAY;
691:
692: // MIDI callback messages
693: #define MIM_OPEN MM_MIM_OPEN
694: #define MIM_CLOSE MM_MIM_CLOSE
695: #define MIM_DATA MM_MIM_DATA
696: #define MIM_LONGDATA MM_MIM_LONGDATA
697: #define MIM_ERROR MM_MIM_ERROR
698: #define MIM_LONGERROR MM_MIM_LONGERROR
699: #define MOM_OPEN MM_MOM_OPEN
700: #define MOM_CLOSE MM_MOM_CLOSE
701: #define MOM_DONE MM_MOM_DONE
702:
703: // device ID for MIDI mapper
704: #define MIDIMAPPER (-1)
705: #define MIDI_MAPPER (-1)
706:
707: // flags for wFlags parm of midiOutCachePatches(), midiOutCacheDrumPatches()
708: #define MIDI_CACHE_ALL 1
709: #define MIDI_CACHE_BESTFIT 2
710: #define MIDI_CACHE_QUERY 3
711: #define MIDI_UNCACHE 4
712: #define MIDI_CACHE_VALID (MIDI_CACHE_ALL | MIDI_CACHE_BESTFIT | MIDI_CACHE_QUERY | MIDI_UNCACHE) /* ;Internal */
713:
714: // MIDI output device capabilities structure (ASCII)
715: typedef struct tagMIDIOUTCAPSA {
716: WORD wMid; // manufacturer ID
717: WORD wPid; // product ID
718: MMVERSION vDriverVersion; // version of the driver
719: CHAR szPname[MAXPNAMELEN]; // product name (NULL terminated string)
720: WORD wTechnology; // type of device
721: WORD wVoices; // # of voices (internal synth only)
722: WORD wNotes; // max # of notes (internal synth only)
723: WORD wChannelMask; // channels used (internal synth only)
724: DWORD dwSupport; // functionality supported by driver
725: } MIDIOUTCAPSA;
726: typedef MIDIOUTCAPSA *PMIDIOUTCAPSA;
727: typedef MIDIOUTCAPSA *NPMIDIOUTCAPSA;
728: typedef MIDIOUTCAPSA *LPMIDIOUTCAPSA;
729:
730: // MIDI output device capabilities structure (UNICODE)
731: typedef struct tagMIDIOUTCAPSW {
732: WORD wMid; // manufacturer ID
733: WORD wPid; // product ID
734: MMVERSION vDriverVersion; // version of the driver
735: WCHAR szPname[MAXPNAMELEN]; // product name (NULL terminated string)
736: WORD wTechnology; // type of device
737: WORD wVoices; // # of voices (internal synth only)
738: WORD wNotes; // max # of notes (internal synth only)
739: WORD wChannelMask; // channels used (internal synth only)
740: DWORD dwSupport; // functionality supported by driver
741: } MIDIOUTCAPSW;
742: typedef MIDIOUTCAPSW *PMIDIOUTCAPSW;
743: typedef MIDIOUTCAPSW *NPMIDIOUTCAPSW;
744: typedef MIDIOUTCAPSW *LPMIDIOUTCAPSW;
745:
746: #ifdef UNICODE
747: #define MIDIOUTCAPS MIDIOUTCAPSW
748: #define NPMIDIOUTCAPS NPMIDIOUTCAPSW
749: #define LPMIDIOUTCAPS LPMIDIOUTCAPSW
750: #else
751: #define MIDIOUTCAPS MIDIOUTCAPSA
752: #define NPMIDIOUTCAPS NPMIDIOUTCAPSA
753: #define LPMIDIOUTCAPS LPMIDIOUTCAPSA
754: #endif
755:
756: // flags for wTechnology field of MIDIOUTCAPS structure
757: #define MOD_MIDIPORT 1 // output port
758: #define MOD_SYNTH 2 // generic internal synth
759: #define MOD_SQSYNTH 3 // square wave internal synth
760: #define MOD_FMSYNTH 4 // FM internal synth
761: #define MOD_MAPPER 5 // MIDI mapper
762:
763: // flags for dwSupport field of MIDIOUTCAPS
764: #define MIDICAPS_VOLUME 0x00000001 // supports volume control
765: #define MIDICAPS_LRVOLUME 0x00000002 // separate left-right volume control
766: #define MIDICAPS_CACHE 0x00000004
767:
768: // MIDI input device capabilities structure (ASCII)
769: typedef struct tagMIDIINCAPSA {
770: WORD wMid; // manufacturer ID
771: WORD wPid; // product ID
772: MMVERSION vDriverVersion; // version of the driver
773: CHAR szPname[MAXPNAMELEN]; // product name (NULL terminated string)
774: } MIDIINCAPSA;
775: typedef MIDIINCAPSA *PMIDIINCAPSA;
776: typedef MIDIINCAPSA *NPMIDIINCAPSA;
777: typedef MIDIINCAPSA *LPMIDIINCAPSA;
778:
779: // MIDI input device capabilities structure (UNICODE)
780: typedef struct tagMIDIINCAPSW {
781: WORD wMid; // manufacturer ID
782: WORD wPid; // product ID
783: MMVERSION vDriverVersion; // version of the driver
784: WCHAR szPname[MAXPNAMELEN]; // product name (NULL terminated string)
785: } MIDIINCAPSW;
786: typedef MIDIINCAPSW *PMIDIINCAPSW;
787: typedef MIDIINCAPSW *NPMIDIINCAPSW;
788: typedef MIDIINCAPSW *LPMIDIINCAPSW;
789:
790: #ifdef UNICODE
791: #define MIDIINCAPS MIDIINCAPSW
792: #define NPMIDIINCAPS NPMIDIINCAPSW
793: #define LPMIDIINCAPS LPMIDIINCAPSW
794: #else
795: #define MIDIINCAPS MIDIINCAPSA
796: #define NPMIDIINCAPS NPMIDIINCAPSA
797: #define LPMIDIINCAPS LPMIDIINCAPSA
798: #endif
799:
800: // MIDI data block header
801: typedef struct midihdr_tag {
802: LPSTR lpData; // pointer to locked data block
803: DWORD dwBufferLength; // length of data in data block
804: DWORD dwBytesRecorded; // used for input only
805: DWORD dwUser; // for client's use
806: DWORD dwFlags; // assorted flags (see defines)
807: struct midihdr_tag *lpNext; // reserved for driver
808: DWORD reserved; // reserved for driver
809: } MIDIHDR;
810: typedef MIDIHDR *PMIDIHDR;
811: typedef MIDIHDR *NPMIDIHDR;
812: typedef MIDIHDR *LPMIDIHDR;
813:
814: // flags for dwFlags field of MIDIHDR structure
815: #define MHDR_DONE 0x00000001 // done bit
816: #define MHDR_PREPARED 0x00000002 // set if header prepared
817: #define MHDR_INQUEUE 0x00000004 // reserved for driver
818: #define MHDR_VALID 0x00000007 // valid flags /* ;Internal */
819:
820: // MIDI function prototypes
821: UINT APIENTRY midiOutGetNumDevs(VOID);
822:
823: MMRESULT APIENTRY midiOutGetDevCapsW(UINT uDeviceID, // UNICODE version
824: LPMIDIOUTCAPSW lpCaps, UINT uSize);
825:
826: MMRESULT APIENTRY midiOutGetDevCapsA(UINT uDeviceID, // ASCII version
827: LPMIDIOUTCAPSA lpCaps, UINT uSize);
828:
829: #ifdef UNICODE
830: #define midiOutGetDevCaps midiOutGetDevCapsW
831: #else
832: #define midiOutGetDevCaps midiOutGetDevCapsA
833: #endif
834:
835: MMRESULT APIENTRY midiOutGetVolume(UINT uDeviceID, LPDWORD lpdwVolume);
836: MMRESULT APIENTRY midiOutSetVolume(UINT uDeviceID, DWORD dwVolume);
837:
838: MMRESULT APIENTRY midiOutGetErrorTextA(MMRESULT err, LPSTR lpText, UINT uSize);
839: MMRESULT APIENTRY midiOutGetErrorTextW(MMRESULT err, LPWSTR lpText, UINT uSize);
840: #ifdef UNICODE
841: #define midiOutGetErrorText midiOutGetErrorTextW
842: #else
843: #define midiOutGetErrorText midiOutGetErrorTextA
844: #endif
845:
846:
847: MMRESULT APIENTRY midiOutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID,
848: DWORD dwCallback, DWORD dwInstance, DWORD dwFlags);
849: MMRESULT APIENTRY midiOutClose(HMIDIOUT hMidiOut);
850: MMRESULT APIENTRY midiOutPrepareHeader(HMIDIOUT hMidiOut,
851: LPMIDIHDR lpMidiOutHdr, UINT uSize);
852: MMRESULT APIENTRY midiOutUnprepareHeader(HMIDIOUT hMidiOut,
853: LPMIDIHDR lpMidiOutHdr, UINT uSize);
854: MMRESULT APIENTRY midiOutShortMsg(HMIDIOUT hMidiOut, DWORD dwMsg);
855: MMRESULT APIENTRY midiOutLongMsg(HMIDIOUT hMidiOut,
856: LPMIDIHDR lpMidiOutHdr, UINT uSize);
857: MMRESULT APIENTRY midiOutReset(HMIDIOUT hMidiOut);
858: MMRESULT APIENTRY midiOutCachePatches(HMIDIOUT hMidiOut,
859: UINT uBank, LPWORD lpPatchArray, UINT uFlags);
860: MMRESULT APIENTRY midiOutCacheDrumPatches(HMIDIOUT hMidiOut,
861: UINT uPatch, LPWORD lpKeyArray, UINT uFlags);
862: MMRESULT APIENTRY midiOutGetID(HMIDIOUT hMidiOut, PUINT lpuDeviceID);
863: MMRESULT APIENTRY
864: midiOutMessage(HMIDIOUT hMidiOut, UINT msg, DWORD dw1, DWORD dw2);
865:
866: UINT APIENTRY midiInGetNumDevs(VOID);
867:
868: MMRESULT APIENTRY midiInGetDevCapsW(UINT uDeviceID, // UNICODE version
869: LPMIDIINCAPSW lpCaps, UINT uSize);
870:
871: MMRESULT APIENTRY midiInGetDevCapsA(UINT uDeviceID, // ASCII version
872: LPMIDIINCAPSA lpCaps, UINT uSize);
873:
874: #ifdef UNICODE
875: #define midiInGetDevCaps midiInGetDevCapsW
876: #else
877: #define midiInGetDevCaps midiInGetDevCapsA
878: #endif
879:
880: MMRESULT APIENTRY midiInGetErrorTextW(MMRESULT err, LPWSTR lpText, UINT uSize);
881:
882: MMRESULT APIENTRY midiInGetErrorTextA(MMRESULT err, LPSTR lpText, UINT uSize);
883:
884: #ifdef UNICODE
885: #define midiInGetErrorText midiInGetErrorTextW
886: #else
887: #define midiInGetErrorText midiInGetErrorTextA
888: #endif
889:
890: MMRESULT APIENTRY midiInOpen(LPHMIDIIN lphMidiIn, UINT uDeviceID,
891: DWORD dwCallback, DWORD dwInstance, DWORD dwFlags);
892: MMRESULT APIENTRY midiInClose(HMIDIIN hMidiIn);
893: MMRESULT APIENTRY midiInPrepareHeader(HMIDIIN hMidiIn,
894: LPMIDIHDR lpMidiInHdr, UINT uSize);
895: MMRESULT APIENTRY midiInUnprepareHeader(HMIDIIN hMidiIn,
896: LPMIDIHDR lpMidiInHdr, UINT uSize);
897: MMRESULT APIENTRY midiInAddBuffer(HMIDIIN hMidiIn,
898: LPMIDIHDR lpMidiInHdr, UINT uSize);
899: MMRESULT APIENTRY midiInStart(HMIDIIN hMidiIn);
900: MMRESULT APIENTRY midiInStop(HMIDIIN hMidiIn);
901: MMRESULT APIENTRY midiInReset(HMIDIIN hMidiIn);
902: MMRESULT APIENTRY midiInGetID(HMIDIIN hMidiIn, PUINT lpuDeviceID);
903: MMRESULT APIENTRY
904: midiInMessage(HMIDIIN hMidiIn, UINT msg, DWORD dw1, DWORD dw2);
905:
906: #endif //ifndef MMNOMIDI
907:
908:
909: #ifndef MMNOAUX
910: /****************************************************************************
911:
912: Auxiliary audio support
913:
914: ****************************************************************************/
915:
916: // device ID for aux device mapper
917: #define AUX_MAPPER (-1)
918:
919: // Auxiliary audio device capabilities structure (UNICODE)
920: typedef struct auxcapsW_tag {
921: WORD wMid; // manufacturer ID
922: WORD wPid; // product ID
923: MMVERSION vDriverVersion; // version of the driver
924: WCHAR szPname[MAXPNAMELEN]; // product name (NULL terminated string)
925: WORD wTechnology; // type of device
926: DWORD dwSupport; // functionality supported by driver
927: } AUXCAPSW;
928: typedef AUXCAPSW *PAUXCAPSW;
929: typedef AUXCAPSW *NPAUXCAPSW;
930: typedef AUXCAPSW *LPAUXCAPSW;
931:
932: // Auxiliary audio device capabilities structure (ASCII)
933: typedef struct auxcapsA_tag {
934: WORD wMid; // manufacturer ID
935: WORD wPid; // product ID
936: MMVERSION vDriverVersion; // version of the driver
937: CHAR szPname[MAXPNAMELEN]; // product name (NULL terminated string)
938: WORD wTechnology; // type of device
939: DWORD dwSupport; // functionality supported by driver
940: } AUXCAPSA;
941: typedef AUXCAPSA *PAUXCAPSA;
942: typedef AUXCAPSA *NPAUXCAPSA;
943: typedef AUXCAPSA *LPAUXCAPSA;
944:
945: #ifdef UNICODE
946: #define AUXCAPS AUXCAPSW
947: #define NPAUXCAPS NPAUXCAPSW
948: #define LPAUXCAPS LPAUXCAPSW
949: #else
950: #define AUXCAPS AUXCAPSA
951: #define NPAUXCAPS NPAUXCAPSA
952: #define LPAUXCAPS LPAUXCAPSA
953: #endif
954:
955: // flags for wTechnology field in AUXCAPS structure
956: #define AUXCAPS_CDAUDIO 1 // audio from internal CD-ROM drive
957: #define AUXCAPS_AUXIN 2 // audio from auxiliary input jacks
958:
959: // flags for dwSupport field in AUXCAPS structure
960: #define AUXCAPS_VOLUME 0x00000001 // supports volume control
961: #define AUXCAPS_LRVOLUME 0x00000002 // separate left-right volume control
962:
963: // auxiliary audio function prototypes
964: UINT APIENTRY auxGetNumDevs(VOID);
965: MMRESULT APIENTRY auxGetDevCapsW(UINT uDeviceID, LPAUXCAPSW lpCaps, UINT uSize);
966: MMRESULT APIENTRY auxGetDevCapsA(UINT uDeviceID, LPAUXCAPSA lpCaps, UINT uSize);
967:
968: #ifdef UNICODE
969: #define auxGetDevCaps auxGetDevCapsW
970: #else
971: #define auxGetDevCaps auxGetDevCapsA
972: #endif
973:
974: MMRESULT APIENTRY auxSetVolume(UINT uDeviceID, DWORD dwVolume);
975: MMRESULT APIENTRY auxGetVolume(UINT uDeviceID, LPDWORD lpdwVolume);
976: MMRESULT APIENTRY auxOutMessage(UINT uDeviceID, UINT msg, DWORD dw1, DWORD dw2);
977:
978: #endif //ifndef MMNOAUX
979:
980:
981: #ifndef MMNOTIMER
982: /****************************************************************************
983:
984: Timer support
985:
986: ****************************************************************************/
987:
988: // timer error return values
989: #define TIMERR_NOERROR (0) // no error
990: #define TIMERR_NOCANDO (TIMERR_BASE+1) // request not completed
991: #define TIMERR_STRUCT (TIMERR_BASE+33) // time struct size
992:
993: // timer data types
994: typedef VOID TIMECALLBACK
995: (UINT uTimerID, UINT msg, DWORD dwUser, DWORD dw1, DWORD dw2);
996: typedef TIMECALLBACK *LPTIMECALLBACK;
997:
998: // flags for wFlags parameter of timeSetEvent() function
999: #define TIME_ONESHOT 0 // program timer for single event
1000: #define TIME_PERIODIC 1 // program for continuous periodic event
1001:
1002: // timer device capabilities data structure
1003: typedef struct timecaps_tag {
1004: UINT wPeriodMin; // minimum period supported
1005: UINT wPeriodMax; // maximum period supported
1006: } TIMECAPS;
1007: typedef TIMECAPS *PTIMECAPS;
1008: typedef TIMECAPS *NPTIMECAPS;
1009: typedef TIMECAPS *LPTIMECAPS;
1010:
1011: // timer function prototypes
1012: MMRESULT APIENTRY timeGetSystemTime(LPMMTIME lpTime, UINT uSize);
1013: DWORD APIENTRY timeGetTime(VOID);
1014: UINT APIENTRY timeSetEvent(UINT uDelay, UINT uResolution,
1015: LPTIMECALLBACK lpFunction, DWORD dwUser, UINT uFlags);
1016: MMRESULT APIENTRY timeKillEvent(UINT uId);
1017: MMRESULT APIENTRY timeGetDevCaps(LPTIMECAPS lpTimeCaps, UINT uSize);
1018: MMRESULT APIENTRY timeBeginPeriod(UINT uPeriod);
1019: MMRESULT APIENTRY timeEndPeriod(UINT uPeriod);
1020:
1021: #endif //ifndef MMNOTIMER
1022:
1023:
1024: #ifndef MMNOJOY
1025: /****************************************************************************
1026:
1027: Joystick support
1028:
1029: ****************************************************************************/
1030:
1031: // joystick error return values
1032: #define JOYERR_NOERROR (0) // no error
1033: #define JOYERR_PARMS (JOYERR_BASE+5) // bad parameters
1034: #define JOYERR_NOCANDO (JOYERR_BASE+6) // request not completed
1035: #define JOYERR_UNPLUGGED (JOYERR_BASE+7) // joystick is unplugged
1036:
1037: // constants used with JOYINFO structure and MM_JOY* messages
1038: #define JOY_BUTTON1 0x0001
1039: #define JOY_BUTTON2 0x0002
1040: #define JOY_BUTTON3 0x0004
1041: #define JOY_BUTTON4 0x0008
1042: #define JOY_BUTTON1CHG 0x0100
1043: #define JOY_BUTTON2CHG 0x0200
1044: #define JOY_BUTTON3CHG 0x0400
1045: #define JOY_BUTTON4CHG 0x0800
1046:
1047: // joystick ID constants
1048: #define JOYSTICKID1 0
1049: #define JOYSTICKID2 1
1050:
1051: // joystick device capabilities data structure (UNICODE)
1052: typedef struct joycapsW_tag {
1053: WORD wMid; // manufacturer ID
1054: WORD wPid; // product ID
1055: WCHAR szPname[MAXPNAMELEN]; // product name (NULL terminated string)
1056: WORD wXmin; // minimum x position value
1057: WORD wXmax; // maximum x position value
1058: WORD wYmin; // minimum y position value
1059: WORD wYmax; // maximum y position value
1060: WORD wZmin; // minimum z position value
1061: WORD wZmax; // maximum z position value
1062: WORD wNumButtons; // number of buttons
1063: WORD wPeriodMin; // minimum message period when captured
1064: WORD wPeriodMax; // maximum message period when captured
1065: } JOYCAPSW;
1066: typedef JOYCAPSW *PJOYCAPSW;
1067: typedef JOYCAPSW *NPJOYCAPSW;
1068: typedef JOYCAPSW *LPJOYCAPSW;
1069:
1070: // joystick device capabilities data structure
1071: typedef struct joycapsA_tag {
1072: WORD wMid; // manufacturer ID
1073: WORD wPid; // product ID
1074: CHAR szPname[MAXPNAMELEN]; // product name (NULL terminated string)
1075: WORD wXmin; // minimum x position value
1076: WORD wXmax; // maximum x position value
1077: WORD wYmin; // minimum y position value
1078: WORD wYmax; // maximum y position value
1079: WORD wZmin; // minimum z position value
1080: WORD wZmax; // maximum z position value
1081: WORD wNumButtons; // number of buttons
1082: WORD wPeriodMin; // minimum message period when captured
1083: WORD wPeriodMax; // maximum message period when captured
1084: } JOYCAPSA;
1085: typedef JOYCAPSA *PJOYCAPSA;
1086: typedef JOYCAPSA *NPJOYCAPSA;
1087: typedef JOYCAPSA *LPJOYCAPSA;
1088:
1089: #ifdef UNICODE
1090: #define JOYCAPS JOYCAPSW
1091: #define NPJOYCAPS NPJOYCAPSW
1092: #define LPJOYCAPS LPJOYCAPSW
1093: #else
1094: #define JOYCAPS JOYCAPSA
1095: #define NPJOYCAPS NPJOYCAPSA
1096: #define LPJOYCAPS LPJOYCAPSA
1097: #endif
1098:
1099: // joystick information data structure
1100: typedef struct joyinfo_tag {
1101: WORD wXpos; // x position
1102: WORD wYpos; // y position
1103: WORD wZpos; // z position
1104: WORD wButtons; // button states
1105: } JOYINFO;
1106: typedef JOYINFO *PJOYINFO;
1107: typedef JOYINFO *NPJOYINFO;
1108: typedef JOYINFO *LPJOYINFO;
1109:
1110: // joystick function prototypes
1111: MMRESULT APIENTRY joyGetDevCapsW(UINT id, LPJOYCAPSW lpCaps, UINT uSize);
1112: MMRESULT APIENTRY joyGetDevCapsA(UINT id, LPJOYCAPSA lpCaps, UINT uSize);
1113: #ifdef UNICODE
1114: #define joyGetDevCaps joyGetDevCapsW
1115: #else
1116: #define joyGetDevCaps joyGetDevCapsA
1117: #endif
1118:
1119: UINT APIENTRY joyGetNumDevs(VOID);
1120: MMRESULT APIENTRY joyGetPos(UINT id, LPJOYINFO lpInfo);
1121: MMRESULT APIENTRY joyGetThreshold(UINT id,LPWORD lpwThreshold);
1122: MMRESULT APIENTRY joyReleaseCapture(UINT id);
1123: MMRESULT APIENTRY joySetCapture(HWND hwnd, UINT uId, UINT uPeriod,
1124: BOOL bChanged);
1125: MMRESULT APIENTRY joySetThreshold(UINT id, UINT uThreshold);
1126: UINT APIENTRY joySetCalibration(UINT id, LPWORD pwXbase, /* ;Internal */
1127: LPWORD pwXdelta, LPWORD pwYbase, LPWORD pwYdelta, /* ;Internal */
1128: LPWORD pwZbase, LPWORD pwZdelta); /* ;Internal */
1129:
1130: #endif //ifndef MMNOJOY
1131:
1132: #ifndef MMNOMMIO
1133: /****************************************************************************
1134:
1135: Multimedia File I/O support
1136:
1137: ****************************************************************************/
1138:
1139: // MMIO error return values
1140: #define MMIOERR_BASE 256
1141: #define MMIOERR_FILENOTFOUND (MMIOERR_BASE + 1) // file not found
1142: #define MMIOERR_OUTOFMEMORY (MMIOERR_BASE + 2) // out of memory
1143: #define MMIOERR_CANNOTOPEN (MMIOERR_BASE + 3) // cannot open
1144: #define MMIOERR_CANNOTCLOSE (MMIOERR_BASE + 4) // cannot close
1145: #define MMIOERR_CANNOTREAD (MMIOERR_BASE + 5) // cannot read
1146: #define MMIOERR_CANNOTWRITE (MMIOERR_BASE + 6) // cannot write
1147: #define MMIOERR_CANNOTSEEK (MMIOERR_BASE + 7) // cannot seek
1148: #define MMIOERR_CANNOTEXPAND (MMIOERR_BASE + 8) // cannot expand file
1149: #define MMIOERR_CHUNKNOTFOUND (MMIOERR_BASE + 9) // chunk not found
1150: #define MMIOERR_UNBUFFERED (MMIOERR_BASE + 10) // file is unbuffered
1151:
1152: // MMIO constants
1153: #define CFSEPCHAR '+' // compound file name separator char.
1154:
1155: // MMIO data types
1156: typedef DWORD FOURCC; // a four character code
1157: typedef HANDLE HMMIO; // a handle to an open file
1158: typedef LPSTR HPSTR; // a huge version of LPSTR
1159:
1160: typedef LRESULT MMIOPROC
1161: (LPSTR lpmmioinfo, UINT uMsg, LONG lParam1, LONG lParam2);
1162: typedef MMIOPROC *LPMMIOPROC;
1163:
1164: // general MMIO information data structure
1165: typedef struct // The MMIO state
1166: {
1167: /* general fields */
1168: DWORD dwFlags; // general status flags
1169: FOURCC fccIOProc; // 4 char id for the I/O procedure
1170: LPMMIOPROC pIOProc; // pointer to I/O procedure
1171: UINT wErrorRet; // place for error to be returned
1172: HANDLE htask; //
1173:
1174: /* fields maintained by MMIO functions during buffered I/O */
1175: LONG cchBuffer; // size of I/O buffer (or 0L)
1176: LPSTR pchBuffer; // start of I/O buffer (or NULL)
1177: LPSTR pchNext; // pointer to next byte to read/write
1178: LPSTR pchEndRead; // pointer to last valid byte to read
1179: LPSTR pchEndWrite; // pointer to last byte to write
1180: LONG lBufOffset; // disk offset of start of buffer
1181:
1182: /* fields maintained by I/O procedure */
1183: LONG lDiskOffset; // disk offset of next read or write
1184: DWORD adwInfo[3]; // data specific to type of MMIOPROC
1185:
1186: /* other fields maintained by MMIO */
1187: DWORD dwReserved1; // reserved for MMIO use
1188: DWORD dwReserved2; // reserved for MMIO use
1189: HMMIO hmmio; // handle to open file
1190:
1191: } MMIOINFO;
1192: typedef MMIOINFO *PMMIOINFO;
1193: typedef MMIOINFO *NPMMIOINFO;
1194: typedef MMIOINFO *LPMMIOINFO;
1195:
1196: // RIFF chunk information data structure
1197: typedef struct MMCKINFO_tag // structure for representing RIFF chunk info.
1198: {
1199: FOURCC ckid; // chunk ID
1200: DWORD cksize; // chunk size
1201: FOURCC fccType; // form type or list type
1202: DWORD dwDataOffset; // offset of data portion of chunk
1203: DWORD dwFlags; // flags used by MMIO functions
1204: } MMCKINFO;
1205: typedef MMCKINFO *PMMCKINFO;
1206: typedef MMCKINFO *NPMMCKINFO;
1207: typedef MMCKINFO *LPMMCKINFO;
1208:
1209: /* <dwFlags> field of MMIOINFO structure -- many same as OpenFile() flags */
1210: /* Low word of flags will be passed to OpenFile() -- therefore, any MMIO-
1211: specific flags should be in the high word. */
1212: #define MMIO_RWMODE 0x00000003 // mask to get bits used for opening
1213: // file for reading/writing/both
1214: #define MMIO_SHAREMODE 0x00000070 // file sharing mode number
1215:
1216: // constants for dwFlags field of MMIOINFO
1217: #define MMIO_CREATE 0x00001000 // create new file (or truncate file)
1218: #define MMIO_PARSE 0x00000100 // parse new file returning path
1219: #define MMIO_DELETE 0x00000200 // create new file (or truncate file)
1220: #define MMIO_EXIST 0x00004000 // checks for existence of file
1221: #define MMIO_ALLOCBUF 0x00010000 // mmioOpen() should allocate a buffer
1222: #define MMIO_GETTEMP 0x00020000 // mmioOpen() should retrieve temp name
1223:
1224: #define MMIO_DIRTY 0x10000000 // I/O buffer is dirty
1225: /* MMIO_DIRTY is also used in the <dwFlags> field of MMCKINFO structure */
1226:
1227: #define MMIO_OPEN_VALID 0x0003FFFF // valid flags for mmioOpen /* ;Internal */
1228:
1229: /* read/write mode numbers (bit field MMIO_RWMODE) */
1230: #define MMIO_READ 0x00000000 // open file for reading only
1231: #define MMIO_WRITE 0x00000001 // open file for writing only
1232: #define MMIO_READWRITE 0x00000002 // open file for reading and writing
1233:
1234: /* share mode numbers (bit field MMIO_SHAREMODE) */
1235: #define MMIO_COMPAT 0x00000000 // compatibility mode
1236: #define MMIO_EXCLUSIVE 0x00000010 // exclusive-access mode
1237: #define MMIO_DENYWRITE 0x00000020 // deny writing to other processes
1238: #define MMIO_DENYREAD 0x00000030 // deny reading to other processes
1239: #define MMIO_DENYNONE 0x00000040 // deny nothing to other processes
1240:
1241: /* flags for other functions */
1242: #define MMIO_FHOPEN 0x0010 // mmioClose(): keep file handle open
1243: #define MMIO_EMPTYBUF 0x0010 // mmioFlush(): empty the I/O buffer
1244: #define MMIO_TOUPPER 0x0010 // mmioStringToFOURCC(): cvt. to u-case
1245: #define MMIO_INSTALLPROC 0x00010000 // mmioInstallIOProc(): install MMIOProc
1246: #define MMIO_GLOBALPROC 0x10000000 // mmioInstallIOProc: install globally
1247: #define MMIO_UNICODEPROC 0x01000000 // mmioInstallIOProc(): Unicode MMIOProc
1248: #define MMIO_REMOVEPROC 0x00020000 // mmioInstallIOProc(): remove MMIOProc
1249: #define MMIO_FINDPROC 0x00040000 // mmioInstallIOProc(): find an MMIOProc
1250: #define MMIO_FINDCHUNK 0x0010 // mmioDescend(): find a chunk by ID
1251: #define MMIO_FINDRIFF 0x0020 // mmioDescend(): find a LIST chunk
1252: // ???
1253: #define MMIO_FINDLIST 0x0040 // mmioDescend(): find a RIFF chunk
1254: // ???
1255: #define MMIO_CREATERIFF 0x0020 // mmioCreateChunk(): make a LIST chunk
1256: // ???
1257: #define MMIO_CREATELIST 0x0040 // mmioCreateChunk(): make a RIFF chunk
1258: // ???
1259:
1260: #define MMIO_VALIDPROC 0x11070000 // valid for mmioInstallIOProc /* ;Internal */
1261:
1262: /* message numbers for MMIOPROC I/O procedure functions */
1263: #define MMIOM_READ MMIO_READ // read (must equal MMIO_READ!)
1264: #define MMIOM_WRITE MMIO_WRITE // write (must equal MMIO_WRITE!)
1265: #define MMIOM_SEEK 2 // seek to a new position in file
1266: #define MMIOM_OPEN 3 // open file
1267: #define MMIOM_CLOSE 4 // close file
1268: #define MMIOM_WRITEFLUSH 5 // write and flush
1269: #define MMIOM_RENAME 6 // rename specified file
1270: #define MMIOM_USER 0x8000 // beginning of user-defined messages
1271:
1272: /* standard four character codes */
1273: #define FOURCC_RIFF mmioFOURCC('R', 'I', 'F', 'F')
1274: #define FOURCC_LIST mmioFOURCC('L', 'I', 'S', 'T')
1275:
1276: /* four character codes used to identify standard built-in I/O procedures */
1277: #define FOURCC_DOS mmioFOURCC('D', 'O', 'S', ' ')
1278: #define FOURCC_MEM mmioFOURCC('M', 'E', 'M', ' ')
1279:
1280: // flags for mmioSeek()
1281: #ifndef SEEK_SET
1282: #define SEEK_SET 0 // seek to an absolute position
1283: #define SEEK_CUR 1 // seek relative to current position
1284: #define SEEK_END 2 // seek relative to end of file
1285: #endif //ifndef SEEK_SET
1286:
1287: /* other constants */
1288: #define MMIO_DEFAULTBUFFER 8192 // default buffer size
1289:
1290: /* MMIO macros */
1291: #define mmioFOURCC( ch0, ch1, ch2, ch3 ) \
1292: ( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ) | \
1293: ( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) )
1294: // This macro is machine byte-sex and word-sex dependent!!
1295: // The characters are BYTES, so compatible with ANSI, not at all with UNICODE
1296:
1297:
1298: /* MMIO prototypes */
1299:
1300: FOURCC APIENTRY mmioStringToFOURCCA(LPSTR sz, UINT uFlags);
1301: FOURCC APIENTRY mmioStringToFOURCCW(LPWSTR sz, UINT uFlags);
1302: #ifdef UNICODE
1303: #define mmioStringToFOURCC mmioStringToFOURCCW
1304: #else
1305: #define mmioStringToFOURCC mmioStringToFOURCCA
1306: #endif
1307:
1308: LPMMIOPROC APIENTRY mmioInstallIOProcA( FOURCC fccIOProc, LPMMIOPROC pIOProc,
1309: DWORD dwFlags);
1310: LPMMIOPROC APIENTRY mmioInstallIOProcW( FOURCC fccIOProc, LPMMIOPROC pIOProc,
1311: DWORD dwFlags);
1312: #ifdef UNICODE
1313: #define mmioInstallIOProc mmioInstallIOProcW
1314: #else
1315: #define mmioInstallIOProc mmioInstallIOProcA
1316: #endif
1317:
1318: HMMIO APIENTRY mmioOpenA( LPSTR szFileName, LPMMIOINFO lpmmioinfo,
1319: DWORD dwOpenFlags);
1320: HMMIO APIENTRY mmioOpenW( LPWSTR szFileName, LPMMIOINFO lpmmioinfo,
1321: DWORD dwOpenFlags);
1322: #ifdef UNICODE
1323: #define mmioOpen mmioOpenW
1324: #else
1325: #define mmioOpen mmioOpenA
1326: #endif
1327:
1328: MMRESULT APIENTRY mmioRenameA( LPSTR szFileName, LPSTR szNewFileName,
1329: LPMMIOINFO lpmmioinfo, DWORD dwRenameFlags);
1330: MMRESULT APIENTRY mmioRenameW( LPWSTR szFileName, LPWSTR szNewFileName,
1331: LPMMIOINFO lpmmioinfo, DWORD dwRenameFlags);
1332: #ifdef UNICODE
1333: #define mmioRename mmioRenameW
1334: #else
1335: #define mmioRename mmioRenameA
1336: #endif
1337:
1338:
1339: MMRESULT APIENTRY mmioClose(HMMIO hmmio, UINT uFlags);
1340: LRESULT APIENTRY mmioRead(HMMIO hmmio, LPSTR pch, LONG cch);
1341: LRESULT APIENTRY mmioWrite(HMMIO hmmio, LPSTR pch, LONG cch);
1342: LRESULT APIENTRY mmioSeek(HMMIO hmmio, LONG lOffset, int iOrigin);
1343: MMRESULT APIENTRY mmioGetInfo(HMMIO hmmio, LPMMIOINFO lpmmioinfo, UINT uFlags);
1344: MMRESULT APIENTRY mmioSetInfo(HMMIO hmmio, LPMMIOINFO lpmmioinfo, UINT uFlags);
1345: MMRESULT APIENTRY mmioSetBuffer( HMMIO hmmio, LPSTR pchBuffer, LONG cchBuffer,
1346: UINT uFlags);
1347: MMRESULT APIENTRY mmioFlush(HMMIO hmmio, UINT uFlags);
1348: MMRESULT APIENTRY mmioAdvance(HMMIO hmmio, LPMMIOINFO lpmmioinfo, UINT uFlags);
1349: LRESULT APIENTRY mmioSendMessage( HMMIO hmmio, UINT uMsg,
1350: LONG lParam1, LONG lParam2);
1351:
1352: /* RIFF I/O prototypes */
1353: MMRESULT APIENTRY mmioDescend( HMMIO hmmio, LPMMCKINFO lpck,
1354: LPMMCKINFO lpckParent, UINT uFlags);
1355: MMRESULT APIENTRY mmioAscend(HMMIO hmmio, LPMMCKINFO lpck, UINT uFlags);
1356: MMRESULT APIENTRY mmioCreateChunk(HMMIO hmmio, LPMMCKINFO lpck, UINT uFlags);
1357:
1358: #endif //ifndef MMNOMMIO
1359:
1360: typedef UINT MCIDEVICEID; // MCI device ID type
1361: // BEWARE: MCI device ids can be stored and read from Win 3 compatible
1362: // files when the device id will be WORD size.
1363:
1364: #ifndef MMNOMCI
1365: /****************************************************************************
1366:
1367: MCI support
1368:
1369: ****************************************************************************/
1370:
1371: /*--------------------------------------------------------------------*\
1372: *
1373: * MCI functions
1374: *
1375: *--------------------------------------------------------------------
1376: * msiSendCommand
1377: \*--------------------------------------------------------------------*/
1378: MCIERROR APIENTRY mciSendCommandA(
1379: MCIDEVICEID wDeviceID,
1380: UINT uMessage,
1381: DWORD dwParam1,
1382: DWORD dwParam2 );
1383:
1384: MCIERROR APIENTRY mciSendCommandW(
1385: MCIDEVICEID wDeviceID,
1386: UINT uMessage,
1387: DWORD dwParam1,
1388: DWORD dwParam2 );
1389:
1390: #ifdef UNICODE
1391: #define mciSendCommand mciSendCommandW
1392: #else
1393: #define mciSendCommand mciSendCommandA
1394: #endif
1395:
1396:
1397: /*--------------------------------------------------------------------*\
1398: * mciSendString
1399: \*--------------------------------------------------------------------*/
1400: MCIERROR APIENTRY mciSendStringA(
1401: LPCSTR lpstrCommand,
1402: LPSTR lpstrReturnString,
1403: UINT uReturnLength,
1404: HWND hwndCallback );
1405:
1406: MCIERROR APIENTRY mciSendStringW(
1407: LPCWSTR lpstrCommand,
1408: LPWSTR lpstrReturnString,
1409: UINT uReturnLength,
1410: HWND hwndCallback );
1411:
1412: #ifdef UNICODE
1413: #define mciSendString mciSendStringW
1414: #else
1415: #define mciSendString mciSendStringA
1416: #endif
1417:
1418:
1419: /*--------------------------------------------------------------------*\
1420: * mciGetCreatorTask
1421: \*--------------------------------------------------------------------*/
1422: HANDLE APIENTRY mciGetCreatorTask(
1423: MCIDEVICEID wDeviceID);
1424:
1425:
1426: /*--------------------------------------------------------------------*\
1427: * mciGetDeviceID
1428: \*--------------------------------------------------------------------*/
1429: MCIDEVICEID APIENTRY mciGetDeviceIDA(
1430: LPCSTR lpstrName );
1431:
1432: MCIDEVICEID APIENTRY mciGetDeviceIDW(
1433: LPCWSTR lpstrName );
1434:
1435: #ifdef UNICODE
1436: #define mciGetDeviceID mciGetDeviceIDW
1437: #else
1438: #define mciGetDeviceID mciGetDeviceIDA
1439: #endif
1440:
1441: /*--------------------------------------------------------------------*\
1442: * mciGetDeviceIDFromElementID
1443: \*--------------------------------------------------------------------*/
1444: MCIDEVICEID APIENTRY mciGetDeviceIDFromElementIDA(
1445: DWORD dwElementID,
1446: LPCSTR lpstrType );
1447:
1448: MCIDEVICEID APIENTRY mciGetDeviceIDFromElementIDW(
1449: DWORD dwElementID,
1450: LPCWSTR lpstrType );
1451:
1452: #ifdef UNICODE
1453: #define mciGetDeviceIDFromElementID mciGetDeviceIDFromElementIDW
1454: #else
1455: #define mciGetDeviceIDFromElementID mciGetDeviceIDFromElementIDA
1456: #endif
1457:
1458:
1459: /*--------------------------------------------------------------------*\
1460: * mciGetErrorString
1461: \*--------------------------------------------------------------------*/
1462: BOOL APIENTRY mciGetErrorStringA(
1463: DWORD dwError,
1464: LPSTR lpstrBuffer,
1465: UINT uLength );
1466:
1467: BOOL APIENTRY mciGetErrorStringW(
1468: DWORD dwError,
1469: LPWSTR lpstrBuffer,
1470: UINT uLength );
1471:
1472: #ifdef UNICODE
1473: #define mciGetErrorString mciGetErrorStringW
1474: #else
1475: #define mciGetErrorString mciGetErrorStringA
1476: #endif
1477:
1478:
1479: /*--------------------------------------------------------------------*\
1480: * mciExecute
1481: \*--------------------------------------------------------------------*/
1482: BOOL APIENTRY mciExecuteA(
1483: LPCSTR lpstrCommand );
1484:
1485: BOOL APIENTRY mciExecuteW(
1486: LPCWSTR lpstrCommand );
1487:
1488: #ifdef UNICODE
1489: #define mciExecute mciExecuteW
1490: #else
1491: #define mciExecute mciExecuteA
1492: #endif
1493:
1494: //BOOL APIENTRY mciSetYieldProc ( MCIDEVICEID wDeviceID // ???
1495: // , YIELDPROC fpYieldProc // ???
1496: // , DWORD dwYieldData // ???
1497: // ); // ???
1498: //YIELDPROC APIENTRY mciGetYieldProc ( MCIDEVICEID wDeviceID // ???
1499: // , LPDWORD lpdwYieldData // ???
1500: // ); // ???
1501: //
1502:
1503: typedef UINT (*YIELDPROC) (MCIDEVICEID wDeviceID, DWORD dwYieldData);
1504:
1505: // THIS NUMBER IS HARDCODED WHERE THE MCI_FORMAT_<x>'s ARE #define'd
1506: // You must change those definitions if you change this number
1507:
1508: // MCI error return values
1509: #define MCIERR_INVALID_DEVICE_ID (MCIERR_BASE + 1)
1510: #define MCIERR_UNRECOGNIZED_KEYWORD (MCIERR_BASE + 3)
1511: #define MCIERR_UNRECOGNIZED_COMMAND (MCIERR_BASE + 5)
1512: #define MCIERR_HARDWARE (MCIERR_BASE + 6)
1513: #define MCIERR_INVALID_DEVICE_NAME (MCIERR_BASE + 7)
1514: #define MCIERR_OUT_OF_MEMORY (MCIERR_BASE + 8)
1515: #define MCIERR_DEVICE_OPEN (MCIERR_BASE + 9)
1516: #define MCIERR_CANNOT_LOAD_DRIVER (MCIERR_BASE + 10)
1517: #define MCIERR_MISSING_COMMAND_STRING (MCIERR_BASE + 11)
1518: #define MCIERR_PARAM_OVERFLOW (MCIERR_BASE + 12)
1519: #define MCIERR_MISSING_STRING_ARGUMENT (MCIERR_BASE + 13)
1520: #define MCIERR_BAD_INTEGER (MCIERR_BASE + 14)
1521: #define MCIERR_PARSER_INTERNAL (MCIERR_BASE + 15)
1522: #define MCIERR_DRIVER_INTERNAL (MCIERR_BASE + 16)
1523: #define MCIERR_MISSING_PARAMETER (MCIERR_BASE + 17)
1524: #define MCIERR_UNSUPPORTED_FUNCTION (MCIERR_BASE + 18)
1525: #define MCIERR_FILE_NOT_FOUND (MCIERR_BASE + 19)
1526: #define MCIERR_DEVICE_NOT_READY (MCIERR_BASE + 20)
1527: #define MCIERR_INTERNAL (MCIERR_BASE + 21)
1528: #define MCIERR_DRIVER (MCIERR_BASE + 22)
1529: #define MCIERR_CANNOT_USE_ALL (MCIERR_BASE + 23)
1530: #define MCIERR_MULTIPLE (MCIERR_BASE + 24)
1531: #define MCIERR_EXTENSION_NOT_FOUND (MCIERR_BASE + 25)
1532: #define MCIERR_OUTOFRANGE (MCIERR_BASE + 26)
1533: #define MCIERR_FLAGS_NOT_COMPATIBLE (MCIERR_BASE + 28)
1534: #define MCIERR_FILE_NOT_SAVED (MCIERR_BASE + 30)
1535: #define MCIERR_DEVICE_TYPE_REQUIRED (MCIERR_BASE + 31)
1536: #define MCIERR_DEVICE_LOCKED (MCIERR_BASE + 32)
1537: #define MCIERR_DUPLICATE_ALIAS (MCIERR_BASE + 33)
1538: #define MCIERR_BAD_CONSTANT (MCIERR_BASE + 34)
1539: #define MCIERR_MUST_USE_SHAREABLE (MCIERR_BASE + 35)
1540: #define MCIERR_MISSING_DEVICE_NAME (MCIERR_BASE + 36)
1541: #define MCIERR_BAD_TIME_FORMAT (MCIERR_BASE + 37)
1542: #define MCIERR_NO_CLOSING_QUOTE (MCIERR_BASE + 38)
1543: #define MCIERR_DUPLICATE_FLAGS (MCIERR_BASE + 39)
1544: #define MCIERR_INVALID_FILE (MCIERR_BASE + 40)
1545: #define MCIERR_NULL_PARAMETER_BLOCK (MCIERR_BASE + 41)
1546: #define MCIERR_UNNAMED_RESOURCE (MCIERR_BASE + 42)
1547: #define MCIERR_NEW_REQUIRES_ALIAS (MCIERR_BASE + 43)
1548: #define MCIERR_NOTIFY_ON_AUTO_OPEN (MCIERR_BASE + 44)
1549: #define MCIERR_NO_ELEMENT_ALLOWED (MCIERR_BASE + 45)
1550: #define MCIERR_NONAPPLICABLE_FUNCTION (MCIERR_BASE + 46)
1551: #define MCIERR_ILLEGAL_FOR_AUTO_OPEN (MCIERR_BASE + 47)
1552: #define MCIERR_FILENAME_REQUIRED (MCIERR_BASE + 48)
1553: #define MCIERR_EXTRA_CHARACTERS (MCIERR_BASE + 49)
1554: #define MCIERR_DEVICE_NOT_INSTALLED (MCIERR_BASE + 50)
1555: #define MCIERR_GET_CD (MCIERR_BASE + 51)
1556: #define MCIERR_SET_CD (MCIERR_BASE + 52)
1557: #define MCIERR_SET_DRIVE (MCIERR_BASE + 53)
1558: #define MCIERR_DEVICE_LENGTH (MCIERR_BASE + 54)
1559: #define MCIERR_DEVICE_ORD_LENGTH (MCIERR_BASE + 55)
1560: #define MCIERR_NO_INTEGER (MCIERR_BASE + 56)
1561:
1562: #define MCIERR_WAVE_OUTPUTSINUSE (MCIERR_BASE + 64)
1563: #define MCIERR_WAVE_SETOUTPUTINUSE (MCIERR_BASE + 65)
1564: #define MCIERR_WAVE_INPUTSINUSE (MCIERR_BASE + 66)
1565: #define MCIERR_WAVE_SETINPUTINUSE (MCIERR_BASE + 67)
1566: #define MCIERR_WAVE_OUTPUTUNSPECIFIED (MCIERR_BASE + 68)
1567: #define MCIERR_WAVE_INPUTUNSPECIFIED (MCIERR_BASE + 69)
1568: #define MCIERR_WAVE_OUTPUTSUNSUITABLE (MCIERR_BASE + 70)
1569: #define MCIERR_WAVE_SETOUTPUTUNSUITABLE (MCIERR_BASE + 71)
1570: #define MCIERR_WAVE_INPUTSUNSUITABLE (MCIERR_BASE + 72)
1571: #define MCIERR_WAVE_SETINPUTUNSUITABLE (MCIERR_BASE + 73)
1572:
1573: #define MCIERR_SEQ_DIV_INCOMPATIBLE (MCIERR_BASE + 80)
1574: #define MCIERR_SEQ_PORT_INUSE (MCIERR_BASE + 81)
1575: #define MCIERR_SEQ_PORT_NONEXISTENT (MCIERR_BASE + 82)
1576: #define MCIERR_SEQ_PORT_MAPNODEVICE (MCIERR_BASE + 83)
1577: #define MCIERR_SEQ_PORT_MISCERROR (MCIERR_BASE + 84)
1578: #define MCIERR_SEQ_TIMER (MCIERR_BASE + 85)
1579: #define MCIERR_SEQ_PORTUNSPECIFIED (MCIERR_BASE + 86)
1580: #define MCIERR_SEQ_NOMIDIPRESENT (MCIERR_BASE + 87)
1581:
1582: #define MCIERR_NO_WINDOW (MCIERR_BASE + 90)
1583: #define MCIERR_CREATEWINDOW (MCIERR_BASE + 91)
1584: #define MCIERR_FILE_READ (MCIERR_BASE + 92)
1585: #define MCIERR_FILE_WRITE (MCIERR_BASE + 93)
1586:
1587: // All custom device driver errors must be >= this value
1588: #define MCIERR_CUSTOM_DRIVER_BASE (MCIERR_BASE + 256)
1589:
1590: /****************************************************************************
1591: * MCI command message identifiers
1592: *****************************************************************************/
1593: // Message numbers are hard coded because the resource compiler
1594: // will otherwise fail on the RCDATA command table in mmsystem.rc
1595:
1596: // They must be in the range between MCI_FIRST and MCI_LAST
1597:
1598: #define MCI_FIRST 0x0800
1599: // Messages 0x801 and 0x802 are reserved
1600: #define MCI_OPEN 0x0803
1601: #define MCI_CLOSE 0x0804
1602: #define MCI_ESCAPE 0x0805
1603: #define MCI_PLAY 0x0806
1604: #define MCI_SEEK 0x0807
1605: #define MCI_STOP 0x0808
1606: #define MCI_PAUSE 0x0809
1607: #define MCI_INFO 0x080A
1608: #define MCI_GETDEVCAPS 0x080B
1609: #define MCI_SPIN 0x080C
1610: #define MCI_SET 0x080D
1611: #define MCI_STEP 0x080E
1612: #define MCI_RECORD 0x080F
1613: #define MCI_SYSINFO 0x0810
1614: #define MCI_BREAK 0x0811
1615: #define MCI_SOUND 0x0812
1616: #define MCI_SAVE 0x0813
1617: #define MCI_STATUS 0x0814
1618:
1619: #define MCI_CUE 0x0830
1620:
1621: #define MCI_REALIZE 0x0840
1622: #define MCI_WINDOW 0x0841
1623: #define MCI_PUT 0x0842
1624: #define MCI_WHERE 0x0843
1625: #define MCI_FREEZE 0x0844
1626: #define MCI_UNFREEZE 0x0845
1627:
1628: #define MCI_LOAD 0x0850
1629: #define MCI_CUT 0x0851
1630: #define MCI_COPY 0x0852
1631: #define MCI_PASTE 0x0853
1632: #define MCI_UPDATE 0x0854
1633: #define MCI_RESUME 0x0855
1634: #define MCI_DELETE 0x0856
1635:
1636: #define MCI_LAST 0x0FFF
1637:
1638: // the next 0x400 message ID's are reserved for custom drivers
1639: // all custom MCI command messages must be >= than this value
1640: #define MCI_USER_MESSAGES (0x400 + MCI_FIRST)
1641:
1642:
1643: /****************************************************************************
1644: * Structures for the lpdwParams (dwParam2) of mciSendCommand for those
1645: * command messages that may be parsed in string form.
1646: *****************************************************************************/
1647:
1648:
1649:
1650: #define MCI_ALL_DEVICE_ID ((MCIDEVICEID)-1) // Device ids are 16 bits
1651:
1652: // constants for predefined MCI device types
1653: //#define MCI_DEVTYPE_VCR (MCI_STRING_OFFSET + 1)
1654: //#define MCI_DEVTYPE_VIDEODISC (MCI_STRING_OFFSET + 2)
1655: //#define MCI_DEVTYPE_OVERLAY (MCI_STRING_OFFSET + 3)
1656: //#define MCI_DEVTYPE_CD_AUDIO (MCI_STRING_OFFSET + 4)
1657: //#define MCI_DEVTYPE_DAT (MCI_STRING_OFFSET + 5)
1658: //#define MCI_DEVTYPE_SCANNER (MCI_STRING_OFFSET + 6)
1659: //#define MCI_DEVTYPE_ANIMATION (MCI_STRING_OFFSET + 7)
1660: //#define MCI_DEVTYPE_DIGITAL_VIDEO (MCI_STRING_OFFSET + 8)
1661: //#define MCI_DEVTYPE_OTHER (MCI_STRING_OFFSET + 9)
1662: //#define MCI_DEVTYPE_WAVEFORM_AUDIO (MCI_STRING_OFFSET + 10)
1663: //#define MCI_DEVTYPE_SEQUENCER (MCI_STRING_OFFSET + 11)
1664:
1665: // Constant values are used because RC does not like the parentheses
1666: #define MCI_DEVTYPE_VCR 513
1667: #define MCI_DEVTYPE_VIDEODISC 514
1668: #define MCI_DEVTYPE_OVERLAY 515
1669: #define MCI_DEVTYPE_CD_AUDIO 516
1670: #define MCI_DEVTYPE_DAT 517
1671: #define MCI_DEVTYPE_SCANNER 518
1672: #define MCI_DEVTYPE_ANIMATION 519
1673: #define MCI_DEVTYPE_DIGITAL_VIDEO 520
1674: #define MCI_DEVTYPE_OTHER 521
1675: #define MCI_DEVTYPE_WAVEFORM_AUDIO 522
1676: #define MCI_DEVTYPE_SEQUENCER 523
1677:
1678: #define MCI_DEVTYPE_FIRST MCI_DEVTYPE_VCR
1679: #define MCI_DEVTYPE_LAST MCI_DEVTYPE_SEQUENCER
1680:
1681:
1682: #define MCI_DEVTYPE_FIRST_USER 0x1000
1683:
1684: // return values for 'status mode' command
1685: #define MCI_MODE_NOT_READY (MCI_STRING_OFFSET + 12)
1686: #define MCI_MODE_STOP (MCI_STRING_OFFSET + 13)
1687: #define MCI_MODE_PLAY (MCI_STRING_OFFSET + 14)
1688: #define MCI_MODE_RECORD (MCI_STRING_OFFSET + 15)
1689: #define MCI_MODE_SEEK (MCI_STRING_OFFSET + 16)
1690: #define MCI_MODE_PAUSE (MCI_STRING_OFFSET + 17)
1691: #define MCI_MODE_OPEN (MCI_STRING_OFFSET + 18)
1692:
1693: // constants used in 'set time format' and 'status time format' commands
1694: // These are not based on MCI_FORMATS_OFFSET because of resource
1695: // compiler limitations
1696: #define MCI_FORMAT_MILLISECONDS 0
1697: #define MCI_FORMAT_HMS 1
1698: #define MCI_FORMAT_MSF 2
1699: #define MCI_FORMAT_FRAMES 3
1700: #define MCI_FORMAT_SMPTE_24 4
1701: #define MCI_FORMAT_SMPTE_25 5
1702: #define MCI_FORMAT_SMPTE_30 6
1703: #define MCI_FORMAT_SMPTE_30DROP 7
1704: #define MCI_FORMAT_BYTES 8
1705: #define MCI_FORMAT_SAMPLES 9
1706: #define MCI_FORMAT_TMSF 10
1707:
1708: // MCI time format conversion macros
1709: // Note that these macros are byte-sex dependent as the SMPT format gives
1710: // the layout in storage that's wanted.
1711: #define MCI_MSF_MINUTE(msf) ((BYTE)(msf))
1712: #define MCI_MSF_SECOND(msf) ((BYTE)(((WORD)(msf)) >> 8))
1713: #define MCI_MSF_FRAME(msf) ((BYTE)((msf)>>16))
1714:
1715: #define MCI_MAKE_MSF(m, s, f) ((DWORD)(((BYTE)(m) | \
1716: ((WORD)(s)<<8)) | \
1717: (((DWORD)(BYTE)(f))<<16)))
1718:
1719: #define MCI_TMSF_TRACK(tmsf) ((BYTE)(tmsf))
1720: #define MCI_TMSF_MINUTE(tmsf) ((BYTE)(((WORD)(tmsf)) >> 8))
1721: #define MCI_TMSF_SECOND(tmsf) ((BYTE)((tmsf)>>16))
1722: #define MCI_TMSF_FRAME(tmsf) ((BYTE)((tmsf)>>24))
1723:
1724: #define MCI_MAKE_TMSF(t, m, s, f) ( (DWORD)( ( (BYTE)(t) \
1725: | ( (WORD)(m) << 8 ) \
1726: ) \
1727: | ( ( (DWORD)(BYTE)(s) \
1728: | ( (WORD)(f) <<8 ) \
1729: ) \
1730: << 16 \
1731: ) \
1732: ) \
1733: )
1734:
1735: #define MCI_HMS_HOUR(hms) ((BYTE)(hms))
1736: #define MCI_HMS_MINUTE(hms) ((BYTE)(((WORD)(hms)) >> 8))
1737: #define MCI_HMS_SECOND(hms) ((BYTE)((hms)>>16))
1738:
1739: #define MCI_MAKE_HMS(h, m, s) ( (DWORD)( ( (BYTE)(h) \
1740: | ( (WORD)(m) <<8 ) \
1741: ) \
1742: | ( ( (DWORD)(BYTE)(s) ) \
1743: <<16 \
1744: ) \
1745: ) \
1746: )
1747:
1748:
1749:
1750: /* Flags for wParam of the MM_MCINOTIFY message */
1751: #define MCI_NOTIFY_SUCCESSFUL 0x0001
1752: #define MCI_NOTIFY_SUPERSEDED 0x0002
1753: #define MCI_NOTIFY_ABORTED 0x0004
1754: #define MCI_NOTIFY_FAILURE 0x0008
1755:
1756: // NOTE: All flags must have an "L" suffix in order to be parsed as
1757: // DWORDs by the resource compiler
1758:
1759: // common flags for dwFlags parameter of MCI command messages
1760: #define MCI_NOTIFY 0x00000001L
1761: #define MCI_WAIT 0x00000002L
1762: #define MCI_FROM 0x00000004L
1763: #define MCI_TO 0x00000008L
1764: #define MCI_TRACK 0x00000010L
1765:
1766: // flags for dwFlags parameter of MCI_OPEN command message
1767: #define MCI_OPEN_SHAREABLE 0x00000100L
1768: #define MCI_OPEN_ELEMENT 0x00000200L
1769: #define MCI_OPEN_ALIAS 0x00000400L
1770: #define MCI_OPEN_ELEMENT_ID 0x00000800L
1771: #define MCI_OPEN_TYPE_ID 0x00001000L
1772: #define MCI_OPEN_TYPE 0x00002000L
1773:
1774: // flags for dwFlags parameter of MCI_SEEK command message
1775: #define MCI_SEEK_TO_START 0x00000100L
1776: #define MCI_SEEK_TO_END 0x00000200L
1777:
1778: // flags for dwFlags parameter of MCI_STATUS command message
1779: #define MCI_STATUS_ITEM 0x00000100L
1780: #define MCI_STATUS_START 0x00000200L
1781:
1782: // flags for dwItem field of the MCI_STATUS_PARMS parameter block
1783: #define MCI_STATUS_LENGTH 0x00000001L
1784: #define MCI_STATUS_POSITION 0x00000002L
1785: #define MCI_STATUS_NUMBER_OF_TRACKS 0x00000003L
1786: #define MCI_STATUS_MODE 0x00000004L
1787: #define MCI_STATUS_MEDIA_PRESENT 0x00000005L
1788: #define MCI_STATUS_TIME_FORMAT 0x00000006L
1789: #define MCI_STATUS_READY 0x00000007L
1790: #define MCI_STATUS_CURRENT_TRACK 0x00000008L
1791:
1792: // flags for dwFlags parameter of MCI_INFO command message
1793: #define MCI_INFO_PRODUCT 0x00000100L
1794: #define MCI_INFO_FILE 0x00000200L
1795:
1796: // flags for dwFlags parameter of MCI_GETDEVCAPS command message
1797: #define MCI_GETDEVCAPS_ITEM 0x00000100L
1798:
1799: // flags for dwItem field of the MCI_GETDEVCAPS_PARMS parameter block
1800: #define MCI_GETDEVCAPS_CAN_RECORD 0x00000001L
1801: #define MCI_GETDEVCAPS_HAS_AUDIO 0x00000002L
1802: #define MCI_GETDEVCAPS_HAS_VIDEO 0x00000003L
1803: #define MCI_GETDEVCAPS_DEVICE_TYPE 0x00000004L
1804: #define MCI_GETDEVCAPS_USES_FILES 0x00000005L
1805: #define MCI_GETDEVCAPS_COMPOUND_DEVICE 0x00000006L
1806: #define MCI_GETDEVCAPS_CAN_EJECT 0x00000007L
1807: #define MCI_GETDEVCAPS_CAN_PLAY 0x00000008L
1808: #define MCI_GETDEVCAPS_CAN_SAVE 0x00000009L
1809:
1810: // flags for dwFlags parameter of MCI_SYSINFO command message
1811: #define MCI_SYSINFO_QUANTITY 0x00000100L
1812: #define MCI_SYSINFO_OPEN 0x00000200L
1813: #define MCI_SYSINFO_NAME 0x00000400L
1814: #define MCI_SYSINFO_INSTALLNAME 0x00000800L
1815:
1816: // flags for dwFlags parameter of MCI_SET command message
1817: #define MCI_SET_DOOR_OPEN 0x00000100L
1818: #define MCI_SET_DOOR_CLOSED 0x00000200L
1819: #define MCI_SET_TIME_FORMAT 0x00000400L
1820: #define MCI_SET_AUDIO 0x00000800L
1821: #define MCI_SET_VIDEO 0x00001000L
1822: #define MCI_SET_ON 0x00002000L
1823: #define MCI_SET_OFF 0x00004000L
1824:
1825: // flags for dwAudio field of MCI_SET_PARMS or MCI_SEQ_SET_PARMS
1826: #define MCI_SET_AUDIO_ALL 0x00004001L
1827: #define MCI_SET_AUDIO_LEFT 0x00004002L
1828: #define MCI_SET_AUDIO_RIGHT 0x00004003L
1829:
1830: // flags for dwFlags parameter of MCI_BREAK command message
1831: #define MCI_BREAK_KEY 0x00000100L
1832: #define MCI_BREAK_HWND 0x00000200L
1833: #define MCI_BREAK_OFF 0x00000400L
1834:
1835: // flags for dwFlags parameter of MCI_RECORD command message
1836: #define MCI_RECORD_INSERT 0x00000100L
1837: #define MCI_RECORD_OVERWRITE 0x00000200L
1838:
1839: // flags for dwFlags parameter of MCI_SOUND command message
1840: #define MCI_SOUND_NAME 0x00000100L
1841:
1842: // flags for dwFlags parameter of MCI_SAVE command message
1843: #define MCI_SAVE_FILE 0x00000100L
1844:
1845: // flags for dwFlags parameter of MCI_LOAD command message
1846: #define MCI_LOAD_FILE 0x00000100L
1847:
1848: /* Note that some structures below do not have all the fields of the
1849: // corresponding Win 3.1 structures. Some reserved WORD sized fields
1850: // have disappeared. This is deliberate. The structures are the same
1851: // size (with one exception which is two bytes longer).
1852: //
1853: // The FIRST entry in each structure must be dwCallback. A large union
1854: // could be defined... but...
1855: */
1856:
1857: // generic parameter block for MCI command messages with no special parameters
1858: typedef struct tagMCI_GENERIC_PARMS {
1859: DWORD dwCallback;
1860: } MCI_GENERIC_PARMS;
1861: typedef MCI_GENERIC_PARMS *PMCI_GENERIC_PARMS;
1862: typedef MCI_GENERIC_PARMS *LPMCI_GENERIC_PARMS;
1863:
1864: // parameter block for MCI_OPEN command message (ascii version)
1865: typedef struct tagMCI_OPEN_PARMSA {
1866: DWORD dwCallback;
1867: MCIDEVICEID wDeviceID;
1868: // MCIDEVICEID wReserved0; // While MCIDEVICEID is a WORD
1869: LPCSTR lpstrDeviceType;
1870: LPCSTR lpstrElementName;
1871: LPCSTR lpstrAlias;
1872: } MCI_OPEN_PARMSA;
1873: typedef MCI_OPEN_PARMSA *PMCI_OPEN_PARMSA;
1874: typedef MCI_OPEN_PARMSA *LPMCI_OPEN_PARMSA;
1875:
1876: // parameter block for MCI_OPEN command message (unicode version)
1877: typedef struct tagMCI_OPEN_PARMSW {
1878: DWORD dwCallback;
1879: MCIDEVICEID wDeviceID;
1880: // MCIDEVICEID wReserved0; // While MCIDEVICEID is a WORD
1881: LPCWSTR lpstrDeviceType;
1882: LPCWSTR lpstrElementName;
1883: LPCWSTR lpstrAlias;
1884: } MCI_OPEN_PARMSW;
1885: typedef MCI_OPEN_PARMSW *PMCI_OPEN_PARMSW;
1886: typedef MCI_OPEN_PARMSW *LPMCI_OPEN_PARMSW;
1887:
1888: #ifdef UNICODE
1889: #define MCI_OPEN_PARMS MCI_OPEN_PARMSW
1890: #define PMCI_OPEN_PARMS PMCI_OPEN_PARMSW
1891: #define LPMCI_OPEN_PARMS LPMCI_OPEN_PARMSW
1892: #else
1893: #define MCI_OPEN_PARMS MCI_OPEN_PARMSA
1894: #define PMCI_OPEN_PARMS PMCI_OPEN_PARMSWA
1895: #define LPMCI_OPEN_PARMS LPMCI_OPEN_PARMSA
1896: #endif
1897:
1898:
1899: // parameter block for MCI_PLAY command message
1900: typedef struct tagMCI_PLAY_PARMS {
1901: DWORD dwCallback;
1902: DWORD dwFrom;
1903: DWORD dwTo;
1904: } MCI_PLAY_PARMS;
1905: typedef MCI_PLAY_PARMS *PMCI_PLAY_PARMS;
1906: typedef MCI_PLAY_PARMS *LPMCI_PLAY_PARMS;
1907:
1908: // parameter block for MCI_SEEK command message
1909: typedef struct tagMCI_SEEK_PARMS {
1910: DWORD dwCallback;
1911: DWORD dwTo;
1912: } MCI_SEEK_PARMS;
1913: typedef MCI_SEEK_PARMS *PMCI_SEEK_PARMS;
1914: typedef MCI_SEEK_PARMS *LPMCI_SEEK_PARMS;
1915:
1916: // parameter block for MCI_STATUS command message
1917: typedef struct tagMCI_STATUS_PARMS {
1918: DWORD dwCallback;
1919: DWORD dwReturn;
1920: DWORD dwItem;
1921: DWORD dwTrack;
1922: } MCI_STATUS_PARMS;
1923: typedef MCI_STATUS_PARMS * PMCI_STATUS_PARMS;
1924: typedef MCI_STATUS_PARMS * LPMCI_STATUS_PARMS;
1925:
1926: // parameter block for MCI_INFO command message (ascii version)
1927: typedef struct tagMCI_INFO_PARMSA {
1928: DWORD dwCallback;
1929: LPSTR lpstrReturn;
1930: DWORD dwRetSize;
1931: } MCI_INFO_PARMSA;
1932: typedef MCI_INFO_PARMSA * PMCI_INFO_PARMSA;
1933: typedef MCI_INFO_PARMSA * LPMCI_INFO_PARMSA;
1934:
1935: // parameter block for MCI_INFO command message (unicode version)
1936: typedef struct tagMCI_INFO_PARMSW {
1937: DWORD dwCallback;
1938: LPWSTR lpstrReturn;
1939: DWORD dwRetSize;
1940: } MCI_INFO_PARMSW;
1941: typedef MCI_INFO_PARMSW * PMCI_INFO_PARMSW;
1942: typedef MCI_INFO_PARMSW * LPMCI_INFO_PARMSW;
1943:
1944: #ifdef UNICODE
1945: #define MCI_INFO_PARMS MCI_INFO_PARMSW
1946: #define PMCI_INFO_PARMS PMCI_INFO_PARMSW
1947: #define LPMCI_INFO_PARMS LPMCI_INFO_PARMSW
1948: #else
1949: #define MCI_INFO_PARMS MCI_INFO_PARMSA
1950: #define PMCI_INFO_PARMS PMCI_INFO_PARMSWA
1951: #define LPMCI_INFO_PARMS LPMCI_INFO_PARMSA
1952: #endif
1953:
1954: // parameter block for MCI_GETDEVCAPS command message
1955: typedef struct tagMCI_GETDEVCAPS_PARMS {
1956: DWORD dwCallback;
1957: DWORD dwReturn;
1958: DWORD dwItem;
1959: } MCI_GETDEVCAPS_PARMS;
1960: typedef MCI_GETDEVCAPS_PARMS * PMCI_GETDEVCAPS_PARMS;
1961: typedef MCI_GETDEVCAPS_PARMS * LPMCI_GETDEVCAPS_PARMS;
1962:
1963: // parameter block for MCI_SYSINFO command message (ascii version)
1964: typedef struct tagMCI_SYSINFO_PARMSA {
1965: DWORD dwCallback;
1966: LPSTR lpstrReturn;
1967: DWORD dwRetSize;
1968: DWORD dwNumber;
1969: UINT wDeviceType;
1970: } MCI_SYSINFO_PARMSA;
1971: typedef MCI_SYSINFO_PARMSA *PMCI_SYSINFO_PARMSA;
1972: typedef MCI_SYSINFO_PARMSA *LPMCI_SYSINFO_PARMSA;
1973:
1974: // parameter block for MCI_SYSINFO command message (unicode version)
1975: typedef struct tagMCI_SYSINFO_PARMSW {
1976: DWORD dwCallback;
1977: LPWSTR lpstrReturn;
1978: DWORD dwRetSize;
1979: DWORD dwNumber;
1980: UINT wDeviceType;
1981: } MCI_SYSINFO_PARMSW;
1982: typedef MCI_SYSINFO_PARMSW *PMCI_SYSINFO_PARMSW;
1983: typedef MCI_SYSINFO_PARMSW *LPMCI_SYSINFO_PARMSW;
1984:
1985: #ifdef UNICODE
1986: #define MCI_SYSINFO_PARMS MCI_SYSINFO_PARMSW
1987: #define PMCI_SYSINFO_PARMS PMCI_SYSINFO_PARMSW
1988: #define LPMCI_SYSINFO_PARMS LPMCI_SYSINFO_PARMSW
1989: #else
1990: #define MCI_SYSINFO_PARMS MCI_SYSINFO_PARMSA
1991: #define PMCI_SYSINFO_PARMS PMCI_SYSINFO_PARMSWA
1992: #define LPMCI_SYSINFO_PARMS LPMCI_SYSINFO_PARMSA
1993: #endif
1994:
1995: // parameter block for MCI_SET command message
1996: typedef struct tagMCI_SET_PARMS {
1997: DWORD dwCallback;
1998: DWORD dwTimeFormat;
1999: DWORD dwAudio;
2000: } MCI_SET_PARMS;
2001: typedef MCI_SET_PARMS *PMCI_SET_PARMS;
2002: typedef MCI_SET_PARMS *LPMCI_SET_PARMS;
2003:
2004: // parameter block for MCI_BREAK command message
2005: typedef struct tagMCI_BREAK_PARMS {
2006: DWORD dwCallback;
2007: int nVirtKey;
2008: HWND hwndBreak;
2009: } MCI_BREAK_PARMS;
2010: typedef MCI_BREAK_PARMS * PMCI_BREAK_PARMS;
2011: typedef MCI_BREAK_PARMS * LPMCI_BREAK_PARMS;
2012:
2013: // parameter block for MCI_SOUND command message (ascii version)
2014: typedef struct tagMCI_SOUND_PARMSA {
2015: DWORD dwCallback;
2016: LPCSTR lpstrSoundName;
2017: } MCI_SOUND_PARMSA;
2018: typedef MCI_SOUND_PARMSA * PMCI_SOUND_PARMSA;
2019: typedef MCI_SOUND_PARMSA * LPMCI_SOUND_PARMSA;
2020:
2021: // parameter block for MCI_SOUND command message (unicode version)
2022: typedef struct tagMCI_SOUND_PARMSW {
2023: DWORD dwCallback;
2024: LPCWSTR lpstrSoundName;
2025: } MCI_SOUND_PARMSW;
2026: typedef MCI_SOUND_PARMSW *PMCI_SOUND_PARMSW;
2027: typedef MCI_SOUND_PARMSW *LPMCI_SOUND_PARMSW;
2028:
2029: #ifdef UNICODE
2030: #define MCI_SOUND_PARMS MCI_SOUND_PARMSW
2031: #define PMCI_SOUND_PARMS PMCI_SOUND_PARMSW
2032: #define LPMCI_SOUND_PARMS LPMCI_SOUND_PARMSW
2033: #else
2034: #define MCI_SOUND_PARMS MCI_SOUND_PARMSA
2035: #define PMCI_SOUND_PARMS PMCI_SOUND_PARMSWA
2036: #define LPMCI_SOUND_PARMS LPMCI_SOUND_PARMSA
2037: #endif
2038:
2039: // parameter block for MCI_SAVE command message (ascii version)
2040: typedef struct tagMCI_SAVE_PARMSA {
2041: DWORD dwCallback;
2042: LPCSTR lpfilename;
2043: } MCI_SAVE_PARMSA;
2044: typedef MCI_SAVE_PARMSA *PMCI_SAVE_PARMSA;
2045: typedef MCI_SAVE_PARMSA *LPMCI_SAVE_PARMSA;
2046:
2047: // parameter block for MCI_SAVE command message (unicode version)
2048: typedef struct tagMCI_SAVE_PARMSW {
2049: DWORD dwCallback;
2050: LPCWSTR lpfilename;
2051: } MCI_SAVE_PARMSW;
2052: typedef MCI_SAVE_PARMSW *PMCI_SAVE_PARMSW;
2053: typedef MCI_SAVE_PARMSW *LPMCI_SAVE_PARMSW;
2054:
2055: #ifdef UNICODE
2056: #define MCI_SAVE_PARMS MCI_SAVE_PARMSW
2057: #define PMCI_SAVE_PARMS PMCI_SAVE_PARMSW
2058: #define LPMCI_SAVE_PARMS LPMCI_SAVE_PARMSW
2059: #else
2060: #define MCI_SAVE_PARMS MCI_SAVE_PARMSA
2061: #define PMCI_SAVE_PARMS PMCI_SAVE_PARMSWA
2062: #define LPMCI_SAVE_PARMS LPMCI_SAVE_PARMSA
2063: #endif
2064:
2065: // parameter block for MCI_LOAD command message (ascii version)
2066: typedef struct tagMCI_LOAD_PARMSA {
2067: DWORD dwCallback;
2068: LPCSTR lpfilename;
2069: } MCI_LOAD_PARMSA;
2070: typedef MCI_LOAD_PARMSA *PMCI_LOAD_PARMSA;
2071: typedef MCI_LOAD_PARMSA *LPMCI_LOAD_PARMSA;
2072:
2073: // parameter block for MCI_LOAD command message (unicode version)
2074: typedef struct tagMCI_LOAD_PARMSW {
2075: DWORD dwCallback;
2076: LPCWSTR lpfilename;
2077: } MCI_LOAD_PARMSW;
2078: typedef MCI_LOAD_PARMSW *PMCI_LOAD_PARMSW;
2079: typedef MCI_LOAD_PARMSW *LPMCI_LOAD_PARMSW;
2080:
2081: #ifdef UNICODE
2082: #define MCI_LOAD_PARMS MCI_LOAD_PARMSW
2083: #define PMCI_LOAD_PARMS PMCI_LOAD_PARMSW
2084: #define LPMCI_LOAD_PARMS LPMCI_LOAD_PARMSW
2085: #else
2086: #define MCI_LOAD_PARMS MCI_LOAD_PARMSA
2087: #define PMCI_LOAD_PARMS PMCI_LOAD_PARMSA
2088: #define LPMCI_LOAD_PARMS LPMCI_LOAD_PARMSA
2089: #endif
2090:
2091: // parameter block for MCI_RECORD command message
2092: typedef struct tagMCI_RECORD_PARMS {
2093: DWORD dwCallback;
2094: DWORD dwFrom;
2095: DWORD dwTo;
2096: } MCI_RECORD_PARMS;
2097: typedef MCI_RECORD_PARMS *PMCI_RECORD_PARMS;
2098: typedef MCI_RECORD_PARMS *LPMCI_RECORD_PARMS;
2099:
2100: /*****************************************************************************
2101: * Standard command parameters for videodisc drivers *
2102: *****************************************************************************/
2103:
2104: // string resource ID's for videodisc players
2105: // return ID's for videodisc status command
2106: // flag for dwReturn field of MCI_STATUS_PARMS
2107: // MCI_STATUS command, (dwItem == MCI_STATUS_MODE)
2108: #define MCI_VD_MODE_PARK (MCI_VD_OFFSET + 1)
2109:
2110: // return ID's for videodisc MCI_GETDEVCAPS command
2111:
2112: // flag for dwReturn field of MCI_STATUS_PARMS
2113: // MCI_STATUS command, (dwItem == MCI_VD_STATUS_MEDIA_TYPE)
2114: #define MCI_VD_MEDIA_CLV (MCI_VD_OFFSET + 2)
2115: #define MCI_VD_MEDIA_CAV (MCI_VD_OFFSET + 3)
2116: #define MCI_VD_MEDIA_OTHER (MCI_VD_OFFSET + 4)
2117:
2118: #define MCI_VD_FORMAT_TRACK 0x4001
2119:
2120: // flags for dwFlags parameter of MCI_PLAY command message
2121: #define MCI_VD_PLAY_REVERSE 0x00010000L
2122: #define MCI_VD_PLAY_FAST 0x00020000L
2123: #define MCI_VD_PLAY_SPEED 0x00040000L
2124: #define MCI_VD_PLAY_SCAN 0x00080000L
2125: #define MCI_VD_PLAY_SLOW 0x00100000L
2126:
2127: // flag for dwFlags parameter of MCI_SEEK command message
2128: #define MCI_VD_SEEK_REVERSE 0x00010000L
2129:
2130: // flags for dwItem field of MCI_STATUS_PARMS parameter block
2131: #define MCI_VD_STATUS_SPEED 0x00004002L
2132: #define MCI_VD_STATUS_FORWARD 0x00004003L
2133: #define MCI_VD_STATUS_MEDIA_TYPE 0x00004004L
2134: #define MCI_VD_STATUS_SIDE 0x00004005L
2135: #define MCI_VD_STATUS_DISC_SIZE 0x00004006L
2136:
2137: // flags for dwFlags parameter of MCI_GETDEVCAPS command message
2138: #define MCI_VD_GETDEVCAPS_CLV 0x00010000L
2139: #define MCI_VD_GETDEVCAPS_CAV 0x00020000L
2140:
2141: #define MCI_VD_SPIN_UP 0x00010000L
2142: #define MCI_VD_SPIN_DOWN 0x00020000L
2143:
2144: // flags for dwItem field of MCI_GETDEVCAPS_PARMS parameter block
2145: #define MCI_VD_GETDEVCAPS_CAN_REVERSE 0x00004002L
2146: #define MCI_VD_GETDEVCAPS_FAST_RATE 0x00004003L
2147: #define MCI_VD_GETDEVCAPS_SLOW_RATE 0x00004004L
2148: #define MCI_VD_GETDEVCAPS_NORMAL_RATE 0x00004005L
2149:
2150: // flags for the dwFlags parameter of MCI_STEP command message
2151: #define MCI_VD_STEP_FRAMES 0x00010000L
2152: #define MCI_VD_STEP_REVERSE 0x00020000L
2153:
2154: // flag for the MCI_ESCAPE command message
2155: #define MCI_VD_ESCAPE_STRING 0x00000100L
2156:
2157: // parameter block for MCI_PLAY command message
2158: typedef struct tagMCI_VD_PLAY_PARMS {
2159: DWORD dwCallback;
2160: DWORD dwFrom;
2161: DWORD dwTo;
2162: DWORD dwSpeed;
2163: } MCI_VD_PLAY_PARMS;
2164: typedef MCI_VD_PLAY_PARMS *PMCI_VD_PLAY_PARMS;
2165: typedef MCI_VD_PLAY_PARMS *LPMCI_VD_PLAY_PARMS;
2166:
2167: // parameter block for MCI_STEP command message
2168: typedef struct tagMCI_VD_STEP_PARMS {
2169: DWORD dwCallback;
2170: DWORD dwFrames;
2171: } MCI_VD_STEP_PARMS;
2172: typedef MCI_VD_STEP_PARMS *PMCI_VD_STEP_PARMS;
2173: typedef MCI_VD_STEP_PARMS *LPMCI_VD_STEP_PARMS;
2174:
2175: // parameter block for MCI_ESCAPE command message (ascii version)
2176: typedef struct tagMCI_VD_ESCAPE_PARMSA {
2177: DWORD dwCallback;
2178: LPCSTR lpstrCommand;
2179: } MCI_VD_ESCAPE_PARMSA;
2180: typedef MCI_VD_ESCAPE_PARMSA *PMCI_VD_ESCAPE_PARMSA;
2181: typedef MCI_VD_ESCAPE_PARMSA *LPMCI_VD_ESCAPE_PARMSA;
2182:
2183: // parameter block for MCI_ESCAPE command message (unicode version)
2184: typedef struct tagMCI_VD_ESCAPE_PARMSW {
2185: DWORD dwCallback;
2186: LPCWSTR lpstrCommand;
2187: } MCI_VD_ESCAPE_PARMSW;
2188: typedef MCI_VD_ESCAPE_PARMSW *PMCI_VD_ESCAPE_PARMSW;
2189: typedef MCI_VD_ESCAPE_PARMSW *LPMCI_VD_ESCAPE_PARMSW;
2190:
2191: #ifdef UNICODE
2192: #define MCI_VD_ESCAPE_PARMS MCI_VD_ESCAPE_PARMSW
2193: #define PMCI_VD_ESCAPE_PARMS PMCI_VD_ESCAPE_PARMSW
2194: #define LPMCI_VD_ESCAPE_PARMS LPMCI_VD_ESCAPE_PARMSW
2195: #else
2196: #define MCI_VD_ESCAPE_PARMS MCI_VD_ESCAPE_PARMSA
2197: #define PMCI_VD_ESCAPE_PARMS PMCI_VD_ESCAPE_PARMSWA
2198: #define LPMCI_VD_ESCAPE_PARMS LPMCI_VD_ESCAPE_PARMSA
2199: #endif
2200:
2201: /*****************************************************************************
2202: * Standard command parameters for waveform audio drivers
2203: *****************************************************************************/
2204:
2205: #define MCI_WAVE_PCM (MCI_WAVE_OFFSET+0)
2206: #define MCI_WAVE_MAPPER (MCI_WAVE_OFFSET+1)
2207:
2208: // flags for the dwFlags parameter of MCI_OPEN command message
2209: #define MCI_WAVE_OPEN_BUFFER 0x00010000L
2210:
2211: // flags for the dwFlags parameter of MCI_SET command message
2212: #define MCI_WAVE_SET_FORMATTAG 0x00010000L
2213: #define MCI_WAVE_SET_CHANNELS 0x00020000L
2214: #define MCI_WAVE_SET_SAMPLESPERSEC 0x00040000L
2215: #define MCI_WAVE_SET_AVGBYTESPERSEC 0x00080000L
2216: #define MCI_WAVE_SET_BLOCKALIGN 0x00100000L
2217: #define MCI_WAVE_SET_BITSPERSAMPLE 0x00200000L
2218:
2219: // flags for the dwFlags parameter of MCI_STATUS, MCI_SET command messages
2220: #define MCI_WAVE_INPUT 0x00400000L
2221: #define MCI_WAVE_OUTPUT 0x00800000L
2222:
2223: // flags for the dwItem field of MCI_STATUS_PARMS parameter block
2224: #define MCI_WAVE_STATUS_FORMATTAG 0x00004001L
2225: #define MCI_WAVE_STATUS_CHANNELS 0x00004002L
2226: #define MCI_WAVE_STATUS_SAMPLESPERSEC 0x00004003L
2227: #define MCI_WAVE_STATUS_AVGBYTESPERSEC 0x00004004L
2228: #define MCI_WAVE_STATUS_BLOCKALIGN 0x00004005L
2229: #define MCI_WAVE_STATUS_BITSPERSAMPLE 0x00004006L
2230: #define MCI_WAVE_STATUS_LEVEL 0x00004007L
2231:
2232: // flags for the dwFlags parameter of MCI_SET command message
2233: #define MCI_WAVE_SET_ANYINPUT 0x04000000L
2234: #define MCI_WAVE_SET_ANYOUTPUT 0x08000000L
2235:
2236: // flags for the dwFlags parameter of MCI_GETDEVCAPS command message
2237: #define MCI_WAVE_GETDEVCAPS_INPUTS 0x00004001L
2238: #define MCI_WAVE_GETDEVCAPS_OUTPUTS 0x00004002L
2239:
2240: // parameter block for MCI_OPEN command message (ascii version)
2241: typedef struct tagMCI_WAVE_OPEN_PARMSA {
2242: DWORD dwCallback;
2243: MCIDEVICEID wDeviceID;
2244: // MCIDEVICEID wReserved0; // While MCIDEVICEID is a WORD - remove when a UINT
2245: LPCSTR lpstrDeviceType;
2246: LPCSTR lpstrElementName;
2247: LPCSTR lpstrAlias;
2248: DWORD dwBufferSeconds;
2249: } MCI_WAVE_OPEN_PARMSA;
2250: typedef MCI_WAVE_OPEN_PARMSA *PMCI_WAVE_OPEN_PARMSA;
2251: typedef MCI_WAVE_OPEN_PARMSA *LPMCI_WAVE_OPEN_PARMSA;
2252:
2253: // parameter block for MCI_OPEN command message (unicode version)
2254: typedef struct tagMCI_WAVE_OPEN_PARMSW {
2255: DWORD dwCallback;
2256: MCIDEVICEID wDeviceID;
2257: // MCIDEVICEID wReserved0; // While MCIDEVICEID is a WORD - remove when a UINT
2258: LPCWSTR lpstrDeviceType;
2259: LPCWSTR lpstrElementName;
2260: LPCWSTR lpstrAlias;
2261: DWORD dwBufferSeconds;
2262: } MCI_WAVE_OPEN_PARMSW;
2263: typedef MCI_WAVE_OPEN_PARMSW *PMCI_WAVE_OPEN_PARMSW;
2264: typedef MCI_WAVE_OPEN_PARMSW *LPMCI_WAVE_OPEN_PARMSW;
2265:
2266: #ifdef UNICODE
2267: #define MCI_WAVE_OPEN_PARMS MCI_WAVE_OPEN_PARMSW
2268: #define PMCI_WAVE_OPEN_PARMS PMCI_WAVE_OPEN_PARMSW
2269: #define LPMCI_WAVE_OPEN_PARMS LPMCI_WAVE_OPEN_PARMSW
2270: #else
2271: #define MCI_WAVE_OPEN_PARMS MCI_WAVE_OPEN_PARMSA
2272: #define PMCI_WAVE_OPEN_PARMS PMCI_WAVE_OPEN_PARMSWA
2273: #define LPMCI_WAVE_OPEN_PARMS LPMCI_WAVE_OPEN_PARMSA
2274: #endif
2275:
2276: // parameter block for MCI_DELETE command message
2277: typedef struct tagMCI_WAVE_DELETE_PARMS {
2278: DWORD dwCallback;
2279: DWORD dwFrom;
2280: DWORD dwTo;
2281: } MCI_WAVE_DELETE_PARMS;
2282: typedef MCI_WAVE_DELETE_PARMS *PMCI_WAVE_DELETE_PARMS;
2283: typedef MCI_WAVE_DELETE_PARMS *LPMCI_WAVE_DELETE_PARMS;
2284:
2285: // parameter block for MCI_SET command message
2286: typedef struct tagMCI_WAVE_SET_PARMS {
2287: DWORD dwCallback;
2288: DWORD dwTimeFormat;
2289: DWORD dwAudio;
2290: UINT wInput;
2291: UINT wOutput;
2292: WORD wFormatTag; // corresponds to WAVEFORMAT structure
2293: WORD wReserved2;
2294: WORD nChannels; // corresponds to WAVEFORMAT structure
2295: WORD wReserved3;
2296: DWORD nSamplesPerSec;
2297: DWORD nAvgBytesPerSec;
2298: WORD nBlockAlign; // corresponds to WAVEFORMAT structure
2299: WORD wReserved4;
2300: WORD wBitsPerSample; // corresponds to PCMWAVEFORMAT structure
2301: WORD wReserved5;
2302: } MCI_WAVE_SET_PARMS;
2303: typedef MCI_WAVE_SET_PARMS * PMCI_WAVE_SET_PARMS;
2304: typedef MCI_WAVE_SET_PARMS * LPMCI_WAVE_SET_PARMS;
2305:
2306: /*****************************************************************************
2307: * Standard command parameters for CD audio drivers
2308: *****************************************************************************/
2309:
2310: // None
2311:
2312: /*****************************************************************************
2313: * Standard command parameters for Sequencer drivers
2314: *****************************************************************************/
2315:
2316: // string resource ID's for sequencers
2317: // return ids for status division type
2318:
2319: // flags for the dwReturn field of MCI_STATUS_PARMS parameter block
2320: // MCI_STATUS command, (dwItem == MCI_SEQ_STATUS_DIVTYPE)
2321: #define MCI_SEQ_DIV_PPQN (0 + MCI_SEQ_OFFSET)
2322: #define MCI_SEQ_DIV_SMPTE_24 (1 + MCI_SEQ_OFFSET)
2323: #define MCI_SEQ_DIV_SMPTE_25 (2 + MCI_SEQ_OFFSET)
2324: #define MCI_SEQ_DIV_SMPTE_30DROP (3 + MCI_SEQ_OFFSET)
2325: #define MCI_SEQ_DIV_SMPTE_30 (4 + MCI_SEQ_OFFSET)
2326:
2327: // flags for the dwMaster field of MCI_SEQ_SET_PARMS parameter block
2328: // MCI_SET command, (dwFlags == MCI_SEQ_SET_MASTER)
2329: #define MCI_SEQ_FORMAT_SONGPTR 0x4001
2330: #define MCI_SEQ_FILE 0x4002
2331: #define MCI_SEQ_MIDI 0x4003
2332: #define MCI_SEQ_SMPTE 0x4004
2333: #define MCI_SEQ_NONE 65533
2334:
2335: #define MCI_SEQ_MAPPER 65535
2336:
2337: // flags for the dwItem field of MCI_STATUS_PARMS parameter block
2338: #define MCI_SEQ_STATUS_TEMPO 0x00004002L
2339: #define MCI_SEQ_STATUS_PORT 0x00004003L
2340: #define MCI_SEQ_STATUS_SLAVE 0x00004007L
2341: #define MCI_SEQ_STATUS_MASTER 0x00004008L
2342: #define MCI_SEQ_STATUS_OFFSET 0x00004009L
2343: #define MCI_SEQ_STATUS_DIVTYPE 0x0000400AL
2344:
2345: // flags for the dwFlags parameter of MCI_SET command message
2346: #define MCI_SEQ_SET_TEMPO 0x00010000L
2347: #define MCI_SEQ_SET_PORT 0x00020000L
2348: #define MCI_SEQ_SET_SLAVE 0x00040000L
2349: #define MCI_SEQ_SET_MASTER 0x00080000L
2350: #define MCI_SEQ_SET_OFFSET 0x01000000L
2351:
2352: // parameter block for MCI_SET command message
2353: typedef struct tagMCI_SEQ_SET_PARMS {
2354: DWORD dwCallback;
2355: DWORD dwTimeFormat;
2356: DWORD dwAudio;
2357: DWORD dwTempo;
2358: DWORD dwPort;
2359: DWORD dwSlave;
2360: DWORD dwMaster;
2361: DWORD dwOffset;
2362: } MCI_SEQ_SET_PARMS;
2363: typedef MCI_SEQ_SET_PARMS * PMCI_SEQ_SET_PARMS;
2364: typedef MCI_SEQ_SET_PARMS * LPMCI_SEQ_SET_PARMS;
2365:
2366: /*****************************************************************************
2367: * Standard command parameters for animation
2368: *****************************************************************************/
2369:
2370:
2371: // flags for dwFlags parameter of MCI_OPEN command message
2372: #define MCI_ANIM_OPEN_WS 0x00010000L
2373: #define MCI_ANIM_OPEN_PARENT 0x00020000L
2374: #define MCI_ANIM_OPEN_NOSTATIC 0x00040000L
2375:
2376: // flags for dwFlags parameter of MCI_PLAY command message
2377: #define MCI_ANIM_PLAY_SPEED 0x00010000L
2378: #define MCI_ANIM_PLAY_REVERSE 0x00020000L
2379: #define MCI_ANIM_PLAY_FAST 0x00040000L
2380: #define MCI_ANIM_PLAY_SLOW 0x00080000L
2381: #define MCI_ANIM_PLAY_SCAN 0x00100000L
2382:
2383: // flags for dwFlags parameter of MCI_STEP command message
2384: #define MCI_ANIM_STEP_REVERSE 0x00010000L
2385: #define MCI_ANIM_STEP_FRAMES 0x00020000L
2386:
2387: // flags for dwItem field of MCI_STATUS_PARMS parameter block
2388: #define MCI_ANIM_STATUS_SPEED 0x00004001L
2389: #define MCI_ANIM_STATUS_FORWARD 0x00004002L
2390: #define MCI_ANIM_STATUS_HWND 0x00004003L
2391: #define MCI_ANIM_STATUS_HPAL 0x00004004L
2392: #define MCI_ANIM_STATUS_STRETCH 0x00004005L
2393:
2394: // flags for the dwFlags parameter of MCI_INFO command message
2395: #define MCI_ANIM_INFO_TEXT 0x00010000L
2396:
2397: // flags for dwItem field of MCI_GETDEVCAPS_PARMS parameter block
2398: #define MCI_ANIM_GETDEVCAPS_CAN_REVERSE 0x00004001L
2399: #define MCI_ANIM_GETDEVCAPS_FAST_RATE 0x00004002L
2400: #define MCI_ANIM_GETDEVCAPS_SLOW_RATE 0x00004003L
2401: #define MCI_ANIM_GETDEVCAPS_NORMAL_RATE 0x00004004L
2402: #define MCI_ANIM_GETDEVCAPS_PALETTES 0x00004006L
2403: #define MCI_ANIM_GETDEVCAPS_CAN_STRETCH 0x00004007L
2404: #define MCI_ANIM_GETDEVCAPS_MAX_WINDOWS 0x00004008L
2405:
2406: // flags for the MCI_REALIZE command message
2407: #define MCI_ANIM_REALIZE_NORM 0x00010000L
2408: #define MCI_ANIM_REALIZE_BKGD 0x00020000L
2409:
2410: // flags for dwFlags parameter of MCI_WINDOW command message
2411: #define MCI_ANIM_WINDOW_HWND 0x00010000L
2412: #define MCI_ANIM_WINDOW_STATE 0x00040000L
2413: #define MCI_ANIM_WINDOW_TEXT 0x00080000L
2414: #define MCI_ANIM_WINDOW_ENABLE_STRETCH 0x00100000L
2415: #define MCI_ANIM_WINDOW_DISABLE_STRETCH 0x00200000L
2416:
2417: // flags for hWnd field of MCI_ANIM_WINDOW_PARMS parameter block
2418: // MCI_WINDOW command message, (dwFlags == MCI_ANIM_WINDOW_HWND)
2419: #define MCI_ANIM_WINDOW_DEFAULT 0x00000000L
2420:
2421: // flags for dwFlags parameter of MCI_PUT command message
2422: #define MCI_ANIM_RECT 0x00010000L
2423: #define MCI_ANIM_PUT_SOURCE 0x00020000L // also MCI_WHERE
2424: #define MCI_ANIM_PUT_DESTINATION 0x00040000L // also MCI_WHERE
2425:
2426: // flags for dwFlags parameter of MCI_WHERE command message
2427: #define MCI_ANIM_WHERE_SOURCE 0x00020000L
2428: #define MCI_ANIM_WHERE_DESTINATION 0x00040000L
2429:
2430: // flags for dwFlags parameter of MCI_UPDATE command message
2431: #define MCI_ANIM_UPDATE_HDC 0x00020000L
2432:
2433: // parameter block for MCI_OPEN command message (ascii version)
2434: typedef struct tagMCI_ANIM_OPEN_PARMSA {
2435: DWORD dwCallback;
2436: MCIDEVICEID wDeviceID;
2437: // MCIDEVICEID wReserved0; // While MCIDEVICEID is a WORD
2438: LPCSTR lpstrDeviceType;
2439: LPCSTR lpstrElementName;
2440: LPCSTR lpstrAlias;
2441: DWORD dwStyle;
2442: HWND hWndParent;
2443: } MCI_ANIM_OPEN_PARMSA;
2444: typedef MCI_ANIM_OPEN_PARMSA *PMCI_ANIM_OPEN_PARMSA;
2445: typedef MCI_ANIM_OPEN_PARMSA *LPMCI_ANIM_OPEN_PARMSA;
2446:
2447: // parameter block for MCI_OPEN command message (unicode version)
2448: typedef struct tagMCI_ANIM_OPEN_PARMSW {
2449: DWORD dwCallback;
2450: MCIDEVICEID wDeviceID;
2451: // MCIDEVICEID wReserved0; // While MCIDEVICEID is a WORD
2452: LPCWSTR lpstrDeviceType;
2453: LPCWSTR lpstrElementName;
2454: LPCWSTR lpstrAlias;
2455: DWORD dwStyle;
2456: HWND hWndParent;
2457: } MCI_ANIM_OPEN_PARMSW;
2458: typedef MCI_ANIM_OPEN_PARMSW *PMCI_ANIM_OPEN_PARMSW;
2459: typedef MCI_ANIM_OPEN_PARMSW *LPMCI_ANIM_OPEN_PARMSW;
2460:
2461: #ifdef UNICODE
2462: #define MCI_ANIM_OPEN_PARMS MCI_ANIM_OPEN_PARMSW
2463: #define PMCI_ANIM_OPEN_PARMS PMCI_ANIM_OPEN_PARMSW
2464: #define LPMCI_ANIM_OPEN_PARMS LPMCI_ANIM_OPEN_PARMSW
2465: #else
2466: #define MCI_ANIM_OPEN_PARMS MCI_ANIM_OPEN_PARMSA
2467: #define PMCI_ANIM_OPEN_PARMS PMCI_ANIM_OPEN_PARMSWA
2468: #define LPMCI_ANIM_OPEN_PARMS LPMCI_ANIM_OPEN_PARMSA
2469: #endif
2470:
2471: // parameter block for MCI_PLAY command message
2472: typedef struct tagMCI_ANIM_PLAY_PARMS {
2473: DWORD dwCallback;
2474: DWORD dwFrom;
2475: DWORD dwTo;
2476: DWORD dwSpeed;
2477: } MCI_ANIM_PLAY_PARMS;
2478: typedef MCI_ANIM_PLAY_PARMS *PMCI_ANIM_PLAY_PARMS;
2479: typedef MCI_ANIM_PLAY_PARMS *LPMCI_ANIM_PLAY_PARMS;
2480:
2481: // parameter block for MCI_STEP command message
2482: typedef struct tagMCI_ANIM_STEP_PARMS {
2483: DWORD dwCallback;
2484: DWORD dwFrames;
2485: } MCI_ANIM_STEP_PARMS;
2486: typedef MCI_ANIM_STEP_PARMS *PMCI_ANIM_STEP_PARMS;
2487: typedef MCI_ANIM_STEP_PARMS *LPMCI_ANIM_STEP_PARMS;
2488:
2489: // paramter block for MCI_ANIM_SET new ???
2490: typedef struct tagMCI_ANIM_SET_PARMS {
2491: DWORD dwCallback;
2492: DWORD dwTimeFormat;
2493: DWORD dwAudio;
2494: } MCI_ANIM_SET_PARMS;
2495: typedef MCI_ANIM_SET_PARMS * PMCI_ANIM_SET_PARMS;
2496: typedef MCI_ANIM_SET_PARMS * LPMCI_ANIM_SET_PARMS;
2497:
2498: // parameter block for MCI_WINDOW command message (ascii version)
2499: typedef struct tagMCI_ANIM_WINDOW_PARMSA {
2500: DWORD dwCallback;
2501: WORD hWnd;
2502: UINT nCmdShow;
2503: LPCSTR lpstrText;
2504: } MCI_ANIM_WINDOW_PARMSA;
2505: typedef MCI_ANIM_WINDOW_PARMSA * PMCI_ANIM_WINDOW_PARMSA;
2506: typedef MCI_ANIM_WINDOW_PARMSA * LPMCI_ANIM_WINDOW_PARMSA;
2507:
2508: // parameter block for MCI_WINDOW command message (unicode version)
2509: typedef struct tagMCI_ANIM_WINDOW_PARMSW {
2510: DWORD dwCallback;
2511: WORD hWnd;
2512: UINT nCmdShow;
2513: LPCWSTR lpstrText;
2514: } MCI_ANIM_WINDOW_PARMSW;
2515: typedef MCI_ANIM_WINDOW_PARMSW * PMCI_ANIM_WINDOW_PARMSW;
2516: typedef MCI_ANIM_WINDOW_PARMSW * LPMCI_ANIM_WINDOW_PARMSW;
2517:
2518: #ifdef UNICODE
2519: #define MCI_ANIM_WINDOW_PARMS MCI_ANIM_WINDOW_PARMSW
2520: #define PMCI_ANIM_WINDOW_PARMS PMCI_ANIM_WINDOW_PARMSW
2521: #define LPMCI_ANIM_WINDOW_PARMS LPMCI_ANIM_WINDOW_PARMSW
2522: #else
2523: #define MCI_ANIM_WINDOW_PARMS MCI_ANIM_WINDOW_PARMSA
2524: #define PMCI_ANIM_WINDOW_PARMS PMCI_ANIM_WINDOW_PARMSWA
2525: #define LPMCI_ANIM_WINDOW_PARMS LPMCI_ANIM_WINDOW_PARMSA
2526: #endif
2527:
2528: // parameter block for MCI_PUT, MCI_UPDATE, MCI_WHERE command messages
2529: typedef struct tagMCI_ANIM_RECT_PARMS {
2530: DWORD dwCallback;
2531: #ifdef MCI_USE_OFFEXT
2532: POINT ptOffset;
2533: POINT ptExtent;
2534: #else //ifdef MCI_USE_OFFEXT
2535: RECT rc;
2536: #endif //ifdef MCI_USE_OFFEXT
2537: } MCI_ANIM_RECT_PARMS;
2538: typedef MCI_ANIM_RECT_PARMS * PMCI_ANIM_RECT_PARMS;
2539: typedef MCI_ANIM_RECT_PARMS * LPMCI_ANIM_RECT_PARMS;
2540:
2541: // parameter block for MCI_UPDATE PARMS
2542: typedef struct tagMCI_ANIM_UPDATE_PARMS {
2543: DWORD dwCallback;
2544: RECT rc;
2545: HDC hDC;
2546: } MCI_ANIM_UPDATE_PARMS;
2547: typedef MCI_ANIM_UPDATE_PARMS * PMCI_ANIM_UPDATE_PARMS;
2548: typedef MCI_ANIM_UPDATE_PARMS * LPMCI_ANIM_UPDATE_PARMS;
2549:
2550:
2551: /*****************************************************************************
2552:
2553: Standard command parameters for overlay
2554:
2555: *****************************************************************************/
2556:
2557:
2558: // flags for dwFlags parameter of MCI_OPEN command message
2559: #define MCI_OVLY_OPEN_WS 0x00010000L
2560: #define MCI_OVLY_OPEN_PARENT 0x00020000L
2561:
2562: // flags for dwFlags parameter of MCI_STATUS command message
2563: #define MCI_OVLY_STATUS_HWND 0x00004001L
2564: #define MCI_OVLY_STATUS_STRETCH 0x00004002L
2565:
2566: // flags for dwFlags parameter of MCI_INFO command message
2567: #define MCI_OVLY_INFO_TEXT 0x00010000L
2568:
2569: // flags for dwItem field of MCI_GETDEVCAPS_PARMS parameter block
2570: #define MCI_OVLY_GETDEVCAPS_CAN_STRETCH 0x00004001L
2571: #define MCI_OVLY_GETDEVCAPS_CAN_FREEZE 0x00004002L
2572: #define MCI_OVLY_GETDEVCAPS_MAX_WINDOWS 0x00004003L
2573:
2574: // flags for dwFlags parameter of MCI_WINDOW command message
2575: #define MCI_OVLY_WINDOW_HWND 0x00010000L
2576: #define MCI_OVLY_WINDOW_STATE 0x00040000L
2577: #define MCI_OVLY_WINDOW_TEXT 0x00080000L
2578: #define MCI_OVLY_WINDOW_ENABLE_STRETCH 0x00100000L
2579: #define MCI_OVLY_WINDOW_DISABLE_STRETCH 0x00200000L
2580:
2581: // flags for hWnd parameter of MCI_OVLY_WINDOW_PARMS parameter block
2582: #define MCI_OVLY_WINDOW_DEFAULT 0x00000000L
2583:
2584: // flags for dwFlags parameter of MCI_PUT command message
2585: #define MCI_OVLY_RECT 0x00010000L
2586: #define MCI_OVLY_PUT_SOURCE 0x00020000L
2587: #define MCI_OVLY_PUT_DESTINATION 0x00040000L
2588: #define MCI_OVLY_PUT_FRAME 0x00080000L
2589: #define MCI_OVLY_PUT_VIDEO 0x00100000L
2590:
2591: // flags for dwFlags parameter of MCI_WHERE command message
2592: #define MCI_OVLY_WHERE_SOURCE 0x00020000L
2593: #define MCI_OVLY_WHERE_DESTINATION 0x00040000L
2594: #define MCI_OVLY_WHERE_FRAME 0x00080000L
2595: #define MCI_OVLY_WHERE_VIDEO 0x00100000L
2596:
2597: #define MCI_OVLY_UPDATE_HDC 0x00020000L // MCI_UPDATE
2598:
2599: // parameter block for MCI_OPEN command message (ascii version)
2600: typedef struct tagMCI_OVLY_OPEN_PARMSA {
2601: DWORD dwCallback;
2602: MCIDEVICEID wDeviceID;
2603: // MCIDEVICEID wReserved0; // While MCIDEVICEID is a WORD
2604: LPCSTR lpstrDeviceType;
2605: LPCSTR lpstrElementName;
2606: LPCSTR lpstrAlias;
2607: DWORD dwStyle;
2608: HWND hWndParent;
2609: } MCI_OVLY_OPEN_PARMSA;
2610: typedef MCI_OVLY_OPEN_PARMSA *PMCI_OVLY_OPEN_PARMSA;
2611: typedef MCI_OVLY_OPEN_PARMSA *LPMCI_OVLY_OPEN_PARMSA;
2612:
2613: // parameter block for MCI_OPEN command message (unicode version)
2614: typedef struct tagMCI_OVLY_OPEN_PARMSW {
2615: DWORD dwCallback;
2616: MCIDEVICEID wDeviceID;
2617: // MCIDEVICEID wReserved0; // While MCIDEVICEID is a WORD
2618: LPCWSTR lpstrDeviceType;
2619: LPCWSTR lpstrElementName;
2620: LPCWSTR lpstrAlias;
2621: DWORD dwStyle;
2622: HWND hWndParent;
2623: } MCI_OVLY_OPEN_PARMSW;
2624: typedef MCI_OVLY_OPEN_PARMSW *PMCI_OVLY_OPEN_PARMSW;
2625: typedef MCI_OVLY_OPEN_PARMSW *LPMCI_OVLY_OPEN_PARMSW;
2626:
2627: #ifdef UNICODE
2628: #define MCI_OVLY_OPEN_PARMS MCI_OVLY_OPEN_PARMSW
2629: #define PMCI_OVLY_OPEN_PARMS PMCI_OVLY_OPEN_PARMSW
2630: #define LPMCI_OVLY_OPEN_PARMS LPMCI_OVLY_OPEN_PARMSW
2631: #else
2632: #define MCI_OVLY_OPEN_PARMS MCI_OVLY_OPEN_PARMSA
2633: #define PMCI_OVLY_OPEN_PARMS PMCI_OVLY_OPEN_PARMSWA
2634: #define LPMCI_OVLY_OPEN_PARMS LPMCI_OVLY_OPEN_PARMSA
2635: #endif
2636:
2637: // parameter block for MCI_WINDOW command message (ascii version)
2638: typedef struct tagMCI_OVLY_WINDOW_PARMSA {
2639: DWORD dwCallback;
2640: HWND hWnd;
2641: UINT nCmdShow;
2642: LPCSTR lpstrText;
2643: } MCI_OVLY_WINDOW_PARMSA;
2644: typedef MCI_OVLY_WINDOW_PARMSA * PMCI_OVLY_WINDOW_PARMSA;
2645: typedef MCI_OVLY_WINDOW_PARMSA * LPMCI_OVLY_WINDOW_PARMSA;
2646:
2647: // parameter block for MCI_WINDOW command message (unicode version)
2648: typedef struct tagMCI_OVLY_WINDOW_PARMSW {
2649: DWORD dwCallback;
2650: HWND hWnd;
2651: UINT nCmdShow;
2652: LPCWSTR lpstrText;
2653: } MCI_OVLY_WINDOW_PARMSW;
2654: typedef MCI_OVLY_WINDOW_PARMSW * PMCI_OVLY_WINDOW_PARMSW;
2655: typedef MCI_OVLY_WINDOW_PARMSW * LPMCI_OVLY_WINDOW_PARMSW;
2656:
2657: #ifdef UNICODE
2658: #define MCI_OVLY_WINDOW_PARMS MCI_OVLY_WINDOW_PARMSW
2659: #define PMCI_OVLY_WINDOW_PARMS PMCI_OVLY_WINDOW_PARMSW
2660: #define LPMCI_OVLY_WINDOW_PARMS LPMCI_OVLY_WINDOW_PARMSW
2661: #else
2662: #define MCI_OVLY_WINDOW_PARMS MCI_OVLY_WINDOW_PARMSA
2663: #define PMCI_OVLY_WINDOW_PARMS PMCI_OVLY_WINDOW_PARMSWA
2664: #define LPMCI_OVLY_WINDOW_PARMS LPMCI_OVLY_WINDOW_PARMSA
2665: #endif
2666:
2667: // parameter block for MCI_PUT, MCI_UPDATE, and MCI_WHERE command messages
2668: typedef struct tagMCI_OVLY_RECT_PARMS {
2669: DWORD dwCallback;
2670: #ifdef MCI_USE_OFFEXT
2671: POINT ptOffset;
2672: POINT ptExtent;
2673: #else //ifdef MCI_USE_OFFEXT
2674: RECT rc;
2675: #endif //ifdef MCI_USE_OFFEXT
2676: } MCI_OVLY_RECT_PARMS;
2677: typedef MCI_OVLY_RECT_PARMS * PMCI_OVLY_RECT_PARMS;
2678: typedef MCI_OVLY_RECT_PARMS * LPMCI_OVLY_RECT_PARMS;
2679:
2680:
2681: typedef struct tagMCI_OVLY_UPDATE_PARMS { // new ???
2682: DWORD dwCallback;
2683: RECT rc;
2684: HDC hDC;
2685: } MCI_OVLY_UPDATE_PARMS;
2686: typedef MCI_OVLY_UPDATE_PARMS * PMCI_OVLY_UPDATE_PARMS;
2687: typedef MCI_OVLY_UPDATE_PARMS * LPMCI_OVLY_UPDATE_PARMS;
2688:
2689: // parameter block for MCI_SAVE command message (ascii version)
2690: typedef struct tagMCI_OVLY_SAVE_PARMSA {
2691: DWORD dwCallback;
2692: LPCSTR lpfilename;
2693: RECT rc;
2694: } MCI_OVLY_SAVE_PARMSA;
2695: typedef MCI_OVLY_SAVE_PARMSA * PMCI_OVLY_SAVE_PARMSA;
2696: typedef MCI_OVLY_SAVE_PARMSA * LPMCI_OVLY_SAVE_PARMSA;
2697:
2698: // parameter block for MCI_SAVE command message (unicode version)
2699: typedef struct tagMCI_OVLY_SAVE_PARMSW {
2700: DWORD dwCallback;
2701: LPCWSTR lpfilename;
2702: RECT rc;
2703: } MCI_OVLY_SAVE_PARMSW;
2704: typedef MCI_OVLY_SAVE_PARMSW * PMCI_OVLY_SAVE_PARMSW;
2705: typedef MCI_OVLY_SAVE_PARMSW * LPMCI_OVLY_SAVE_PARMSW;
2706:
2707: #ifdef UNICODE
2708: #define MCI_OVLY_SAVE_PARMS MCI_OVLY_SAVE_PARMSW
2709: #define PMCI_OVLY_SAVE_PARMS PMCI_OVLY_SAVE_PARMSW
2710: #define LPMCI_OVLY_SAVE_PARMS LPMCI_OVLY_SAVE_PARMSW
2711: #else
2712: #define MCI_OVLY_SAVE_PARMS MCI_OVLY_SAVE_PARMSA
2713: #define PMCI_OVLY_SAVE_PARMS PMCI_OVLY_SAVE_PARMSWA
2714: #define LPMCI_OVLY_SAVE_PARMS LPMCI_OVLY_SAVE_PARMSA
2715: #endif
2716:
2717: // parameter block for MCI_LOAD command message (ascii version)
2718: typedef struct tagMCI_OVLY_LOAD_PARMSA {
2719: DWORD dwCallback;
2720: LPCSTR lpfilename;
2721: RECT rc;
2722: } MCI_OVLY_LOAD_PARMSA;
2723: typedef MCI_OVLY_LOAD_PARMSA * PMCI_OVLY_LOAD_PARMSA;
2724: typedef MCI_OVLY_LOAD_PARMSA * LPMCI_OVLY_LOAD_PARMSA;
2725:
2726: // parameter block for MCI_LOAD command message (unicode version)
2727: typedef struct tagMCI_OVLY_LOAD_PARMSW {
2728: DWORD dwCallback;
2729: LPCWSTR lpfilename;
2730: RECT rc;
2731: } MCI_OVLY_LOAD_PARMSW;
2732: typedef MCI_OVLY_LOAD_PARMSW * PMCI_OVLY_LOAD_PARMSW;
2733: typedef MCI_OVLY_LOAD_PARMSW * LPMCI_OVLY_LOAD_PARMSW;
2734:
2735: #ifdef UNICODE
2736: #define MCI_OVLY_LOAD_PARMS MCI_OVLY_LOAD_PARMSW
2737: #define PMCI_OVLY_LOAD_PARMS PMCI_OVLY_LOAD_PARMSW
2738: #define LPMCI_OVLY_LOAD_PARMS LPMCI_OVLY_LOAD_PARMSW
2739: #else
2740: #define MCI_OVLY_LOAD_PARMS MCI_OVLY_LOAD_PARMSA
2741: #define PMCI_OVLY_LOAD_PARMS PMCI_OVLY_LOAD_PARMSWA
2742: #define LPMCI_OVLY_LOAD_PARMS LPMCI_OVLY_LOAD_PARMSA
2743: #endif
2744:
2745:
2746:
2747: #endif //ifndef MMNOMCI
2748:
2749:
2750: /****************************************************************************
2751:
2752: DISPLAY Driver extensions
2753:
2754: ****************************************************************************/
2755:
2756: #ifndef C1_TRANSPARENT
2757: #define CAPS1 94 // other caps
2758: #define C1_TRANSPARENT 0x0001 // new raster cap
2759: #define NEWTRANSPARENT 3 // use with SetBkMode()
2760:
2761: #define QUERYROPSUPPORT 40 // use to determine ROP support
2762: #endif //ifndef C1_TRANSPARENT
2763:
2764: /****************************************************************************
2765:
2766: DIB Driver extensions
2767:
2768: ****************************************************************************/
2769:
2770: #define SELECTDIB 41 // DIB.DRV select dib escape
2771: #define DIBINDEX(n) MAKELONG((n),0x10FF)
2772:
2773:
2774: /****************************************************************************
2775:
2776: ScreenSaver support
2777:
2778: The current application will receive a syscommand of SC_SCREENSAVE just
2779: before the screen saver is invoked. If the app wishes to prevent a
2780: screen save, return non-zero value, otherwise call DefWindowProc().
2781:
2782: ****************************************************************************/
2783:
2784: #ifndef SC_SCREENSAVE
2785:
2786: #define SC_SCREENSAVE 0xF140
2787:
2788: #endif //ifndef SC_SCREENSAVE
2789:
2790: #endif // _MMSYSTEM_
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.