ReactOS 0.4.15-dev-5666-gc548b97
private_mciavi.h File Reference
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "mmddk.h"
#include "digitalv.h"
#include "vfw.h"
#include "wownt32.h"
#include "mciavi.h"
Include dependency graph for private_mciavi.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  MMIOPos
 
struct  WINE_MCIAVI
 

Functions

DWORD MCIAVI_ConvertTimeFormatToFrame (WINE_MCIAVI *wma, DWORD val) DECLSPEC_HIDDEN
 
DWORD MCIAVI_mciGetDevCaps (UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_PARMS lpParms) DECLSPEC_HIDDEN
 
DWORD MCIAVI_mciInfo (UINT wDevID, DWORD dwFlags, LPMCI_DGV_INFO_PARMSW lpParms) DECLSPEC_HIDDEN
 
DWORD MCIAVI_mciSet (UINT wDevID, DWORD dwFlags, LPMCI_DGV_SET_PARMS lpParms) DECLSPEC_HIDDEN
 
DWORD MCIAVI_mciStatus (UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpParms) DECLSPEC_HIDDEN
 
BOOL MCIAVI_GetInfo (WINE_MCIAVI *wma) DECLSPEC_HIDDEN
 
DWORD MCIAVI_OpenAudio (WINE_MCIAVI *wma, unsigned *nHdr, LPWAVEHDR *pWaveHdr) DECLSPEC_HIDDEN
 
BOOL MCIAVI_OpenVideo (WINE_MCIAVI *wma) DECLSPEC_HIDDEN
 
void MCIAVI_PlayAudioBlocks (WINE_MCIAVI *wma, unsigned nHdr, LPWAVEHDR waveHdr) DECLSPEC_HIDDEN
 
double MCIAVI_PaintFrame (WINE_MCIAVI *wma, HDC hDC) DECLSPEC_HIDDEN
 
WINE_MCIAVIMCIAVI_mciGetOpenDev (UINT wDevID) DECLSPEC_HIDDEN
 
DWORD MCIAVI_mciClose (UINT, DWORD, LPMCI_GENERIC_PARMS) DECLSPEC_HIDDEN
 
BOOL MCIAVI_RegisterClass (void) DECLSPEC_HIDDEN
 
BOOL MCIAVI_UnregisterClass (void) DECLSPEC_HIDDEN
 
BOOL MCIAVI_CreateWindow (WINE_MCIAVI *wma, DWORD dwFlags, LPMCI_DGV_OPEN_PARMSW lpOpenParms) DECLSPEC_HIDDEN
 
DWORD MCIAVI_mciPut (UINT wDevID, DWORD dwFlags, LPMCI_DGV_PUT_PARMS lpParms) DECLSPEC_HIDDEN
 
DWORD MCIAVI_mciWhere (UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms) DECLSPEC_HIDDEN
 
DWORD MCIAVI_mciWindow (UINT wDevID, DWORD dwFlags, LPMCI_DGV_WINDOW_PARMSW lpParms) DECLSPEC_HIDDEN
 

Variables

HINSTANCE MCIAVI_hInstance DECLSPEC_HIDDEN
 

Function Documentation

◆ MCIAVI_ConvertTimeFormatToFrame()

DWORD MCIAVI_ConvertTimeFormatToFrame ( WINE_MCIAVI wma,
DWORD  val 
)

Definition at line 52 of file info.c.

53{
54 DWORD ret = 0;
55
56 switch (wma->dwMciTimeFormat) {
58 ret = (val * 1000) / wma->mah.dwMicroSecPerFrame;
59 break;
61 ret = val;
62 break;
63 default:
64 WARN("Bad time format %u!\n", wma->dwMciTimeFormat);
65 }
66 TRACE("val=%u=0x%08x [tf=%u] => ret=%u\n", val, val, wma->dwMciTimeFormat, ret);
67 return ret;
68}
#define WARN(fmt,...)
Definition: debug.h:112
unsigned long DWORD
Definition: ntddk_ex.h:95
GLuint GLfloat * val
Definition: glext.h:7180
#define MCI_FORMAT_MILLISECONDS
Definition: mmsystem.h:701
#define MCI_FORMAT_FRAMES
Definition: mmsystem.h:704
#define TRACE(s)
Definition: solgame.cpp:4
DWORD dwMciTimeFormat
MainAVIHeader mah
DWORD dwMicroSecPerFrame
Definition: vfw.h:941
int ret

Referenced by MCIAVI_mciPlay(), and MCIAVI_mciSeek().

◆ MCIAVI_CreateWindow()

BOOL MCIAVI_CreateWindow ( WINE_MCIAVI wma,
DWORD  dwFlags,
LPMCI_DGV_OPEN_PARMSW  lpOpenParms 
)

Definition at line 112 of file wnd.c.

113{
114 static const WCHAR captionW[] = {'W','i','n','e',' ','M','C','I','-','A','V','I',' ','p','l','a','y','e','r',0};
115 HWND hParent = 0;
116 DWORD dwStyle = WS_OVERLAPPEDWINDOW;
117 RECT rc;
118
119 /* what should be done ? */
120 if (wma->hWnd) return TRUE;
121
122 if (dwFlags & MCI_DGV_OPEN_PARENT) hParent = lpParms->hWndParent;
123 if (dwFlags & MCI_DGV_OPEN_WS) dwStyle = lpParms->dwStyle;
124
125 if (wma->hic)
126 SetRect(&rc, 0, 0, wma->outbih->biWidth, wma->outbih->biHeight);
127 else
128 SetRect(&rc, 0, 0, wma->inbih->biWidth, wma->inbih->biHeight);
129
130 AdjustWindowRect(&rc, dwStyle, FALSE);
131 if (!(dwStyle & (WS_CHILD|WS_POPUP))) /* overlapped window ? */
132 {
133 rc.right -= rc.left;
134 rc.bottom -= rc.top;
135 rc.left = rc.top = CW_USEDEFAULT;
136 }
137
138 wma->hWnd = CreateWindowW(mciaviW, captionW,
139 dwStyle, rc.left, rc.top,
140 rc.right, rc.bottom,
141 hParent, 0, MCIAVI_hInstance,
142 ULongToPtr(wma->wDevID));
143 wma->hWndPaint = wma->hWnd;
144
145 TRACE("(%04x, %08X, %p, style %x, parent %p, dimensions %dx%d, hwnd %p)\n", wma->wDevID,
146 dwFlags, lpParms, dwStyle, hParent, rc.right - rc.left, rc.bottom - rc.top, wma->hWnd);
147 return wma->hWnd != 0;
148}
#define ULongToPtr(ul)
Definition: basetsd.h:92
#define MCI_DGV_OPEN_PARENT
Definition: digitalv.h:212
#define MCI_DGV_OPEN_WS
Definition: digitalv.h:211
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
HINSTANCE MCIAVI_hInstance
Definition: mciavi.c:52
#define WS_CHILD
Definition: pedump.c:617
#define WS_OVERLAPPEDWINDOW
Definition: pedump.c:637
#define WS_POPUP
Definition: pedump.c:616
MCIDEVICEID wDevID
LPBITMAPINFOHEADER inbih
LPBITMAPINFOHEADER outbih
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
BOOL WINAPI AdjustWindowRect(_Inout_ LPRECT, _In_ DWORD, _In_ BOOL)
#define CreateWindowW(a, b, c, d, e, f, g, h, i, j, k)
Definition: winuser.h:4306
#define CW_USEDEFAULT
Definition: winuser.h:225
BOOL WINAPI SetRect(_Out_ LPRECT, _In_ int, _In_ int, _In_ int, _In_ int)
static const WCHAR mciaviW[]
Definition: wnd.c:28
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by MCIAVI_mciOpen().

◆ MCIAVI_GetInfo()

BOOL MCIAVI_GetInfo ( WINE_MCIAVI wma)

Definition at line 255 of file mmoutput.c.

