mmio.c File Reference

#include "winemm.h"

Include dependency graph for mmio.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (mmio)
static LRESULT CALLBACK	mmioDosIOProc (LPMMIOINFO lpmmioinfo, UINT uMessage, LPARAM lParam1, LPARAM lParam2)
static LRESULT CALLBACK	mmioMemIOProc (LPMMIOINFO lpmmioinfo, UINT uMessage, LPARAM lParam1, LPARAM lParam2)
static struct IOProcList *	MMIO_FindProcNode (FOURCC fccIOProc)
static LPMMIOPROC	MMIO_InstallIOProc (FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags, BOOL is_unicode)
static LRESULT	send_message (struct IOProcList *ioProc, LPMMIOINFO mmioinfo, DWORD wMsg, LPARAM lParam1, LPARAM lParam2, BOOL is_unicode)
static FOURCC	MMIO_ParseExtA (LPCSTR szFileName)
static LPWINE_MMIO	MMIO_Get (HMMIO h)
static LPWINE_MMIO	MMIO_Create (void)
static BOOL	MMIO_Destroy (LPWINE_MMIO wm)
static MMRESULT	MMIO_Flush (WINE_MMIO *wm, UINT uFlags)
static LONG	MMIO_GrabNextBuffer (LPWINE_MMIO wm, int for_read)
static MMRESULT	MMIO_SetBuffer (WINE_MMIO *wm, void *pchBuffer, LONG cchBuffer, UINT uFlags)
static HMMIO	MMIO_Open (LPSTR szFileName, MMIOINFO *refmminfo, DWORD dwOpenFlags, BOOL is_unicode)
HMMIO WINAPI	mmioOpenW (LPWSTR szFileName, MMIOINFO *lpmmioinfo, DWORD dwOpenFlags)
HMMIO WINAPI	mmioOpenA (LPSTR szFileName, MMIOINFO *lpmmioinfo, DWORD dwOpenFlags)
MMRESULT WINAPI	mmioClose (HMMIO hmmio, UINT uFlags)
LONG WINAPI	mmioRead (HMMIO hmmio, HPSTR pch, LONG cch)
LONG WINAPI	mmioWrite (HMMIO hmmio, HPCSTR pch, LONG cch)
LONG WINAPI	mmioSeek (HMMIO hmmio, LONG lOffset, INT iOrigin)
MMRESULT WINAPI	mmioGetInfo (HMMIO hmmio, MMIOINFO *lpmmioinfo, UINT uFlags)
MMRESULT WINAPI	mmioSetInfo (HMMIO hmmio, const MMIOINFO *lpmmioinfo, UINT uFlags)
MMRESULT WINAPI	mmioSetBuffer (HMMIO hmmio, LPSTR pchBuffer, LONG cchBuffer, UINT uFlags)
MMRESULT WINAPI	mmioFlush (HMMIO hmmio, UINT uFlags)
MMRESULT WINAPI	mmioAdvance (HMMIO hmmio, MMIOINFO *lpmmioinfo, UINT uFlags)
FOURCC WINAPI	mmioStringToFOURCCA (LPCSTR sz, UINT uFlags)
FOURCC WINAPI	mmioStringToFOURCCW (LPCWSTR sz, UINT uFlags)
LPMMIOPROC WINAPI	mmioInstallIOProcA (FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags)
LPMMIOPROC WINAPI	mmioInstallIOProcW (FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags)
static LRESULT	MMIO_SendMessage (HMMIO hmmio, UINT uMessage, LPARAM lParam1, LPARAM lParam2, BOOL is_unicode)
LRESULT WINAPI	mmioSendMessage (HMMIO hmmio, UINT uMessage, LPARAM lParam1, LPARAM lParam2)
MMRESULT WINAPI	mmioDescend (HMMIO hmmio, LPMMCKINFO lpck, const MMCKINFO *lpckParent, UINT uFlags)
MMRESULT WINAPI	mmioAscend (HMMIO hmmio, LPMMCKINFO lpck, UINT uFlags)
MMRESULT WINAPI	mmioCreateChunk (HMMIO hmmio, MMCKINFO *lpck, UINT uFlags)
MMRESULT WINAPI	mmioRenameA (LPCSTR szFileName, LPCSTR szNewFileName, const MMIOINFO *lpmmioinfo, DWORD dwFlags)
MMRESULT WINAPI	mmioRenameW (LPCWSTR szFileName, LPCWSTR szNewFileName, const MMIOINFO *lpmmioinfo, DWORD dwFlags)

Variables
static WINE_MMIO *	MMIOList
static struct IOProcList	defaultProcs []
static struct IOProcList *	pIOProcListAnchor = &defaultProcs[0]

Function Documentation

MMIO_Create()

static LPWINE_MMIO MMIO_Create ( void  )

static

Definition at line 432 of file mmio.c.

{
    static  WORD    MMIO_counter = 0;
    LPWINE_MMIO     wm;
 
    wm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MMIO));
    if (wm) {
    EnterCriticalSection(&WINMM_cs);
        /* lookup next unallocated WORD handle, with a non NULL value */
    while (++MMIO_counter == 0 || MMIO_Get((HMMIO)(ULONG_PTR)MMIO_counter));
    wm->info.hmmio = (HMMIO)(ULONG_PTR)MMIO_counter;
    wm->lpNext = MMIOList;
    MMIOList = wm;
    LeaveCriticalSection(&WINMM_cs);
    }
    return wm;
}

Referenced by MMIO_Open().

MMIO_Destroy()

static BOOL MMIO_Destroy ( LPWINE_MMIO  wm )

static

Definition at line 455 of file mmio.c.

{
    LPWINE_MMIO*    m;
 
    EnterCriticalSection(&WINMM_cs);
    /* search for the matching one... */
    m = &MMIOList;
    while (*m && *m != wm) m = &(*m)->lpNext;
    /* ...and destroy */
    if (*m) {
    *m = (*m)->lpNext;
    HeapFree(GetProcessHeap(), 0, wm);
    wm = NULL;
    }
    LeaveCriticalSection(&WINMM_cs);
    return wm ? FALSE : TRUE;
}

Referenced by MMIO_Open(), and mmioClose().

MMIO_FindProcNode()

static struct IOProcList * MMIO_FindProcNode ( FOURCC  fccIOProc )

static

Definition at line 227 of file mmio.c.

{
    struct IOProcList*  pListNode;
 
    for (pListNode = pIOProcListAnchor; pListNode; pListNode = pListNode->pNext) {
    if (pListNode->fourCC == fccIOProc) {
        return pListNode;
    }
    }
    return NULL;
}

Referenced by MMIO_InstallIOProc(), MMIO_Open(), and mmioRenameA().

MMIO_Flush()

static MMRESULT MMIO_Flush ( WINE_MMIO *  wm, UINT  uFlags  )

static

Definition at line 476 of file mmio.c.

{
    if (wm->info.cchBuffer && (wm->info.fccIOProc != FOURCC_MEM)) {
    /* not quite sure what to do here, but I'll guess */
    if (wm->info.dwFlags & MMIO_DIRTY) {
            /* FIXME: error handling */
        send_message(wm->ioProc, &wm->info, MMIOM_SEEK, wm->info.lBufOffset, SEEK_SET, FALSE);
        send_message(wm->ioProc, &wm->info, MMIOM_WRITE,
                         (LPARAM)wm->info.pchBuffer,
                         wm->info.pchNext - wm->info.pchBuffer, FALSE);
    }
    if (uFlags & MMIO_EMPTYBUF)
        wm->info.pchNext = wm->info.pchEndRead = wm->info.pchBuffer;
    }
    wm->info.dwFlags &= ~MMIO_DIRTY;
 
    return MMSYSERR_NOERROR;
}

Referenced by MMIO_SetBuffer(), mmioAdvance(), mmioClose(), mmioFlush(), mmioSeek(), and mmioWrite().

