dll/win32/mciavi32/info.c

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