windows-server-2003/multimedia/media/avi/inc/mediaman.h

/* MEDIAMAN.H
 * 
 * Public header for the MMSys media element manager DLL
 * 
 * include after windows.h
 * 
 */

#ifndef _MEDMAN_H_
#define _MEDMAN_H_

/***************   MEDIAMAN TYPES  ****************/

typedef	DWORD	MEDID;
typedef	WORD	MEDGID;
typedef	DWORD	FOURCC;
typedef	FOURCC	MEDTYPE;

typedef	WORD	MEDMSG;
typedef	WORD	MEDUSER;

/***************  MEDINFO INSTANCE BLOCK  ****************/
/*
 *  Resource instance structure, passed around as MEDINFO.
 *  This structure definition may change, DO NOT DEPEND ON IT, but
 *  use access macros defined below instead!!
 */
typedef struct _MedInfoStruct {
	DWORD	wFlags;		// maybe duplicate fpEnt flags
	WORD	wAccessCount;
	WORD	wLockCount;
	DWORD	dwAccessRet;
	DWORD	dwLockRet;
	char	achInst[2];
} MedInfoStruct;
typedef MedInfoStruct FAR *MEDINFO;

/*  Instance data access macros  */
#define medInfoInstance(medinfo)	((LPSTR) &((medinfo)->achInst[0]))
#define medInfoAccessCount(medinfo)	((medinfo)->wAccessCount)
#define medInfoLockCount(medinfo)	((medinfo)->wLockCount)
#define medInfoLockRead(medinfo)	((medinfo)->wFlags & 0x0800)
#define medInfoLockWrite(medinfo)	((medinfo)->wFlags & 0x0400)

#define MedInfoInstance(medinfo)	medInfoInstance(medinfo)
#define MedInfoAccessCount(medinfo)	medInfoAccessCount(medinfo)
#define MedInfoLockCount(medinfo)	medInfoLockCount(medinfo)
#define MedInfoLockRead(medinfo)	medInfoLockRead(medinfo)
#define MedInfoLockWrite(medinfo)	medInfoLockWrite(medinfo)

		

/**********  RESOURCE HANDLER DECLARATION  *************/

typedef DWORD (FAR PASCAL MedHandler)
		(MEDID medid, MEDMSG medmsg, MEDINFO medinfo,
		 LONG lParam1, LONG lParam2);
typedef MedHandler FAR *FPMedHandler;

/*  Logical resource handler messages  */
#define	MED_INIT		0x0010
#define MED_UNLOAD		0x0011
#define MED_LOCK		0x0012
#define MED_UNLOCK		0x0013
#define MED_EXPEL		0x0014
#define MED_DESTROY		0x0015
#define MED_CREATE		0x0016
#define MED_TYPEINIT		0x0020
#define MED_TYPEUNLOAD		0x0021
#define MED_SETPHYSICAL		0x0022
#define MED_COPY		0x0023
#define MED_NEWNAME		0x0024

#define MED_PAINT		0x002A
#define MED_REALIZEPALETTE	0x002B
#define MED_GETPAINTCAPS	0x002C
#define MED_GETCLIPBOARDDATA	0x002D

/*  PaintCaps flags  */
#define	MMC_PALETTEINFO		0x0001
#define MMC_BOUNDRECT		0x0002
#define MMC_CLIPFORMAT		0x0003

/*  Paint message flags  */
#define MMP_NORMPAL		0x0000
#define MMP_NOPALETTE		0x0001
#define MMP_PALBACKGROUND	0x0002
#define MMP_SHRINKTOFIT		0x0010
#define MMP_DSTANDSRCRECTS	0x0020

/* Load/Save messages */
#define MED_GETLOADPARAM	0x0030
#define MED_PRELOAD		0x0031
#define MED_LOAD		0x0032
#define MED_POSTLOAD		0x0033
#define MED_FREELOADPARAM	0x0034
#define MED_GETSAVEPARAM	0x0035
#define MED_PRESAVE		0x0036
#define MED_SAVE		0x0037
#define MED_POSTSAVE		0x0038
#define MED_FREESAVEPARAM	0x0039

/*  Sent to resource users  */
#define	MED_CHANGE		0x0060

/* Messages sent to MedDiskInfoCallback */
#define MED_DISKCBBEGIN		0x0065
#define MED_DISKCBUPDATE	0x0066
#define MED_DISKCBEND		0x0067
#define MED_DISKCBNEWCONV	0x0068