MMIO_Get()

static LPWINE_MMIO MMIO_Get ( HMMIO  h )

static

Definition at line 414 of file mmio.c.

{
    LPWINE_MMIO     wm = NULL;
 
    EnterCriticalSection(&WINMM_cs);
    for (wm = MMIOList; wm; wm = wm->lpNext) {
    if (wm->info.hmmio == h)
        break;
    }
    LeaveCriticalSection(&WINMM_cs);
    return wm;
}

Referenced by MMIO_Create(), MMIO_SendMessage(), mmioAdvance(), mmioClose(), mmioFlush(), mmioGetInfo(), mmioRead(), mmioSeek(), mmioSetBuffer(), mmioSetInfo(), and mmioWrite().

MMIO_GrabNextBuffer()

static LONG MMIO_GrabNextBuffer ( LPWINE_MMIO  wm, int  for_read  )

static

Definition at line 498 of file mmio.c.

{
    LONG    size = wm->info.cchBuffer;
 
    TRACE("bo=%x do=%x of=%lx\n",
      wm->info.lBufOffset, wm->info.lDiskOffset,
      send_message(wm->ioProc, &wm->info, MMIOM_SEEK, 0, SEEK_CUR, FALSE));
 
    wm->info.lBufOffset = wm->info.lDiskOffset;
    wm->info.pchNext = wm->info.pchBuffer;
    wm->info.pchEndRead = wm->info.pchBuffer;
    wm->info.pchEndWrite = wm->info.pchBuffer + wm->info.cchBuffer;
 
    wm->bBufferLoaded = TRUE;
    if (for_read) {
    size = send_message(wm->ioProc, &wm->info, MMIOM_READ,
                            (LPARAM)wm->info.pchBuffer, size, FALSE);
    if (size > 0)
        wm->info.pchEndRead += size;
        else
            wm->bBufferLoaded = FALSE;
    }
 
    return size;
}

Referenced by mmioAdvance(), mmioRead(), mmioSeek(), and mmioWrite().

MMIO_InstallIOProc()

static LPMMIOPROC MMIO_InstallIOProc ( FOURCC  fccIOProc, LPMMIOPROC  pIOProc, DWORD  dwFlags, BOOL  is_unicode  )

static

Definition at line 242 of file mmio.c.

{
    LPMMIOPROC          lpProc = NULL;
    struct IOProcList*  pListNode;
    struct IOProcList** ppListNode;
 
    TRACE("(%08x, %p, %08X, %s)\n", fccIOProc, pIOProc, dwFlags, is_unicode ? "unicode" : "ansi");
 
    if (dwFlags & MMIO_GLOBALPROC)
    FIXME("Global procedures not implemented\n");
 
    /* just handle the known procedures for now */
    switch (dwFlags & (MMIO_INSTALLPROC|MMIO_REMOVEPROC|MMIO_FINDPROC)) {
    case MMIO_INSTALLPROC:
    /* Create new entry for the IOProc list */
    pListNode = HeapAlloc(GetProcessHeap(), 0, sizeof(*pListNode));
    if (pListNode) {
        /* Fill in this node */
        pListNode->fourCC = fccIOProc;
        pListNode->pIOProc = pIOProc;
        pListNode->is_unicode = is_unicode;
        pListNode->count = 0;
 
        /* Stick it on the end of the list */
        pListNode->pNext = pIOProcListAnchor;
        pIOProcListAnchor = pListNode;
 
        /* Return this IOProc - that's how the caller knows we succeeded */
        lpProc = pIOProc;
    }
    break;
 
    case MMIO_REMOVEPROC:
    /*
     * Search for the node that we're trying to remove
         * We search for a matching fourCC code if it's non null, or the proc
         * address otherwise
         * note that this method won't find the first item on the list, but
     * since the first two items on this list are ones we won't
     * let the user delete anyway, that's okay
     */
    ppListNode = &pIOProcListAnchor;
    while ((*ppListNode) && 
               ((fccIOProc != 0) ? 
                (*ppListNode)->fourCC != fccIOProc : 
                (*ppListNode)->pIOProc != pIOProc))
        ppListNode = &((*ppListNode)->pNext);
 
    if (*ppListNode) { /* found it */
        /* FIXME: what should be done if an open mmio object uses this proc ?
         * shall we return an error, nuke the mmio object ?
         */
        if ((*ppListNode)->count) {
        ERR("Cannot remove a mmIOProc while in use\n");
        break;
        }
        /* remove it, but only if it isn't builtin */
        if ((*ppListNode) >= defaultProcs &&
        (*ppListNode) < defaultProcs + sizeof(defaultProcs) / sizeof(defaultProcs[0])) {
        WARN("Tried to remove built-in mmio proc. Skipping\n");
        } else {
        /* Okay, nuke it */
        struct IOProcList*  ptmpNode = *ppListNode;
        lpProc = (*ppListNode)->pIOProc;
        *ppListNode = (*ppListNode)->pNext;
        HeapFree(GetProcessHeap(), 0, ptmpNode);
        }
    }
    break;
 
    case MMIO_FINDPROC:
    if ((pListNode = MMIO_FindProcNode(fccIOProc))) {
        lpProc = pListNode->pIOProc;
    }
    break;
    }
 
    return lpProc;
}

Referenced by MMIO_Open(), mmioClose(), mmioInstallIOProcA(), and mmioInstallIOProcW().

MMIO_Open()

static HMMIO MMIO_Open ( LPSTR  szFileName, MMIOINFO *  refmminfo, DWORD  dwOpenFlags, BOOL  is_unicode  )

static

Definition at line 568 of file mmio.c.

{
    LPWINE_MMIO     wm;
    MMIOINFO        mmioinfo;
 
    TRACE("('%s', %p, %08X, %s);\n", szFileName, refmminfo, dwOpenFlags, is_unicode ? "unicode" : "ansi");
 
    if (!refmminfo) {
        refmminfo = &mmioinfo;
 
    mmioinfo.fccIOProc = 0;
    mmioinfo.pIOProc = NULL;
    mmioinfo.pchBuffer = NULL;
    mmioinfo.cchBuffer = 0;
        is_unicode = FALSE;
    }
 
    if (dwOpenFlags & (MMIO_PARSE|MMIO_EXIST)) {
    char    buffer[MAX_PATH];
 
    if (!szFileName)
        return (HMMIO)FALSE;
    if (GetFullPathNameA(szFileName, sizeof(buffer), buffer, NULL) >= sizeof(buffer))
        return (HMMIO)FALSE;
    if ((dwOpenFlags & MMIO_EXIST) && (GetFileAttributesA(buffer) == INVALID_FILE_ATTRIBUTES))
        return (HMMIO)FALSE;
    strcpy(szFileName, buffer);
    return (HMMIO)TRUE;
    }
 
    if ((wm = MMIO_Create()) == NULL)
    return 0;
 
    /* If both params are NULL, then parse the file name if available */
    if (refmminfo->fccIOProc == 0 && refmminfo->pIOProc == NULL) {
    wm->info.fccIOProc = MMIO_ParseExtA(szFileName);
    /* Handle any unhandled/error case. Assume DOS file */
    if (wm->info.fccIOProc == 0)
        wm->info.fccIOProc = FOURCC_DOS;
    if (!(wm->ioProc = MMIO_FindProcNode(wm->info.fccIOProc))) {
        /* If not found, retry with FOURCC_DOS */
        wm->info.fccIOProc = FOURCC_DOS;
        if (!(wm->ioProc = MMIO_FindProcNode(wm->info.fccIOProc)))
        goto error2;
    }
    wm->bTmpIOProc = FALSE;
    }
    /* if just the four character code is present, look up IO proc */
    else if (refmminfo->pIOProc == NULL) {
    wm->info.fccIOProc = refmminfo->fccIOProc;
    if (!(wm->ioProc = MMIO_FindProcNode(wm->info.fccIOProc))) goto error2;
    wm->bTmpIOProc = FALSE;
    }
    /* if IO proc specified, use it and specified four character code */
    else {
    wm->info.fccIOProc = refmminfo->fccIOProc;
    MMIO_InstallIOProc(wm->info.fccIOProc, refmminfo->pIOProc,
                           MMIO_INSTALLPROC, is_unicode);
    if (!(wm->ioProc = MMIO_FindProcNode(wm->info.fccIOProc))) goto error2;
    assert(wm->ioProc->pIOProc == refmminfo->pIOProc);
    wm->bTmpIOProc = TRUE;
    }
 
    wm->ioProc->count++;
    wm->info.dwFlags = dwOpenFlags;
 
    if (dwOpenFlags & MMIO_ALLOCBUF) {
    refmminfo->wErrorRet = MMIO_SetBuffer(wm, refmminfo->pchBuffer,
        refmminfo->cchBuffer ? refmminfo->cchBuffer : MMIO_DEFAULTBUFFER, 0);
    if (refmminfo->wErrorRet != MMSYSERR_NOERROR)
        goto error1;
    } else {
        refmminfo->wErrorRet = MMIO_SetBuffer(wm, refmminfo->pchBuffer, refmminfo->cchBuffer, 0);
    if (refmminfo->wErrorRet != MMSYSERR_NOERROR)
        goto error1;
    }
 
    if (wm->info.fccIOProc == FOURCC_MEM && !(wm->info.dwFlags & MMIO_ALLOCBUF))
        wm->bBufferLoaded = TRUE;
 
    /* see mmioDosIOProc for that one */
    wm->info.adwInfo[0] = refmminfo->adwInfo[0];
 
    /* call IO proc to actually open file */
    refmminfo->wErrorRet = send_message(wm->ioProc, &wm->info, MMIOM_OPEN,
                                        (LPARAM)szFileName, 0, FALSE);
 
    /* grab file size, when possible (FIXME: not 64 bit safe) */
    wm->dwFileSize = GetFileSize((HANDLE)(ULONG_PTR)wm->info.adwInfo[0], NULL);
 
    if (refmminfo->wErrorRet == 0)
    return wm->info.hmmio;
 error1:
    if (wm->ioProc) wm->ioProc->count--;
 error2:
    MMIO_Destroy(wm);
    return 0;
}

