/* 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_ */