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