Referenced by mmioOpenA(), and mmioOpenW().

MMIO_ParseExtA()

static FOURCC MMIO_ParseExtA ( LPCSTR  szFileName )

static

Definition at line 361 of file mmio.c.

{
    /* Filenames are of the form file.ext{+ABC}
       For now, we take the last '+' if present */
 
    FOURCC ret = 0;
 
    /* Note that ext{Start,End} point to the . and + respectively */
    LPCSTR extEnd;
    LPCSTR extStart;
 
    CHAR ext[5];
 
    TRACE("(%s)\n", debugstr_a(szFileName));
 
    if (!szFileName)
    return ret;
 
    /* Find the last '+' */
    extEnd = strrchr(szFileName,'+');
 
    if (!extEnd) {
        /* No + so just an extension */
        return ret;
    } else {
        /* Find the first '.' before '+' */
        extStart = extEnd - 1;
        while (extStart >= szFileName && *extStart != '.') {
            extStart--;
        }
        if (extStart < szFileName) {
            ERR("No extension in szFileName: %s\n", debugstr_a(szFileName));
            return ret;
        }
    }
 
    if (extEnd - extStart - 1 > 4)
        WARN("Extension length > 4\n");
    lstrcpynA(ext, extStart + 1, min(extEnd-extStart,5));
 
    TRACE("Got extension: %s\n", debugstr_a(ext));
 
    /* FOURCC codes identifying file-extensions must be uppercase */
    ret = mmioStringToFOURCCA(ext, MMIO_TOUPPER);
 
    return ret;
}

Referenced by MMIO_Open(), and mmioRenameA().

MMIO_SendMessage()

static LRESULT MMIO_SendMessage ( HMMIO  hmmio, UINT  uMessage, LPARAM  lParam1, LPARAM  lParam2, BOOL  is_unicode  )

static

Definition at line 1079 of file mmio.c.

{
    LPWINE_MMIO     wm;
 
    TRACE("(%p, %u, %ld, %ld, %s)\n", hmmio, uMessage, lParam1, lParam2, is_unicode ? "unicode" : "ansi");
 
    if (uMessage < MMIOM_USER)
    return MMSYSERR_INVALPARAM;
 
    if ((wm = MMIO_Get(hmmio)) == NULL)
    return MMSYSERR_INVALHANDLE;
 
    return send_message(wm->ioProc, &wm->info, uMessage, lParam1, lParam2, is_unicode);
}

Referenced by mmioSendMessage().

MMIO_SetBuffer()

static MMRESULT MMIO_SetBuffer ( WINE_MMIO *  wm, void *  pchBuffer, LONG  cchBuffer, UINT  uFlags  )

static

Definition at line 527 of file mmio.c.

{
    TRACE("(%p %p %d %u)\n", wm, pchBuffer, cchBuffer, uFlags);
 
    if (cchBuffer > 0xFFFF)
    WARN("Untested handling of huge mmio buffers (%d >= 64k)\n", cchBuffer);
 
    if (MMIO_Flush(wm, 0) != MMSYSERR_NOERROR)
    return MMIOERR_CANNOTWRITE;
 
    /* free previous buffer if allocated */
    if (wm->info.dwFlags & MMIO_ALLOCBUF) {
        HeapFree(GetProcessHeap(), 0, wm->info.pchBuffer);
        wm->info.pchBuffer = NULL;
    wm->info.dwFlags &= ~MMIO_ALLOCBUF;
    }
 
    if (pchBuffer) {
        wm->info.pchBuffer = pchBuffer;
    } else if (cchBuffer) {
    if (!(wm->info.pchBuffer = HeapAlloc(GetProcessHeap(), 0, cchBuffer)))
        return MMIOERR_OUTOFMEMORY;
    wm->info.dwFlags |= MMIO_ALLOCBUF;
    } else {
    wm->info.pchBuffer = NULL;
    }
 
    wm->info.cchBuffer = cchBuffer;
    wm->info.pchNext = wm->info.pchBuffer;
    wm->info.pchEndRead = wm->info.pchBuffer;
    wm->info.pchEndWrite = wm->info.pchBuffer + cchBuffer;
    wm->info.lBufOffset = wm->info.lDiskOffset;
    wm->bBufferLoaded = FALSE;
 
    return MMSYSERR_NOERROR;
}

Referenced by MMIO_Open(), mmioClose(), and mmioSetBuffer().

mmioAdvance()

MMRESULT WINAPI mmioAdvance	(	HMMIO	hmmio,
		MMIOINFO *	lpmmioinfo,
		UINT	uFlags
	)

Definition at line 976 of file mmio.c.