/*  Minimum value available for type-defined messages  */
#define MED_USER		0x0200



/*****************  RESOURCE LOAD/SAVE  *******************/

typedef struct _MedDisk {
	WORD	wFlags;
	DWORD	dwMessageData;
	DWORD	dwRetVal;

	DWORD	dwInstance1;
	DWORD	dwInstance2;

	DWORD	dwParam1;
	DWORD	dwParam2;

	DWORD	dwCbInstance1;
	DWORD	dwCbInstance2;

	HWND	hwndParentWindow;
	MEDID	medid;

	DWORD	dwReserved1;
	DWORD	dwReserved2;
	DWORD	dwReserved3;
	DWORD	dwReserved4;
} MedDisk;
typedef MedDisk	FAR	*FPMedDisk;
typedef MedDisk	NEAR	*NPMedDisk;

/*  Flags for wFlags field  */
#define MEDF_DISKSAVE	0x0001		// save taking place
#define MEDF_DISKLOAD	0x0002		// load taking place
#define MEDF_DISKVERIFY	0x0004		// verify the file format on load

typedef HANDLE	HMEDIABATCH;

/* Macros to check status of load/save */
#define medIsDiskVerify(FPDISK)		\
	(((FPMedDisk) (FPDISK))->wFlags & MEDF_DISKVERIFY)
#define medIsDiskLoad(FPDISK)		\
	(((FPMedDisk) (FPDISK))->wFlags & MEDF_DISKLOAD)
#define medIsDiskSave(FPDISK)		\
	(((FPMedDisk) (FPDISK))->wFlags & MEDF_DISKSAVE)

/* Values returned by physical handlers to MED_LOAD & MED_SAVE messages */
#define MEDF_OK		1
#define MEDF_ABORT	2
#define MEDF_ERROR	3
#define MEDF_BADFORMAT	4
#define MEDF_NOTPROCESSED	0L

/* Callback type used for information on disk save/load status */
typedef WORD (FAR PASCAL MedDiskInfoCallback)
		(WORD wmsg, FPMedDisk fpDisk, LONG lParam,
		 WORD wPercentDone, LPSTR lpszTextStatus);
typedef MedDiskInfoCallback FAR *FPMedDiskInfoCallback;


/*  Functions used by info callbacks  */
void	FAR PASCAL	medDiskCancel(FPMedDisk fpDisk);
WORD	FAR PASCAL	medUpdateProgress(FPMedDisk fpDisk,
				WORD wPercentDone, LPSTR lpszTextStatus);


/*************  LOGICAL I/O ROUTINES  *****************/

typedef struct _MedReturn {
	MEDID	medid;
	DWORD	dwReturn;
} MedReturn;
typedef MedReturn FAR *FPMedReturn;
 
WORD FAR PASCAL medSave(MEDID medid, LONG lParam,
			BOOL fYield, FPMedDiskInfoCallback lpfnCb,
			LONG lParamCb);
WORD FAR PASCAL medSaveAs(MEDID medid, FPMedReturn medReturn,
			LPSTR lpszName, LONG lParam, BOOL fYield,
			FPMedDiskInfoCallback lpfnCb, LONG lParamCb);
WORD FAR PASCAL medAccess(MEDID medid, LONG lParam,
			FPMedReturn medReturn, BOOL fYield,
			FPMedDiskInfoCallback lpfnCb, LONG lParamCb);
void FAR PASCAL medRelease(MEDID medid, LONG lParam);
DWORD FAR PASCAL medLock(MEDID medid, WORD wFlags, LONG lParam);
void FAR PASCAL medUnlock(MEDID medid, WORD wFlags,
			DWORD dwChangeInfo, LONG lParam);
DWORD FAR PASCAL medSendMessage(MEDID medid, MEDMSG medmsg,
			LONG lParam1, LONG lParam2);
DWORD FAR PASCAL medSendPhysMessage(MEDID medid, MEDMSG medmsg,
			LONG lParam1, LONG lParam2);
BOOL FAR PASCAL medCreate(FPMedReturn medReturn,
			MEDTYPE medtype, LONG lParam);
BOOL FAR PASCAL medIsDirty(MEDID medid);
BOOL FAR PASCAL medSetDirty(MEDID medid, BOOL fDirty);
WORD FAR PASCAL medIsAccessed(MEDID medid);
BOOL FAR PASCAL medIsShared(MEDID medid);


