ReactOS Fundraising Campaign 2012
 
€ 4,410 / € 30,000

Information | Donate

Home | Info | Community | Development | myReactOS | Contact Us

  1. Home
  2. Community
  3. Development
  4. myReactOS
  5. Fundraiser 2012

  1. Main Page
  2. Alphabetical List
  3. Data Structures
  4. Directories
  5. File List
  6. Data Fields
  7. Globals
  8. Related Pages

ReactOS Development > Doxygen

info.c
Go to the documentation of this file.
00001 /*
00002  * Digital video MCI Wine Driver
00003  *
00004  * Copyright 1999, 2000 Eric POUECH
00005  *
00006  * This library is free software; you can redistribute it and/or
00007  * modify it under the terms of the GNU Lesser General Public
00008  * License as published by the Free Software Foundation; either
00009  * version 2.1 of the License, or (at your option) any later version.
00010  *
00011  * This library is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014  * Lesser General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU Lesser General Public
00017  * License along with this library; if not, write to the Free Software
00018  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
00019  */
00020 
00021 #include <string.h>
00022 #include "private_mciavi.h"
00023 #include "wine/debug.h"
00024 #include "wine/unicode.h"
00025 
00026 WINE_DEFAULT_DEBUG_CHANNEL(mciavi);
00027 
00028 /**************************************************************************
00029  *              MCIAVI_ConvertFrameToTimeFormat [internal]
00030  */
00031 static DWORD MCIAVI_ConvertFrameToTimeFormat(WINE_MCIAVI* wma, DWORD val, LPDWORD lpRet)
00032 {
00033     DWORD      ret = 0;
00034 
00035     switch (wma->dwMciTimeFormat) {
00036     case MCI_FORMAT_MILLISECONDS:
00037         ret = (val * wma->mah.dwMicroSecPerFrame) / 1000;
00038     break;
00039     case MCI_FORMAT_FRAMES:
00040     ret = val;
00041     break;
00042     default:
00043     WARN("Bad time format %u!\n", wma->dwMciTimeFormat);
00044     }
00045     TRACE("val=%u=0x%08x [tf=%u] => ret=%u\n", val, val, wma->dwMciTimeFormat, ret);
00046     *lpRet = 0;
00047     return ret;
00048 }
00049 
00050 /**************************************************************************
00051  *              MCIAVI_ConvertTimeFormatToFrame [internal]
00052  */
00053 DWORD   MCIAVI_ConvertTimeFormatToFrame(WINE_MCIAVI* wma, DWORD val)
00054 {
00055     DWORD   ret = 0;
00056 
00057     switch (wma->dwMciTimeFormat) {
00058     case MCI_FORMAT_MILLISECONDS:
00059     ret = (val * 1000) / wma->mah.dwMicroSecPerFrame;
00060     break;
00061     case MCI_FORMAT_FRAMES:
00062     ret = val;
00063     break;
00064     default:
00065     WARN("Bad time format %u!\n", wma->dwMciTimeFormat);
00066     }
00067     TRACE("val=%u=0x%08x [tf=%u] => ret=%u\n", val, val, wma->dwMciTimeFormat, ret);
00068     return ret;
00069 }
00070 
00071 /***************************************************************************
00072  *              MCIAVI_mciGetDevCaps        [internal]
00073  */
00074 DWORD   MCIAVI_mciGetDevCaps(UINT wDevID, DWORD dwFlags,  LPMCI_GETDEVCAPS_PARMS lpParms)
00075 {
00076     WINE_MCIAVI*    wma = MCIAVI_mciGetOpenDev(wDevID);
00077     DWORD       ret;
00078 
00079     TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
00080 
00081     if (lpParms == NULL)    return MCIERR_NULL_PARAMETER_BLOCK;
00082     if (wma == NULL)        return MCIERR_INVALID_DEVICE_ID;
00083     if (!(dwFlags & MCI_GETDEVCAPS_ITEM)) return MCIERR_MISSING_PARAMETER;
00084     if (dwFlags & MCI_TEST) return 0;
00085 
00086     EnterCriticalSection(&wma->cs);
00087 
00088     if (dwFlags & MCI_GETDEVCAPS_ITEM) {
00089     switch (lpParms->dwItem) {
00090     case MCI_GETDEVCAPS_DEVICE_TYPE:
00091         TRACE("MCI_GETDEVCAPS_DEVICE_TYPE !\n");
00092         lpParms->dwReturn = MAKEMCIRESOURCE(MCI_DEVTYPE_DIGITAL_VIDEO, MCI_DEVTYPE_DIGITAL_VIDEO);
00093         ret = MCI_RESOURCE_RETURNED;
00094         break;
00095     case MCI_GETDEVCAPS_HAS_AUDIO:
00096         TRACE("MCI_GETDEVCAPS_HAS_AUDIO !\n");
00097         lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
00098         ret = MCI_RESOURCE_RETURNED;
00099         break;
00100     case MCI_GETDEVCAPS_HAS_VIDEO:
00101         TRACE("MCI_GETDEVCAPS_HAS_VIDEO !\n");
00102         lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
00103         ret = MCI_RESOURCE_RETURNED;
00104         break;
00105     case MCI_GETDEVCAPS_USES_FILES:
00106         TRACE("MCI_GETDEVCAPS_USES_FILES !\n");
00107         lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
00108         ret = MCI_RESOURCE_RETURNED;
00109         break;
00110     case MCI_GETDEVCAPS_COMPOUND_DEVICE:
00111         TRACE("MCI_GETDEVCAPS_COMPOUND_DEVICE !\n");
00112         lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
00113         ret = MCI_RESOURCE_RETURNED;
00114         break;
00115     case MCI_GETDEVCAPS_CAN_EJECT:
00116         TRACE("MCI_GETDEVCAPS_CAN_EJECT !\n");
00117         lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
00118         ret = MCI_RESOURCE_RETURNED;
00119         break;
00120     case MCI_GETDEVCAPS_CAN_PLAY:
00121         TRACE("MCI_GETDEVCAPS_CAN_PLAY !\n");
00122         lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
00123         ret = MCI_RESOURCE_RETURNED;
00124         break;
00125     case MCI_GETDEVCAPS_CAN_RECORD:
00126         TRACE("MCI_GETDEVCAPS_CAN_RECORD !\n");
00127         lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
00128         ret = MCI_RESOURCE_RETURNED;
00129         break;
00130     case MCI_GETDEVCAPS_CAN_SAVE:
00131         TRACE("MCI_GETDEVCAPS_CAN_SAVE !\n");
00132         lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
00133         ret = MCI_RESOURCE_RETURNED;
00134         break;
00135     case MCI_DGV_GETDEVCAPS_CAN_REVERSE:
00136         TRACE("MCI_DGV_GETDEVCAPS_CAN_REVERSE !\n");
00137         lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
00138         ret = MCI_RESOURCE_RETURNED;
00139         break;
00140     case MCI_DGV_GETDEVCAPS_CAN_STRETCH:
00141         TRACE("MCI_DGV_GETDEVCAPS_CAN_STRETCH !\n");
00142         lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
00143         ret = MCI_RESOURCE_RETURNED;
00144         break;
00145     case MCI_DGV_GETDEVCAPS_CAN_LOCK:
00146         TRACE("MCI_DGV_GETDEVCAPS_CAN_LOCK !\n");
00147         lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
00148         ret = MCI_RESOURCE_RETURNED;
00149         break;
00150     case MCI_DGV_GETDEVCAPS_CAN_FREEZE:
00151         TRACE("MCI_DGV_GETDEVCAPS_CAN_FREEZE !\n");
00152         lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
00153         ret = MCI_RESOURCE_RETURNED;
00154         break;
00155     case MCI_DGV_GETDEVCAPS_CAN_STR_IN:
00156         TRACE("MCI_DGV_GETDEVCAPS_CAN_STRETCH_INPUT !\n");
00157         lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
00158         ret = MCI_RESOURCE_RETURNED;
00159         break;
00160     case MCI_DGV_GETDEVCAPS_HAS_STILL:
00161         TRACE("MCI_DGV_GETDEVCAPS_HAS_STILL !\n");
00162         lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE);
00163         ret = MCI_RESOURCE_RETURNED;
00164         break;
00165     case MCI_DGV_GETDEVCAPS_CAN_TEST:
00166         TRACE("MCI_DGV_GETDEVCAPS_CAN_TEST !\n");
00167         lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
00168         ret = MCI_RESOURCE_RETURNED;
00169         break;
00170     case MCI_DGV_GETDEVCAPS_PALETTES:
00171         TRACE("MCI_DGV_GETDEVCAPS_PALETTES !\n");
00172         lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
00173         ret = MCI_RESOURCE_RETURNED;
00174         break;
00175     /* w2k does not know MAX_WINDOWS or MAX/MINIMUM_RATE */
00176     default:
00177             FIXME("Unknown capability (%08x) !\n", lpParms->dwItem);
00178             ret = MCIERR_UNSUPPORTED_FUNCTION;
00179             break;
00180     }
00181     }
00182 
00183     LeaveCriticalSection(&wma->cs);
00184     return ret;
00185 }
00186 
00187 /***************************************************************************
00188  *              MCIAVI_mciInfo          [internal]
00189  */
00190 DWORD   MCIAVI_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_DGV_INFO_PARMSW lpParms)
00191 {
00192     LPCWSTR     str = 0;
00193     WINE_MCIAVI*    wma = MCIAVI_mciGetOpenDev(wDevID);
00194     DWORD       ret = 0;
00195     static const WCHAR wszAviPlayer[] = {'W','i','n','e','\'','s',' ','A','V','I',' ','p','l','a','y','e','r',0};
00196 
00197     if (lpParms == NULL || lpParms->lpstrReturn == NULL)
00198     return MCIERR_NULL_PARAMETER_BLOCK;
00199     if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
00200     if (dwFlags & MCI_TEST) return 0;
00201 
00202     TRACE("buf=%p, len=%u\n", lpParms->lpstrReturn, lpParms->dwRetSize);
00203 
00204     EnterCriticalSection(&wma->cs);
00205 
00206     if (dwFlags & MCI_INFO_PRODUCT)
00207     str = wszAviPlayer;
00208     else if (dwFlags & MCI_INFO_FILE)
00209     str = wma->lpFileName;
00210     else {
00211     WARN("Don't know this info command (%u)\n", dwFlags);
00212     ret = MCIERR_UNRECOGNIZED_COMMAND;
00213     }
00214     if (!ret) {
00215     WCHAR zero = 0;
00216     /* Only mciwave, mciseq and mcicda set dwRetSize (since NT). */
00217     lstrcpynW(lpParms->lpstrReturn, str ? str : &zero, lpParms->dwRetSize);
00218     }
00219     LeaveCriticalSection(&wma->cs);
00220     return ret;
00221 }
00222 
00223 /***************************************************************************
00224  *              MCIAVI_mciSet           [internal]
00225  */
00226 DWORD   MCIAVI_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SET_PARMS lpParms)
00227 {
00228     WINE_MCIAVI*    wma = MCIAVI_mciGetOpenDev(wDevID);
00229 
00230     if (lpParms == NULL)    return MCIERR_NULL_PARAMETER_BLOCK;
00231     if (wma == NULL)        return MCIERR_INVALID_DEVICE_ID;
00232     if (dwFlags & MCI_TEST) return 0;
00233 
00234     EnterCriticalSection(&wma->cs);
00235 
00236     if (dwFlags & MCI_SET_TIME_FORMAT) {
00237     switch (lpParms->dwTimeFormat) {
00238     case MCI_FORMAT_MILLISECONDS:
00239         TRACE("MCI_FORMAT_MILLISECONDS !\n");
00240         wma->dwMciTimeFormat = MCI_FORMAT_MILLISECONDS;
00241         break;
00242     case MCI_FORMAT_FRAMES:
00243         TRACE("MCI_FORMAT_FRAMES !\n");
00244         wma->dwMciTimeFormat = MCI_FORMAT_FRAMES;
00245         break;
00246     default:
00247             WARN("Bad time format %u!\n", lpParms->dwTimeFormat);
00248             LeaveCriticalSection(&wma->cs);
00249         return MCIERR_BAD_TIME_FORMAT;
00250     }
00251     }
00252 
00253     if (dwFlags & MCI_SET_DOOR_OPEN) {
00254     TRACE("No support for door open !\n");
00255         LeaveCriticalSection(&wma->cs);
00256     return MCIERR_UNSUPPORTED_FUNCTION;
00257     }
00258     if (dwFlags & MCI_SET_DOOR_CLOSED) {
00259     TRACE("No support for door close !\n");
00260         LeaveCriticalSection(&wma->cs);
00261     return MCIERR_UNSUPPORTED_FUNCTION;
00262     }
00263 
00264     if (dwFlags & MCI_SET_ON) {
00265     const char *szVideo="";
00266     const char *szAudio="";
00267     const char *szSeek="";
00268 
00269     if (dwFlags & MCI_SET_VIDEO) {
00270         szVideo = " video";
00271         wma->dwSet |= 4;
00272     }
00273     if (dwFlags & MCI_SET_AUDIO) {
00274         switch (lpParms->dwAudio) {
00275         case MCI_SET_AUDIO_ALL:
00276         szAudio = " audio all";
00277         wma->dwSet |= 3;
00278         break;
00279         case MCI_SET_AUDIO_LEFT:
00280         szAudio = " audio left";
00281         wma->dwSet |= 1;
00282         break;
00283         case MCI_SET_AUDIO_RIGHT:
00284         szAudio = " audio right";
00285         wma->dwSet |= 2;
00286         break;
00287         default:
00288         szAudio = " audio unknown";
00289         WARN("Unknown audio channel %u\n", lpParms->dwAudio);
00290         break;
00291         }
00292     }
00293     if (dwFlags & MCI_DGV_SET_SEEK_EXACTLY) {
00294         szSeek = " seek_exactly";
00295     }
00296     FIXME("MCI_SET_ON:%s%s%s\n", szVideo, szAudio, szSeek);
00297     }
00298 
00299     if (dwFlags & MCI_SET_OFF) {
00300     const char *szVideo="";
00301     const char *szAudio="";
00302     const char *szSeek="";
00303 
00304     if (dwFlags & MCI_SET_VIDEO) {
00305         szVideo = " video";
00306         wma->dwSet &= ~4;
00307     }
00308     if (dwFlags & MCI_SET_AUDIO) {
00309         switch (lpParms->dwAudio) {
00310         case MCI_SET_AUDIO_ALL:
00311         szAudio = " audio all";
00312         wma->dwSet &= ~3;
00313         break;
00314         case MCI_SET_AUDIO_LEFT:
00315         szAudio = " audio left";
00316         wma->dwSet &= ~2;
00317         break;
00318         case MCI_SET_AUDIO_RIGHT:
00319         szAudio = " audio right";
00320         wma->dwSet &= ~2;
00321         break;
00322         default:
00323         szAudio = " audio unknown";
00324         WARN("Unknown audio channel %u\n", lpParms->dwAudio);
00325         break;
00326         }
00327     }
00328     if (dwFlags & MCI_DGV_SET_SEEK_EXACTLY) {
00329         szSeek = " seek_exactly";
00330     }
00331     FIXME("MCI_SET_OFF:%s%s%s\n", szVideo, szAudio, szSeek);
00332     }
00333     if (dwFlags & MCI_DGV_SET_FILEFORMAT) {
00334     LPCSTR  str = "save";
00335     if (dwFlags & MCI_DGV_SET_STILL)
00336         str = "capture";
00337 
00338     switch (lpParms->dwFileFormat) {
00339     case MCI_DGV_FF_AVI:    FIXME("Setting file format (%s) to 'AVI'\n", str);  break;
00340     case MCI_DGV_FF_AVSS:   FIXME("Setting file format (%s) to 'AVSS'\n", str); break;
00341     case MCI_DGV_FF_DIB:    FIXME("Setting file format (%s) to 'DIB'\n", str);  break;
00342     case MCI_DGV_FF_JFIF:   FIXME("Setting file format (%s) to 'JFIF'\n", str); break;
00343     case MCI_DGV_FF_JPEG:   FIXME("Setting file format (%s) to 'JPEG'\n", str); break;
00344     case MCI_DGV_FF_MPEG:   FIXME("Setting file format (%s) to 'MPEG'\n", str);     break;
00345     case MCI_DGV_FF_RDIB:   FIXME("Setting file format (%s) to 'RLE DIB'\n", str);  break;
00346     case MCI_DGV_FF_RJPEG:  FIXME("Setting file format (%s) to 'RJPEG'\n", str);    break;
00347     default:        FIXME("Setting unknown file format (%s): %d\n", str, lpParms->dwFileFormat);
00348     }
00349     }
00350 
00351     if (dwFlags & MCI_DGV_SET_SPEED) {
00352     FIXME("Setting speed to %d\n", lpParms->dwSpeed);
00353     }
00354 
00355     LeaveCriticalSection(&wma->cs);
00356     return 0;
00357 }
00358 
00359 /***************************************************************************
00360  *              MCIAVI_mciStatus            [internal]
00361  */
00362 DWORD   MCIAVI_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpParms)
00363 {
00364     WINE_MCIAVI*    wma = MCIAVI_mciGetOpenDev(wDevID);
00365     DWORD       ret = 0;
00366 
00367     if (lpParms == NULL)    return MCIERR_NULL_PARAMETER_BLOCK;
00368     if (wma == NULL)        return MCIERR_INVALID_DEVICE_ID;
00369     if (!(dwFlags & MCI_STATUS_ITEM))   return MCIERR_MISSING_PARAMETER;
00370     if (dwFlags & MCI_TEST) return 0;
00371 
00372     EnterCriticalSection(&wma->cs);
00373 
00374     if (dwFlags & MCI_STATUS_ITEM) {
00375     switch (lpParms->dwItem) {
00376     case MCI_STATUS_CURRENT_TRACK:
00377         lpParms->dwReturn = 1;
00378         TRACE("MCI_STATUS_CURRENT_TRACK => %lu\n", lpParms->dwReturn);
00379         break;
00380     case MCI_STATUS_LENGTH:
00381         if (!wma->hFile) {
00382         lpParms->dwReturn = 0;
00383                 LeaveCriticalSection(&wma->cs);
00384         return MCIERR_UNSUPPORTED_FUNCTION;
00385         }
00386         /* only one track in file is currently handled, so don't take care of MCI_TRACK flag */
00387         lpParms->dwReturn = MCIAVI_ConvertFrameToTimeFormat(wma, wma->mah.dwTotalFrames, &ret);
00388         TRACE("MCI_STATUS_LENGTH => %lu\n", lpParms->dwReturn);
00389         break;
00390     case MCI_STATUS_MODE:
00391         lpParms->dwReturn = MAKEMCIRESOURCE(wma->dwStatus, wma->dwStatus);
00392         ret = MCI_RESOURCE_RETURNED;
00393            TRACE("MCI_STATUS_MODE => 0x%04x\n", LOWORD(lpParms->dwReturn));
00394         break;
00395     case MCI_STATUS_MEDIA_PRESENT:
00396         TRACE("MCI_STATUS_MEDIA_PRESENT => TRUE\n");
00397         lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
00398         ret = MCI_RESOURCE_RETURNED;
00399         break;
00400     case MCI_STATUS_NUMBER_OF_TRACKS:
00401         lpParms->dwReturn = 1;
00402         TRACE("MCI_STATUS_NUMBER_OF_TRACKS => %lu\n", lpParms->dwReturn);
00403         break;
00404     case MCI_STATUS_POSITION:
00405         if (!wma->hFile) {
00406         lpParms->dwReturn = 0;
00407                 LeaveCriticalSection(&wma->cs);
00408         return MCIERR_UNSUPPORTED_FUNCTION;
00409         }
00410         /* only one track in file is currently handled, so don't take care of MCI_TRACK flag */
00411         lpParms->dwReturn = MCIAVI_ConvertFrameToTimeFormat(wma,
00412                                  (dwFlags & MCI_STATUS_START) ? 0 : wma->dwCurrVideoFrame,
00413                                  &ret);
00414         TRACE("MCI_STATUS_POSITION %s => %lu\n",
00415           (dwFlags & MCI_STATUS_START) ? "start" : "current", lpParms->dwReturn);
00416         break;
00417     case MCI_STATUS_READY:
00418         lpParms->dwReturn = (wma->dwStatus == MCI_MODE_NOT_READY) ?
00419         MAKEMCIRESOURCE(FALSE, MCI_FALSE) : MAKEMCIRESOURCE(TRUE, MCI_TRUE);
00420         ret = MCI_RESOURCE_RETURNED;
00421         TRACE("MCI_STATUS_READY = %u\n", LOWORD(lpParms->dwReturn));
00422         break;
00423     case MCI_STATUS_TIME_FORMAT:
00424         lpParms->dwReturn = MAKEMCIRESOURCE(wma->dwMciTimeFormat,
00425                                 wma->dwMciTimeFormat + MCI_FORMAT_RETURN_BASE);
00426         TRACE("MCI_STATUS_TIME_FORMAT => %u\n", LOWORD(lpParms->dwReturn));
00427         ret = MCI_RESOURCE_RETURNED;
00428         break;
00429     case MCI_DGV_STATUS_AUDIO:
00430         lpParms->dwReturn = (wma->dwSet & 3) ?
00431         MAKEMCIRESOURCE(MCI_ON, MCI_ON_S) : MAKEMCIRESOURCE(MCI_OFF, MCI_OFF_S);
00432         ret = MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER;
00433         TRACE("MCI_STATUS_AUDIO = %u\n", LOWORD(lpParms->dwReturn));
00434         break;
00435     case MCI_DGV_STATUS_VIDEO:
00436         lpParms->dwReturn = (wma->dwSet & 4) ?
00437         MAKEMCIRESOURCE(MCI_ON, MCI_ON_S) : MAKEMCIRESOURCE(MCI_OFF, MCI_OFF_S);
00438         ret = MCI_RESOURCE_RETURNED|MCI_RESOURCE_DRIVER;
00439         TRACE("MCI_STATUS_VIDEO = %u\n", LOWORD(lpParms->dwReturn));
00440         break;
00441 
00442 #if 0
00443     case MCI_AVI_STATUS_AUDIO_BREAKS:
00444     case MCI_AVI_STATUS_FRAMES_SKIPPED:
00445     case MCI_AVI_STATUS_LAST_PLAY_SPEED:
00446     case MCI_DGV_STATUS_AUDIO_INPUT:
00447     case MCI_DGV_STATUS_AUDIO_RECORD:
00448     case MCI_DGV_STATUS_AUDIO_SOURCE:
00449     case MCI_DGV_STATUS_AVGBYTESPERSEC:
00450     case MCI_DGV_STATUS_BASS:
00451     case MCI_DGV_STATUS_BITSPERSAMPLE:
00452     case MCI_DGV_STATUS_BLOCKALIGN:
00453     case MCI_DGV_STATUS_BRIGHTNESS:
00454     case MCI_DGV_STATUS_COLOR:
00455     case MCI_DGV_STATUS_CONTRAST:
00456     case MCI_DGV_STATUS_FILEFORMAT:
00457     case MCI_DGV_STATUS_FILE_MODE:
00458     case MCI_DGV_STATUS_FILE_COMPLETION:
00459     case MCI_DGV_STATUS_GAMMA:
00460 #endif
00461     case MCI_DGV_STATUS_BITSPERPEL:
00462         lpParms->dwReturn = wma->inbih->biBitCount;
00463         TRACE("MCI_DGV_STATUS_BITSPERPEL => %lu\n", lpParms->dwReturn);
00464         break;
00465     case MCI_DGV_STATUS_HPAL:
00466         lpParms->dwReturn = 0;
00467         TRACE("MCI_DGV_STATUS_HPAL => %lx\n", lpParms->dwReturn);
00468         break;
00469     case MCI_DGV_STATUS_HWND:
00470            lpParms->dwReturn = (DWORD_PTR)wma->hWndPaint;
00471            TRACE("MCI_DGV_STATUS_HWND => %p\n", wma->hWndPaint);
00472        break;
00473     case MCI_DGV_STATUS_WINDOW_VISIBLE:
00474         lpParms->dwReturn = IsWindowVisible(wma->hWndPaint) ?
00475         MAKEMCIRESOURCE(TRUE, MCI_TRUE) : MAKEMCIRESOURCE(FALSE, MCI_FALSE);
00476         ret = MCI_RESOURCE_RETURNED;
00477         TRACE("MCI_STATUS_WINDOW_VISIBLE = %u\n", LOWORD(lpParms->dwReturn));
00478         break;
00479     case MCI_DGV_STATUS_WINDOW_MINIMIZED:
00480         lpParms->dwReturn = IsIconic(wma->hWndPaint) ?
00481         MAKEMCIRESOURCE(TRUE, MCI_TRUE) : MAKEMCIRESOURCE(FALSE, MCI_FALSE);
00482         ret = MCI_RESOURCE_RETURNED;
00483         TRACE("MCI_STATUS_WINDOW_MINIMIZED = %u\n", LOWORD(lpParms->dwReturn));
00484         break;
00485     case MCI_DGV_STATUS_WINDOW_MAXIMIZED:
00486         lpParms->dwReturn = IsZoomed(wma->hWndPaint) ?
00487         MAKEMCIRESOURCE(TRUE, MCI_TRUE) : MAKEMCIRESOURCE(FALSE, MCI_FALSE);
00488         ret = MCI_RESOURCE_RETURNED;
00489         TRACE("MCI_STATUS_WINDOW_MMAXIMIZED = %u\n", LOWORD(lpParms->dwReturn));
00490         break;
00491     case MCI_DGV_STATUS_SPEED:
00492         lpParms->dwReturn = 1000;
00493         TRACE("MCI_DGV_STATUS_SPEED = %lu\n", lpParms->dwReturn);
00494         break;
00495     case MCI_DGV_STATUS_FRAME_RATE:
00496         /* FIXME: 1000 is a settable speed multiplier */
00497         lpParms->dwReturn = MulDiv(1000000,1000,wma->mah.dwMicroSecPerFrame);
00498         TRACE("MCI_DGV_STATUS_FRAME_RATE = %lu\n", lpParms->dwReturn);
00499         break;
00500     case MCI_DGV_STATUS_FORWARD:
00501         lpParms->dwReturn = MAKEMCIRESOURCE(TRUE, MCI_TRUE);
00502         ret = MCI_RESOURCE_RETURNED;
00503         TRACE("MCI_DGV_STATUS_FORWARD = %u\n", LOWORD(lpParms->dwReturn));
00504         break;
00505     case MCI_DGV_STATUS_PAUSE_MODE:
00506         if (wma->dwStatus != MCI_MODE_PAUSE) {
00507         LeaveCriticalSection(&wma->cs);
00508         return MCIERR_NONAPPLICABLE_FUNCTION;
00509         }
00510         lpParms->dwReturn = MAKEMCIRESOURCE(MCI_MODE_PLAY, MCI_MODE_PLAY);
00511         ret = MCI_RESOURCE_RETURNED;
00512         TRACE("MCI_STATUS_MODE => 0x%04x\n", LOWORD(lpParms->dwReturn));
00513         break;
00514     case MCI_DGV_STATUS_AUDIO_STREAM:
00515        lpParms->dwReturn = wma->audio_stream_n;
00516        TRACE("MCI_DGV_STATUS_AUDIO_STREAM => %lu\n", lpParms->dwReturn);
00517        break;
00518 #if 0
00519     case MCI_DGV_STATUS_KEY_COLOR:
00520     case MCI_DGV_STATUS_KEY_INDEX:
00521     case MCI_DGV_STATUS_MONITOR:
00522     case MCI_DGV_MONITOR_FILE:
00523     case MCI_DGV_MONITOR_INPUT:
00524     case MCI_DGV_STATUS_MONITOR_METHOD:
00525     case MCI_DGV_STATUS_SAMPLESPERSECOND:
00526     case MCI_DGV_STATUS_SEEK_EXACTLY:
00527     case MCI_DGV_STATUS_SHARPNESS:
00528     case MCI_DGV_STATUS_SIZE:
00529     case MCI_DGV_STATUS_SMPTE:
00530     case MCI_DGV_STATUS_STILL_FILEFORMAT:
00531     case MCI_DGV_STATUS_TINT:
00532     case MCI_DGV_STATUS_TREBLE:
00533     case MCI_DGV_STATUS_UNSAVED:
00534     case MCI_DGV_STATUS_VIDEO_RECORD:
00535     case MCI_DGV_STATUS_VIDEO_SOURCE:
00536     case MCI_DGV_STATUS_VIDEO_SRC_NUM:
00537     case MCI_DGV_STATUS_VIDEO_STREAM:
00538     case MCI_DGV_STATUS_VOLUME:
00539 #endif
00540     default:
00541             FIXME("Unknown command %08X !\n", lpParms->dwItem);
00542             TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
00543             LeaveCriticalSection(&wma->cs);
00544         return MCIERR_UNSUPPORTED_FUNCTION;
00545     }
00546     }
00547 
00548     if (dwFlags & MCI_NOTIFY) {
00549     TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
00550     mciDriverNotify(HWND_32(LOWORD(lpParms->dwCallback)),
00551                        wDevID, MCI_NOTIFY_SUCCESSFUL);
00552     }
00553     LeaveCriticalSection(&wma->cs);
00554     return ret;
00555 }

Generated on Sun May 27 2012 04:24:38 for ReactOS by doxygen 1.7.6.1

ReactOS is a registered trademark or a trademark of ReactOS Foundation in the United States and other countries.