256{
257 MMCKINFO ckMainRIFF;
258 MMCKINFO mmckHead;
259 MMCKINFO mmckList;
260 MMCKINFO mmckInfo;
261 AVIStreamHeader strh;
262 struct AviListBuild alb;
263 DWORD stream_n;
264
265 if (mmioDescend(wma->hFile, &ckMainRIFF, NULL, 0) != 0) {
266 WARN("Can't find 'RIFF' chunk\n");
267 return FALSE;
268 }
269
270 if ((ckMainRIFF.ckid != FOURCC_RIFF) || (ckMainRIFF.fccType != formtypeAVI)) {
271 WARN("Can't find 'AVI ' chunk\n");
272 return FALSE;
273 }
274
275 mmckHead.fccType = listtypeAVIHEADER;
276 if (mmioDescend(wma->hFile, &mmckHead, &ckMainRIFF, MMIO_FINDLIST) != 0) {
277 WARN("Can't find 'hdrl' list\n");
278 return FALSE;
279 }
280
281 mmckInfo.ckid = ckidAVIMAINHDR;
282 if (mmioDescend(wma->hFile, &mmckInfo, &mmckHead, MMIO_FINDCHUNK) != 0) {
283 WARN("Can't find 'avih' chunk\n");
284 return FALSE;
285 }
286
287 mmioRead(wma->hFile, (LPSTR)&wma->mah, sizeof(wma->mah));
288
289 TRACE("mah.dwMicroSecPerFrame=%d\n", wma->mah.dwMicroSecPerFrame);
290 TRACE("mah.dwMaxBytesPerSec=%d\n", wma->mah.dwMaxBytesPerSec);
291 TRACE("mah.dwPaddingGranularity=%d\n", wma->mah.dwPaddingGranularity);
292 TRACE("mah.dwFlags=%d\n", wma->mah.dwFlags);
293 TRACE("mah.dwTotalFrames=%d\n", wma->mah.dwTotalFrames);
294 TRACE("mah.dwInitialFrames=%d\n", wma->mah.dwInitialFrames);
295 TRACE("mah.dwStreams=%d\n", wma->mah.dwStreams);
296 TRACE("mah.dwSuggestedBufferSize=%d\n", wma->mah.dwSuggestedBufferSize);
297 TRACE("mah.dwWidth=%d\n", wma->mah.dwWidth);
298 TRACE("mah.dwHeight=%d\n", wma->mah.dwHeight);
299
300 mmioAscend(wma->hFile, &mmckInfo, 0);
301
302 TRACE("Start of streams\n");
303 wma->video_stream_n = 0;
304 wma->audio_stream_n = 0;
305
306 for (stream_n = 0; stream_n < wma->mah.dwStreams; stream_n++)
307 {
308 MMCKINFO mmckStream;
309
310 mmckList.fccType = listtypeSTREAMHEADER;
311 if (mmioDescend(wma->hFile, &mmckList, &mmckHead, MMIO_FINDLIST) != 0)
312 break;
313
314 mmckStream.ckid = ckidSTREAMHEADER;
315 if (mmioDescend(wma->hFile, &mmckStream, &mmckList, MMIO_FINDCHUNK) != 0)
316 {
317 WARN("Can't find 'strh' chunk\n");
318 continue;
319 }
320
321 mmioRead(wma->hFile, (LPSTR)&strh, sizeof(strh));
322
323 TRACE("Stream #%d fccType %4.4s\n", stream_n, (LPSTR)&strh.fccType);
324
325 if (strh.fccType == streamtypeVIDEO)
326 {
327 TRACE("found video stream\n");
328 if (wma->inbih)
329 WARN("ignoring another video stream\n");
330 else
331 {
332 wma->ash_video = strh;
333
334 if (!MCIAVI_GetInfoVideo(wma, &mmckList, &mmckStream))
335 return FALSE;
336 wma->video_stream_n = stream_n;
337 wma->dwSet |= 4;
338 }
339 }
340 else if (strh.fccType == streamtypeAUDIO)
341 {
342 TRACE("found audio stream\n");
343 if (wma->lpWaveFormat)
344 WARN("ignoring another audio stream\n");
345 else
346 {
347 wma->ash_audio = strh;
348
349 if (!MCIAVI_GetInfoAudio(wma, &mmckList, &mmckStream))
350 return FALSE;
351 wma->audio_stream_n = stream_n;
352 wma->dwSet |= 3;
353 }
354 }
355 else
356 TRACE("Unsupported stream type %4.4s\n", (LPSTR)&strh.fccType);
357
358 mmioAscend(wma->hFile, &mmckList, 0);
359 }
360
361 TRACE("End of streams\n");
362
363 mmioAscend(wma->hFile, &mmckHead, 0);
364
365 /* no need to read optional JUNK chunk */
366
367 mmckList.fccType = listtypeAVIMOVIE;
368 if (mmioDescend(wma->hFile, &mmckList, &ckMainRIFF, MMIO_FINDLIST) != 0) {
369 WARN("Can't find 'movi' list\n");
370 return FALSE;
371 }
372
375 wma->dwPlayableVideoFrames * sizeof(struct MMIOPos));
376 if (!wma->lpVideoIndex) {
377 WARN("Can't alloc video index array\n");
378 return FALSE;
379 }
380 wma->dwPlayableAudioBlocks = 0;
381 wma->lpAudioIndex = NULL;
382
383 alb.numAudioBlocks = alb.numVideoFrames = 0;
384 alb.inVideoSize = alb.inAudioSize = 0;
385 alb.numAudioAllocated = 0;
386
387 while (mmioDescend(wma->hFile, &mmckInfo, &mmckList, 0) == 0) {
388 if (mmckInfo.fccType == listtypeAVIRECORD) {
389 MMCKINFO tmp;
390
391 while (mmioDescend(wma->hFile, &tmp, &mmckInfo, 0) == 0) {
392 MCIAVI_AddFrame(wma, &tmp, &alb);
393 mmioAscend(wma->hFile, &tmp, 0);
394 }
395 } else {
396 MCIAVI_AddFrame(wma, &mmckInfo, &alb);
397 }
398
399 mmioAscend(wma->hFile, &mmckInfo, 0);
400 }
401 if (alb.numVideoFrames != wma->dwPlayableVideoFrames) {
402 WARN("AVI header says %d frames, we found %d video frames, reducing playable frames\n",
403 wma->dwPlayableVideoFrames, alb.numVideoFrames);
404 wma->dwPlayableVideoFrames = alb.numVideoFrames;
405 }
406 wma->dwPlayableAudioBlocks = alb.numAudioBlocks;
407
408 if (alb.inVideoSize > wma->ash_video.dwSuggestedBufferSize) {
409 WARN("inVideoSize=%d suggestedSize=%d\n", alb.inVideoSize, wma->ash_video.dwSuggestedBufferSize);
410 wma->ash_video.dwSuggestedBufferSize = alb.inVideoSize;
411 }
412 if (alb.inAudioSize > wma->ash_audio.dwSuggestedBufferSize) {
413 WARN("inAudioSize=%d suggestedSize=%d\n", alb.inAudioSize, wma->ash_audio.dwSuggestedBufferSize);
414 wma->ash_audio.dwSuggestedBufferSize = alb.inAudioSize;
415 }
416
418 if (!wma->indata) {
419 WARN("Can't alloc input buffer\n");
420 return FALSE;
421 }
422
423 return TRUE;
424}
#define streamtypeAUDIO
Definition: aviriff.h:93
#define streamtypeVIDEO
Definition: aviriff.h:92
#define ckidSTREAMHEADER
Definition: aviriff.h:88
#define NULL
Definition: types.h:112
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
MMRESULT WINAPI mmioAscend(HMMIO hmmio, LPMMCKINFO lpck, UINT uFlags)
Definition: mmio.c:1204
MMRESULT WINAPI mmioDescend(HMMIO hmmio, LPMMCKINFO lpck, const MMCKINFO *lpckParent, UINT uFlags)
Definition: mmio.c:1106
LONG WINAPI mmioRead(HMMIO hmmio, HPSTR pch, LONG cch)
Definition: mmio.c:732
static BOOL MCIAVI_AddFrame(WINE_MCIAVI *wma, LPMMCKINFO mmck, struct AviListBuild *alb)
Definition: mmoutput.c:157
static BOOL MCIAVI_GetInfoAudio(WINE_MCIAVI *wma, const MMCKINFO *mmckList, MMCKINFO *mmckStream)
Definition: mmoutput.c:27
static BOOL MCIAVI_GetInfoVideo(WINE_MCIAVI *wma, const MMCKINFO *mmckList, MMCKINFO *mmckStream)
Definition: mmoutput.c:88
#define FOURCC_RIFF
Definition: mmsystem.h:564
#define MMIO_FINDCHUNK
Definition: mmsystem.h:551
#define MMIO_FINDLIST
Definition: mmsystem.h:553
FOURCC fccType
Definition: vfw.h:959
DWORD dwSuggestedBufferSize
Definition: vfw.h:969
LPWAVEFORMATEX lpWaveFormat
DWORD audio_stream_n
AVIStreamHeader ash_audio
DWORD video_stream_n
struct MMIOPos * lpVideoIndex
DWORD dwPlayableVideoFrames
struct MMIOPos * lpAudioIndex
DWORD dwPlayableAudioBlocks
AVIStreamHeader ash_video
FOURCC ckid
Definition: mmsystem.h:1507
FOURCC fccType
Definition: mmsystem.h:1509
DWORD dwWidth
Definition: vfw.h:949
DWORD dwSuggestedBufferSize
Definition: vfw.h:948
DWORD dwHeight
Definition: vfw.h:950
DWORD dwPaddingGranularity
Definition: vfw.h:943
DWORD dwStreams
Definition: vfw.h:947
DWORD dwMaxBytesPerSec
Definition: vfw.h:942
DWORD dwInitialFrames
Definition: vfw.h:946
DWORD dwFlags
Definition: vfw.h:944
DWORD dwTotalFrames
Definition: vfw.h:945
#define listtypeAVIMOVIE
Definition: vfw.h:898
#define listtypeSTREAMHEADER
Definition: vfw.h:892
#define listtypeAVIRECORD
Definition: vfw.h:899
#define listtypeAVIHEADER
Definition: vfw.h:890
#define ckidAVIMAINHDR
Definition: vfw.h:891
#define formtypeAVI
Definition: vfw.h:889
char * LPSTR
Definition: xmlstorage.h:182