MEDINFO FAR PASCAL medGetMedinfo(MEDID medid);
BOOL FAR PASCAL medReleaseResinfo(MEDID medid, MEDINFO medinfo);

DWORD FAR PASCAL medSendPhysTypeMsg(MEDID medid, MEDTYPE medTypePhysical,
			MEDMSG medmsg, LONG lParam1, LONG lParam2);

typedef struct _MedAccessStruct {
	MEDID			medid;
	LONG			lParamLoad;
	BOOL			fYield;
	HWND			hwndParent;
	FPMedDiskInfoCallback	lpfnCb;
	LONG			lParamCb;
	DWORD			dwReturn;
} MedAccessStruct;
typedef MedAccessStruct FAR *FPMedAccessStruct;

WORD FAR PASCAL medAccessIndirect(FPMedAccessStruct fpAccess, WORD wSize);

typedef struct _MedSaveStruct {
	MEDID			medid;
	LONG			lParamSave;
	BOOL			fYield;
	HWND			hwndParent;
	FPMedDiskInfoCallback	lpfnCb;
	LONG			lParamCb;
	LPSTR			lpszNewName;
	
	MEDID			medidReturn;
	DWORD			dwReturn;
} MedSaveStruct;
typedef MedSaveStruct FAR *FPMedSaveStruct;

WORD FAR PASCAL medSaveIndirect(FPMedSaveStruct fpSave, WORD wSize);
WORD FAR PASCAL medSaveAsIndirect(FPMedSaveStruct fpSave, WORD wSize);

		
/*
 *  BATCH CONVERSION
 */
WORD FAR PASCAL medAccessBatch(HMEDIABATCH hmedBatch, FPMedReturn medReturn,
			   BOOL fYield, WORD wFlags);
WORD FAR PASCAL medSaveBatch(HMEDIABATCH hmedBatch, BOOL fYield);
WORD FAR PASCAL medSaveAsBatch(HMEDIABATCH hmedBatch, MEDID medidExisting,
			   LPSTR lpszName, FPMedReturn medReturn,
			   BOOL fYield, WORD wResetFlags);

HMEDIABATCH FAR PASCAL medAllocBatchBuffer(MEDID medid, HWND hwnd,
			WORD wFlags, BOOL fLoad, DWORD dwMsgData,
			FPMedDiskInfoCallback lpfnCb, LONG lParamCb);
BOOL FAR PASCAL medResetBatchBuffer(HMEDIABATCH hmedbatch, MEDID medid,
			WORD wFlags);
BOOL FAR PASCAL medFreeBatchBuffer(HMEDIABATCH hmedbatch);

#define MEDBATCH_RESETUPDATECB	0x0001

/* Flags for medLock */
#define	MEDF_READ	0x0001
#define MEDF_WRITE	0x0002
/* Flags for medUnlock */
#define MEDF_CHANGED	0x0004
#define MEDF_NOCHANGE	0x0000


/****************  RESOURCE USER  ******************/

MEDUSER FAR PASCAL medRegisterUser(HWND hWnd, DWORD dwInst);
void FAR PASCAL medUnregisterUser(MEDUSER meduser);
void FAR PASCAL medSendUserMessage(MEDID medid, MEDMSG medmsg, LONG lParam);
BOOL FAR PASCAL medRegisterUsage(MEDID medid, MEDUSER meduser);
BOOL FAR PASCAL medUnregisterUsage(MEDID medid, MEDUSER meduser);


typedef struct _MedUserMsgInfo {
        MEDID           medid;
        LONG            lParam;
        MEDINFO         medinfo;
        DWORD           dwInst;
} MedUserMsgInfo;
typedef MedUserMsgInfo FAR *FPMedUserMsgInfo;

#ifndef MM_MEDNOTIFY
#define MM_MEDNOTIFY         0x3BA
#endif

// obsolete but still required by bitedit and paledit

typedef DWORD (FAR PASCAL MedUser)
 		(MEDID medid, MEDMSG medmsg, MEDINFO medinfo,
 		LONG lParam, DWORD dwInst);
typedef MedUser FAR *FPMedUser;
 
MEDUSER FAR PASCAL medRegisterCallback(FPMedUser lpfnUser, DWORD dwInst);


/****************  TYPE TABLE  *****************/