{
    LPWINE_MMIO     wm;
 
    TRACE("hmmio=%p, lpmmioinfo=%p, uFlags=%04X\n", hmmio, lpmmioinfo, uFlags);
 
    /* NOTE: mmioAdvance16 heavily relies on parameters from lpmmioinfo we're using
     * here. be sure if you change something here to check mmioAdvance16 as well
     */
    if ((wm = MMIO_Get(hmmio)) == NULL)
    return MMSYSERR_INVALHANDLE;
 
    if (!wm->info.cchBuffer)
    return MMIOERR_UNBUFFERED;
 
    if (uFlags != MMIO_READ && uFlags != MMIO_WRITE)
    return MMSYSERR_INVALPARAM;
 
    if (uFlags == MMIO_WRITE && (lpmmioinfo->dwFlags & MMIO_DIRTY))
    {
        send_message(wm->ioProc, &wm->info, MMIOM_SEEK, lpmmioinfo->lBufOffset, SEEK_SET, FALSE);
        send_message(wm->ioProc, &wm->info, MMIOM_WRITE, (LPARAM)lpmmioinfo->pchBuffer,
                     lpmmioinfo->pchNext - lpmmioinfo->pchBuffer, FALSE);
        lpmmioinfo->dwFlags &= ~MMIO_DIRTY;
    }
    if (MMIO_Flush(wm, 0) != MMSYSERR_NOERROR)
    return MMIOERR_CANNOTWRITE;
 
    if (lpmmioinfo) {
    wm->dwFileSize = max(wm->dwFileSize, lpmmioinfo->lBufOffset + 
                             (lpmmioinfo->pchNext - lpmmioinfo->pchBuffer));
    }
    MMIO_GrabNextBuffer(wm, uFlags == MMIO_READ);
 
    if (lpmmioinfo) {
    lpmmioinfo->pchNext = lpmmioinfo->pchBuffer;
    lpmmioinfo->pchEndRead  = lpmmioinfo->pchBuffer +
        (wm->info.pchEndRead - wm->info.pchBuffer);
    lpmmioinfo->pchEndWrite = lpmmioinfo->pchBuffer +
        (wm->info.pchEndWrite - wm->info.pchBuffer);
    lpmmioinfo->lDiskOffset = wm->info.lDiskOffset;
    lpmmioinfo->lBufOffset = wm->info.lBufOffset;
    }
    return MMSYSERR_NOERROR;
}

Referenced by test_mmio_buffer_pointer(), test_mmio_end_of_file(), and test_riff_write().

mmioAscend()

MMRESULT WINAPI mmioAscend	(	HMMIO	hmmio,
		LPMMCKINFO	lpck,
		UINT	uFlags
	)

Definition at line 1205 of file mmio.c.

{
    TRACE("(%p, %p, %04X);\n", hmmio, lpck, uFlags);
 
    if (lpck->dwFlags & MMIO_DIRTY) {
    DWORD   dwOldPos, dwNewSize;
 
    TRACE("Chunk is dirty, checking if chunk's size is correct\n");
    dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
    TRACE("dwOldPos=%d lpck->dwDataOffset = %d\n", dwOldPos, lpck->dwDataOffset);
    dwNewSize = dwOldPos - lpck->dwDataOffset;
    if (dwNewSize != lpck->cksize) {
        TRACE("Nope: lpck->cksize=%d dwNewSize=%d\n", lpck->cksize, dwNewSize);
        lpck->cksize = dwNewSize;
 
        /* pad odd size with 0 */
        if (dwNewSize & 1) {
        char ch = 0;
        mmioWrite(hmmio, &ch, 1);
        }
        mmioSeek(hmmio, lpck->dwDataOffset - sizeof(DWORD), SEEK_SET);
        mmioWrite(hmmio, (LPSTR)&dwNewSize, sizeof(DWORD));
    }
    lpck->dwFlags = 0;
    }
 
    mmioSeek(hmmio, lpck->dwDataOffset + ((lpck->cksize + 1) & ~1), SEEK_SET);
 
    return MMSYSERR_NOERROR;
}

Referenced by ANIMATE_GetAviInfo(), AVIFILE_LoadFile(), AVIFILE_SaveFile(), AVIFILE_SaveIndex(), AVIFILE_WriteBlock(), create_wav_file(), FindChunkAndKeepExtras(), IAVIFile_fnEndRecord(), IAVIStream_fnSetFormat(), MCIAVI_GetInfo(), MCIAVI_GetInfoAudio(), MCIAVI_GetInfoVideo(), proc_PlaySound(), test_riff_write(), WAVE_mciCreateRIFFSkeleton(), WAVE_mciReadFmt(), and WAVE_mciSave().

mmioClose()

MMRESULT WINAPI mmioClose	(	HMMIO	hmmio,
		UINT	uFlags
	)

Definition at line 702 of file mmio.c.

{
    LPWINE_MMIO wm;
    MMRESULT    result;
 
    TRACE("(%p, %04X);\n", hmmio, uFlags);
 
    if ((wm = MMIO_Get(hmmio)) == NULL)
    return MMSYSERR_INVALHANDLE;
 
    if ((result = MMIO_Flush(wm, 0)) != MMSYSERR_NOERROR)
    return result;
 
    result = send_message(wm->ioProc, &wm->info, MMIOM_CLOSE, uFlags, 0, FALSE);
 
    MMIO_SetBuffer(wm, NULL, 0, 0);
 
    wm->ioProc->count--;
 
    if (wm->bTmpIOProc)
    MMIO_InstallIOProc(wm->info.fccIOProc, wm->ioProc->pIOProc,
                           MMIO_REMOVEPROC, wm->ioProc->is_unicode);
 
    MMIO_Destroy(wm);
 
    return result;
}

Referenced by ANIMATE_Free(), create_wav_file(), IUnknown_fnRelease(), MCIAVI_CleanUp(), MIDI_mciClose(), MIDI_mciOpen(), PlaySound_Free(), test_mmio_buffer_pointer(), test_mmio_end_of_file(), test_mmioDescend(), test_mmioOpen(), test_mmioOpen_fourcc(), test_mmioSeek(), test_mmioSetBuffer(), test_riff_write(), WAVE_mciClose(), WAVE_mciOpen(), and WAVE_mciSave().

mmioCreateChunk()

MMRESULT WINAPI mmioCreateChunk	(	HMMIO	hmmio,
		MMCKINFO *	lpck,
		UINT	uFlags
	)

Definition at line 1239 of file mmio.c.

{
    DWORD   dwOldPos;
    LONG    size;
    LONG    ix;
 
    TRACE("(%p, %p, %04X);\n", hmmio, lpck, uFlags);
 
    dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
    TRACE("dwOldPos=%d\n", dwOldPos);
 
    if (uFlags == MMIO_CREATELIST)
    lpck->ckid = FOURCC_LIST;
    else if (uFlags == MMIO_CREATERIFF)
    lpck->ckid = FOURCC_RIFF;
 
    TRACE("ckid=%.4s\n", (LPSTR)&lpck->ckid);
 
    size = 2 * sizeof(DWORD);
    lpck->dwDataOffset = dwOldPos + size;
 
    if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST)
    size += sizeof(DWORD);
    lpck->dwFlags = MMIO_DIRTY;
 
    ix = mmioWrite(hmmio, (LPSTR)lpck, size);
    TRACE("after mmioWrite ix = %d req = %d, errno = %d\n", ix, size, errno);
    if (ix != size) {
    mmioSeek(hmmio, dwOldPos, SEEK_SET);
    WARN("return CannotWrite\n");
    return MMIOERR_CANNOTWRITE;
    }
 
    return MMSYSERR_NOERROR;
}

Referenced by AVIFILE_SaveFile(), AVIFILE_SaveIndex(), AVIFILE_WriteBlock(), create_wav_file(), IAVIFile_fnEndRecord(), IAVIStream_fnSetFormat(), test_riff_write(), and WAVE_mciCreateRIFFSkeleton().

mmioDescend()

MMRESULT WINAPI mmioDescend	(	HMMIO	hmmio,
		LPMMCKINFO	lpck,
		const MMCKINFO *	lpckParent,
		UINT	uFlags
	)

Definition at line 1107 of file mmio.c.