Referenced by MCIAVI_mciOpen().

◆ MCIAVI_mciClose()

DWORD MCIAVI_mciClose ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_GENERIC_PARMS  lpParms 
)

Definition at line 305 of file mciavi.c.

306{
307 WINE_MCIAVI *wma;
308 DWORD dwRet = 0;
309
310 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
311
312 wma = MCIAVI_mciGetOpenDev(wDevID);
313 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
314
315 MCIAVI_mciStop(wDevID, MCI_WAIT, NULL);
316
318
319 if (wma->nUseCount == 1) {
320 MCIAVI_CleanUp(wma);
321
322 if ((dwFlags & MCI_NOTIFY) && lpParms) {
324 wDevID,
326 }
328 return dwRet;
329 }
330 wma->nUseCount--;
331
333 return dwRet;
334}
BOOL WINAPI mciDriverNotify(HWND hwndCallback, UINT uDeviceID, UINT uStatus)
Definition: mci.c:2223
static void MCIAVI_CleanUp(WINE_MCIAVI *wma)
Definition: mciavi.c:168
static DWORD MCIAVI_mciStop(UINT, DWORD, LPMCI_GENERIC_PARMS)
Definition: mciavi.c:636
WINE_MCIAVI * MCIAVI_mciGetOpenDev(UINT wDevID)
Definition: mciavi.c:157
#define MCI_NOTIFY
Definition: mmsystem.h:729
#define MCIERR_INVALID_DEVICE_ID
Definition: mmsystem.h:569
#define MCI_WAIT
Definition: mmsystem.h:730
#define MCI_NOTIFY_SUCCESSFUL
Definition: mmsystem.h:725
#define LOWORD(l)
Definition: pedump.c:82
CRITICAL_SECTION cs
DWORD_PTR dwCallback
Definition: mmsystem.h:1517
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
#define HWND_32(h16)
Definition: wownt32.h:29

Referenced by MCIAVI_DriverProc(), MCIAVI_drvClose(), and MCIAVI_WindowProc().

◆ MCIAVI_mciGetDevCaps()

DWORD MCIAVI_mciGetDevCaps ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_GETDEVCAPS_PARMS  lpParms 
)

Definition at line 73 of file info.c.

74{
75 WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
77
78 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
79
80 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
81 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
83 if (dwFlags & MCI_TEST) return 0;
84
86
88 switch (lpParms->dwItem) {
90 TRACE("MCI_GETDEVCAPS_DEVICE_TYPE !\n");
93 break;
95 TRACE("MCI_GETDEVCAPS_HAS_AUDIO !\n");
98 break;
100 TRACE("MCI_GETDEVCAPS_HAS_VIDEO !\n");
103 break;
105 TRACE("MCI_GETDEVCAPS_USES_FILES !\n");
108 break;
110 TRACE("MCI_GETDEVCAPS_COMPOUND_DEVICE !\n");
113 break;
115 TRACE("MCI_GETDEVCAPS_CAN_EJECT !\n");
118 break;
120 TRACE("MCI_GETDEVCAPS_CAN_PLAY !\n");
123 break;
125 TRACE("MCI_GETDEVCAPS_CAN_RECORD !\n");
128 break;
130 TRACE("MCI_GETDEVCAPS_CAN_SAVE !\n");
133 break;
135 TRACE("MCI_DGV_GETDEVCAPS_CAN_REVERSE !\n");
136 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
138 break;
140 TRACE("MCI_DGV_GETDEVCAPS_CAN_STRETCH !\n");
141 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
143 break;
145 TRACE("MCI_DGV_GETDEVCAPS_CAN_LOCK !\n");
148 break;
150 TRACE("MCI_DGV_GETDEVCAPS_CAN_FREEZE !\n");
153 break;
155 TRACE("MCI_DGV_GETDEVCAPS_CAN_STRETCH_INPUT !\n");
158 break;
160 TRACE("MCI_DGV_GETDEVCAPS_HAS_STILL !\n");
163 break;
165 TRACE("MCI_DGV_GETDEVCAPS_CAN_TEST !\n");
168 break;
170 TRACE("MCI_DGV_GETDEVCAPS_PALETTES !\n");
171 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
173 break;
174 /* w2k does not know MAX_WINDOWS or MAX/MINIMUM_RATE */
175 default:
176 FIXME("Unknown capability (%08x) !\n", lpParms->dwItem);
177 break;
178 }
179 }
180
182 return ret;
183}
#define FIXME(fmt,...)
Definition: debug.h:111
#define MCI_DGV_GETDEVCAPS_HAS_STILL
Definition: digitalv.h:121
#define MCI_DGV_GETDEVCAPS_PALETTES
Definition: digitalv.h:122
#define MCI_DGV_GETDEVCAPS_CAN_STRETCH
Definition: digitalv.h:117
#define MCI_DGV_GETDEVCAPS_CAN_LOCK
Definition: digitalv.h:116
#define MCI_DGV_GETDEVCAPS_CAN_STR_IN
Definition: digitalv.h:123
#define MCI_DGV_GETDEVCAPS_CAN_TEST
Definition: digitalv.h:124
#define MCI_DGV_GETDEVCAPS_CAN_REVERSE
Definition: digitalv.h:120
#define MCI_DGV_GETDEVCAPS_CAN_FREEZE
Definition: digitalv.h:118
#define MCI_TEST
Definition: digitalv.h:32
#define MAKEMCIRESOURCE(wRet, wRes)
Definition: mmddk.h:388
#define MCI_FALSE
Definition: mmddk.h:340
#define MCI_TRUE
Definition: mmddk.h:341
#define MCI_RESOURCE_RETURNED
Definition: mmddk.h:369
#define MCI_GETDEVCAPS_CAN_SAVE
Definition: mmsystem.h:767
#define MCI_GETDEVCAPS_HAS_VIDEO
Definition: mmsystem.h:761
#define MCI_GETDEVCAPS_CAN_RECORD
Definition: mmsystem.h:759
#define MCI_GETDEVCAPS_DEVICE_TYPE
Definition: mmsystem.h:762
#define MCI_GETDEVCAPS_COMPOUND_DEVICE
Definition: mmsystem.h:764
#define MCI_GETDEVCAPS_USES_FILES
Definition: mmsystem.h:763
#define MCI_GETDEVCAPS_CAN_PLAY
Definition: mmsystem.h:766
#define MCI_GETDEVCAPS_CAN_EJECT
Definition: mmsystem.h:765
#define MCIERR_MISSING_PARAMETER
Definition: mmsystem.h:583
#define MCIERR_NULL_PARAMETER_BLOCK
Definition: mmsystem.h:605
#define MCI_DEVTYPE_DIGITAL_VIDEO
Definition: mmsystem.h:687
#define MCI_GETDEVCAPS_ITEM
Definition: mmsystem.h:758
#define MCIERR_UNSUPPORTED_FUNCTION
Definition: mmsystem.h:584
#define MCI_GETDEVCAPS_HAS_AUDIO
Definition: mmsystem.h:760

Referenced by MCIAVI_DriverProc().

◆ MCIAVI_mciGetOpenDev()

◆ MCIAVI_mciInfo()

DWORD MCIAVI_mciInfo ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_DGV_INFO_PARMSW  lpParms 
)

Definition at line 188 of file info.c.

