4 * Copyright 1998 Andrew Taylor
5 * Copyright 1998 Ove Kåven
6 * Copyright 2000,2002 Eric Pouech
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 * + correct handling of global/local IOProcs (and temporary IOProcs)
25 * + mode of mmio objects is not used (read vs write vs readwrite)
27 * + 32 A <=> W message mapping
44 #include "wine/debug.h"
46 WINE_DEFAULT_DEBUG_CHANNEL(mmio
);
48 static WINE_MMIO
*MMIOList
;
50 /**************************************************************************
51 * mmioDosIOProc [internal]
53 static LRESULT CALLBACK
mmioDosIOProc(LPMMIOINFO lpmmioinfo
, UINT uMessage
,
54 LPARAM lParam1
, LPARAM lParam2
)
56 LRESULT ret
= MMSYSERR_NOERROR
;
58 TRACE("(%p, %X, 0x%lx, 0x%lx);\n", lpmmioinfo
, uMessage
, lParam1
, lParam2
);
64 * lParam1 = szFileName parameter from mmioOpen
66 * Returns: zero on success, error code on error
67 * NOTE: lDiskOffset automatically set to zero
69 LPCSTR szFileName
= (LPCSTR
)lParam1
;
71 if (lpmmioinfo
->dwFlags
& MMIO_GETTEMP
) {
72 FIXME("MMIO_GETTEMP not implemented\n");
73 return MMIOERR_CANNOTOPEN
;
76 /* if filename NULL, assume open file handle in adwInfo[0] */
79 lpmmioinfo
->adwInfo
[0] = OpenFile(szFileName
, &ofs
, lpmmioinfo
->dwFlags
& 0xFFFF);
81 if (lpmmioinfo
->adwInfo
[0] == HFILE_ERROR
)
82 ret
= MMIOERR_FILENOTFOUND
;
88 * lParam1 = wFlags parameter from mmioClose
90 * Returns: zero on success, error code on error
92 if (!(lParam1
& MMIO_FHOPEN
))
93 _lclose((HFILE
)lpmmioinfo
->adwInfo
[0]);
98 * lParam1 = huge pointer to read buffer
99 * lParam2 = number of bytes to read
100 * Returns: number of bytes read, 0 for EOF, -1 for error (error code
103 ret
= _lread((HFILE
)lpmmioinfo
->adwInfo
[0], (HPSTR
)lParam1
, (LONG
)lParam2
);
105 lpmmioinfo
->lDiskOffset
+= ret
;
110 case MMIOM_WRITEFLUSH
:
111 /* no internal buffering, so WRITEFLUSH handled same as WRITE */
114 * lParam1 = huge pointer to write buffer
115 * lParam2 = number of bytes to write
116 * Returns: number of bytes written, -1 for error (error code in
119 ret
= _hwrite((HFILE
)lpmmioinfo
->adwInfo
[0], (HPSTR
)lParam1
, (LONG
)lParam2
);
121 lpmmioinfo
->lDiskOffset
+= ret
;
126 * lParam1 = new position
127 * lParam2 = from whence to seek (SEEK_SET, SEEK_CUR, SEEK_END)
128 * Returns: new file position, -1 on error
130 if (lParam2
== SEEK_END
)
131 ret
= _llseek((HFILE
)lpmmioinfo
->adwInfo
[0], -(LONG
)lParam1
, (LONG
)lParam2
);
133 ret
= _llseek((HFILE
)lpmmioinfo
->adwInfo
[0], (LONG
)lParam1
, (LONG
)lParam2
);
135 lpmmioinfo
->lDiskOffset
= ret
;
142 * Returns: zero on success, non-zero on failure
144 if (!MoveFileA((const char*)lParam1
, (const char*)lParam2
))
145 ret
= MMIOERR_FILENOTFOUND
;
149 FIXME("unexpected message %u\n", uMessage
);
156 /**************************************************************************
157 * mmioMemIOProc [internal]
159 static LRESULT CALLBACK
mmioMemIOProc(LPMMIOINFO lpmmioinfo
, UINT uMessage
,
160 LPARAM lParam1
, LPARAM lParam2
)
162 TRACE("(%p,0x%04x,0x%08lx,0x%08lx)\n", lpmmioinfo
, uMessage
, lParam1
, lParam2
);
168 * lParam1 = filename (must be NULL)
170 * Returns: zero on success, error code on error
171 * NOTE: lDiskOffset automatically set to zero
173 /* FIXME: io proc shouldn't change it */
174 if (!(lpmmioinfo
->dwFlags
& MMIO_CREATE
))
175 lpmmioinfo
->pchEndRead
= lpmmioinfo
->pchEndWrite
;
176 lpmmioinfo
->adwInfo
[0] = HFILE_ERROR
;
181 * lParam1 = wFlags parameter from mmioClose
183 * Returns: zero on success, error code on error
189 * lParam1 = huge pointer to read buffer
190 * lParam2 = number of bytes to read
191 * Returns: number of bytes read, 0 for EOF, -1 for error (error code
193 * NOTE: lDiskOffset should be updated
195 FIXME("MMIOM_READ on memory files should not occur, buffer may be lost!\n");
199 case MMIOM_WRITEFLUSH
:
200 /* no internal buffering, so WRITEFLUSH handled same as WRITE */
203 * lParam1 = huge pointer to write buffer
204 * lParam2 = number of bytes to write
205 * Returns: number of bytes written, -1 for error (error code in
207 * NOTE: lDiskOffset should be updated
209 FIXME("MMIOM_WRITE on memory files should not occur, buffer may be lost!\n");
214 * lParam1 = new position
215 * lParam2 = from whence to seek (SEEK_SET, SEEK_CUR, SEEK_END)
216 * Returns: new file position, -1 on error
217 * NOTE: lDiskOffset should be updated
219 FIXME("MMIOM_SEEK on memory files should not occur, buffer may be lost!\n");
223 FIXME("unexpected message %u\n", uMessage
);
228 /* This array will be the entire list for most apps
229 * Note that temporary ioProcs will be stored with a 0 fourCC code
232 static struct IOProcList defaultProcs
[] = {
233 {&defaultProcs
[1], FOURCC_DOS
, (LPMMIOPROC
)mmioDosIOProc
, FALSE
, 0},
234 {NULL
, FOURCC_MEM
, (LPMMIOPROC
)mmioMemIOProc
, FALSE
, 0},
237 static struct IOProcList
* pIOProcListAnchor
= &defaultProcs
[0];
239 /****************************************************************
240 * MMIO_FindProcNode [INTERNAL]
242 * Finds the ProcList node associated with a given FOURCC code.
244 static struct IOProcList
* MMIO_FindProcNode(FOURCC fccIOProc
)
246 struct IOProcList
* pListNode
;
248 for (pListNode
= pIOProcListAnchor
; pListNode
; pListNode
= pListNode
->pNext
) {
249 if (pListNode
->fourCC
== fccIOProc
) {
256 /****************************************************************
257 * MMIO_InstallIOProc [INTERNAL]
259 static LPMMIOPROC
MMIO_InstallIOProc(FOURCC fccIOProc
, LPMMIOPROC pIOProc
,
260 DWORD dwFlags
, BOOL is_unicode
)
262 LPMMIOPROC lpProc
= NULL
;
263 struct IOProcList
* pListNode
;
264 struct IOProcList
** ppListNode
;
266 TRACE("(%08x, %p, %08X, %s)\n", fccIOProc
, pIOProc
, dwFlags
, is_unicode
? "unicode" : "ansi");
268 if (dwFlags
& MMIO_GLOBALPROC
)
269 FIXME("Global procedures not implemented\n");
271 /* just handle the known procedures for now */
272 switch (dwFlags
& (MMIO_INSTALLPROC
|MMIO_REMOVEPROC
|MMIO_FINDPROC
)) {
273 case MMIO_INSTALLPROC
:
274 /* Create new entry for the IOProc list */
275 pListNode
= HeapAlloc(GetProcessHeap(), 0, sizeof(*pListNode
));
277 /* Fill in this node */
278 pListNode
->fourCC
= fccIOProc
;
279 pListNode
->pIOProc
= pIOProc
;
280 pListNode
->is_unicode
= is_unicode
;
281 pListNode
->count
= 0;
283 /* Stick it on the end of the list */
284 pListNode
->pNext
= pIOProcListAnchor
;
285 pIOProcListAnchor
= pListNode
;
287 /* Return this IOProc - that's how the caller knows we succeeded */
292 case MMIO_REMOVEPROC
:
294 * Search for the node that we're trying to remove
295 * We search for a matching fourCC code if it's non null, or the proc
297 * note that this method won't find the first item on the list, but
298 * since the first two items on this list are ones we won't
299 * let the user delete anyway, that's okay
301 ppListNode
= &pIOProcListAnchor
;
302 while ((*ppListNode
) &&
304 (*ppListNode
)->fourCC
!= fccIOProc
:
305 (*ppListNode
)->pIOProc
!= pIOProc
))
306 ppListNode
= &((*ppListNode
)->pNext
);
308 if (*ppListNode
) { /* found it */
309 /* FIXME: what should be done if an open mmio object uses this proc ?
310 * shall we return an error, nuke the mmio object ?
312 if ((*ppListNode
)->count
) {
313 ERR("Cannot remove a mmIOProc while in use\n");
316 /* remove it, but only if it isn't builtin */
317 if ((*ppListNode
) >= defaultProcs
&&
318 (*ppListNode
) < defaultProcs
+ sizeof(defaultProcs
) / sizeof(defaultProcs
[0])) {
319 WARN("Tried to remove built-in mmio proc. Skipping\n");
322 struct IOProcList
* ptmpNode
= *ppListNode
;
323 lpProc
= (*ppListNode
)->pIOProc
;
324 *ppListNode
= (*ppListNode
)->pNext
;
325 HeapFree(GetProcessHeap(), 0, ptmpNode
);
331 if ((pListNode
= MMIO_FindProcNode(fccIOProc
))) {
332 lpProc
= pListNode
->pIOProc
;
340 /****************************************************************
341 * send_message [INTERNAL]
343 static LRESULT
send_message(struct IOProcList
* ioProc
, LPMMIOINFO mmioinfo
,
344 DWORD wMsg
, LPARAM lParam1
,
345 LPARAM lParam2
, BOOL is_unicode
)
347 LRESULT result
= MMSYSERR_ERROR
;
348 LPARAM lp1
= lParam1
, lp2
= lParam2
;
351 ERR("ioProc NULL\n");
352 return MMSYSERR_INVALPARAM
;
355 if (ioProc
->is_unicode
!= is_unicode
) {
356 /* map (lParam1, lParam2) into (lp1, lp2) 32 A<=>W */
357 FIXME("NIY 32 A<=>W mapping\n");
359 result
= (ioProc
->pIOProc
)((LPSTR
)mmioinfo
, wMsg
, lp1
, lp2
);
362 if (ioProc
->is_unicode
!= is_unicode
) {
363 /* unmap (lParam1, lParam2) into (lp1, lp2) 32 A<=>W */
370 /**************************************************************************
371 * MMIO_ParseExtA [internal]
373 * Parses a filename for the extension.
376 * The FOURCC code for the extension if found, else 0.
378 static FOURCC
MMIO_ParseExtA(LPCSTR szFileName
)
380 /* Filenames are of the form file.ext{+ABC}
381 For now, we take the last '+' if present */
385 /* Note that ext{Start,End} point to the . and + respectively */
391 TRACE("(%s)\n", debugstr_a(szFileName
));
396 /* Find the last '+' */
397 extEnd
= strrchr(szFileName
,'+');
400 /* No + so just an extension */
403 /* Find the first '.' before '+' */
404 extStart
= extEnd
- 1;
405 while (extStart
>= szFileName
&& *extStart
!= '.') {
408 if (extStart
< szFileName
) {
409 ERR("No extension in szFileName: %s\n", debugstr_a(szFileName
));
414 if (extEnd
- extStart
- 1 > 4)
415 WARN("Extension length > 4\n");
416 lstrcpynA(ext
, extStart
+ 1, min(extEnd
-extStart
,5));
418 TRACE("Got extension: %s\n", debugstr_a(ext
));
420 /* FOURCC codes identifying file-extensions must be uppercase */
421 ret
= mmioStringToFOURCCA(ext
, MMIO_TOUPPER
);
426 /**************************************************************************
427 * MMIO_Get [internal]
429 * Retrieves the mmio object from current process
431 static LPWINE_MMIO
MMIO_Get(HMMIO h
)
433 LPWINE_MMIO wm
= NULL
;
435 EnterCriticalSection(&WINMM_cs
);
436 for (wm
= MMIOList
; wm
; wm
= wm
->lpNext
) {
437 if (wm
->info
.hmmio
== h
)
440 LeaveCriticalSection(&WINMM_cs
);
444 /**************************************************************************
445 * MMIO_Create [internal]
447 * Creates an internal representation for a mmio instance
449 static LPWINE_MMIO
MMIO_Create(void)
451 static WORD MMIO_counter
= 0;
454 wm
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(WINE_MMIO
));
456 EnterCriticalSection(&WINMM_cs
);
457 /* lookup next unallocated WORD handle, with a non NULL value */
458 while (++MMIO_counter
== 0 || MMIO_Get((HMMIO
)(ULONG_PTR
)MMIO_counter
));
459 wm
->info
.hmmio
= (HMMIO
)(ULONG_PTR
)MMIO_counter
;
460 wm
->lpNext
= MMIOList
;
462 LeaveCriticalSection(&WINMM_cs
);
467 /**************************************************************************
468 * MMIO_Destroy [internal]
470 * Destroys an internal representation for a mmio instance
472 static BOOL
MMIO_Destroy(LPWINE_MMIO wm
)
476 EnterCriticalSection(&WINMM_cs
);
477 /* search for the matching one... */
479 while (*m
&& *m
!= wm
) m
= &(*m
)->lpNext
;
483 HeapFree(GetProcessHeap(), 0, wm
);
486 LeaveCriticalSection(&WINMM_cs
);
490 /****************************************************************
491 * MMIO_Flush [INTERNAL]
493 static MMRESULT
MMIO_Flush(WINE_MMIO
* wm
, UINT uFlags
)
495 if (wm
->info
.cchBuffer
&& (wm
->info
.fccIOProc
!= FOURCC_MEM
)) {
496 /* not quite sure what to do here, but I'll guess */
497 if (wm
->info
.dwFlags
& MMIO_DIRTY
) {
498 /* FIXME: error handling */
499 send_message(wm
->ioProc
, &wm
->info
, MMIOM_SEEK
, wm
->info
.lBufOffset
, SEEK_SET
, FALSE
);
500 send_message(wm
->ioProc
, &wm
->info
, MMIOM_WRITE
,
501 (LPARAM
)wm
->info
.pchBuffer
,
502 wm
->info
.pchNext
- wm
->info
.pchBuffer
, FALSE
);
504 if (uFlags
& MMIO_EMPTYBUF
)
505 wm
->info
.pchNext
= wm
->info
.pchEndRead
= wm
->info
.pchBuffer
;
507 wm
->info
.dwFlags
&= ~MMIO_DIRTY
;
509 return MMSYSERR_NOERROR
;
512 /***************************************************************************
513 * MMIO_GrabNextBuffer [INTERNAL]
515 static LONG
MMIO_GrabNextBuffer(LPWINE_MMIO wm
, int for_read
)
517 LONG size
= wm
->info
.cchBuffer
;
519 TRACE("bo=%x do=%x\n",
520 wm
->info
.lBufOffset
, wm
->info
.lDiskOffset
);
522 wm
->info
.lBufOffset
= wm
->info
.lDiskOffset
;
523 wm
->info
.pchNext
= wm
->info
.pchBuffer
;
524 wm
->info
.pchEndRead
= wm
->info
.pchBuffer
;
525 wm
->info
.pchEndWrite
= wm
->info
.pchBuffer
+ wm
->info
.cchBuffer
;
527 wm
->bBufferLoaded
= TRUE
;
529 size
= send_message(wm
->ioProc
, &wm
->info
, MMIOM_READ
,
530 (LPARAM
)wm
->info
.pchBuffer
, size
, FALSE
);
532 wm
->info
.pchEndRead
+= size
;
534 wm
->bBufferLoaded
= FALSE
;
540 /***************************************************************************
541 * MMIO_SetBuffer [INTERNAL]
543 static MMRESULT
MMIO_SetBuffer(WINE_MMIO
* wm
, void* pchBuffer
, LONG cchBuffer
,
546 TRACE("(%p %p %d %u)\n", wm
, pchBuffer
, cchBuffer
, uFlags
);
548 if (cchBuffer
> 0xFFFF)
549 WARN("Untested handling of huge mmio buffers (%d >= 64k)\n", cchBuffer
);
551 if (MMIO_Flush(wm
, 0) != MMSYSERR_NOERROR
)
552 return MMIOERR_CANNOTWRITE
;
554 /* free previous buffer if allocated */
555 if (wm
->info
.dwFlags
& MMIO_ALLOCBUF
) {
556 HeapFree(GetProcessHeap(), 0, wm
->info
.pchBuffer
);
557 wm
->info
.pchBuffer
= NULL
;
558 wm
->info
.dwFlags
&= ~MMIO_ALLOCBUF
;
562 wm
->info
.pchBuffer
= pchBuffer
;
563 } else if (cchBuffer
) {
564 if (!(wm
->info
.pchBuffer
= HeapAlloc(GetProcessHeap(), 0, cchBuffer
)))
565 return MMIOERR_OUTOFMEMORY
;
566 wm
->info
.dwFlags
|= MMIO_ALLOCBUF
;
568 wm
->info
.pchBuffer
= NULL
;
571 wm
->info
.cchBuffer
= cchBuffer
;
572 wm
->info
.pchNext
= wm
->info
.pchBuffer
;
573 wm
->info
.pchEndRead
= wm
->info
.pchBuffer
;
574 wm
->info
.pchEndWrite
= wm
->info
.pchBuffer
+ cchBuffer
;
575 wm
->info
.lBufOffset
= wm
->info
.lDiskOffset
;
576 wm
->bBufferLoaded
= (wm
->info
.fccIOProc
== FOURCC_MEM
);
578 return MMSYSERR_NOERROR
;
581 /**************************************************************************
582 * MMIO_Open [internal]
584 static HMMIO
MMIO_Open(LPSTR szFileName
, MMIOINFO
* refmminfo
, DWORD dwOpenFlags
, BOOL is_unicode
)
590 TRACE("(%s, %p, %08X, %s);\n", debugstr_a(szFileName
), refmminfo
, dwOpenFlags
, is_unicode
? "unicode" : "ansi");
593 refmminfo
= &mmioinfo
;
595 mmioinfo
.fccIOProc
= 0;
596 mmioinfo
.pIOProc
= NULL
;
597 mmioinfo
.pchBuffer
= NULL
;
598 mmioinfo
.cchBuffer
= 0;
602 if (dwOpenFlags
& (MMIO_PARSE
|MMIO_EXIST
)) {
603 char buffer
[MAX_PATH
];
607 if (GetFullPathNameA(szFileName
, sizeof(buffer
), buffer
, NULL
) >= sizeof(buffer
))
609 if ((dwOpenFlags
& MMIO_EXIST
) && (GetFileAttributesA(buffer
) == INVALID_FILE_ATTRIBUTES
))
611 strcpy(szFileName
, buffer
);
615 if ((wm
= MMIO_Create()) == NULL
)
618 /* If both params are NULL, then parse the file name if available */
619 if (refmminfo
->fccIOProc
== 0 && refmminfo
->pIOProc
== NULL
) {
620 wm
->info
.fccIOProc
= MMIO_ParseExtA(szFileName
);
621 /* Handle any unhandled/error case. Assume DOS file */
622 if (wm
->info
.fccIOProc
== 0) {
623 wm
->info
.fccIOProc
= FOURCC_DOS
;
624 wm
->ioProc
= &defaultProcs
[0];
626 else if (!(wm
->ioProc
= MMIO_FindProcNode(wm
->info
.fccIOProc
))) {
627 /* If not found, assume DOS file */
628 wm
->ioProc
= &defaultProcs
[0];
630 wm
->bTmpIOProc
= FALSE
;
632 /* if just the four character code is present, look up IO proc */
633 else if (refmminfo
->pIOProc
== NULL
) {
634 wm
->info
.fccIOProc
= refmminfo
->fccIOProc
;
635 if (!(wm
->ioProc
= MMIO_FindProcNode(wm
->info
.fccIOProc
))) goto error2
;
636 wm
->bTmpIOProc
= FALSE
;
638 /* if IO proc specified, use it and specified four character code */
640 wm
->info
.fccIOProc
= refmminfo
->fccIOProc
;
641 MMIO_InstallIOProc(wm
->info
.fccIOProc
, refmminfo
->pIOProc
,
642 MMIO_INSTALLPROC
, is_unicode
);
643 if (!(wm
->ioProc
= MMIO_FindProcNode(wm
->info
.fccIOProc
))) goto error2
;
644 assert(wm
->ioProc
->pIOProc
== refmminfo
->pIOProc
);
645 wm
->bTmpIOProc
= TRUE
;
649 wm
->info
.dwFlags
= dwOpenFlags
;
651 if (dwOpenFlags
& MMIO_ALLOCBUF
) {
652 refmminfo
->wErrorRet
= MMIO_SetBuffer(wm
, refmminfo
->pchBuffer
,
653 refmminfo
->cchBuffer
? refmminfo
->cchBuffer
: MMIO_DEFAULTBUFFER
, 0);
654 if (refmminfo
->wErrorRet
!= MMSYSERR_NOERROR
)
657 refmminfo
->wErrorRet
= MMIO_SetBuffer(wm
, refmminfo
->pchBuffer
, refmminfo
->cchBuffer
, 0);
658 if (refmminfo
->wErrorRet
!= MMSYSERR_NOERROR
)
662 /* see mmioDosIOProc for that one */
663 memcpy( wm
->info
.adwInfo
, refmminfo
->adwInfo
, sizeof(wm
->info
.adwInfo
) );
665 /* call IO proc to actually open file */
666 refmminfo
->wErrorRet
= send_message(wm
->ioProc
, &wm
->info
, MMIOM_OPEN
,
667 (LPARAM
)szFileName
, 0, FALSE
);
669 /* update offsets and grab file size, when possible */
670 if (wm
->info
.fccIOProc
== FOURCC_DOS
&& (send_message(wm
->ioProc
, &wm
->info
, MMIOM_SEEK
, 0, SEEK_CUR
, FALSE
)) != -1) {
671 pos
= wm
->info
.lBufOffset
= wm
->info
.lDiskOffset
;
672 send_message(wm
->ioProc
, &wm
->info
, MMIOM_SEEK
, 0, SEEK_END
, FALSE
);
673 wm
->dwFileSize
= wm
->info
.lDiskOffset
;
674 send_message(wm
->ioProc
, &wm
->info
, MMIOM_SEEK
, pos
, SEEK_SET
, FALSE
);
676 else wm
->dwFileSize
= 0;
678 if (refmminfo
->wErrorRet
== 0)
679 return wm
->info
.hmmio
;
681 if (wm
->info
.dwFlags
& MMIO_ALLOCBUF
)
682 HeapFree(GetProcessHeap(), 0, wm
->info
.pchBuffer
);
683 if (wm
->ioProc
) wm
->ioProc
->count
--;
689 /**************************************************************************
690 * mmioOpenW [WINMM.@]
692 HMMIO WINAPI
mmioOpenW(LPWSTR szFileName
, MMIOINFO
* lpmmioinfo
,
700 INT len
= WideCharToMultiByte( CP_ACP
, 0, szFileName
, -1, NULL
, 0, NULL
, NULL
);
701 szFn
= HeapAlloc( GetProcessHeap(), 0, len
);
702 if (!szFn
) return NULL
;
703 WideCharToMultiByte( CP_ACP
, 0, szFileName
, -1, szFn
, len
, NULL
, NULL
);
706 ret
= MMIO_Open(szFn
, lpmmioinfo
, dwOpenFlags
, TRUE
);
708 HeapFree(GetProcessHeap(), 0, szFn
);
712 /**************************************************************************
713 * mmioOpenA [WINMM.@]
715 HMMIO WINAPI
mmioOpenA(LPSTR szFileName
, MMIOINFO
* lpmmioinfo
,
718 return MMIO_Open(szFileName
, lpmmioinfo
, dwOpenFlags
, FALSE
);
721 /**************************************************************************
722 * mmioClose [WINMM.@]
724 MMRESULT WINAPI
mmioClose(HMMIO hmmio
, UINT uFlags
)
729 TRACE("(%p, %04X);\n", hmmio
, uFlags
);
731 if ((wm
= MMIO_Get(hmmio
)) == NULL
)
732 return MMSYSERR_INVALHANDLE
;
734 if ((result
= MMIO_Flush(wm
, 0)) != MMSYSERR_NOERROR
)
737 result
= send_message(wm
->ioProc
, &wm
->info
, MMIOM_CLOSE
, uFlags
, 0, FALSE
);
739 MMIO_SetBuffer(wm
, NULL
, 0, 0);
744 MMIO_InstallIOProc(wm
->info
.fccIOProc
, wm
->ioProc
->pIOProc
,
745 MMIO_REMOVEPROC
, wm
->ioProc
->is_unicode
);
752 /**************************************************************************
755 LONG WINAPI
mmioRead(HMMIO hmmio
, HPSTR pch
, LONG cch
)
760 TRACE("(%p, %p, %d);\n", hmmio
, pch
, cch
);
762 if ((wm
= MMIO_Get(hmmio
)) == NULL
)
765 /* unbuffered case first */
766 if (!wm
->info
.pchBuffer
)
767 return send_message(wm
->ioProc
, &wm
->info
, MMIOM_READ
, (LPARAM
)pch
, cch
, FALSE
);
769 /* first try from current buffer */
770 if (cch
&& wm
->info
.fccIOProc
!= FOURCC_MEM
&& wm
->info
.pchNext
== wm
->info
.pchEndRead
)
771 MMIO_GrabNextBuffer(wm
, TRUE
);
772 if (wm
->info
.pchNext
!= wm
->info
.pchEndRead
) {
773 count
= wm
->info
.pchEndRead
- wm
->info
.pchNext
;
774 if (count
> cch
|| count
< 0) count
= cch
;
775 memcpy(pch
, wm
->info
.pchNext
, count
);
776 wm
->info
.pchNext
+= count
;
782 if (cch
&& (wm
->info
.fccIOProc
!= FOURCC_MEM
)) {
783 assert(wm
->info
.cchBuffer
);
788 size
= MMIO_GrabNextBuffer(wm
, TRUE
);
789 if (size
<= 0) break;
790 if (size
> cch
) size
= cch
;
791 memcpy(pch
, wm
->info
.pchBuffer
, size
);
792 wm
->info
.pchNext
+= size
;
797 wm
->bBufferLoaded
= FALSE
;
798 mmioSeek(hmmio
, 0, SEEK_CUR
);
801 TRACE("count=%d\n", count
);
805 /**************************************************************************
806 * mmioWrite [WINMM.@]
808 LONG WINAPI
mmioWrite(HMMIO hmmio
, HPCSTR pch
, LONG cch
)
813 TRACE("(%p, %p, %d);\n", hmmio
, pch
, cch
);
815 if ((wm
= MMIO_Get(hmmio
)) == NULL
)
818 if (wm
->info
.cchBuffer
) {
823 if (wm
->info
.pchNext
!= wm
->info
.pchEndWrite
) {
824 count
= wm
->info
.pchEndWrite
- wm
->info
.pchNext
;
825 if (count
> cch
|| count
< 0) count
= cch
;
826 memcpy(wm
->info
.pchNext
, pch
, count
);
827 wm
->info
.pchNext
+= count
;
831 wm
->info
.dwFlags
|= MMIO_DIRTY
;
833 if (wm
->info
.fccIOProc
== FOURCC_MEM
) {
834 if (wm
->info
.adwInfo
[0]) {
835 /* from where would we get the memory handle? */
836 FIXME("memory file expansion not implemented!\n");
842 if (wm
->info
.pchNext
== wm
->info
.pchEndWrite
)
844 MMIO_Flush(wm
, MMIO_EMPTYBUF
);
845 MMIO_GrabNextBuffer(wm
, FALSE
);
851 count
= send_message(wm
->ioProc
, &wm
->info
, MMIOM_WRITE
, (LPARAM
)pch
, cch
, FALSE
);
852 wm
->info
.lBufOffset
= wm
->info
.lDiskOffset
;
855 TRACE("bytes written=%d\n", count
);
859 /**************************************************************************
862 LONG WINAPI
mmioSeek(HMMIO hmmio
, LONG lOffset
, INT iOrigin
)
867 TRACE("(%p, %08X, %d);\n", hmmio
, lOffset
, iOrigin
);
869 if ((wm
= MMIO_Get(hmmio
)) == NULL
)
870 return MMSYSERR_INVALHANDLE
;
872 /* not buffered, direct seek on file */
873 if (!wm
->info
.pchBuffer
&& wm
->info
.fccIOProc
!= FOURCC_MEM
) {
874 LRESULT ret
= send_message(wm
->ioProc
, &wm
->info
, MMIOM_SEEK
, lOffset
, iOrigin
, FALSE
);
876 wm
->info
.lBufOffset
= wm
->info
.lDiskOffset
;
885 offset
= wm
->info
.lBufOffset
+ (wm
->info
.pchNext
- wm
->info
.pchBuffer
) + lOffset
;
888 switch (wm
->info
.fccIOProc
) {
890 offset
= wm
->info
.cchBuffer
- lOffset
;
893 offset
= wm
->dwFileSize
- lOffset
;
896 offset
= send_message(wm
->ioProc
, &wm
->info
, MMIOM_SEEK
, lOffset
, SEEK_END
, FALSE
);
904 /* stay in same buffer ? */
905 /* some memory mapped buffers are defined with -1 as a size */
906 if ((wm
->info
.cchBuffer
> 0) &&
907 ((offset
< wm
->info
.lBufOffset
) ||
908 (offset
> wm
->info
.lBufOffset
+ wm
->info
.cchBuffer
) ||
909 (offset
> wm
->dwFileSize
&& wm
->info
.fccIOProc
== FOURCC_DOS
) ||
910 !wm
->bBufferLoaded
)) {
912 /* condition to change buffer */
913 if ((wm
->info
.fccIOProc
== FOURCC_MEM
) ||
914 MMIO_Flush(wm
, 0) != MMSYSERR_NOERROR
||
915 /* this also sets the wm->info.lDiskOffset field */
916 send_message(wm
->ioProc
, &wm
->info
, MMIOM_SEEK
,
917 offset
, SEEK_SET
, FALSE
) == -1)
919 wm
->info
.lBufOffset
= offset
;
920 wm
->bBufferLoaded
= FALSE
;
921 wm
->info
.pchNext
= wm
->info
.pchEndRead
= wm
->info
.pchBuffer
;
924 wm
->info
.pchNext
= wm
->info
.pchBuffer
+ (offset
- wm
->info
.lBufOffset
);
926 TRACE("=> %d\n", offset
);
930 /**************************************************************************
931 * mmioGetInfo [WINMM.@]
933 MMRESULT WINAPI
mmioGetInfo(HMMIO hmmio
, MMIOINFO
* lpmmioinfo
, UINT uFlags
)
937 TRACE("(%p,%p,0x%08x)\n",hmmio
,lpmmioinfo
,uFlags
);
939 if ((wm
= MMIO_Get(hmmio
)) == NULL
)
940 return MMSYSERR_INVALHANDLE
;
942 *lpmmioinfo
= wm
->info
;
944 return MMSYSERR_NOERROR
;
947 /**************************************************************************
948 * mmioSetInfo [WINMM.@]
950 MMRESULT WINAPI
mmioSetInfo(HMMIO hmmio
, const MMIOINFO
* lpmmioinfo
, UINT uFlags
)
954 TRACE("(%p,%p,0x%08x)\n",hmmio
,lpmmioinfo
,uFlags
);
956 if ((wm
= MMIO_Get(hmmio
)) == NULL
)
957 return MMSYSERR_INVALHANDLE
;
959 /* check pointers coherence */
960 if (lpmmioinfo
->pchNext
< wm
->info
.pchBuffer
||
961 lpmmioinfo
->pchNext
> wm
->info
.pchBuffer
+ wm
->info
.cchBuffer
||
962 lpmmioinfo
->pchEndRead
< wm
->info
.pchBuffer
||
963 lpmmioinfo
->pchEndRead
> wm
->info
.pchBuffer
+ wm
->info
.cchBuffer
||
964 lpmmioinfo
->pchEndWrite
< wm
->info
.pchBuffer
||
965 lpmmioinfo
->pchEndWrite
> wm
->info
.pchBuffer
+ wm
->info
.cchBuffer
)
966 return MMSYSERR_INVALPARAM
;
968 wm
->info
= *lpmmioinfo
;
969 return MMSYSERR_NOERROR
;
972 /**************************************************************************
973 * mmioSetBuffer [WINMM.@]
975 MMRESULT WINAPI
mmioSetBuffer(HMMIO hmmio
, LPSTR pchBuffer
, LONG cchBuffer
, UINT uFlags
)
979 TRACE("(hmmio=%p, pchBuf=%p, cchBuf=%d, uFlags=%#08x)\n",
980 hmmio
, pchBuffer
, cchBuffer
, uFlags
);
982 if ((wm
= MMIO_Get(hmmio
)) == NULL
)
983 return MMSYSERR_INVALHANDLE
;
985 return MMIO_SetBuffer(wm
, pchBuffer
, cchBuffer
, uFlags
);
988 /**************************************************************************
989 * mmioFlush [WINMM.@]
991 MMRESULT WINAPI
mmioFlush(HMMIO hmmio
, UINT uFlags
)
995 TRACE("(%p, %04X)\n", hmmio
, uFlags
);
997 if ((wm
= MMIO_Get(hmmio
)) == NULL
)
998 return MMSYSERR_INVALHANDLE
;
1000 return MMIO_Flush(wm
, uFlags
);
1003 /**************************************************************************
1004 * mmioAdvance [WINMM.@]
1006 MMRESULT WINAPI
mmioAdvance(HMMIO hmmio
, MMIOINFO
* lpmmioinfo
, UINT uFlags
)
1010 TRACE("hmmio=%p, lpmmioinfo=%p, uFlags=%04X\n", hmmio
, lpmmioinfo
, uFlags
);
1012 /* NOTE: mmioAdvance16 heavily relies on parameters from lpmmioinfo we're using
1013 * here. be sure if you change something here to check mmioAdvance16 as well
1015 if ((wm
= MMIO_Get(hmmio
)) == NULL
)
1016 return MMSYSERR_INVALHANDLE
;
1018 if (!wm
->info
.cchBuffer
)
1019 return MMIOERR_UNBUFFERED
;
1021 if (uFlags
!= MMIO_READ
&& uFlags
!= MMIO_WRITE
)
1022 return MMSYSERR_INVALPARAM
;
1024 if (MMIO_Flush(wm
, 0) != MMSYSERR_NOERROR
)
1025 return MMIOERR_CANNOTWRITE
;
1026 if (uFlags
== MMIO_WRITE
&& (lpmmioinfo
->dwFlags
& MMIO_DIRTY
))
1028 send_message(wm
->ioProc
, &wm
->info
, MMIOM_SEEK
, lpmmioinfo
->lBufOffset
, SEEK_SET
, FALSE
);
1029 send_message(wm
->ioProc
, &wm
->info
, MMIOM_WRITE
, (LPARAM
)lpmmioinfo
->pchBuffer
,
1030 lpmmioinfo
->pchNext
- lpmmioinfo
->pchBuffer
, FALSE
);
1031 lpmmioinfo
->dwFlags
&= ~MMIO_DIRTY
;
1034 if (lpmmioinfo
&& lpmmioinfo
->fccIOProc
== FOURCC_DOS
) {
1035 wm
->dwFileSize
= max(wm
->dwFileSize
, lpmmioinfo
->lBufOffset
+
1036 (lpmmioinfo
->pchNext
- lpmmioinfo
->pchBuffer
));
1038 MMIO_GrabNextBuffer(wm
, uFlags
== MMIO_READ
);
1041 lpmmioinfo
->pchNext
= lpmmioinfo
->pchBuffer
;
1042 lpmmioinfo
->pchEndRead
= lpmmioinfo
->pchBuffer
+
1043 (wm
->info
.pchEndRead
- wm
->info
.pchBuffer
);
1044 lpmmioinfo
->pchEndWrite
= lpmmioinfo
->pchBuffer
+
1045 (wm
->info
.pchEndWrite
- wm
->info
.pchBuffer
);
1046 lpmmioinfo
->lDiskOffset
= wm
->info
.lDiskOffset
;
1047 lpmmioinfo
->lBufOffset
= wm
->info
.lBufOffset
;
1049 return MMSYSERR_NOERROR
;
1052 /**************************************************************************
1053 * mmioStringToFOURCCA [WINMM.@]
1055 FOURCC WINAPI
mmioStringToFOURCCA(LPCSTR sz
, UINT uFlags
)
1060 for (i
= 0; i
< 4 && sz
[i
]; i
++) {
1061 if (uFlags
& MMIO_TOUPPER
) {
1062 cc
[i
] = toupper(sz
[i
]);
1068 /* Pad with spaces */
1069 while (i
< 4) cc
[i
++] = ' ';
1071 TRACE("Got %s\n",debugstr_an(cc
,4));
1072 return mmioFOURCC(cc
[0],cc
[1],cc
[2],cc
[3]);
1075 /**************************************************************************
1076 * mmioStringToFOURCCW [WINMM.@]
1078 FOURCC WINAPI
mmioStringToFOURCCW(LPCWSTR sz
, UINT uFlags
)
1082 WideCharToMultiByte( CP_ACP
, 0, sz
, 4, szA
, sizeof(szA
), NULL
, NULL
);
1083 return mmioStringToFOURCCA(szA
,uFlags
);
1086 /**************************************************************************
1087 * mmioInstallIOProcA [WINMM.@]
1089 LPMMIOPROC WINAPI
mmioInstallIOProcA(FOURCC fccIOProc
,
1090 LPMMIOPROC pIOProc
, DWORD dwFlags
)
1092 return MMIO_InstallIOProc(fccIOProc
, pIOProc
, dwFlags
, FALSE
);
1095 /**************************************************************************
1096 * mmioInstallIOProcW [WINMM.@]
1098 LPMMIOPROC WINAPI
mmioInstallIOProcW(FOURCC fccIOProc
,
1099 LPMMIOPROC pIOProc
, DWORD dwFlags
)
1101 return MMIO_InstallIOProc(fccIOProc
, pIOProc
, dwFlags
, TRUE
);
1104 /******************************************************************
1109 static LRESULT
MMIO_SendMessage(HMMIO hmmio
, UINT uMessage
, LPARAM lParam1
,
1110 LPARAM lParam2
, BOOL is_unicode
)
1114 TRACE("(%p, %u, %ld, %ld, %s)\n", hmmio
, uMessage
, lParam1
, lParam2
, is_unicode
? "unicode" : "ansi");
1116 if (uMessage
< MMIOM_USER
)
1117 return MMSYSERR_INVALPARAM
;
1119 if ((wm
= MMIO_Get(hmmio
)) == NULL
)
1120 return MMSYSERR_INVALHANDLE
;
1122 return send_message(wm
->ioProc
, &wm
->info
, uMessage
, lParam1
, lParam2
, is_unicode
);
1125 /**************************************************************************
1126 * mmioSendMessage [WINMM.@]
1128 LRESULT WINAPI
mmioSendMessage(HMMIO hmmio
, UINT uMessage
,
1129 LPARAM lParam1
, LPARAM lParam2
)
1131 return MMIO_SendMessage(hmmio
, uMessage
, lParam1
, lParam2
, FALSE
);
1134 /**************************************************************************
1135 * mmioDescend [WINMM.@]
1137 MMRESULT WINAPI
mmioDescend(HMMIO hmmio
, LPMMCKINFO lpck
,
1138 const MMCKINFO
* lpckParent
, UINT uFlags
)
1144 TRACE("(%p, %p, %p, %04X);\n", hmmio
, lpck
, lpckParent
, uFlags
);
1147 return MMSYSERR_INVALPARAM
;
1149 dwOldPos
= mmioSeek(hmmio
, 0, SEEK_CUR
);
1150 TRACE("dwOldPos=%d\n", dwOldPos
);
1152 if (lpckParent
!= NULL
) {
1153 TRACE("seek inside parent at %d !\n", lpckParent
->dwDataOffset
);
1154 /* EPP: was dwOldPos = mmioSeek(hmmio,lpckParent->dwDataOffset,SEEK_SET); */
1155 if (dwOldPos
< lpckParent
->dwDataOffset
||
1156 dwOldPos
>= lpckParent
->dwDataOffset
+ lpckParent
->cksize
) {
1157 WARN("outside parent chunk\n");
1158 return MMIOERR_CHUNKNOTFOUND
;
1162 /* The SDK docu says 'ckid' is used for all cases. Real World
1163 * examples disagree -Marcus,990216.
1169 /* find_chunk looks for 'ckid' */
1170 if (uFlags
& MMIO_FINDCHUNK
)
1171 srchCkId
= lpck
->ckid
;
1173 /* find_riff and find_list look for 'fccType' */
1174 if (uFlags
& MMIO_FINDLIST
)
1176 srchCkId
= FOURCC_LIST
;
1177 srchType
= lpck
->fccType
;
1180 if (uFlags
& MMIO_FINDRIFF
)
1182 srchCkId
= FOURCC_RIFF
;
1183 srchType
= lpck
->fccType
;
1186 TRACE("searching for %s.%s\n",
1187 debugstr_an((LPCSTR
)&srchCkId
, 4), srchType
? debugstr_an((LPCSTR
)&srchType
, 4) : "<any>");
1193 ix
= mmioRead(hmmio
, (LPSTR
)lpck
, 3 * sizeof(DWORD
));
1194 if (ix
< 2*sizeof(DWORD
))
1196 mmioSeek(hmmio
, dwOldPos
, SEEK_SET
);
1197 WARN("return ChunkNotFound\n");
1198 return MMIOERR_CHUNKNOTFOUND
;
1201 lpck
->dwDataOffset
= dwOldPos
+ 2 * sizeof(DWORD
);
1202 TRACE("ckid=%s fcc=%s cksize=%08X !\n",
1203 debugstr_an((LPCSTR
)&lpck
->ckid
, 4),
1204 srchType
? debugstr_an((LPCSTR
)&lpck
->fccType
, 4) : "<na>",
1206 if ( (!srchCkId
|| (srchCkId
== lpck
->ckid
)) &&
1207 (!srchType
|| (srchType
== lpck
->fccType
)) )
1210 dwOldPos
= lpck
->dwDataOffset
+ ((lpck
->cksize
+ 1) & ~1);
1211 mmioSeek(hmmio
, dwOldPos
, SEEK_SET
);
1215 /* If we were looking for RIFF/LIST chunks, the final file position
1216 * is after the chunkid. If we were just looking for the chunk
1217 * it is after the cksize. So add 4 in RIFF/LIST case.
1219 if (lpck
->ckid
== FOURCC_RIFF
|| lpck
->ckid
== FOURCC_LIST
)
1220 mmioSeek(hmmio
, lpck
->dwDataOffset
+ sizeof(DWORD
), SEEK_SET
);
1223 mmioSeek(hmmio
, lpck
->dwDataOffset
, SEEK_SET
);
1226 TRACE("lpck: ckid=%s, cksize=%d, dwDataOffset=%d fccType=%08X (%s)!\n",
1227 debugstr_an((LPSTR
)&lpck
->ckid
, 4), lpck
->cksize
, lpck
->dwDataOffset
,
1228 lpck
->fccType
, srchType
? debugstr_an((LPSTR
)&lpck
->fccType
, 4):"");
1229 return MMSYSERR_NOERROR
;
1232 /**************************************************************************
1233 * mmioAscend [WINMM.@]
1235 MMRESULT WINAPI
mmioAscend(HMMIO hmmio
, LPMMCKINFO lpck
, UINT uFlags
)
1237 TRACE("(%p, %p, %04X);\n", hmmio
, lpck
, uFlags
);
1239 if (lpck
->dwFlags
& MMIO_DIRTY
) {
1240 DWORD dwOldPos
, dwNewSize
;
1242 TRACE("Chunk is dirty, checking if chunk's size is correct\n");
1243 dwOldPos
= mmioSeek(hmmio
, 0, SEEK_CUR
);
1244 TRACE("dwOldPos=%d lpck->dwDataOffset = %d\n", dwOldPos
, lpck
->dwDataOffset
);
1245 dwNewSize
= dwOldPos
- lpck
->dwDataOffset
;
1246 if (dwNewSize
!= lpck
->cksize
) {
1247 TRACE("Nope: lpck->cksize=%d dwNewSize=%d\n", lpck
->cksize
, dwNewSize
);
1248 lpck
->cksize
= dwNewSize
;
1250 /* pad odd size with 0 */
1251 if (dwNewSize
& 1) {
1253 mmioWrite(hmmio
, &ch
, 1);
1255 mmioSeek(hmmio
, lpck
->dwDataOffset
- sizeof(DWORD
), SEEK_SET
);
1256 mmioWrite(hmmio
, (LPSTR
)&dwNewSize
, sizeof(DWORD
));
1261 mmioSeek(hmmio
, lpck
->dwDataOffset
+ ((lpck
->cksize
+ 1) & ~1), SEEK_SET
);
1263 return MMSYSERR_NOERROR
;
1266 /**************************************************************************
1267 * mmioCreateChunk [WINMM.@]
1269 MMRESULT WINAPI
mmioCreateChunk(HMMIO hmmio
, MMCKINFO
* lpck
, UINT uFlags
)
1275 TRACE("(%p, %p, %04X);\n", hmmio
, lpck
, uFlags
);
1277 dwOldPos
= mmioSeek(hmmio
, 0, SEEK_CUR
);
1278 TRACE("dwOldPos=%d\n", dwOldPos
);
1280 if (uFlags
== MMIO_CREATELIST
)
1281 lpck
->ckid
= FOURCC_LIST
;
1282 else if (uFlags
== MMIO_CREATERIFF
)
1283 lpck
->ckid
= FOURCC_RIFF
;
1285 TRACE("ckid=%s\n", debugstr_an((LPSTR
)&lpck
->ckid
, 4));
1287 size
= 2 * sizeof(DWORD
);
1288 lpck
->dwDataOffset
= dwOldPos
+ size
;
1290 if (lpck
->ckid
== FOURCC_RIFF
|| lpck
->ckid
== FOURCC_LIST
)
1291 size
+= sizeof(DWORD
);
1292 lpck
->dwFlags
= MMIO_DIRTY
;
1294 ix
= mmioWrite(hmmio
, (LPSTR
)lpck
, size
);
1295 TRACE("after mmioWrite ix = %d req = %d, errno = %d\n", ix
, size
, errno
);
1297 mmioSeek(hmmio
, dwOldPos
, SEEK_SET
);
1298 WARN("return CannotWrite\n");
1299 return MMIOERR_CANNOTWRITE
;
1302 return MMSYSERR_NOERROR
;
1305 /**************************************************************************
1306 * mmioRenameA [WINMM.@]
1308 MMRESULT WINAPI
mmioRenameA(LPCSTR szFileName
, LPCSTR szNewFileName
,
1309 const MMIOINFO
* lpmmioinfo
, DWORD dwFlags
)
1311 struct IOProcList
* ioProc
= NULL
;
1312 struct IOProcList tmp
;
1315 TRACE("(%s, %s, %p, %08X);\n",
1316 debugstr_a(szFileName
), debugstr_a(szNewFileName
), lpmmioinfo
, dwFlags
);
1318 /* If both params are NULL, then parse the file name */
1319 if (lpmmioinfo
&& lpmmioinfo
->fccIOProc
== 0 && lpmmioinfo
->pIOProc
== NULL
)
1321 fcc
= MMIO_ParseExtA(szFileName
);
1322 if (fcc
) ioProc
= MMIO_FindProcNode(fcc
);
1325 /* Handle any unhandled/error case from above. Assume DOS file */
1326 if (!lpmmioinfo
|| (lpmmioinfo
->fccIOProc
== 0 && lpmmioinfo
->pIOProc
== NULL
&& ioProc
== NULL
))
1327 ioProc
= &defaultProcs
[0];
1328 /* if just the four character code is present, look up IO proc */
1329 else if (lpmmioinfo
->pIOProc
== NULL
)
1330 ioProc
= MMIO_FindProcNode(lpmmioinfo
->fccIOProc
);
1331 else /* use relevant ioProc */
1334 tmp
.fourCC
= lpmmioinfo
->fccIOProc
;
1335 tmp
.pIOProc
= lpmmioinfo
->pIOProc
;
1336 tmp
.is_unicode
= FALSE
;
1340 /* FIXME: should we actually pass lpmmioinfo down the drain ???
1341 * or make a copy of it because it's const ???
1343 return send_message(ioProc
, (MMIOINFO
*)lpmmioinfo
, MMIOM_RENAME
,
1344 (LPARAM
)szFileName
, (LPARAM
)szNewFileName
, FALSE
);
1347 /**************************************************************************
1348 * mmioRenameW [WINMM.@]
1350 MMRESULT WINAPI
mmioRenameW(LPCWSTR szFileName
, LPCWSTR szNewFileName
,
1351 const MMIOINFO
* lpmmioinfo
, DWORD dwFlags
)
1355 UINT ret
= MMSYSERR_NOMEM
;
1360 len
= WideCharToMultiByte( CP_ACP
, 0, szFileName
, -1, NULL
, 0, NULL
, NULL
);
1361 szFn
= HeapAlloc( GetProcessHeap(), 0, len
);
1362 if (!szFn
) goto done
;
1363 WideCharToMultiByte( CP_ACP
, 0, szFileName
, -1, szFn
, len
, NULL
, NULL
);
1367 len
= WideCharToMultiByte( CP_ACP
, 0, szNewFileName
, -1, NULL
, 0, NULL
, NULL
);
1368 sznFn
= HeapAlloc( GetProcessHeap(), 0, len
);
1369 if (!sznFn
) goto done
;
1370 WideCharToMultiByte( CP_ACP
, 0, szNewFileName
, -1, sznFn
, len
, NULL
, NULL
);
1373 ret
= mmioRenameA(szFn
, sznFn
, lpmmioinfo
, dwFlags
);
1376 HeapFree(GetProcessHeap(),0,szFn
);
1377 HeapFree(GetProcessHeap(),0,sznFn
);