{
    DWORD       dwOldPos;
    FOURCC      srchCkId;
    FOURCC      srchType;
 
    TRACE("(%p, %p, %p, %04X);\n", hmmio, lpck, lpckParent, uFlags);
 
    if (lpck == NULL)
    return MMSYSERR_INVALPARAM;
 
    dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
    TRACE("dwOldPos=%d\n", dwOldPos);
 
    if (lpckParent != NULL) {
    TRACE("seek inside parent at %d !\n", lpckParent->dwDataOffset);
    /* EPP: was dwOldPos = mmioSeek(hmmio,lpckParent->dwDataOffset,SEEK_SET); */
    if (dwOldPos < lpckParent->dwDataOffset ||
        dwOldPos >= lpckParent->dwDataOffset + lpckParent->cksize) {
        WARN("outside parent chunk\n");
        return MMIOERR_CHUNKNOTFOUND;
    }
    }
 
    /* The SDK docu says 'ckid' is used for all cases. Real World
     * examples disagree -Marcus,990216.
     */
 
    srchCkId = 0;
    srchType = 0;
 
    /* find_chunk looks for 'ckid' */
    if (uFlags & MMIO_FINDCHUNK)
    srchCkId = lpck->ckid;
 
    /* find_riff and find_list look for 'fccType' */
    if (uFlags & MMIO_FINDLIST)
    {
    srchCkId = FOURCC_LIST;
        srchType = lpck->fccType;
    }
 
    if (uFlags & MMIO_FINDRIFF)
    {
    srchCkId = FOURCC_RIFF;
        srchType = lpck->fccType;
    }
 
    TRACE("searching for %4.4s.%4.4s\n",
          (LPCSTR)&srchCkId, srchType ? (LPCSTR)&srchType : "any");
 
    while (TRUE)
    {
        LONG ix;
 
        ix = mmioRead(hmmio, (LPSTR)lpck, 3 * sizeof(DWORD));
        if (ix < 0 || ix < 2*sizeof(DWORD))
        {
            mmioSeek(hmmio, dwOldPos, SEEK_SET);
            WARN("return ChunkNotFound\n");
            return MMIOERR_CHUNKNOTFOUND;
        }
 
        lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD);
        TRACE("ckid=%4.4s fcc=%4.4s cksize=%08X !\n",
              (LPCSTR)&lpck->ckid,
              srchType ? (LPCSTR)&lpck->fccType:"<na>",
              lpck->cksize);
        if ( (!srchCkId || (srchCkId == lpck->ckid)) &&
             (!srchType || (srchType == lpck->fccType)) )
            break;
 
        dwOldPos = lpck->dwDataOffset + ((lpck->cksize + 1) & ~1);
        mmioSeek(hmmio, dwOldPos, SEEK_SET);
    }
 
    lpck->dwFlags = 0;
    /* If we were looking for RIFF/LIST chunks, the final file position
     * is after the chunkid. If we were just looking for the chunk
     * it is after the cksize. So add 4 in RIFF/LIST case.
     */
    if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST)
    mmioSeek(hmmio, lpck->dwDataOffset + sizeof(DWORD), SEEK_SET);
    else
    {
    mmioSeek(hmmio, lpck->dwDataOffset, SEEK_SET);
    lpck->fccType = 0;
    }
    TRACE("lpck: ckid=%.4s, cksize=%d, dwDataOffset=%d fccType=%08X (%.4s)!\n",
      (LPSTR)&lpck->ckid, lpck->cksize, lpck->dwDataOffset,
      lpck->fccType, srchType?(LPSTR)&lpck->fccType:"");
    return MMSYSERR_NOERROR;
}

Referenced by ANIMATE_GetAviInfo(), AVIFILE_LoadFile(), FindChunkAndKeepExtras(), MCIAVI_GetInfo(), MCIAVI_GetInfoAudio(), MCIAVI_GetInfoVideo(), MIDI_mciOpen(), proc_PlaySound(), test_mmioDescend(), WAVE_mciOpenFile(), and WAVE_mciReadFmt().

mmioDosIOProc()

static LRESULT CALLBACK mmioDosIOProc ( LPMMIOINFO  lpmmioinfo, UINT  uMessage, LPARAM  lParam1, LPARAM  lParam2  )

static

Definition at line 39 of file mmio.c.

{
    LRESULT ret = MMSYSERR_NOERROR;
 
    TRACE("(%p, %X, 0x%lx, 0x%lx);\n", lpmmioinfo, uMessage, lParam1, lParam2);
 
    switch (uMessage) {
    case MMIOM_OPEN:
    {
        /* Parameters:
         * lParam1 = szFileName parameter from mmioOpen
         * lParam2 = reserved
         * Returns: zero on success, error code on error
         * NOTE: lDiskOffset automatically set to zero
         */
        LPCSTR      szFileName = (LPCSTR)lParam1;
 
        if (lpmmioinfo->dwFlags & MMIO_GETTEMP) {
        FIXME("MMIO_GETTEMP not implemented\n");
        return MMIOERR_CANNOTOPEN;
        }
 
        /* if filename NULL, assume open file handle in adwInfo[0] */
        if (szFileName) {
                OFSTRUCT    ofs;
                lpmmioinfo->adwInfo[0] = (DWORD)OpenFile(szFileName, &ofs, lpmmioinfo->dwFlags & 0xFFFF);
            }
        if (lpmmioinfo->adwInfo[0] == (DWORD)HFILE_ERROR)
        ret = MMIOERR_CANNOTOPEN;
    }
    break;
 
    case MMIOM_CLOSE:
    /* Parameters:
     * lParam1 = wFlags parameter from mmioClose
     * lParam2 = unused
     * Returns: zero on success, error code on error
     */
    if (!(lParam1 & MMIO_FHOPEN))
        _lclose((HFILE)lpmmioinfo->adwInfo[0]);
    break;
 
    case MMIOM_READ:
    /* Parameters:
     * lParam1 = huge pointer to read buffer
     * lParam2 = number of bytes to read
     * Returns: number of bytes read, 0 for EOF, -1 for error (error code
     *     in wErrorRet)
     */
    ret = _lread((HFILE)lpmmioinfo->adwInfo[0], (HPSTR)lParam1, (LONG)lParam2);
    if (ret != -1)
        lpmmioinfo->lDiskOffset += ret;
 
    break;
 
    case MMIOM_WRITE:
    case MMIOM_WRITEFLUSH:
    /* no internal buffering, so WRITEFLUSH handled same as WRITE */
 
    /* Parameters:
     * lParam1 = huge pointer to write buffer
     * lParam2 = number of bytes to write
     * Returns: number of bytes written, -1 for error (error code in
     *      wErrorRet)
     */
    ret = _hwrite((HFILE)lpmmioinfo->adwInfo[0], (HPSTR)lParam1, (LONG)lParam2);
    if (ret != -1)
        lpmmioinfo->lDiskOffset += ret;
    break;
 
    case MMIOM_SEEK:
    /* Parameters:
     * lParam1 = new position
     * lParam2 = from whence to seek (SEEK_SET, SEEK_CUR, SEEK_END)
     * Returns: new file postion, -1 on error
     */
    ret = _llseek((HFILE)lpmmioinfo->adwInfo[0], (LONG)lParam1, (LONG)lParam2);
    if (ret != -1)
        lpmmioinfo->lDiskOffset = ret;
    return ret;
 
    case MMIOM_RENAME:
    /* Parameters:
     * lParam1 = old name
     * lParam2 = new name
     * Returns: zero on success, non-zero on failure
     */
     if (!MoveFileA((const char*)lParam1, (const char*)lParam2))
         ret = MMIOERR_FILENOTFOUND;
     break;
 
    default:
    FIXME("unexpected message %u\n", uMessage);
    return 0;
    }
 
    return ret;
}

mmioFlush()

MMRESULT WINAPI mmioFlush	(	HMMIO	hmmio,
		UINT	uFlags
	)

Definition at line 961 of file mmio.c.

{
    LPWINE_MMIO     wm;
 
    TRACE("(%p, %04X)\n", hmmio, uFlags);
 
    if ((wm = MMIO_Get(hmmio)) == NULL)
    return MMSYSERR_INVALHANDLE;
 
    return MMIO_Flush(wm, uFlags);
}

Referenced by AVIFILE_SaveFile().

mmioGetInfo()

MMRESULT WINAPI mmioGetInfo	(	HMMIO	hmmio,
		MMIOINFO *	lpmmioinfo,
		UINT	uFlags
	)

Definition at line 901 of file mmio.c.