189{
190 LPCWSTR str = 0;
191 WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
192 DWORD ret = 0;
193 static const WCHAR wszAviPlayer[] = {'W','i','n','e','\'','s',' ','A','V','I',' ','p','l','a','y','e','r',0};
194 static const WCHAR wszVersion[] = {'1','.','1',0};
195
196 if (lpParms == NULL || lpParms->lpstrReturn == NULL)
198 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
199 if (dwFlags & MCI_TEST) return 0;
200
201 TRACE("buf=%p, len=%u\n", lpParms->lpstrReturn, lpParms->dwRetSize);
202
204
206 str = wszAviPlayer;
207 else if (dwFlags & MCI_INFO_VERSION)
208 str = wszVersion;
209 else if (dwFlags & MCI_INFO_FILE)
210 str = wma->lpFileName;
211 else {
212 WARN("Don't know this info command (%u)\n", dwFlags);
214 }
215 if (!ret) {
216 WCHAR zero = 0;
217 /* Only mciwave, mciseq and mcicda set dwRetSize (since NT). */
218 lstrcpynW(lpParms->lpstrReturn, str ? str : &zero, lpParms->dwRetSize);
219 }
221 return ret;
222}
#define MCI_INFO_VERSION
Definition: digitalv.h:169
#define lstrcpynW
Definition: compat.h:738
#define MCI_INFO_PRODUCT
Definition: mmsystem.h:752
#define MCIERR_UNRECOGNIZED_COMMAND
Definition: mmsystem.h:571
#define MCI_INFO_FILE
Definition: mmsystem.h:753
const WCHAR * str
int zero
Definition: sehframes.cpp:29
LPWSTR lpFileName
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185

Referenced by MCIAVI_DriverProc().

◆ MCIAVI_mciPut()

DWORD MCIAVI_mciPut ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_DGV_PUT_PARMS  lpParms 
)

Definition at line 153 of file wnd.c.

154{
155 WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
156 RECT rc;
157
158 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
159
160 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
161 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
162 if (dwFlags & MCI_TEST) return 0;
163
165
166 if (dwFlags & MCI_DGV_RECT) {
167 /* In MCI, RECT structure is used differently: rc.right = width & rc.bottom = height
168 * So convert input MCI RECT into a normal RECT */
169 SetRect(&rc, lpParms->rc.left, lpParms->rc.top, lpParms->rc.left + lpParms->rc.right,
170 lpParms->rc.top + lpParms->rc.bottom);
171 } else {
172 GetClientRect(wma->hWndPaint, &rc);
173 }
174
176 FIXME("PUT_CLIENT %s\n", wine_dbgstr_rect(&rc));
179 }
181 TRACE("PUT_DESTINATION %s\n", wine_dbgstr_rect(&rc));
182 wma->dest = rc;
183 }
185 FIXME("PUT_FRAME %s\n", wine_dbgstr_rect(&rc));
188 }
190 TRACE("PUT_SOURCE %s\n", wine_dbgstr_rect(&rc));
191 wma->source = rc;
192 }
194 FIXME("PUT_VIDEO %s\n", wine_dbgstr_rect(&rc));
197 }
199 TRACE("PUT_WINDOW %s\n", wine_dbgstr_rect(&rc));
200 SetWindowPos(wma->hWndPaint, NULL, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, SWP_NOZORDER);
201 }
203 return 0;
204}
#define MCI_DGV_PUT_DESTINATION
Definition: digitalv.h:234
#define MCI_DGV_PUT_SOURCE
Definition: digitalv.h:233
#define MCI_DGV_PUT_WINDOW
Definition: digitalv.h:237
#define MCI_DGV_RECT
Definition: digitalv.h:232
#define MCI_DGV_PUT_CLIENT
Definition: digitalv.h:238
#define MCI_DGV_PUT_VIDEO
Definition: digitalv.h:236
#define MCI_DGV_PUT_FRAME
Definition: digitalv.h:235
static __inline const char * wine_dbgstr_rect(const RECT *rect)
Definition: debug.h:219
BOOL WINAPI SetWindowPos(_In_ HWND, _In_opt_ HWND, _In_ int, _In_ int, _In_ int, _In_ int, _In_ UINT)
BOOL WINAPI GetClientRect(_In_ HWND, _Out_ LPRECT)
#define SWP_NOZORDER
Definition: winuser.h:1237

Referenced by MCIAVI_DriverProc().

◆ MCIAVI_mciSet()

DWORD MCIAVI_mciSet ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_DGV_SET_PARMS  lpParms 
)

Definition at line 227 of file info.c.

228{
229 WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
230
231 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
232 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
233 if (dwFlags & MCI_TEST) return 0;
234
236
238 switch (lpParms->dwTimeFormat) {
240 TRACE("MCI_FORMAT_MILLISECONDS !\n");
242 break;
244 TRACE("MCI_FORMAT_FRAMES !\n");
246 break;
247 default:
248 WARN("Bad time format %u!\n", lpParms->dwTimeFormat);
251 }
252 }
253
255 TRACE("No support for door open !\n");
258 }
260 TRACE("No support for door close !\n");
263 }
264
265 if (dwFlags & MCI_SET_ON) {
266 const char *szVideo="";
267 const char *szAudio="";
268 const char *szSeek="";
269
270 if (dwFlags & MCI_SET_VIDEO) {
271 szVideo = " video";
272 wma->dwSet |= 4;
273 }
274 if (dwFlags & MCI_SET_AUDIO) {
275 switch (lpParms->dwAudio) {
277 szAudio = " audio all";
278 wma->dwSet |= 3;
279 break;
281 szAudio = " audio left";
282 wma->dwSet |= 1;
283 break;
285 szAudio = " audio right";
286 wma->dwSet |= 2;
287 break;
288 default:
289 szAudio = " audio unknown";
290 WARN("Unknown audio channel %u\n", lpParms->dwAudio);
291 break;
292 }
293 }
295 szSeek = " seek_exactly";
296 }
297 FIXME("MCI_SET_ON:%s%s%s\n", szVideo, szAudio, szSeek);
298 }
299
300 if (dwFlags & MCI_SET_OFF) {
301 const char *szVideo="";
302 const char *szAudio="";
303 const char *szSeek="";
304
305 if (dwFlags & MCI_SET_VIDEO) {
306 szVideo = " video";
307 wma->dwSet &= ~4;
308 }
309 if (dwFlags & MCI_SET_AUDIO) {
310 switch (lpParms->dwAudio) {
312 szAudio = " audio all";
313 wma->dwSet &= ~3;
314 break;
316 szAudio = " audio left";
317 wma->dwSet &= ~2;
318 break;
320 szAudio = " audio right";
321 wma->dwSet &= ~2;
322 break;
323 default:
324 szAudio = " audio unknown";
325 WARN("Unknown audio channel %u\n", lpParms->dwAudio);
326 break;
327 }
328 }
330 szSeek = " seek_exactly";
331 }
332 FIXME("MCI_SET_OFF:%s%s%s\n", szVideo, szAudio, szSeek);
333 }
335 LPCSTR str = "save";
337 str = "capture";
338
339 switch (lpParms->dwFileFormat) {
340 case MCI_DGV_FF_AVI: FIXME("Setting file format (%s) to 'AVI'\n", str); break;
341 case MCI_DGV_FF_AVSS: FIXME("Setting file format (%s) to 'AVSS'\n", str); break;
342 case MCI_DGV_FF_DIB: FIXME("Setting file format (%s) to 'DIB'\n", str); break;
343 case MCI_DGV_FF_JFIF: FIXME("Setting file format (%s) to 'JFIF'\n", str); break;
344 case MCI_DGV_FF_JPEG: FIXME("Setting file format (%s) to 'JPEG'\n", str); break;
345 case MCI_DGV_FF_MPEG: FIXME("Setting file format (%s) to 'MPEG'\n", str); break;
346 case MCI_DGV_FF_RDIB: FIXME("Setting file format (%s) to 'RLE DIB'\n", str); break;
347 case MCI_DGV_FF_RJPEG: FIXME("Setting file format (%s) to 'RJPEG'\n", str); break;
348 default: FIXME("Setting unknown file format (%s): %d\n", str, lpParms->dwFileFormat);
349 }
350 }
351
353 FIXME("Setting speed to %d\n", lpParms->dwSpeed);
354 }
355
357 return 0;
358}
#define MCI_DGV_FF_JFIF
Definition: digitalv.h:111
#define MCI_DGV_FF_AVSS
Definition: digitalv.h:105
#define MCI_DGV_FF_AVI
Definition: digitalv.h:106
#define MCI_DGV_SET_SEEK_EXACTLY
Definition: digitalv.h:282
#define MCI_DGV_FF_RDIB
Definition: digitalv.h:108
#define MCI_DGV_FF_MPEG
Definition: digitalv.h:112
#define MCI_DGV_SET_FILEFORMAT
Definition: digitalv.h:285
#define MCI_DGV_FF_DIB
Definition: digitalv.h:107
#define MCI_DGV_SET_SPEED
Definition: digitalv.h:283
#define MCI_DGV_FF_RJPEG
Definition: digitalv.h:110
#define MCI_DGV_SET_STILL
Definition: digitalv.h:284
#define MCI_DGV_FF_JPEG
Definition: digitalv.h:109
#define MCI_SET_AUDIO
Definition: mmsystem.h:775
#define MCI_SET_DOOR_OPEN
Definition: mmsystem.h:772
#define MCI_SET_TIME_FORMAT
Definition: mmsystem.h:774
#define MCI_SET_VIDEO
Definition: mmsystem.h:776
#define MCI_SET_AUDIO_RIGHT
Definition: mmsystem.h:781
#define MCI_SET_AUDIO_ALL
Definition: mmsystem.h:779
#define MCI_SET_DOOR_CLOSED
Definition: mmsystem.h:773
#define MCI_SET_AUDIO_LEFT
Definition: mmsystem.h:780
#define MCI_SET_OFF
Definition: mmsystem.h:778
#define MCIERR_BAD_TIME_FORMAT
Definition: mmsystem.h:601
#define MCI_SET_ON
Definition: mmsystem.h:777
DWORD dwTimeFormat
Definition: digitalv.h:733
DWORD dwFileFormat
Definition: digitalv.h:735
const char * LPCSTR
Definition: xmlstorage.h:183

