git.oblomov.eu Git - wine/blob - dlls/winmm/mmio.c

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