typedef struct _MedTypeInfo {
	BOOL		fValid;		// Is this entry valid?
	WORD		wFlags;		// type flags
	MEDTYPE		medtype;	// the type id
	FPMedHandler	lpfnHandler;	// handler function for this type
	WORD		wInstanceSize;	// the byte count of instance data
	WORD		wRefcount;	// reference count on this type
} MedTypeInfo;
typedef MedTypeInfo FAR *FPMedTypeInfo;

/*  Flags to medRegisterType  */
#define MEDTYPE_LOGICAL		0x0001
#define MEDTYPE_PHYSICAL	0x0002

/*  Type creation macros  */
#define medMEDTYPE( ch0, ch1, ch2, ch3 )				\
		( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ) |	\
		( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) )

#define medFOURCC( ch0, ch1, ch2, ch3 )				\
		( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ) |	\
		( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) )

BOOL FAR PASCAL medRegisterType(MEDTYPE medtype, FPMedHandler lpfnHandler,
				WORD wFlags);
BOOL FAR PASCAL medUnregisterType(MEDTYPE medtype);
BOOL FAR PASCAL medGetTypeInfo(MEDTYPE medtype, FPMedTypeInfo fpInfo);
WORD FAR PASCAL medIterTypes(WORD wIndex, FPMedTypeInfo fpInfo);
FOURCC FAR PASCAL medStringToFourCC(LPSTR lpszString);
void FAR PASCAL medFourCCToString( FOURCC fcc, LPSTR lpszString);

MEDTYPE FAR PASCAL medGetLogicalType(MEDID medid);
MEDTYPE FAR PASCAL medGetPhysicalType(MEDID medid);
BOOL FAR PASCAL medSetPhysicalType(MEDID medid, MEDTYPE medtype);


/*************  MISC FUNCTIONS  *****************/

WORD FAR PASCAL medGetErrorText(DWORD wErrno, LPSTR lpszBuf, WORD wSize);
DWORD FAR PASCAL medGetError(void);
void FAR PASCAL medSetExtError(WORD wErrno, HANDLE hInst);
BOOL FAR PASCAL medClientInit(void);
BOOL FAR PASCAL medClientExit(void);
HANDLE FAR PASCAL medLoadHandlerDLL(LPSTR lpszDLLName);
BOOL FAR PASCAL medUnloadHandlerDLL(HANDLE hModule);


/*************  RESOURCE LOCATION  *****************/

MEDID FAR PASCAL medLocate(LPSTR lpszMedName, MEDTYPE medtype,
			WORD wFlags, LPSTR lpszMedPath);
MEDID FAR PASCAL medSubLocate(MEDID medidParent, MEDTYPE medtype,
			DWORD dwOffset, DWORD dwSize);
HANDLE FAR PASCAL medGetAliases(MEDID medid);
		
/* Flags for medLocate */
#define MEDF_LOCATE	0x0001
#define MEDF_MAKEFILE	0x0002
#define MEDF_MEMORYFILE	0x0004
#define MEDF_NONSHARED	0x0008

typedef struct _MedMemoryFileStruct {
	LPSTR	lpszBuf;
	DWORD	dwSize;
} MedMemoryFile;
typedef MedMemoryFile FAR *FPMedMemoryFile;

		     
typedef struct _MedFileInfo {
	WORD	wFlags;
	WORD	wFilesysType;
	MEDID	medidParent;
	DWORD	dwSize;
	DWORD	dwOffset;
	/*  Information on memory file system  */
	LPSTR	lpszMemory;
	DWORD	dwMemSize;
} MedFileInfo;
typedef MedFileInfo FAR *FPMedFileInfo;

#define	MEDFILE_SUBELEMENT	0x01
#define MEDFILE_NONSHARED	0x02

BOOL FAR PASCAL medGetFileInfo(MEDID medid, FPMedFileInfo fpInfo, WORD wSize);
WORD FAR PASCAL medGetFileName(MEDID medid, LPSTR lpszBuf, WORD wBufSize);

#define	MEDNAME_ERROR	0
#define MEDNAME_DYNAMIC	1
#define MEDNAME_MEMORY	2
#define MEDNAME_FILE	3


/***************************************
 *
 *	MEDIAMAN DLL ERROR MESSAGES
 *
 *	Should be less than 0x200.
 *
 ***************************************/
#define MMERR_NOERROR		0x0000
#define MMERR_TYPELISTMEM	0x0001
#define MMERR_BADHANDLER	0x0002
#define MMERR_TYPELISTDUPL	0x0003
#define MMERR_INVALIDTYPE	0x0004
#define MMERR_TYPEREFNOTZERO	0x0005
#define MMERR_WRONGHANDLERTYPE	0x0006