Referenced by MCIAVI_DriverProc().

◆ MCIAVI_mciStatus()

DWORD MCIAVI_mciStatus ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_DGV_STATUS_PARMSW  lpParms 
)

Definition at line 363 of file info.c.

364{
365 WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
366 DWORD ret = 0;
367
368 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
369 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
371 if (dwFlags & MCI_TEST) return 0;
372
374
375 if (dwFlags & MCI_STATUS_ITEM) {
376 switch (lpParms->dwItem) {
378 lpParms->dwReturn = 1;
379 TRACE("MCI_STATUS_CURRENT_TRACK => %lu\n", lpParms->dwReturn);
380 break;
382 if (!wma->hFile) {
383 lpParms->dwReturn = 0;
386 }
387 /* only one track in file is currently handled, so don't take care of MCI_TRACK flag */
389 TRACE("MCI_STATUS_LENGTH => %lu\n", lpParms->dwReturn);
390 break;
391 case MCI_STATUS_MODE:
392 lpParms->dwReturn = MAKEMCIRESOURCE(wma->dwStatus, wma->dwStatus);
394 TRACE("MCI_STATUS_MODE => 0x%04x\n", LOWORD(lpParms->dwReturn));
395 break;
397 TRACE("MCI_STATUS_MEDIA_PRESENT => TRUE\n");
400 break;
402 lpParms->dwReturn = 1;
403 TRACE("MCI_STATUS_NUMBER_OF_TRACKS => %lu\n", lpParms->dwReturn);
404 break;
406 if (!wma->hFile) {
407 lpParms->dwReturn = 0;
410 }
411 /* only one track in file is currently handled, so don't take care of MCI_TRACK flag */
414 &ret);
415 TRACE("MCI_STATUS_POSITION %s => %lu\n",
416 (dwFlags & MCI_STATUS_START) ? "start" : "current", lpParms->dwReturn);
417 break;
418 case MCI_STATUS_READY:
419 lpParms->dwReturn = (wma->dwStatus == MCI_MODE_NOT_READY) ?
422 TRACE("MCI_STATUS_READY = %u\n", LOWORD(lpParms->dwReturn));
423 break;
427 TRACE("MCI_STATUS_TIME_FORMAT => %u\n", LOWORD(lpParms->dwReturn));
429 break;
431 lpParms->dwReturn = (wma->dwSet & 3) ?
434 TRACE("MCI_STATUS_AUDIO = %u\n", LOWORD(lpParms->dwReturn));
435 break;
437 lpParms->dwReturn = (wma->dwSet & 4) ?
440 TRACE("MCI_STATUS_VIDEO = %u\n", LOWORD(lpParms->dwReturn));
441 break;
442
443#if 0
461#endif
463 lpParms->dwReturn = wma->inbih->biBitCount;
464 TRACE("MCI_DGV_STATUS_BITSPERPEL => %lu\n", lpParms->dwReturn);
465 break;
467 lpParms->dwReturn = 0;
468 TRACE("MCI_DGV_STATUS_HPAL => %lx\n", lpParms->dwReturn);
469 break;
471 lpParms->dwReturn = (DWORD_PTR)wma->hWndPaint;
472 TRACE("MCI_DGV_STATUS_HWND => %p\n", wma->hWndPaint);
473 break;
475 lpParms->dwReturn = IsWindowVisible(wma->hWndPaint) ?
478 TRACE("MCI_STATUS_WINDOW_VISIBLE = %u\n", LOWORD(lpParms->dwReturn));
479 break;
481 lpParms->dwReturn = IsIconic(wma->hWndPaint) ?
484 TRACE("MCI_STATUS_WINDOW_MINIMIZED = %u\n", LOWORD(lpParms->dwReturn));
485 break;
487 lpParms->dwReturn = IsZoomed(wma->hWndPaint) ?
490 TRACE("MCI_STATUS_WINDOW_MMAXIMIZED = %u\n", LOWORD(lpParms->dwReturn));
491 break;
493 lpParms->dwReturn = 1000;
494 TRACE("MCI_DGV_STATUS_SPEED = %lu\n", lpParms->dwReturn);
495 break;
497 /* FIXME: 1000 is a settable speed multiplier */
498 lpParms->dwReturn = MulDiv(1000000,1000,wma->mah.dwMicroSecPerFrame);
499 TRACE("MCI_DGV_STATUS_FRAME_RATE = %lu\n", lpParms->dwReturn);
500 break;
504 TRACE("MCI_DGV_STATUS_FORWARD = %u\n", LOWORD(lpParms->dwReturn));
505 break;
507 if (wma->dwStatus != MCI_MODE_PAUSE) {
510 }
513 TRACE("MCI_STATUS_MODE => 0x%04x\n", LOWORD(lpParms->dwReturn));
514 break;
516 lpParms->dwReturn = wma->audio_stream_n;
517 TRACE("MCI_DGV_STATUS_AUDIO_STREAM => %lu\n", lpParms->dwReturn);
518 break;
519#if 0
526 case MCI_DGV_STATUS_SAMPLESPERSECOND:
540#endif
541 default:
542 FIXME("Unknown command %08X !\n", lpParms->dwItem);
543 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
546 }
547 }
548
549 if (dwFlags & MCI_NOTIFY) {
550 TRACE("MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback);
552 wDevID, MCI_NOTIFY_SUCCESSFUL);
553 }
555 return ret;
556}
#define MCI_DGV_STATUS_BITSPERPEL
Definition: digitalv.h:423
#define MCI_DGV_STATUS_FRAME_RATE
Definition: digitalv.h:394
#define MCI_DGV_STATUS_HPAL
Definition: digitalv.h:385
#define MCI_DGV_STATUS_BLOCKALIGN
Definition: digitalv.h:421
#define MCI_DGV_STATUS_AUDIO_RECORD
Definition: digitalv.h:406
#define MCI_DGV_STATUS_VOLUME
Definition: digitalv.h:405
#define MCI_DGV_MONITOR_INPUT
Definition: digitalv.h:206
#define MCI_DGV_STATUS_AUDIO_SOURCE
Definition: digitalv.h:390
#define MCI_DGV_STATUS_AUDIO_INPUT
Definition: digitalv.h:382
#define MCI_DGV_STATUS_SIZE
Definition: digitalv.h:396
#define MCI_DGV_STATUS_VIDEO_STREAM
Definition: digitalv.h:426
#define MCI_DGV_STATUS_BRIGHTNESS
Definition: digitalv.h:386
#define MCI_DGV_STATUS_FILEFORMAT
Definition: digitalv.h:389
#define MCI_DGV_STATUS_VIDEO_SRC_NUM
Definition: digitalv.h:410
#define MCI_DGV_STATUS_KEY_COLOR
Definition: digitalv.h:417
#define MCI_DGV_STATUS_TINT
Definition: digitalv.h:401
#define MCI_DGV_STATUS_WINDOW_VISIBLE
Definition: digitalv.h:413
#define MCI_DGV_STATUS_HWND
Definition: digitalv.h:383
#define MCI_DGV_STATUS_TREBLE
Definition: digitalv.h:402
#define MCI_DGV_STATUS_STILL_FILEFORMAT
Definition: digitalv.h:409
#define MCI_DGV_STATUS_PAUSE_MODE
Definition: digitalv.h:418
#define MCI_DGV_MONITOR_FILE
Definition: digitalv.h:207
#define MCI_DGV_STATUS_WINDOW_MAXIMIZED
Definition: digitalv.h:415
#define MCI_DGV_STATUS_FILE_COMPLETION
Definition: digitalv.h:412
#define MCI_OFF_S
Definition: digitalv.h:61
#define MCI_DGV_STATUS_AVGBYTESPERSEC
Definition: digitalv.h:420
#define MCI_DGV_STATUS_FILE_MODE
Definition: digitalv.h:411
#define MCI_DGV_STATUS_CONTRAST
Definition: digitalv.h:388
#define MCI_DGV_STATUS_BASS
Definition: digitalv.h:395
#define MCI_DGV_STATUS_SMPTE
Definition: digitalv.h:399
#define MCI_DGV_STATUS_BITSPERSAMPLE
Definition: digitalv.h:422
#define MCI_DGV_STATUS_AUDIO
Definition: digitalv.h:400
#define MCI_DGV_STATUS_SPEED
Definition: digitalv.h:384
#define MCI_ON
Definition: digitalv.h:50
#define MCI_DGV_STATUS_AUDIO_STREAM
Definition: digitalv.h:425
#define MCI_DGV_STATUS_VIDEO_SOURCE
Definition: digitalv.h:407
#define MCI_DGV_STATUS_KEY_INDEX
Definition: digitalv.h:416
#define MCI_DGV_STATUS_SHARPNESS
Definition: digitalv.h:398
#define MCI_DGV_STATUS_MONITOR_METHOD
Definition: digitalv.h:393
#define MCI_DGV_STATUS_FORWARD
Definition: digitalv.h:424
#define MCI_DGV_STATUS_SEEK_EXACTLY
Definition: digitalv.h:397
#define MCI_DGV_STATUS_GAMMA
Definition: digitalv.h:391
#define MCI_DGV_STATUS_VIDEO
Definition: digitalv.h:404
#define MCI_OFF
Definition: digitalv.h:51
#define MCI_ON_S
Definition: digitalv.h:60
#define MCI_DGV_STATUS_UNSAVED
Definition: digitalv.h:403
#define MCI_DGV_STATUS_VIDEO_RECORD
Definition: digitalv.h:408
#define MCI_DGV_STATUS_MONITOR
Definition: digitalv.h:392
#define MCI_DGV_STATUS_WINDOW_MINIMIZED
Definition: digitalv.h:414
#define MCI_DGV_STATUS_COLOR
Definition: digitalv.h:387
static DWORD MCIAVI_ConvertFrameToTimeFormat(WINE_MCIAVI *wma, DWORD val, LPDWORD lpRet)
Definition: info.c:30
#define MCI_FORMAT_RETURN_BASE
Definition: mmddk.h:343
#define MCI_RESOURCE_DRIVER
Definition: mmddk.h:373
#define MCI_AVI_STATUS_AUDIO_BREAKS
Definition: mciavi.h:9
#define MCI_AVI_STATUS_FRAMES_SKIPPED
Definition: mciavi.h:7
#define MCI_AVI_STATUS_LAST_PLAY_SPEED
Definition: mciavi.h:8
#define MCI_STATUS_POSITION
Definition: mmsystem.h:745
#define MCI_MODE_PLAY
Definition: mmsystem.h:696
#define MCI_STATUS_START
Definition: mmsystem.h:743
#define MCI_STATUS_CURRENT_TRACK
Definition: mmsystem.h:751
#define MCI_STATUS_NUMBER_OF_TRACKS
Definition: mmsystem.h:746
#define MCI_STATUS_LENGTH
Definition: mmsystem.h:744
#define MCI_STATUS_MODE
Definition: mmsystem.h:747
#define MCI_MODE_NOT_READY
Definition: mmsystem.h:694
#define MCI_STATUS_MEDIA_PRESENT
Definition: mmsystem.h:748
#define MCI_MODE_PAUSE
Definition: mmsystem.h:699
#define MCIERR_NONAPPLICABLE_FUNCTION
Definition: mmsystem.h:610
#define MCI_STATUS_TIME_FORMAT
Definition: mmsystem.h:749
#define MCI_STATUS_ITEM
Definition: mmsystem.h:742
#define MCI_STATUS_READY
Definition: mmsystem.h:750
INT WINAPI MulDiv(INT nNumber, INT nNumerator, INT nDenominator)
Definition: muldiv.c:25
DWORD_PTR dwReturn
Definition: digitalv.h:809
DWORD_PTR dwCallback
Definition: digitalv.h:808
DWORD dwCurrVideoFrame
#define DWORD_PTR
Definition: treelist.c:76
BOOL WINAPI IsIconic(_In_ HWND)
BOOL WINAPI IsZoomed(_In_ HWND)
BOOL WINAPI IsWindowVisible(_In_ HWND)

