dlls/mmsystem.dll16/mmio16.c

   1 /*
   2  * MMSYSTEM mmio* functions
   3  *
   4  * Copyright 1993               Martin Ayotte
   5  *           1998-2003,2009     Eric Pouech
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23 #include <string.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "mmsystem.h"
  28 #include "winternl.h"
  29 #include "wownt32.h"
  30 #include "winnls.h"
  31
  32 #include "wine/winuser16.h"
  33 #include "winemm16.h"
  34
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(mmsys);
  38
  39 /* ###################################################
  40  * #                     MMIO                        #
  41  * ###################################################
  42  */
  43 #include <pshpack1.h>
  44 #define MMIO_MAX_THUNKS      32
  45
  46 static struct mmio_thunk
  47 {
  48     BYTE        popl_eax;       /* popl  %eax (return address) */
  49     BYTE        pushl_func;     /* pushl $pfn16 (16bit callback function) */
  50     LPMMIOPROC16 pfn16;
  51     BYTE        pushl_eax;      /* pushl %eax */
  52     BYTE        jmp;            /* ljmp MMIO_Callback1632 */
  53     DWORD       callback;
  54     HMMIO       hMmio;          /* Handle to 32bit mmio object */
  55     SEGPTR      segbuffer;      /* actual segmented ptr to buffer */
  56 } *MMIO_Thunks;
  57
  58 #include <poppack.h>
  59
  60 static CRITICAL_SECTION mmio_cs;
  61 static CRITICAL_SECTION_DEBUG mmio_critsect_debug =
  62 {
  63     0, 0, &mmio_cs,
  64     { &mmio_critsect_debug.ProcessLocksList, &mmio_critsect_debug.ProcessLocksList },
  65       0, 0, { (DWORD_PTR)(__FILE__ ": mmsystem_mmio_cs") }
  66 };
  67 static CRITICAL_SECTION mmio_cs = { &mmio_critsect_debug, -1, 0, 0, 0, 0 };
  68
  69 /****************************************************************
  70  *                      MMIO_Map32To16                  [INTERNAL]
  71  */
  72 static LRESULT  MMIO_Map32To16(DWORD wMsg, LPARAM* lp1, LPARAM* lp2)
  73 {
  74     switch (wMsg) {
  75     case MMIOM_CLOSE:
  76     case MMIOM_SEEK:
  77         /* nothing to do */
  78         break;
  79     case MMIOM_OPEN:
  80     case MMIOM_READ:
  81     case MMIOM_WRITE:
  82     case MMIOM_WRITEFLUSH:
  83         *lp1 = MapLS( (void *)*lp1 );
  84         break;
  85     case MMIOM_RENAME:
  86         *lp1 = MapLS( (void *)*lp1 );
  87         *lp2 = MapLS( (void *)*lp2 );
  88         break;
  89     default:
  90         if (wMsg < MMIOM_USER)
  91             TRACE("Not a mappable message (%d)\n", wMsg);
  92     }
  93     return MMSYSERR_NOERROR;
  94 }
  95
  96 /****************************************************************
  97  *              MMIO_UnMap32To16                        [INTERNAL]
  98  */
  99 static LRESULT  MMIO_UnMap32To16(DWORD wMsg, LPARAM lParam1, LPARAM lParam2,
 100                                  LPARAM lp1, LPARAM lp2)
 101 {
 102     switch (wMsg) {
 103     case MMIOM_CLOSE:
 104     case MMIOM_SEEK:
 105         /* nothing to do */
 106         break;
 107     case MMIOM_OPEN:
 108     case MMIOM_READ:
 109     case MMIOM_WRITE:
 110     case MMIOM_WRITEFLUSH:
 111         UnMapLS( lp1 );
 112         break;
 113     case MMIOM_RENAME:
 114         UnMapLS( lp1 );
 115         UnMapLS( lp2 );
 116         break;
 117     default:
 118         if (wMsg < MMIOM_USER)
 119             TRACE("Not a mappable message (%d)\n", wMsg);
 120     }
 121     return MMSYSERR_NOERROR;
 122 }
 123
 124 /******************************************************************
 125  *              MMIO_Callback3216
 126  *
 127  *
 128  */
 129 static LRESULT MMIO_Callback3216(SEGPTR cb16, LPMMIOINFO lpmmioinfo, UINT uMessage,
 130                                  LPARAM lParam1, LPARAM lParam2)
 131 {
 132     DWORD               result;
 133     MMIOINFO16          mmioInfo16;
 134     SEGPTR              segmmioInfo16;
 135     LPARAM              lp1 = lParam1, lp2 = lParam2;
 136     WORD                args[7];
 137
 138     if (!cb16) return MMSYSERR_INVALPARAM;
 139
 140     memset(&mmioInfo16, 0, sizeof(MMIOINFO16));
 141     mmioInfo16.lDiskOffset = lpmmioinfo->lDiskOffset;
 142     mmioInfo16.adwInfo[0]  = lpmmioinfo->adwInfo[0];
 143     mmioInfo16.adwInfo[1]  = lpmmioinfo->adwInfo[1];
 144     mmioInfo16.adwInfo[2]  = lpmmioinfo->adwInfo[2];
 145     /* map (lParam1, lParam2) into (lp1, lp2) 32=>16 */
 146     if ((result = MMIO_Map32To16(uMessage, &lp1, &lp2)) != MMSYSERR_NOERROR)
 147         return result;
 148
 149     segmmioInfo16 = MapLS(&mmioInfo16);
 150     args[6] = HIWORD(segmmioInfo16);
 151     args[5] = LOWORD(segmmioInfo16);
 152     args[4] = uMessage;
 153     args[3] = HIWORD(lp1);
 154     args[2] = LOWORD(lp1);
 155     args[1] = HIWORD(lp2);
 156     args[0] = LOWORD(lp2);
 157     WOWCallback16Ex( cb16, WCB16_PASCAL, sizeof(args), args, &result );
 158     UnMapLS(segmmioInfo16);
 159     MMIO_UnMap32To16(uMessage, lParam1, lParam2, lp1, lp2);
 160
 161     lpmmioinfo->lDiskOffset = mmioInfo16.lDiskOffset;
 162     lpmmioinfo->adwInfo[0]  = mmioInfo16.adwInfo[0];
 163     lpmmioinfo->adwInfo[1]  = mmioInfo16.adwInfo[1];
 164     lpmmioinfo->adwInfo[2]  = mmioInfo16.adwInfo[2];
 165
 166     return result;
 167 }
 168
 169 /******************************************************************
 170  *              MMIO_AddThunk
 171  *
 172  */
 173 static struct mmio_thunk*       MMIO_AddThunk(LPMMIOPROC16 pfn16, HPSTR segbuf)
 174 {
 175     struct mmio_thunk* thunk;
 176
 177     if (!MMIO_Thunks)
 178     {
 179         MMIO_Thunks = VirtualAlloc(NULL, MMIO_MAX_THUNKS * sizeof(*MMIO_Thunks), MEM_COMMIT,
 180                                    PAGE_EXECUTE_READWRITE);
 181         if (!MMIO_Thunks) return NULL;
 182         for (thunk = MMIO_Thunks; thunk < &MMIO_Thunks[MMIO_MAX_THUNKS]; thunk++)
 183         {
 184             thunk->popl_eax     = 0x58;   /* popl  %eax */
 185             thunk->pushl_func   = 0x68;   /* pushl $pfn16 */
 186             thunk->pfn16        = 0;
 187             thunk->pushl_eax    = 0x50;   /* pushl %eax */
 188             thunk->jmp          = 0xe9;   /* jmp MMIO_Callback3216 */
 189             thunk->callback     = (char *)MMIO_Callback3216 - (char *)(&thunk->callback + 1);
 190             thunk->hMmio        = NULL;
 191             thunk->segbuffer    = 0;
 192         }
 193     }
 194     for (thunk = MMIO_Thunks; thunk < &MMIO_Thunks[MMIO_MAX_THUNKS]; thunk++)
 195     {
 196         if (thunk->pfn16 == 0 && thunk->hMmio == NULL)
 197         {
 198             thunk->pfn16 = pfn16;
 199             thunk->hMmio = NULL;
 200             thunk->segbuffer = (SEGPTR)segbuf;
 201             return thunk;
 202         }
 203     }
 204     FIXME("Out of mmio-thunks. Bump MMIO_MAX_THUNKS\n");
 205     return NULL;
 206 }
 207
 208 /******************************************************************
 209  *              MMIO_HasThunk
 210  *
 211  */
 212 static struct mmio_thunk*    MMIO_HasThunk(HMMIO hmmio)
 213 {
 214     struct mmio_thunk* thunk;
 215
 216     if (!MMIO_Thunks) return NULL;
 217     for (thunk = MMIO_Thunks; thunk < &MMIO_Thunks[MMIO_MAX_THUNKS]; thunk++)
 218     {
 219         if (thunk->hMmio == hmmio) return thunk;
 220     }
 221     return NULL;
 222 }
 223
 224 /******************************************************************
 225  *             MMIO_SetSegmentedBuffer
 226  *
 227  */
 228 static void     MMIO_SetSegmentedBuffer(struct mmio_thunk* thunk, SEGPTR ptr, BOOL release)
 229 {
 230     if (release) UnMapLS(thunk->segbuffer);
 231     thunk->segbuffer = ptr;
 232 }
 233
 234 /**************************************************************************
 235  *                              mmioOpen                [MMSYSTEM.1210]
 236  */
 237 HMMIO16 WINAPI mmioOpen16(LPSTR szFileName, MMIOINFO16* lpmmioinfo16,
 238                           DWORD dwOpenFlags)
 239 {
 240     HMMIO       ret;
 241
 242     if (lpmmioinfo16) {
 243         MMIOINFO                mmioinfo;
 244         struct mmio_thunk*      thunk = NULL;
 245
 246         memset(&mmioinfo, 0, sizeof(mmioinfo));
 247
 248         EnterCriticalSection(&mmio_cs);
 249         if (!(thunk = MMIO_AddThunk(lpmmioinfo16->pIOProc, lpmmioinfo16->pchBuffer)))
 250         {
 251             LeaveCriticalSection(&mmio_cs);
 252             return 0;
 253         }
 254
 255         mmioinfo.dwFlags     = lpmmioinfo16->dwFlags;
 256         mmioinfo.fccIOProc   = lpmmioinfo16->fccIOProc;
 257         mmioinfo.pIOProc     = lpmmioinfo16->pIOProc ? (LPMMIOPROC)thunk : 0;
 258         mmioinfo.cchBuffer   = lpmmioinfo16->cchBuffer;
 259         mmioinfo.pchBuffer   = MapSL((DWORD)lpmmioinfo16->pchBuffer);
 260         mmioinfo.adwInfo[0]  = lpmmioinfo16->adwInfo[0];
 261         /* if we don't have a file name, it's likely a passed open file descriptor */
 262         if (!szFileName)
 263             mmioinfo.adwInfo[0] = (DWORD)DosFileHandleToWin32Handle(mmioinfo.adwInfo[0]);
 264         mmioinfo.adwInfo[1]  = lpmmioinfo16->adwInfo[1];
 265         mmioinfo.adwInfo[2]  = lpmmioinfo16->adwInfo[2];
 266
 267         ret = mmioOpenA(szFileName, &mmioinfo, dwOpenFlags);
 268         if (!ret || (dwOpenFlags & (MMIO_PARSE|MMIO_EXIST)))
 269         {
 270             thunk->pfn16 = NULL;
 271             thunk->hMmio = NULL;
 272         }
 273         else thunk->hMmio = ret;
 274         if (ret && (dwOpenFlags & MMIO_ALLOCBUF))
 275         {
 276             MMIOINFO    m;
 277             if (lpmmioinfo16->pchBuffer) FIXME("ooch\n");
 278             /* FIXME: check whether mmioOpen should set pchBuffer */
 279             mmioGetInfo(ret, &m, 0);
 280             thunk->segbuffer = MapLS(m.pchBuffer);
 281         }
 282         LeaveCriticalSection(&mmio_cs);
 283
 284         lpmmioinfo16->wErrorRet = mmioinfo.wErrorRet;
 285         lpmmioinfo16->hmmio     = HMMIO_16(mmioinfo.hmmio);
 286     } else {
 287         ret = mmioOpenA(szFileName, NULL, dwOpenFlags);
 288     }
 289     return HMMIO_16(ret);
 290 }
 291
 292 /**************************************************************************
 293  *                              mmioClose               [MMSYSTEM.1211]
 294  */
 295 MMRESULT16 WINAPI mmioClose16(HMMIO16 hmmio, UINT16 uFlags)
 296 {
 297     MMRESULT ret;
 298
 299     EnterCriticalSection(&mmio_cs);
 300     ret = mmioClose(HMMIO_32(hmmio), uFlags);
 301     if (ret == MMSYSERR_NOERROR)
 302     {
 303         struct mmio_thunk* thunk;
 304
 305         if ((thunk = MMIO_HasThunk(HMMIO_32(hmmio))))
 306         {
 307             MMIO_SetSegmentedBuffer(thunk, 0, TRUE);
 308             thunk->pfn16 = NULL;
 309             thunk->hMmio = NULL;
 310         }
 311     }
 312     LeaveCriticalSection(&mmio_cs);
 313     return ret;
 314 }
 315
 316 /**************************************************************************
 317  *                              mmioRead                [MMSYSTEM.1212]
 318  */
 319 LONG WINAPI mmioRead16(HMMIO16 hmmio, HPSTR pch, LONG cch)
 320 {
 321     return mmioRead(HMMIO_32(hmmio), pch, cch);
 322 }
 323
 324 /**************************************************************************
 325  *                              mmioWrite               [MMSYSTEM.1213]
 326  */
 327 LONG WINAPI mmioWrite16(HMMIO16 hmmio, HPCSTR pch, LONG cch)
 328 {
 329     return mmioWrite(HMMIO_32(hmmio),pch,cch);
 330 }
 331
 332 /**************************************************************************
 333  *                              mmioSeek                [MMSYSTEM.1214]
 334  */
 335 LONG WINAPI mmioSeek16(HMMIO16 hmmio, LONG lOffset, INT16 iOrigin)
 336 {
 337     return mmioSeek(HMMIO_32(hmmio), lOffset, iOrigin);
 338 }
 339
 340 /**************************************************************************
 341  *                              mmioGetInfo             [MMSYSTEM.1215]
 342  */
 343 MMRESULT16 WINAPI mmioGetInfo16(HMMIO16 hmmio, MMIOINFO16* lpmmioinfo, UINT16 uFlags)
 344 {
 345     MMIOINFO            mmioinfo;
 346     MMRESULT            ret;
 347     struct mmio_thunk*  thunk;
 348
 349     TRACE("(0x%04x,%p,0x%08x)\n", hmmio, lpmmioinfo, uFlags);
 350
 351     EnterCriticalSection(&mmio_cs);
 352     if ((thunk = MMIO_HasThunk(HMMIO_32(hmmio))) == NULL)
 353     {
 354         LeaveCriticalSection(&mmio_cs);
 355         return MMSYSERR_INVALHANDLE;
 356     }
 357
 358     ret = mmioGetInfo(HMMIO_32(hmmio), &mmioinfo, uFlags);
 359     if (ret != MMSYSERR_NOERROR)
 360     {
 361         LeaveCriticalSection(&mmio_cs);
 362         return ret;
 363     }
 364
 365     lpmmioinfo->dwFlags     = mmioinfo.dwFlags;
 366     lpmmioinfo->fccIOProc   = mmioinfo.fccIOProc;
 367     lpmmioinfo->pIOProc     = thunk->pfn16;
 368     lpmmioinfo->wErrorRet   = mmioinfo.wErrorRet;
 369     lpmmioinfo->hTask       = HTASK_16(mmioinfo.hTask);
 370     lpmmioinfo->cchBuffer   = mmioinfo.cchBuffer;
 371     lpmmioinfo->pchBuffer   = (void*)thunk->segbuffer;
 372     lpmmioinfo->pchNext     = (void*)(thunk->segbuffer + (mmioinfo.pchNext - mmioinfo.pchBuffer));
 373     lpmmioinfo->pchEndRead  = (void*)(thunk->segbuffer + (mmioinfo.pchEndRead - mmioinfo.pchBuffer));
 374     lpmmioinfo->pchEndWrite = (void*)(thunk->segbuffer + (mmioinfo.pchEndWrite - mmioinfo.pchBuffer));
 375     lpmmioinfo->lBufOffset  = mmioinfo.lBufOffset;
 376     lpmmioinfo->lDiskOffset = mmioinfo.lDiskOffset;
 377     lpmmioinfo->adwInfo[0]  = mmioinfo.adwInfo[0];
 378     lpmmioinfo->adwInfo[1]  = mmioinfo.adwInfo[1];
 379     lpmmioinfo->adwInfo[2]  = mmioinfo.adwInfo[2];
 380     lpmmioinfo->dwReserved1 = 0;
 381     lpmmioinfo->dwReserved2 = 0;
 382     lpmmioinfo->hmmio = HMMIO_16(mmioinfo.hmmio);
 383     LeaveCriticalSection(&mmio_cs);
 384
 385     return MMSYSERR_NOERROR;
 386 }
 387
 388 /**************************************************************************
 389  *                              mmioSetInfo             [MMSYSTEM.1216]
 390  */
 391 MMRESULT16 WINAPI mmioSetInfo16(HMMIO16 hmmio, const MMIOINFO16* lpmmioinfo, UINT16 uFlags)
 392 {
 393     MMIOINFO            mmioinfo;
 394     MMRESULT            ret;
 395
 396     TRACE("(0x%04x,%p,0x%08x)\n",hmmio,lpmmioinfo,uFlags);
 397
 398     ret = mmioGetInfo(HMMIO_32(hmmio), &mmioinfo, 0);
 399     if (ret != MMSYSERR_NOERROR) return ret;
 400
 401     /* check if seg and lin buffers are the same */
 402     if (mmioinfo.cchBuffer != lpmmioinfo->cchBuffer  ||
 403         mmioinfo.pchBuffer != MapSL((DWORD)lpmmioinfo->pchBuffer))
 404         return MMSYSERR_INVALPARAM;
 405
 406     /* check pointers coherence */
 407     if (lpmmioinfo->pchNext < lpmmioinfo->pchBuffer ||
 408         lpmmioinfo->pchNext > lpmmioinfo->pchBuffer + lpmmioinfo->cchBuffer ||
 409         lpmmioinfo->pchEndRead < lpmmioinfo->pchBuffer ||
 410         lpmmioinfo->pchEndRead > lpmmioinfo->pchBuffer + lpmmioinfo->cchBuffer ||
 411         lpmmioinfo->pchEndWrite < lpmmioinfo->pchBuffer ||
 412         lpmmioinfo->pchEndWrite > lpmmioinfo->pchBuffer + lpmmioinfo->cchBuffer)
 413         return MMSYSERR_INVALPARAM;
 414
 415     mmioinfo.pchNext     = mmioinfo.pchBuffer + (lpmmioinfo->pchNext     - lpmmioinfo->pchBuffer);
 416     mmioinfo.pchEndRead  = mmioinfo.pchBuffer + (lpmmioinfo->pchEndRead  - lpmmioinfo->pchBuffer);
 417     mmioinfo.pchEndWrite = mmioinfo.pchBuffer + (lpmmioinfo->pchEndWrite - lpmmioinfo->pchBuffer);
 418
 419     return mmioSetInfo(HMMIO_32(hmmio), &mmioinfo, uFlags);
 420 }
 421
 422 /**************************************************************************
 423  *                              mmioSetBuffer           [MMSYSTEM.1217]
 424  */
 425 MMRESULT16 WINAPI mmioSetBuffer16(HMMIO16 hmmio, SEGPTR pchBuffer,
 426                                   LONG cchBuffer, UINT16 uFlags)
 427 {
 428     MMRESULT    ret = mmioSetBuffer(HMMIO_32(hmmio), MapSL(pchBuffer),
 429                                     cchBuffer, uFlags);
 430
 431     if (ret == MMSYSERR_NOERROR)
 432     {
 433         struct mmio_thunk* thunk;
 434
 435         if ((thunk = MMIO_HasThunk(HMMIO_32(hmmio))) == NULL)
 436         {
 437             FIXME("really ?\n");
 438             return MMSYSERR_INVALHANDLE;
 439         }
 440         MMIO_SetSegmentedBuffer(thunk, pchBuffer, TRUE);
 441     }
 442     else
 443         UnMapLS(pchBuffer);
 444     return ret;
 445 }
 446
 447 /**************************************************************************
 448  *                              mmioFlush               [MMSYSTEM.1218]
 449  */
 450 MMRESULT16 WINAPI mmioFlush16(HMMIO16 hmmio, UINT16 uFlags)
 451 {
 452     return mmioFlush(HMMIO_32(hmmio), uFlags);
 453 }
 454
 455 /***********************************************************************
 456  *                              mmioAdvance             [MMSYSTEM.1219]
 457  */
 458 MMRESULT16 WINAPI mmioAdvance16(HMMIO16 hmmio, MMIOINFO16* lpmmioinfo, UINT16 uFlags)
 459 {
 460     MMIOINFO    mmioinfo;
 461     LRESULT     ret;
 462
 463     /* WARNING: this heavily relies on mmioAdvance implementation (for choosing which
 464      * fields to init
 465      */
 466     if (lpmmioinfo)
 467     {
 468         mmioinfo.pchBuffer = MapSL((DWORD)lpmmioinfo->pchBuffer);
 469         mmioinfo.pchNext = MapSL((DWORD)lpmmioinfo->pchNext);
 470         mmioinfo.dwFlags = lpmmioinfo->dwFlags;
 471         mmioinfo.lBufOffset = lpmmioinfo->lBufOffset;
 472         ret = mmioAdvance(HMMIO_32(hmmio), &mmioinfo, uFlags);
 473     }
 474     else
 475         ret = mmioAdvance(HMMIO_32(hmmio), NULL, uFlags);
 476
 477     if (ret != MMSYSERR_NOERROR) return ret;
 478
 479     if (lpmmioinfo)
 480     {
 481         lpmmioinfo->dwFlags = mmioinfo.dwFlags;
 482         lpmmioinfo->pchNext     = (void*)(lpmmioinfo->pchBuffer + (mmioinfo.pchNext - mmioinfo.pchBuffer));
 483         lpmmioinfo->pchEndRead  = (void*)(lpmmioinfo->pchBuffer + (mmioinfo.pchEndRead - mmioinfo.pchBuffer));
 484         lpmmioinfo->pchEndWrite = (void*)(lpmmioinfo->pchBuffer + (mmioinfo.pchEndWrite - mmioinfo.pchBuffer));
 485         lpmmioinfo->lBufOffset  = mmioinfo.lBufOffset;
 486         lpmmioinfo->lDiskOffset = mmioinfo.lDiskOffset;
 487     }
 488
 489     return MMSYSERR_NOERROR;
 490 }
 491
 492 /**************************************************************************
 493  *                              mmioStringToFOURCC      [MMSYSTEM.1220]
 494  */
 495 FOURCC WINAPI mmioStringToFOURCC16(LPCSTR sz, UINT16 uFlags)
 496 {
 497     return mmioStringToFOURCCA(sz, uFlags);
 498 }
 499
 500 /**************************************************************************
 501  *              mmioInstallIOProc    [MMSYSTEM.1221]
 502  */
 503 LPMMIOPROC16 WINAPI mmioInstallIOProc16(FOURCC fccIOProc, LPMMIOPROC16 pIOProc,
 504                                         DWORD dwFlags)
 505 {
 506     struct mmio_thunk*  thunk = NULL;
 507     LPMMIOPROC pIOProc32;
 508
 509     EnterCriticalSection(&mmio_cs);
 510
 511     switch (dwFlags & (MMIO_INSTALLPROC|MMIO_REMOVEPROC|MMIO_FINDPROC)) {
 512     case MMIO_INSTALLPROC:
 513         if (!(thunk = MMIO_AddThunk(pIOProc, NULL)))
 514         {
 515             LeaveCriticalSection(&mmio_cs);
 516             return NULL;
 517         }
 518         if (!mmioInstallIOProcA(fccIOProc, (LPMMIOPROC)thunk, dwFlags))
 519         {
 520             thunk->pfn16 = NULL;
 521             pIOProc = NULL;
 522         }
 523         break;
 524     case MMIO_REMOVEPROC:
 525         if (MMIO_Thunks)
 526         {
 527             for (thunk = MMIO_Thunks; thunk < &MMIO_Thunks[MMIO_MAX_THUNKS]; thunk++)
 528             {
 529                 if (thunk->pfn16 == pIOProc && thunk->segbuffer == 0)
 530                 {
 531                     if (mmioInstallIOProcA(fccIOProc, (LPMMIOPROC)thunk, dwFlags))
 532                         thunk->pfn16 = NULL;
 533                     else
 534                         pIOProc = NULL;
 535                     break;
 536                 }
 537             }
 538         }
 539         if (!thunk) pIOProc = NULL;
 540         break;
 541     case MMIO_FINDPROC:
 542         if ((pIOProc32 = mmioInstallIOProcA(fccIOProc, NULL, dwFlags)) && MMIO_Thunks)
 543         {
 544             for (thunk = MMIO_Thunks; thunk < &MMIO_Thunks[MMIO_MAX_THUNKS]; thunk++)
 545             {
 546                 if ((LPMMIOPROC)thunk == pIOProc32)
 547                 {
 548                     pIOProc = thunk->pfn16;
 549                     break;
 550                 }
 551             }
 552         }
 553         break;
 554     default:
 555         FIXME("Unsupported flags %08x\n", dwFlags);
 556         pIOProc = NULL;
 557     }
 558     LeaveCriticalSection(&mmio_cs);
 559
 560     return pIOProc;
 561 }
 562
 563 /**************************************************************************
 564  *                              mmioSendMessage [MMSYSTEM.1222]
 565  */
 566 LRESULT WINAPI mmioSendMessage16(HMMIO16 hmmio, UINT16 uMessage,
 567                                  LPARAM lParam1, LPARAM lParam2)
 568 {
 569     struct mmio_thunk*  thunk;
 570
 571     if ((thunk = MMIO_HasThunk(HMMIO_32(hmmio))))
 572     {
 573         MMIOINFO        mmioinfo;
 574         if (mmioGetInfo(HMMIO_32(hmmio), &mmioinfo, 0) == MMSYSERR_NOERROR)
 575         {
 576             return MMIO_Callback3216((SEGPTR)thunk->pfn16, &mmioinfo, uMessage, lParam1, lParam2);
 577         }
 578         return MMSYSERR_INVALHANDLE;
 579     }
 580     else
 581     {
 582         /* FIXME: we need to map lParam1 and lParam2 to 32bit entities */
 583         return mmioSendMessage(HMMIO_32(hmmio), uMessage, lParam1, lParam2);
 584     }
 585 }
 586
 587 /**************************************************************************
 588  *                              mmioDescend             [MMSYSTEM.1223]
 589  */
 590 MMRESULT16 WINAPI mmioDescend16(HMMIO16 hmmio, LPMMCKINFO lpck,
 591                                 const MMCKINFO* lpckParent, UINT16 uFlags)
 592 {
 593     return mmioDescend(HMMIO_32(hmmio), lpck, lpckParent, uFlags);
 594 }
 595
 596 /**************************************************************************
 597  *                              mmioAscend              [MMSYSTEM.1224]
 598  */
 599 MMRESULT16 WINAPI mmioAscend16(HMMIO16 hmmio, MMCKINFO* lpck, UINT16 uFlags)
 600 {
 601     return mmioAscend(HMMIO_32(hmmio),lpck,uFlags);
 602 }
 603
 604 /**************************************************************************
 605  *                              mmioCreateChunk         [MMSYSTEM.1225]
 606  */
 607 MMRESULT16 WINAPI mmioCreateChunk16(HMMIO16 hmmio, MMCKINFO* lpck, UINT16 uFlags)
 608 {
 609     return mmioCreateChunk(HMMIO_32(hmmio), lpck, uFlags);
 610 }
 611
 612 /**************************************************************************
 613  *                              mmioRename              [MMSYSTEM.1226]
 614  */
 615 MMRESULT16 WINAPI mmioRename16(LPCSTR szFileName, LPCSTR szNewFileName,
 616                                MMIOINFO16* lpmmioinfo, DWORD dwRenameFlags)
 617 {
 618     BOOL        inst = FALSE;
 619     MMRESULT    ret;
 620     MMIOINFO    mmioinfo;
 621
 622     if (lpmmioinfo != NULL && lpmmioinfo->pIOProc != NULL &&
 623         lpmmioinfo->fccIOProc == 0) {
 624         FIXME("Can't handle this case yet\n");
 625         return MMSYSERR_ERROR;
 626     }
 627
 628     /* this is a bit hacky, but it'll work if we get a fourCC code or nothing.
 629      * but a non installed ioproc without a fourcc won't do
 630      */
 631     if (lpmmioinfo && lpmmioinfo->fccIOProc && lpmmioinfo->pIOProc) {
 632         mmioInstallIOProc16(lpmmioinfo->fccIOProc, lpmmioinfo->pIOProc,
 633                            MMIO_INSTALLPROC);
 634         inst = TRUE;
 635     }
 636     memset(&mmioinfo, 0, sizeof(mmioinfo));
 637     if (lpmmioinfo)
 638         mmioinfo.fccIOProc = lpmmioinfo->fccIOProc;
 639     ret = mmioRenameA(szFileName, szNewFileName, &mmioinfo, dwRenameFlags);
 640     if (inst) {
 641         mmioInstallIOProc16(lpmmioinfo->fccIOProc, NULL, MMIO_REMOVEPROC);
 642     }
 643     return ret;
 644 }