{
    LPWINE_MMIO     wm;
 
    TRACE("(%p,%p,0x%08x)\n",hmmio,lpmmioinfo,uFlags);
 
    if ((wm = MMIO_Get(hmmio)) == NULL)
    return MMSYSERR_INVALHANDLE;
 
    *lpmmioinfo = wm->info;
 
    return MMSYSERR_NOERROR;
}

Referenced by expect_buf_offset_dbg(), test_mmio_buffer_pointer(), test_mmio_end_of_file(), test_mmioOpen(), test_mmioOpen_fourcc(), test_mmioSeek(), test_mmioSetBuffer(), and test_riff_write().

mmioInstallIOProcA()

LPMMIOPROC WINAPI mmioInstallIOProcA	(	FOURCC	fccIOProc,
		LPMMIOPROC	pIOProc,
		DWORD	dwFlags
	)

Definition at line 1059 of file mmio.c.

{
    return MMIO_InstallIOProc(fccIOProc, pIOProc, dwFlags, FALSE);
}

Referenced by test_mmioOpen_fourcc().

mmioInstallIOProcW()

LPMMIOPROC WINAPI mmioInstallIOProcW	(	FOURCC	fccIOProc,
		LPMMIOPROC	pIOProc,
		DWORD	dwFlags
	)

Definition at line 1068 of file mmio.c.

{
    return MMIO_InstallIOProc(fccIOProc, pIOProc, dwFlags, TRUE);
}

mmioMemIOProc()

static LRESULT CALLBACK mmioMemIOProc ( LPMMIOINFO  lpmmioinfo, UINT  uMessage, LPARAM  lParam1, LPARAM  lParam2  )

static

Definition at line 142 of file mmio.c.

{
    TRACE("(%p,0x%04x,0x%08lx,0x%08lx)\n", lpmmioinfo, uMessage, lParam1, lParam2);
 
    switch (uMessage) {
 
    case MMIOM_OPEN:
    /* Parameters:
     * lParam1 = filename (must be NULL)
     * lParam2 = reserved
     * Returns: zero on success, error code on error
     * NOTE: lDiskOffset automatically set to zero
     */
    /* FIXME: io proc shouldn't change it */
    if (!(lpmmioinfo->dwFlags & MMIO_CREATE))
        lpmmioinfo->pchEndRead = lpmmioinfo->pchEndWrite;
        lpmmioinfo->adwInfo[0] = HFILE_ERROR;
    return 0;
 
    case MMIOM_CLOSE:
    /* Parameters:
     * lParam1 = wFlags parameter from mmioClose
     * lParam2 = unused
     * Returns: zero on success, error code on error
     */
    return 0;
 
    case MMIOM_READ:
    /* Parameters:
     * lParam1 = huge pointer to read buffer
     * lParam2 = number of bytes to read
     * Returns: number of bytes read, 0 for EOF, -1 for error (error code
     *     in wErrorRet)
     * NOTE: lDiskOffset should be updated
     */
    FIXME("MMIOM_READ on memory files should not occur, buffer may be lost!\n");
    return 0;
 
    case MMIOM_WRITE:
    case MMIOM_WRITEFLUSH:
    /* no internal buffering, so WRITEFLUSH handled same as WRITE */
 
    /* Parameters:
     * lParam1 = huge pointer to write buffer
     * lParam2 = number of bytes to write
     * Returns: number of bytes written, -1 for error (error code in
     *      wErrorRet)
     * NOTE: lDiskOffset should be updated
     */
    FIXME("MMIOM_WRITE on memory files should not occur, buffer may be lost!\n");
    return 0;
 
    case MMIOM_SEEK:
    /* Parameters:
     * lParam1 = new position
     * lParam2 = from whence to seek (SEEK_SET, SEEK_CUR, SEEK_END)
     * Returns: new file postion, -1 on error
     * NOTE: lDiskOffset should be updated
     */
    FIXME("MMIOM_SEEK on memory files should not occur, buffer may be lost!\n");
    return -1;
 
    default:
    FIXME("unexpected message %u\n", uMessage);
    return 0;
    }
}

mmioOpenA()

HMMIO WINAPI mmioOpenA	(	LPSTR	szFileName,
		MMIOINFO *	lpmmioinfo,
		DWORD	dwOpenFlags
	)

Definition at line 693 of file mmio.c.

{
    return  MMIO_Open(szFileName, lpmmioinfo, dwOpenFlags, FALSE);
}

Referenced by create_wav_file(), IPersistFile_fnLoad(), test_mmio_buffer_pointer(), test_mmio_end_of_file(), test_mmioDescend(), test_mmioOpen(), test_mmioOpen_fourcc(), test_mmioSeek(), test_mmioSetBuffer(), and test_riff_write().

mmioOpenW()

HMMIO WINAPI mmioOpenW	(	LPWSTR	szFileName,
		MMIOINFO *	lpmmioinfo,
		DWORD	dwOpenFlags
	)

Definition at line 670 of file mmio.c.

{
    HMMIO   ret;
    LPSTR   szFn = NULL;
 
    if (szFileName)
    {
        INT     len = WideCharToMultiByte( CP_ACP, 0, szFileName, -1, NULL, 0, NULL, NULL );
        szFn = HeapAlloc( GetProcessHeap(), 0, len );
        if (!szFn) return NULL;
        WideCharToMultiByte( CP_ACP, 0, szFileName, -1, szFn, len, NULL, NULL );
    }
 
    ret = MMIO_Open(szFn, lpmmioinfo, dwOpenFlags, TRUE);
 
    HeapFree(GetProcessHeap(), 0, szFn);
    return ret;
}

Referenced by ANIMATE_LoadFileW(), ANIMATE_LoadResW(), create_tmp_file(), get_mmioFromFile(), get_mmioFromProfile(), IPersistFile_fnLoad(), MCIAVI_mciOpen(), MIDI_mciOpen(), PlaySound_GetMMIO(), and WAVE_mciOpenFile().

mmioRead()

LONG WINAPI mmioRead	(	HMMIO	hmmio,
		HPSTR	pch,
		LONG	cch
	)

Definition at line 733 of file mmio.c.

{
    LPWINE_MMIO wm;
    LONG    count;
 
    TRACE("(%p, %p, %d);\n", hmmio, pch, cch);
 
    if ((wm = MMIO_Get(hmmio)) == NULL)
    return -1;
 
    /* unbuffered case first */
    if (!wm->info.pchBuffer)
    return send_message(wm->ioProc, &wm->info, MMIOM_READ, (LPARAM)pch, cch, FALSE);
 
    /* first try from current buffer */
    if (wm->info.pchNext != wm->info.pchEndRead) {
    count = wm->info.pchEndRead - wm->info.pchNext;
    if (count > cch || count < 0) count = cch;
    memcpy(pch, wm->info.pchNext, count);
    wm->info.pchNext += count;
    pch += count;
    cch -= count;
    } else
    count = 0;
 
    if (cch && (wm->info.fccIOProc != FOURCC_MEM)) {
    assert(wm->info.cchBuffer);
 
    while (cch) {
        LONG size;
 
        size = MMIO_GrabNextBuffer(wm, TRUE);
        if (size <= 0) break;
        if (size > cch) size = cch;
        memcpy(pch, wm->info.pchBuffer, size);
        wm->info.pchNext += size;
        pch += size;
        cch -= size;
        count += size;
    }
    }
 
    TRACE("count=%d\n", count);
    return count;
}

Referenced by ANIMATE_DrawFrame(), ANIMATE_GetAviInfo(), AVIFILE_LoadFile(), AVIFILE_LoadIndex(), AVIFILE_LoadSunFile(), AVIFILE_ReadBlock(), IAVIStream_fnRead(), MCIAVI_GetInfo(), MCIAVI_GetInfoAudio(), MCIAVI_GetInfoVideo(), MCIAVI_PaintFrame(), MCIAVI_PlayAudioBlocks(), MIDI_mciReadByte(), MIDI_mciReadMThd(), MIDI_mciReadMTrk(), MIDI_player(), mmioDescend(), proc_PlaySound(), ReadChunkIntoExtra(), test_mmio_buffer_pointer(), test_mmio_end_of_file(), WAVE_mciPlay(), and WAVE_mciReadFmt().