Referenced by MCIAVI_DriverProc().

◆ MCIAVI_mciWhere()

DWORD MCIAVI_mciWhere ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_DGV_RECT_PARMS  lpParms 
)

Definition at line 209 of file wnd.c.

210{
211 WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
212 RECT rc;
213
214 TRACE("(%04x, %08x, %p)\n", wDevID, dwFlags, lpParms);
215
216 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
217 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
218 /* Ignore MCI_TEST flag. */
219
221
224 GetClientRect(wma->hWndPaint, &rc);
225 TRACE("WHERE_DESTINATION_MAX %s\n", wine_dbgstr_rect(&rc));
226 } else {
227 TRACE("WHERE_DESTINATION %s\n", wine_dbgstr_rect(&wma->dest));
228 rc = wma->dest;
229 }
230 }
233 FIXME("MCI_DGV_WHERE_FRAME_MAX\n");
234 else
235 FIXME("MCI_DGV_WHERE_FRAME\n");
238 }
241 SetRect(&rc, 0, 0, wma->inbih->biWidth, wma->inbih->biHeight);
242 TRACE("WHERE_SOURCE_MAX %s\n", wine_dbgstr_rect(&rc));
243 } else {
244 TRACE("WHERE_SOURCE %s\n", wine_dbgstr_rect(&wma->source));
245 rc = wma->source;
246 }
247 }
250 FIXME("WHERE_VIDEO_MAX\n");
251 else
252 FIXME("WHERE_VIDEO\n");
255 }
259 TRACE("WHERE_WINDOW_MAX %s\n", wine_dbgstr_rect(&rc));
260 } else {
261 GetWindowRect(wma->hWndPaint, &rc);
262 TRACE("WHERE_WINDOW %s\n", wine_dbgstr_rect(&rc));
263 }
264 }
265
266 /* In MCI, RECT structure is used differently: rc.right = width & rc.bottom = height
267 * So convert the normal RECT into a MCI RECT before returning */
268 SetRect(&lpParms->rc, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top);
269
271 return 0;
272}
#define MCI_DGV_WHERE_WINDOW
Definition: digitalv.h:448
#define MCI_DGV_WHERE_FRAME
Definition: digitalv.h:446
#define MCI_DGV_WHERE_VIDEO
Definition: digitalv.h:447
#define MCI_DGV_WHERE_SOURCE
Definition: digitalv.h:444
#define MCI_DGV_WHERE_MAX
Definition: digitalv.h:449
#define MCI_DGV_WHERE_DESTINATION
Definition: digitalv.h:445
BOOL WINAPI GetWindowRect(_In_ HWND, _Out_ LPRECT)
HWND WINAPI GetDesktopWindow(void)
Definition: window.c:656

Referenced by MCIAVI_DriverProc().

◆ MCIAVI_mciWindow()

DWORD MCIAVI_mciWindow ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_DGV_WINDOW_PARMSW  lpParms 
)

Definition at line 277 of file wnd.c.

278{
279 WINE_MCIAVI* wma = MCIAVI_mciGetOpenDev(wDevID);
280
281 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
282
283 if (lpParms == NULL) return MCIERR_NULL_PARAMETER_BLOCK;
284 if (wma == NULL) return MCIERR_INVALID_DEVICE_ID;
285 if (dwFlags & MCI_TEST) return 0;
286
288
290 if (IsWindow(lpParms->hWnd))
291 {
292 TRACE("Setting hWnd to %p\n", lpParms->hWnd);
293 if (wma->hWnd) ShowWindow(wma->hWnd, SW_HIDE);
294 wma->hWndPaint = (lpParms->hWnd == MCI_DGV_WINDOW_DEFAULT) ? wma->hWnd : lpParms->hWnd;
295 }
296 }
298 TRACE("Setting nCmdShow to %d\n", lpParms->nCmdShow);
299 ShowWindow(wma->hWndPaint, lpParms->nCmdShow);
300 }
302 TRACE("Setting caption to %s\n", debugstr_w(lpParms->lpstrText));
303 SetWindowTextW(wma->hWndPaint, lpParms->lpstrText);
304 }
305
307 return 0;
308}
#define MCI_DGV_WINDOW_STATE
Definition: digitalv.h:454
#define MCI_DGV_WINDOW_DEFAULT
Definition: digitalv.h:459
#define MCI_DGV_WINDOW_TEXT
Definition: digitalv.h:455
#define MCI_DGV_WINDOW_HWND
Definition: digitalv.h:453
#define debugstr_w
Definition: kernel32.h:32
BOOL WINAPI IsWindow(_In_opt_ HWND)
#define SW_HIDE
Definition: winuser.h:762
BOOL WINAPI ShowWindow(_In_ HWND, _In_ int)
BOOL WINAPI SetWindowTextW(_In_ HWND, _In_opt_ LPCWSTR)