#define MMERR_GROUPTABLEMEMORY	0x0010
#define MMERR_GROUPSTRUCTMEMORY	0x0011
#define MMERR_GROUPSTRINGTABLE	0x0012
#define MMERR_GROUPENTRYTABLE	0x0013

#define MMERR_USERTABLEMEMORY	0x0014
#define RMERR_INVALIDMEDUSER	0x0015
#define MMERR_GLOBALUSERMEMORY	0x0016

#define MMERR_INVALIDSUBPARENT	0x0030
#define MMERR_NOFILEEXISTS	0x0031

#define MMERR_LOGONNAMESPACE	0x0040
#define MMERR_FILENAMESTEP	0x0041
#define MMERR_MEDNOTACCESSED	0x0042
#define MMERR_UNNAMEDELEMENT	0x0043
#define MMERR_DISKOPABORT	0x0044
#define	MMERR_NOTCORRECTFILE	0x0045
#define MMERR_COPYFAILED	0x0046
#define MMERR_DISKOPINPROGRESS	0x0047
#define MMERR_MEMORY		0x0048

#define MMERR_READOFWRITELOCKED		0x00E0
#define MMERR_WRITEOFWRITELOCKED	0x00E1

#define	MMERR_INVALIDDLLNAME	0x00F0
#define MMERR_COULDNOTLOADDLL	0x00F1
#define MMERR_BADLIBINIT	0x00F2
#define MMERR_INVALIDMODULE	0x00F3

#define MMERR_UNKNOWN		0x0100

#define MMERR_HMEDREAD		0x0101
#define MMERR_HMEDWRITE		0x0102
#define MMERR_HMEDGET		0x0103
#define MMERR_HMEDPUT		0x0104
#define MMERR_HMEDCLOSE		0x0105
#define MMERR_HMEDFIND		0x0106
#define MMERR_HMEDFINDANY	0x0107
#define MMERR_HMEDUNGET		0x0108
#define MMERR_HMEDALLOC		0x0109
#define MMERR_HMEDLOCK		0x010a
#define MMERR_GETFILEINFO	0x010b
#define MMERR_HMEDASCEND	0x010c
#define MMERR_STACKASCEND	0x010d
#define MMERR_HMEDDESCEND	0x010e
#define MMERR_DESCENDSPACE	0x010f
#define MMERR_DESCENDGET	0x0110
#define MMERR_STACKDESCEND	0x0111
#define MMERR_HMEDRESIZE	0x0112
#define MMERR_STACKRESIZE	0x0113
#define MMERR_HMEDCREATE	0x0114
#define MMERR_STACKCREATE	0x0115
#define MMERR_CREATESPACE	0x0116
#define MMERR_CREATEPUT		0x0117
#define MMERR_HMEDSIZE		0x0118
#define MMERR_HMEDLEVEL		0x0119
#define MMERR_HMEDCKID		0x011a
#define RMERR_MEDIDOPEN		0x011b
#define MMERR_WRITEONLY		0x011c
#define MMERR_READONLY		0x011d
#define MMERR_PREVERROR		0x011e
#define MMERR_EOF		0x011f
#define MMERR_BEGIN		0x0120
#define MMERR_IOERROR		0x0121
#define MMERR_UNGETROOM		0x0122
#define MMERR_GETFILENAME	0x0123
#define MMERR_FINDFIRST		0x0124
#define MMERR_OPEN		0x0125
#define MMERR_SEEKINIT		0x0126
#define MMERR_HMEDSEEK		0x0127
#define MMERR_READ		0x0128
#define MMERR_HMEDCFOPEN	0x0129
#define MMERR_MEDGCFCLOSE	0x0130
#define MMERR_WRITE		0x0131



#define MMERR_MAXERROR		0x0200





/***************************************
 *
 *	MEDIAMAN PHYSICAL IO DEFINITIONS
 *
 ***************************************/

typedef FOURCC CKID;
typedef FOURCC FORMTYPE;
typedef DWORD CKSIZE;

/* 
 * RIFF stack elements
 */

typedef int RIFFSTACKPLACE;
typedef void huge * HPVOID;


