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