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|MMIO_EXIST)) {
 349                 char    buffer[MAX_PATH];
 350
 351                 if (GetFullPathNameA(szFileName, sizeof(buffer), buffer, NULL) >= sizeof(buffer))
 352                         return (HMMIO16)FALSE;
 353                 if ((dwOpenFlags&MMIO_EXIST)&&(GetFileAttributesA(buffer)==-1))
 354                         return (HMMIO16)FALSE;
 355                 strcpy(szFileName, buffer);
 356                 return (HMMIO16)TRUE;
 357         }
 358
 359         hmmio = GlobalAlloc16(GHND, sizeof(MMIOINFO16));
 360         lpmminfo = (LPMMIOINFO16)GlobalLock16(hmmio);
 361         if (lpmminfo == NULL)
 362                 return 0;
 363         memset(lpmminfo, 0, sizeof(MMIOINFO16));
 364
 365         /* If both params are NULL, then parse the file name */
 366         if (refmminfo->fccIOProc == 0 && refmminfo->pIOProc == NULL) {
 367                 lpmminfo->fccIOProc = MMIO_ParseExt(szFileName);
 368                 /* Handle any unhandled/error case. Assume DOS file */
 369                 if (lpmminfo->fccIOProc == 0) {
 370                 lpmminfo->fccIOProc = FOURCC_DOS;
 371                 lpmminfo->pIOProc = (LPMMIOPROC16) mmioDosIOProc;
 372                 } else {
 373                         lpmminfo->pIOProc = MMIO_InstallIOProc(lpmminfo->fccIOProc, NULL, MMIO_FINDPROC, b32bit);
 374                 }
 375         }
 376
 377         /* if just the four character code is present, look up IO proc */
 378         else if (refmminfo->pIOProc == NULL) {
 379
 380                 lpmminfo->fccIOProc = refmminfo->fccIOProc;
 381                 lpmminfo->pIOProc = MMIO_InstallIOProc(refmminfo->fccIOProc, NULL, MMIO_FINDPROC, b32bit);
 382
 383         }
 384         /* if IO proc specified, use it and specified four character code */
 385         else {
 386
 387                 lpmminfo->fccIOProc = refmminfo->fccIOProc;
 388                 lpmminfo->pIOProc = (LPMMIOPROC16)refmminfo->pIOProc;
 389         }
 390
 391         if (dwOpenFlags & MMIO_ALLOCBUF) {
 392                 if ((refmminfo->wErrorRet = mmioSetBuffer16(hmmio, NULL, MMIO_DEFAULTBUFFER, 0))) {
 393                         return 0;
 394                 }
 395         } else if (lpmminfo->fccIOProc == FOURCC_MEM) {
 396                 if ((refmminfo->wErrorRet = mmioSetBuffer16(hmmio, refmminfo->pchBuffer, refmminfo->cchBuffer, 0))) {
 397                         return 0;
 398                 }
 399         }
 400
 401         /* see mmioDosIOProc for that one */
 402         lpmminfo->adwInfo[0] = refmminfo->adwInfo[0];
 403         lpmminfo->dwFlags = dwOpenFlags;
 404         lpmminfo->hmmio = hmmio;
 405
 406         /* call IO proc to actually open file */
 407         refmminfo->wErrorRet = (UINT16) mmioSendMessage(hmmio, MMIOM_OPEN, (LPARAM) szFileName, (LPARAM) !b32bit);
 408
 409         GlobalUnlock16(hmmio);
 410
 411         if (refmminfo->wErrorRet != 0) {
 412                 GlobalFree16(hmmio);
 413                 return 0;
 414         }
 415
 416         return hmmio;
 417 }
 418
 419 /**************************************************************************
 420  *                              mmioOpenW                       [WINMM.123]
 421  */
 422 HMMIO WINAPI mmioOpenW(LPWSTR szFileName, MMIOINFO* lpmmioinfo,
 423                        DWORD dwOpenFlags)
 424 {
 425         LPSTR   szFn = HEAP_strdupWtoA(GetProcessHeap(),0,szFileName);
 426         HMMIO   ret = mmioOpenA(szFn, lpmmioinfo, dwOpenFlags);
 427
 428         HeapFree(GetProcessHeap(),0,szFn);
 429         return ret;
 430 }
 431
 432 /**************************************************************************
 433  *                              mmioOpenA                       [WINMM.122]
 434  */
 435 HMMIO WINAPI mmioOpenA(LPSTR szFileName, MMIOINFO* lpmmioinfo,
 436                        DWORD dwOpenFlags)
 437 {
 438         HMMIO   ret;
 439
 440         if (lpmmioinfo) {
 441                 ret = MMIO_Open(szFileName, lpmmioinfo, dwOpenFlags, TRUE);
 442         } else {
 443            MMIOINFO     mmioinfo;
 444
 445            mmioinfo.fccIOProc = 0;
 446            mmioinfo.pIOProc = NULL;
 447            mmioinfo.pchBuffer = NULL;
 448            mmioinfo.cchBuffer = 0;
 449
 450                 ret = MMIO_Open(szFileName, &mmioinfo, dwOpenFlags, TRUE);
 451         }
 452         return ret;
 453 }
 454
 455 /**************************************************************************
 456  *                              mmioOpen                [MMSYSTEM.1210]
 457  */
 458 HMMIO16 WINAPI mmioOpen16(LPSTR szFileName, MMIOINFO16* lpmmioinfo,
 459                           DWORD dwOpenFlags)
 460 {
 461         HMMIO           ret;
 462         MMIOINFO        mmio;
 463
 464         if (lpmmioinfo) {
 465                 MMIO_infoMap16To32(&mmio,lpmmioinfo);
 466                 ret = MMIO_Open(szFileName, &mmio, dwOpenFlags, FALSE);
 467                 MMIO_infoUnmap16To32(lpmmioinfo,&mmio);
 468                 /* Copy additional things changed by MMIO_Open */
 469                 lpmmioinfo->fccIOProc = mmio.fccIOProc;
 470                 lpmmioinfo->pIOProc = (LPMMIOPROC16)mmio.pIOProc;
 471                 lpmmioinfo->wErrorRet = mmio.wErrorRet;
 472         } else {
 473                 mmio.fccIOProc = 0;
 474                 mmio.pIOProc = NULL;
 475                 mmio.pchBuffer = NULL;
 476                 mmio.cchBuffer = 0;
 477                 ret = MMIO_Open(szFileName, &mmio, dwOpenFlags, FALSE);
 478         }
 479         return ret;
 480 }
 481
 482
 483 /**************************************************************************
 484  *                              mmioClose               [WINMM.114]
 485  */
 486 MMRESULT WINAPI mmioClose(HMMIO hmmio, UINT uFlags)
 487 {
 488         LPMMIOINFO16 lpmminfo;
 489         MMRESULT result;
 490
 491         TRACE("(%04X, %04X);\n", hmmio, uFlags);
 492
 493         lpmminfo = (LPMMIOINFO16) GlobalLock16(hmmio);
 494         if (lpmminfo == NULL)
 495                 return 0;
 496
 497         /* flush the file - if error reported, ignore */
 498         if (mmioFlush(hmmio, MMIO_EMPTYBUF) != 0)
 499                 lpmminfo->dwFlags &= ~MMIO_DIRTY;
 500
 501         result = mmioSendMessage(hmmio,MMIOM_CLOSE,(LPARAM)uFlags,(LPARAM)0);
 502
 503         mmioSetBuffer16(hmmio, NULL, 0, 0);
 504
 505         GlobalUnlock16(hmmio);
 506         GlobalFree16(hmmio);
 507
 508         return result;
 509 }
 510
 511
 512 /**************************************************************************
 513  *                              mmioClose               [MMSYSTEM.1211]
 514  */
 515 MMRESULT16 WINAPI mmioClose16(HMMIO16 hmmio, UINT16 uFlags)
 516 {
 517         return mmioClose(hmmio,uFlags);
 518 }
 519
 520
 521
 522 /**************************************************************************
 523  *                              mmioRead                [WINMM.124]
 524  */
 525 LONG WINAPI mmioRead(HMMIO hmmio, HPSTR pch, LONG cch)
 526 {
 527         LONG count;
 528         LPMMIOINFO16 lpmminfo;
 529
 530         TRACE("(%04X, %p, %ld);\n", hmmio, pch, cch);
 531
 532         lpmminfo = (LPMMIOINFO16)GlobalLock16(hmmio);
 533         if (lpmminfo == NULL)
 534                 return -1;
 535
 536         if (lpmminfo->pchNext != lpmminfo->pchEndRead) {
 537                 count = lpmminfo->pchEndRead - lpmminfo->pchNext;
 538                 if (count > cch || count < 0) count = cch;
 539                 memcpy(pch, lpmminfo->pchNext, count);
 540                 lpmminfo->pchNext += count;
 541                 pch += count;
 542                 cch -= count;
 543         } else
 544                 count = 0;
 545
 546         if (cch&&(lpmminfo->fccIOProc!=FOURCC_MEM)) {
 547                 if (lpmminfo->cchBuffer) {
 548                         mmioFlush(hmmio, MMIO_EMPTYBUF);
 549
 550                         while (cch) {
 551                                 LONG size;
 552                                 lpmminfo->lBufOffset = lpmminfo->lDiskOffset;
 553                                 lpmminfo->pchNext = lpmminfo->pchBuffer;
 554                                 lpmminfo->pchEndRead = lpmminfo->pchBuffer;
 555                                 size = mmioSendMessage(hmmio, MMIOM_READ,
 556                                                 (LPARAM) lpmminfo->pchBuffer,
 557                                                 (LPARAM) lpmminfo->cchBuffer);
 558                                 if (size<=0) break;
 559                                 lpmminfo->pchEndRead = lpmminfo->pchBuffer + size;
 560                                 if (size > cch) size = cch;
 561                                 memcpy(pch, lpmminfo->pchNext, size);
 562                                 lpmminfo->pchNext += size;
 563                                 pch += size;
 564                                 cch -= size;
 565                                 count += size;
 566                         }
 567                 } else {
 568                         count += mmioSendMessage(hmmio, MMIOM_READ, (LPARAM) pch, (LPARAM) cch);
 569                         if (count>0) lpmminfo->lBufOffset += count;
 570                 }
 571         }
 572
 573         GlobalUnlock16(hmmio);
 574         TRACE("count=%ld\n", count);
 575         return count;
 576 }
 577
 578 /**************************************************************************
 579  *                              mmioRead                [MMSYSTEM.1212]
 580  */
 581 LONG WINAPI mmioRead16(HMMIO16 hmmio, HPSTR pch, LONG cch)
 582 {
 583         return mmioRead(hmmio,pch,cch);
 584 }
 585
 586 /**************************************************************************
 587  *                              mmioWrite               [WINMM.133]
 588  */
 589 LONG WINAPI mmioWrite(HMMIO hmmio, HPCSTR pch, LONG cch)
 590 {
 591         LONG count;
 592         LPMMIOINFO16 lpmminfo;
 593
 594         TRACE("(%04X, %p, %ld);\n", hmmio, pch, cch);
 595
 596         lpmminfo = (LPMMIOINFO16)GlobalLock16(hmmio);
 597         if (lpmminfo == NULL)
 598                 return -1;
 599
 600         if (lpmminfo->cchBuffer) {
 601                 count = 0;
 602                 while (cch) {
 603                         if (lpmminfo->pchNext != lpmminfo->pchEndWrite) {
 604                                 count = lpmminfo->pchEndWrite - lpmminfo->pchNext;
 605                                 if (count > cch || count < 0) count = cch;
 606                                 memcpy(lpmminfo->pchNext, pch, count);
 607                                 lpmminfo->pchNext += count;
 608                                 pch += count;
 609                                 cch -= count;
 610                                 lpmminfo->dwFlags |= MMIO_DIRTY;
 611                         } else
 612                         if (lpmminfo->fccIOProc==FOURCC_MEM) {
 613                                 if (lpmminfo->adwInfo[0]) {
 614                                         /* from where would we get the memory handle? */
 615                                         FIXME("memory file expansion not implemented!\n");
 616                                 } else break;
 617                         }
 618
 619                         if (lpmminfo->pchNext == lpmminfo->pchEndWrite
 620                                 && mmioFlush(hmmio, MMIO_EMPTYBUF)) break;
 621                 }
 622         } else {
 623                 count = mmioSendMessage(hmmio, MMIOM_WRITE, (LPARAM) pch, (LPARAM) cch);
 624                 lpmminfo->lBufOffset = lpmminfo->lDiskOffset;
 625         }
 626
 627         GlobalUnlock16(hmmio);
 628         TRACE("count=%ld\n", count);
 629         return count;
 630 }
 631
 632 /**************************************************************************
 633  *                              mmioWrite               [MMSYSTEM.1213]
 634  */
 635 LONG WINAPI mmioWrite16(HMMIO16 hmmio, HPCSTR pch, LONG cch)
 636 {
 637         return mmioWrite(hmmio,pch,cch);
 638 }
 639
 640 /**************************************************************************
 641  *                              mmioSeek                [MMSYSTEM.1214]
 642  */
 643 LONG WINAPI mmioSeek(HMMIO hmmio, LONG lOffset, INT iOrigin)
 644 {
 645         int offset;
 646         LPMMIOINFO16 lpmminfo;
 647
 648         TRACE("(%04X, %08lX, %d);\n", hmmio, lOffset, iOrigin);
 649
 650         lpmminfo = (LPMMIOINFO16)GlobalLock16(hmmio);
 651         if (lpmminfo == NULL)
 652                 return -1;
 653
 654         offset = (iOrigin==SEEK_SET)?(lOffset - lpmminfo->lBufOffset):
 655                  (iOrigin==SEEK_CUR)?(lOffset +
 656                  (lpmminfo->pchNext - lpmminfo->pchBuffer)):-1;
 657
 658         if ((lpmminfo->cchBuffer<0)||
 659             ((offset>=0)&&(offset<=(lpmminfo->pchEndRead-lpmminfo->pchBuffer)))) {
 660                 lpmminfo->pchNext = lpmminfo->pchBuffer + offset;
 661                 GlobalUnlock16(hmmio);
 662                 return lpmminfo->lBufOffset + offset;
 663         }
 664
 665         if ((lpmminfo->fccIOProc==FOURCC_MEM)||mmioFlush(hmmio, MMIO_EMPTYBUF)) {
 666                 GlobalUnlock16(hmmio);
 667                 return -1;
 668         }
 669
 670         offset = mmioSendMessage(hmmio, MMIOM_SEEK, (LPARAM) lOffset, (LPARAM) iOrigin);
 671         lpmminfo->lBufOffset = lpmminfo->lDiskOffset;
 672
 673         GlobalUnlock16(hmmio);
 674         return offset;
 675 }
 676
 677 /**************************************************************************
 678  *                              mmioSeek                [MMSYSTEM.1214]
 679  */
 680 LONG WINAPI mmioSeek16(HMMIO16 hmmio, LONG lOffset, INT16 iOrigin)
 681 {
 682         return mmioSeek(hmmio,lOffset,iOrigin);
 683 }
 684
 685 /**************************************************************************
 686  *                              mmioGetInfo             [MMSYSTEM.1215]
 687  */
 688 UINT16 WINAPI mmioGetInfo16(HMMIO16 hmmio, MMIOINFO16 * lpmmioinfo, UINT16 uFlags)
 689 {
 690         LPMMIOINFO16    lpmminfo;
 691         TRACE("mmioGetInfo\n");
 692         lpmminfo = (LPMMIOINFO16)GlobalLock16(hmmio);
 693         if (lpmminfo == NULL) return 0;
 694         memcpy(lpmmioinfo, lpmminfo, sizeof(MMIOINFO16));
 695         GlobalUnlock16(hmmio);
 696         return 0;
 697 }
 698
 699 /**************************************************************************
 700  *                              mmioGetInfo             [WINMM.118]
 701  */
 702 UINT WINAPI mmioGetInfo(HMMIO hmmio, MMIOINFO*lpmmioinfo, UINT uFlags)
 703 {
 704         MMIOINFO16      mmioinfo;
 705         LPMMIOINFO16    lpmminfo=&mmioinfo;
 706         UINT16          ret;
 707
 708         TRACE("(0x%04x,%p,0x%08x)\n",hmmio,lpmmioinfo,uFlags);
 709         ret = mmioGetInfo16(hmmio,&mmioinfo,uFlags);
 710         if (!ret)
 711                 return 0;
 712         MMIO_infoMap16To32(lpmmioinfo, lpmminfo);
 713         return 0;
 714 }
 715
 716 /**************************************************************************
 717  *                              mmioSetInfo             [MMSYSTEM.1216]
 718  */
 719 UINT16 WINAPI mmioSetInfo16(HMMIO16 hmmio, const MMIOINFO16 * lpmmioinfo, UINT16 uFlags)
 720 {
 721         LPMMIOINFO16    lpmminfo;
 722         TRACE("mmioSetInfo\n");
 723         lpmminfo = (LPMMIOINFO16)GlobalLock16(hmmio);
 724         if (lpmminfo == NULL) return 0;
 725         lpmminfo->pchNext       = lpmmioinfo->pchNext;
 726         lpmminfo->pchEndRead    = lpmmioinfo->pchEndRead;
 727         GlobalUnlock16(hmmio);
 728         return 0;
 729 }
 730
 731 /**************************************************************************
 732  *                              mmioSetInfo             [WINMM.130]
 733  */
 734 UINT WINAPI mmioSetInfo(HMMIO hmmio, const MMIOINFO * lpmmioinfo, UINT uFlags)
 735 {
 736         LPMMIOINFO16    lpmminfo;
 737         TRACE("mmioSetInfo\n");
 738         lpmminfo = (LPMMIOINFO16)GlobalLock16(hmmio);
 739         if (lpmminfo == NULL) return 0;
 740         lpmminfo->pchNext = (HPSTR)(lpmminfo->pchBuffer + (lpmmioinfo->pchNext - lpmmioinfo->pchBuffer));
 741         GlobalUnlock16(hmmio);
 742         return 0;
 743 }
 744
 745 /**************************************************************************
 746 *                               mmioSetBuffer           [WINMM.129]
 747 */
 748 UINT WINAPI mmioSetBuffer(HMMIO hmmio, LPSTR pchBuffer,
 749                                                                                 LONG cchBuffer, UINT uFlags)
 750 {
 751         LPMMIOINFO16    lpmminfo;
 752
 753         if (mmioFlush(hmmio, MMIO_EMPTYBUF) != 0)
 754                 return MMIOERR_CANNOTWRITE;
 755
 756         TRACE("(hmmio=%04x, pchBuf=%p, cchBuf=%ld, uFlags=%#08x)\n",
 757               hmmio, pchBuffer, cchBuffer, uFlags);
 758
 759         lpmminfo = (LPMMIOINFO16)GlobalLock16(hmmio);
 760         if (lpmminfo == NULL) return 0;
 761         if ((!cchBuffer || pchBuffer) && lpmminfo->dwFlags&MMIO_ALLOCBUF) {
 762                 GlobalUnlock16(lpmminfo->dwReserved1);
 763                 GlobalFree16(lpmminfo->dwReserved1);
 764                 lpmminfo->dwFlags &= ~MMIO_ALLOCBUF;
 765         }
 766         if (pchBuffer) {
 767                 lpmminfo->pchBuffer = pchBuffer;
 768         } else if (lpmminfo->dwFlags&MMIO_ALLOCBUF) {
 769                 HGLOBAL16 hNewBuf;
 770                 GlobalUnlock16(lpmminfo->dwReserved1);
 771                 hNewBuf = GlobalReAlloc16(lpmminfo->dwReserved1, cchBuffer, 0);
 772                 if (!hNewBuf) {
 773                         /* FIXME: this assumes the memory block didn't move */
 774                         GlobalLock16(lpmminfo->dwReserved1);
 775                         GlobalUnlock16(hmmio);
 776                         return MMIOERR_OUTOFMEMORY;
 777                 }
 778                 lpmminfo->dwReserved1 = hNewBuf;
 779                 lpmminfo->pchBuffer = GlobalLock16(hNewBuf);
 780         } else if (cchBuffer) {
 781                 HGLOBAL16 hNewBuf = GlobalAlloc16(GMEM_MOVEABLE, cchBuffer);
 782                 if (!hNewBuf) {
 783                         GlobalUnlock16(hmmio);
 784                         return MMIOERR_OUTOFMEMORY;
 785                 }
 786                 lpmminfo->dwReserved1 = hNewBuf;
 787                 lpmminfo->pchBuffer = GlobalLock16(hNewBuf);
 788                 lpmminfo->dwFlags |= MMIO_ALLOCBUF;
 789         } else
 790                 lpmminfo->pchBuffer = NULL;
 791         lpmminfo->cchBuffer = cchBuffer;
 792         lpmminfo->pchNext = lpmminfo->pchBuffer;
 793         lpmminfo->pchEndRead = lpmminfo->pchBuffer;
 794         lpmminfo->pchEndWrite = lpmminfo->pchBuffer + cchBuffer;
 795         lpmminfo->lBufOffset = 0;
 796
 797         GlobalUnlock16(hmmio);
 798         return (UINT16) 0;
 799 }
 800
 801 /**************************************************************************
 802 *                               mmioSetBuffer           [MMSYSTEM.1217]
 803 */
 804 UINT16 WINAPI mmioSetBuffer16(HMMIO16 hmmio, LPSTR pchBuffer,
 805                                                                                 LONG cchBuffer, UINT16 uFlags)
 806 {
 807         return mmioSetBuffer(hmmio, pchBuffer, cchBuffer, uFlags);
 808 }
 809
 810 /**************************************************************************
 811  *                              mmioFlush               [WINMM.117]
 812  */
 813 UINT WINAPI mmioFlush(HMMIO hmmio, UINT uFlags)
 814 {
 815         LPMMIOINFO16    lpmminfo;
 816         TRACE("(%04X, %04X)\n", hmmio, uFlags);
 817         lpmminfo = (LPMMIOINFO16)GlobalLock16(hmmio);
 818         if (lpmminfo == NULL) return 0;
 819
 820         if ((!lpmminfo->cchBuffer)||(lpmminfo->fccIOProc==FOURCC_MEM)) {
 821                 GlobalUnlock16(hmmio);
 822                 return 0;
 823         }
 824         /* not quite sure what to do here, but I'll guess */
 825         if (lpmminfo->dwFlags & MMIO_DIRTY) {
 826                 mmioSendMessage(hmmio, MMIOM_SEEK,
 827                         (LPARAM) lpmminfo->lBufOffset,
 828                         (LPARAM) SEEK_SET);
 829                 mmioSendMessage(hmmio, MMIOM_WRITE,
 830                         (LPARAM) lpmminfo->pchBuffer,
 831                         (LPARAM) (lpmminfo->pchNext - lpmminfo->pchBuffer) );
 832                 lpmminfo->dwFlags &= ~MMIO_DIRTY;
 833         }
 834         if (uFlags & MMIO_EMPTYBUF) {
 835                 /* seems Windows doesn't do any seeking here, hopefully this
 836                    won't matter, otherwise a slight rewrite is necessary */
 837                 mmioSendMessage(hmmio, MMIOM_SEEK,
 838                         (LPARAM) (lpmminfo->lBufOffset +
 839                                   (lpmminfo->pchNext - lpmminfo->pchBuffer)),
 840                         (LPARAM) SEEK_SET);
 841                 lpmminfo->pchNext = lpmminfo->pchBuffer;
 842                 lpmminfo->pchEndRead = lpmminfo->pchBuffer;
 843                 lpmminfo->lBufOffset = lpmminfo->lDiskOffset;
 844         }
 845
 846         GlobalUnlock16(hmmio);
 847         return 0;
 848 }
 849
 850 /**************************************************************************
 851  *                              mmioFlush               [MMSYSTEM.1218]
 852  */
 853 UINT16 WINAPI mmioFlush16(HMMIO16 hmmio, UINT16 uFlags)
 854 {
 855         return mmioFlush(hmmio,uFlags);
 856 }
 857
 858 /**************************************************************************
 859  *                              mmioAdvance             [MMSYSTEM.1219]
 860  */
 861 UINT WINAPI mmioAdvance(HMMIO hmmio,MMIOINFO*lpmmioinfo,UINT uFlags)
 862 {
 863         LPMMIOINFO16    lpmminfo;
 864         DWORD count;
 865
 866         TRACE("hmmio=%04X, lpmmioinfo=%p, uFlags=%04X\n", hmmio, lpmmioinfo, uFlags);
 867         lpmminfo = (LPMMIOINFO16)GlobalLock16(hmmio);
 868         if (lpmminfo == NULL) return 0;
 869         if (!lpmminfo->cchBuffer) {
 870                 GlobalUnlock16(hmmio);
 871                 return MMIOERR_UNBUFFERED;
 872         }
 873         lpmminfo->pchNext += (lpmmioinfo->pchNext - lpmminfo->pchBuffer);
 874         if (mmioFlush(hmmio, MMIO_EMPTYBUF)) {
 875                 GlobalUnlock16(hmmio);
 876                 return MMIOERR_CANNOTWRITE;
 877         }
 878         if (uFlags == MMIO_READ) {
 879                 count = mmioSendMessage(hmmio, MMIOM_READ,
 880                         (LPARAM) lpmmioinfo->pchBuffer,
 881                         (LPARAM) lpmmioinfo->cchBuffer);
 882                 lpmmioinfo->pchEndRead = lpmmioinfo->pchBuffer + count;
 883                 lpmminfo->pchEndRead = lpmminfo->pchBuffer + count;
 884                 /* Manually update pchNext for the 16 bit struct */
 885                 lpmminfo->pchNext += count;
 886         }
 887 #if 0   /* mmioFlush already did the writing */
 888         if (uFlags == MMIO_WRITE)
 889                     mmioSendMessage(hmmio, MMIOM_WRITE,
 890                         (LPARAM) lpmmioinfo->pchBuffer,
 891                         (LPARAM) lpmmioinfo->cchBuffer);
 892 #endif
 893         lpmmioinfo->pchNext = lpmmioinfo->pchBuffer;
 894         GlobalUnlock16(hmmio);
 895         return 0;
 896 }
 897
 898 /**************************************************************************
 899  *                              mmioAdvance             [MMSYSTEM.1219]
 900  */
 901 UINT16 WINAPI mmioAdvance16(HMMIO16 hmmio,MMIOINFO16*lpmmioinfo,UINT16 uFlags)
 902 {
 903         LPMMIOINFO16    lpmminfo;
 904         TRACE("mmioAdvance\n");
 905         lpmminfo = (LPMMIOINFO16)GlobalLock16(hmmio);
 906         if (lpmminfo == NULL) return 0;
 907         if (!lpmminfo->cchBuffer) {
 908                 GlobalUnlock16(hmmio);
 909                 return MMIOERR_UNBUFFERED;
 910         }
 911         lpmminfo->pchNext = lpmmioinfo->pchNext;
 912         if (mmioFlush(hmmio, MMIO_EMPTYBUF)) {
 913                 GlobalUnlock16(hmmio);
 914                 return MMIOERR_CANNOTWRITE;
 915         }
 916         if (uFlags == MMIO_READ)
 917                 lpmmioinfo->pchEndRead = lpmmioinfo->pchBuffer +
 918                     mmioSendMessage(hmmio, MMIOM_READ,
 919                         (LPARAM) lpmmioinfo->pchBuffer,
 920                         (LPARAM) lpmmioinfo->cchBuffer);
 921 #if 0   /* mmioFlush already did the writing */
 922         if (uFlags == MMIO_WRITE)
 923                     mmioSendMessage(hmmio, MMIOM_WRITE,
 924                         (LPARAM) lpmmioinfo->pchBuffer,
 925                         (LPARAM) lpmmioinfo->cchBuffer);
 926 #endif
 927         lpmmioinfo->pchNext = lpmmioinfo->pchBuffer;
 928         GlobalUnlock16(hmmio);
 929         return 0;
 930 }
 931
 932 /**************************************************************************
 933  *                              mmioStringToFOURCCA     [WINMM.131]
 934  */
 935 FOURCC WINAPI mmioStringToFOURCCA(LPCSTR sz, UINT uFlags)
 936 {
 937         return mmioStringToFOURCC16(sz,uFlags);
 938 }
 939
 940 /**************************************************************************
 941  *                              mmioStringToFOURCCW     [WINMM.132]
 942  */
 943 FOURCC WINAPI mmioStringToFOURCCW(LPCWSTR sz, UINT uFlags)
 944 {
 945         LPSTR   szA = HEAP_strdupWtoA(GetProcessHeap(),0,sz);
 946         FOURCC  ret = mmioStringToFOURCCA(szA,uFlags);
 947
 948         HeapFree(GetProcessHeap(),0,szA);
 949         return ret;
 950 }
 951
 952 /**************************************************************************
 953  *                              mmioStringToFOURCC      [MMSYSTEM.1220]
 954  */
 955 FOURCC WINAPI mmioStringToFOURCC16(LPCSTR sz, UINT16 uFlags)
 956 {
 957         CHAR cc[4];
 958         int i = 0;
 959
 960         while (i < 4 && sz[i]) {
 961                 if (uFlags & MMIO_TOUPPER) {
 962                         cc[i] = toupper(sz[i]);
 963                 } else {
 964                         cc[i] = sz[i];
 965                 }
 966                 i++;
 967 }
 968
 969         /* Pad with spaces */
 970         while (i < 4) {
 971                 cc[i] = ' ';
 972                 i++;
 973         }
 974
 975         TRACE("Got %c%c%c%c\n",cc[0],cc[1],cc[2],cc[3]);
 976         return mmioFOURCC(cc[0],cc[1],cc[2],cc[3]);
 977 }
 978
 979 /* maximum number of I/O procedures which can be installed */
 980
 981 struct IOProcList
 982 {
 983   struct IOProcList *pNext;      /* Next item in linked list */
 984   FOURCC            fourCC;     /* four-character code identifying IOProc */
 985   LPMMIOPROC16      pIOProc;    /* pointer to IProc */
 986   BOOL              b32bit;       /* 32 bit IO proc? */
 987 };
 988
 989 /* This array will be the entire list for most apps */
 990
 991 static struct IOProcList defaultProcs[] = {
 992   { &defaultProcs[1], (FOURCC) FOURCC_DOS,(LPMMIOPROC16) mmioDosIOProc, FALSE },
 993   { NULL, (FOURCC) FOURCC_MEM,(LPMMIOPROC16) mmioMemIOProc, FALSE },
 994 };
 995
 996 static struct IOProcList *pIOProcListAnchor = &defaultProcs[0];
 997
 998 /****************************************************************
 999  *       MMIO_FindProcNode [INTERNAL]
1000  *
1001  * Finds the ProcList node associated with a given FOURCC code.
1002  */
1003 struct IOProcList *MMIO_FindProcNode(FOURCC fccIOProc) {
1004         struct IOProcList *pListNode;
1005
1006         for (pListNode = pIOProcListAnchor; pListNode; pListNode=pListNode->pNext)
1007                 {
1008                         if (pListNode->fourCC == fccIOProc)
1009 {
1010                                         return pListNode;
1011                         };
1012                 };
1013         return NULL;
1014 }
1015
1016 /****************************************************************
1017  *       MMIO_InstallIOProc [INTERNAL]
1018  */
1019
1020 LPMMIOPROC16 MMIO_InstallIOProc(FOURCC fccIOProc, LPMMIOPROC16 pIOProc,
1021                                         DWORD dwFlags, BOOL b32bit)
1022 {
1023         LPMMIOPROC16        lpProc = NULL;
1024         struct IOProcList  *pListNode;
1025
1026         TRACE("(%ld, %p, %08lX, %i)\n",
1027                                  fccIOProc, pIOProc, dwFlags, (b32bit?32:16));
1028
1029         if (dwFlags & MMIO_GLOBALPROC) {
1030                 FIXME(" global procedures not implemented\n");
1031         }
1032
1033         /* just handle the known procedures for now */
1034         switch(dwFlags & (MMIO_INSTALLPROC|MMIO_REMOVEPROC|MMIO_FINDPROC)) {
1035                 case MMIO_INSTALLPROC:
1036                   /* Create new entry for the IOProc list */
1037                   pListNode = HeapAlloc(GetProcessHeap(),0,sizeof(*pListNode));
1038                   if (pListNode)
1039                   {
1040                     /* Find the end of the list, so we can add our new entry to it */
1041                     struct IOProcList *pListEnd = pIOProcListAnchor;
1042                     while (pListEnd->pNext)
1043                        pListEnd = pListEnd->pNext;
1044
1045                     /* Fill in this node */
1046                     pListNode->fourCC = fccIOProc;
1047                     pListNode->pIOProc = pIOProc;
1048                                 pListNode->b32bit = b32bit;
1049
1050                     /* Stick it on the end of the list */
1051                     pListEnd->pNext = pListNode;
1052                     pListNode->pNext = NULL;
1053
1054                     /* Return this IOProc - that's how the caller knows we succeeded */
1055                     lpProc = pIOProc;
1056                   };
1057                   break;
1058
1059                 case MMIO_REMOVEPROC:
1060                   /*
1061                    * Search for the node that we're trying to remove - note
1062                    * that this method won't find the first item on the list, but
1063                    * since the first two items on this list are ones we won't
1064                    * let the user delete anyway, that's okay
1065                    */
1066
1067                   pListNode = pIOProcListAnchor;
1068                   while (pListNode && pListNode->pNext->fourCC != fccIOProc)
1069                     pListNode = pListNode->pNext;
1070
1071                   /* If we found it, remove it, but only if it isn't builtin */
1072                   if (pListNode &&
1073                       ((pListNode >= defaultProcs) && (pListNode < defaultProcs + sizeof(defaultProcs))))
1074                   {
1075                     /* Okay, nuke it */
1076                     pListNode->pNext = pListNode->pNext->pNext;
1077                     HeapFree(GetProcessHeap(),0,pListNode);
1078                   };
1079                   break;
1080
1081                 case MMIO_FINDPROC:
1082                           pListNode = MMIO_FindProcNode(fccIOProc);
1083                           if (pListNode) {
1084                           lpProc = pListNode->pIOProc;
1085                           }
1086                       break;
1087         }
1088
1089         return lpProc;
1090 }
1091
1092 /**************************************************************************
1093  *              mmioInstallIOProc16    [MMSYSTEM.1221]
1094  */
1095 LPMMIOPROC16 WINAPI mmioInstallIOProc16(FOURCC fccIOProc, LPMMIOPROC16 pIOProc,
1096                                         DWORD dwFlags)
1097 {
1098         return MMIO_InstallIOProc(fccIOProc, pIOProc, dwFlags, FALSE);
1099 }
1100
1101 /**************************************************************************
1102  *                              mmioInstallIOProcA         [WINMM.120]
1103  */
1104 LPMMIOPROC WINAPI mmioInstallIOProcA(FOURCC fccIOProc,
1105                                          LPMMIOPROC pIOProc, DWORD dwFlags)
1106 {
1107         return (LPMMIOPROC) MMIO_InstallIOProc(fccIOProc,
1108                                         (LPMMIOPROC16)pIOProc, dwFlags, TRUE);
1109 }
1110
1111 /**************************************************************************
1112 *                               mmioSendMessage         [MMSYSTEM.1222]
1113 */
1114 LRESULT WINAPI mmioSendMessage(HMMIO16 hmmio, UINT16 uMessage,
1115                                LPARAM lParam1, LPARAM lParam2)
1116 {
1117         LPMMIOINFO16 lpmminfo;
1118         LRESULT result;
1119         struct IOProcList *pListNode;
1120
1121         if (TRACE_ON(mmio))
1122         {
1123             const char *msg = NULL;
1124             switch (uMessage) {
1125 #define msgname(x) case x: msg = #x; break;
1126                 msgname(MMIOM_OPEN);
1127                 msgname(MMIOM_CLOSE);
1128                 msgname(MMIOM_READ);
1129                 msgname(MMIOM_WRITE);
1130                 msgname(MMIOM_WRITEFLUSH);
1131                 msgname(MMIOM_SEEK);
1132                 msgname(MMIOM_RENAME);
1133 #undef msgname
1134             }
1135             if (msg)
1136                 TRACE("(%04X, %s, %ld, %ld)\n",
1137                       hmmio, msg, lParam1, lParam2);
1138             else
1139                 TRACE("(%04X, %u, %ld, %ld)\n",
1140                       hmmio, uMessage, lParam1, lParam2);
1141         }
1142
1143         lpmminfo = (LPMMIOINFO16)GlobalLock16(hmmio);
1144
1145         if (lpmminfo && lpmminfo->pIOProc) {
1146
1147                 pListNode = MMIO_FindProcNode(lpmminfo->fccIOProc); /* Offset is the same for 16 and 32 bit */
1148                 TRACE("%d bit\n",pListNode->b32bit?32:16);
1149                 if (pListNode->b32bit) {
1150                         /* Convert 16 bit internal structure to 32 bit for the mmioproc */
1151                         MMIOINFO mminfo32;
1152
1153                         MMIO_infoMap16To32(&mminfo32,lpmminfo);
1154                         result = (*(&mminfo32)->pIOProc)((LPSTR)&mminfo32, uMessage, lParam1, lParam2);
1155                         MMIO_infoUnmap16To32(lpmminfo,&mminfo32);
1156                 } else {
1157                 result = (*lpmminfo->pIOProc)((LPSTR)lpmminfo, uMessage, lParam1, lParam2);
1158                 }
1159         } else
1160                 result = MMSYSERR_INVALPARAM;
1161
1162         GlobalUnlock16(hmmio);
1163
1164         return result;
1165 }
1166
1167 /**************************************************************************
1168 *                               mmioDescend             [MMSYSTEM.1223]
1169 */
1170 UINT16 WINAPI mmioDescend(HMMIO16 hmmio, LPMMCKINFO lpck,
1171                           const MMCKINFO * lpckParent, UINT16 uFlags)
1172 {
1173         DWORD           dwOldPos;
1174         FOURCC          srchCkId;
1175         FOURCC          srchType;
1176
1177
1178         TRACE("(%04X, %p, %p, %04X);\n", hmmio, lpck, lpckParent, uFlags);
1179
1180         if (lpck == NULL)
1181                 return MMSYSERR_INVALPARAM;
1182
1183         dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
1184         TRACE("dwOldPos=%ld\n", dwOldPos);
1185
1186         if (lpckParent != NULL) {
1187                 TRACE("seek inside parent at %ld !\n", lpckParent->dwDataOffset);
1188                 /* EPP: was dwOldPos = mmioSeek(hmmio,lpckParent->dwDataOffset,SEEK_SET); */
1189                 if (dwOldPos < lpckParent->dwDataOffset || dwOldPos >= lpckParent->dwDataOffset + lpckParent->cksize) {
1190                         WARN("outside parent chunk\n");
1191                         return MMIOERR_CHUNKNOTFOUND;
1192                 }
1193         }
1194
1195         /* The SDK docu says 'ckid' is used for all cases. Real World
1196          * examples disagree -Marcus,990216.
1197          */
1198
1199         srchType = 0;
1200         /* find_chunk looks for 'ckid' */
1201         if (uFlags & MMIO_FINDCHUNK)
1202                 srchCkId = lpck->ckid;
1203         /* find_riff and find_list look for 'fccType' */
1204         if (uFlags & MMIO_FINDLIST) {
1205                 srchCkId = FOURCC_LIST;
1206                 srchType = lpck->fccType;
1207         }
1208         if (uFlags & MMIO_FINDRIFF) {
1209                 srchCkId = FOURCC_RIFF;
1210                 srchType = lpck->fccType;
1211         }
1212
1213         if (uFlags & (MMIO_FINDCHUNK|MMIO_FINDLIST|MMIO_FINDRIFF)) {
1214         TRACE("searching for %.4s.%.4s\n",
1215               (LPSTR)&srchCkId,
1216                           srchType?(LPSTR)&srchType:"any ");
1217
1218                 while (TRUE) {
1219                         LONG ix;
1220
1221                         ix = mmioRead(hmmio, (LPSTR)lpck, 3 * sizeof(DWORD));
1222                         if (ix < 2*sizeof(DWORD)) {
1223                                 mmioSeek(hmmio, dwOldPos, SEEK_SET);
1224                                 WARN("return ChunkNotFound\n");
1225                                 return MMIOERR_CHUNKNOTFOUND;
1226                         }
1227                         lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD);
1228                         if (ix < lpck->dwDataOffset - dwOldPos) {
1229                                 mmioSeek(hmmio, dwOldPos, SEEK_SET);
1230                                 WARN("return ChunkNotFound\n");
1231                                 return MMIOERR_CHUNKNOTFOUND;
1232                         }
1233                         TRACE("ckid=%.4s fcc=%.4s cksize=%08lX !\n",
1234                               (LPSTR)&lpck->ckid,
1235                               srchType?(LPSTR)&lpck->fccType:"<na>",
1236                               lpck->cksize);
1237                         if ((srchCkId == lpck->ckid) &&
1238                             (!srchType || (srchType == lpck->fccType))
1239                             )
1240                                 break;
1241
1242                         dwOldPos = lpck->dwDataOffset + ((lpck->cksize + 1) & ~1);
1243                         mmioSeek(hmmio, dwOldPos, SEEK_SET);
1244                 }
1245         } else {
1246                 /* FIXME: unverified, does it do this? */
1247                 /* NB: This part is used by WAVE_mciOpen, among others */
1248                 if (mmioRead(hmmio, (LPSTR)lpck, 3 * sizeof(DWORD)) < 3 * sizeof(DWORD)) {
1249                         mmioSeek(hmmio, dwOldPos, SEEK_SET);
1250                         WARN("return ChunkNotFound 2nd\n");
1251                         return MMIOERR_CHUNKNOTFOUND;
1252                 }
1253                 lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD);
1254         }
1255         lpck->dwFlags = 0;
1256         /* If we were looking for RIFF/LIST chunks, the final file position
1257          * is after the chunkid. If we were just looking for the chunk
1258          * it is after the cksize. So add 4 in RIFF/LIST case.
1259          */
1260         if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST)
1261                 mmioSeek(hmmio, lpck->dwDataOffset + sizeof(DWORD), SEEK_SET);
1262         else
1263                 mmioSeek(hmmio, lpck->dwDataOffset, SEEK_SET);
1264         TRACE("lpck: ckid=%.4s, cksize=%ld, dwDataOffset=%ld fccType=%08lX (%.4s)!\n",
1265               (LPSTR)&lpck->ckid, lpck->cksize, lpck->dwDataOffset,
1266               lpck->fccType, srchType?(LPSTR)&lpck->fccType:"");
1267         return 0;
1268 }
1269
1270 /**************************************************************************
1271  *                              mmioAscend              [WINMM.113]
1272  */
1273 UINT WINAPI mmioAscend(HMMIO hmmio, MMCKINFO * lpck, UINT uFlags)
1274 {
1275         TRACE("(%04X, %p, %04X);\n", hmmio, lpck, uFlags);
1276
1277         if (lpck->dwFlags & MMIO_DIRTY) {
1278                 DWORD   dwOldPos, dwNewSize, dwSizePos;
1279
1280                 TRACE("chunk is marked MMIO_DIRTY, correcting chunk size\n");
1281                 dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
1282                 TRACE("dwOldPos=%ld\n", dwOldPos);
1283                 dwNewSize = dwOldPos - lpck->dwDataOffset;
1284                 if (dwNewSize != lpck->cksize) {
1285                         TRACE("dwNewSize=%ld\n", dwNewSize);
1286                         lpck->cksize = dwNewSize;
1287
1288                         dwSizePos = lpck->dwDataOffset - sizeof(DWORD);
1289                         TRACE("dwSizePos=%ld\n", dwSizePos);
1290
1291                         mmioSeek(hmmio, dwSizePos, SEEK_SET);
1292                         mmioWrite(hmmio, (LPSTR)&dwNewSize, sizeof(DWORD));
1293                 }
1294         }
1295
1296         mmioSeek(hmmio, lpck->dwDataOffset + ((lpck->cksize + 1) & ~1), SEEK_SET);
1297
1298         return 0;
1299 }
1300
1301 /**************************************************************************
1302  *                              mmioAscend              [MMSYSTEM.1224]
1303  */
1304 UINT16 WINAPI mmioAscend16(HMMIO16 hmmio, MMCKINFO * lpck, UINT16 uFlags)
1305 {
1306         return mmioAscend(hmmio,lpck,uFlags);
1307 }
1308
1309 /**************************************************************************
1310  *                              mmioCreateChunk         [MMSYSTEM.1225]
1311  */
1312 UINT16 WINAPI mmioCreateChunk16(HMMIO16 hmmio, MMCKINFO * lpck, UINT16 uFlags)
1313 {
1314         DWORD   dwOldPos;
1315         LONG    size;
1316         LONG    ix;
1317
1318         TRACE("(%04X, %p, %04X);\n", hmmio, lpck, uFlags);
1319
1320         dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
1321         TRACE("dwOldPos=%ld\n", dwOldPos);
1322
1323         if (uFlags == MMIO_CREATELIST)
1324                 lpck->ckid = FOURCC_LIST;
1325         else if (uFlags == MMIO_CREATERIFF)
1326                 lpck->ckid = FOURCC_RIFF;
1327
1328         TRACE("ckid=%08lX\n", lpck->ckid);
1329
1330         size = 2 * sizeof(DWORD);
1331         lpck->dwDataOffset = dwOldPos + size;
1332
1333         if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST)
1334                 size += sizeof(DWORD);
1335         lpck->dwFlags = MMIO_DIRTY;
1336
1337         ix = mmioWrite(hmmio, (LPSTR)lpck, size);
1338         TRACE("after mmioWrite ix = %ld req = %ld, errno = %d\n",ix, size, errno);
1339         if (ix < size) {
1340                 mmioSeek(hmmio, dwOldPos, SEEK_SET);
1341                 WARN("return CannotWrite\n");
1342                 return MMIOERR_CANNOTWRITE;
1343         }
1344
1345         return 0;
1346 }
1347
1348 /**************************************************************************
1349  *                                      mmioCreateChunk                                 [WINMM.115]
1350  */
1351 UINT WINAPI mmioCreateChunk(HMMIO hmmio, MMCKINFO * lpck, UINT uFlags)
1352 {
1353         return mmioCreateChunk16(hmmio, lpck, uFlags);
1354 }
1355
1356 /**************************************************************************
1357  *                              mmioRename              [MMSYSTEM.1226]
1358  */
1359 UINT16 WINAPI mmioRename16(LPCSTR szFileName, LPCSTR szNewFileName,
1360                          MMIOINFO16 * lpmmioinfo, DWORD dwRenameFlags)
1361 {
1362         UINT16 result;
1363         LPMMIOINFO16 lpmminfo;
1364         HMMIO16 hmmio;
1365
1366         TRACE("('%s', '%s', %p, %08lX);\n",
1367                                  szFileName, szNewFileName, lpmmioinfo, dwRenameFlags);
1368
1369         hmmio = GlobalAlloc16(GHND, sizeof(MMIOINFO16));
1370         lpmminfo = (LPMMIOINFO16) GlobalLock16(hmmio);
1371
1372         if (lpmmioinfo)
1373                 memcpy(lpmminfo, lpmmioinfo, sizeof(MMIOINFO16));
1374
1375         /* If both params are NULL, then parse the file name */
1376         if (lpmminfo->fccIOProc == 0 && lpmminfo->pIOProc == NULL) {
1377                 lpmminfo->fccIOProc = MMIO_ParseExt(szFileName);
1378         }
1379         /* Handle any unhandled/error case from above. Assume DOS file */
1380         if (lpmminfo->fccIOProc == 0 && lpmminfo->pIOProc == NULL) {
1381
1382                 lpmminfo->fccIOProc = mmioFOURCC('D', 'O', 'S', ' ');
1383                 lpmminfo->pIOProc = (LPMMIOPROC16) mmioDosIOProc;
1384
1385         }
1386         /* if just the four character code is present, look up IO proc */
1387         else if (lpmminfo->pIOProc == NULL) {
1388
1389                 lpmminfo->pIOProc = mmioInstallIOProc16(lpmminfo->fccIOProc, NULL, MMIO_FINDPROC);
1390
1391         }
1392         /* (if IO proc specified, use it and specified four character code) */
1393
1394         result = (UINT16) mmioSendMessage(hmmio, MMIOM_RENAME, (LPARAM) szFileName, (LPARAM) szNewFileName);
1395
1396         GlobalUnlock16(hmmio);
1397         GlobalFree16(hmmio);
1398
1399         return result;
1400 }
1401
1402 /**************************************************************************
1403  *                              mmioRenameA                             [WINMM.125]
1404  */
1405 UINT WINAPI mmioRenameA(LPCSTR szFileName, LPCSTR szNewFileName,
1406                          MMIOINFO* lpmmioinfo, DWORD dwRenameFlags)
1407 {
1408         FIXME("This may fail\n");
1409         return mmioRename16(szFileName, szNewFileName, (MMIOINFO16*)lpmmioinfo, dwRenameFlags);
1410 }
1411
1412 /**************************************************************************
1413  *                              mmioRenameW                             [WINMM.126]
1414  */
1415 UINT WINAPI mmioRenameW(LPCWSTR szFileName, LPCWSTR szNewFileName,
1416                                                                          MMIOINFO* lpmmioinfo, DWORD dwRenameFlags)
1417 {
1418         LPSTR           szFn = HEAP_strdupWtoA(GetProcessHeap(), 0, szFileName);
1419         LPSTR           sznFn = HEAP_strdupWtoA(GetProcessHeap(), 0, szNewFileName);
1420         UINT    ret = mmioRenameA(szFn, sznFn, lpmmioinfo, dwRenameFlags);
1421
1422         HeapFree(GetProcessHeap(),0,szFn);
1423         HeapFree(GetProcessHeap(),0,sznFn);
1424         return ret;
1425 }