typedef struct riff_stack_element {
    CKID		nID;		/* TOS current chunk id */
    CKSIZE		cbSize;		/* TOS current chunk size */
    LONG		nOffset;	/* Stacked nOffset for prev chunk */
    LONG		nEnd;		/* Stacked nEnd for prev chunk */
    WORD		info;		/* Stacked info for prev chunk */
} RIFFSTACKELEM;

typedef RIFFSTACKELEM FAR * FPRIFFSTACKELEM;

/*
 * Storage System Handler routine type definition 
 */
typedef LONG (FAR PASCAL MIOHANDLER)       \
		(struct medElement far * hMed, WORD wFlags, \
			DWORD lParam1, DWORD lParam2 );
typedef MIOHANDLER FAR * FPMIOHANDLER;


#define MEDIO_DOS_STORAGE	0
#define MEDIO_MEM_STORAGE	1
#define MEDIO_CF_STORAGE	2

/*
 * Handle to Resource ( once opened ) 
 */
typedef struct medElement {
    LONG lData1;		/*  data 1 2 and 3 sections hold */
    LONG lData2;		/* info specific to the storage system */
    LONG lData3;		/* eg the dos file handle for dos files */
    MEDID medid;		/* medid opened */
    HANDLE hMem;		/* handle to the memory of the HMED */
    FPMIOHANDLER fpfnHandler;	/* storage system handler */
    LONG nInitOffset;		/* for sub-resources - offset of start */
    LONG nOffset;		/* for riff offset start of chunk to start */
				/* NOTE nOffset doesn't include nInitOffset */
    LONG nCurrent;		/* offset of end of current buffer */
    LONG nEnd;			/* offset of end of current chunk/file */
    LONG nLeft;			/* space in buff from eof(chunk) to buffend */
    LONG nGet;			/* number of chars left to read in buff */
    LONG nPut;			/* number of chars left to write in buff */
				/* NOTE nGet, nPut are mutually exclusive */
    LONG nSize;			/* size of information read into buffer */
    LONG nUnGet;		/* num of chars ungotten before buff start */
    WORD flags;			/* RIOF_ info 'temperary' like error */
    WORD info;			/* RIOI_ info 'permanent' eg. extendable*/
    LPSTR fpchPlace;		/* place to get/put next char in buffer */
    LPSTR fpchMax;		/* max position of Place - for seek, unget */
    LONG cbBuffer;		/* the full buffer size */
    RIFFSTACKPLACE nRiffTop;	/* current top of riff stack, -1 is nothing */
    FPRIFFSTACKELEM fpRiffStack;
				/* FP into the data to for Riff Stack */
				/* riff stack index top by nRiffTop */
    LPSTR fpchBuffer;		/* FP into the data for the Buffer */
    char data[1];		/* the actual buffer */
} MIOELEMENT;

typedef MIOELEMENT FAR * HMED;

/*
 * HMED flags 'temporary' info
 */
#define MIOF_OK		0	/* no info */
#define MIOF_EOF	1	/* have reached eof (or end of chunk) */
#define MIOF_READING	2	/* info has been read into buffer */
#define MIOF_WRITING	4	/* info has been written to buffer */
#define MIOF_UNGET	8	/* have ungotten before buff start */
#define MIOF_ERROR	16	/* have gotten some form of error */

#define MIOF_BUFF_EOF	64	/* EOF at buffer end */
#define MIOF_BUFF_ERROR	128	/* error at buffer end or 'fatal' error */
				/* fatal as in can not do any more IO */
				/* unlike the error you get for */
				/* trying to unget too many chars */
#define MIOF_AFTERCURR	256	/* the characters in the buffer are located */
				/* after the hMed->nCurrent */


/*
 * HMED info 'permanent' info
 */
#define MIOI_NOTHING		0	/* no info */
#define MIOI_RESIZED		32	/* This chunk has been resized */
					/* possibly fix the size on ascend */
#define MIOI_AUTOSIZED		64	/* This chunk has been created */
					/* fix the size on ascend */
#define MIOI_BYTESWAPPED	128	/* riff chunk sizes are byteswapped */
#define MIOI_EXTENDABLE		256	/* the resource is extendable */
					/* unlike riff chunks */


/*
 * Return values
 */
#define MED_EOF		(-1)		/* universal something wrong return */

/*
 * Resource mode to open resource as 
 */
#define MOP_READ	0
#define MOP_WRITE	1
#define MOP_READ_WRITE	2