mmioRenameA()

MMRESULT WINAPI mmioRenameA	(	LPCSTR	szFileName,
		LPCSTR	szNewFileName,
		const MMIOINFO *	lpmmioinfo,
		DWORD	dwFlags
	)

Definition at line 1278 of file mmio.c.

{
    struct IOProcList*  ioProc = NULL;
    struct IOProcList   tmp;
    FOURCC              fcc;
 
    TRACE("('%s', '%s', %p, %08X);\n",
      debugstr_a(szFileName), debugstr_a(szNewFileName), lpmmioinfo, dwFlags);
 
    /* If both params are NULL, then parse the file name */
    if (lpmmioinfo && lpmmioinfo->fccIOProc == 0 && lpmmioinfo->pIOProc == NULL)
    {
    fcc = MMIO_ParseExtA(szFileName);
        if (fcc) ioProc = MMIO_FindProcNode(fcc);
    }
 
    /* Handle any unhandled/error case from above. Assume DOS file */
    if (!lpmmioinfo || (lpmmioinfo->fccIOProc == 0 && lpmmioinfo->pIOProc == NULL && ioProc == NULL))
    ioProc = MMIO_FindProcNode(FOURCC_DOS);
    /* if just the four character code is present, look up IO proc */
    else if (lpmmioinfo->pIOProc == NULL)
        ioProc = MMIO_FindProcNode(lpmmioinfo->fccIOProc);
    else /* use relevant ioProc */
    {
        ioProc = &tmp;
        tmp.fourCC = lpmmioinfo->fccIOProc;
        tmp.pIOProc = lpmmioinfo->pIOProc;
        tmp.is_unicode = FALSE;
        tmp.count = 1;
    }
 
    /* FIXME: should we actually pass lpmmioinfo down the drain ???
     * or make a copy of it because it's const ???
     */
    return send_message(ioProc, (MMIOINFO*)lpmmioinfo, MMIOM_RENAME,
                        (LPARAM)szFileName, (LPARAM)szNewFileName, FALSE);
}

Referenced by mmioRenameW().

mmioRenameW()

MMRESULT WINAPI mmioRenameW	(	LPCWSTR	szFileName,
		LPCWSTR	szNewFileName,
		const MMIOINFO *	lpmmioinfo,
		DWORD	dwFlags
	)

Definition at line 1320 of file mmio.c.

{
    LPSTR   szFn = NULL;
    LPSTR   sznFn = NULL;
    UINT    ret = MMSYSERR_NOMEM;
    INT         len;
 
    if (szFileName)
    {
        len = WideCharToMultiByte( CP_ACP, 0, szFileName, -1, NULL, 0, NULL, NULL );
        szFn = HeapAlloc( GetProcessHeap(), 0, len );
        if (!szFn) goto done;
        WideCharToMultiByte( CP_ACP, 0, szFileName, -1, szFn, len, NULL, NULL );
    }
    if (szNewFileName)
    {
        len = WideCharToMultiByte( CP_ACP, 0, szNewFileName, -1, NULL, 0, NULL, NULL );
        sznFn = HeapAlloc( GetProcessHeap(), 0, len );
        if (!sznFn) goto done;
        WideCharToMultiByte( CP_ACP, 0, szNewFileName, -1, sznFn, len, NULL, NULL );
    }
 
    ret = mmioRenameA(szFn, sznFn, lpmmioinfo, dwFlags);
 
done:
    HeapFree(GetProcessHeap(),0,szFn);
    HeapFree(GetProcessHeap(),0,sznFn);
    return ret;
}

Referenced by WAVE_mciSave().

mmioSeek()

LONG WINAPI mmioSeek	(	HMMIO	hmmio,
		LONG	lOffset,
		INT	iOrigin
	)

Definition at line 836 of file mmio.c.

{
    LPWINE_MMIO wm;
    LONG    offset;
 
    TRACE("(%p, %08X, %d);\n", hmmio, lOffset, iOrigin);
 
    if ((wm = MMIO_Get(hmmio)) == NULL)
    return MMSYSERR_INVALHANDLE;
 
    /* not buffered, direct seek on file */
    if (!wm->info.pchBuffer)
    return send_message(wm->ioProc, &wm->info, MMIOM_SEEK, lOffset, iOrigin, FALSE);
 
    switch (iOrigin) {
    case SEEK_SET:
    offset = lOffset;
    break;
    case SEEK_CUR:
    offset = wm->info.lBufOffset + (wm->info.pchNext - wm->info.pchBuffer) + lOffset;
    break;
    case SEEK_END:
    offset = ((wm->info.fccIOProc == FOURCC_MEM)? wm->info.cchBuffer : wm->dwFileSize) - lOffset;
    break;
    default:
    return -1;
    }
 
    if (offset && offset >= wm->dwFileSize && wm->info.fccIOProc != FOURCC_MEM) {
        /* should check that write mode exists */
        if (MMIO_Flush(wm, 0) != MMSYSERR_NOERROR)
            return -1;
        wm->info.lBufOffset = offset;
        wm->info.pchEndRead = wm->info.pchBuffer;
        wm->info.pchEndWrite = wm->info.pchBuffer + wm->info.cchBuffer;
        if ((wm->info.dwFlags & MMIO_RWMODE) == MMIO_READ) {
            wm->info.lDiskOffset = wm->dwFileSize;
        }
    } else if ((wm->info.cchBuffer > 0) &&
    ((offset < wm->info.lBufOffset) ||
     (offset >= wm->info.lBufOffset + wm->info.cchBuffer) ||
     !wm->bBufferLoaded)) {
        /* stay in same buffer ? */
        /* some memory mapped buffers are defined with -1 as a size */
 
    /* condition to change buffer */
    if ((wm->info.fccIOProc == FOURCC_MEM) ||
        MMIO_Flush(wm, 0) != MMSYSERR_NOERROR ||
        /* this also sets the wm->info.lDiskOffset field */
        send_message(wm->ioProc, &wm->info, MMIOM_SEEK,
                         (offset / wm->info.cchBuffer) * wm->info.cchBuffer,
                         SEEK_SET, FALSE) == -1)
        return -1;
    MMIO_GrabNextBuffer(wm, TRUE);
    }
 
    wm->info.pchNext = wm->info.pchBuffer + (offset - wm->info.lBufOffset);
 
    TRACE("=> %d\n", offset);
    return offset;
}

Referenced by ANIMATE_DrawFrame(), AVIFILE_LoadFile(), AVIFILE_LoadSunFile(), AVIFILE_ReadBlock(), AVIFILE_SaveFile(), AVIFILE_WriteBlock(), expect_buf_offset_dbg(), IAVIFile_fnEndRecord(), IAVIStream_fnRead(), IAVIStream_fnSetFormat(), IAVIStream_fnWrite(), MCIAVI_PaintFrame(), MCIAVI_PlayAudioBlocks(), MIDI_mciOpen(), MIDI_mciReadMThd(), MIDI_mciReadMTrk(), MIDI_mciReadNextEvent(), MIDI_player(), mmioAscend(), mmioCreateChunk(), mmioDescend(), proc_PlaySound(), ReadChunkIntoExtra(), test_mmio_buffer_pointer(), test_mmio_end_of_file(), test_mmioDescend(), test_mmioOpen(), test_mmioSeek(), test_mmioSetBuffer(), WAVE_mciOpenFile(), WAVE_mciPlay(), and WAVE_mciRecord().

mmioSendMessage()

LRESULT WINAPI mmioSendMessage	(	HMMIO	hmmio,
		UINT	uMessage,
		LPARAM	lParam1,
		LPARAM	lParam2
	)

