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

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  * Digital video MCI Wine Driver
   5  *
   6  * Copyright 1999, 2000 Eric POUECH
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <string.h>
  24 #include "private_mciavi.h"
  25 #include "wine/debug.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(mciavi);
  28
  29 /**************************************************************************
  30  *                              MCIAVI_ConvertFrameToTimeFormat [internal]
  31  */
  32 DWORD   MCIAVI_ConvertFrameToTimeFormat(WINE_MCIAVI* wma, DWORD val, LPDWORD lpRet)
  33 {
  34     DWORD          ret = 0;
  35
  36     switch (wma->dwMciTimeFormat) {
  37     case MCI_FORMAT_MILLISECONDS:
  38         ret = (val * wma->mah.dwMicroSecPerFrame) / 1000;
  39         break;
  40     case MCI_FORMAT_FRAMES:
  41         ret = val;
  42         break;
  43     default:
  44         WARN("Bad time format %lu!\n", wma->dwMciTimeFormat);
  45     }
  46     TRACE("val=%lu=0x%08lx [tf=%lu] => ret=%lu\n", val, val, wma->dwMciTimeFormat, ret);
  47     *lpRet = 0;
  48     return ret;
  49 }
  50
  51 /**************************************************************************
  52  *                              MCIAVI_ConvertTimeFormatToFrame [internal]
  53  */
  54 DWORD   MCIAVI_ConvertTimeFormatToFrame(WINE_MCIAVI* wma, DWORD val)
  55 {
  56     DWORD       ret = 0;
  57
  58     switch (wma->dwMciTimeFormat) {
  59     case MCI_FORMAT_MILLISECONDS:
  60         ret = (val * 1000) / wma->mah.dwMicroSecPerFrame;
  61         break;
  62     case MCI_FORMAT_FRAMES:
  63         ret = val;
  64         break;
  65     default:
  66         WARN("Bad time format %lu!\n", wma->dwMciTimeFormat);
  67     }
  68     TRACE("val=%lu=0x%08lx [tf=%lu] => ret=%lu\n", val, val, wma->dwMciTimeFormat, ret);
  69     return ret;
  70 }
  71
  72 /***************************************************************************
  73  *                              MCIAVI_mciGetDevCaps            [internal]
  74  */
  75 DWORD   MCIAVI_mciGetDevCaps(UINT wDevID, DWORD dwFlags,  LPMCI_GETDEVCAPS_PARMS lpParms)
  76 {
  77     WINE_MCIAVI*        wma = MCIAVI_mciGetOpenDev(wDevID);
  78     DWORD               ret;
  79
  80     TRACE("(%04x, %08lX, %p)\n", wDevID, dwFlags, lpParms);
  81
  82     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
  83     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
  84
  85     EnterCriticalSection(&wma->cs);
  86
  87     if (dwFlags & MCI_GETDEVCAPS_ITEM) {
  88         switch (lpParms->dwItem) {
  89         case MCI_GETDEVCAPS_DEVICE_TYPE:
  90             TRACE("MCI_GETDEVCAPS_DEVICE_TYPE !\n");
  91             lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_DIGITAL_VIDEO, MCI_DEVTYPE_DIGITAL_VIDEO);
  92             ret = MCI_RESOURCE_RETURNED;
  93             break;
  94         case MCI_GETDEVCAPS_HAS_AUDIO:
  95             TRACE("MCI_GETDEVCAPS_HAS_AUDIO !\n");
  96             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
  97             ret = MCI_RESOURCE_RETURNED;
  98             break;
  99         case MCI_GETDEVCAPS_HAS_VIDEO:
 100             TRACE("MCI_GETDEVCAPS_HAS_VIDEO !\n");
 101             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 102             ret = MCI_RESOURCE_RETURNED;
 103             break;
 104         case MCI_GETDEVCAPS_USES_FILES:
 105             TRACE("MCI_GETDEVCAPS_USES_FILES !\n");
 106             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 107             ret = MCI_RESOURCE_RETURNED;
 108             break;
 109         case MCI_GETDEVCAPS_COMPOUND_DEVICE:
 110             TRACE("MCI_GETDEVCAPS_COMPOUND_DEVICE !\n");
 111             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 112             ret = MCI_RESOURCE_RETURNED;
 113             break;
 114         case MCI_GETDEVCAPS_CAN_EJECT:
 115             TRACE("MCI_GETDEVCAPS_CAN_EJECT !\n");
 116             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 117             ret = MCI_RESOURCE_RETURNED;
 118             break;
 119         case MCI_GETDEVCAPS_CAN_PLAY:
 120             TRACE("MCI_GETDEVCAPS_CAN_PLAY !\n");
 121             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 122             ret = MCI_RESOURCE_RETURNED;
 123             break;
 124         case MCI_GETDEVCAPS_CAN_RECORD:
 125             TRACE("MCI_GETDEVCAPS_CAN_RECORD !\n");
 126             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 127             ret = MCI_RESOURCE_RETURNED;
 128             break;
 129         case MCI_GETDEVCAPS_CAN_SAVE:
 130             TRACE("MCI_GETDEVCAPS_CAN_SAVE !\n");
 131             lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
 132             ret = MCI_RESOURCE_RETURNED;
 133             break;
 134         default:
 135             FIXME("Unknown capability (%08lx) !\n", lpParms->dwItem);
 136            ret = MCIERR_UNRECOGNIZED_COMMAND;
 137             break;
 138         }
 139     } else {
 140         WARN("No GetDevCaps-Item !\n");
 141        ret = MCIERR_UNRECOGNIZED_COMMAND;
 142     }
 143
 144     LeaveCriticalSection(&wma->cs);
 145     return ret;
 146 }
 147
 148 /***************************************************************************
 149  *                              MCIAVI_mciInfo                  [internal]
 150  */
 151 DWORD   MCIAVI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_INFO_PARMSA lpParms)
 152 {
 153     LPCSTR              str = 0;
 154     WINE_MCIAVI*        wma = MCIAVI_mciGetOpenDev(wDevID);
 155     DWORD               ret = 0;
 156
 157     if (lpParms == NULL || lpParms->lpstrReturn == NULL)
 158         return MCIERR_NULL_PARAMETER_BLOCK;
 159     if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
 160
 161     TRACE("buf=%p, len=%lu\n", lpParms->lpstrReturn, lpParms->dwRetSize);
 162
 163     EnterCriticalSection(&wma->cs);
 164
 165     switch (dwFlags) {
 166     case MCI_INFO_PRODUCT:
 167         str = "Wine's AVI player";
 168         break;
 169     case MCI_INFO_FILE:
 170        str = wma->lpFileName;
 171         break;
 172     default:
 173         WARN("Don't know this info command (%lu)\n", dwFlags);
 174         LeaveCriticalSection(&wma->cs);
 175         return MCIERR_UNRECOGNIZED_COMMAND;
 176     }
 177     if (str) {
 178         if (strlen(str) + 1 > lpParms->dwRetSize) {
 179             ret = MCIERR_PARAM_OVERFLOW;
 180         } else {
 181             lstrcpynA(lpParms->lpstrReturn, str, lpParms->dwRetSize);
 182         }
 183     } else {
 184         lpParms->lpstrReturn[0] = 0;
 185     }
 186
 187     LeaveCriticalSection(&wma->cs);
 188     return ret;
 189 }
 190
 191 /***************************************************************************
 192  *                              MCIAVI_mciSet                   [internal]
 193  */
 194 DWORD   MCIAVI_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SET_PARMS lpParms)
 195 {
 196     WINE_MCIAVI*        wma = MCIAVI_mciGetOpenDev(wDevID);
 197
 198     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 199     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 200
 201     EnterCriticalSection(&wma->cs);
 202
 203     if (dwFlags & MCI_SET_TIME_FORMAT) {
 204         switch (lpParms->dwTimeFormat) {
 205         case MCI_FORMAT_MILLISECONDS:
 206             TRACE("MCI_FORMAT_MILLISECONDS !\n");
 207             wma->dwMciTimeFormat = MCI_FORMAT_MILLISECONDS;
 208             break;
 209         case MCI_FORMAT_FRAMES:
 210             TRACE("MCI_FORMAT_FRAMES !\n");
 211             wma->dwMciTimeFormat = MCI_FORMAT_FRAMES;
 212             break;
 213         default:
 214             WARN("Bad time format %lu!\n", lpParms->dwTimeFormat);
 215             LeaveCriticalSection(&wma->cs);
 216             return MCIERR_BAD_TIME_FORMAT;
 217         }
 218     }
 219
 220     if (dwFlags & MCI_SET_DOOR_OPEN) {
 221         TRACE("No support for door open !\n");
 222         LeaveCriticalSection(&wma->cs);
 223         return MCIERR_UNSUPPORTED_FUNCTION;
 224     }
 225     if (dwFlags & MCI_SET_DOOR_CLOSED) {
 226         TRACE("No support for door close !\n");
 227         LeaveCriticalSection(&wma->cs);
 228         return MCIERR_UNSUPPORTED_FUNCTION;
 229     }
 230
 231     if (dwFlags & MCI_SET_ON) {
 232         char    buffer[256];
 233
 234         strcpy(buffer, "MCI_SET_ON:");
 235
 236         if (dwFlags & MCI_SET_VIDEO) {
 237             strncat(buffer, " video", sizeof(buffer));
 238             wma->dwSet |= 4;
 239         }
 240         if (dwFlags & MCI_SET_AUDIO) {
 241             strncat(buffer, " audio", sizeof(buffer));
 242             switch (lpParms->dwAudio) {
 243             case MCI_SET_AUDIO_ALL:
 244                 strncat(buffer, " all", sizeof(buffer));
 245                 wma->dwSet |= 3;
 246                 break;
 247             case MCI_SET_AUDIO_LEFT:
 248                 strncat(buffer, " left", sizeof(buffer));
 249                 wma->dwSet |= 1;
 250                 break;
 251             case MCI_SET_AUDIO_RIGHT:
 252                 strncat(buffer, " right", sizeof(buffer));
 253                 wma->dwSet |= 2;
 254                 break;
 255             default:
 256                 WARN("Unknown audio chanel %lu\n", lpParms->dwAudio);
 257                 break;
 258             }
 259         }
 260         if (dwFlags & MCI_DGV_SET_SEEK_EXACTLY) {
 261             strncat(buffer, " seek_exactly", sizeof(buffer));
 262         }
 263         FIXME("%s\n", buffer);
 264     }
 265
 266     if (dwFlags & MCI_SET_OFF) {
 267         char    buffer[256];
 268
 269         strcpy(buffer, "MCI_SET_OFF:");
 270         if (dwFlags & MCI_SET_VIDEO) {
 271             strncat(buffer, " video", sizeof(buffer));
 272             wma->dwSet &= ~4;
 273         }
 274         if (dwFlags & MCI_SET_AUDIO) {
 275             strncat(buffer, " audio", sizeof(buffer));
 276             switch (lpParms->dwAudio) {
 277             case MCI_SET_AUDIO_ALL:
 278                 strncat(buffer, " all", sizeof(buffer));
 279                 wma->dwSet &= ~3;
 280                 break;
 281             case MCI_SET_AUDIO_LEFT:
 282                 strncat(buffer, " left", sizeof(buffer));
 283                 wma->dwSet &= ~2;
 284                 break;
 285             case MCI_SET_AUDIO_RIGHT:
 286                 strncat(buffer, " right", sizeof(buffer));
 287                 wma->dwSet &= ~2;
 288                 break;
 289             default:
 290                 WARN("Unknown audio chanel %lu\n", lpParms->dwAudio);
 291                 break;
 292             }
 293         }
 294         if (dwFlags & MCI_DGV_SET_SEEK_EXACTLY) {
 295             strncat(buffer, " seek_exactly", sizeof(buffer));
 296         }
 297         FIXME("%s\n", buffer);
 298     }
 299     if (dwFlags & MCI_DGV_SET_FILEFORMAT) {
 300         LPCSTR  str = "save";
 301         if (dwFlags & MCI_DGV_SET_STILL)
 302             str = "capture";
 303
 304         switch (lpParms->dwFileFormat) {
 305         case MCI_DGV_FF_AVI:    FIXME("Setting file format (%s) to 'AVI'\n", str);      break;
 306         case MCI_DGV_FF_AVSS:   FIXME("Setting file format (%s) to 'AVSS'\n", str);     break;
 307         case MCI_DGV_FF_DIB:    FIXME("Setting file format (%s) to 'DIB'\n", str);      break;
 308         case MCI_DGV_FF_JFIF:   FIXME("Setting file format (%s) to 'JFIF'\n", str);     break;
 309         case MCI_DGV_FF_JPEG:   FIXME("Setting file format (%s) to 'JPEG'\n", str);     break;
 310         case MCI_DGV_FF_MPEG:   FIXME("Setting file format (%s) to 'MPEG'\n", str);     break;
 311         case MCI_DGV_FF_RDIB:   FIXME("Setting file format (%s) to 'RLE DIB'\n", str);  break;
 312         case MCI_DGV_FF_RJPEG:  FIXME("Setting file format (%s) to 'RJPEG'\n", str);    break;
 313         default:                FIXME("Setting unknown file format (%s): %ld\n", str, lpParms->dwFileFormat);
 314         }
 315     }
 316
 317     if (dwFlags & MCI_DGV_SET_SPEED) {
 318         FIXME("Setting speed to %ld\n", lpParms->dwSpeed);
 319     }
 320
 321     LeaveCriticalSection(&wma->cs);
 322     return 0;
 323 }
 324
 325 /***************************************************************************
 326  *                              MCIAVI_mciStatus                        [internal]
 327  */
 328 DWORD   MCIAVI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSA lpParms)
 329 {
 330     WINE_MCIAVI*        wma = MCIAVI_mciGetOpenDev(wDevID);
 331     DWORD               ret = 0;
 332
 333     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
 334     if (wma == NULL)            return MCIERR_INVALID_DEVICE_ID;
 335
 336     EnterCriticalSection(&wma->cs);
 337
 338     if (dwFlags & MCI_STATUS_ITEM) {
 339         switch (lpParms->dwItem) {
 340         case MCI_STATUS_CURRENT_TRACK:
 341             lpParms->dwReturn = 1;
 342             TRACE("MCI_STATUS_CURRENT_TRACK => %lu\n", lpParms->dwReturn);
 343             break;
 344         case MCI_STATUS_LENGTH:
 345             if (!wma->hFile) {
 346                 lpParms->dwReturn = 0;
 347                 LeaveCriticalSection(&wma->cs);
 348                 return MCIERR_UNSUPPORTED_FUNCTION;
 349             }
 350             /* only one track in file is currently handled, so don't take care of MCI_TRACK flag */
 351             lpParms->dwReturn = MCIAVI_ConvertFrameToTimeFormat(wma, wma->mah.dwTotalFrames, &ret);
 352             TRACE("MCI_STATUS_LENGTH => %lu\n", lpParms->dwReturn);
 353             break;
 354         case MCI_STATUS_MODE:
 355             lpParms->dwReturn = MAKEMCIRESOURCE(wma->dwStatus, wma->dwStatus);
 356             ret = MCI_RESOURCE_RETURNED;
 357            TRACE("MCI_STATUS_MODE => 0x%04x\n", LOWORD(lpParms->dwReturn));
 358             break;
 359         case MCI_STATUS_MEDIA_PRESENT:
 360             TRACE("MCI_STATUS_MEDIA_PRESENT => TRUE\n");
 361             lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 362             ret = MCI_RESOURCE_RETURNED;
 363             break;
 364         case MCI_STATUS_NUMBER_OF_TRACKS:
 365             lpParms->dwReturn = 1;
 366             TRACE("MCI_STATUS_NUMBER_OF_TRACKS => %lu\n", lpParms->dwReturn);
 367             break;
 368         case MCI_STATUS_POSITION:
 369             if (!wma->hFile) {
 370                 lpParms->dwReturn = 0;
 371                 LeaveCriticalSection(&wma->cs);
 372                 return MCIERR_UNSUPPORTED_FUNCTION;
 373             }
 374             /* only one track in file is currently handled, so don't take care of MCI_TRACK flag */
 375             lpParms->dwReturn = MCIAVI_ConvertFrameToTimeFormat(wma,
 376                                                              (dwFlags & MCI_STATUS_START) ? 0 : wma->dwCurrVideoFrame,
 377                                                              &ret);
 378             TRACE("MCI_STATUS_POSITION %s => %lu\n",
 379                   (dwFlags & MCI_STATUS_START) ? "start" : "current", lpParms->dwReturn);
 380             break;
 381         case MCI_STATUS_READY:
 382             lpParms->dwReturn = (wma->dwStatus == MCI_MODE_NOT_READY) ?
 383                 MAKEMCIRESOURCE(FALSE, MCI_FALSE) : MAKEMCIRESOURCE(TRUE, MCI_TRUE);
 384             ret = MCI_RESOURCE_RETURNED;
 385             TRACE("MCI_STATUS_READY = %u\n", LOWORD(lpParms->dwReturn));
 386             break;
 387         case MCI_STATUS_TIME_FORMAT:
 388             lpParms->dwReturn = MAKEMCIRESOURCE(wma->dwMciTimeFormat,
 389                                 wma->dwMciTimeFormat + MCI_FORMAT_RETURN_BASE);
 390             TRACE("MCI_STATUS_TIME_FORMAT => %u\n", LOWORD(lpParms->dwReturn));
 391             ret = MCI_RESOURCE_RETURNED;
 392             break;
 393 #if 0
 394         case MCI_AVI_STATUS_AUDIO_BREAKS:
 395         case MCI_AVI_STATUS_FRAMES_SKIPPED:
 396         case MCI_AVI_STATUS_LAST_PLAY_SPEED:
 397         case MCI_DGV_STATUS_AUDIO:
 398         case MCI_DGV_STATUS_AUDIO_INPUT:
 399         case MCI_DGV_STATUS_AUDIO_RECORD:
 400         case MCI_DGV_STATUS_AUDIO_SOURCE:
 401         case MCI_DGV_SETAUDIO_AVERAGE:
 402         case MCI_DGV_SETAUDIO_LEFT:
 403         case MCI_DGV_SETAUDIO_RIGHT:
 404         case MCI_DGV_SETAUDIO_STEREO:
 405         case MCI_DGV_STATUS_AUDIO_STREAM:
 406         case MCI_DGV_STATUS_AVGBYTESPERSEC:
 407         case MCI_DGV_STATUS_BASS:
 408         case MCI_DGV_STATUS_BITSPERPEL:
 409         case MCI_DGV_STATUS_BITSPERSAMPLE:
 410         case MCI_DGV_STATUS_BLOCKALIGN:
 411         case MCI_DGV_STATUS_BRIGHTNESS:
 412         case MCI_DGV_STATUS_COLOR:
 413         case MCI_DGV_STATUS_CONTRAST:
 414         case MCI_DGV_STATUS_FILEFORMAT:
 415         case MCI_DGV_STATUS_FILE_MODE:
 416         case MCI_DGV_STATUS_FILE_COMPLETION:
 417         case MCI_DGV_STATUS_FORWARD:
 418         case MCI_DGV_STATUS_FRAME_RATE:
 419         case MCI_DGV_STATUS_GAMMA:
 420 #endif
 421         case MCI_DGV_STATUS_HPAL:
 422             lpParms->dwReturn = 0;
 423             TRACE("MCI_DGV_STATUS_HPAL => %lx\n", lpParms->dwReturn);
 424             break;
 425         case MCI_DGV_STATUS_HWND:
 426            lpParms->dwReturn = (DWORD_PTR)wma->hWndPaint;
 427            TRACE("MCI_DGV_STATUS_HWND => %p\n", wma->hWndPaint);
 428             break;
 429 #if 0
 430         case MCI_DGV_STATUS_KEY_COLOR:
 431         case MCI_DGV_STATUS_KEY_INDEX:
 432         case MCI_DGV_STATUS_MONITOR:
 433         case MCI_DGV_MONITOR_FILE:
 434         case MCI_DGV_MONITOR_INPUT:
 435         case MCI_DGV_STATUS_MONITOR_METHOD:
 436         case MCI_DGV_STATUS_PAUSE_MODE:
 437         case MCI_DGV_STATUS_SAMPLESPERSECOND:
 438         case MCI_DGV_STATUS_SEEK_EXACTLY:
 439         case MCI_DGV_STATUS_SHARPNESS:
 440         case MCI_DGV_STATUS_SIZE:
 441         case MCI_DGV_STATUS_SMPTE:
 442         case MCI_DGV_STATUS_SPEED:
 443         case MCI_DGV_STATUS_STILL_FILEFORMAT:
 444         case MCI_DGV_STATUS_TINT:
 445         case MCI_DGV_STATUS_TREBLE:
 446         case MCI_DGV_STATUS_UNSAVED:
 447         case MCI_DGV_STATUS_VIDEO:
 448         case MCI_DGV_STATUS_VIDEO_RECORD:
 449         case MCI_DGV_STATUS_VIDEO_SOURCE:
 450         case MCI_DGV_STATUS_VIDEO_SRC_NUM:
 451         case MCI_DGV_STATUS_VIDEO_STREAM:
 452         case MCI_DGV_STATUS_VOLUME:
 453         case MCI_DGV_STATUS_WINDOW_VISIBLE:
 454         case MCI_DGV_STATUS_WINDOW_MINIMIZED:
 455         case MCI_DGV_STATUS_WINDOW_MAXIMIZED:
 456         case MCI_STATUS_MEDIA_PRESENT:
 457 #endif
 458         default:
 459             FIXME("Unknowm command %08lX !\n", lpParms->dwItem);
 460             TRACE("(%04x, %08lX, %p)\n", wDevID, dwFlags, lpParms);
 461             LeaveCriticalSection(&wma->cs);
 462             return MCIERR_UNRECOGNIZED_COMMAND;
 463         }
 464     } else {
 465         WARN("No Status-Item!\n");
 466         LeaveCriticalSection(&wma->cs);
 467         return MCIERR_UNRECOGNIZED_COMMAND;
 468     }
 469
 470     if (dwFlags & MCI_NOTIFY) {
 471         TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
 472         mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
 473                        wDevID, MCI_NOTIFY_SUCCESSFUL);
 474     }
 475     LeaveCriticalSection(&wma->cs);
 476     return ret;
 477 }