#define MOP_PRELOAD	0x0008
#define MOP_CREATE	0x0010
#define MOP_ZEROBUFFER	0x0100


/* CLOSE return flags */
#define MCERR_OK		0x0000
#define MCERR_UNSPECIFIC	0x0001
#define MCERR_FLUSH		0x0002
#define MCERR_STORAGE		0x0004


/* 
 * seek flags
 */
#define MOPS_SET	1
#define MOPS_CUR	2
#define MOPS_END	4
#define MOPS_NONLOCAL	128
#define MOPS_EXTEND	64



/*
 * Resize Chunk Flags
 */
#define MOPRC_AUTOSIZE		1

/* 
 * FUNCTION API's
 */
/* normal IO */
HMED FAR PASCAL medOpen( MEDID id, WORD wMode, WORD wSize );
WORD FAR PASCAL medClose( HMED hMed );
LONG FAR PASCAL medRead( HMED hMed, HPVOID hpBuffer, LONG lBytes );
LONG FAR PASCAL medWrite( HMED hMed, HPVOID hpBuffer, LONG lBytes );
LONG FAR PASCAL medSeek( HMED hMed, LONG lOffset, WORD wOrigin );

/* RIFF */
BOOL FAR PASCAL medAscend( HMED hMed );
CKID FAR PASCAL medDescend( HMED hMed );
CKID FAR PASCAL medCreateChunk(HMED hMed, CKID ckid, DWORD dwCkSize);
BOOL FAR PASCAL medResizeChunk(HMED hMed, DWORD dwCkSize, WORD wFlags);
int FAR PASCAL medGetChunkLevel( HMED hMed );
CKID FAR PASCAL medGetChunkID( HMED hMed );
CKSIZE FAR PASCAL medGetChunkSize( HMED hMed );
BOOL FAR PASCAL medFindAnyChunk( HMED hMed, CKID FAR * ackid );
BOOL FAR PASCAL medFindChunk( HMED hMed, CKID id );

LONG FAR PASCAL medGetSwapWORD( HMED hMed );  

/* 
 * FUNCTIONs used in macros and such
 */
LONG FAR PASCAL medIOFillBuff( HMED hMed, int size );
LONG FAR PASCAL medIOFlushBuff( HMED hMed, DWORD dwElem, int size );
BOOL FAR PASCAL medFlush( HMED hMed );
LONG FAR PASCAL medUnGet( HMED hMed, DWORD dwElem, int size );

/*
 * MACRO API's autodocked in riomac.d
 */
/* RIFF stuff */

#define medFCC3( fcc )	( (BYTE)( (fcc & 0xFF000000) >> 24 ) )
#define medFCC2( fcc )	( (BYTE)( (fcc & 0x00FF0000) >> 16 ) )
#define medFCC1( fcc )	( (BYTE)( (fcc & 0x0000FF00) >> 8 ) )
#define medFCC0( fcc )	( (BYTE)(fcc & 0x000000FF) )


/* constant RIFF chunk id */
#define ckidRIFF	medFOURCC( 'R', 'I', 'F', 'F' )
			  

/* lets the user set and check if the file is byteswapped */
#define medGetByteSwapped( hMed )	( (hMed)->info & MIOI_BYTESWAPPED )

#define medSetByteSwapped( hMed, fVal )   ( (hMed)->info = ( fVal ?       \
			( (hMed)->info | MIOI_BYTESWAPPED ) :		\
			~((~((hMed)->info))|MIOI_BYTESWAPPED) ) )


#define medHMEDtoMEDID( hMed )	( (hMed)->medid )

						
						

/*
 * UnGet Get and Put of BYTE WORD and DWORD and ByteSwapped versions 
 * NOTE the ByteSwap function is in WINCOM and so WINCOM.H must be included
 *	before the RESIO.H
 */						
#define medUnGetBYTE( hMed, ch )   ( (int)(medUnGet( hMed,(DWORD)ch,1 ) ) )
#define medUnGetWORD( hMed, w )	   ( (LONG)(medUnGet( hMed,(DWORD)w,2 ) ) )
#define medUnGetDWORD( hMed, dw )  ( (LONG)(medUnGet( hMed,(DWORD)dw,4) ) )
#define medUnGetSwapWORD(hMed,w)   ( medUnGetWORD( hMed,		\
						ByteSwapWORD((WORD)w) ) )
#define medUnGetSwapDWORD(hMed,dw) ( medUnGetDWORD( hMed,		\
						ByteSwapDWORD((DWORD)dw) ) )