Definition at line 1098 of file mmio.c.

{
    return MMIO_SendMessage(hmmio, uMessage, lParam1, lParam2, FALSE);
}

mmioSetBuffer()

MMRESULT WINAPI mmioSetBuffer	(	HMMIO	hmmio,
		LPSTR	pchBuffer,
		LONG	cchBuffer,
		UINT	uFlags
	)

Definition at line 945 of file mmio.c.

{
    LPWINE_MMIO     wm;
 
    TRACE("(hmmio=%p, pchBuf=%p, cchBuf=%d, uFlags=%#08x)\n",
      hmmio, pchBuffer, cchBuffer, uFlags);
 
    if ((wm = MMIO_Get(hmmio)) == NULL)
    return MMSYSERR_INVALHANDLE;
 
    return MMIO_SetBuffer(wm, pchBuffer, cchBuffer, uFlags);
}

Referenced by test_mmioSetBuffer().

mmioSetInfo()

MMRESULT WINAPI mmioSetInfo	(	HMMIO	hmmio,
		const MMIOINFO *	lpmmioinfo,
		UINT	uFlags
	)

Definition at line 918 of file mmio.c.

{
    LPWINE_MMIO     wm;
 
    TRACE("(%p,%p,0x%08x)\n",hmmio,lpmmioinfo,uFlags);
 
    if ((wm = MMIO_Get(hmmio)) == NULL)
    return MMSYSERR_INVALHANDLE;
 
    /* check pointers coherence */
    if (lpmmioinfo->pchNext < wm->info.pchBuffer ||
    lpmmioinfo->pchNext > wm->info.pchBuffer + wm->info.cchBuffer ||
    lpmmioinfo->pchEndRead < wm->info.pchBuffer ||
    lpmmioinfo->pchEndRead > wm->info.pchBuffer + wm->info.cchBuffer ||
    lpmmioinfo->pchEndWrite < wm->info.pchBuffer ||
    lpmmioinfo->pchEndWrite > wm->info.pchBuffer + wm->info.cchBuffer)
    return MMSYSERR_INVALPARAM;
 
    wm->info.pchNext = lpmmioinfo->pchNext;
    wm->info.pchEndRead = lpmmioinfo->pchEndRead;
 
    return MMSYSERR_NOERROR;
}

Referenced by test_riff_write().

mmioStringToFOURCCA()

FOURCC WINAPI mmioStringToFOURCCA	(	LPCSTR	sz,
		UINT	uFlags
	)

Definition at line 1025 of file mmio.c.

{
    CHAR cc[4];
    int i = 0;
 
    for (i = 0; i < 4 && sz[i]; i++) {
    if (uFlags & MMIO_TOUPPER) {
        cc[i] = toupper(sz[i]);
    } else {
        cc[i] = sz[i];
    }
    }
 
    /* Pad with spaces */
    while (i < 4) cc[i++] = ' ';
 
    TRACE("Got '%.4s'\n",cc);
    return mmioFOURCC(cc[0],cc[1],cc[2],cc[3]);
}

Referenced by ICInfo(), MMIO_ParseExtA(), and mmioStringToFOURCCW().

mmioStringToFOURCCW()

FOURCC WINAPI mmioStringToFOURCCW	(	LPCWSTR	sz,
		UINT	uFlags
	)

Definition at line 1048 of file mmio.c.

{
    char    szA[4];
 
    WideCharToMultiByte( CP_ACP, 0, sz, 4, szA, sizeof(szA), NULL, NULL );
    return mmioStringToFOURCCA(szA,uFlags);
}

mmioWrite()

LONG WINAPI mmioWrite	(	HMMIO	hmmio,
		HPCSTR	pch,
		LONG	cch
	)

Definition at line 782 of file mmio.c.

{
    LPWINE_MMIO wm;
    LONG    count;
 
    TRACE("(%p, %p, %d);\n", hmmio, pch, cch);
 
    if ((wm = MMIO_Get(hmmio)) == NULL)
    return -1;
 
    if (wm->info.cchBuffer) {
    LONG    bytesW = 0;
 
        count = 0;
        while (cch) {
            if (wm->info.pchNext != wm->info.pchEndWrite) {
                count = wm->info.pchEndWrite - wm->info.pchNext;
                if (count > cch || count < 0) count = cch;
                memcpy(wm->info.pchNext, pch, count);
                wm->info.pchNext += count;
                pch += count;
                cch -= count;
                bytesW += count;
                wm->info.dwFlags |= MMIO_DIRTY;
        } else {
                if (wm->info.fccIOProc == FOURCC_MEM) {
                    if (wm->info.adwInfo[0]) {
                        /* from where would we get the memory handle? */
                        FIXME("memory file expansion not implemented!\n");
                        break;
            } else break;
                }
            }
 
            if (wm->info.pchNext == wm->info.pchEndWrite)
            {
                MMIO_Flush(wm, MMIO_EMPTYBUF);
                MMIO_GrabNextBuffer(wm, FALSE);
            }
            else break;
        }
    count = bytesW;
    } else {
    count = send_message(wm->ioProc, &wm->info, MMIOM_WRITE, (LPARAM)pch, cch, FALSE);
    wm->info.lBufOffset = wm->info.lDiskOffset;
    }
 
    TRACE("bytes written=%d\n", count);
    return count;
}

Referenced by AVIFILE_SaveFile(), AVIFILE_SaveIndex(), AVIFILE_WriteBlock(), create_wav_file(), IAVIStream_fnSetFormat(), IAVIStream_fnWrite(), mmioAscend(), mmioCreateChunk(), test_riff_write(), WAVE_mciCreateRIFFSkeleton(), and WAVE_mciRecordCallback().

send_message()

static LRESULT send_message ( struct IOProcList *  ioProc, LPMMIOINFO  mmioinfo, DWORD  wMsg, LPARAM  lParam1, LPARAM  lParam2, BOOL  is_unicode  )

static

Definition at line 326 of file mmio.c.

{
    LRESULT         result = MMSYSERR_ERROR;
    LPARAM      lp1 = lParam1, lp2 = lParam2;
 
    if (!ioProc) {
    ERR("ioProc NULL\n");
    return MMSYSERR_INVALPARAM;
    }
 
    if (ioProc->is_unicode != is_unicode) {
        /* map (lParam1, lParam2) into (lp1, lp2) 32 A<=>W */
        FIXME("NIY 32 A<=>W mapping\n");
    }
    result = (ioProc->pIOProc)((LPSTR)mmioinfo, wMsg, lp1, lp2);
 
#if 0
    if (ioProc->is_unicode != is_unicode) {
        /* unmap (lParam1, lParam2) into (lp1, lp2) 32 A<=>W */
    }
#endif
 
    return result;
}

Referenced by MMIO_Flush(), MMIO_GrabNextBuffer(), MMIO_Open(), MMIO_SendMessage(), mmioAdvance(), mmioClose(), mmioRead(), mmioRenameA(), mmioSeek(), and mmioWrite().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

mmio

)

Variable Documentation

defaultProcs

struct IOProcList defaultProcs[]

static

Initial value:

= {
    {&defaultProcs[1], FOURCC_DOS, (LPMMIOPROC)mmioDosIOProc, FALSE, 0},
    {NULL,             FOURCC_MEM, (LPMMIOPROC)mmioMemIOProc, FALSE, 0},
}

Definition at line 215 of file mmio.c.

Referenced by MMIO_InstallIOProc().

MMIOList

WINE_MMIO* MMIOList

static

Definition at line 34 of file mmio.c.

Referenced by MMIO_Create(), MMIO_Destroy(), and MMIO_Get().

pIOProcListAnchor

struct IOProcList* pIOProcListAnchor = &defaultProcs[0]

static

Definition at line 220 of file mmio.c.

Referenced by MMIO_FindProcNode(), and MMIO_InstallIOProc().