Referenced by MCIAVI_DriverProc().

◆ MCIAVI_OpenAudio()

DWORD MCIAVI_OpenAudio ( WINE_MCIAVI wma,
unsigned nHdr,
LPWAVEHDR pWaveHdr 
)

Definition at line 525 of file mmoutput.c.

526{
527 DWORD dwRet;
528 LPWAVEHDR waveHdr;
529 unsigned i;
530
531 dwRet = waveOutOpen((HWAVEOUT *)&wma->hWave, WAVE_MAPPER, wma->lpWaveFormat,
533 if (dwRet != 0) {
534 TRACE("Can't open low level audio device %d\n", dwRet);
535 dwRet = MCIERR_DEVICE_OPEN;
536 wma->hWave = 0;
537 goto cleanUp;
538 }
539
540 /* FIXME: should set up a heuristic to compute the number of wave headers
541 * to be used...
542 */
543 *nHdr = 7;
545 *nHdr * (sizeof(WAVEHDR) + wma->ash_audio.dwSuggestedBufferSize));
546 if (!waveHdr) {
547 TRACE("Can't alloc wave headers\n");
548 dwRet = MCIERR_DEVICE_OPEN;
549 goto cleanUp;
550 }
551
552 for (i = 0; i < *nHdr; i++) {
553 /* other fields are zero:ed on allocation */
554 waveHdr[i].lpData = (char*)waveHdr +
555 *nHdr * sizeof(WAVEHDR) + i * wma->ash_audio.dwSuggestedBufferSize;
557 if (waveOutPrepareHeader(wma->hWave, &waveHdr[i], sizeof(WAVEHDR))) {
558 dwRet = MCIERR_INTERNAL;
559 goto cleanUp;
560 }
561 }
562
563 if (wma->dwCurrVideoFrame != 0 && wma->lpWaveFormat) {
564 FIXME("Should recompute dwCurrAudioBlock, except unsynchronized sound & video\n");
565 }
566 wma->dwCurrAudioBlock = 0;
567
569 wma->dwEventCount = *nHdr - 1;
570 *pWaveHdr = waveHdr;
571 cleanUp:
572 return dwRet;
573}
void cleanUp()
Definition: main.cpp:472
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
static void CALLBACK MCIAVI_waveCallback(HWAVEOUT hwo, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
Definition: mmoutput.c:500
#define WAVE_MAPPER
Definition: mmsystem.h:187
#define MCIERR_DEVICE_OPEN
Definition: mmsystem.h:575
#define MCIERR_INTERNAL
Definition: mmsystem.h:587
#define CALLBACK_FUNCTION
Definition: mmsystem.h:150
DWORD dwCurrAudioBlock
DWORD dwBufferLength
Definition: mmsystem.h:1015
LPSTR lpData
Definition: mmsystem.h:1014
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:651
uint32_t DWORD_PTR
Definition: typedefs.h:65
MMRESULT WINAPI waveOutOpen(LPHWAVEOUT lphWaveOut, UINT uDeviceID, LPCWAVEFORMATEX lpFormat, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
Definition: winmm.c:2249
UINT WINAPI waveOutPrepareHeader(HWAVEOUT hWaveOut, WAVEHDR *lpWaveOutHdr, UINT uSize)
Definition: winmm.c:2280

Referenced by MCIAVI_player().

◆ MCIAVI_OpenVideo()

BOOL MCIAVI_OpenVideo ( WINE_MCIAVI wma)

Definition at line 426 of file mmoutput.c.

427{
428 HDC hDC;
429 DWORD outSize;
430 FOURCC fcc = wma->ash_video.fccHandler;
431
432 TRACE("fcc %4.4s\n", (LPSTR)&fcc);
433
434 wma->dwCachedFrame = -1;
435
436 /* get the right handle */
437 if (fcc == mmioFOURCC('C','R','A','M')) fcc = mmioFOURCC('M','S','V','C');
438
439 /* try to get a decompressor for that type */
441 if (!wma->hic) {
442 /* check for builtin DIB compressions */
443 fcc = wma->inbih->biCompression;
444 if ((fcc == mmioFOURCC('D','I','B',' ')) ||
445 (fcc == mmioFOURCC('R','L','E',' ')) ||
446 (fcc == BI_RGB) || (fcc == BI_RLE8) ||
447 (fcc == BI_RLE4) || (fcc == BI_BITFIELDS))
448 goto paint_frame;
449
450 WARN("Can't locate codec for the file\n");
451 return FALSE;
452 }
453
454 outSize = sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD);
455
456 wma->outbih = HeapAlloc(GetProcessHeap(), 0, outSize);
457 if (!wma->outbih) {
458 WARN("Can't alloc output BIH\n");
459 return FALSE;
460 }
461 if (!ICGetDisplayFormat(wma->hic, wma->inbih, wma->outbih, 0, 0, 0)) {
462 WARN("Can't open decompressor\n");
463 return FALSE;
464 }
465
466 TRACE("bih.biSize=%d\n", wma->outbih->biSize);
467 TRACE("bih.biWidth=%d\n", wma->outbih->biWidth);
468 TRACE("bih.biHeight=%d\n", wma->outbih->biHeight);
469 TRACE("bih.biPlanes=%d\n", wma->outbih->biPlanes);
470 TRACE("bih.biBitCount=%d\n", wma->outbih->biBitCount);
471 TRACE("bih.biCompression=%x\n", wma->outbih->biCompression);
472 TRACE("bih.biSizeImage=%d\n", wma->outbih->biSizeImage);
473 TRACE("bih.biXPelsPerMeter=%d\n", wma->outbih->biXPelsPerMeter);
474 TRACE("bih.biYPelsPerMeter=%d\n", wma->outbih->biYPelsPerMeter);
475 TRACE("bih.biClrUsed=%d\n", wma->outbih->biClrUsed);
476 TRACE("bih.biClrImportant=%d\n", wma->outbih->biClrImportant);
477
479 if (!wma->outdata) {
480 WARN("Can't alloc output buffer\n");
481 return FALSE;
482 }
483
485 (DWORD_PTR)wma->inbih, (DWORD_PTR)wma->outbih) != ICERR_OK) {
486 WARN("Can't begin decompression\n");
487 return FALSE;
488 }
489
490paint_frame:
491 hDC = wma->hWndPaint ? GetDC(wma->hWndPaint) : 0;
492 if (hDC)
493 {
495 ReleaseDC(wma->hWndPaint, hDC);
496 }
497 return TRUE;
498}
static HDC hDC
Definition: 3dtext.c:33
DWORD FOURCC
Definition: dmdls.h:25
#define BI_RLE4
Definition: precomp.h:48
#define BI_RGB
Definition: precomp.h:47
ULONG RGBQUAD
Definition: precomp.h:50
double MCIAVI_PaintFrame(WINE_MCIAVI *wma, HDC hDC)
Definition: mmoutput.c:604
#define BI_BITFIELDS
Definition: mmreg.h:507
#define ICTYPE_VIDEO
Definition: mmreg.h:531
#define mmioFOURCC(c0, c1, c2, c3)
Definition: mmsystem.h:38
static HDC
Definition: imagelist.c:92
LRESULT VFWAPI ICSendMessage(HIC hic, UINT msg, DWORD_PTR lParam1, DWORD_PTR lParam2)
HIC VFWAPI ICLocate(DWORD type, DWORD handler, BITMAPINFOHEADER *in, BITMAPINFOHEADER *out, WORD mode)
Definition: msvideo_main.c:633
HIC VFWAPI ICGetDisplayFormat(HIC hic, BITMAPINFOHEADER *in, BITMAPINFOHEADER *out, int depth, int width, int height)
Definition: msvideo_main.c:699
FOURCC fccHandler
Definition: vfw.h:960
LONG biYPelsPerMeter
Definition: amvideo.idl:38
DWORD biCompression
Definition: amvideo.idl:35
DWORD biClrImportant
Definition: amvideo.idl:40
LONG biXPelsPerMeter
Definition: amvideo.idl:37
DWORD biSizeImage
Definition: amvideo.idl:36
DWORD dwCachedFrame
LPVOID outdata
#define ICMODE_DECOMPRESS
Definition: vfw.h:269
#define ICERR_OK
Definition: vfw.h:50
#define ICM_DECOMPRESS_BEGIN
Definition: vfw.h:108
#define BI_RLE8
Definition: wingdi.h:35
int WINAPI ReleaseDC(_In_opt_ HWND, _In_ HDC)
HDC WINAPI GetDC(_In_opt_ HWND)

