1 /*
2 * MMIO functions
3 *
4 * Copyright 1998 Andrew Taylor
5 * Copyright 1998 Ove Kåven
6 * Copyright 2000,2002 Eric Pouech
7 *
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.
12 *
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.
17 *
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
21 */
22
23 /* Still to be done:
24 * + correct handling of global/local IOProcs (and temporary IOProcs)
25 * + mode of mmio objects is not used (read vs write vs readwrite)
26 * + thread safeness
27 * + 32 A <=> W message mapping
28 */
29
30 #include "winemm.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(mmio);
33
34 static WINE_MMIO *MMIOList;
35
36 /**************************************************************************
37 * mmioDosIOProc [internal]
38 */
mmioDosIOProc(LPMMIOINFO lpmmioinfo,UINT uMessage,LPARAM lParam1,LPARAM lParam2)39 static LRESULT CALLBACK mmioDosIOProc(LPMMIOINFO lpmmioinfo, UINT uMessage,
40 LPARAM lParam1, LPARAM lParam2)
41 {
42 LRESULT ret = MMSYSERR_NOERROR;
43
44 TRACE("(%p, %X, 0x%lx, 0x%lx);\n", lpmmioinfo, uMessage, lParam1, lParam2);
45
46 switch (uMessage) {
47 case MMIOM_OPEN:
48 {
49 /* Parameters:
50 * lParam1 = szFileName parameter from mmioOpen
51 * lParam2 = reserved
52 * Returns: zero on success, error code on error
53 * NOTE: lDiskOffset automatically set to zero
54 */
55 LPCSTR szFileName = (LPCSTR)lParam1;
56
57 if (lpmmioinfo->dwFlags & MMIO_GETTEMP) {
58 FIXME("MMIO_GETTEMP not implemented\n");
59 return MMIOERR_CANNOTOPEN;
60 }
61
62 /* if filename NULL, assume open file handle in adwInfo[0] */
63 if (szFileName) {
64 OFSTRUCT ofs;
65 lpmmioinfo->adwInfo[0] = (DWORD)OpenFile(szFileName, &ofs, lpmmioinfo->dwFlags & 0xFFFF);
66 }
67 if (lpmmioinfo->adwInfo[0] == (DWORD)HFILE_ERROR)
68 ret = MMIOERR_CANNOTOPEN;
69 }
70 break;
71
72 case MMIOM_CLOSE:
73 /* Parameters:
74 * lParam1 = wFlags parameter from mmioClose
75 * lParam2 = unused
76 * Returns: zero on success, error code on error
77 */
78 if (!(lParam1 & MMIO_FHOPEN))
79 _lclose((HFILE)lpmmioinfo->adwInfo[0]);
80 break;
81
82 case MMIOM_READ:
83 /* Parameters:
84 * lParam1 = huge pointer to read buffer
85 * lParam2 = number of bytes to read
86 * Returns: number of bytes read, 0 for EOF, -1 for error (error code
87 * in wErrorRet)
88 */
89 ret = _lread((HFILE)lpmmioinfo->adwInfo[0], (HPSTR)lParam1, (LONG)lParam2);
90 if (ret != -1)
91 lpmmioinfo->lDiskOffset += ret;
92
93 break;
94
95 case MMIOM_WRITE:
96 case MMIOM_WRITEFLUSH:
97 /* no internal buffering, so WRITEFLUSH handled same as WRITE */
98
99 /* Parameters:
100 * lParam1 = huge pointer to write buffer
101 * lParam2 = number of bytes to write
102 * Returns: number of bytes written, -1 for error (error code in
103 * wErrorRet)
104 */
105 ret = _hwrite((HFILE)lpmmioinfo->adwInfo[0], (HPSTR)lParam1, (LONG)lParam2);
106 if (ret != -1)
107 lpmmioinfo->lDiskOffset += ret;
108 break;
109
110 case MMIOM_SEEK:
111 /* Parameters:
112 * lParam1 = new position
113 * lParam2 = from whence to seek (SEEK_SET, SEEK_CUR, SEEK_END)
114 * Returns: new file postion, -1 on error
115 */
116 ret = _llseek((HFILE)lpmmioinfo->adwInfo[0], (LONG)lParam1, (LONG)lParam2);
117 if (ret != -1)
118 lpmmioinfo->lDiskOffset = ret;
119 return ret;
120
121 case MMIOM_RENAME:
122 /* Parameters:
123 * lParam1 = old name
124 * lParam2 = new name
125 * Returns: zero on success, non-zero on failure
126 */
127 if (!MoveFileA((const char*)lParam1, (const char*)lParam2))
128 ret = MMIOERR_FILENOTFOUND;
129 break;
130
131 default:
132 FIXME("unexpected message %u\n", uMessage);
133 return 0;
134 }
135
136 return ret;
137 }
138
139 /**************************************************************************
140 * mmioMemIOProc [internal]
141 */
mmioMemIOProc(LPMMIOINFO lpmmioinfo,UINT uMessage,LPARAM lParam1,LPARAM lParam2)142 static LRESULT CALLBACK mmioMemIOProc(LPMMIOINFO lpmmioinfo, UINT uMessage,
143 LPARAM lParam1, LPARAM lParam2)
144 {
145 TRACE("(%p,0x%04x,0x%08lx,0x%08lx)\n", lpmmioinfo, uMessage, lParam1, lParam2);
146
147 switch (uMessage) {
148
149 case MMIOM_OPEN:
150 /* Parameters:
151 * lParam1 = filename (must be NULL)
152 * lParam2 = reserved
153 * Returns: zero on success, error code on error
154 * NOTE: lDiskOffset automatically set to zero
155 */
156 /* FIXME: io proc shouldn't change it */
157 if (!(lpmmioinfo->dwFlags & MMIO_CREATE))
158 lpmmioinfo->pchEndRead = lpmmioinfo->pchEndWrite;
159 lpmmioinfo->adwInfo[0] = HFILE_ERROR;
160 return 0;
161
162 case MMIOM_CLOSE:
163 /* Parameters:
164 * lParam1 = wFlags parameter from mmioClose
165 * lParam2 = unused
166 * Returns: zero on success, error code on error
167 */
168 return 0;
169
170 case MMIOM_READ:
171 /* Parameters:
172 * lParam1 = huge pointer to read buffer
173 * lParam2 = number of bytes to read
174 * Returns: number of bytes read, 0 for EOF, -1 for error (error code
175 * in wErrorRet)
176 * NOTE: lDiskOffset should be updated
177 */
178 FIXME("MMIOM_READ on memory files should not occur, buffer may be lost!\n");
179 return 0;
180
181 case MMIOM_WRITE:
182 case MMIOM_WRITEFLUSH:
183 /* no internal buffering, so WRITEFLUSH handled same as WRITE */
184
185 /* Parameters:
186 * lParam1 = huge pointer to write buffer
187 * lParam2 = number of bytes to write
188 * Returns: number of bytes written, -1 for error (error code in
189 * wErrorRet)
190 * NOTE: lDiskOffset should be updated
191 */
192 FIXME("MMIOM_WRITE on memory files should not occur, buffer may be lost!\n");
193 return 0;
194
195 case MMIOM_SEEK:
196 /* Parameters:
197 * lParam1 = new position
198 * lParam2 = from whence to seek (SEEK_SET, SEEK_CUR, SEEK_END)
199 * Returns: new file postion, -1 on error
200 * NOTE: lDiskOffset should be updated
201 */
202 FIXME("MMIOM_SEEK on memory files should not occur, buffer may be lost!\n");
203 return -1;
204
205 default:
206 FIXME("unexpected message %u\n", uMessage);
207 return 0;
208 }
209 }
210
211 /* This array will be the entire list for most apps
212 * Note that temporary ioProcs will be stored with a 0 fourCC code
213 */
214
215 static struct IOProcList defaultProcs[] = {
216 {&defaultProcs[1], FOURCC_DOS, (LPMMIOPROC)mmioDosIOProc, FALSE, 0},
217 {NULL, FOURCC_MEM, (LPMMIOPROC)mmioMemIOProc, FALSE, 0},
218 };
219
220 static struct IOProcList* pIOProcListAnchor = &defaultProcs[0];
221
222 /****************************************************************
223 * MMIO_FindProcNode [INTERNAL]
224 *
225 * Finds the ProcList node associated with a given FOURCC code.
226 */
MMIO_FindProcNode(FOURCC fccIOProc)227 static struct IOProcList* MMIO_FindProcNode(FOURCC fccIOProc)
228 {
229 struct IOProcList* pListNode;
230
231 for (pListNode = pIOProcListAnchor; pListNode; pListNode = pListNode->pNext) {
232 if (pListNode->fourCC == fccIOProc) {
233 return pListNode;
234 }
235 }
236 return NULL;
237 }
238
239 /****************************************************************
240 * MMIO_InstallIOProc [INTERNAL]
241 */
MMIO_InstallIOProc(FOURCC fccIOProc,LPMMIOPROC pIOProc,DWORD dwFlags,BOOL is_unicode)242 static LPMMIOPROC MMIO_InstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc,
243 DWORD dwFlags, BOOL is_unicode)
244 {
245 LPMMIOPROC lpProc = NULL;
246 struct IOProcList* pListNode;
247 struct IOProcList** ppListNode;
248
249 TRACE("(%08x, %p, %08X, %s)\n", fccIOProc, pIOProc, dwFlags, is_unicode ? "unicode" : "ansi");
250
251 if (dwFlags & MMIO_GLOBALPROC)
252 FIXME("Global procedures not implemented\n");
253
254 /* just handle the known procedures for now */
255 switch (dwFlags & (MMIO_INSTALLPROC|MMIO_REMOVEPROC|MMIO_FINDPROC)) {
256 case MMIO_INSTALLPROC:
257 /* Create new entry for the IOProc list */
258 pListNode = HeapAlloc(GetProcessHeap(), 0, sizeof(*pListNode));
259 if (pListNode) {
260 /* Fill in this node */
261 pListNode->fourCC = fccIOProc;
262 pListNode->pIOProc = pIOProc;
263 pListNode->is_unicode = is_unicode;
264 pListNode->count = 0;
265
266 /* Stick it on the end of the list */
267 pListNode->pNext = pIOProcListAnchor;
268 pIOProcListAnchor = pListNode;
269
270 /* Return this IOProc - that's how the caller knows we succeeded */
271 lpProc = pIOProc;
272 }
273 break;
274
275 case MMIO_REMOVEPROC:
276 /*
277 * Search for the node that we're trying to remove
278 * We search for a matching fourCC code if it's non null, or the proc
279 * address otherwise
280 * note that this method won't find the first item on the list, but
281 * since the first two items on this list are ones we won't
282 * let the user delete anyway, that's okay
283 */
284 ppListNode = &pIOProcListAnchor;
285 while ((*ppListNode) &&
286 ((fccIOProc != 0) ?
287 (*ppListNode)->fourCC != fccIOProc :
288 (*ppListNode)->pIOProc != pIOProc))
289 ppListNode = &((*ppListNode)->pNext);
290
291 if (*ppListNode) { /* found it */
292 /* FIXME: what should be done if an open mmio object uses this proc ?
293 * shall we return an error, nuke the mmio object ?
294 */
295 if ((*ppListNode)->count) {
296 ERR("Cannot remove a mmIOProc while in use\n");
297 break;
298 }
299 /* remove it, but only if it isn't builtin */
300 if ((*ppListNode) >= defaultProcs &&
301 (*ppListNode) < defaultProcs + sizeof(defaultProcs) / sizeof(defaultProcs[0])) {
302 WARN("Tried to remove built-in mmio proc. Skipping\n");
303 } else {
304 /* Okay, nuke it */
305 struct IOProcList* ptmpNode = *ppListNode;
306 lpProc = (*ppListNode)->pIOProc;
307 *ppListNode = (*ppListNode)->pNext;
308 HeapFree(GetProcessHeap(), 0, ptmpNode);
309 }
310 }
311 break;
312
313 case MMIO_FINDPROC:
314 if ((pListNode = MMIO_FindProcNode(fccIOProc))) {
315 lpProc = pListNode->pIOProc;
316 }
317 break;
318 }
319
320 return lpProc;
321 }
322
323 /****************************************************************
324 * send_message [INTERNAL]
325 */
send_message(struct IOProcList * ioProc,LPMMIOINFO mmioinfo,DWORD wMsg,LPARAM lParam1,LPARAM lParam2,BOOL is_unicode)326 static LRESULT send_message(struct IOProcList* ioProc, LPMMIOINFO mmioinfo,
327 DWORD wMsg, LPARAM lParam1,
328 LPARAM lParam2, BOOL is_unicode)
329 {
330 LRESULT result = MMSYSERR_ERROR;
331 LPARAM lp1 = lParam1, lp2 = lParam2;
332
333 if (!ioProc) {
334 ERR("ioProc NULL\n");
335 return MMSYSERR_INVALPARAM;
336 }
337
338 if (ioProc->is_unicode != is_unicode) {
339 /* map (lParam1, lParam2) into (lp1, lp2) 32 A<=>W */
340 FIXME("NIY 32 A<=>W mapping\n");
341 }
342 result = (ioProc->pIOProc)((LPSTR)mmioinfo, wMsg, lp1, lp2);
343
344 #if 0
345 if (ioProc->is_unicode != is_unicode) {
346 /* unmap (lParam1, lParam2) into (lp1, lp2) 32 A<=>W */
347 }
348 #endif
349
350 return result;
351 }
352
353 /**************************************************************************
354 * MMIO_ParseExtA [internal]
355 *
356 * Parses a filename for the extension.
357 *
358 * RETURNS
359 * The FOURCC code for the extension if found, else 0.
360 */
MMIO_ParseExtA(LPCSTR szFileName)361 static FOURCC MMIO_ParseExtA(LPCSTR szFileName)
362 {
363 /* Filenames are of the form file.ext{+ABC}
364 For now, we take the last '+' if present */
365
366 FOURCC ret = 0;
367
368 /* Note that ext{Start,End} point to the . and + respectively */
369 LPCSTR extEnd;
370 LPCSTR extStart;
371
372 CHAR ext[5];
373
374 TRACE("(%s)\n", debugstr_a(szFileName));
375
376 if (!szFileName)
377 return ret;
378
379 /* Find the last '+' */
380 extEnd = strrchr(szFileName,'+');
381
382 if (!extEnd) {
383 /* No + so just an extension */
384 return ret;
385 } else {
386 /* Find the first '.' before '+' */
387 extStart = extEnd - 1;
388 while (extStart >= szFileName && *extStart != '.') {
389 extStart--;
390 }
391 if (extStart < szFileName) {
392 ERR("No extension in szFileName: %s\n", debugstr_a(szFileName));
393 return ret;
394 }
395 }
396
397 if (extEnd - extStart - 1 > 4)
398 WARN("Extension length > 4\n");
399 lstrcpynA(ext, extStart + 1, min(extEnd-extStart,5));
400
401 TRACE("Got extension: %s\n", debugstr_a(ext));
402
403 /* FOURCC codes identifying file-extensions must be uppercase */
404 ret = mmioStringToFOURCCA(ext, MMIO_TOUPPER);
405
406 return ret;
407 }
408
409 /**************************************************************************
410 * MMIO_Get [internal]
411 *
412 * Retrieves the mmio object from current process
413 */
MMIO_Get(HMMIO h)414 static LPWINE_MMIO MMIO_Get(HMMIO h)
415 {
416 LPWINE_MMIO wm = NULL;
417
418 EnterCriticalSection(&WINMM_cs);
419 for (wm = MMIOList; wm; wm = wm->lpNext) {
420 if (wm->info.hmmio == h)
421 break;
422 }
423 LeaveCriticalSection(&WINMM_cs);
424 return wm;
425 }
426
427 /**************************************************************************
428 * MMIO_Create [internal]
429 *
430 * Creates an internal representation for a mmio instance
431 */
MMIO_Create(void)432 static LPWINE_MMIO MMIO_Create(void)
433 {
434 static WORD MMIO_counter = 0;
435 LPWINE_MMIO wm;
436
437 wm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MMIO));
438 if (wm) {
439 EnterCriticalSection(&WINMM_cs);
440 /* lookup next unallocated WORD handle, with a non NULL value */
441 while (++MMIO_counter == 0 || MMIO_Get((HMMIO)(ULONG_PTR)MMIO_counter));
442 wm->info.hmmio = (HMMIO)(ULONG_PTR)MMIO_counter;
443 wm->lpNext = MMIOList;
444 MMIOList = wm;
445 LeaveCriticalSection(&WINMM_cs);
446 }
447 return wm;
448 }
449
450 /**************************************************************************
451 * MMIO_Destroy [internal]
452 *-
453 * Destroys an internal representation for a mmio instance
454 */
MMIO_Destroy(LPWINE_MMIO wm)455 static BOOL MMIO_Destroy(LPWINE_MMIO wm)
456 {
457 LPWINE_MMIO* m;
458
459 EnterCriticalSection(&WINMM_cs);
460 /* search for the matching one... */
461 m = &MMIOList;
462 while (*m && *m != wm) m = &(*m)->lpNext;
463 /* ...and destroy */
464 if (*m) {
465 *m = (*m)->lpNext;
466 HeapFree(GetProcessHeap(), 0, wm);
467 wm = NULL;
468 }
469 LeaveCriticalSection(&WINMM_cs);
470 return wm ? FALSE : TRUE;
471 }
472
473 /****************************************************************
474 * MMIO_Flush [INTERNAL]
475 */
MMIO_Flush(WINE_MMIO * wm,UINT uFlags)476 static MMRESULT MMIO_Flush(WINE_MMIO* wm, UINT uFlags)
477 {
478 if (wm->info.cchBuffer && (wm->info.fccIOProc != FOURCC_MEM)) {
479 /* not quite sure what to do here, but I'll guess */
480 if (wm->info.dwFlags & MMIO_DIRTY) {
481 /* FIXME: error handling */
482 send_message(wm->ioProc, &wm->info, MMIOM_SEEK, wm->info.lBufOffset, SEEK_SET, FALSE);
483 send_message(wm->ioProc, &wm->info, MMIOM_WRITE,
484 (LPARAM)wm->info.pchBuffer,
485 wm->info.pchNext - wm->info.pchBuffer, FALSE);
486 }
487 if (uFlags & MMIO_EMPTYBUF)
488 wm->info.pchNext = wm->info.pchEndRead = wm->info.pchBuffer;
489 }
490 wm->info.dwFlags &= ~MMIO_DIRTY;
491
492 return MMSYSERR_NOERROR;
493 }
494
495 /***************************************************************************
496 * MMIO_GrabNextBuffer [INTERNAL]
497 */
MMIO_GrabNextBuffer(LPWINE_MMIO wm,int for_read)498 static LONG MMIO_GrabNextBuffer(LPWINE_MMIO wm, int for_read)
499 {
500 LONG size = wm->info.cchBuffer;
501
502 TRACE("bo=%x do=%x of=%lx\n",
503 wm->info.lBufOffset, wm->info.lDiskOffset,
504 send_message(wm->ioProc, &wm->info, MMIOM_SEEK, 0, SEEK_CUR, FALSE));
505
506 wm->info.lBufOffset = wm->info.lDiskOffset;
507 wm->info.pchNext = wm->info.pchBuffer;
508 wm->info.pchEndRead = wm->info.pchBuffer;
509 wm->info.pchEndWrite = wm->info.pchBuffer + wm->info.cchBuffer;
510
511 wm->bBufferLoaded = TRUE;
512 if (for_read) {
513 size = send_message(wm->ioProc, &wm->info, MMIOM_READ,
514 (LPARAM)wm->info.pchBuffer, size, FALSE);
515 if (size > 0)
516 wm->info.pchEndRead += size;
517 else
518 wm->bBufferLoaded = FALSE;
519 }
520
521 return size;
522 }
523
524 /***************************************************************************
525 * MMIO_SetBuffer [INTERNAL]
526 */
MMIO_SetBuffer(WINE_MMIO * wm,void * pchBuffer,LONG cchBuffer,UINT uFlags)527 static MMRESULT MMIO_SetBuffer(WINE_MMIO* wm, void* pchBuffer, LONG cchBuffer,
528 UINT uFlags)
529 {
530 TRACE("(%p %p %d %u)\n", wm, pchBuffer, cchBuffer, uFlags);
531
532 if (cchBuffer > 0xFFFF)
533 WARN("Untested handling of huge mmio buffers (%d >= 64k)\n", cchBuffer);
534
535 if (MMIO_Flush(wm, 0) != MMSYSERR_NOERROR)
536 return MMIOERR_CANNOTWRITE;
537
538 /* free previous buffer if allocated */
539 if (wm->info.dwFlags & MMIO_ALLOCBUF) {
540 HeapFree(GetProcessHeap(), 0, wm->info.pchBuffer);
541 wm->info.pchBuffer = NULL;
542 wm->info.dwFlags &= ~MMIO_ALLOCBUF;
543 }
544
545 if (pchBuffer) {
546 wm->info.pchBuffer = pchBuffer;
547 } else if (cchBuffer) {
548 if (!(wm->info.pchBuffer = HeapAlloc(GetProcessHeap(), 0, cchBuffer)))
549 return MMIOERR_OUTOFMEMORY;
550 wm->info.dwFlags |= MMIO_ALLOCBUF;
551 } else {
552 wm->info.pchBuffer = NULL;
553 }
554
555 wm->info.cchBuffer = cchBuffer;
556 wm->info.pchNext = wm->info.pchBuffer;
557 wm->info.pchEndRead = wm->info.pchBuffer;
558 wm->info.pchEndWrite = wm->info.pchBuffer + cchBuffer;
559 wm->info.lBufOffset = wm->info.lDiskOffset;
560 wm->bBufferLoaded = FALSE;
561
562 return MMSYSERR_NOERROR;
563 }
564
565 /**************************************************************************
566 * MMIO_Open [internal]
567 */
MMIO_Open(LPSTR szFileName,MMIOINFO * refmminfo,DWORD dwOpenFlags,BOOL is_unicode)568 static HMMIO MMIO_Open(LPSTR szFileName, MMIOINFO* refmminfo, DWORD dwOpenFlags, BOOL is_unicode)
569 {
570 LPWINE_MMIO wm;
571 MMIOINFO mmioinfo;
572
573 TRACE("('%s', %p, %08X, %s);\n", szFileName, refmminfo, dwOpenFlags, is_unicode ? "unicode" : "ansi");
574
575 if (!refmminfo) {
576 refmminfo = &mmioinfo;
577
578 mmioinfo.fccIOProc = 0;
579 mmioinfo.pIOProc = NULL;
580 mmioinfo.pchBuffer = NULL;
581 mmioinfo.cchBuffer = 0;
582 is_unicode = FALSE;
583 }
584
585 if (dwOpenFlags & (MMIO_PARSE|MMIO_EXIST)) {
586 char buffer[MAX_PATH];
587
588 if (!szFileName)
589 return (HMMIO)FALSE;
590 if (GetFullPathNameA(szFileName, sizeof(buffer), buffer, NULL) >= sizeof(buffer))
591 return (HMMIO)FALSE;
592 if ((dwOpenFlags & MMIO_EXIST) && (GetFileAttributesA(buffer) == INVALID_FILE_ATTRIBUTES))
593 return (HMMIO)FALSE;
594 strcpy(szFileName, buffer);
595 return (HMMIO)TRUE;
596 }
597
598 if ((wm = MMIO_Create()) == NULL)
599 return 0;
600
601 /* If both params are NULL, then parse the file name if available */
602 if (refmminfo->fccIOProc == 0 && refmminfo->pIOProc == NULL) {
603 wm->info.fccIOProc = MMIO_ParseExtA(szFileName);
604 /* Handle any unhandled/error case. Assume DOS file */
605 if (wm->info.fccIOProc == 0)
606 wm->info.fccIOProc = FOURCC_DOS;
607 if (!(wm->ioProc = MMIO_FindProcNode(wm->info.fccIOProc))) {
608 /* If not found, retry with FOURCC_DOS */
609 wm->info.fccIOProc = FOURCC_DOS;
610 if (!(wm->ioProc = MMIO_FindProcNode(wm->info.fccIOProc)))
611 goto error2;
612 }
613 wm->bTmpIOProc = FALSE;
614 }
615 /* if just the four character code is present, look up IO proc */
616 else if (refmminfo->pIOProc == NULL) {
617 wm->info.fccIOProc = refmminfo->fccIOProc;
618 if (!(wm->ioProc = MMIO_FindProcNode(wm->info.fccIOProc))) goto error2;
619 wm->bTmpIOProc = FALSE;
620 }
621 /* if IO proc specified, use it and specified four character code */
622 else {
623 wm->info.fccIOProc = refmminfo->fccIOProc;
624 MMIO_InstallIOProc(wm->info.fccIOProc, refmminfo->pIOProc,
625 MMIO_INSTALLPROC, is_unicode);
626 if (!(wm->ioProc = MMIO_FindProcNode(wm->info.fccIOProc))) goto error2;
627 assert(wm->ioProc->pIOProc == refmminfo->pIOProc);
628 wm->bTmpIOProc = TRUE;
629 }
630
631 wm->ioProc->count++;
632 wm->info.dwFlags = dwOpenFlags;
633
634 if (dwOpenFlags & MMIO_ALLOCBUF) {
635 refmminfo->wErrorRet = MMIO_SetBuffer(wm, refmminfo->pchBuffer,
636 refmminfo->cchBuffer ? refmminfo->cchBuffer : MMIO_DEFAULTBUFFER, 0);
637 if (refmminfo->wErrorRet != MMSYSERR_NOERROR)
638 goto error1;
639 } else {
640 refmminfo->wErrorRet = MMIO_SetBuffer(wm, refmminfo->pchBuffer, refmminfo->cchBuffer, 0);
641 if (refmminfo->wErrorRet != MMSYSERR_NOERROR)
642 goto error1;
643 }
644
645 if (wm->info.fccIOProc == FOURCC_MEM && !(wm->info.dwFlags & MMIO_ALLOCBUF))
646 wm->bBufferLoaded = TRUE;
647
648 /* see mmioDosIOProc for that one */
649 wm->info.adwInfo[0] = refmminfo->adwInfo[0];
650
651 /* call IO proc to actually open file */
652 refmminfo->wErrorRet = send_message(wm->ioProc, &wm->info, MMIOM_OPEN,
653 (LPARAM)szFileName, 0, FALSE);
654
655 /* grab file size, when possible (FIXME: not 64 bit safe) */
656 wm->dwFileSize = GetFileSize((HANDLE)(ULONG_PTR)wm->info.adwInfo[0], NULL);
657
658 if (refmminfo->wErrorRet == 0)
659 return wm->info.hmmio;
660 error1:
661 if (wm->ioProc) wm->ioProc->count--;
662 error2:
663 MMIO_Destroy(wm);
664 return 0;
665 }
666
667 /**************************************************************************
668 * mmioOpenW [WINMM.@]
669 */
mmioOpenW(LPWSTR szFileName,MMIOINFO * lpmmioinfo,DWORD dwOpenFlags)670 HMMIO WINAPI mmioOpenW(LPWSTR szFileName, MMIOINFO* lpmmioinfo,
671 DWORD dwOpenFlags)
672 {
673 HMMIO ret;
674 LPSTR szFn = NULL;
675
676 if (szFileName)
677 {
678 INT len = WideCharToMultiByte( CP_ACP, 0, szFileName, -1, NULL, 0, NULL, NULL );
679 szFn = HeapAlloc( GetProcessHeap(), 0, len );
680 if (!szFn) return NULL;
681 WideCharToMultiByte( CP_ACP, 0, szFileName, -1, szFn, len, NULL, NULL );
682 }
683
684 ret = MMIO_Open(szFn, lpmmioinfo, dwOpenFlags, TRUE);
685
686 HeapFree(GetProcessHeap(), 0, szFn);
687 return ret;
688 }
689
690 /**************************************************************************
691 * mmioOpenA [WINMM.@]
692 */
mmioOpenA(LPSTR szFileName,MMIOINFO * lpmmioinfo,DWORD dwOpenFlags)693 HMMIO WINAPI mmioOpenA(LPSTR szFileName, MMIOINFO* lpmmioinfo,
694 DWORD dwOpenFlags)
695 {
696 return MMIO_Open(szFileName, lpmmioinfo, dwOpenFlags, FALSE);
697 }
698
699 /**************************************************************************
700 * mmioClose [WINMM.@]
701 */
mmioClose(HMMIO hmmio,UINT uFlags)702 MMRESULT WINAPI mmioClose(HMMIO hmmio, UINT uFlags)
703 {
704 LPWINE_MMIO wm;
705 MMRESULT result;
706
707 TRACE("(%p, %04X);\n", hmmio, uFlags);
708
709 if ((wm = MMIO_Get(hmmio)) == NULL)
710 return MMSYSERR_INVALHANDLE;
711
712 if ((result = MMIO_Flush(wm, 0)) != MMSYSERR_NOERROR)
713 return result;
714
715 result = send_message(wm->ioProc, &wm->info, MMIOM_CLOSE, uFlags, 0, FALSE);
716
717 MMIO_SetBuffer(wm, NULL, 0, 0);
718
719 wm->ioProc->count--;
720
721 if (wm->bTmpIOProc)
722 MMIO_InstallIOProc(wm->info.fccIOProc, wm->ioProc->pIOProc,
723 MMIO_REMOVEPROC, wm->ioProc->is_unicode);
724
725 MMIO_Destroy(wm);
726
727 return result;
728 }
729
730 /**************************************************************************
731 * mmioRead [WINMM.@]
732 */
mmioRead(HMMIO hmmio,HPSTR pch,LONG cch)733 LONG WINAPI mmioRead(HMMIO hmmio, HPSTR pch, LONG cch)
734 {
735 LPWINE_MMIO wm;
736 LONG count;
737
738 TRACE("(%p, %p, %d);\n", hmmio, pch, cch);
739
740 if ((wm = MMIO_Get(hmmio)) == NULL)
741 return -1;
742
743 /* unbuffered case first */
744 if (!wm->info.pchBuffer)
745 return send_message(wm->ioProc, &wm->info, MMIOM_READ, (LPARAM)pch, cch, FALSE);
746
747 /* first try from current buffer */
748 if (wm->info.pchNext != wm->info.pchEndRead) {
749 count = wm->info.pchEndRead - wm->info.pchNext;
750 if (count > cch || count < 0) count = cch;
751 memcpy(pch, wm->info.pchNext, count);
752 wm->info.pchNext += count;
753 pch += count;
754 cch -= count;
755 } else
756 count = 0;
757
758 if (cch && (wm->info.fccIOProc != FOURCC_MEM)) {
759 assert(wm->info.cchBuffer);
760
761 while (cch) {
762 LONG size;
763
764 size = MMIO_GrabNextBuffer(wm, TRUE);
765 if (size <= 0) break;
766 if (size > cch) size = cch;
767 memcpy(pch, wm->info.pchBuffer, size);
768 wm->info.pchNext += size;
769 pch += size;
770 cch -= size;
771 count += size;
772 }
773 }
774
775 TRACE("count=%d\n", count);
776 return count;
777 }
778
779 /**************************************************************************
780 * mmioWrite [WINMM.@]
781 */
mmioWrite(HMMIO hmmio,HPCSTR pch,LONG cch)782 LONG WINAPI mmioWrite(HMMIO hmmio, HPCSTR pch, LONG cch)
783 {
784 LPWINE_MMIO wm;
785 LONG count;
786
787 TRACE("(%p, %p, %d);\n", hmmio, pch, cch);
788
789 if ((wm = MMIO_Get(hmmio)) == NULL)
790 return -1;
791
792 if (wm->info.cchBuffer) {
793 LONG bytesW = 0;
794
795 count = 0;
796 while (cch) {
797 if (wm->info.pchNext != wm->info.pchEndWrite) {
798 count = wm->info.pchEndWrite - wm->info.pchNext;
799 if (count > cch || count < 0) count = cch;
800 memcpy(wm->info.pchNext, pch, count);
801 wm->info.pchNext += count;
802 pch += count;
803 cch -= count;
804 bytesW += count;
805 wm->info.dwFlags |= MMIO_DIRTY;
806 } else {
807 if (wm->info.fccIOProc == FOURCC_MEM) {
808 if (wm->info.adwInfo[0]) {
809 /* from where would we get the memory handle? */
810 FIXME("memory file expansion not implemented!\n");
811 break;
812 } else break;
813 }
814 }
815
816 if (wm->info.pchNext == wm->info.pchEndWrite)
817 {
818 MMIO_Flush(wm, MMIO_EMPTYBUF);
819 MMIO_GrabNextBuffer(wm, FALSE);
820 }
821 else break;
822 }
823 count = bytesW;
824 } else {
825 count = send_message(wm->ioProc, &wm->info, MMIOM_WRITE, (LPARAM)pch, cch, FALSE);
826 wm->info.lBufOffset = wm->info.lDiskOffset;
827 }
828
829 TRACE("bytes written=%d\n", count);
830 return count;
831 }
832
833 /**************************************************************************
834 * mmioSeek [WINMM.@]
835 */
mmioSeek(HMMIO hmmio,LONG lOffset,INT iOrigin)836 LONG WINAPI mmioSeek(HMMIO hmmio, LONG lOffset, INT iOrigin)
837 {
838 LPWINE_MMIO wm;
839 LONG offset;
840
841 TRACE("(%p, %08X, %d);\n", hmmio, lOffset, iOrigin);
842
843 if ((wm = MMIO_Get(hmmio)) == NULL)
844 return MMSYSERR_INVALHANDLE;
845
846 /* not buffered, direct seek on file */
847 if (!wm->info.pchBuffer)
848 return send_message(wm->ioProc, &wm->info, MMIOM_SEEK, lOffset, iOrigin, FALSE);
849
850 switch (iOrigin) {
851 case SEEK_SET:
852 offset = lOffset;
853 break;
854 case SEEK_CUR:
855 offset = wm->info.lBufOffset + (wm->info.pchNext - wm->info.pchBuffer) + lOffset;
856 break;
857 case SEEK_END:
858 offset = ((wm->info.fccIOProc == FOURCC_MEM)? wm->info.cchBuffer : wm->dwFileSize) - lOffset;
859 break;
860 default:
861 return -1;
862 }
863
864 if (offset && offset >= wm->dwFileSize && wm->info.fccIOProc != FOURCC_MEM) {
865 /* should check that write mode exists */
866 if (MMIO_Flush(wm, 0) != MMSYSERR_NOERROR)
867 return -1;
868 wm->info.lBufOffset = offset;
869 wm->info.pchEndRead = wm->info.pchBuffer;
870 wm->info.pchEndWrite = wm->info.pchBuffer + wm->info.cchBuffer;
871 if ((wm->info.dwFlags & MMIO_RWMODE) == MMIO_READ) {
872 wm->info.lDiskOffset = wm->dwFileSize;
873 }
874 } else if ((wm->info.cchBuffer > 0) &&
875 ((offset < wm->info.lBufOffset) ||
876 (offset >= wm->info.lBufOffset + wm->info.cchBuffer) ||
877 !wm->bBufferLoaded)) {
878 /* stay in same buffer ? */
879 /* some memory mapped buffers are defined with -1 as a size */
880
881 /* condition to change buffer */
882 if ((wm->info.fccIOProc == FOURCC_MEM) ||
883 MMIO_Flush(wm, 0) != MMSYSERR_NOERROR ||
884 /* this also sets the wm->info.lDiskOffset field */
885 send_message(wm->ioProc, &wm->info, MMIOM_SEEK,
886 (offset / wm->info.cchBuffer) * wm->info.cchBuffer,
887 SEEK_SET, FALSE) == -1)
888 return -1;
889 MMIO_GrabNextBuffer(wm, TRUE);
890 }
891
892 wm->info.pchNext = wm->info.pchBuffer + (offset - wm->info.lBufOffset);
893
894 TRACE("=> %d\n", offset);
895 return offset;
896 }
897
898 /**************************************************************************
899 * mmioGetInfo [WINMM.@]
900 */
mmioGetInfo(HMMIO hmmio,MMIOINFO * lpmmioinfo,UINT uFlags)901 MMRESULT WINAPI mmioGetInfo(HMMIO hmmio, MMIOINFO* lpmmioinfo, UINT uFlags)
902 {
903 LPWINE_MMIO wm;
904
905 TRACE("(%p,%p,0x%08x)\n",hmmio,lpmmioinfo,uFlags);
906
907 if ((wm = MMIO_Get(hmmio)) == NULL)
908 return MMSYSERR_INVALHANDLE;
909
910 *lpmmioinfo = wm->info;
911
912 return MMSYSERR_NOERROR;
913 }
914
915 /**************************************************************************
916 * mmioSetInfo [WINMM.@]
917 */
mmioSetInfo(HMMIO hmmio,const MMIOINFO * lpmmioinfo,UINT uFlags)918 MMRESULT WINAPI mmioSetInfo(HMMIO hmmio, const MMIOINFO* lpmmioinfo, UINT uFlags)
919 {
920 LPWINE_MMIO wm;
921
922 TRACE("(%p,%p,0x%08x)\n",hmmio,lpmmioinfo,uFlags);
923
924 if ((wm = MMIO_Get(hmmio)) == NULL)
925 return MMSYSERR_INVALHANDLE;
926
927 /* check pointers coherence */
928 if (lpmmioinfo->pchNext < wm->info.pchBuffer ||
929 lpmmioinfo->pchNext > wm->info.pchBuffer + wm->info.cchBuffer ||
930 lpmmioinfo->pchEndRead < wm->info.pchBuffer ||
931 lpmmioinfo->pchEndRead > wm->info.pchBuffer + wm->info.cchBuffer ||
932 lpmmioinfo->pchEndWrite < wm->info.pchBuffer ||
933 lpmmioinfo->pchEndWrite > wm->info.pchBuffer + wm->info.cchBuffer)
934 return MMSYSERR_INVALPARAM;
935
936 wm->info.pchNext = lpmmioinfo->pchNext;
937 wm->info.pchEndRead = lpmmioinfo->pchEndRead;
938
939 return MMSYSERR_NOERROR;
940 }
941
942 /**************************************************************************
943 * mmioSetBuffer [WINMM.@]
944 */
mmioSetBuffer(HMMIO hmmio,LPSTR pchBuffer,LONG cchBuffer,UINT uFlags)945 MMRESULT WINAPI mmioSetBuffer(HMMIO hmmio, LPSTR pchBuffer, LONG cchBuffer, UINT uFlags)
946 {
947 LPWINE_MMIO wm;
948
949 TRACE("(hmmio=%p, pchBuf=%p, cchBuf=%d, uFlags=%#08x)\n",
950 hmmio, pchBuffer, cchBuffer, uFlags);
951
952 if ((wm = MMIO_Get(hmmio)) == NULL)
953 return MMSYSERR_INVALHANDLE;
954
955 return MMIO_SetBuffer(wm, pchBuffer, cchBuffer, uFlags);
956 }
957
958 /**************************************************************************
959 * mmioFlush [WINMM.@]
960 */
mmioFlush(HMMIO hmmio,UINT uFlags)961 MMRESULT WINAPI mmioFlush(HMMIO hmmio, UINT uFlags)
962 {
963 LPWINE_MMIO wm;
964
965 TRACE("(%p, %04X)\n", hmmio, uFlags);
966
967 if ((wm = MMIO_Get(hmmio)) == NULL)
968 return MMSYSERR_INVALHANDLE;
969
970 return MMIO_Flush(wm, uFlags);
971 }
972
973 /**************************************************************************
974 * mmioAdvance [WINMM.@]
975 */
mmioAdvance(HMMIO hmmio,MMIOINFO * lpmmioinfo,UINT uFlags)976 MMRESULT WINAPI mmioAdvance(HMMIO hmmio, MMIOINFO* lpmmioinfo, UINT uFlags)
977 {
978 LPWINE_MMIO wm;
979
980 TRACE("hmmio=%p, lpmmioinfo=%p, uFlags=%04X\n", hmmio, lpmmioinfo, uFlags);
981
982 /* NOTE: mmioAdvance16 heavily relies on parameters from lpmmioinfo we're using
983 * here. be sure if you change something here to check mmioAdvance16 as well
984 */
985 if ((wm = MMIO_Get(hmmio)) == NULL)
986 return MMSYSERR_INVALHANDLE;
987
988 if (!wm->info.cchBuffer)
989 return MMIOERR_UNBUFFERED;
990
991 if (uFlags != MMIO_READ && uFlags != MMIO_WRITE)
992 return MMSYSERR_INVALPARAM;
993
994 if (uFlags == MMIO_WRITE && (lpmmioinfo->dwFlags & MMIO_DIRTY))
995 {
996 send_message(wm->ioProc, &wm->info, MMIOM_SEEK, lpmmioinfo->lBufOffset, SEEK_SET, FALSE);
997 send_message(wm->ioProc, &wm->info, MMIOM_WRITE, (LPARAM)lpmmioinfo->pchBuffer,
998 lpmmioinfo->pchNext - lpmmioinfo->pchBuffer, FALSE);
999 lpmmioinfo->dwFlags &= ~MMIO_DIRTY;
1000 }
1001 if (MMIO_Flush(wm, 0) != MMSYSERR_NOERROR)
1002 return MMIOERR_CANNOTWRITE;
1003
1004 if (lpmmioinfo) {
1005 wm->dwFileSize = max(wm->dwFileSize, lpmmioinfo->lBufOffset +
1006 (lpmmioinfo->pchNext - lpmmioinfo->pchBuffer));
1007 }
1008 MMIO_GrabNextBuffer(wm, uFlags == MMIO_READ);
1009
1010 if (lpmmioinfo) {
1011 lpmmioinfo->pchNext = lpmmioinfo->pchBuffer;
1012 lpmmioinfo->pchEndRead = lpmmioinfo->pchBuffer +
1013 (wm->info.pchEndRead - wm->info.pchBuffer);
1014 lpmmioinfo->pchEndWrite = lpmmioinfo->pchBuffer +
1015 (wm->info.pchEndWrite - wm->info.pchBuffer);
1016 lpmmioinfo->lDiskOffset = wm->info.lDiskOffset;
1017 lpmmioinfo->lBufOffset = wm->info.lBufOffset;
1018 }
1019 return MMSYSERR_NOERROR;
1020 }
1021
1022 /**************************************************************************
1023 * mmioStringToFOURCCA [WINMM.@]
1024 */
mmioStringToFOURCCA(LPCSTR sz,UINT uFlags)1025 FOURCC WINAPI mmioStringToFOURCCA(LPCSTR sz, UINT uFlags)
1026 {
1027 CHAR cc[4];
1028 int i = 0;
1029
1030 for (i = 0; i < 4 && sz[i]; i++) {
1031 if (uFlags & MMIO_TOUPPER) {
1032 cc[i] = toupper(sz[i]);
1033 } else {
1034 cc[i] = sz[i];
1035 }
1036 }
1037
1038 /* Pad with spaces */
1039 while (i < 4) cc[i++] = ' ';
1040
1041 TRACE("Got '%.4s'\n",cc);
1042 return mmioFOURCC(cc[0],cc[1],cc[2],cc[3]);
1043 }
1044
1045 /**************************************************************************
1046 * mmioStringToFOURCCW [WINMM.@]
1047 */
mmioStringToFOURCCW(LPCWSTR sz,UINT uFlags)1048 FOURCC WINAPI mmioStringToFOURCCW(LPCWSTR sz, UINT uFlags)
1049 {
1050 char szA[4];
1051
1052 WideCharToMultiByte( CP_ACP, 0, sz, 4, szA, sizeof(szA), NULL, NULL );
1053 return mmioStringToFOURCCA(szA,uFlags);
1054 }
1055
1056 /**************************************************************************
1057 * mmioInstallIOProcA [WINMM.@]
1058 */
mmioInstallIOProcA(FOURCC fccIOProc,LPMMIOPROC pIOProc,DWORD dwFlags)1059 LPMMIOPROC WINAPI mmioInstallIOProcA(FOURCC fccIOProc,
1060 LPMMIOPROC pIOProc, DWORD dwFlags)
1061 {
1062 return MMIO_InstallIOProc(fccIOProc, pIOProc, dwFlags, FALSE);
1063 }
1064
1065 /**************************************************************************
1066 * mmioInstallIOProcW [WINMM.@]
1067 */
mmioInstallIOProcW(FOURCC fccIOProc,LPMMIOPROC pIOProc,DWORD dwFlags)1068 LPMMIOPROC WINAPI mmioInstallIOProcW(FOURCC fccIOProc,
1069 LPMMIOPROC pIOProc, DWORD dwFlags)
1070 {
1071 return MMIO_InstallIOProc(fccIOProc, pIOProc, dwFlags, TRUE);
1072 }
1073
1074 /******************************************************************
1075 * MMIO_SendMessage
1076 *
1077 *
1078 */
MMIO_SendMessage(HMMIO hmmio,UINT uMessage,LPARAM lParam1,LPARAM lParam2,BOOL is_unicode)1079 static LRESULT MMIO_SendMessage(HMMIO hmmio, UINT uMessage, LPARAM lParam1,
1080 LPARAM lParam2, BOOL is_unicode)
1081 {
1082 LPWINE_MMIO wm;
1083
1084 TRACE("(%p, %u, %ld, %ld, %s)\n", hmmio, uMessage, lParam1, lParam2, is_unicode ? "unicode" : "ansi");
1085
1086 if (uMessage < MMIOM_USER)
1087 return MMSYSERR_INVALPARAM;
1088
1089 if ((wm = MMIO_Get(hmmio)) == NULL)
1090 return MMSYSERR_INVALHANDLE;
1091
1092 return send_message(wm->ioProc, &wm->info, uMessage, lParam1, lParam2, is_unicode);
1093 }
1094
1095 /**************************************************************************
1096 * mmioSendMessage [WINMM.@]
1097 */
mmioSendMessage(HMMIO hmmio,UINT uMessage,LPARAM lParam1,LPARAM lParam2)1098 LRESULT WINAPI mmioSendMessage(HMMIO hmmio, UINT uMessage,
1099 LPARAM lParam1, LPARAM lParam2)
1100 {
1101 return MMIO_SendMessage(hmmio, uMessage, lParam1, lParam2, FALSE);
1102 }
1103
1104 /**************************************************************************
1105 * mmioDescend [WINMM.@]
1106 */
mmioDescend(HMMIO hmmio,LPMMCKINFO lpck,const MMCKINFO * lpckParent,UINT uFlags)1107 MMRESULT WINAPI mmioDescend(HMMIO hmmio, LPMMCKINFO lpck,
1108 const MMCKINFO* lpckParent, UINT uFlags)
1109 {
1110 DWORD dwOldPos;
1111 FOURCC srchCkId;
1112 FOURCC srchType;
1113
1114 TRACE("(%p, %p, %p, %04X);\n", hmmio, lpck, lpckParent, uFlags);
1115
1116 if (lpck == NULL)
1117 return MMSYSERR_INVALPARAM;
1118
1119 dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
1120 TRACE("dwOldPos=%d\n", dwOldPos);
1121
1122 if (lpckParent != NULL) {
1123 TRACE("seek inside parent at %d !\n", lpckParent->dwDataOffset);
1124 /* EPP: was dwOldPos = mmioSeek(hmmio,lpckParent->dwDataOffset,SEEK_SET); */
1125 if (dwOldPos < lpckParent->dwDataOffset ||
1126 dwOldPos >= lpckParent->dwDataOffset + lpckParent->cksize) {
1127 WARN("outside parent chunk\n");
1128 return MMIOERR_CHUNKNOTFOUND;
1129 }
1130 }
1131
1132 /* The SDK docu says 'ckid' is used for all cases. Real World
1133 * examples disagree -Marcus,990216.
1134 */
1135
1136 srchCkId = 0;
1137 srchType = 0;
1138
1139 /* find_chunk looks for 'ckid' */
1140 if (uFlags & MMIO_FINDCHUNK)
1141 srchCkId = lpck->ckid;
1142
1143 /* find_riff and find_list look for 'fccType' */
1144 if (uFlags & MMIO_FINDLIST)
1145 {
1146 srchCkId = FOURCC_LIST;
1147 srchType = lpck->fccType;
1148 }
1149
1150 if (uFlags & MMIO_FINDRIFF)
1151 {
1152 srchCkId = FOURCC_RIFF;
1153 srchType = lpck->fccType;
1154 }
1155
1156 TRACE("searching for %4.4s.%4.4s\n",
1157 (LPCSTR)&srchCkId, srchType ? (LPCSTR)&srchType : "any");
1158
1159 while (TRUE)
1160 {
1161 LONG ix;
1162
1163 ix = mmioRead(hmmio, (LPSTR)lpck, 3 * sizeof(DWORD));
1164 if (ix < 0 || ix < 2*sizeof(DWORD))
1165 {
1166 mmioSeek(hmmio, dwOldPos, SEEK_SET);
1167 WARN("return ChunkNotFound\n");
1168 return MMIOERR_CHUNKNOTFOUND;
1169 }
1170
1171 lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD);
1172 TRACE("ckid=%4.4s fcc=%4.4s cksize=%08X !\n",
1173 (LPCSTR)&lpck->ckid,
1174 srchType ? (LPCSTR)&lpck->fccType:"<na>",
1175 lpck->cksize);
1176 if ( (!srchCkId || (srchCkId == lpck->ckid)) &&
1177 (!srchType || (srchType == lpck->fccType)) )
1178 break;
1179
1180 dwOldPos = lpck->dwDataOffset + ((lpck->cksize + 1) & ~1);
1181 mmioSeek(hmmio, dwOldPos, SEEK_SET);
1182 }
1183
1184 lpck->dwFlags = 0;
1185 /* If we were looking for RIFF/LIST chunks, the final file position
1186 * is after the chunkid. If we were just looking for the chunk
1187 * it is after the cksize. So add 4 in RIFF/LIST case.
1188 */
1189 if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST)
1190 mmioSeek(hmmio, lpck->dwDataOffset + sizeof(DWORD), SEEK_SET);
1191 else
1192 {
1193 mmioSeek(hmmio, lpck->dwDataOffset, SEEK_SET);
1194 lpck->fccType = 0;
1195 }
1196 TRACE("lpck: ckid=%.4s, cksize=%d, dwDataOffset=%d fccType=%08X (%.4s)!\n",
1197 (LPSTR)&lpck->ckid, lpck->cksize, lpck->dwDataOffset,
1198 lpck->fccType, srchType?(LPSTR)&lpck->fccType:"");
1199 return MMSYSERR_NOERROR;
1200 }
1201
1202 /**************************************************************************
1203 * mmioAscend [WINMM.@]
1204 */
mmioAscend(HMMIO hmmio,LPMMCKINFO lpck,UINT uFlags)1205 MMRESULT WINAPI mmioAscend(HMMIO hmmio, LPMMCKINFO lpck, UINT uFlags)
1206 {
1207 TRACE("(%p, %p, %04X);\n", hmmio, lpck, uFlags);
1208
1209 if (lpck->dwFlags & MMIO_DIRTY) {
1210 DWORD dwOldPos, dwNewSize;
1211
1212 TRACE("Chunk is dirty, checking if chunk's size is correct\n");
1213 dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
1214 TRACE("dwOldPos=%d lpck->dwDataOffset = %d\n", dwOldPos, lpck->dwDataOffset);
1215 dwNewSize = dwOldPos - lpck->dwDataOffset;
1216 if (dwNewSize != lpck->cksize) {
1217 TRACE("Nope: lpck->cksize=%d dwNewSize=%d\n", lpck->cksize, dwNewSize);
1218 lpck->cksize = dwNewSize;
1219
1220 /* pad odd size with 0 */
1221 if (dwNewSize & 1) {
1222 char ch = 0;
1223 mmioWrite(hmmio, &ch, 1);
1224 }
1225 mmioSeek(hmmio, lpck->dwDataOffset - sizeof(DWORD), SEEK_SET);
1226 mmioWrite(hmmio, (LPSTR)&dwNewSize, sizeof(DWORD));
1227 }
1228 lpck->dwFlags = 0;
1229 }
1230
1231 mmioSeek(hmmio, lpck->dwDataOffset + ((lpck->cksize + 1) & ~1), SEEK_SET);
1232
1233 return MMSYSERR_NOERROR;
1234 }
1235
1236 /**************************************************************************
1237 * mmioCreateChunk [WINMM.@]
1238 */
mmioCreateChunk(HMMIO hmmio,MMCKINFO * lpck,UINT uFlags)1239 MMRESULT WINAPI mmioCreateChunk(HMMIO hmmio, MMCKINFO* lpck, UINT uFlags)
1240 {
1241 DWORD dwOldPos;
1242 LONG size;
1243 LONG ix;
1244
1245 TRACE("(%p, %p, %04X);\n", hmmio, lpck, uFlags);
1246
1247 dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
1248 TRACE("dwOldPos=%d\n", dwOldPos);
1249
1250 if (uFlags == MMIO_CREATELIST)
1251 lpck->ckid = FOURCC_LIST;
1252 else if (uFlags == MMIO_CREATERIFF)
1253 lpck->ckid = FOURCC_RIFF;
1254
1255 TRACE("ckid=%.4s\n", (LPSTR)&lpck->ckid);
1256
1257 size = 2 * sizeof(DWORD);
1258 lpck->dwDataOffset = dwOldPos + size;
1259
1260 if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST)
1261 size += sizeof(DWORD);
1262 lpck->dwFlags = MMIO_DIRTY;
1263
1264 ix = mmioWrite(hmmio, (LPSTR)lpck, size);
1265 TRACE("after mmioWrite ix = %d req = %d, errno = %d\n", ix, size, errno);
1266 if (ix != size) {
1267 mmioSeek(hmmio, dwOldPos, SEEK_SET);
1268 WARN("return CannotWrite\n");
1269 return MMIOERR_CANNOTWRITE;
1270 }
1271
1272 return MMSYSERR_NOERROR;
1273 }
1274
1275 /**************************************************************************
1276 * mmioRenameA [WINMM.@]
1277 */
mmioRenameA(LPCSTR szFileName,LPCSTR szNewFileName,const MMIOINFO * lpmmioinfo,DWORD dwFlags)1278 MMRESULT WINAPI mmioRenameA(LPCSTR szFileName, LPCSTR szNewFileName,
1279 const MMIOINFO* lpmmioinfo, DWORD dwFlags)
1280 {
1281 struct IOProcList* ioProc = NULL;
1282 struct IOProcList tmp;
1283 FOURCC fcc;
1284
1285 TRACE("('%s', '%s', %p, %08X);\n",
1286 debugstr_a(szFileName), debugstr_a(szNewFileName), lpmmioinfo, dwFlags);
1287
1288 /* If both params are NULL, then parse the file name */
1289 if (lpmmioinfo && lpmmioinfo->fccIOProc == 0 && lpmmioinfo->pIOProc == NULL)
1290 {
1291 fcc = MMIO_ParseExtA(szFileName);
1292 if (fcc) ioProc = MMIO_FindProcNode(fcc);
1293 }
1294
1295 /* Handle any unhandled/error case from above. Assume DOS file */
1296 if (!lpmmioinfo || (lpmmioinfo->fccIOProc == 0 && lpmmioinfo->pIOProc == NULL && ioProc == NULL))
1297 ioProc = MMIO_FindProcNode(FOURCC_DOS);
1298 /* if just the four character code is present, look up IO proc */
1299 else if (lpmmioinfo->pIOProc == NULL)
1300 ioProc = MMIO_FindProcNode(lpmmioinfo->fccIOProc);
1301 else /* use relevant ioProc */
1302 {
1303 ioProc = &tmp;
1304 tmp.fourCC = lpmmioinfo->fccIOProc;
1305 tmp.pIOProc = lpmmioinfo->pIOProc;
1306 tmp.is_unicode = FALSE;
1307 tmp.count = 1;
1308 }
1309
1310 /* FIXME: should we actually pass lpmmioinfo down the drain ???
1311 * or make a copy of it because it's const ???
1312 */
1313 return send_message(ioProc, (MMIOINFO*)lpmmioinfo, MMIOM_RENAME,
1314 (LPARAM)szFileName, (LPARAM)szNewFileName, FALSE);
1315 }
1316
1317 /**************************************************************************
1318 * mmioRenameW [WINMM.@]
1319 */
mmioRenameW(LPCWSTR szFileName,LPCWSTR szNewFileName,const MMIOINFO * lpmmioinfo,DWORD dwFlags)1320 MMRESULT WINAPI mmioRenameW(LPCWSTR szFileName, LPCWSTR szNewFileName,
1321 const MMIOINFO* lpmmioinfo, DWORD dwFlags)
1322 {
1323 LPSTR szFn = NULL;
1324 LPSTR sznFn = NULL;
1325 UINT ret = MMSYSERR_NOMEM;
1326 INT len;
1327
1328 if (szFileName)
1329 {
1330 len = WideCharToMultiByte( CP_ACP, 0, szFileName, -1, NULL, 0, NULL, NULL );
1331 szFn = HeapAlloc( GetProcessHeap(), 0, len );
1332 if (!szFn) goto done;
1333 WideCharToMultiByte( CP_ACP, 0, szFileName, -1, szFn, len, NULL, NULL );
1334 }
1335 if (szNewFileName)
1336 {
1337 len = WideCharToMultiByte( CP_ACP, 0, szNewFileName, -1, NULL, 0, NULL, NULL );
1338 sznFn = HeapAlloc( GetProcessHeap(), 0, len );
1339 if (!sznFn) goto done;
1340 WideCharToMultiByte( CP_ACP, 0, szNewFileName, -1, sznFn, len, NULL, NULL );
1341 }
1342
1343 ret = mmioRenameA(szFn, sznFn, lpmmioinfo, dwFlags);
1344
1345 done:
1346 HeapFree(GetProcessHeap(),0,szFn);
1347 HeapFree(GetProcessHeap(),0,sznFn);
1348 return ret;
1349 }
1350