using System; using System.Runtime.InteropServices; using System.Text; using Vanara.InteropServices; namespace Vanara.PInvoke { public static partial class WinMm { ///

Processes driver messages for the installable driver. DriverProc is a driver-supplied function.

/// Identifier of the installable driver. /// Handle of the installable driver instance. Each instance of the installable driver has a unique handle. /// /// Driver message value. It can be a custom value or one of these standard values: /// /// /// Value /// Meaning /// /// /// DRV_CLOSE /// Notifies the driver that it should decrement its usage count and unload the driver if the count is zero. /// /// /// DRV_CONFIGURE /// /// Notifies the driver that it should display a configuration dialog box. This message is sent only if the driver returns a nonzero /// value when processing the DRV_QUERYCONFIGURE message. /// /// /// /// DRV_DISABLE /// Notifies the driver that its allocated memory is about to be freed. /// /// /// DRV_ENABLE /// Notifies the driver that it has been loaded or reloaded or that Windows has been enabled. /// /// /// DRV_FREE /// Notifies the driver that it will be discarded. /// /// /// DRV_INSTALL /// Notifies the driver that it has been successfully installed. /// /// /// DRV_LOAD /// Notifies the driver that it has been successfully loaded. /// /// /// DRV_OPEN /// Notifies the driver that it is about to be opened. /// /// /// DRV_POWER /// Notifies the driver that the device's power source is about to be turned on or off. /// /// /// DRV_QUERYCONFIGURE /// Directs the driver to specify whether it supports the DRV_CONFIGURE message. /// /// /// DRV_REMOVE /// Notifies the driver that it is about to be removed from the system. /// /// /// /// 32-bit message-specific value. /// 32-bit message-specific value. /// Returns nonzero if successful or zero otherwise. /// /// /// When msg is DRV_OPEN, lParam1 is the string following the driver filename from the SYSTEM.INI file and lParam2 is the value /// given as the lParam parameter in a call to the OpenDriver function. /// /// /// When msg is DRV_CLOSE, lParam1 and lParam2 are the same values as the lParam1 and lParam2 parameters in a call to the /// CloseDriver function. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nc-mmiscapi-driverproc DRIVERPROC Driverproc; LRESULT Driverproc( // DWORD_PTR unnamedParam1, HDRVR unnamedParam2, UINT unnamedParam3, LPARAM unnamedParam4, LPARAM unnamedParam5 ) {...} [UnmanagedFunctionPointer(CallingConvention.Winapi)] [PInvokeData("mmiscapi.h", MSDNShortId = "NC:mmiscapi.DRIVERPROC")] public delegate IntPtr DRIVERPROC(IntPtr dwDriverIdentifier, HDRVR hdrvr, DRV uMsg, IntPtr lParam1, IntPtr lParam2); ///

/// The MMIOProc function is a custom input/output (I/O) procedure installed by the mmioInstallIOProc function. /// MMIOProc is a placeholder for the application-defined function name. The address of this function can be specified in the /// callback-address parameter of mmioInstallIOProc. ///

/// /// Points to an MMIOINFO structure containing information about the open file. /// /// The I/O procedure must maintain the lDiskOffset member in this structure to indicate the file offset to the next read or /// write location. The I/O procedure can use the adwInfo[] member to store state information. The I/O procedure should not /// modify any other members of the MMIOINFO structure. /// /// /// /// Specifies a message indicating the requested I/O operation. Messages that can be received include MMIOM_OPEN, MMIOM_CLOSE, /// MMIOM_READ, MMIOM_SEEK, MMIOM_WRITE, and MMIOM_WRITEFLUSH. /// /// Specifies an application-defined parameter for the message. /// Specifies an application-defined parameter for the message. /// /// The return value depends on the message specified by uMsg. If the I/O procedure does not recognize a message, it should return zero. /// /// /// /// The four-character code specified by the fccMMIOProc member in the MMIOINFO structure associated with a file identifies a /// file name extension for a custom storage system. When an application calls mmioOpen with a file name such as "one.xyz+two", the /// I/O procedure associated with the four-character code "XYZ" is called to open the "two" element of the file "one.xyz". /// /// /// The mmioInstallIOProc function maintains a separate list of installed I/O procedures for each Windows-based application. /// Therefore, different applications can use the same I/O procedure identifier for different I/O procedures without conflict. /// However, installing an I/O procedure globally enables any process to use the procedure. /// /// /// If an application calls mmioInstallIOProc more than once to register the same I/O procedure, then it must call /// mmioInstallIOProc to remove the procedure once for each time it installed the procedure. /// /// /// mmioInstallIOProc will not prevent an application from installing two different I/O procedures with the same identifier, or /// installing an I/O procedure with one of the predefined identifiers ("DOS ", "MEM "). The most recently installed procedure takes /// precedence, and the most recently installed procedure is the first one to be removed. /// /// When searching for a specified I/O procedure, local procedures are searched first, then global procedures. /// // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nc-mmiscapi-mmioproc MMIOPROC Mmioproc; LRESULT Mmioproc( LPSTR // lpmmioinfo, UINT uMsg, LPARAM lParam1, LPARAM lParam2 ) {...} [UnmanagedFunctionPointer(CallingConvention.Winapi)] [PInvokeData("mmiscapi.h", MSDNShortId = "NC:mmiscapi.MMIOPROC")] public delegate IntPtr MMIOPROC(ref MMIOINFO lpmmioinfo, MMIOM uMsg, IntPtr lParam1, IntPtr lParam2); ///

Notification flags.

[PInvokeData("mmddk.h")] public enum DCB : uint { ///

Unknown callback type

DCB_NULL = 0x0000, ///

/// The dwCallback parameter is the handle of an application-defined window. The system sends subsequent notifications to the window. ///

DCB_WINDOW = 0x0001, ///

/// The dwCallback parameter is the handle of an application or task. The system sends subsequent notifications to the /// application or task. ///

DCB_TASK = 0x0002, ///

/// The dwCallback parameter is the address of an application-defined callback function. The system sends the callback message /// to the callback function. ///

DCB_FUNCTION = 0x0003, ///

dwCallback is an EVENT

DCB_EVENT = 0x0005, ///

/// The system is prevented from switching stacks. This value is only used if enough stack space for the callback function is /// known to exist. ///

DCB_NOSWITCH = 0x0008, } ///

Driver message value. It can be a custom value or one of these standard values.

[PInvokeData("mmiscapi.h", MSDNShortId = "NC:mmiscapi.DRIVERPROC")] public enum DRV { ///

Notifies the driver that it has been successfully loaded.

DRV_LOAD = 0x0001, ///

Notifies the driver that it has been loaded or reloaded or that Windows has been enabled.

DRV_ENABLE = 0x0002, ///

Notifies the driver that it is about to be opened.

DRV_OPEN = 0x0003, ///

Notifies the driver that it should decrement its usage count and unload the driver if the count is zero.

DRV_CLOSE = 0x0004, ///

Notifies the driver that its allocated memory is about to be freed.

DRV_DISABLE = 0x0005, ///

Notifies the driver that it will be discarded.

DRV_FREE = 0x0006, ///

/// Notifies the driver that it should display a configuration dialog box. This message is sent only if the driver returns a /// nonzero value when processing the DRV_QUERYCONFIGURE message. ///

DRV_CONFIGURE = 0x0007, ///

Directs the driver to specify whether it supports the DRV_CONFIGURE message.

DRV_QUERYCONFIGURE = 0x0008, ///

Notifies the driver that it has been successfully installed.

DRV_INSTALL = 0x0009, ///

Notifies the driver that it is about to be removed from the system.

DRV_REMOVE = 0x000A, ///

DRV_EXITSESSION = 0x000B, ///

Notifies the driver that the device's power source is about to be turned on or off.

DRV_POWER = 0x000F, ///

DRV_RESERVED = 0x0800, ///

DRV_USER = 0x4000, } ///

[Flags] public enum MMIO : uint { /* constants for dwFlags field of MMIOINFO */ ///

The mmioOpen function was directed to create the file (or truncate it to zero length if it already existed).

MMIO_CREATE = 0x00001000, ///

The new file's path is returned.

MMIO_PARSE = 0x00000100, ///

create new file (or truncate file)

MMIO_DELETE = 0x00000200, ///

Checks for the existence of the file.

MMIO_EXIST = 0x00004000, ///

File's I/O buffer was allocated by the mmioOpen or mmioSetBuffer function.

MMIO_ALLOCBUF = 0x00010000, ///

A temporary name was retrieved by the mmioOpen function.

MMIO_GETTEMP = 0x00020000, ///

The I/O buffer has been modified.

MMIO_DIRTY = 0x10000000, ///

File was opened only for reading.

MMIO_READ = 0x00000000, ///

File was opened only for writing.

MMIO_WRITE = 0x00000001, ///

File was opened for reading and writing.

MMIO_READWRITE = 0x00000002, /* share mode numbers (bit field MMIO_SHAREMODE) */ ///

/// File was opened with compatibility mode, allowing any process on a given machine to open the file any number of times. ///

MMIO_COMPAT = 0x00000000, ///

Other processes are denied read and write access to the file.

MMIO_EXCLUSIVE = 0x00000010, ///

Other processes are denied write access to the file.

MMIO_DENYWRITE = 0x00000020, ///

Other processes are denied read access to the file.

MMIO_DENYREAD = 0x00000030, ///

Other processes are not denied read or write access to the file.

MMIO_DENYNONE = 0x00000040, } ///

Flags for the close operation.

[PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioClose")] [Flags] public enum MMIOCLOSE : uint { ///

/// If the file was opened by passing a file handle whose type is not HMMIO, using this flag tells the mmioClose function to /// close the multimedia file handle, but not the standard file handle. ///

MMIO_FHOPEN = 0x0010, } ///

Flags for the conversion.

[PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioStringToFOURCC")] [Flags] public enum MMIOCONV : uint { ///

Converts all characters to uppercase.

MMIO_TOUPPER = 0x0010, } ///

Flags identifying what type of chunk to create.

[PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioCreateChunk")] [Flags] public enum MMIOCREATE : uint { ///

RIFF chunk

MMIO_CREATERIFF = 0x0020, ///

LIST chunk

MMIO_CREATELIST = 0x0040, } ///

/// Search flags. If no flags are specified, mmioDescend descends into the chunk beginning at the current file position. ///

[Flags] public enum MMIODESC : uint { ///

Searches for a chunk with the specified chunk identifier.

MMIO_FINDCHUNK = 0x0010, ///

Searches for a chunk with the chunk identifier "RIFF" and with the specified form type.

MMIO_FINDRIFF = 0x0020, ///

Searches for a chunk with the chunk identifier "LIST" and with the specified form type.

MMIO_FINDLIST = 0x0040, } ///

Flag determining how the flush is carried out.

[PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioFlush")] [Flags] public enum MMIOFLUSH : uint { ///

Empties the buffer after writing it to the disk.

MMIO_EMPTYBUF = 0x0010, } ///

Flag indicating whether the I/O procedure is being installed, removed, or located.

[PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioInstallIOProc")] [Flags] public enum MMIOINST : uint { ///

Installs the specified I/O procedure.

MMIO_INSTALLPROC = 0x00010000, ///

/// This flag is a modifier to the MMIO_INSTALLPROC flag and indicates the I/O procedure should be installed for global use. /// This flag is ignored if MMIO_FINDPROC or MMIO_REMOVEPROC is specified. ///

MMIO_GLOBALPROC = 0x10000000, ///

Removes the specified I/O procedure.

MMIO_REMOVEPROC = 0x00020000, ///

Unicode MMIOProc

MMIO_UNICODEPROC = 0x01000000, ///

Searches for the specified I/O procedure.

MMIO_FINDPROC = 0x00040000, } ///

MMIO messages.

[PInvokeData("mmiscapi.h")] public enum MMIOM : uint { ///

read

MMIOM_READ = MMIO.MMIO_READ, ///

write

MMIOM_WRITE = MMIO.MMIO_WRITE, ///

seek to a new position in file

MMIOM_SEEK = 2, ///

open file

MMIOM_OPEN = 3, ///

close file

MMIOM_CLOSE = 4, ///

write and flush

MMIOM_WRITEFLUSH = 5, ///

rename specified file

MMIOM_RENAME = 6, ///

beginning of user-defined messages

MMIOM_USER = 0x8000, } ///

Closes an installable driver.

/// /// Handle of an installable driver instance. The handle must have been previously created by using the OpenDriver function. /// /// 32-bit driver-specific data. /// 32-bit driver-specific data. /// Returns nonzero if successful or zero otherwise. /// The function passes the lParam1 and lParam2 parameters to the DriverProc function of the installable driver. // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-closedriver LRESULT CloseDriver( HDRVR hDriver, LPARAM // lParam1, LPARAM lParam2 ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.CloseDriver")] public static extern IntPtr CloseDriver(HDRVR hDriver, [In, Optional] IntPtr lParam1, [In, Optional] IntPtr lParam2); ///

/// Provides default processing for any messages not processed by an installable driver. This function is intended to be used only /// within the DriverProc function of an installable driver. ///

/// Identifier of the installable driver. /// Handle of the installable driver instance. /// Driver message value. /// 32-bit message-dependent information. /// 32-bit message-dependent information. /// Returns nonzero if successful or zero otherwise. // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-defdriverproc LRESULT DefDriverProc( DWORD_PTR // dwDriverIdentifier, HDRVR hdrvr, UINT uMsg, LPARAM lParam1, LPARAM lParam2 ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.DefDriverProc")] public static extern IntPtr DefDriverProc(IntPtr dwDriverIdentifier, HDRVR hdrvr, DRV uMsg, IntPtr lParam1, IntPtr lParam2); ///

/// Calls a callback function, sends a message to a window, or unblocks a thread. The action depends on the value of the /// notification flag. This function is intended to be used only within the DriverProc function of an installable driver. ///

/// /// Address of the callback function, a window handle, or a task handle, depending on the flag specified in the dwFlags parameter. /// /// /// Notification flags. It can be one of these values: /// /// /// Value /// Meaning /// /// /// DCB_NOSWITCH /// /// The system is prevented from switching stacks. This value is only used if enough stack space for the callback function is known /// to exist. /// /// /// /// DCB_FUNCTION /// /// The dwCallback parameter is the address of an application-defined callback function. The system sends the callback message to /// the callback function. /// /// /// /// DCB_WINDOW /// /// The dwCallback parameter is the handle of an application-defined window. The system sends subsequent notifications to the window. /// /// /// /// DCB_TASK /// /// The dwCallback parameter is the handle of an application or task. The system sends subsequent notifications to the application /// or task. /// /// /// /// /// Handle of the installable driver instance. /// Message value. /// 32-bit user-instance data supplied by the application when the device was opened. /// 32-bit message-dependent parameter. /// 32-bit message-dependent parameter. /// Returns TRUE if successful or FALSE if a parameter is invalid or the task's message queue is full. /// /// /// The client specifies how to notify it when the device is opened. The DCB_FUNCTION and DCB_WINDOW flags are equivalent to the /// high-order word of the corresponding flags CALLBACK_FUNCTION and CALLBACK_WINDOW specified in the lParam2 parameter of the /// DRV_OPEN message when the device was opened. /// /// /// If notification is accomplished with a callback function, hdrvr, msg, dwUser, dwParam1, and dwParam2 are passed to the callback /// function. If notification is accomplished by means of a window, only msg, hdrvr, and dwParam1 are passed to the window. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-drivercallback BOOL DriverCallback( DWORD_PTR dwCallback, // DWORD dwFlags, HDRVR hDevice, DWORD dwMsg, DWORD_PTR dwUser, DWORD_PTR dwParam1, DWORD_PTR dwParam2 ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.DriverCallback")] [return: MarshalAs(UnmanagedType.Bool)] public static extern bool DriverCallback(IntPtr dwCallback, DCB dwFlags, HDRVR hDevice, uint dwMsg, IntPtr dwUser, IntPtr dwParam1, IntPtr dwParam2); ///

/// Provides default processing for any messages not processed by an installable driver. This function is intended to be used only /// within the DriverProc function of an installable driver. ///

/// Identifier of the installable driver. /// Handle of the installable driver instance. /// Driver message value. /// 32-bit message-dependent information. /// 32-bit message-dependent information. /// Returns nonzero if successful or zero otherwise. // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-drvdefdriverproc LRESULT DrvDefDriverProc( DWORD // dwDriverIdentifier, HDRVR hdrvr, UINT uMsg, LPARAM lParam1, LPARAM lParam2 ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.DrvDefDriverProc")] public static extern IntPtr DrvDefDriverProc(uint dwDriverIdentifier, HDRVR hdrvr, uint uMsg, IntPtr lParam1, IntPtr lParam2); ///

/// Retrieves the instance handle of the module that contains the installable driver. This function is provided for compatibility /// with previous versions of Windows. ///

/// /// Handle of the installable driver instance. The handle must have been previously created by using the OpenDriver function. /// /// Returns an instance handle of the driver module if successful or NULL otherwise. // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-drvgetmodulehandle HMODULE DrvGetModuleHandle( HDRVR // hDriver ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.DrvGetModuleHandle")] public static extern HINSTANCE DrvGetModuleHandle([In] HDRVR hDriver); ///

Retrieves the instance handle of the module that contains the installable driver.

/// Handle of the installable driver instance. The handle must have been previously created by using the OpenDriver function. /// Returns an instance handle of the driver module if successful or NULL otherwise. // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-getdrivermodulehandle // HMODULE GetDriverModuleHandle( HDRVR hDriver ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.GetDriverModuleHandle")] public static extern HINSTANCE GetDriverModuleHandle([In] HDRVR hDriver); ///

/// The mmioAdvance function advances the I/O buffer of a file set up for direct I/O buffer access with the mmioGetInfo function. ///

/// File handle of a file opened by using the mmioOpen function. /// /// Pointer to the MMIOINFO structure obtained by using the mmioGetInfo function. This structure is used to set the current file /// information, and then it is updated after the buffer is advanced. This parameter is optional. /// /// /// Flags for the operation. It can be one of the following. /// /// /// Value /// Meaning /// /// /// MMIO_READ /// Buffer is filled from the file. /// /// /// MMIO_WRITE /// Buffer is written to the file. /// /// /// /// /// Returns MMSYSERR_NOERROR if successful or an error otherwise. Possible error values include the following. /// /// /// Return code /// Description /// /// /// MMIOERR_CANNOTEXPAND /// /// The specified memory file cannot be expanded, probably because the adwInfo member of the MMIOINFO structure was set to zero in /// the initial call to the mmioOpen function. /// /// /// /// MMIOERR_CANNOTREAD /// An error occurred while refilling the buffer. /// /// /// MMIOERR_CANNOTWRITE /// The contents of the buffer could not be written to disk. /// /// /// MMIOERR_OUTOFMEMORY /// There was not enough memory to expand a memory file for further writing. /// /// /// MMIOERR_UNBUFFERED /// The specified file is not opened for buffered I/O. /// /// /// /// /// /// If the file is opened for reading, the I/O buffer is filled from the disk. If the file is opened for writing and the MMIO_DIRTY /// flag is set in the dwFlags member of the MMIOINFO structure, the buffer is written to disk. The /// pchNext,pchEndRead, and pchEndWrite members of the MMIOINFO structure are updated to reflect the new /// state of the I/O buffer. /// /// /// If the specified file is opened for writing or for both reading and writing, the I/O buffer is flushed to disk before the next /// buffer is read. If the I/O buffer cannot be written to disk because the disk is full, mmioAdvance returns MMIOERR_CANNOTWRITE. /// /// If the specified file is open only for writing, the MMIO_WRITE flag must be specified. /// /// If you have written to the I/O buffer, you must set the MMIO_DIRTY flag in the dwFlags member of the MMIOINFO /// structure before calling mmioAdvance. Otherwise, the buffer will not be written to disk. /// /// /// If the end of file is reached, mmioAdvance still returns successfully even though no more data can be read. To check for /// the end of the file, check if the pchNext and pchEndRead members of the MMIOINFO structure are equal after /// calling mmioAdvance. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-mmioadvance MMRESULT mmioAdvance( HMMIO hmmio, LPMMIOINFO // pmmioinfo, UINT fuAdvance ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioAdvance")] public static extern MMRESULT mmioAdvance(HMMIO hmmio, in MMIOINFO pmmioinfo, MMIO fuAdvance); ///

/// The mmioAdvance function advances the I/O buffer of a file set up for direct I/O buffer access with the mmioGetInfo function. ///

/// The mmioAscend function ascends out of a chunk in a RIFF file descended into with the mmioDescend function or created /// with the mmioCreateChunk function. ///

/// File handle of an open RIFF file. /// /// Pointer to an application-defined MMCKINFO structure previously filled by the mmioDescend or mmioCreateChunk function. /// /// Reserved; must be zero. /// /// Returns MMSYSERR_NOERROR if successful or an error otherwise. Possible error values include the following. /// /// /// Return code /// Description /// /// /// MMIOERR_CANNOTSEEK /// There was an error while seeking to the end of the chunk. /// /// /// MMIOERR_CANNOTWRITE /// The contents of the buffer could not be written to disk. /// /// /// /// /// /// If the chunk was descended into by using mmioDescend, mmioAscend seeks to the location following the end of the chunk /// (past the extra pad byte, if any). /// /// /// If the chunk was created and descended into by using mmioCreateChunk, or if the MMIO_DIRTY flag is set in the /// dwFlags member of the MMCKINFO structure referenced by lpck, the current file position is assumed to be the end of /// the data portion of the chunk. If the chunk size is not the same as the value stored in the cksize member of the /// MMCKINFO structure when mmioCreateChunk was called, mmioAscend corrects the chunk size in the file before /// ascending from the chunk. If the chunk size is odd, mmioAscend writes a null pad byte at the end of the chunk. After /// ascending from the chunk, the current file position is the location following the end of the chunk (past the extra pad byte, if any). /// /// // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-mmioascend MMRESULT mmioAscend( HMMIO hmmio, LPMMCKINFO // pmmcki, UINT fuAscend ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioAscend")] public static extern MMRESULT mmioAscend(HMMIO hmmio, in MMCKINFO pmmcki, uint fuAscend = 0); ///

The mmioClose function closes a file that was opened by using the mmioOpen function.

/// File handle of the file to close. /// /// Flags for the close operation. The following value is defined. /// /// /// Value /// Meaning /// /// /// MMIO_FHOPEN /// /// If the file was opened by passing a file handle whose type is not HMMIO, using this flag tells the mmioClose function to close /// the multimedia file handle, but not the standard file handle. /// /// /// /// /// /// /// Returns zero if successful or an error otherwise. The error value can originate from the mmioFlush function or from the I/O /// procedure. Possible error values include the following. /// /// /// /// Return code /// Description /// /// /// MMIOERR_CANNOTWRITE /// The contents of the buffer could not be written to disk. /// /// /// // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-mmioclose MMRESULT mmioClose( HMMIO hmmio, UINT fuClose ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioClose")] public static extern MMRESULT mmioClose(HMMIO hmmio, MMIOCLOSE fuClose); ///

/// The mmioCreateChunk function creates a chunk in a RIFF file that was opened by using the mmioOpen function. The new chunk /// is created at the current file position. After the new chunk is created, the current file position is the beginning of the data /// portion of the new chunk. ///

/// File handle of an open RIFF file. /// Pointer to a buffer that receives a MMCKINFO structure containing information about the chunk to be created. /// /// Flags identifying what type of chunk to create. The following values are defined. /// /// /// Value /// Meaning /// /// /// MMIO_CREATELIST /// "LIST" chunk. /// /// /// MMIO_CREATERIFF /// "RIFF" chunk. /// /// /// /// /// Returns MMSYSERR_NOERROR if successful or an error otherwise. Possible error values include the following. /// /// /// Return code /// Description /// /// /// MMIOERR_CANNOTSEEK /// Unable to determine offset of the data portion of the chunk. /// /// /// MMIOERR_CANNOTWRITE /// Unable to write the chunk header. /// /// /// /// /// /// This function cannot insert a chunk into the middle of a file. If an application attempts to create a chunk somewhere other than /// at the end of a file, mmioCreateChunk overwrites existing information in the file. /// /// The MMCKINFO structure pointed to by the lpck parameter should be set up as follows: /// /// /// /// The ckid member specifies the chunk identifier. If wFlags includes MMIO_CREATERIFF or MMIO_CREATELIST, this member will /// be filled by mmioCreateChunk. /// /// /// /// /// The cksize member specifies the size of the data portion of the chunk, including the form type or list type (if any). If /// this value is not correct when the mmioAscend function is called to mark the end of the chunk, mmioAscend corrects the /// chunk size. /// /// /// /// /// The fccType member specifies the form type or list type if the chunk is a "RIFF" or "LIST" chunk. If the chunk is not a /// "RIFF" or "LIST" chunk, this member does not need to be filled in. /// /// /// /// /// The dwDataOffset member does not need to be filled in. The mmioCreateChunk function fills this member with the /// file offset of the data portion of the chunk. /// /// /// /// /// The dwFlags member does not need to be filled in. The mmioCreateChunk function sets the MMIO_DIRTY flag in dwFlags. /// /// /// /// // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-mmiocreatechunk MMRESULT mmioCreateChunk( HMMIO hmmio, // LPMMCKINFO pmmcki, UINT fuCreate ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioCreateChunk")] public static extern MMRESULT mmioCreateChunk(HMMIO hmmio, in MMCKINFO pmmcki, MMIOCREATE fuCreate); ///

/// The mmioDescend function descends into a chunk of a RIFF file that was opened by using the mmioOpen function. It can also /// search for a given chunk. ///

/// File handle of an open RIFF file. /// Pointer to a buffer that receives an MMCKINFO structure. /// /// Pointer to an optional application-defined MMCKINFO structure identifying the parent of the chunk being searched for. If this /// parameter is not NULL, mmioDescend assumes the MMCKINFO structure it refers to was filled when /// mmioDescend was called to descend into the parent chunk, and mmioDescend searches for a chunk within the parent /// chunk. Set this parameter to NULL if no parent chunk is being specified. /// /// /// /// Search flags. If no flags are specified, mmioDescend descends into the chunk beginning at the current file position. The /// following values are defined. /// /// /// /// Value /// Meaning /// /// /// MMIO_FINDCHUNK /// Searches for a chunk with the specified chunk identifier. /// /// /// MMIO_FINDLIST /// Searches for a chunk with the chunk identifier "LIST" and with the specified form type. /// /// /// MMIO_FINDRIFF /// Searches for a chunk with the chunk identifier "RIFF" and with the specified form type. /// /// /// /// /// Returns MMSYSERR_NOERROR if successful or an error otherwise. Possible error values include the following. /// /// /// Return code /// Description /// /// /// MMIOERR_CHUNKNOTFOUND /// The end of the file (or the end of the parent chunk, if given) was reached before the desired chunk was found. /// /// /// /// /// /// A "RIFF" chunk consists of a four-byte chunk identifier (type FOURCC), followed by a four-byte chunk size (type /// DWORD), followed by the data portion of the chunk, followed by a null pad byte if the size of the data portion is odd. If /// the chunk identifier is "RIFF" or "LIST", the first four bytes of the data portion of the chunk are a form type or list type /// (type FOURCC). /// /// /// If you use mmioDescend to search for a chunk, make sure the file position is at the beginning of a chunk before calling /// the function. The search begins at the current file position and continues to the end of the file. If a parent chunk is /// specified, the file position should be somewhere within the parent chunk before calling mmioDescend. In this case, the /// search begins at the current file position and continues to the end of the parent chunk. /// /// /// If mmioDescend is unsuccessful in searching for a chunk, the current file position is undefined. If mmioDescend is /// successful, the current file position is changed. If the chunk is a "RIFF" or "LIST" chunk, the new file position will be just /// after the form type or list type (12 bytes from the beginning of the chunk). For other chunks, the new file position will be the /// start of the data portion of the chunk (8 bytes from the beginning of the chunk). /// /// The mmioDescend function fills the MMCKINFO structure pointed to by the lpck parameter with the following information: /// /// /// /// The ckid member is the chunk. If the MMIO_FINDCHUNK, MMIO_FINDRIFF, or MMIO_FINDLIST flag is specified for wFlags, /// the MMCKINFO structure is also used to pass parameters to mmioDescend. In this case, the ckid member specifies the /// four-character code of the chunk identifier, form type, or list type to search for. /// /// /// /// /// The cksize member is the size, in bytes, of the data portion of the chunk. The size includes the form type or list type /// (if any), but does not include the 8-byte chunk header or the pad byte at the end of the data (if any). /// /// /// /// /// The fccType member is the form type if ckid is "RIFF", or the list type if ckid is "LIST". Otherwise, it is NULL. /// /// /// /// /// The dwDataOffset member is the file offset of the beginning of the data portion of the chunk. If the chunk is a "RIFF" /// chunk or a "LIST" chunk, this member is the offset of the form type or list type. /// /// /// /// /// The dwFlags member contains other information about the chunk. Currently, this information is not used and is set to zero. /// /// /// /// // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-mmiodescend MMRESULT mmioDescend( HMMIO hmmio, LPMMCKINFO // pmmcki, const MMCKINFO *pmmckiParent, UINT fuDescend ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioDescend")] public static extern MMRESULT mmioDescend(HMMIO hmmio, ref MMCKINFO pmmcki, in MMCKINFO pmmckiParent, MMIODESC fuDescend); ///

The mmioFlush function writes the I/O buffer of a file to disk if the buffer has been written to.

/// File handle of a file opened by using the mmioOpen function. /// /// Flag determining how the flush is carried out. It can be zero or the following. /// /// /// Value /// Description /// /// /// MMIO_EMPTYBUF /// Empties the buffer after writing it to the disk. /// /// /// /// /// Returns zero if successful or an error otherwise. Possible error values include the following. /// /// /// Return code /// Description /// /// /// MMIOERR_CANNOTWRITE /// The contents of the buffer could not be written to disk. /// /// /// /// /// Closing a file with the mmioClose function automatically flushes its buffer. /// /// If there is insufficient disk space to write the buffer, mmioFlush fails, even if the preceding calls of the mmioWrite /// function were successful. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-mmioflush MMRESULT mmioFlush( HMMIO hmmio, UINT fuFlush ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioFlush")] public static extern MMRESULT mmioFlush(HMMIO hmmio, MMIOFLUSH fuFlush); ///

/// The mmioGetInfo function retrieves information about a file opened by using the mmioOpen function. This information /// allows the application to directly access the I/O buffer, if the file is opened for buffered I/O. ///

/// File handle of the file. /// /// Pointer to a buffer that receives an MMIOINFO structure that mmioGetInfo fills with information about the file. /// /// Reserved; must be zero. /// Returns zero if successful or an error otherwise. /// /// /// To directly access the I/O buffer of a file opened for buffered I/O, use the following members of the MMIOINFO structure filled /// by mmioGetInfo: /// /// /// /// /// The pchNext member points to the next byte in the buffer that can be read or written. When you read or write, increment /// pchNext by the number of bytes read or written. /// /// /// /// The pchEndRead member points to 1 byte past the last valid byte in the buffer that can be read. /// /// /// The pchEndWrite member points to 1 byte past the last location in the buffer that can be written. /// /// /// /// After you read or write to the buffer and modify pchNext, do not call any multimedia file I/O functions except /// mmioAdvance until you call the mmioSetInfo function. Call mmioSetInfo when you are finished directly accessing the buffer. /// /// /// When you reach the end of the buffer specified by the pchEndRead or pchEndWrite member, call mmioAdvance to fill /// the buffer from the disk or write the buffer to the disk. The mmioAdvance function updates the pchNext, /// pchEndRead, and pchEndWrite members in the MMIOINFO structure for the file. /// /// /// Before calling mmioAdvance or mmioSetInfo to flush a buffer to disk, set the MMIO_DIRTY flag in the dwFlags member of the /// MMIOINFO structure for the file. Otherwise, the buffer will not be written to disk. /// /// /// Do not decrement pchNext or modify any members in the MMIOINFO structure other than pchNext and dwFlags. Do /// not set any flags in dwFlags except MMIO_DIRTY. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-mmiogetinfo MMRESULT mmioGetInfo( HMMIO hmmio, LPMMIOINFO // pmmioinfo, UINT fuInfo ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioGetInfo")] public static extern MMRESULT mmioGetInfo(HMMIO hmmio, out MMIOINFO pmmioinfo, uint fuInfo = 0); ///

/// The mmioInstallIOProc function installs or removes a custom I/O procedure. This function also locates an installed I/O /// procedure, using its corresponding four-character code. ///

/// /// Four-character code identifying the I/O procedure to install, remove, or locate. All characters in this code should be uppercase. /// /// /// Pointer to the I/O procedure to install. To remove or locate an I/O procedure, set this parameter to NULL. For more /// information about the I/O procedure, see MMIOProc. /// /// /// Flag indicating whether the I/O procedure is being installed, removed, or located. The following values are defined. /// /// /// Value /// Meaning /// /// /// MMIO_FINDPROC /// Searches for the specified I/O procedure. /// /// /// MMIO_GLOBALPROC /// /// This flag is a modifier to the MMIO_INSTALLPROC flag and indicates the I/O procedure should be installed for global use. This /// flag is ignored if MMIO_FINDPROC or MMIO_REMOVEPROC is specified. /// /// /// /// MMIO_INSTALLPROC /// Installs the specified I/O procedure. /// /// /// MMIO_REMOVEPROC /// Removes the specified I/O procedure. /// /// /// /// Returns the address of the I/O procedure installed, removed, or located. Returns NULL if there is an error. // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-mmioinstallioproc LPMMIOPROC mmioInstallIOProc( FOURCC // fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags ); [DllImport(Lib_Winmm, SetLastError = false, CharSet = CharSet.Auto)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioInstallIOProc")] [return: MarshalAs(UnmanagedType.FunctionPtr)] public static extern MMIOPROC mmioInstallIOProc(uint fccIOProc, [In, Optional] MMIOPROC pIOProc, MMIOINST dwFlags); ///

/// /// The mmioOpen function opens a file for unbuffered or buffered I/O; creates a file; deletes a file; or checks whether a /// file exists. The file can be a standard file, a memory file, or an element of a custom storage system. The handle returned by /// mmioOpen is not a standard file handle; do not use it with any file I/O functions other than multimedia file I/O functions. /// /// Note This function is deprecated. Applications should call CreateFile to create or open files. ///

/// /// /// Pointer to a buffer that contains the name of the file. If no I/O procedure is specified to open the file, the file name /// determines how the file is opened, as follows: /// /// /// /// /// If the file name does not contain a plus sign (+), it is assumed to be the name of a standard file (that is, a file whose type /// is not HMMIO). /// /// /// /// /// If the file name is of the form EXAMPLE.EXT+ABC, the extension EXT is assumed to identify an installed I/O procedure which is /// called to perform I/O on the file. For more information, see mmioInstallIOProc. /// /// /// /// /// If the file name is NULL and no I/O procedure is given, the adwInfo member of the MMIOINFO structure is assumed to /// be the standard (non- HMMIO) file handle of a currently open file. /// /// /// /// The file name should not be longer than 128 characters, including the terminating NULL character. /// When opening a memory file, set szFilename to NULL. /// /// /// Pointer to an MMIOINFO structure containing extra parameters used by mmioOpen. Unless you are opening a memory file, /// specifying the size of a buffer for buffered I/O, or specifying an uninstalled I/O procedure to open a file, this parameter /// should be NULL. If this parameter is not NULL, all unused members of the MMIOINFO structure it references /// must be set to zero, including the reserved members. /// /// /// /// Flags for the open operation. The MMIO_READ, MMIO_WRITE, and MMIO_READWRITE flags are mutually exclusive � only one should be /// specified. The MMIO_COMPAT, MMIO_EXCLUSIVE, MMIO_DENYWRITE, MMIO_DENYREAD, and MMIO_DENYNONE flags are file-sharing flags. The /// following values are defined. /// /// /// /// Value /// Meaning /// /// /// MMIO_ALLOCBUF /// /// Opens a file for buffered I/O. To allocate a buffer larger or smaller than the default buffer size (8K, defined as /// MMIO_DEFAULTBUFFER), set the cchBuffer member of the MMIOINFO structure to the desired buffer size. If cchBuffer is zero, the /// default buffer size is used. If you are providing your own I/O buffer, this flag should not be used. /// /// /// /// MMIO_COMPAT /// /// Opens the file with compatibility mode, allowing any process on a given machine to open the file any number of times. If the /// file has been opened with any of the other sharing modes, mmioOpen fails. /// /// /// /// MMIO_CREATE /// /// Creates a new file. If the file already exists, it is truncated to zero length. For memory files, this flag indicates the end of /// the file is initially at the start of the buffer. /// /// /// /// MMIO_DELETE /// /// Deletes a file. If this flag is specified, szFilename should not be NULL. The return value is TRUE (cast to HMMIO) if the file /// was deleted successfully or FALSE otherwise. Do not call the mmioClose function for a file that has been deleted. If this flag /// is specified, all other flags that open files are ignored. /// /// /// /// MMIO_DENYNONE /// /// Opens the file without denying other processes read or write access to the file. If the file has been opened in compatibility /// mode by any other process, mmioOpen fails. /// /// /// /// MMIO_DENYREAD /// /// Opens the file and denies other processes read access to the file. If the file has been opened in compatibility mode or for read /// access by any other process, mmioOpen fails. /// /// /// /// MMIO_DENYWRITE /// /// Opens the file and denies other processes write access to the file. If the file has been opened in compatibility mode or for /// write access by any other process, mmioOpen fails. /// /// /// /// MMIO_EXCLUSIVE /// /// Opens the file and denies other processes read and write access to the file. If the file has been opened in any other mode for /// read or write access, even by the current process, mmioOpen fails. /// /// /// /// MMIO_EXIST /// /// Determines whether the specified file exists and creates a fully qualified file name from the path specified in szFilename. The /// return value is TRUE (cast to HMMIO) if the qualification was successful and the file exists or FALSE otherwise. The file is not /// opened, and the function does not return a valid multimedia file I/O file handle, so do not attempt to close the file. /// /// /// /// MMIO_GETTEMP /// /// Creates a temporary file name, optionally using the parameters passed in szFilename. For example, you can specify "C:F" to /// create a temporary file residing on drive C, starting with letter "F". The resulting file name is copied to the buffer pointed /// to by szFilename. The buffer must be large enough to hold at least 128 characters. If the temporary file name was created /// successfully, the return value is MMSYSERR_NOERROR (cast to HMMIO). Otherwise, the return value is MMIOERR_FILENOTFOUND /// otherwise. The file is not opened, and the function does not return a valid multimedia file I/O file handle, so do not attempt /// to close the file. This flag overrides all other flags. /// /// /// /// MMIO_PARSE /// /// Creates a fully qualified file name from the path specified in szFilename. The fully qualified name is copied to the buffer /// pointed to by szFilename. The buffer must be large enough to hold at least 128 characters. If the function succeeds, the return /// value is TRUE (cast to HMMIO). Otherwise, the return value is FALSE. The file is not opened, and the function does not return a /// valid multimedia file I/O file handle, so do not attempt to close the file. If this flag is specified, all flags that open files /// are ignored. /// /// /// /// MMIO_READ /// Opens the file for reading only. This is the default if MMIO_WRITE and MMIO_READWRITE are not specified. /// /// /// MMIO_READWRITE /// Opens the file for reading and writing. /// /// /// MMIO_WRITE /// Opens the file for writing only. /// /// /// /// /// /// Returns a handle of the opened file. If the file cannot be opened, the return value is NULL. If lpmmioinfo is not /// NULL, the wErrorRet member of the MMIOINFO structure will contain one of the following error values. /// /// /// /// Return code /// Description /// /// /// MMIOERR_ACCESSDENIED /// The file is protected and cannot be opened. /// /// /// MMIOERR_INVALIDFILE /// Another failure condition occurred. This is the default error for an open-file failure. /// /// /// MMIOERR_NETWORKERROR /// The network is not responding to the request to open a remote file. /// /// /// MMIOERR_PATHNOTFOUND /// The directory specification is incorrect. /// /// /// MMIOERR_SHARINGVIOLATION /// The file is being used by another application and is unavailable. /// /// /// MMIOERR_TOOMANYOPENFILES /// The number of files simultaneously open is at a maximum level. The system has run out of available file handles. /// /// /// /// /// /// If lpmmioinfo points to an MMIOINFO structure, initialize the members of the structure as follows. All unused members must be /// set to zero, including reserved members. /// /// /// /// /// To request that a file be opened with an installed I/O procedure, set fccIOProc to the four-character code of the I/O /// procedure, and set pIOProc to NULL. /// /// /// /// /// To request that a file be opened with an uninstalled I/O procedure, set IOProc to point to the I/O procedure, and set /// fccIOProc to NULL. /// /// /// /// /// To request that mmioOpen determine which I/O procedure to use to open the file based on the file name contained in /// szFilename, set fccIOProc and pIOProc to NULL. This is the default behavior if no MMIOINFO structure is specified. /// /// /// /// /// To open a memory file using an internally allocated and managed buffer, set pchBuffer to NULL, fccIOProc to /// FOURCC_MEM, cchBuffer to the initial size of the buffer, and adwInfo to the incremental expansion size of the /// buffer. This memory file will automatically be expanded in increments of the number of bytes specified in adwInfo when /// necessary. Specify the MMIO_CREATE flag for the dwOpenFlags parameter to initially set the end of the file to be the beginning /// of the buffer. /// /// /// /// /// To open a memory file using an application-supplied buffer, set pchBuffer to point to the memory buffer, fccIOProc /// to FOURCC_MEM, cchBuffer to the size of the buffer, and adwInfo to the incremental expansion size of the buffer. /// The expansion size in adwInfo should be nonzero only if pchBuffer is a pointer obtained by calling the GlobalAlloc /// and GlobalLock functions; in this case, the GlobalReAlloc function will be called to expand the buffer. In other words, if /// pchBuffer points to a local or global array or a block of memory in the local heap, adwInfo must be zero. Specify /// the MMIO_CREATE flag for the dwOpenFlags parameter to initially set the end of the file to be the beginning of the buffer. /// Otherwise, the entire block of memory is considered readable. /// /// /// /// /// To use a currently open standard file handle (that is, a file handle that does not have the HMMIO type) with multimedia /// file I/O services, set fccIOProc to FOURCC_DOS, pchBuffer to NULL, and adwInfo to the standard file /// handle. Offsets within the file will be relative to the beginning of the file and are not related to the position in the /// standard file at the time mmioOpen is called; the initial multimedia file I/O offset will be the same as the offset in /// the standard file when mmioOpen is called. To close the multimedia file I/O file handle without closing the standard file /// handle, pass the MMIO_FHOPEN flag to mmioClose. /// /// /// /// /// You must call mmioClose to close a file opened by using mmioOpen. Open files are not automatically closed when an /// application exits. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-mmioopen HMMIO mmioOpen( LPSTR pszFileName, LPMMIOINFO // pmmioinfo, DWORD fdwOpen ); [DllImport(Lib_Winmm, SetLastError = false, CharSet = CharSet.Auto)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioOpen")] public static extern HMMIO mmioOpen([In, Out, MarshalAs(UnmanagedType.LPTStr)] StringBuilder pszFileName, ref MMIOINFO pmmioinfo, MMIO fdwOpen); ///

The mmioRead function reads a specified number of bytes from a file opened by using the mmioOpen function.

/// File handle of the file to be read. /// Pointer to a buffer to contain the data read from the file. /// Number of bytes to read from the file. /// /// Returns the number of bytes actually read. If the end of the file has been reached and no more bytes can be read, the return /// value is 0. If there is an error reading from the file, the return value is �1. /// // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-mmioread LONG mmioRead( HMMIO hmmio, HPSTR pch, LONG cch ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioRead")] public static extern int mmioRead(HMMIO hmmio, [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] byte[] pch, int cch); ///

The mmioRename function renames the specified file.

/// Pointer to a string containing the file name of the file to rename. /// Pointer to a string containing the new file name. /// /// Pointer to an MMIOINFO structure containing extra parameters used by mmioRename. If this parameter is not NULL, /// all unused members of the MMIOINFO structure it references must be set to zero, including the reserved members. /// /// Flags for the rename operation. This parameter should be set to zero. /// /// Returns zero if the file was renamed. Otherwise, returns an error code returned from mmioRename or from the I/O procedure. /// // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-mmiorename MMRESULT mmioRename( LPCSTR pszFileName, // LPCSTR pszNewFileName, const MMIOINFO *pmmioinfo, DWORD fdwRename ); [DllImport(Lib_Winmm, SetLastError = false, CharSet = CharSet.Auto)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioRename")] public static extern MMRESULT mmioRename([MarshalAs(UnmanagedType.LPTStr)] string pszFileName, [MarshalAs(UnmanagedType.LPTStr)] string pszNewFileName, in MMIOINFO pmmioinfo, uint fdwRename = 0); ///

The mmioRename function renames the specified file.

The mmioSeek function changes the current file position in a file opened by using the mmioOpen function.

/// File handle of the file to seek in. /// Offset to change the file position. /// /// Flags indicating how the offset specified by lOffset is interpreted. The following values are defined: /// /// /// Name /// Description /// /// /// SEEK_CUR /// Seeks to lOffset bytes from the current file position. /// /// /// SEEK_END /// Seeks to lOffset bytes from the end of the file. /// /// /// SEEK_SET /// Seeks to lOffset bytes from the beginning of the file. /// /// /// /// /// Returns the new file position, in bytes, relative to the beginning of the file. If there is an error, the return value is �1. /// /// /// /// Seeking to an invalid location in the file, such as past the end of the file, might not cause mmioSeek to return an /// error, but it might cause subsequent I/O operations on the file to fail. /// /// To locate the end of a file, call mmioSeek with lOffset set to zero and iOrigin set to SEEK_END. /// // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-mmioseek LONG mmioSeek( HMMIO hmmio, LONG lOffset, int // iOrigin ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioSeek")] public static extern int mmioSeek(HMMIO hmmio, int lOffset, int iOrigin); ///

The mmioSendMessage function sends a message to the I/O procedure associated with the specified file.

/// File handle for a file opened by using the mmioOpen function. /// Message to send to the I/O procedure. /// Parameter for the message. /// Parameter for the message. /// /// Returns a value that corresponds to the message. If the I/O procedure does not recognize the message, the return value should be zero. /// /// /// Use this function to send custom user-defined messages. Do not use it to send the MMIOM_OPEN, MMIOM_CLOSE, MMIOM_READ, /// MMIOM_WRITE, MMIOM_WRITEFLUSH, or MMIOM_SEEK messages. Define custom messages to be greater than or equal to the MMIOM_USER constant. /// // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-mmiosendmessage LRESULT mmioSendMessage( HMMIO hmmio, // UINT uMsg, LPARAM lParam1, LPARAM lParam2 ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioSendMessage")] public static extern IntPtr mmioSendMessage(HMMIO hmmio, uint uMsg, IntPtr lParam1, IntPtr lParam2); ///

/// The mmioSetBuffer function enables or disables buffered I/O, or changes the buffer or buffer size for a file opened by /// using the mmioOpen function. ///

/// File handle of the file. /// /// Pointer to an application-defined buffer to use for buffered I/O. If this parameter is NULL, mmioSetBuffer /// allocates an internal buffer for buffered I/O. /// /// /// Size, in characters, of the application-defined buffer, or the size of the buffer for mmioSetBuffer to allocate. /// /// Reserved; must be zero. /// /// /// Returns zero if successful or an error otherwise. If an error occurs, the file handle remains valid. The following values are defined. /// /// /// /// Return code /// Description /// /// /// MMIOERR_CANNOTWRITE /// The contents of the old buffer could not be written to disk, so the operation was aborted. /// /// /// MMIOERR_OUTOFMEMORY /// The new buffer could not be allocated, probably due to a lack of available memory. /// /// /// /// /// To enable buffering using an internal buffer, set pchBuffer to NULL and cchBuffer to the desired buffer size. /// To supply your own buffer, set pchBuffer to point to the buffer, and set cchBuffer to the size of the buffer. /// To disable buffered I/O, set pchBuffer to NULL and cchBuffer to zero. /// /// If buffered I/O is already enabled using an internal buffer, you can reallocate the buffer to a different size by setting /// pchBuffer to NULL and cchBuffer to the new buffer size. The contents of the buffer can be changed after resizing. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-mmiosetbuffer MMRESULT mmioSetBuffer( HMMIO hmmio, LPSTR // pchBuffer, LONG cchBuffer, UINT fuBuffer ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioSetBuffer")] public static extern MMRESULT mmioSetBuffer(HMMIO hmmio, [Out, MarshalAs(UnmanagedType.LPStr)] StringBuilder pchBuffer, int cchBuffer, uint fuBuffer = 0); ///

/// The mmioSetInfo function updates the information retrieved by the mmioGetInfo function about a file opened by using the /// mmioOpen function. Use this function to terminate direct buffer access of a file opened for buffered I/O. ///

/// File handle of the file. /// Pointer to an MMIOINFO structure filled with information by the mmioGetInfo function. /// Reserved; must be zero. /// Returns zero if successful or an error otherwise. /// /// If you have written to the file I/O buffer, set the MMIO_DIRTY flag in the dwFlags member of the MMIOINFO structure /// before calling mmioSetInfo to terminate direct buffer access. Otherwise, the buffer will not get flushed to disk. /// // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-mmiosetinfo MMRESULT mmioSetInfo( HMMIO hmmio, // LPCMMIOINFO pmmioinfo, UINT fuInfo ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioSetInfo")] public static extern MMRESULT mmioSetInfo(HMMIO hmmio, in MMIOINFO pmmioinfo, uint fuInfo = 0); ///

The mmioStringToFOURCC function converts a null-terminated string to a four-character code.

/// Pointer to a null-terminated string to convert to a four-character code. /// /// Flags for the conversion. The following value is defined: /// /// /// Value /// Meaning /// /// /// MMIO_TOUPPER /// Converts all characters to uppercase. /// /// /// /// Returns the four-character code created from the given string. /// /// This function copies the string to a four-character code and pads it with space characters or truncates it if necessary. It does /// not check whether the code it returns is valid. /// // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-mmiostringtofourcc FOURCC mmioStringToFOURCC( LPCSTR sz, // UINT uFlags ); [DllImport(Lib_Winmm, SetLastError = false, CharSet = CharSet.Auto)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioStringToFOURCC")] public static extern uint mmioStringToFOURCC([MarshalAs(UnmanagedType.LPTStr)] string sz, MMIOCONV uFlags); ///

The mmioWrite function writes a specified number of bytes to a file opened by using the mmioOpen function.

/// File handle of the file. /// Pointer to the buffer to be written to the file. /// Number of bytes to write to the file. /// Returns the number of bytes actually written. If there is an error writing to the file, the return value is -1. /// The current file position is incremented by the number of bytes written. // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-mmiowrite LONG mmioWrite( HMMIO hmmio, const char _huge // *pch, LONG cch ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.mmioWrite")] public static extern int mmioWrite(HMMIO hmmio, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] byte[] pch, int cch); ///

/// Opens an instance of an installable driver and initializes the instance using either the driver's default settings or a /// driver-specific value. ///

/// /// Address of a null-terminated, wide-character string that specifies the filename of an installable driver or the name of a /// registry value associated with the installable driver. (This value must have been previously set when the driver was installed.) /// /// /// Address of a null-terminated, wide-character string that specifies the name of the registry key containing the registry value /// given by the lpDriverName parameter. If lpSectionName is NULL, the registry key is assumed to be Drivers32. /// /// /// 32-bit driver-specific value. This value is passed as the lParam2 parameter to the DriverProc function of the installable driver. /// /// Returns the handle of the installable driver instance if successful or NULL otherwise. // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-opendriver HDRVR OpenDriver( LPCWSTR szDriverName, // LPCWSTR szSectionName, LPARAM lParam2 ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.OpenDriver")] public static extern SafeHDRVR OpenDriver([MarshalAs(UnmanagedType.LPWStr)] string szDriverName, [Optional, MarshalAs(UnmanagedType.LPWStr)] string szSectionName, [In, Optional] IntPtr lParam2); ///

Sends the specified message to the installable driver.

/// /// Handle of the installable driver instance. The handle must been previously created by using the OpenDriver function. /// /// /// Driver message value. It can be a custom message value or one of these standard message values. /// /// /// Value /// Meaning /// /// /// DRV_QUERYCONFIGURE /// /// Queries an installable driver about whether it supports the DRV_CONFIGURE message and can display a configuration dialog box. /// /// /// /// DRV_CONFIGURE /// /// Notifies an installable driver that it should display a configuration dialog box. (This message should only be sent if the /// driver returns a nonzero value when the DRV_QUERYCONFIGURE message is processed.) /// /// /// /// DRV_INSTALL /// Notifies an installable driver that it has been successfully installed. /// /// /// DRV_REMOVE /// Notifies an installable driver that it is about to be removed from the system. /// /// /// /// 32-bit message-dependent information. /// 32-bit message-dependent information. /// Returns nonzero if successful or zero otherwise. // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-senddrivermessage LRESULT SendDriverMessage( HDRVR // hDriver, UINT message, LPARAM lParam1, LPARAM lParam2 ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.SendDriverMessage")] public static extern IntPtr SendDriverMessage(HDRVR hDriver, DRV message, IntPtr lParam1, IntPtr lParam2); ///

Opens the specified sound event.

/// The name of the sound event. /// The application associated with the sound event. /// Flags for playing the sound. The following values are defined. /// Receives the handle to the sound. /// If this function succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. // https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/nf-mmiscapi-sndopensound LONG sndOpenSound( LPCWSTR EventName, // LPCWSTR AppName, INT32 Flags, PHANDLE FileHandle ); [DllImport(Lib_Winmm, SetLastError = false, ExactSpelling = true)] [PInvokeData("mmiscapi.h", MSDNShortId = "NF:mmiscapi.sndOpenSound")] public static extern int sndOpenSound([MarshalAs(UnmanagedType.LPWStr)] string EventName, [MarshalAs(UnmanagedType.LPWStr)] string AppName, int Flags, out IntPtr FileHandle); ///

Contains the registry key and value names associated with the installable driver.

// https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/ns-mmiscapi-drvconfiginfo typedef struct tagDRVCONFIGINFO { DWORD // dwDCISize; LPCWSTR lpszDCISectionName; LPCWSTR lpszDCIAliasName; } DRVCONFIGINFO, *PDRVCONFIGINFO, *NPDRVCONFIGINFO, *LPDRVCONFIGINFO; [PInvokeData("mmiscapi.h", MSDNShortId = "NS:mmiscapi.tagDRVCONFIGINFO")] [StructLayout(LayoutKind.Sequential)] public struct DRVCONFIGINFO { ///

Size of the structure, in bytes.

public uint dwDCISize; ///

/// Address of a null-terminated, wide-character string specifying the name of the registry key associated with the driver. ///

[MarshalAs(UnmanagedType.LPWStr)] public string lpszDCISectionName; ///

/// Address of a null-terminated, wide-character string specifying the name of the registry value associated with the driver. ///

[MarshalAs(UnmanagedType.LPWStr)] public string lpszDCIAliasName; } ///

Provides a handle to an installable driver.

[StructLayout(LayoutKind.Sequential)] public struct HDRVR : IHandle { private readonly IntPtr handle; ///

Initializes a new instance of the struct.

/// An object that represents the pre-existing handle to use. public HDRVR(IntPtr preexistingHandle) => handle = preexistingHandle; ///

Returns an invalid handle by instantiating a object with .

public static HDRVR NULL => new(IntPtr.Zero); ///

Gets a value indicating whether this instance is a null handle.

public bool IsNull => handle == IntPtr.Zero; ///

Performs an explicit conversion from to .

/// The handle. /// The result of the conversion. public static explicit operator IntPtr(HDRVR h) => h.handle; ///

Performs an implicit conversion from to .

/// The pointer to a handle. /// The result of the conversion. public static implicit operator HDRVR(IntPtr h) => new(h); ///

Implements the operator !=.

/// The first handle. /// The second handle. /// The result of the operator. public static bool operator !=(HDRVR h1, HDRVR h2) => !(h1 == h2); ///

Implements the operator ==.

/// The first handle. /// The second handle. /// The result of the operator. public static bool operator ==(HDRVR h1, HDRVR h2) => h1.Equals(h2); /// public override bool Equals(object obj) => obj is HDRVR h && handle == h.handle; /// public override int GetHashCode() => handle.GetHashCode(); /// public IntPtr DangerousGetHandle() => handle; } ///

Provides a handle to a MMIO device.

[StructLayout(LayoutKind.Sequential)] public struct HMMIO : IHandle { private readonly IntPtr handle; ///

Initializes a new instance of the struct.

/// An object that represents the pre-existing handle to use. public HMMIO(IntPtr preexistingHandle) => handle = preexistingHandle; ///

Returns an invalid handle by instantiating a object with .

public static HMMIO NULL => new(IntPtr.Zero); ///

Gets a value indicating whether this instance is a null handle.

public bool IsNull => handle == IntPtr.Zero; ///

Performs an explicit conversion from to .

/// The handle. /// The result of the conversion. public static explicit operator IntPtr(HMMIO h) => h.handle; ///

Performs an implicit conversion from to .

/// The pointer to a handle. /// The result of the conversion. public static implicit operator HMMIO(IntPtr h) => new(h); ///

Implements the operator !=.

/// The first handle. /// The second handle. /// The result of the operator. public static bool operator !=(HMMIO h1, HMMIO h2) => !(h1 == h2); ///

Implements the operator ==.

/// The first handle. /// The second handle. /// The result of the operator. public static bool operator ==(HMMIO h1, HMMIO h2) => h1.Equals(h2); /// public override bool Equals(object obj) => obj is HMMIO h && handle == h.handle; /// public override int GetHashCode() => handle.GetHashCode(); /// public IntPtr DangerousGetHandle() => handle; } ///

The MMCKINFO structure contains information about a chunk in a RIFF file.

// https://docs.microsoft.com/en-us/windows/win32/api/mmiscapi/ns-mmiscapi-mmckinfo typedef struct _MMCKINFO { FOURCC ckid; DWORD // cksize; FOURCC fccType; DWORD dwDataOffset; DWORD dwFlags; } MMCKINFO, *PMMCKINFO, *NPMMCKINFO, *LPMMCKINFO; [PInvokeData("mmiscapi.h", MSDNShortId = "NS:mmiscapi._MMCKINFO")] [StructLayout(LayoutKind.Sequential)] public struct MMCKINFO { ///

Chunk identifier.

public uint ckid; ///

/// Size, in bytes, of the data member of the chunk. The size of the data member does not include the 4-byte chunk identifier, /// the 4-byte chunk size, or the optional pad byte at the end of the data member. ///

public uint cksize; ///

Form type for "RIFF" chunks or the list type for "LIST" chunks.

public uint fccType; ///

File offset of the beginning of the chunk's data member, relative to the beginning of the file.

public uint dwDataOffset; ///

/// Flags specifying additional information about the chunk. It can be zero or the following flag: /// /// /// Name /// Description /// /// /// MMIO_DIRTY /// /// The length of the chunk might have changed and should be updated by the mmioAscend function. This flag is set when a chunk /// is created by using the mmioCreateChunk function. /// /// /// ///

public MMIO dwFlags; } ///

The MMIOINFO structure contains the current state of a file opened by using the mmioOpen function.

// https://docs.microsoft.com/en-us/previous-versions/dd757322(v=vs.85) typedef struct { DWORD dwFlags; FOURCC fccIOProc; LPMMIOPROC // pIOProc; UINT wErrorRet; HTASK hTask; LONG cchBuffer; HPSTR pchBuffer; HPSTR pchNext; HPSTR pchEndRead; HPSTR pchEndWrite; LONG // lBufOffset; LONG lDiskOffset; DWORD adwInfo[4]; DWORD dwReserved1; DWORD dwReserved2; HMMIO hmmio; } MMIOINFO; [PInvokeData("Mmsystem.h")] [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] public struct MMIOINFO { ///

Flags specifying how a file was opened.

public MMIO dwFlags; ///

/// Four-character code identifying the file's I/O procedure. If the I/O procedure is not an installed I/O procedure, this /// member is NULL. ///

public uint fccIOProc; ///

Pointer to file's IO procedure.

[MarshalAs(UnmanagedType.FunctionPtr)] public MMIOPROC pIOProc; ///

/// Extended error value from the mmioOpen function if it returns NULL. This member is not used to return extended error /// information from any other functions. ///

public uint wErrorRet; ///

/// Handle to a local I/O procedure. Media Control Interface (MCI) devices that perform file I/O in the background and need an /// I/O procedure can locate a local I/O procedure with this handle. ///

public HTASK hTask; ///

Size, in bytes, of the file's I/O buffer. If the file does not have an I/O buffer, this member is zero.

public int cchBuffer; ///

Pointer to the file's I/O buffer. If the file is unbuffered, this member is NULL.

public StrPtrAnsi pchBuffer; ///

/// Pointer to the next location in the I/O buffer to be read or written. If no more bytes can be read without calling the /// mmioAdvance or mmioRead function, this member points to the pchEndRead member. If no more bytes can be written without /// calling the mmioAdvance or mmioWrite function, this member points to the pchEndWrite member. ///

public StrPtrAnsi pchNext; ///

Pointer to the location that is 1 byte past the last location in the buffer that can be read.

public StrPtrAnsi pchEndRead; ///

Pointer to the location that is 1 byte past the last location in the buffer that can be written.

public StrPtrAnsi pchEndWrite; ///

Reserved.

public int lBufOffset; ///

/// Current file position, which is an offset, in bytes, from the beginning of the file. I/O procedures are responsible for /// maintaining this member. ///

public int lDiskOffset; ///

/// State information maintained by the I/O procedure. I/O procedures can also use these members to transfer information from /// the application to the I/O procedure when the application opens a file. ///

[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] public uint[] adwInfo; ///

Reserved.

public uint dwReserved1; ///

Reserved.

public uint dwReserved2; ///

/// Handle to the open file, as returned by the mmioOpen function. I/O procedures can use this handle when calling other /// multimedia file I/O functions. ///

public HMMIO hmmio; } ///

Provides a for that is disposed using .

public class SafeHDRVR : SafeHANDLE { ///

Initializes a new instance of the class and assigns an existing handle.

/// An object that represents the pre-existing handle to use. /// /// to reliably release the handle during the finalization phase; otherwise, (not recommended). /// public SafeHDRVR(IntPtr preexistingHandle, bool ownsHandle = true) : base(preexistingHandle, ownsHandle) { } ///

Initializes a new instance of the class.

private SafeHDRVR() : base() { } ///

Performs an implicit conversion from to .

/// The safe handle instance. /// The result of the conversion. public static implicit operator HDRVR(SafeHDRVR h) => h.handle; /// protected override bool InternalReleaseHandle() => CloseDriver(handle) != default; } } }