Referenced by MCIAVI_mciOpen().

◆ MCIAVI_PaintFrame()

double MCIAVI_PaintFrame ( WINE_MCIAVI wma,
HDC  hDC 
)

Definition at line 604 of file mmoutput.c.

605{
606 void* pBitmapData;
607 LPBITMAPINFO pBitmapInfo;
608
609 if (!hDC || !wma->inbih)
610 return 0;
611
612 TRACE("Painting frame %u (cached %u)\n", wma->dwCurrVideoFrame, wma->dwCachedFrame);
613
614 if (wma->dwCurrVideoFrame != wma->dwCachedFrame)
615 {
616 if (!wma->lpVideoIndex[wma->dwCurrVideoFrame].dwOffset)
617 return 0;
618
619 if (wma->lpVideoIndex[wma->dwCurrVideoFrame].dwSize)
620 {
621 mmioSeek(wma->hFile, wma->lpVideoIndex[wma->dwCurrVideoFrame].dwOffset, SEEK_SET);
622 mmioRead(wma->hFile, wma->indata, wma->lpVideoIndex[wma->dwCurrVideoFrame].dwSize);
623
624 wma->inbih->biSizeImage = wma->lpVideoIndex[wma->dwCurrVideoFrame].dwSize;
625
626 if (wma->hic && ICDecompress(wma->hic, 0, wma->inbih, wma->indata,
627 wma->outbih, wma->outdata) != ICERR_OK)
628 {
629 WARN("Decompression error\n");
630 return 0;
631 }
632 }
633
635 }
636
637 if (wma->hic) {
638 pBitmapData = wma->outdata;
639 pBitmapInfo = (LPBITMAPINFO)wma->outbih;
640 } else {
641 pBitmapData = wma->indata;
642 pBitmapInfo = (LPBITMAPINFO)wma->inbih;
643 }
644
646 wma->dest.left, wma->dest.top,
647 wma->dest.right - wma->dest.left, wma->dest.bottom - wma->dest.top,
648 wma->source.left, wma->source.top,
649 wma->source.right - wma->source.left, wma->source.bottom - wma->source.top,
650 pBitmapData, pBitmapInfo, DIB_RGB_COLORS, SRCCOPY);
651
652 return (wma->ash_video.dwScale / (double)wma->ash_video.dwRate) * 1000000;
653}
LONG WINAPI mmioSeek(HMMIO hmmio, LONG lOffset, INT iOrigin)
Definition: mmio.c:835
#define SEEK_SET
Definition: jmemansi.c:26
DWORD VFWAPIV ICDecompress(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiFormat, LPVOID lpData, LPBITMAPINFOHEADER lpbi, LPVOID lpBits)
Definition: msvideo_main.c:827
DWORD dwScale
Definition: vfw.h:965
DWORD dwRate
Definition: vfw.h:966
#define DIB_RGB_COLORS
Definition: wingdi.h:367
struct tagBITMAPINFO * LPBITMAPINFO
#define SRCCOPY
Definition: wingdi.h:333
int WINAPI StretchDIBits(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int, _In_ int, _In_ int, _In_ int, _In_ int, _In_opt_ const VOID *, _In_ const BITMAPINFO *, _In_ UINT, _In_ DWORD)

Referenced by MCIAVI_mciUpdate(), MCIAVI_OpenVideo(), MCIAVI_player(), and MCIAVI_WindowProc().

◆ MCIAVI_PlayAudioBlocks()

void MCIAVI_PlayAudioBlocks ( WINE_MCIAVI wma,
unsigned  nHdr,
LPWAVEHDR  waveHdr 
)

Definition at line 575 of file mmoutput.c.

576{
577 if (!wma->lpAudioIndex)
578 return;
579 TRACE("%d (ec=%u)\n", wma->lpAudioIndex[wma->dwCurrAudioBlock].dwOffset, wma->dwEventCount);
580
581 /* push as many blocks as possible => audio gets priority */
582 while (wma->dwStatus != MCI_MODE_STOP && wma->dwStatus != MCI_MODE_NOT_READY &&
584 unsigned whidx = wma->dwCurrAudioBlock % nHdr;
585
586 ResetEvent(wma->hEvent);
587 if (InterlockedDecrement(&wma->dwEventCount) < 0 ||
588 !wma->lpAudioIndex[wma->dwCurrAudioBlock].dwOffset)
589 {
591 break;
592 }
593
594 mmioSeek(wma->hFile, wma->lpAudioIndex[wma->dwCurrAudioBlock].dwOffset, SEEK_SET);
595 mmioRead(wma->hFile, waveHdr[whidx].lpData, wma->lpAudioIndex[wma->dwCurrAudioBlock].dwSize);
596
597 waveHdr[whidx].dwFlags &= ~WHDR_DONE;
598 waveHdr[whidx].dwBufferLength = wma->lpAudioIndex[wma->dwCurrAudioBlock].dwSize;
599 waveOutWrite(wma->hWave, &waveHdr[whidx], sizeof(WAVEHDR));
600 wma->dwCurrAudioBlock++;
601 }
602}
#define InterlockedIncrement
Definition: armddk.h:53
#define InterlockedDecrement
Definition: armddk.h:52
#define MCI_MODE_STOP
Definition: mmsystem.h:695
DWORD dwFlags
Definition: mmsystem.h:1018
BOOL WINAPI DECLSPEC_HOTPATCH ResetEvent(IN HANDLE hEvent)
Definition: synch.c:714
UINT WINAPI waveOutWrite(HWAVEOUT hWaveOut, LPWAVEHDR lpWaveOutHdr, UINT uSize)
Definition: winmm.c:2344

Referenced by MCIAVI_player().

◆ MCIAVI_RegisterClass()

BOOL MCIAVI_RegisterClass ( void  )

Definition at line 93 of file wnd.c.

94{
95 WNDCLASSW wndClass;
96
97 ZeroMemory(&wndClass, sizeof(WNDCLASSW));
98 wndClass.style = CS_DBLCLKS;
100 wndClass.cbWndExtra = sizeof(MCIDEVICEID);
101 wndClass.hInstance = MCIAVI_hInstance;
102 wndClass.hCursor = LoadCursorW(0, (LPCWSTR)IDC_ARROW);
103 wndClass.hbrBackground = (HBRUSH)(COLOR_3DFACE + 1);
104 wndClass.lpszClassName = mciaviW;
105
106 if (RegisterClassW(&wndClass)) return TRUE;
108
109 return FALSE;
110}
UINT MCIDEVICEID
Definition: mmsystem.h:959
LPCWSTR lpszClassName
Definition: winuser.h:3175
HBRUSH hbrBackground
Definition: winuser.h:3173
HINSTANCE hInstance
Definition: winuser.h:3170
UINT style
Definition: winuser.h:3166
WNDPROC lpfnWndProc
Definition: winuser.h:3167
int cbWndExtra
Definition: winuser.h:3169
HCURSOR hCursor
Definition: winuser.h:3172
#define ZeroMemory
Definition: winbase.h:1670
DWORD WINAPI GetLastError(void)
Definition: except.c:1040
#define ERROR_CLASS_ALREADY_EXISTS
Definition: winerror.h:891
ATOM WINAPI RegisterClassW(_In_ CONST WNDCLASSW *)
#define IDC_ARROW
Definition: winuser.h:682
#define CS_DBLCLKS
Definition: winuser.h:646
HCURSOR WINAPI LoadCursorW(_In_opt_ HINSTANCE, _In_ LPCWSTR)
Definition: cursoricon.c:2074
#define COLOR_3DFACE
Definition: winuser.h:923
static LRESULT WINAPI MCIAVI_WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
Definition: wnd.c:30

Referenced by MCIAVI_drvOpen().

◆ MCIAVI_UnregisterClass()

BOOL MCIAVI_UnregisterClass ( void  )

Definition at line 88 of file wnd.c.

89{
91}
BOOL WINAPI UnregisterClassW(_In_ LPCWSTR, HINSTANCE)

Referenced by MCIAVI_drvClose().

Variable Documentation

◆ DECLSPEC_HIDDEN

HINSTANCE MCIAVI_hInstance DECLSPEC_HIDDEN
extern

Definition at line 289 of file d3dcompiler_private.h.