#define medUnGetOpSwapWORD( hMed, w )   ( medGetByteSwapped( hMed ) ?	\
			medUnGetSwapWORD( hMed, w ) :			\
			medUnGetWORD( hMed, w ) )

#define medUnGetOpSwapDWORD( hMed, dw )   ( medGetByteSwapped( hMed ) ?	\
			medUnGetSwapDWORD( hMed, dw ) :			\
			medUnGetDWORD( hMed, dw ) )

							
							

#define medGetBYTE( hMed )	( (--((hMed)->nGet) >= 0) ?	             \
		(int)(BYTE)*(((hMed)->fpchPlace)++) :			     \
		(int)(medIOFillBuff( hMed, 1 )) )
						
#define medPutBYTE( hMed, ch )	( (--((hMed)->nPut) >= 0) ?                 \
		(int)(BYTE)((*(((hMed)->fpchPlace)++)) = (BYTE)ch) :	  \
		(int)(medIOFlushBuff(hMed,(DWORD)ch,1)) )
				
				
/* note in the following macros we want to advance the fpchPlace */
/* by the size after we get the value of it.  To do this we typecast */
/* them to int ( or long ) and add the size ( += size ) and then */
/* subtract 4 so the value used is not incremented yet */
							
							
#define medGetWORD( hMed )	( (((hMed)->nGet -= 2) >= 0) ?		     \
	(long)*((WORD FAR *)((((LONG)((hMed)->fpchPlace))+=2)-2)) :	     \
	(long)(medIOFillBuff( hMed, 2 )) )
					
#define medPutWORD( hMed, w )	( (((hMed)->nPut -= 2) >= 0) ?                 \
	(long)((*((WORD FAR *)((((LONG)((hMed)->fpchPlace))+=2)-2)))=(WORD)w) :\
	(long)(medIOFlushBuff( hMed, (DWORD)w, 2 )) )

#define medPutSwapWORD( hMed, w )  ( medPutWORD(hMed,ByteSwapWORD((WORD)w)) )
		
#define medGetOpSwapWORD( hMed )   ( medGetByteSwapped( hMed ) ?	\
			medGetSwapWORD( hMed ) :			\
			medGetWORD( hMed ) )

#define medPutOpSwapWORD( hMed, w )   ( medGetByteSwapped( hMed ) ?	\
			medPutSwapWORD( hMed, w ) :			\
			medPutWORD( hMed, w ) )




#define medGetDWORD( hMed )	( (((hMed)->nGet -= 4) >= 0) ?		     \
	(long)*((DWORD FAR *)((((LONG)((hMed)->fpchPlace))+=4)-4)) :	     \
	(long)(medIOFillBuff( hMed, 4 )) )
					
#define medPutDWORD( hMed, dw )	( (((hMed)->nPut -= 4) >= 0) ?                \
    (long)((*((DWORD FAR *)((((LONG)((hMed)->fpchPlace))+=4)-4)))=(DWORD)dw): \
    (long)(medIOFlushBuff( hMed, (DWORD)dw, 4 )) )

#define medGetSwapDWORD(hMed)    (ByteSwapDWORD((DWORD)medGetDWORD(hMed)))
#define medPutSwapDWORD(hMed,dw) (medPutDWORD(hMed,ByteSwapDWORD((DWORD)dw)))

#define medGetOpSwapDWORD( hMed )   ( medGetByteSwapped( hMed ) ?	\
			medGetSwapDWORD( hMed ) :			\
			medGetDWORD( hMed ) )

#define medPutOpSwapDWORD( hMed, dw )   ( medGetByteSwapped( hMed ) ?	\
			medPutSwapDWORD( hMed, dw ) :			\
			medPutDWORD( hMed, dw ) )


/* for RIFF, read the FORMTYPE */
#define medReadFormHeader( hMed )		medGetDWORD( hMed )
#define medWriteFormHeader( hMed, formtype )	medPutDWORD( hMed, formtype )
#define medGetFOURCC( hMed )			medGetDWORD( hMed )
#define medPutFOURCC( hMed, fcc )		medPutDWORD( hMed, fcc )

/* ERROR and EOF checks */
#define medGetIOError( hMed )	( (hMed)->flags & MIOF_ERROR )
#define medGetIOEOF( hMed )	( (hMed)->flags & MIOF_EOF )

#endif /* _MEDMAN_H_ */