?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Removed trailing whitespace.
[wine/wine-gecko.git] / dlls / winmm / mmio.c
blob61e80c31080df62ec775f04be6ea92163446e1b2
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2 /*
3 * MMIO functions
4 *
5 * Copyright 1998 Andrew Taylor
6 * Copyright 1998 Ove Kåven
7 * Copyright 2000 Eric Pouech
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24 /* Still to be done:
25 * + correct handling of global/local IOProcs
26 * + mode of mmio objects is not used (read vs write vs readwrite)
27 * + optimization of internal buffers (seg / lin)
28 * + even in 32 bit only, a seg ptr IO buffer is allocated (after this is
29 * fixed, we'll have a proper 32/16 separation)
30 * + thread safeness
31 * + rename operation is broken
32 */
33
34 #include <ctype.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <errno.h>
38 #include <assert.h>
39
40 #include "mmsystem.h"
41 #include "windef.h"
42
43 #include "wine/mmsystem16.h"
44 #include "wine/winbase16.h"
45 #include "heap.h"
46 #include "winemm.h"
47
48 #include "wine/debug.h"
49
50 WINE_DEFAULT_DEBUG_CHANNEL(mmio);
51
52 /**************************************************************************
53 * mmioDosIOProc [internal]
54 */
55 static LRESULT CALLBACK mmioDosIOProc(LPMMIOINFO lpmmioinfo, UINT uMessage,
56 LPARAM lParam1, LPARAM lParam2)
57 {
58 LRESULT ret = MMSYSERR_NOERROR;
59
60 TRACE("(%p, %X, 0x%lx, 0x%lx);\n", lpmmioinfo, uMessage, lParam1, lParam2);
61
62 switch (uMessage) {
63 case MMIOM_OPEN:
64 {
65 /* Parameters:
66 * lParam1 = szFileName parameter from mmioOpen
67 * lParam2 = reserved (we use it for 16-bitness)
68 * Returns: zero on success, error code on error
69 * NOTE: lDiskOffset automatically set to zero
70 */
71 OFSTRUCT ofs;
72 LPCSTR szFileName = (LPCSTR)lParam1;
73
74 if (lpmmioinfo->dwFlags & MMIO_GETTEMP) {
75 FIXME("MMIO_GETTEMP not implemented\n");
76 return MMIOERR_CANNOTOPEN;
77 }
78
79 /* if filename NULL, assume open file handle in adwInfo[0] */
80 if (!szFileName) {
81 if (lParam2)
82 lpmmioinfo->adwInfo[0] = DosFileHandleToWin32Handle(lpmmioinfo->adwInfo[0]);
83 break;
84 }
85 lpmmioinfo->adwInfo[0] = (DWORD)OpenFile(szFileName, &ofs, lpmmioinfo->dwFlags & 0xFFFF);
86 if (lpmmioinfo->adwInfo[0] == (DWORD)HFILE_ERROR)
87 ret = MMIOERR_CANNOTOPEN;
88 }
89 break;
90
91 case MMIOM_CLOSE:
92 /* Parameters:
93 * lParam1 = wFlags parameter from mmioClose
94 * lParam2 = unused
95 * Returns: zero on success, error code on error
96 */
97 if (!(lParam1 & MMIO_FHOPEN))
98 _lclose((HFILE)lpmmioinfo->adwInfo[0]);
99 break;
100
101 case MMIOM_READ:
102 /* Parameters:
103 * lParam1 = huge pointer to read buffer
104 * lParam2 = number of bytes to read
105 * Returns: number of bytes read, 0 for EOF, -1 for error (error code
106 * in wErrorRet)
107 */
108 ret = _lread((HFILE)lpmmioinfo->adwInfo[0], (HPSTR)lParam1, (LONG)lParam2);
109 if (ret != -1)
110 lpmmioinfo->lDiskOffset += ret;
111
112 break;
113
114 case MMIOM_WRITE:
115 case MMIOM_WRITEFLUSH:
116 /* no internal buffering, so WRITEFLUSH handled same as WRITE */
117
118 /* Parameters:
119 * lParam1 = huge pointer to write buffer
120 * lParam2 = number of bytes to write
121 * Returns: number of bytes written, -1 for error (error code in
122 * wErrorRet)
123 */
124 ret = _hwrite((HFILE)lpmmioinfo->adwInfo[0], (HPSTR)lParam1, (LONG)lParam2);
125 if (ret != -1)
126 lpmmioinfo->lDiskOffset += ret;
127 break;
128
129 case MMIOM_SEEK:
130 /* Parameters:
131 * lParam1 = new position
132 * lParam2 = from whence to seek (SEEK_SET, SEEK_CUR, SEEK_END)
133 * Returns: new file postion, -1 on error
134 */
135 ret = _llseek((HFILE)lpmmioinfo->adwInfo[0], (LONG)lParam1, (LONG)lParam2);
136 if (ret != -1)
137 lpmmioinfo->lDiskOffset = ret;
138 return ret;
139
140 case MMIOM_RENAME:
141 /* Parameters:
142 * lParam1 = old name
143 * lParam2 = new name
144 * Returns: zero on success, non-zero on failure
145 */
146 if (!MoveFileA((const char*)lParam1, (const char*)lParam2))
147 ret = MMIOERR_FILENOTFOUND;
148 break;
149
150 default:
151 FIXME("unexpected message %u\n", uMessage);
152 return 0;
153 }
154
155 return ret;
156 }
157
158 /**************************************************************************
159 * mmioMemIOProc [internal]
160 */
161 static LRESULT CALLBACK mmioMemIOProc(LPMMIOINFO lpmmioinfo, UINT uMessage,
162 LPARAM lParam1, LPARAM lParam2)
163 {
164 TRACE("(%p,0x%04x,0x%08lx,0x%08lx)\n", lpmmioinfo, uMessage, lParam1, lParam2);
165
166 switch (uMessage) {
167
168 case MMIOM_OPEN:
169 /* Parameters:
170 * lParam1 = filename (must be NULL)
171 * lParam2 = reserved (we use it for 16-bitness)
172 * Returns: zero on success, error code on error
173 * NOTE: lDiskOffset automatically set to zero
174 */
175 /* FIXME: io proc shouldn't change it */
176 if (!(lpmmioinfo->dwFlags & MMIO_CREATE))
177 lpmmioinfo->pchEndRead = lpmmioinfo->pchEndWrite;
178 lpmmioinfo->adwInfo[0] = HFILE_ERROR;
179 return 0;
180
181 case MMIOM_CLOSE:
182 /* Parameters:
183 * lParam1 = wFlags parameter from mmioClose
184 * lParam2 = unused
185 * Returns: zero on success, error code on error
186 */
187 return 0;
188
189 case MMIOM_READ:
190 /* Parameters:
191 * lParam1 = huge pointer to read buffer
192 * lParam2 = number of bytes to read
193 * Returns: number of bytes read, 0 for EOF, -1 for error (error code
194 * in wErrorRet)
195 * NOTE: lDiskOffset should be updated
196 */
197 FIXME("MMIOM_READ on memory files should not occur, buffer may be lost!\n");
198 return 0;
199
200 case MMIOM_WRITE:
201 case MMIOM_WRITEFLUSH:
202 /* no internal buffering, so WRITEFLUSH handled same as WRITE */
203
204 /* Parameters:
205 * lParam1 = huge pointer to write buffer
206 * lParam2 = number of bytes to write
207 * Returns: number of bytes written, -1 for error (error code in
208 * wErrorRet)
209 * NOTE: lDiskOffset should be updated
210 */
211 FIXME("MMIOM_WRITE on memory files should not occur, buffer may be lost!\n");
212 return 0;
213
214 case MMIOM_SEEK:
215 /* Parameters:
216 * lParam1 = new position
217 * lParam2 = from whence to seek (SEEK_SET, SEEK_CUR, SEEK_END)
218 * Returns: new file postion, -1 on error
219 * NOTE: lDiskOffset should be updated
220 */
221 FIXME("MMIOM_SEEK on memory files should not occur, buffer may be lost!\n");
222 return -1;
223
224 default:
225 FIXME("unexpected message %u\n", uMessage);
226 return 0;
227 }
228
229 return 0;
230 }
231
232
233 enum mmioProcType {MMIO_PROC_16,MMIO_PROC_32A,MMIO_PROC_32W};
234
235 struct IOProcList
236 {
237 struct IOProcList*pNext; /* Next item in linked list */
238 FOURCC fourCC; /* four-character code identifying IOProc */
239 LPMMIOPROC pIOProc; /* pointer to IProc */
240 enum mmioProcType type; /* 16, 32A or 32W */
241 int count; /* number of objects linked to it */
242 };
243
244 /* This array will be the entire list for most apps */
245
246 static struct IOProcList defaultProcs[] = {
247 {&defaultProcs[1], FOURCC_DOS, (LPMMIOPROC)mmioDosIOProc, MMIO_PROC_32A, 0},
248 {NULL, FOURCC_MEM, (LPMMIOPROC)mmioMemIOProc, MMIO_PROC_32A, 0},
249 };
250
251 static struct IOProcList* pIOProcListAnchor = &defaultProcs[0];
252
253 /****************************************************************
254 * MMIO_FindProcNode [INTERNAL]
255 *
256 * Finds the ProcList node associated with a given FOURCC code.
257 */
258 static struct IOProcList* MMIO_FindProcNode(FOURCC fccIOProc)
259 {
260 struct IOProcList* pListNode;
261
262 for (pListNode = pIOProcListAnchor; pListNode; pListNode = pListNode->pNext) {
263 if (pListNode->fourCC == fccIOProc) {
264 return pListNode;
265 }
266 }
267 return NULL;
268 }
269
270 /****************************************************************
271 * MMIO_InstallIOProc [INTERNAL]
272 */
273 static LPMMIOPROC MMIO_InstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc,
274 DWORD dwFlags, enum mmioProcType type)
275 {
276 LPMMIOPROC lpProc = NULL;
277 struct IOProcList* pListNode;
278 struct IOProcList** ppListNode;
279
280 TRACE("(%ld, %p, %08lX, %i)\n", fccIOProc, pIOProc, dwFlags, type);
281
282 if (dwFlags & MMIO_GLOBALPROC)
283 FIXME("Global procedures not implemented\n");
284
285 /* just handle the known procedures for now */
286 switch (dwFlags & (MMIO_INSTALLPROC|MMIO_REMOVEPROC|MMIO_FINDPROC)) {
287 case MMIO_INSTALLPROC:
288 /* Create new entry for the IOProc list */
289 pListNode = HeapAlloc(GetProcessHeap(), 0, sizeof(*pListNode));
290 if (pListNode) {
291 /* Fill in this node */
292 pListNode->fourCC = fccIOProc;
293 pListNode->pIOProc = pIOProc;
294 pListNode->type = type;
295 pListNode->count = 0;
296
297 /* Stick it on the end of the list */
298 pListNode->pNext = pIOProcListAnchor;
299 pIOProcListAnchor = pListNode;
300
301 /* Return this IOProc - that's how the caller knows we succeeded */
302 lpProc = pIOProc;
303 }
304 break;
305
306 case MMIO_REMOVEPROC:
307 /*
308 * Search for the node that we're trying to remove - note
309 * that this method won't find the first item on the list, but
310 * since the first two items on this list are ones we won't
311 * let the user delete anyway, that's okay
312 */
313 ppListNode = &pIOProcListAnchor;
314 while ((*ppListNode) && (*ppListNode)->fourCC != fccIOProc)
315 ppListNode = &((*ppListNode)->pNext);
316
317 if (*ppListNode) { /* found it */
318 /* FIXME: what should be done if an open mmio object uses this proc ?
319 * shall we return an error, nuke the mmio object ?
320 */
321 if ((*ppListNode)->count) {
322 ERR("Cannot remove a mmIOProc while in use\n");
323 break;
324 }
325 /* remove it, but only if it isn't builtin */
326 if ((*ppListNode) >= defaultProcs &&
327 (*ppListNode) < defaultProcs + sizeof(defaultProcs)) {
328 WARN("Tried to remove built-in mmio proc. Skipping\n");
329 } else {
330 /* Okay, nuke it */
331 struct IOProcList* ptmpNode = *ppListNode;
332 lpProc = (*ppListNode)->pIOProc;
333 *ppListNode = (*ppListNode)->pNext;
334 HeapFree(GetProcessHeap(), 0, ptmpNode);
335 }
336 }
337 break;
338
339 case MMIO_FINDPROC:
340 if ((pListNode = MMIO_FindProcNode(fccIOProc))) {
341 lpProc = pListNode->pIOProc;
342 }
343 break;
344 }
345
346 return lpProc;
347 }
348
349 /****************************************************************
350 * MMIO_Map32To16 [INTERNAL]
351 */
352 static LRESULT MMIO_Map32To16(DWORD wMsg, LPARAM* lp1, LPARAM* lp2)
353 {
354 switch (wMsg) {
355 case MMIOM_CLOSE:
356 case MMIOM_SEEK:
357 /* nothing to do */
358 break;
359 case MMIOM_OPEN:
360 case MMIOM_READ:
361 case MMIOM_WRITE:
362 case MMIOM_WRITEFLUSH:
363 *lp1 = MapLS( (void *)*lp1 );
364 break;
365 default:
366 TRACE("Not a mappable message (%ld)\n", wMsg);
367 }
368 return MMSYSERR_NOERROR;
369 }
370
371 /****************************************************************
372 * MMIO_UnMap32To16 [INTERNAL]
373 */
374 static LRESULT MMIO_UnMap32To16(DWORD wMsg, LPARAM lParam1, LPARAM lParam2,
375 LPARAM lp1, LPARAM lp2)
376 {
377 switch (wMsg) {
378 case MMIOM_CLOSE:
379 case MMIOM_SEEK:
380 /* nothing to do */
381 break;
382 case MMIOM_OPEN:
383 case MMIOM_READ:
384 case MMIOM_WRITE:
385 case MMIOM_WRITEFLUSH:
386 UnMapLS( lp1 );
387 break;
388 default:
389 TRACE("Not a mappable message (%ld)\n", wMsg);
390 }
391 return MMSYSERR_NOERROR;
392 }
393
394 /****************************************************************
395 * MMIO_SendMessage [INTERNAL]
396 */
397 static LRESULT MMIO_SendMessage(LPWINE_MMIO wm, DWORD wMsg, LPARAM lParam1,
398 LPARAM lParam2, enum mmioProcType type)
399 {
400 MMIOINFO16 mmioInfo16;
401 LRESULT result;
402 SEGPTR segmmioInfo16;
403 LPARAM lp1 = lParam1, lp2 = lParam2;
404
405 if (!wm->ioProc || !wm->info.pIOProc) {
406 ERR("brrr\n");
407 result = MMSYSERR_INVALPARAM;
408 }
409
410 switch (wm->ioProc->type) {
411 case MMIO_PROC_16:
412 memset( &mmioInfo16, 0, sizeof(MMIOINFO16));
413 mmioInfo16.lDiskOffset = wm->info.lDiskOffset;
414 mmioInfo16.adwInfo[0] = wm->info.adwInfo[0];
415 mmioInfo16.adwInfo[1] = wm->info.adwInfo[1];
416 mmioInfo16.adwInfo[2] = wm->info.adwInfo[2];
417 mmioInfo16.adwInfo[3] = wm->info.adwInfo[3];
418 if (wm->ioProc->type != type) {
419 /* map (lParam1, lParam2) into (lp1, lp2) 32=>16 */
420 if ((result = MMIO_Map32To16(wMsg, &lp1, &lp2)) != MMSYSERR_NOERROR)
421 return result;
422 }
423 /* FIXME: is wm->info.pIOProc a segmented or a linear address ?
424 * sounds to me it's a segmented one, should use a thunk somewhere
425 */
426 segmmioInfo16 = MapLS( &mmioInfo16 );
427 result = ((LPMMIOPROC16)wm->info.pIOProc)((LPSTR)segmmioInfo16, wMsg, lp1, lp2);
428 UnMapLS( segmmioInfo16 );
429 if (wm->ioProc->type != type) {
430 MMIO_UnMap32To16(wMsg, lParam1, lParam2, lp1, lp2);
431 }
432 wm->info.lDiskOffset = mmioInfo16.lDiskOffset;
433 wm->info.adwInfo[0] = mmioInfo16.adwInfo[0];
434 wm->info.adwInfo[1] = mmioInfo16.adwInfo[1];
435 wm->info.adwInfo[2] = mmioInfo16.adwInfo[2];
436 wm->info.adwInfo[3] = mmioInfo16.adwInfo[3];
437 break;
438 case MMIO_PROC_32A:
439 case MMIO_PROC_32W:
440 if (wm->ioProc->type != type) {
441 /* map (lParam1, lParam2) into (lp1, lp2) 16=>32 */
442 WARN("NIY\n");
443 }
444 result = (wm->info.pIOProc)((LPSTR)&wm->info, wMsg, lp1, lp2);
445
446 #if 0
447 if (wm->ioProc->type != type) {
448 /* unmap (lParam1, lParam2) into (lp1, lp2) 16=>32 */
449 }
450 #endif
451 break;
452 default:
453 FIXME("Internal error\n");
454 result = MMSYSERR_ERROR;
455 }
456
457 return result;
458 }
459
460 /**************************************************************************
461 * MMIO_ParseExt [internal]
462 *
463 * Parses a filename for the extension.
464 *
465 * RETURNS
466 * The FOURCC code for the extension if found, else 0.
467 */
468 static FOURCC MMIO_ParseExt(LPCSTR szFileName)
469 {
470 /* Filenames are of the form file.ext+ABC
471 FIXME: What if a '+' is part of the file name?
472 For now, we take the last '+' present */
473
474 FOURCC ret = 0;
475
476 /* Note that ext{Start,End} point to the . and + respectively */
477 LPSTR extEnd;
478
479 TRACE("(%s)\n",debugstr_a(szFileName));
480
481 if (!szFileName)
482 return ret;
483 extEnd = strrchr(szFileName,'+');
484 if (extEnd) {
485 /* Need to parse to find the extension */
486 LPSTR extStart;
487
488 extStart = extEnd;
489 while (extStart >= szFileName && extStart[0] != '.') {
490 extStart--;
491 }
492
493 if (extStart < szFileName) {
494 ERR("+ but no . in szFileName: %s\n", debugstr_a(szFileName));
495 } else {
496 CHAR ext[5];
497
498 if (extEnd - extStart - 1 > 4)
499 WARN("Extension length > 4\n");
500 lstrcpynA(ext,extStart + 1,min(extEnd-extStart,5));
501 TRACE("Got extension: %s\n", debugstr_a(ext));
502 /* FOURCC codes identifying file-extensions must be uppercase */
503 ret = mmioStringToFOURCCA(ext, MMIO_TOUPPER);
504 }
505 }
506 return ret;
507 }
508
509 /**************************************************************************
510 * MMIO_Get [internal]
511 *
512 * Retrieves the mmio object from current process
513 */
514 static LPWINE_MMIO MMIO_Get(LPWINE_MM_IDATA iData, HMMIO h)
515 {
516 LPWINE_MMIO wm = NULL;
517
518 if (!iData) iData = MULTIMEDIA_GetIData();
519
520 EnterCriticalSection(&iData->cs);
521 for (wm = iData->lpMMIO; wm; wm = wm->lpNext) {
522 if (wm->info.hmmio == h)
523 break;
524 }
525 LeaveCriticalSection(&iData->cs);
526 return wm;
527 }
528
529 /**************************************************************************
530 * MMIO_Create [internal]
531 *
532 * Creates an internal representation for a mmio instance
533 */
534 static LPWINE_MMIO MMIO_Create(void)
535 {
536 static WORD MMIO_counter = 0;
537 LPWINE_MMIO wm;
538 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
539
540 wm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MMIO));
541 if (wm) {
542 EnterCriticalSection(&iData->cs);
543 while (MMIO_Get(iData, ++MMIO_counter));
544 wm->info.hmmio = MMIO_counter;
545 wm->lpNext = iData->lpMMIO;
546 iData->lpMMIO = wm;
547 LeaveCriticalSection(&iData->cs);
548 }
549 return wm;
550 }
551
552 /**************************************************************************
553 * MMIO_Destroy [internal]
554 *-
555 * Destroys an internal representation for a mmio instance
556 */
557 static BOOL MMIO_Destroy(LPWINE_MMIO wm)
558 {
559 LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
560 LPWINE_MMIO* m;
561
562 EnterCriticalSection(&iData->cs);
563 /* search for the matching one... */
564 m = &(iData->lpMMIO);
565 while (*m && *m != wm) m = &(*m)->lpNext;
566 /* ...and destroy */
567 if (*m) {
568 *m = (*m)->lpNext;
569 HeapFree(GetProcessHeap(), 0, wm);
570 wm = NULL;
571 }
572 LeaveCriticalSection(&iData->cs);
573 return wm ? FALSE : TRUE;
574 }
575
576 /****************************************************************
577 * MMIO_Flush [INTERNAL]
578 */
579 static MMRESULT MMIO_Flush(WINE_MMIO* wm, UINT uFlags)
580 {
581 if (wm->info.cchBuffer && (wm->info.fccIOProc != FOURCC_MEM)) {
582 /* not quite sure what to do here, but I'll guess */
583 if (wm->info.dwFlags & MMIO_DIRTY) {
584 /* FIXME: error handling */
585 MMIO_SendMessage(wm, MMIOM_SEEK, wm->info.lBufOffset,
586 SEEK_SET, MMIO_PROC_32A);
587 MMIO_SendMessage(wm, MMIOM_WRITE, (LPARAM)wm->info.pchBuffer,
588 wm->info.pchNext - wm->info.pchBuffer, MMIO_PROC_32A);
589 }
590 if (uFlags & MMIO_EMPTYBUF)
591 wm->info.pchNext = wm->info.pchEndRead = wm->info.pchBuffer;
592 }
593 wm->info.dwFlags &= ~MMIO_DIRTY;
594
595 return MMSYSERR_NOERROR;
596 }
597
598 /***************************************************************************
599 * MMIO_GrabNextBuffer [INTERNAL]
600 */
601 static LONG MMIO_GrabNextBuffer(LPWINE_MMIO wm, int for_read)
602 {
603 LONG size = wm->info.cchBuffer;
604
605 TRACE("bo=%lx do=%lx of=%lx\n",
606 wm->info.lBufOffset, wm->info.lDiskOffset,
607 MMIO_SendMessage(wm, MMIOM_SEEK, 0, SEEK_CUR, MMIO_PROC_32A));
608
609 wm->info.lBufOffset = wm->info.lDiskOffset;
610 wm->info.pchNext = wm->info.pchBuffer;
611 wm->info.pchEndRead = wm->info.pchBuffer;
612 wm->info.pchEndWrite = wm->info.pchBuffer + wm->info.cchBuffer;
613
614 if (for_read) {
615 size = MMIO_SendMessage(wm, MMIOM_READ, (LPARAM)wm->info.pchBuffer,
616 size, MMIO_PROC_32A);
617 if (size > 0)
618 wm->info.pchEndRead += size;
619 }
620
621 wm->bBufferLoaded = TRUE;
622 return size;
623 }
624
625 /***************************************************************************
626 * MMIO_SetBuffer [INTERNAL]
627 */
628 static MMRESULT MMIO_SetBuffer(WINE_MMIO* wm, void* pchBuffer, LONG cchBuffer,
629 UINT uFlags, BOOL bFrom32)
630 {
631 TRACE("(%p %p %ld %u %d)\n", wm, pchBuffer, cchBuffer, uFlags, bFrom32);
632
633 if (uFlags) return MMSYSERR_INVALPARAM;
634 if (cchBuffer > 0xFFFF)
635 WARN("Untested handling of huge mmio buffers (%ld >= 64k)\n", cchBuffer);
636
637 if (MMIO_Flush(wm, 0) != MMSYSERR_NOERROR)
638 return MMIOERR_CANNOTWRITE;
639
640 if (wm->hMem && (wm->info.dwFlags & MMIO_ALLOCBUF)) {
641 GlobalUnlock16(wm->hMem);
642 GlobalFree16(wm->hMem);
643 wm->hMem = 0;
644 wm->info.dwFlags &= ~MMIO_ALLOCBUF;
645 }
646
647 if (pchBuffer) {
648 if (bFrom32) {
649 wm->info.pchBuffer = pchBuffer;
650 wm->buffer16 = 0;
651 } else {
652 wm->info.pchBuffer = MapSL((SEGPTR)pchBuffer);
653 wm->buffer16 = (SEGPTR)pchBuffer;
654 }
655 wm->hMem = 0;
656 } else if (cchBuffer) {
657 if (!(wm->hMem = GlobalAlloc16(GMEM_MOVEABLE, cchBuffer)))
658 return MMIOERR_OUTOFMEMORY;
659 wm->info.dwFlags |= MMIO_ALLOCBUF;
660 } else {
661 wm->info.pchBuffer = NULL;
662 wm->hMem = 0;
663 wm->buffer16 = 0;
664 }
665
666 if (wm->hMem) {
667 wm->buffer16 = K32WOWGlobalLock16(wm->hMem);
668 wm->info.pchBuffer = MapSL(wm->buffer16);
669 }
670
671 wm->info.cchBuffer = cchBuffer;
672 wm->info.pchNext = wm->info.pchBuffer;
673 wm->info.pchEndRead = wm->info.pchBuffer;
674 wm->info.pchEndWrite = wm->info.pchBuffer + cchBuffer;
675 wm->info.lBufOffset = 0;
676 wm->bBufferLoaded = FALSE;
677
678 return MMSYSERR_NOERROR;
679 }
680
681 /**************************************************************************
682 * MMIO_Open [internal]
683 */
684 static HMMIO MMIO_Open(LPSTR szFileName, MMIOINFO* refmminfo,
685 DWORD dwOpenFlags, enum mmioProcType type)
686 {
687 LPWINE_MMIO wm;
688
689 TRACE("('%s', %p, %08lX, %d);\n", szFileName, refmminfo, dwOpenFlags, type);
690
691 if (dwOpenFlags & (MMIO_PARSE|MMIO_EXIST)) {
692 char buffer[MAX_PATH];
693
694 if (GetFullPathNameA(szFileName, sizeof(buffer), buffer, NULL) >= sizeof(buffer))
695 return (HMMIO16)FALSE;
696 if ((dwOpenFlags & MMIO_EXIST) && (GetFileAttributesA(buffer) == -1))
697 return (HMMIO)FALSE;
698 strcpy(szFileName, buffer);
699 return (HMMIO)TRUE;
700 }
701
702 if ((wm = MMIO_Create()) == NULL)
703 return 0;
704
705 /* If both params are NULL, then parse the file name if available */
706 if (refmminfo->fccIOProc == 0 && refmminfo->pIOProc == NULL) {
707 wm->info.fccIOProc = MMIO_ParseExt(szFileName);
708 /* Handle any unhandled/error case. Assume DOS file */
709 if (wm->info.fccIOProc == 0)
710 wm->info.fccIOProc = FOURCC_DOS;
711 if (!(wm->ioProc = MMIO_FindProcNode(wm->info.fccIOProc))) goto error2;
712 wm->info.pIOProc = wm->ioProc->pIOProc;
713 wm->bTmpIOProc = FALSE;
714 }
715 /* if just the four character code is present, look up IO proc */
716 else if (refmminfo->pIOProc == NULL) {
717 wm->info.fccIOProc = refmminfo->fccIOProc;
718 if (!(wm->ioProc = MMIO_FindProcNode(wm->info.fccIOProc))) goto error2;
719 wm->info.pIOProc = wm->ioProc->pIOProc;
720 wm->bTmpIOProc = FALSE;
721 }
722 /* if IO proc specified, use it and specified four character code */
723 else {
724 wm->info.fccIOProc = refmminfo->fccIOProc;
725 wm->info.pIOProc = refmminfo->pIOProc;
726 MMIO_InstallIOProc(wm->info.fccIOProc, wm->info.pIOProc,
727 MMIO_INSTALLPROC, type);
728 if (!(wm->ioProc = MMIO_FindProcNode(wm->info.fccIOProc))) goto error2;
729 assert(wm->ioProc->pIOProc == refmminfo->pIOProc);
730 wm->info.pIOProc = wm->ioProc->pIOProc;
731 wm->bTmpIOProc = TRUE;
732 }
733
734 wm->bBufferLoaded = FALSE;
735 wm->ioProc->count++;
736
737 if (dwOpenFlags & MMIO_ALLOCBUF) {
738 if ((refmminfo->wErrorRet = MMIO_SetBuffer(wm, NULL, MMIO_DEFAULTBUFFER, 0,
739 type != MMIO_PROC_16)))
740 goto error1;
741 } else if (wm->info.fccIOProc == FOURCC_MEM) {
742 refmminfo->wErrorRet = MMIO_SetBuffer(wm, refmminfo->pchBuffer,
743 refmminfo->cchBuffer, 0,
744 type != MMIO_PROC_16);
745 if (refmminfo->wErrorRet != MMSYSERR_NOERROR)
746 goto error1;
747 wm->bBufferLoaded = TRUE;
748 } /* else => unbuffered, wm->info.pchBuffer == NULL */
749
750 /* see mmioDosIOProc for that one */
751 wm->info.adwInfo[0] = refmminfo->adwInfo[0];
752 wm->info.dwFlags = dwOpenFlags;
753
754 /* call IO proc to actually open file */
755 refmminfo->wErrorRet = MMIO_SendMessage(wm, MMIOM_OPEN, (LPARAM)szFileName,
756 type == MMIO_PROC_16, MMIO_PROC_32A);
757
758 /* grab file size, when possible */
759 wm->dwFileSize = GetFileSize(wm->info.adwInfo[0], NULL);
760
761 if (refmminfo->wErrorRet == 0)
762 return wm->info.hmmio;
763 error1:
764 if (wm->ioProc) wm->ioProc->count--;
765 error2:
766 MMIO_Destroy(wm);
767 return 0;
768 }
769
770 /**************************************************************************
771 * mmioOpenW [WINMM.@]
772 */
773 HMMIO WINAPI mmioOpenW(LPWSTR szFileName, MMIOINFO* lpmmioinfo,
774 DWORD dwOpenFlags)
775 {
776 HMMIO ret;
777 LPSTR szFn = HEAP_strdupWtoA(GetProcessHeap(), 0, szFileName);
778
779 if (lpmmioinfo) {
780 ret = MMIO_Open(szFn, lpmmioinfo, dwOpenFlags, MMIO_PROC_32W);
781 } else {
782 MMIOINFO mmioinfo;
783
784 mmioinfo.fccIOProc = 0;
785 mmioinfo.pIOProc = NULL;
786 mmioinfo.pchBuffer = NULL;
787 mmioinfo.cchBuffer = 0;
788
789 ret = MMIO_Open(szFn, &mmioinfo, dwOpenFlags, MMIO_PROC_32W);
790 }
791
792 HeapFree(GetProcessHeap(), 0, szFn);
793 return ret;
794 }
795
796 /**************************************************************************
797 * mmioOpenA [WINMM.@]
798 */
799 HMMIO WINAPI mmioOpenA(LPSTR szFileName, MMIOINFO* lpmmioinfo,
800 DWORD dwOpenFlags)
801 {
802 HMMIO ret;
803
804 if (lpmmioinfo) {
805 ret = MMIO_Open(szFileName, lpmmioinfo, dwOpenFlags, MMIO_PROC_32A);
806 } else {
807 MMIOINFO mmioinfo;
808
809 mmioinfo.fccIOProc = 0;
810 mmioinfo.pIOProc = NULL;
811 mmioinfo.pchBuffer = NULL;
812 mmioinfo.cchBuffer = 0;
813
814 ret = MMIO_Open(szFileName, &mmioinfo, dwOpenFlags, MMIO_PROC_32A);
815 }
816 return ret;
817 }
818
819 /**************************************************************************
820 * mmioOpen [MMSYSTEM.1210]
821 */
822 HMMIO16 WINAPI mmioOpen16(LPSTR szFileName, MMIOINFO16* lpmmioinfo16,
823 DWORD dwOpenFlags)
824 {
825 HMMIO ret;
826 MMIOINFO mmio;
827
828 if (lpmmioinfo16) {
829 MMIOINFO mmioinfo;
830
831 memset(&mmioinfo, 0, sizeof(mmioinfo));
832
833 mmioinfo.dwFlags = lpmmioinfo16->dwFlags;
834 mmioinfo.fccIOProc = lpmmioinfo16->fccIOProc;
835 mmioinfo.pIOProc = (LPMMIOPROC)lpmmioinfo16->pIOProc;
836 mmioinfo.cchBuffer = lpmmioinfo16->cchBuffer;
837 mmioinfo.pchBuffer = lpmmioinfo16->pchBuffer;
838 mmioinfo.adwInfo[0] = lpmmioinfo16->adwInfo[0];
839 mmioinfo.adwInfo[1] = lpmmioinfo16->adwInfo[1];
840 mmioinfo.adwInfo[2] = lpmmioinfo16->adwInfo[2];
841 mmioinfo.adwInfo[3] = lpmmioinfo16->adwInfo[3];
842
843 ret = MMIO_Open(szFileName, &mmioinfo, dwOpenFlags, MMIO_PROC_16);
844
845 mmioGetInfo16(mmioinfo.hmmio, lpmmioinfo16, 0);
846 lpmmioinfo16->wErrorRet = ret;
847 } else {
848 mmio.fccIOProc = 0;
849 mmio.pIOProc = NULL;
850 mmio.pchBuffer = NULL;
851 mmio.cchBuffer = 0;
852 ret = MMIO_Open(szFileName, &mmio, dwOpenFlags, FALSE);
853 }
854 return ret;
855 }
856
857
858 /**************************************************************************
859 * mmioClose [WINMM.@]
860 */
861 MMRESULT WINAPI mmioClose(HMMIO hmmio, UINT uFlags)
862 {
863 LPWINE_MMIO wm;
864 MMRESULT result;
865
866 TRACE("(%04X, %04X);\n", hmmio, uFlags);
867
868 if ((wm = MMIO_Get(NULL, hmmio)) == NULL)
869 return MMSYSERR_INVALHANDLE;
870
871 if ((result = MMIO_Flush(wm, 0)) != MMSYSERR_NOERROR)
872 return result;
873
874 result = MMIO_SendMessage(wm, MMIOM_CLOSE, uFlags, 0, MMIO_PROC_32A);
875
876 MMIO_SetBuffer(wm, NULL, 0, 0, TRUE);
877
878 wm->ioProc->count--;
879
880 if (wm->bTmpIOProc)
881 MMIO_InstallIOProc(wm->info.fccIOProc, NULL,
882 MMIO_REMOVEPROC, wm->ioProc->type);
883
884 MMIO_Destroy(wm);
885
886 return result;
887 }
888
889 /**************************************************************************
890 * mmioClose [MMSYSTEM.1211]
891 */
892 MMRESULT16 WINAPI mmioClose16(HMMIO16 hmmio, UINT16 uFlags)
893 {
894 return mmioClose(hmmio, uFlags);
895 }
896
897 /**************************************************************************
898 * mmioRead [WINMM.@]
899 */
900 LONG WINAPI mmioRead(HMMIO hmmio, HPSTR pch, LONG cch)
901 {
902 LPWINE_MMIO wm;
903 LONG count;
904
905 TRACE("(%04X, %p, %ld);\n", hmmio, pch, cch);
906
907 if ((wm = MMIO_Get(NULL, hmmio)) == NULL)
908 return -1;
909
910 /* unbuffered case first */
911 if (!wm->info.pchBuffer)
912 return MMIO_SendMessage(wm, MMIOM_READ, (LPARAM)pch, cch, MMIO_PROC_32A);
913
914 /* first try from current buffer */
915 if (wm->info.pchNext != wm->info.pchEndRead) {
916 count = wm->info.pchEndRead - wm->info.pchNext;
917 if (count > cch || count < 0) count = cch;
918 memcpy(pch, wm->info.pchNext, count);
919 wm->info.pchNext += count;
920 pch += count;
921 cch -= count;
922 } else
923 count = 0;
924
925 if (cch && (wm->info.fccIOProc != FOURCC_MEM)) {
926 assert(wm->info.cchBuffer);
927
928 while (cch) {
929 LONG size;
930
931 size = MMIO_GrabNextBuffer(wm, TRUE);
932 if (size <= 0) break;
933 if (size > cch) size = cch;
934 memcpy(pch, wm->info.pchBuffer, size);
935 wm->info.pchNext += size;
936 pch += size;
937 cch -= size;
938 count += size;
939 }
940 }
941
942 TRACE("count=%ld\n", count);
943 return count;
944 }
945
946 /**************************************************************************
947 * mmioRead [MMSYSTEM.1212]
948 */
949 LONG WINAPI mmioRead16(HMMIO16 hmmio, HPSTR pch, LONG cch)
950 {
951 return mmioRead(hmmio, pch, cch);
952 }
953
954 /**************************************************************************
955 * mmioWrite [WINMM.@]
956 */
957 LONG WINAPI mmioWrite(HMMIO hmmio, HPCSTR pch, LONG cch)
958 {
959 LPWINE_MMIO wm;
960 LONG count;
961
962 TRACE("(%04X, %p, %ld);\n", hmmio, pch, cch);
963
964 if ((wm = MMIO_Get(NULL, hmmio)) == NULL)
965 return -1;
966
967 if (wm->info.cchBuffer) {
968 LONG bytesW = 0;
969
970 count = 0;
971 while (cch) {
972 if (wm->info.pchNext != wm->info.pchEndWrite) {
973 count = wm->info.pchEndWrite - wm->info.pchNext;
974 if (count > cch || count < 0) count = cch;
975 memcpy(wm->info.pchNext, pch, count);
976 wm->info.pchNext += count;
977 pch += count;
978 cch -= count;
979 bytesW += count;
980 wm->info.dwFlags |= MMIO_DIRTY;
981 } else {
982 if (wm->info.fccIOProc == FOURCC_MEM) {
983 if (wm->info.adwInfo[0]) {
984 /* from where would we get the memory handle? */
985 FIXME("memory file expansion not implemented!\n");
986 break;
987 } else break;
988 }
989 }
990
991 if (wm->info.pchNext == wm->info.pchEndWrite)
992 {
993 MMIO_Flush(wm, MMIO_EMPTYBUF);
994 MMIO_GrabNextBuffer(wm, FALSE);
995 }
996 else break;
997 }
998 count = bytesW;
999 } else {
1000 count = MMIO_SendMessage(wm, MMIOM_WRITE, (LPARAM)pch, cch, MMIO_PROC_32A);
1001 wm->info.lBufOffset = wm->info.lDiskOffset;
1002 }
1003
1004 TRACE("bytes written=%ld\n", count);
1005 return count;
1006 }
1007
1008 /**************************************************************************
1009 * mmioWrite [MMSYSTEM.1213]
1010 */
1011 LONG WINAPI mmioWrite16(HMMIO16 hmmio, HPCSTR pch, LONG cch)
1012 {
1013 return mmioWrite(hmmio,pch,cch);
1014 }
1015
1016 /**************************************************************************
1017 * mmioSeek [WINMM.@]
1018 */
1019 LONG WINAPI mmioSeek(HMMIO hmmio, LONG lOffset, INT iOrigin)
1020 {
1021 LPWINE_MMIO wm;
1022 LONG offset;
1023
1024 TRACE("(%04X, %08lX, %d);\n", hmmio, lOffset, iOrigin);
1025
1026 if ((wm = MMIO_Get(NULL, hmmio)) == NULL)
1027 return MMSYSERR_INVALHANDLE;
1028
1029 /* not buffered, direct seek on file */
1030 if (!wm->info.pchBuffer)
1031 return MMIO_SendMessage(wm, MMIOM_SEEK, lOffset, iOrigin, MMIO_PROC_32A);
1032
1033 switch (iOrigin) {
1034 case SEEK_SET:
1035 offset = lOffset;
1036 break;
1037 case SEEK_CUR:
1038 offset = wm->info.lBufOffset + (wm->info.pchNext - wm->info.pchBuffer) + lOffset;
1039 break;
1040 case SEEK_END:
1041 offset = ((wm->info.fccIOProc == FOURCC_MEM)? wm->info.cchBuffer : wm->dwFileSize) - lOffset;
1042 break;
1043 default:
1044 return -1;
1045 }
1046
1047 if (offset && offset >= wm->dwFileSize && wm->info.fccIOProc != FOURCC_MEM) {
1048 /* should check that write mode exists */
1049 if (MMIO_Flush(wm, 0) != MMSYSERR_NOERROR)
1050 return -1;
1051 wm->info.lBufOffset = offset;
1052 wm->info.pchEndRead = wm->info.pchBuffer;
1053 wm->info.pchEndWrite = wm->info.pchBuffer + wm->info.cchBuffer;
1054 if ((wm->info.dwFlags & MMIO_RWMODE) == MMIO_READ) {
1055 wm->info.lDiskOffset = wm->dwFileSize;
1056 }
1057 } else if ((wm->info.cchBuffer > 0) &&
1058 ((offset < wm->info.lBufOffset) ||
1059 (offset >= wm->info.lBufOffset + wm->info.cchBuffer) ||
1060 !wm->bBufferLoaded)) {
1061 /* stay in same buffer ? */
1062 /* some memory mapped buffers are defined with -1 as a size */
1063
1064 /* condition to change buffer */
1065 if ((wm->info.fccIOProc == FOURCC_MEM) ||
1066 MMIO_Flush(wm, 0) != MMSYSERR_NOERROR ||
1067 /* this also sets the wm->info.lDiskOffset field */
1068 MMIO_SendMessage(wm, MMIOM_SEEK,
1069 (offset / wm->info.cchBuffer) * wm->info.cchBuffer,
1070 SEEK_SET, MMIO_PROC_32A) == -1)
1071 return -1;
1072 MMIO_GrabNextBuffer(wm, TRUE);
1073 }
1074
1075 wm->info.pchNext = wm->info.pchBuffer + (offset - wm->info.lBufOffset);
1076
1077 TRACE("=> %ld\n", offset);
1078 return offset;
1079 }
1080
1081 /**************************************************************************
1082 * mmioSeek [MMSYSTEM.1214]
1083 */
1084 LONG WINAPI mmioSeek16(HMMIO16 hmmio, LONG lOffset, INT16 iOrigin)
1085 {
1086 return mmioSeek(hmmio, lOffset, iOrigin);
1087 }
1088
1089 /**************************************************************************
1090 * mmioGetInfo [MMSYSTEM.1215]
1091 */
1092 MMRESULT16 WINAPI mmioGetInfo16(HMMIO16 hmmio, MMIOINFO16* lpmmioinfo, UINT16 uFlags)
1093 {
1094 LPWINE_MMIO wm;
1095
1096 TRACE("(0x%04x,%p,0x%08x)\n",hmmio,lpmmioinfo,uFlags);
1097
1098 if ((wm = MMIO_Get(NULL, hmmio)) == NULL)
1099 return MMSYSERR_INVALHANDLE;
1100
1101 if (!wm->buffer16)
1102 return MMSYSERR_ERROR;
1103
1104 lpmmioinfo->dwFlags = wm->info.dwFlags;
1105 lpmmioinfo->fccIOProc = wm->info.fccIOProc;
1106 lpmmioinfo->pIOProc = (LPMMIOPROC16)wm->info.pIOProc;
1107 lpmmioinfo->wErrorRet = wm->info.wErrorRet;
1108 lpmmioinfo->hTask = wm->info.hTask;
1109 lpmmioinfo->cchBuffer = wm->info.cchBuffer;
1110 lpmmioinfo->pchBuffer = (void*)wm->buffer16;
1111 lpmmioinfo->pchNext = (void*)(wm->buffer16 + (wm->info.pchNext - wm->info.pchBuffer));
1112 lpmmioinfo->pchEndRead = (void*)(wm->buffer16 + (wm->info.pchEndRead - wm->info.pchBuffer));
1113 lpmmioinfo->pchEndWrite = (void*)(wm->buffer16 + (wm->info.pchEndWrite - wm->info.pchBuffer));
1114 lpmmioinfo->lBufOffset = wm->info.lBufOffset;
1115 lpmmioinfo->lDiskOffset = wm->info.lDiskOffset;
1116 lpmmioinfo->adwInfo[0] = wm->info.adwInfo[0];
1117 lpmmioinfo->adwInfo[1] = wm->info.adwInfo[1];
1118 lpmmioinfo->adwInfo[2] = wm->info.adwInfo[2];
1119 lpmmioinfo->adwInfo[3] = wm->info.adwInfo[3];
1120 lpmmioinfo->dwReserved1 = 0;
1121 lpmmioinfo->dwReserved2 = 0;
1122 lpmmioinfo->hmmio = wm->info.hmmio;
1123
1124 return MMSYSERR_NOERROR;
1125 }
1126
1127 /**************************************************************************
1128 * mmioGetInfo [WINMM.@]
1129 */
1130 MMRESULT WINAPI mmioGetInfo(HMMIO hmmio, MMIOINFO* lpmmioinfo, UINT uFlags)
1131 {
1132 LPWINE_MMIO wm;
1133
1134 TRACE("(0x%04x,%p,0x%08x)\n",hmmio,lpmmioinfo,uFlags);
1135
1136 if ((wm = MMIO_Get(NULL, hmmio)) == NULL)
1137 return MMSYSERR_INVALHANDLE;
1138
1139 memcpy(lpmmioinfo, &wm->info, sizeof(MMIOINFO));
1140
1141 return MMSYSERR_NOERROR;
1142 }
1143
1144 /**************************************************************************
1145 * mmioSetInfo [MMSYSTEM.1216]
1146 */
1147 MMRESULT16 WINAPI mmioSetInfo16(HMMIO16 hmmio, const MMIOINFO16* lpmmioinfo, UINT16 uFlags)
1148 {
1149 LPWINE_MMIO wm;
1150
1151 TRACE("(0x%04x,%p,0x%08x)\n",hmmio,lpmmioinfo,uFlags);
1152
1153 if ((wm = MMIO_Get(NULL, hmmio)) == NULL)
1154 return MMSYSERR_INVALHANDLE;
1155
1156 /* check if seg and lin buffers are the same */
1157 if (wm->info.cchBuffer != lpmmioinfo->cchBuffer ||
1158 wm->info.pchBuffer != MapSL(wm->buffer16))
1159 return MMSYSERR_INVALPARAM;
1160
1161 /* check pointers coherence */
1162 if (lpmmioinfo->pchNext < lpmmioinfo->pchBuffer ||
1163 lpmmioinfo->pchNext > lpmmioinfo->pchBuffer + lpmmioinfo->cchBuffer ||
1164 lpmmioinfo->pchEndRead < lpmmioinfo->pchBuffer ||
1165 lpmmioinfo->pchEndRead > lpmmioinfo->pchBuffer + lpmmioinfo->cchBuffer ||
1166 lpmmioinfo->pchEndWrite < lpmmioinfo->pchBuffer ||
1167 lpmmioinfo->pchEndWrite > lpmmioinfo->pchBuffer + lpmmioinfo->cchBuffer)
1168 return MMSYSERR_INVALPARAM;
1169
1170 wm->info.pchNext = wm->info.pchBuffer + (lpmmioinfo->pchNext - lpmmioinfo->pchBuffer);
1171 wm->info.pchEndRead = wm->info.pchBuffer + (lpmmioinfo->pchEndRead - lpmmioinfo->pchBuffer);
1172 wm->info.pchEndWrite = wm->info.pchBuffer + (lpmmioinfo->pchEndWrite - lpmmioinfo->pchBuffer);
1173
1174 return MMSYSERR_NOERROR;
1175 }
1176
1177 /**************************************************************************
1178 * mmioSetInfo [WINMM.@]
1179 */
1180 MMRESULT WINAPI mmioSetInfo(HMMIO hmmio, const MMIOINFO* lpmmioinfo, UINT uFlags)
1181 {
1182 LPWINE_MMIO wm;
1183
1184 TRACE("(0x%04x,%p,0x%08x)\n",hmmio,lpmmioinfo,uFlags);
1185
1186 if ((wm = MMIO_Get(NULL, hmmio)) == NULL)
1187 return MMSYSERR_INVALHANDLE;
1188
1189 /* check pointers coherence */
1190 if (lpmmioinfo->pchNext < wm->info.pchBuffer ||
1191 lpmmioinfo->pchNext > wm->info.pchBuffer + wm->info.cchBuffer ||
1192 lpmmioinfo->pchEndRead < wm->info.pchBuffer ||
1193 lpmmioinfo->pchEndRead > wm->info.pchBuffer + wm->info.cchBuffer ||
1194 lpmmioinfo->pchEndWrite < wm->info.pchBuffer ||
1195 lpmmioinfo->pchEndWrite > wm->info.pchBuffer + wm->info.cchBuffer)
1196 return MMSYSERR_INVALPARAM;
1197
1198 wm->info.pchNext = lpmmioinfo->pchNext;
1199 wm->info.pchEndRead = lpmmioinfo->pchEndRead;
1200
1201 return MMSYSERR_NOERROR;
1202 }
1203
1204 /**************************************************************************
1205 * mmioSetBuffer [WINMM.@]
1206 */
1207 MMRESULT WINAPI mmioSetBuffer(HMMIO hmmio, LPSTR pchBuffer, LONG cchBuffer, UINT uFlags)
1208 {
1209 LPWINE_MMIO wm;
1210
1211 TRACE("(hmmio=%04x, pchBuf=%p, cchBuf=%ld, uFlags=%#08x)\n",
1212 hmmio, pchBuffer, cchBuffer, uFlags);
1213
1214 if ((wm = MMIO_Get(NULL, hmmio)) == NULL)
1215 return MMSYSERR_INVALHANDLE;
1216
1217 return MMIO_SetBuffer(wm, pchBuffer, cchBuffer, uFlags, TRUE);
1218 }
1219
1220 /**************************************************************************
1221 * mmioSetBuffer [MMSYSTEM.1217]
1222 */
1223 MMRESULT16 WINAPI mmioSetBuffer16(HMMIO16 hmmio, LPSTR segpchBuffer,
1224 LONG cchBuffer, UINT16 uFlags)
1225 {
1226 LPWINE_MMIO wm;
1227
1228 TRACE("(hmmio=%04x, segpchBuf=%p, cchBuf=%ld, uFlags=%#08x)\n",
1229 hmmio, segpchBuffer, cchBuffer, uFlags);
1230
1231 if ((wm = MMIO_Get(NULL, hmmio)) == NULL)
1232 return MMSYSERR_INVALHANDLE;
1233
1234 return MMIO_SetBuffer(wm, segpchBuffer, cchBuffer, uFlags, FALSE);
1235 }
1236
1237 /**************************************************************************
1238 * mmioFlush [WINMM.@]
1239 */
1240 MMRESULT WINAPI mmioFlush(HMMIO hmmio, UINT uFlags)
1241 {
1242 LPWINE_MMIO wm;
1243
1244 TRACE("(%04X, %04X)\n", hmmio, uFlags);
1245
1246 if ((wm = MMIO_Get(NULL, hmmio)) == NULL)
1247 return MMSYSERR_INVALHANDLE;
1248
1249 return MMIO_Flush(wm, uFlags);
1250 }
1251
1252 /**************************************************************************
1253 * mmioFlush [MMSYSTEM.1218]
1254 */
1255 MMRESULT16 WINAPI mmioFlush16(HMMIO16 hmmio, UINT16 uFlags)
1256 {
1257 return mmioFlush(hmmio, uFlags);
1258 }
1259
1260 /**************************************************************************
1261 * mmioAdvance [WINMM.@]
1262 */
1263 MMRESULT WINAPI mmioAdvance(HMMIO hmmio, MMIOINFO* lpmmioinfo, UINT uFlags)
1264 {
1265 LPWINE_MMIO wm;
1266
1267 TRACE("hmmio=%04X, lpmmioinfo=%p, uFlags=%04X\n", hmmio, lpmmioinfo, uFlags);
1268
1269 if ((wm = MMIO_Get(NULL, hmmio)) == NULL)
1270 return MMSYSERR_INVALHANDLE;
1271
1272 if (!wm->info.cchBuffer)
1273 return MMIOERR_UNBUFFERED;
1274
1275 if (uFlags != MMIO_READ && uFlags != MMIO_WRITE)
1276 return MMSYSERR_INVALPARAM;
1277
1278 if (uFlags == MMIO_WRITE && (lpmmioinfo->dwFlags & MMIO_DIRTY))
1279 {
1280 MMIO_SendMessage(wm, MMIOM_SEEK, lpmmioinfo->lBufOffset, SEEK_SET, MMIO_PROC_32A);
1281 MMIO_SendMessage(wm, MMIOM_WRITE, (LPARAM)lpmmioinfo->pchBuffer,
1282 lpmmioinfo->pchNext - lpmmioinfo->pchBuffer, MMIO_PROC_32A);
1283 lpmmioinfo->dwFlags &= ~MMIO_DIRTY;
1284 }
1285 if (MMIO_Flush(wm, 0) != MMSYSERR_NOERROR)
1286 return MMIOERR_CANNOTWRITE;
1287
1288 if (lpmmioinfo) {
1289 wm->dwFileSize = max(wm->dwFileSize, lpmmioinfo->lBufOffset + (lpmmioinfo->pchNext - lpmmioinfo->pchBuffer));
1290 }
1291 MMIO_GrabNextBuffer(wm, uFlags == MMIO_READ);
1292
1293 if (lpmmioinfo) {
1294 lpmmioinfo->pchNext = lpmmioinfo->pchBuffer;
1295 lpmmioinfo->pchEndRead = lpmmioinfo->pchBuffer +
1296 (wm->info.pchEndRead - wm->info.pchBuffer);
1297 lpmmioinfo->pchEndWrite = lpmmioinfo->pchBuffer +
1298 (wm->info.pchEndWrite - wm->info.pchBuffer);
1299 lpmmioinfo->lDiskOffset = wm->info.lDiskOffset;
1300 lpmmioinfo->lBufOffset = wm->info.lBufOffset;
1301 }
1302 return MMSYSERR_NOERROR;
1303 }
1304
1305 /***********************************************************************
1306 * mmioAdvance [MMSYSTEM.1219]
1307 */
1308 MMRESULT16 WINAPI mmioAdvance16(HMMIO16 hmmio, MMIOINFO16* lpmmioinfo, UINT16 uFlags)
1309 {
1310 LPWINE_MMIO wm;
1311
1312 TRACE("hmmio=%04X, lpmmioinfo=%p, uFlags=%04X\n", hmmio, lpmmioinfo, uFlags);
1313
1314 if ((wm = MMIO_Get(NULL, hmmio)) == NULL)
1315 return MMSYSERR_INVALHANDLE;
1316
1317 if (!wm->info.cchBuffer)
1318 return MMIOERR_UNBUFFERED;
1319
1320 if (uFlags != MMIO_READ && uFlags != MMIO_WRITE)
1321 return MMSYSERR_INVALPARAM;
1322
1323 if (MMIO_Flush(wm, 0) != MMSYSERR_NOERROR)
1324 return MMIOERR_CANNOTWRITE;
1325
1326 MMIO_GrabNextBuffer(wm, uFlags == MMIO_READ);
1327
1328 lpmmioinfo->pchNext = lpmmioinfo->pchBuffer;
1329 lpmmioinfo->pchEndRead = lpmmioinfo->pchBuffer +
1330 (wm->info.pchEndRead - wm->info.pchBuffer);
1331 lpmmioinfo->pchEndWrite = lpmmioinfo->pchBuffer +
1332 (wm->info.pchEndWrite - wm->info.pchBuffer);
1333 lpmmioinfo->lDiskOffset = wm->info.lDiskOffset;
1334 lpmmioinfo->lBufOffset = wm->info.lBufOffset;
1335
1336 return MMSYSERR_NOERROR;
1337 }
1338
1339 /**************************************************************************
1340 * mmioStringToFOURCCA [WINMM.@]
1341 */
1342 FOURCC WINAPI mmioStringToFOURCCA(LPCSTR sz, UINT uFlags)
1343 {
1344 CHAR cc[4];
1345 int i = 0;
1346
1347 for (i = 0; i < 4 && sz[i]; i++) {
1348 if (uFlags & MMIO_TOUPPER) {
1349 cc[i] = toupper(sz[i]);
1350 } else {
1351 cc[i] = sz[i];
1352 }
1353 }
1354
1355 /* Pad with spaces */
1356 while (i < 4) cc[i++] = ' ';
1357
1358 TRACE("Got '%.4s'\n",cc);
1359 return mmioFOURCC(cc[0],cc[1],cc[2],cc[3]);
1360 }
1361
1362 /**************************************************************************
1363 * mmioStringToFOURCCW [WINMM.@]
1364 */
1365 FOURCC WINAPI mmioStringToFOURCCW(LPCWSTR sz, UINT uFlags)
1366 {
1367 LPSTR szA = HEAP_strdupWtoA(GetProcessHeap(),0,sz);
1368 FOURCC ret = mmioStringToFOURCCA(szA,uFlags);
1369
1370 HeapFree(GetProcessHeap(), 0, szA);
1371 return ret;
1372 }
1373
1374 /**************************************************************************
1375 * mmioStringToFOURCC [MMSYSTEM.1220]
1376 */
1377 FOURCC WINAPI mmioStringToFOURCC16(LPCSTR sz, UINT16 uFlags)
1378 {
1379 return mmioStringToFOURCCA(sz, uFlags);
1380 }
1381
1382 /**************************************************************************
1383 * mmioInstallIOProc [MMSYSTEM.1221]
1384 */
1385 LPMMIOPROC16 WINAPI mmioInstallIOProc16(FOURCC fccIOProc, LPMMIOPROC16 pIOProc,
1386 DWORD dwFlags)
1387 {
1388 return (LPMMIOPROC16)MMIO_InstallIOProc(fccIOProc, (LPMMIOPROC)pIOProc,
1389 dwFlags, MMIO_PROC_16);
1390 }
1391
1392 /**************************************************************************
1393 * mmioInstallIOProcA [WINMM.@]
1394 */
1395 LPMMIOPROC WINAPI mmioInstallIOProcA(FOURCC fccIOProc,
1396 LPMMIOPROC pIOProc, DWORD dwFlags)
1397 {
1398 return MMIO_InstallIOProc(fccIOProc, pIOProc, dwFlags, MMIO_PROC_32A);
1399 }
1400
1401 /**************************************************************************
1402 * mmioInstallIOProcW [WINMM.@]
1403 */
1404 LPMMIOPROC WINAPI mmioInstallIOProcW(FOURCC fccIOProc,
1405 LPMMIOPROC pIOProc, DWORD dwFlags)
1406 {
1407 return MMIO_InstallIOProc(fccIOProc, pIOProc, dwFlags, MMIO_PROC_32W);
1408 }
1409
1410 /**************************************************************************
1411 * mmioSendMessage [MMSYSTEM.1222]
1412 */
1413 LRESULT WINAPI mmioSendMessage16(HMMIO16 hmmio, UINT16 uMessage,
1414 LPARAM lParam1, LPARAM lParam2)
1415 {
1416 LPWINE_MMIO wm;
1417
1418 TRACE("(%04X, %u, %ld, %ld)\n", hmmio, uMessage, lParam1, lParam2);
1419
1420 if (uMessage < MMIOM_USER)
1421 return MMSYSERR_INVALPARAM;
1422
1423 if ((wm = MMIO_Get(NULL, hmmio)) == NULL)
1424 return MMSYSERR_INVALHANDLE;
1425
1426 return MMIO_SendMessage(wm, uMessage, lParam1, lParam2, MMIO_PROC_16);
1427 }
1428
1429 /**************************************************************************
1430 * mmioSendMessage [WINMM.@]
1431 */
1432 LRESULT WINAPI mmioSendMessage(HMMIO hmmio, UINT uMessage,
1433 LPARAM lParam1, LPARAM lParam2)
1434 {
1435 LPWINE_MMIO wm;
1436
1437 TRACE("(%04X, %u, %ld, %ld)\n", hmmio, uMessage, lParam1, lParam2);
1438
1439 if (uMessage < MMIOM_USER)
1440 return MMSYSERR_INVALPARAM;
1441
1442 if ((wm = MMIO_Get(NULL, hmmio)) == NULL)
1443 return MMSYSERR_INVALHANDLE;
1444
1445 return MMIO_SendMessage(wm, uMessage, lParam1, lParam2, MMIO_PROC_32A);
1446 }
1447
1448 /**************************************************************************
1449 * mmioDescend [WINMM.@]
1450 */
1451 MMRESULT WINAPI mmioDescend(HMMIO hmmio, LPMMCKINFO lpck,
1452 const MMCKINFO* lpckParent, UINT uFlags)
1453 {
1454 DWORD dwOldPos;
1455 FOURCC srchCkId;
1456 FOURCC srchType;
1457
1458
1459 TRACE("(%04X, %p, %p, %04X);\n", hmmio, lpck, lpckParent, uFlags);
1460
1461 if (lpck == NULL)
1462 return MMSYSERR_INVALPARAM;
1463
1464 dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
1465 TRACE("dwOldPos=%ld\n", dwOldPos);
1466
1467 if (lpckParent != NULL) {
1468 TRACE("seek inside parent at %ld !\n", lpckParent->dwDataOffset);
1469 /* EPP: was dwOldPos = mmioSeek(hmmio,lpckParent->dwDataOffset,SEEK_SET); */
1470 if (dwOldPos < lpckParent->dwDataOffset ||
1471 dwOldPos >= lpckParent->dwDataOffset + lpckParent->cksize) {
1472 WARN("outside parent chunk\n");
1473 return MMIOERR_CHUNKNOTFOUND;
1474 }
1475 }
1476
1477 /* The SDK docu says 'ckid' is used for all cases. Real World
1478 * examples disagree -Marcus,990216.
1479 */
1480
1481 srchType = 0;
1482 /* find_chunk looks for 'ckid' */
1483 if (uFlags & MMIO_FINDCHUNK)
1484 srchCkId = lpck->ckid;
1485 /* find_riff and find_list look for 'fccType' */
1486 if (uFlags & MMIO_FINDLIST) {
1487 srchCkId = FOURCC_LIST;
1488 srchType = lpck->fccType;
1489 }
1490 if (uFlags & MMIO_FINDRIFF) {
1491 srchCkId = FOURCC_RIFF;
1492 srchType = lpck->fccType;
1493 }
1494
1495 if (uFlags & (MMIO_FINDCHUNK|MMIO_FINDLIST|MMIO_FINDRIFF)) {
1496 TRACE("searching for %.4s.%.4s\n",
1497 (LPSTR)&srchCkId,
1498 srchType?(LPSTR)&srchType:"any ");
1499
1500 while (TRUE) {
1501 LONG ix;
1502
1503 ix = mmioRead(hmmio, (LPSTR)lpck, 3 * sizeof(DWORD));
1504 if (ix < 2*sizeof(DWORD)) {
1505 mmioSeek(hmmio, dwOldPos, SEEK_SET);
1506 WARN("return ChunkNotFound\n");
1507 return MMIOERR_CHUNKNOTFOUND;
1508 }
1509 lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD);
1510 if (ix < lpck->dwDataOffset - dwOldPos) {
1511 mmioSeek(hmmio, dwOldPos, SEEK_SET);
1512 WARN("return ChunkNotFound\n");
1513 return MMIOERR_CHUNKNOTFOUND;
1514 }
1515 TRACE("ckid=%.4s fcc=%.4s cksize=%08lX !\n",
1516 (LPSTR)&lpck->ckid,
1517 srchType?(LPSTR)&lpck->fccType:"<na>",
1518 lpck->cksize);
1519 if ((srchCkId == lpck->ckid) &&
1520 (!srchType || (srchType == lpck->fccType))
1521 )
1522 break;
1523
1524 dwOldPos = lpck->dwDataOffset + ((lpck->cksize + 1) & ~1);
1525 mmioSeek(hmmio, dwOldPos, SEEK_SET);
1526 }
1527 } else {
1528 /* FIXME: unverified, does it do this? */
1529 /* NB: This part is used by WAVE_mciOpen, among others */
1530 if (mmioRead(hmmio, (LPSTR)lpck, 3 * sizeof(DWORD)) < 3 * sizeof(DWORD)) {
1531 mmioSeek(hmmio, dwOldPos, SEEK_SET);
1532 WARN("return ChunkNotFound 2nd\n");
1533 return MMIOERR_CHUNKNOTFOUND;
1534 }
1535 lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD);
1536 }
1537 lpck->dwFlags = 0;
1538 /* If we were looking for RIFF/LIST chunks, the final file position
1539 * is after the chunkid. If we were just looking for the chunk
1540 * it is after the cksize. So add 4 in RIFF/LIST case.
1541 */
1542 if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST)
1543 mmioSeek(hmmio, lpck->dwDataOffset + sizeof(DWORD), SEEK_SET);
1544 else
1545 mmioSeek(hmmio, lpck->dwDataOffset, SEEK_SET);
1546 TRACE("lpck: ckid=%.4s, cksize=%ld, dwDataOffset=%ld fccType=%08lX (%.4s)!\n",
1547 (LPSTR)&lpck->ckid, lpck->cksize, lpck->dwDataOffset,
1548 lpck->fccType, srchType?(LPSTR)&lpck->fccType:"");
1549 return MMSYSERR_NOERROR;
1550 }
1551
1552 /**************************************************************************
1553 * mmioDescend [MMSYSTEM.1223]
1554 */
1555 MMRESULT16 WINAPI mmioDescend16(HMMIO16 hmmio, LPMMCKINFO lpck,
1556 const MMCKINFO* lpckParent, UINT16 uFlags)
1557 {
1558 return mmioDescend(hmmio, lpck, lpckParent, uFlags);
1559 }
1560
1561 /**************************************************************************
1562 * mmioAscend [WINMM.@]
1563 */
1564 MMRESULT WINAPI mmioAscend(HMMIO hmmio, LPMMCKINFO lpck, UINT uFlags)
1565 {
1566 TRACE("(%04X, %p, %04X);\n", hmmio, lpck, uFlags);
1567
1568 if (lpck->dwFlags & MMIO_DIRTY) {
1569 DWORD dwOldPos, dwNewSize;
1570
1571 TRACE("Chunk is dirty, checking if chunk's size is correct\n");
1572 dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
1573 TRACE("dwOldPos=%ld lpck->dwDataOffset = %ld\n", dwOldPos, lpck->dwDataOffset);
1574 dwNewSize = dwOldPos - lpck->dwDataOffset;
1575 if (dwNewSize != lpck->cksize) {
1576 TRACE("Nope: lpck->cksize=%ld dwNewSize=%ld\n", lpck->cksize, dwNewSize);
1577 lpck->cksize = dwNewSize;
1578
1579 /* pad odd size with 0 */
1580 if (dwNewSize & 1) {
1581 char ch = 0;
1582 mmioWrite(hmmio, &ch, 1);
1583 }
1584 mmioSeek(hmmio, lpck->dwDataOffset - sizeof(DWORD), SEEK_SET);
1585 mmioWrite(hmmio, (LPSTR)&dwNewSize, sizeof(DWORD));
1586 }
1587 lpck->dwFlags = 0;
1588 }
1589
1590 mmioSeek(hmmio, lpck->dwDataOffset + ((lpck->cksize + 1) & ~1), SEEK_SET);
1591
1592 return MMSYSERR_NOERROR;
1593 }
1594
1595 /**************************************************************************
1596 * mmioAscend [MMSYSTEM.1224]
1597 */
1598 MMRESULT16 WINAPI mmioAscend16(HMMIO16 hmmio, MMCKINFO* lpck, UINT16 uFlags)
1599 {
1600 return mmioAscend(hmmio,lpck,uFlags);
1601 }
1602
1603 /**************************************************************************
1604 * mmioCreateChunk [WINMM.@]
1605 */
1606 MMRESULT WINAPI mmioCreateChunk(HMMIO hmmio, MMCKINFO* lpck, UINT uFlags)
1607 {
1608 DWORD dwOldPos;
1609 LONG size;
1610 LONG ix;
1611
1612 TRACE("(%04X, %p, %04X);\n", hmmio, lpck, uFlags);
1613
1614 dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
1615 TRACE("dwOldPos=%ld\n", dwOldPos);
1616
1617 if (uFlags == MMIO_CREATELIST)
1618 lpck->ckid = FOURCC_LIST;
1619 else if (uFlags == MMIO_CREATERIFF)
1620 lpck->ckid = FOURCC_RIFF;
1621
1622 TRACE("ckid=%.4s\n", (LPSTR)&lpck->ckid);
1623
1624 size = 2 * sizeof(DWORD);
1625 lpck->dwDataOffset = dwOldPos + size;
1626
1627 if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST)
1628 size += sizeof(DWORD);
1629 lpck->dwFlags = MMIO_DIRTY;
1630
1631 ix = mmioWrite(hmmio, (LPSTR)lpck, size);
1632 TRACE("after mmioWrite ix = %ld req = %ld, errno = %d\n",ix, size, errno);
1633 if (ix < size) {
1634 mmioSeek(hmmio, dwOldPos, SEEK_SET);
1635 WARN("return CannotWrite\n");
1636 return MMIOERR_CANNOTWRITE;
1637 }
1638
1639 return MMSYSERR_NOERROR;
1640 }
1641
1642 /**************************************************************************
1643 * mmioCreateChunk [MMSYSTEM.1225]
1644 */
1645 MMRESULT16 WINAPI mmioCreateChunk16(HMMIO16 hmmio, MMCKINFO* lpck, UINT16 uFlags)
1646 {
1647 return mmioCreateChunk(hmmio, lpck, uFlags);
1648 }
1649
1650 /**************************************************************************
1651 * mmioRename [MMSYSTEM.1226]
1652 */
1653 MMRESULT16 WINAPI mmioRename16(LPCSTR szFileName, LPCSTR szNewFileName,
1654 MMIOINFO16* lpmmioinfo, DWORD dwRenameFlags)
1655 {
1656 UINT16 result = MMSYSERR_ERROR;
1657 LPMMIOPROC16 ioProc;
1658
1659 TRACE("('%s', '%s', %p, %08lX);\n",
1660 szFileName, szNewFileName, lpmmioinfo, dwRenameFlags);
1661
1662 /* If both params are NULL, then parse the file name */
1663 if (lpmmioinfo && lpmmioinfo->fccIOProc == 0 && lpmmioinfo->pIOProc == NULL)
1664 lpmmioinfo->fccIOProc = MMIO_ParseExt(szFileName);
1665
1666 /* Handle any unhandled/error case from above. Assume DOS file */
1667 if (!lpmmioinfo || (lpmmioinfo->fccIOProc == 0 && lpmmioinfo->pIOProc == NULL))
1668 ioProc = (LPMMIOPROC16)mmioDosIOProc;
1669 /* if just the four character code is present, look up IO proc */
1670 else if (lpmmioinfo->pIOProc == NULL)
1671 ioProc = mmioInstallIOProc16(lpmmioinfo->fccIOProc, NULL, MMIO_FINDPROC);
1672 else
1673 ioProc = lpmmioinfo->pIOProc;
1674
1675 /* FIXME: ioProc is likely a segmented address, thus needing a
1676 * thunk somewhere. The main issue is that Wine's current thunking
1677 * 32 to 16 only supports pascal calling convention
1678 */
1679 if (ioProc)
1680 result = (ioProc)(0, MMIOM_RENAME,
1681 (LPARAM)szFileName, (LPARAM)szNewFileName);
1682
1683 return result;
1684 }
1685
1686 /**************************************************************************
1687 * mmioRenameA [WINMM.@]
1688 */
1689 MMRESULT WINAPI mmioRenameA(LPCSTR szFileName, LPCSTR szNewFileName,
1690 MMIOINFO* lpmmioinfo, DWORD dwRenameFlags)
1691 {
1692 UINT result = MMSYSERR_ERROR;
1693 LPMMIOPROC ioProc;
1694
1695 TRACE("('%s', '%s', %p, %08lX);\n",
1696 szFileName, szNewFileName, lpmmioinfo, dwRenameFlags);
1697
1698 /* If both params are NULL, then parse the file name */
1699 if (lpmmioinfo && lpmmioinfo->fccIOProc == 0 && lpmmioinfo->pIOProc == NULL)
1700 lpmmioinfo->fccIOProc = MMIO_ParseExt(szFileName);
1701
1702 /* Handle any unhandled/error case from above. Assume DOS file */
1703 if (!lpmmioinfo || (lpmmioinfo->fccIOProc == 0 && lpmmioinfo->pIOProc == NULL))
1704 ioProc = (LPMMIOPROC)mmioDosIOProc;
1705 /* if just the four character code is present, look up IO proc */
1706 else if (lpmmioinfo->pIOProc == NULL)
1707 ioProc = MMIO_InstallIOProc(lpmmioinfo->fccIOProc, NULL,
1708 MMIO_FINDPROC, MMIO_PROC_32A);
1709 else /* use relevant ioProc */
1710 ioProc = lpmmioinfo->pIOProc;
1711
1712 if (ioProc)
1713 result = (ioProc)(0, MMIOM_RENAME,
1714 (LPARAM)szFileName, (LPARAM)szNewFileName);
1715
1716 return result;
1717 }
1718
1719 /**************************************************************************
1720 * mmioRenameW [WINMM.@]
1721 */
1722 MMRESULT WINAPI mmioRenameW(LPCWSTR szFileName, LPCWSTR szNewFileName,
1723 MMIOINFO* lpmmioinfo, DWORD dwRenameFlags)
1724 {
1725 LPSTR szFn = HEAP_strdupWtoA(GetProcessHeap(), 0, szFileName);
1726 LPSTR sznFn = HEAP_strdupWtoA(GetProcessHeap(), 0, szNewFileName);
1727 UINT ret = mmioRenameA(szFn, sznFn, lpmmioinfo, dwRenameFlags);
1728
1729 HeapFree(GetProcessHeap(),0,szFn);
1730 HeapFree(GetProcessHeap(),0,sznFn);
1731 return ret;
1732 }
Wine tree for Wine Gecko development