ReactOS 0.4.15-dev-5666-gc548b97
mciqtz.c File Reference
#include <stdarg.h>
#include <math.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "mmddk.h"
#include "wine/debug.h"
#include "mciqtz_private.h"
#include "digitalv.h"
#include "wownt32.h"
Include dependency graph for mciqtz.c:

Go to the source code of this file.

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (mciqtz)
 
static DWORD MCIQTZ_mciClose (UINT, DWORD, LPMCI_GENERIC_PARMS)
 
static DWORD MCIQTZ_mciStop (UINT, DWORD, LPMCI_GENERIC_PARMS)
 
BOOL WINAPI DllMain (HINSTANCE hInstDLL, DWORD fdwReason, LPVOID fImpLoad)
 
static WINE_MCIQTZMCIQTZ_mciGetOpenDev (UINT wDevID)
 
static DWORD MCIQTZ_drvOpen (LPCWSTR str, LPMCI_OPEN_DRIVER_PARMSW modp)
 
static DWORD MCIQTZ_drvClose (DWORD dwDevID)
 
static DWORD MCIQTZ_drvConfigure (DWORD dwDevID)
 
static void MCIQTZ_mciNotify (DWORD_PTR hWndCallBack, WINE_MCIQTZ *wma, UINT wStatus)
 
static DWORD MCIQTZ_mciOpen (UINT wDevID, DWORD dwFlags, LPMCI_DGV_OPEN_PARMSW lpOpenParms)
 
static DWORD CALLBACK MCIQTZ_notifyThread (LPVOID parm)
 
static DWORD MCIQTZ_mciPlay (UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
 
static DWORD MCIQTZ_mciSeek (UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
 
static DWORD MCIQTZ_mciPause (UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 
static DWORD MCIQTZ_mciResume (UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
 
static DWORD MCIQTZ_mciGetDevCaps (UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_PARMS lpParms)
 
static DWORD MCIQTZ_mciSet (UINT wDevID, DWORD dwFlags, LPMCI_DGV_SET_PARMS lpParms)
 
static DWORD MCIQTZ_mciStatus (UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpParms)
 
static DWORD MCIQTZ_mciWhere (UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
 
static DWORD MCIQTZ_mciWindow (UINT wDevID, DWORD dwFlags, LPMCI_DGV_WINDOW_PARMSW lpParms)
 
static DWORD MCIQTZ_mciPut (UINT wDevID, DWORD dwFlags, MCI_GENERIC_PARMS *lpParms)
 
static DWORD MCIQTZ_mciUpdate (UINT wDevID, DWORD dwFlags, LPMCI_DGV_UPDATE_PARMS lpParms)
 
static DWORD MCIQTZ_mciSetAudio (UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_PARMSW lpParms)
 
LRESULT CALLBACK MCIQTZ_DriverProc (DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg, LPARAM dwParam1, LPARAM dwParam2)
 

Variables

static HINSTANCE MCIQTZ_hInstance = 0
 

Function Documentation

◆ DllMain()

BOOL WINAPI DllMain ( HINSTANCE  hInstDLL,
DWORD  fdwReason,
LPVOID  fImpLoad 
)

Definition at line 46 of file mciqtz.c.

47{
48 switch (fdwReason) {
51 MCIQTZ_hInstance = hInstDLL;
52 break;
53 }
54 return TRUE;
55}
#define TRUE
Definition: types.h:120
#define DLL_PROCESS_ATTACH
Definition: compat.h:131
BOOL WINAPI DisableThreadLibraryCalls(IN HMODULE hLibModule)
Definition: loader.c:85
static HINSTANCE MCIQTZ_hInstance
Definition: mciqtz.c:41

◆ MCIQTZ_DriverProc()

LRESULT CALLBACK MCIQTZ_DriverProc ( DWORD_PTR  dwDevID,
HDRVR  hDriv,
UINT  wMsg,
LPARAM  dwParam1,
LPARAM  dwParam2 
)

Definition at line 1126 of file mciqtz.c.

1128{
1129 TRACE("(%08lX, %p, %08X, %08lX, %08lX)\n",
1130 dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1131
1132 switch (wMsg) {
1133 case DRV_LOAD: return 1;
1134 case DRV_FREE: return 1;
1135 case DRV_OPEN: return MCIQTZ_drvOpen((LPCWSTR)dwParam1, (LPMCI_OPEN_DRIVER_PARMSW)dwParam2);
1136 case DRV_CLOSE: return MCIQTZ_drvClose(dwDevID);
1137 case DRV_ENABLE: return 1;
1138 case DRV_DISABLE: return 1;
1139 case DRV_QUERYCONFIGURE: return 1;
1140 case DRV_CONFIGURE: return MCIQTZ_drvConfigure(dwDevID);
1141 case DRV_INSTALL: return DRVCNF_RESTART;
1142 case DRV_REMOVE: return DRVCNF_RESTART;
1143 }
1144
1145 /* session instance */
1146 if (dwDevID == 0xFFFFFFFF)
1147 return 1;
1148
1149 switch (wMsg) {
1150 case MCI_OPEN_DRIVER: return MCIQTZ_mciOpen (dwDevID, dwParam1, (LPMCI_DGV_OPEN_PARMSW) dwParam2);
1151 case MCI_CLOSE_DRIVER: return MCIQTZ_mciClose (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1152 case MCI_PLAY: return MCIQTZ_mciPlay (dwDevID, dwParam1, (LPMCI_PLAY_PARMS) dwParam2);
1153 case MCI_SEEK: return MCIQTZ_mciSeek (dwDevID, dwParam1, (LPMCI_SEEK_PARMS) dwParam2);
1154 case MCI_STOP: return MCIQTZ_mciStop (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1155 case MCI_PAUSE: return MCIQTZ_mciPause (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1156 case MCI_RESUME: return MCIQTZ_mciResume (dwDevID, dwParam1, (LPMCI_GENERIC_PARMS) dwParam2);
1157 case MCI_GETDEVCAPS: return MCIQTZ_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS) dwParam2);
1158 case MCI_SET: return MCIQTZ_mciSet (dwDevID, dwParam1, (LPMCI_DGV_SET_PARMS) dwParam2);
1159 case MCI_STATUS: return MCIQTZ_mciStatus (dwDevID, dwParam1, (LPMCI_DGV_STATUS_PARMSW) dwParam2);
1160 case MCI_WHERE: return MCIQTZ_mciWhere (dwDevID, dwParam1, (LPMCI_DGV_RECT_PARMS) dwParam2);
1161 /* Digital Video specific */
1162 case MCI_SETAUDIO: return MCIQTZ_mciSetAudio (dwDevID, dwParam1, (LPMCI_DGV_SETAUDIO_PARMSW) dwParam2);
1163 case MCI_UPDATE:
1164 return MCIQTZ_mciUpdate(dwDevID, dwParam1, (LPMCI_DGV_UPDATE_PARMS)dwParam2);
1165 case MCI_WINDOW:
1166 return MCIQTZ_mciWindow(dwDevID, dwParam1, (LPMCI_DGV_WINDOW_PARMSW)dwParam2);
1167 case MCI_PUT:
1168 return MCIQTZ_mciPut(dwDevID, dwParam1, (MCI_GENERIC_PARMS*)dwParam2);
1169 case MCI_RECORD:
1170 case MCI_INFO:
1171 case MCI_LOAD:
1172 case MCI_SAVE:
1173 case MCI_FREEZE:
1174 case MCI_REALIZE:
1175 case MCI_UNFREEZE:
1176 case MCI_STEP:
1177 case MCI_COPY:
1178 case MCI_CUT:
1179 case MCI_DELETE:
1180 case MCI_PASTE:
1181 case MCI_CUE:
1182 /* Digital Video specific */
1183 case MCI_CAPTURE:
1184 case MCI_MONITOR:
1185 case MCI_RESERVE:
1186 case MCI_SIGNAL:
1187 case MCI_SETVIDEO:
1188 case MCI_QUALITY:
1189 case MCI_LIST:
1190 case MCI_UNDO:
1191 case MCI_CONFIGURE:
1192 case MCI_RESTORE:
1193 FIXME("Unimplemented command [%08X]\n", wMsg);
1194 break;
1195 case MCI_SPIN:
1196 case MCI_ESCAPE:
1197 WARN("Unsupported command [%08X]\n", wMsg);
1198 break;
1199 case MCI_OPEN:
1200 case MCI_CLOSE:
1201 FIXME("Shouldn't receive a MCI_OPEN or CLOSE message\n");
1202 break;
1203 default:
1204 TRACE("Sending msg [%08X] to default driver proc\n", wMsg);
1205 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1206 }
1207
1209}
#define FIXME(fmt,...)
Definition: debug.h:111
#define WARN(fmt,...)
Definition: debug.h:112
#define MCI_SETAUDIO
Definition: digitalv.h:39
#define MCI_MONITOR
Definition: digitalv.h:37
#define MCI_LIST
Definition: digitalv.h:43
#define MCI_CAPTURE
Definition: digitalv.h:36
#define MCI_RESERVE
Definition: digitalv.h:38
#define MCI_SETVIDEO
Definition: digitalv.h:41
#define MCI_SIGNAL
Definition: digitalv.h:40
#define MCI_QUALITY
Definition: digitalv.h:42
#define MCI_RESTORE
Definition: digitalv.h:46
#define MCI_CONFIGURE
Definition: digitalv.h:45
#define MCI_UNDO
Definition: digitalv.h:44
LRESULT WINAPI DefDriverProc(DWORD_PTR dwDriverIdentifier, HDRVR hDrv, UINT Msg, LPARAM lParam1, LPARAM lParam2)
Definition: driver.c:554
#define DRV_LOAD(x)
static DWORD MCIQTZ_mciWindow(UINT wDevID, DWORD dwFlags, LPMCI_DGV_WINDOW_PARMSW lpParms)
Definition: mciqtz.c:908
static DWORD MCIQTZ_drvConfigure(DWORD dwDevID)
Definition: mciqtz.c:126
static DWORD MCIQTZ_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
Definition: mciqtz.c:538
static DWORD MCIQTZ_mciPut(UINT wDevID, DWORD dwFlags, MCI_GENERIC_PARMS *lpParms)
Definition: mciqtz.c:953
static DWORD MCIQTZ_mciWhere(UINT wDevID, DWORD dwFlags, LPMCI_DGV_RECT_PARMS lpParms)
Definition: mciqtz.c:839
static DWORD MCIQTZ_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
Definition: mciqtz.c:561
static DWORD MCIQTZ_drvClose(DWORD dwDevID)
Definition: mciqtz.c:101
static DWORD MCIQTZ_mciSetAudio(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SETAUDIO_PARMSW lpParms)
Definition: mciqtz.c:1067
static DWORD MCIQTZ_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_DGV_SET_PARMS lpParms)
Definition: mciqtz.c:683
static DWORD MCIQTZ_mciStop(UINT, DWORD, LPMCI_GENERIC_PARMS)
Definition: mciqtz.c:509
static DWORD MCIQTZ_mciGetDevCaps(UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_PARMS lpParms)
Definition: mciqtz.c:584
static DWORD MCIQTZ_mciOpen(UINT wDevID, DWORD dwFlags, LPMCI_DGV_OPEN_PARMSW lpOpenParms)
Definition: mciqtz.c:160
static DWORD MCIQTZ_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
Definition: mciqtz.c:398
static DWORD MCIQTZ_mciUpdate(UINT wDevID, DWORD dwFlags, LPMCI_DGV_UPDATE_PARMS lpParms)
Definition: mciqtz.c:1003
static DWORD MCIQTZ_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_DGV_STATUS_PARMSW lpParms)
Definition: mciqtz.c:738
static DWORD MCIQTZ_drvOpen(LPCWSTR str, LPMCI_OPEN_DRIVER_PARMSW modp)
Definition: mciqtz.c:74
static DWORD MCIQTZ_mciClose(UINT, DWORD, LPMCI_GENERIC_PARMS)
Definition: mciqtz.c:298
static DWORD MCIQTZ_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
Definition: mciqtz.c:464
#define MCI_CUT
Definition: mmsystem.h:671
#define MCI_SAVE
Definition: mmsystem.h:661
#define DRV_CLOSE
Definition: mmsystem.h:122
#define DRV_QUERYCONFIGURE
Definition: mmsystem.h:126
#define MCI_GETDEVCAPS
Definition: mmsystem.h:654
#define MCI_RESUME
Definition: mmsystem.h:675
#define MCI_DELETE
Definition: mmsystem.h:676
#define MCI_FREEZE
Definition: mmsystem.h:668
#define DRVCNF_RESTART
Definition: mmsystem.h:135
#define MCI_WINDOW
Definition: mmsystem.h:665
#define MCI_STATUS
Definition: mmsystem.h:662
#define MCI_COPY
Definition: mmsystem.h:672
#define MCI_ESCAPE
Definition: mmsystem.h:648
#define MCIERR_UNRECOGNIZED_COMMAND
Definition: mmsystem.h:571
#define MCI_SET
Definition: mmsystem.h:656
#define MCI_LOAD
Definition: mmsystem.h:670
#define MCI_UPDATE
Definition: mmsystem.h:674
#define DRV_REMOVE
Definition: mmsystem.h:128
#define DRV_ENABLE
Definition: mmsystem.h:120
#define MCI_STOP
Definition: mmsystem.h:651
#define MCI_CLOSE
Definition: mmsystem.h:647
#define MCI_SEEK
Definition: mmsystem.h:650
#define DRV_CONFIGURE
Definition: mmsystem.h:125
#define DRV_OPEN
Definition: mmsystem.h:121
#define MCI_WHERE
Definition: mmsystem.h:667
#define DRV_INSTALL
Definition: mmsystem.h:127
#define MCI_OPEN
Definition: mmsystem.h:646
#define MCI_UNFREEZE
Definition: mmsystem.h:669
#define MCI_PUT
Definition: mmsystem.h:666
#define MCI_SPIN
Definition: mmsystem.h:655
#define MCI_CUE
Definition: mmsystem.h:663
#define MCI_PAUSE
Definition: mmsystem.h:652
#define MCI_INFO
Definition: mmsystem.h:653
#define MCI_PASTE
Definition: mmsystem.h:673
#define DRV_FREE
Definition: mmsystem.h:124
#define MCI_PLAY
Definition: mmsystem.h:649
#define MCI_STEP
Definition: mmsystem.h:657
#define MCI_REALIZE
Definition: mmsystem.h:664
#define MCI_RECORD
Definition: mmsystem.h:658
#define DRV_DISABLE
Definition: mmsystem.h:123
#define MCI_OPEN_DRIVER
Definition: mmddk.h:338
#define MCI_CLOSE_DRIVER
Definition: mmddk.h:339
#define TRACE(s)
Definition: solgame.cpp:4
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185

◆ MCIQTZ_drvClose()

static DWORD MCIQTZ_drvClose ( DWORD  dwDevID)
static

Definition at line 101 of file mciqtz.c.

102{
103 WINE_MCIQTZ* wma;
104
105 TRACE("(%04x)\n", dwDevID);
106
107 wma = MCIQTZ_mciGetOpenDev(dwDevID);
108
109 if (wma) {
110 /* finish all outstanding things */
111 MCIQTZ_mciClose(dwDevID, MCI_WAIT, NULL);
112
114 mciSetDriverData(dwDevID, 0);
116 HeapFree(GetProcessHeap(), 0, wma);
117 return 1;
118 }
119
120 return (dwDevID == 0xFFFFFFFF) ? 1 : 0;
121}
#define NULL
Definition: types.h:112
#define CloseHandle
Definition: compat.h:739
#define GetProcessHeap()
Definition: compat.h:736
#define HeapFree(x, y, z)
Definition: compat.h:735
BOOL WINAPI mciFreeCommandResource(UINT uTable)
Definition: mci.c:1681
BOOL WINAPI mciSetDriverData(UINT uDeviceID, DWORD dwData)
static WINE_MCIQTZ * MCIQTZ_mciGetOpenDev(UINT wDevID)
Definition: mciqtz.c:60
#define MCI_WAIT
Definition: mmsystem.h:730
UINT command_table
HANDLE stop_event

Referenced by MCIQTZ_DriverProc().

◆ MCIQTZ_drvConfigure()

static DWORD MCIQTZ_drvConfigure ( DWORD  dwDevID)
static

Definition at line 126 of file mciqtz.c.

127{
128 WINE_MCIQTZ* wma;
129
130 TRACE("(%04x)\n", dwDevID);
131
132 wma = MCIQTZ_mciGetOpenDev(dwDevID);
133 if (!wma)
134 return 0;
135
136 MCIQTZ_mciStop(dwDevID, MCI_WAIT, NULL);
137
138 MessageBoxA(0, "Sample QTZ Wine Driver !", "MM-Wine Driver", MB_OK);
139
140 return 1;
141}
int WINAPI MessageBoxA(_In_opt_ HWND hWnd, _In_opt_ LPCSTR lpText, _In_opt_ LPCSTR lpCaption, _In_ UINT uType)
#define MB_OK
Definition: winuser.h:784

Referenced by MCIQTZ_DriverProc().

◆ MCIQTZ_drvOpen()

static DWORD MCIQTZ_drvOpen ( LPCWSTR  str,
LPMCI_OPEN_DRIVER_PARMSW  modp 
)
static

Definition at line 74 of file mciqtz.c.

75{
76 WINE_MCIQTZ* wma;
77 static const WCHAR mciAviWStr[] = {'M','C','I','A','V','I',0};
78
79 TRACE("(%s, %p)\n", debugstr_w(str), modp);
80
81 /* session instance */
82 if (!modp)
83 return 0xFFFFFFFF;
84
86 if (!wma)
87 return 0;
88
91 wma->wDevID = modp->wDeviceID;
94
95 return modp->wDeviceID;
96}
#define FALSE
Definition: types.h:117
#define HeapAlloc
Definition: compat.h:733
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
UINT WINAPI mciLoadCommandResource(HINSTANCE hInstance, LPCWSTR lpResName, UINT uType)
Definition: mci.c:1641
#define debugstr_w
Definition: kernel32.h:32
#define MCI_DEVTYPE_DIGITAL_VIDEO
Definition: mmsystem.h:687
const WCHAR * str
UINT wCustomCommandTable
Definition: mmddk.h:438
MCIDEVICEID wDevID
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
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by MCIQTZ_DriverProc().

◆ MCIQTZ_mciClose()

static DWORD MCIQTZ_mciClose ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_GENERIC_PARMS  lpParms 
)
static

Definition at line 298 of file mciqtz.c.

299{
300 WINE_MCIQTZ* wma;
301
302 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
303
304 wma = MCIQTZ_mciGetOpenDev(wDevID);
305 if (!wma)
307
308 MCIQTZ_mciStop(wDevID, MCI_WAIT, NULL);
309
310 if (wma->opened) {
311 IVideoWindow_Release(wma->vidwin);
312 IBasicVideo_Release(wma->vidbasic);
313 IBasicAudio_Release(wma->audio);
314 IMediaSeeking_Release(wma->seek);
315 IMediaEvent_Release(wma->mevent);
316 IGraphBuilder_Release(wma->pgraph);
317 IMediaControl_Release(wma->pmctrl);
318 if (wma->uninit)
320 wma->opened = FALSE;
321 }
322
323 return 0;
324}
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:2067
#define MCIERR_INVALID_DEVICE_ID
Definition: mmsystem.h:569
IMediaEvent * mevent
IMediaSeeking * seek
IBasicVideo * vidbasic
IVideoWindow * vidwin
IGraphBuilder * pgraph
IMediaControl * pmctrl
IBasicAudio * audio
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176

Referenced by MCIQTZ_DriverProc(), and MCIQTZ_drvClose().

◆ MCIQTZ_mciGetDevCaps()

static DWORD MCIQTZ_mciGetDevCaps ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_GETDEVCAPS_PARMS  lpParms 
)
static

Definition at line 584 of file mciqtz.c.

585{
586 WINE_MCIQTZ* wma;
587
588 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
589
590 if(!lpParms)
592
593 wma = MCIQTZ_mciGetOpenDev(wDevID);
594 if (!wma)
596
599
600 switch (lpParms->dwItem) {
603 TRACE("MCI_GETDEVCAPS_CAN_RECORD = %08x\n", lpParms->dwReturn);
604 break;
607 TRACE("MCI_GETDEVCAPS_HAS_AUDIO = %08x\n", lpParms->dwReturn);
608 break;
611 TRACE("MCI_GETDEVCAPS_HAS_VIDEO = %08x\n", lpParms->dwReturn);
612 break;
615 TRACE("MCI_GETDEVCAPS_DEVICE_TYPE = %08x\n", lpParms->dwReturn);
616 break;
619 TRACE("MCI_GETDEVCAPS_USES_FILES = %08x\n", lpParms->dwReturn);
620 break;
623 TRACE("MCI_GETDEVCAPS_COMPOUND_DEVICE = %08x\n", lpParms->dwReturn);
624 break;
627 TRACE("MCI_GETDEVCAPS_EJECT = %08x\n", lpParms->dwReturn);
628 break;
631 TRACE("MCI_GETDEVCAPS_CAN_PLAY = %08x\n", lpParms->dwReturn);
632 break;
635 TRACE("MCI_GETDEVCAPS_CAN_SAVE = %08x\n", lpParms->dwReturn);
636 break;
639 TRACE("MCI_DGV_GETDEVCAPS_CAN_REVERSE = %08x\n", lpParms->dwReturn);
640 break;
642 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
643 TRACE("MCI_DGV_GETDEVCAPS_CAN_STRETCH = %08x\n", lpParms->dwReturn);
644 break;
647 TRACE("MCI_DGV_GETDEVCAPS_CAN_LOCK = %08x\n", lpParms->dwReturn);
648 break;
651 TRACE("MCI_DGV_GETDEVCAPS_CAN_FREEZE = %08x\n", lpParms->dwReturn);
652 break;
655 TRACE("MCI_DGV_GETDEVCAPS_CAN_STRETCH_INPUT = %08x\n", lpParms->dwReturn);
656 break;
659 TRACE("MCI_DGV_GETDEVCAPS_HAS_STILL = %08x\n", lpParms->dwReturn);
660 break;
662 lpParms->dwReturn = MAKEMCIRESOURCE(FALSE, MCI_FALSE); /* FIXME */
663 TRACE("MCI_DGV_GETDEVCAPS_CAN_TEST = %08x\n", lpParms->dwReturn);
664 break;
666 lpParms->dwReturn = 1;
667 TRACE("MCI_DGV_GETDEVCAPS_MAX_WINDOWS = %u\n", lpParms->dwReturn);
668 return 0;
669 default:
670 WARN("Unknown capability %08x\n", lpParms->dwItem);
671 /* Fall through */
672 case MCI_DGV_GETDEVCAPS_MAXIMUM_RATE: /* unknown to w2k */
673 case MCI_DGV_GETDEVCAPS_MINIMUM_RATE: /* unknown to w2k */
675 }
676
678}
#define MCI_DGV_GETDEVCAPS_HAS_STILL
Definition: digitalv.h:121
#define MCI_DGV_GETDEVCAPS_CAN_STRETCH
Definition: digitalv.h:117
#define MCI_DGV_GETDEVCAPS_CAN_LOCK
Definition: digitalv.h:116
#define MCI_DGV_GETDEVCAPS_MAX_WINDOWS
Definition: digitalv.h:119
#define MCI_DGV_GETDEVCAPS_MINIMUM_RATE
Definition: digitalv.h:126
#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_DGV_GETDEVCAPS_MAXIMUM_RATE
Definition: digitalv.h:125
#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_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 MCIQTZ_DriverProc().

◆ MCIQTZ_mciGetOpenDev()

static WINE_MCIQTZ * MCIQTZ_mciGetOpenDev ( UINT  wDevID)
static

Definition at line 60 of file mciqtz.c.

61{
63
64 if (!wma) {
65 WARN("Invalid wDevID=%u\n", wDevID);
66 return NULL;
67 }
68 return wma;
69}
DWORD WINAPI mciGetDriverData(UINT uDeviceID)
Definition: mci.c:2233

Referenced by MCIQTZ_drvClose(), MCIQTZ_drvConfigure(), MCIQTZ_mciClose(), MCIQTZ_mciGetDevCaps(), MCIQTZ_mciOpen(), MCIQTZ_mciPause(), MCIQTZ_mciPlay(), MCIQTZ_mciPut(), MCIQTZ_mciResume(), MCIQTZ_mciSeek(), MCIQTZ_mciSet(), MCIQTZ_mciSetAudio(), MCIQTZ_mciStatus(), MCIQTZ_mciStop(), MCIQTZ_mciUpdate(), MCIQTZ_mciWhere(), and MCIQTZ_mciWindow().

◆ MCIQTZ_mciNotify()

static void MCIQTZ_mciNotify ( DWORD_PTR  hWndCallBack,
WINE_MCIQTZ wma,
UINT  wStatus 
)
static

Definition at line 149 of file mciqtz.c.

150{
151 MCIDEVICEID wDevID = wma->notify_devid;
153 if (old) mciDriverNotify(old, wDevID, MCI_NOTIFY_SUPERSEDED);
154 mciDriverNotify(HWND_32(LOWORD(hWndCallBack)), wDevID, wStatus);
155}
BOOL WINAPI mciDriverNotify(HWND hwndCallback, UINT uDeviceID, UINT uStatus)
Definition: mci.c:2223
#define InterlockedExchangePointer(Target, Value)
Definition: dshow.h:45
#define MCI_NOTIFY_SUPERSEDED
Definition: mmsystem.h:726
UINT MCIDEVICEID
Definition: mmsystem.h:959
#define LOWORD(l)
Definition: pedump.c:82
MCIDEVICEID notify_devid
HANDLE callback
#define HWND_32(h16)
Definition: wownt32.h:29

Referenced by MCIQTZ_mciPut(), MCIQTZ_mciSeek(), and MCIQTZ_mciStatus().

◆ MCIQTZ_mciOpen()

static DWORD MCIQTZ_mciOpen ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_DGV_OPEN_PARMSW  lpOpenParms 
)
static

Definition at line 160 of file mciqtz.c.

162{
163 WINE_MCIQTZ* wma;
164 HRESULT hr;
165 DWORD style = 0;
166 RECT rc = { 0, 0, 0, 0 };
167
168 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpOpenParms);
169
170 if(!lpOpenParms)
172
173 wma = MCIQTZ_mciGetOpenDev(wDevID);
174 if (!wma)
176
177 MCIQTZ_mciStop(wDevID, MCI_WAIT, NULL);
178
180 wma->uninit = SUCCEEDED(hr);
181
182 hr = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, &IID_IGraphBuilder, (LPVOID*)&wma->pgraph);
183 if (FAILED(hr)) {
184 TRACE("Cannot create filtergraph (hr = %x)\n", hr);
185 goto err;
186 }
187
188 hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IMediaControl, (LPVOID*)&wma->pmctrl);
189 if (FAILED(hr)) {
190 TRACE("Cannot get IMediaControl interface (hr = %x)\n", hr);
191 goto err;
192 }
193
194 hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IMediaSeeking, (void**)&wma->seek);
195 if (FAILED(hr)) {
196 TRACE("Cannot get IMediaSeeking interface (hr = %x)\n", hr);
197 goto err;
198 }
199
200 hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IMediaEvent, (void**)&wma->mevent);
201 if (FAILED(hr)) {
202 TRACE("Cannot get IMediaEvent interface (hr = %x)\n", hr);
203 goto err;
204 }
205
206 hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IVideoWindow, (void**)&wma->vidwin);
207 if (FAILED(hr)) {
208 TRACE("Cannot get IVideoWindow interface (hr = %x)\n", hr);
209 goto err;
210 }
211
212 hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IBasicVideo, (void**)&wma->vidbasic);
213 if (FAILED(hr)) {
214 TRACE("Cannot get IBasicVideo interface (hr = %x)\n", hr);
215 goto err;
216 }
217
218 hr = IGraphBuilder_QueryInterface(wma->pgraph, &IID_IBasicAudio, (void**)&wma->audio);
219 if (FAILED(hr)) {
220 TRACE("Cannot get IBasicAudio interface (hr = %x)\n", hr);
221 goto err;
222 }
223
225 TRACE("Wrong dwFlags %x\n", dwFlags);
226 goto err;
227 }
228
229 if (!lpOpenParms->lpstrElementName || !lpOpenParms->lpstrElementName[0]) {
230 TRACE("Invalid filename specified\n");
231 goto err;
232 }
233
234 TRACE("Open file %s\n", debugstr_w(lpOpenParms->lpstrElementName));
235
236 hr = IGraphBuilder_RenderFile(wma->pgraph, lpOpenParms->lpstrElementName, NULL);
237 if (FAILED(hr)) {
238 TRACE("Cannot render file (hr = %x)\n", hr);
239 goto err;
240 }
241
242 IVideoWindow_put_AutoShow(wma->vidwin, OAFALSE);
243 IVideoWindow_put_Visible(wma->vidwin, OAFALSE);
245 style = lpOpenParms->dwStyle;
247 IVideoWindow_put_MessageDrain(wma->vidwin, (OAHWND)lpOpenParms->hWndParent);
248 IVideoWindow_put_WindowState(wma->vidwin, SW_HIDE);
249 IVideoWindow_put_WindowStyle(wma->vidwin, style|WS_CHILD);
250 IVideoWindow_put_Owner(wma->vidwin, (OAHWND)lpOpenParms->hWndParent);
251 GetClientRect(lpOpenParms->hWndParent, &rc);
252 IVideoWindow_SetWindowPosition(wma->vidwin, rc.left, rc.top, rc.right - rc.top, rc.bottom - rc.top);
253 wma->parent = (HWND)lpOpenParms->hWndParent;
254 }
255 else if (style)
256 IVideoWindow_put_WindowStyle(wma->vidwin, style);
257 IBasicVideo_GetVideoSize(wma->vidbasic, &rc.right, &rc.bottom);
258 wma->opened = TRUE;
259
260 if (dwFlags & MCI_NOTIFY)
262
263 return 0;
264
265err:
266 if (wma->audio)
267 IBasicAudio_Release(wma->audio);
268 wma->audio = NULL;
269 if (wma->vidbasic)
270 IBasicVideo_Release(wma->vidbasic);
271 wma->vidbasic = NULL;
272 if (wma->seek)
273 IMediaSeeking_Release(wma->seek);
274 wma->seek = NULL;
275 if (wma->vidwin)
276 IVideoWindow_Release(wma->vidwin);
277 wma->vidwin = NULL;
278 if (wma->pgraph)
279 IGraphBuilder_Release(wma->pgraph);
280 wma->pgraph = NULL;
281 if (wma->mevent)
282 IMediaEvent_Release(wma->mevent);
283 wma->mevent = NULL;
284 if (wma->pmctrl)
285 IMediaControl_Release(wma->pmctrl);
286 wma->pmctrl = NULL;
287
288 if (wma->uninit)
290 wma->uninit = FALSE;
291
292 return MCIERR_INTERNAL;
293}
Arabic default style
Definition: afstyles.h:94
#define MCI_DGV_OPEN_PARENT
Definition: digitalv.h:212
#define MCI_DGV_OPEN_WS
Definition: digitalv.h:211
HANDLE HWND
Definition: compat.h:19
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3325
HRESULT WINAPI DECLSPEC_HOTPATCH CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit)
Definition: compobj.c:2002
#define OAFALSE
Definition: dshow.h:53
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define FAILED(hr)
Definition: intsafe.h:51
#define MCI_NOTIFY
Definition: mmsystem.h:729
#define MCI_OPEN_ELEMENT_ID
Definition: mmsystem.h:737
#define MCI_OPEN_ELEMENT
Definition: mmsystem.h:735
#define MCIERR_INTERNAL
Definition: mmsystem.h:587
#define MCI_NOTIFY_SUCCESSFUL
Definition: mmsystem.h:725
@ COINIT_MULTITHREADED
Definition: objbase.h:279
#define WS_CHILD
Definition: pedump.c:617
#define err(...)
HRESULT hr
Definition: shlfolder.c:183
DWORD_PTR dwCallback
Definition: digitalv.h:604
LPWSTR lpstrElementName
Definition: digitalv.h:607
LONG right
Definition: windef.h:308
LONG bottom
Definition: windef.h:309
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
#define SW_HIDE
Definition: winuser.h:762
BOOL WINAPI GetClientRect(_In_ HWND, _Out_ LPRECT)

Referenced by MCIQTZ_DriverProc().

◆ MCIQTZ_mciPause()

static DWORD MCIQTZ_mciPause ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_GENERIC_PARMS  lpParms 
)
static

Definition at line 538 of file mciqtz.c.

539{
540 WINE_MCIQTZ* wma;
541 HRESULT hr;
542
543 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
544
545 wma = MCIQTZ_mciGetOpenDev(wDevID);
546 if (!wma)
548
549 hr = IMediaControl_Pause(wma->pmctrl);
550 if (FAILED(hr)) {
551 TRACE("Cannot pause filtergraph (hr = %x)\n", hr);
552 return MCIERR_INTERNAL;
553 }
554
555 return 0;
556}

Referenced by MCIQTZ_DriverProc().

◆ MCIQTZ_mciPlay()

static DWORD MCIQTZ_mciPlay ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_PLAY_PARMS  lpParms 
)
static

Definition at line 398 of file mciqtz.c.

399{
400 WINE_MCIQTZ* wma;
401 HRESULT hr;
402 GUID format;
403 DWORD start_flags;
404
405 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
406
407 if(!lpParms)
409
410 wma = MCIQTZ_mciGetOpenDev(wDevID);
411 if (!wma)
413
415 if (dwFlags & MCI_NOTIFY) {
416 HANDLE old;
418 if (old)
420 }
421
422 wma->mci_flags = dwFlags;
423 IMediaSeeking_GetTimeFormat(wma->seek, &format);
424 if (dwFlags & MCI_FROM) {
425 wma->seek_start = lpParms->dwFrom;
426 if (IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME))
427 wma->seek_start *= 10000;
428
429 start_flags = AM_SEEKING_AbsolutePositioning;
430 } else {
431 wma->seek_start = 0;
432 start_flags = AM_SEEKING_NoPositioning;
433 }
434 if (dwFlags & MCI_TO) {
435 wma->seek_stop = lpParms->dwTo;
436 if (IsEqualGUID(&format, &TIME_FORMAT_MEDIA_TIME))
437 wma->seek_stop *= 10000;
438 } else {
439 wma->seek_stop = 0;
440 IMediaSeeking_GetDuration(wma->seek, &wma->seek_stop);
441 }
442 IMediaSeeking_SetPositions(wma->seek, &wma->seek_start, start_flags,
444
445 hr = IMediaControl_Run(wma->pmctrl);
446 if (FAILED(hr)) {
447 TRACE("Cannot run filtergraph (hr = %x)\n", hr);
448 return MCIERR_INTERNAL;
449 }
450
451 IVideoWindow_put_Visible(wma->vidwin, OATRUE);
452
453 wma->thread = CreateThread(NULL, 0, MCIQTZ_notifyThread, wma, 0, NULL);
454 if (!wma->thread) {
455 TRACE("Can't create thread\n");
456 return MCIERR_INTERNAL;
457 }
458 return 0;
459}
@ AM_SEEKING_NoPositioning
Definition: axcore.idl:591
@ AM_SEEKING_AbsolutePositioning
Definition: axcore.idl:592
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
#define OATRUE
Definition: dshow.h:49
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
static DWORD CALLBACK MCIQTZ_notifyThread(LPVOID parm)
Definition: mciqtz.c:329
#define MCI_TO
Definition: mmsystem.h:732
#define MCI_NOTIFY_ABORTED
Definition: mmsystem.h:727
#define MCI_FROM
Definition: mmsystem.h:731
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
REFERENCE_TIME seek_stop
REFERENCE_TIME seek_start
DWORD_PTR dwCallback
Definition: mmsystem.h:1537
BOOL WINAPI DECLSPEC_HOTPATCH ResetEvent(IN HANDLE hEvent)
Definition: synch.c:714

Referenced by MCIQTZ_DriverProc().

◆ MCIQTZ_mciPut()

static DWORD MCIQTZ_mciPut ( UINT  wDevID,
DWORD  dwFlags,
MCI_GENERIC_PARMS lpParms 
)
static

Definition at line 953 of file mciqtz.c.

954{
955 WINE_MCIQTZ *wma = MCIQTZ_mciGetOpenDev(wDevID);
956 MCI_DGV_RECT_PARMS *rectparms;
957 HRESULT hr;
958
959 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
960
961 if(!lpParms)
963
964 if (!wma)
966
967 if (!(dwFlags & MCI_DGV_RECT)) {
968 FIXME("No support for non-RECT MCI_PUT\n");
969 return 1;
970 }
971
972 if (dwFlags & MCI_TEST)
973 return 0;
974
975 dwFlags &= ~MCI_DGV_RECT;
976 rectparms = (MCI_DGV_RECT_PARMS*)lpParms;
977
979 hr = IVideoWindow_SetWindowPosition(wma->vidwin,
980 rectparms->rc.left, rectparms->rc.top,
981 rectparms->rc.right - rectparms->rc.left,
982 rectparms->rc.bottom - rectparms->rc.top);
983 if(FAILED(hr))
984 WARN("IVideoWindow_SetWindowPosition failed: 0x%x\n", hr);
985
986 dwFlags &= ~MCI_DGV_PUT_DESTINATION;
987 }
988
989 if (dwFlags & MCI_NOTIFY) {
991 dwFlags &= ~MCI_NOTIFY;
992 }
993
994 if (dwFlags)
995 FIXME("No support for some flags: 0x%x\n", dwFlags);
996
997 return 0;
998}
#define MCI_DGV_PUT_DESTINATION
Definition: digitalv.h:234
#define MCI_DGV_RECT
Definition: digitalv.h:232
#define MCI_TEST
Definition: digitalv.h:32
static void MCIQTZ_mciNotify(DWORD_PTR hWndCallBack, WINE_MCIQTZ *wma, UINT wStatus)
Definition: mciqtz.c:149
DWORD_PTR dwCallback
Definition: mmsystem.h:1517

Referenced by MCIQTZ_DriverProc().

◆ MCIQTZ_mciResume()

static DWORD MCIQTZ_mciResume ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_GENERIC_PARMS  lpParms 
)
static

Definition at line 561 of file mciqtz.c.

562{
563 WINE_MCIQTZ* wma;
564 HRESULT hr;
565
566 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
567
568 wma = MCIQTZ_mciGetOpenDev(wDevID);
569 if (!wma)
571
572 hr = IMediaControl_Run(wma->pmctrl);
573 if (FAILED(hr)) {
574 TRACE("Cannot run filtergraph (hr = %x)\n", hr);
575 return MCIERR_INTERNAL;
576 }
577
578 return 0;
579}

Referenced by MCIQTZ_DriverProc().

◆ MCIQTZ_mciSeek()

static DWORD MCIQTZ_mciSeek ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_SEEK_PARMS  lpParms 
)
static

Definition at line 464 of file mciqtz.c.

465{
466 WINE_MCIQTZ* wma;
467 HRESULT hr;
468 LONGLONG newpos;
469
470 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
471
472 if(!lpParms)
474
475 wma = MCIQTZ_mciGetOpenDev(wDevID);
476 if (!wma)
478
479 MCIQTZ_mciStop(wDevID, MCI_WAIT, NULL);
480
482 newpos = 0;
483 } else if (dwFlags & MCI_SEEK_TO_END) {
484 FIXME("MCI_SEEK_TO_END not implemented yet\n");
485 return MCIERR_INTERNAL;
486 } else if (dwFlags & MCI_TO) {
487 FIXME("MCI_TO not implemented yet\n");
488 return MCIERR_INTERNAL;
489 } else {
490 WARN("dwFlag doesn't tell where to seek to...\n");
492 }
493
494 hr = IMediaSeeking_SetPositions(wma->seek, &newpos, AM_SEEKING_AbsolutePositioning, NULL, AM_SEEKING_NoPositioning);
495 if (FAILED(hr)) {
496 FIXME("Cannot set position (hr = %x)\n", hr);
497 return MCIERR_INTERNAL;
498 }
499
500 if (dwFlags & MCI_NOTIFY)
502
503 return 0;
504}
#define MCI_SEEK_TO_END
Definition: mmsystem.h:741
#define MCI_SEEK_TO_START
Definition: mmsystem.h:740
DWORD_PTR dwCallback
Definition: mmsystem.h:1543
int64_t LONGLONG
Definition: typedefs.h:68

Referenced by MCIQTZ_DriverProc().

◆ MCIQTZ_mciSet()

static DWORD MCIQTZ_mciSet ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_DGV_SET_PARMS  lpParms 
)
static

Definition at line 683 of file mciqtz.c.

684{
685 WINE_MCIQTZ* wma;
686
687 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
688
689 if(!lpParms)
691
692 wma = MCIQTZ_mciGetOpenDev(wDevID);
693 if (!wma)
695
697 switch (lpParms->dwTimeFormat) {
699 TRACE("MCI_SET_TIME_FORMAT = MCI_FORMAT_MILLISECONDS\n");
701 break;
703 TRACE("MCI_SET_TIME_FORMAT = MCI_FORMAT_FRAMES\n");
705 break;
706 default:
707 WARN("Bad time format %u\n", lpParms->dwTimeFormat);
709 }
710 }
711
713 FIXME("MCI_SET_DOOR_OPEN not implemented yet\n");
715 FIXME("MCI_SET_DOOR_CLOSED not implemented yet\n");
717 FIXME("MCI_SET_AUDIO not implemented yet\n");
719 FIXME("MCI_SET_VIDEO not implemented yet\n");
720 if (dwFlags & MCI_SET_ON)
721 FIXME("MCI_SET_ON not implemented yet\n");
722 if (dwFlags & MCI_SET_OFF)
723 FIXME("MCI_SET_OFF not implemented yet\n");
725 FIXME("MCI_SET_AUDIO_LEFT not implemented yet\n");
727 FIXME("MCI_SET_AUDIO_RIGHT not implemented yet\n");
728
729 if (dwFlags & ~0x7f03 /* All MCI_SET flags mask */)
730 ERR("Unknown flags %08x\n", dwFlags & ~0x7f03);
731
732 return 0;
733}
#define ERR(fmt,...)
Definition: debug.h:110
#define MCI_SET_AUDIO
Definition: mmsystem.h:775
#define MCI_FORMAT_MILLISECONDS
Definition: mmsystem.h:701
#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_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_FORMAT_FRAMES
Definition: mmsystem.h:704
#define MCI_SET_ON
Definition: mmsystem.h:777
DWORD dwTimeFormat
Definition: digitalv.h:733
DWORD time_format

Referenced by MCIQTZ_DriverProc().

◆ MCIQTZ_mciSetAudio()

static DWORD MCIQTZ_mciSetAudio ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_DGV_SETAUDIO_PARMSW  lpParms 
)
static

Definition at line 1067 of file mciqtz.c.

1068{
1069 WINE_MCIQTZ *wma;
1070 DWORD ret = 0;
1071
1072 TRACE("(%04x, %08x, %p)\n", wDevID, dwFlags, lpParms);
1073
1074 if(!lpParms)
1076
1077 wma = MCIQTZ_mciGetOpenDev(wDevID);
1078 if (!wma)
1080
1081 if (!(dwFlags & MCI_DGV_SETAUDIO_ITEM)) {
1082 FIXME("Unknown flags (%08x)\n", dwFlags);
1083 return 0;
1084 }
1085
1087 switch (lpParms->dwItem) {
1090 long vol;
1091 HRESULT hr;
1092 if (lpParms->dwValue > 1000) {
1094 break;
1095 }
1096 if (dwFlags & MCI_TEST)
1097 break;
1098 if (lpParms->dwValue != 0)
1099 vol = (long)(2000.0 * (log10(lpParms->dwValue) - 3.0));
1100 else
1101 vol = -10000;
1102 TRACE("Setting volume to %ld\n", vol);
1103 hr = IBasicAudio_put_Volume(wma->audio, vol);
1104 if (FAILED(hr)) {
1105 WARN("Cannot set volume (hr = %x)\n", hr);
1107 }
1108 }
1109 break;
1110 default:
1111 FIXME("Unknown item %08x\n", lpParms->dwItem);
1112 break;
1113 }
1114 }
1115
1116 return ret;
1117}
#define MCI_DGV_SETAUDIO_ITEM
Definition: digitalv.h:296
#define MCI_DGV_SETAUDIO_VALUE
Definition: digitalv.h:297
#define MCI_DGV_SETAUDIO_VOLUME
Definition: digitalv.h:305
double log10(double x)
Definition: freeldr.c:122
#define MCIERR_OUTOFRANGE
Definition: mmsystem.h:592
#define long
Definition: qsort.c:33
int ret

Referenced by MCIQTZ_DriverProc().

◆ MCIQTZ_mciStatus()

static DWORD MCIQTZ_mciStatus ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_DGV_STATUS_PARMSW  lpParms 
)
static

Definition at line 738 of file mciqtz.c.

739{
740 WINE_MCIQTZ* wma;
741 HRESULT hr;
743
744 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
745
746 if(!lpParms)
748
749 wma = MCIQTZ_mciGetOpenDev(wDevID);
750 if (!wma)
752
753 if (!(dwFlags & MCI_STATUS_ITEM)) {
754 WARN("No status item specified\n");
756 }
757
758 switch (lpParms->dwItem) {
759 case MCI_STATUS_LENGTH: {
760 LONGLONG duration = -1;
761 GUID format;
762 switch (wma->time_format) {
763 case MCI_FORMAT_MILLISECONDS: format = TIME_FORMAT_MEDIA_TIME; break;
764 case MCI_FORMAT_FRAMES: format = TIME_FORMAT_FRAME; break;
765 default: ERR("Unhandled format %x\n", wma->time_format); break;
766 }
767 hr = IMediaSeeking_SetTimeFormat(wma->seek, &format);
768 if (FAILED(hr)) {
769 FIXME("Cannot set time format (hr = %x)\n", hr);
770 lpParms->dwReturn = 0;
771 break;
772 }
773 hr = IMediaSeeking_GetDuration(wma->seek, &duration);
774 if (FAILED(hr) || duration < 0) {
775 FIXME("Cannot read duration (hr = %x)\n", hr);
776 lpParms->dwReturn = 0;
777 } else if (wma->time_format != MCI_FORMAT_MILLISECONDS)
778 lpParms->dwReturn = duration;
779 else
780 lpParms->dwReturn = duration / 10000;
781 break;
782 }
783 case MCI_STATUS_POSITION: {
784 REFERENCE_TIME curpos;
785
786 hr = IMediaSeeking_GetCurrentPosition(wma->seek, &curpos);
787 if (FAILED(hr)) {
788 FIXME("Cannot get position (hr = %x)\n", hr);
789 return MCIERR_INTERNAL;
790 }
791 lpParms->dwReturn = curpos / 10000;
792 break;
793 }
795 FIXME("MCI_STATUS_NUMBER_OF_TRACKS not implemented yet\n");
797 case MCI_STATUS_MODE: {
798 LONG state = State_Stopped;
799 IMediaControl_GetState(wma->pmctrl, -1, &state);
800 if (state == State_Stopped)
802 else if (state == State_Running) {
804 if (!wma->thread || WaitForSingleObject(wma->thread, 0) == WAIT_OBJECT_0)
806 } else if (state == State_Paused)
809 break;
810 }
812 FIXME("MCI_STATUS_MEDIA_PRESENT not implemented yet\n");
815 lpParms->dwReturn = MAKEMCIRESOURCE(wma->time_format,
818 break;
819 case MCI_STATUS_READY:
820 FIXME("MCI_STATUS_READY not implemented yet\n");
823 FIXME("MCI_STATUS_CURRENT_TRACK not implemented yet\n");
825 default:
826 FIXME("Unknown command %08X\n", lpParms->dwItem);
828 }
829
830 if (dwFlags & MCI_NOTIFY)
832
833 return ret;
834}
static int state
Definition: maze.c:121
#define MCI_FORMAT_RETURN_BASE
Definition: mmddk.h:343
#define MCI_INTEGER_RETURNED
Definition: mmddk.h:372
LONGLONG REFERENCE_TIME
Definition: dmusicks.h:9
#define MCI_STATUS_POSITION
Definition: mmsystem.h:745
#define MCI_MODE_PLAY
Definition: mmsystem.h:696
#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_STOP
Definition: mmsystem.h:695
#define MCI_STATUS_MEDIA_PRESENT
Definition: mmsystem.h:748
#define MCI_MODE_PAUSE
Definition: mmsystem.h:699
#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
long LONG
Definition: pedump.c:60
DWORD_PTR dwReturn
Definition: digitalv.h:809
DWORD_PTR dwCallback
Definition: digitalv.h:808
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
#define WAIT_OBJECT_0
Definition: winbase.h:406

Referenced by MCIQTZ_DriverProc().

◆ MCIQTZ_mciStop()

static DWORD MCIQTZ_mciStop ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_GENERIC_PARMS  lpParms 
)
static

Definition at line 509 of file mciqtz.c.

510{
511 WINE_MCIQTZ* wma;
512
513 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
514
515 wma = MCIQTZ_mciGetOpenDev(wDevID);
516 if (!wma)
518
519 if (!wma->opened)
520 return 0;
521
522 if (wma->thread) {
523 SetEvent(wma->stop_event);
525 CloseHandle(wma->thread);
526 wma->thread = NULL;
527 }
528
529 if (!wma->parent)
530 IVideoWindow_put_Visible(wma->vidwin, OAFALSE);
531
532 return 0;
533}
#define INFINITE
Definition: serial.h:102
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733

Referenced by MCIQTZ_DriverProc(), MCIQTZ_drvConfigure(), MCIQTZ_mciClose(), MCIQTZ_mciOpen(), and MCIQTZ_mciSeek().

◆ MCIQTZ_mciUpdate()

static DWORD MCIQTZ_mciUpdate ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_DGV_UPDATE_PARMS  lpParms 
)
static

Definition at line 1003 of file mciqtz.c.

1004{
1005 WINE_MCIQTZ *wma;
1006 DWORD res = 0;
1007
1008 TRACE("%04x, %08x, %p\n", wDevID, dwFlags, lpParms);
1009
1010 if(!lpParms)
1012
1013 wma = MCIQTZ_mciGetOpenDev(wDevID);
1014 if (!wma)
1016
1018 LONG state, size;
1019 BYTE *data;
1021 HRESULT hr;
1022 RECT src, dest;
1023 LONG visible = OATRUE;
1024
1026 IMediaControl_GetState(wma->pmctrl, -1, &state);
1027 if (state == State_Running)
1029 /* If in stopped state, nothing has been drawn to screen
1030 * moving to pause, which is needed for the old dib renderer, will result
1031 * in a single frame drawn, so hide the window here */
1032 IVideoWindow_get_Visible(wma->vidwin, &visible);
1033 if (wma->parent)
1034 IVideoWindow_put_Visible(wma->vidwin, OAFALSE);
1035 /* FIXME: Should we check the original state and restore it? */
1036 IMediaControl_Pause(wma->pmctrl);
1037 IMediaControl_GetState(wma->pmctrl, -1, &state);
1038 if (FAILED(hr = IBasicVideo_GetCurrentImage(wma->vidbasic, &size, NULL))) {
1039 WARN("Could not get image size (hr = %x)\n", hr);
1040 goto out;
1041 }
1043 info = (BITMAPINFO*)data;
1044 IBasicVideo_GetCurrentImage(wma->vidbasic, &size, (LONG*)data);
1045 data += info->bmiHeader.biSize;
1046
1047 IBasicVideo_GetSourcePosition(wma->vidbasic, &src.left, &src.top, &src.right, &src.bottom);
1048 IBasicVideo_GetDestinationPosition(wma->vidbasic, &dest.left, &dest.top, &dest.right, &dest.bottom);
1049 StretchDIBits(lpParms->hDC,
1050 dest.left, dest.top, dest.right + dest.left, dest.bottom + dest.top,
1051 src.left, src.top, src.right + src.left, src.bottom + src.top,
1054 res = 0;
1055out:
1056 if (wma->parent)
1057 IVideoWindow_put_Visible(wma->vidwin, visible);
1058 }
1059 else if (dwFlags)
1060 FIXME("Unhandled flags %x\n", dwFlags);
1061 return res;
1062}
#define MCI_DGV_UPDATE_HDC
Definition: digitalv.h:439
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLsizeiptr size
Definition: glext.h:5919
GLuint res
Definition: glext.h:9613
GLenum src
Definition: glext.h:6340
static char * dest
Definition: rtl.c:135
static FILE * out
Definition: regtests2xml.c:44
#define DIB_RGB_COLORS
Definition: wingdi.h:367
#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)
unsigned char BYTE
Definition: xxhash.c:193

Referenced by MCIQTZ_DriverProc().

◆ MCIQTZ_mciWhere()

static DWORD MCIQTZ_mciWhere ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_DGV_RECT_PARMS  lpParms 
)
static

Definition at line 839 of file mciqtz.c.

840{
841 WINE_MCIQTZ* wma;
842 HRESULT hr;
843 HWND hWnd;
844 RECT rc;
846
847 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
848
849 if(!lpParms)
851
852 wma = MCIQTZ_mciGetOpenDev(wDevID);
853 if (!wma)
855
856 hr = IVideoWindow_get_Owner(wma->vidwin, (OAHWND*)&hWnd);
857 if (FAILED(hr)) {
858 TRACE("No video stream, returning no window error\n");
859 return MCIERR_NO_WINDOW;
860 }
861
864 FIXME("MCI_DGV_WHERE_SOURCE_MAX stub\n");
865 IBasicVideo_GetSourcePosition(wma->vidbasic, &rc.left, &rc.top, &rc.right, &rc.bottom);
866 TRACE("MCI_DGV_WHERE_SOURCE %s\n", wine_dbgstr_rect(&rc));
867 }
870 FIXME("MCI_DGV_WHERE_DESTINATION_MAX stub\n");
871 IBasicVideo_GetDestinationPosition(wma->vidbasic, &rc.left, &rc.top, &rc.right, &rc.bottom);
872 TRACE("MCI_DGV_WHERE_DESTINATION %s\n", wine_dbgstr_rect(&rc));
873 }
876 FIXME("MCI_DGV_WHERE_FRAME_MAX not supported yet\n");
877 else
878 FIXME("MCI_DGV_WHERE_FRAME not supported yet\n");
879 goto out;
880 }
883 FIXME("MCI_DGV_WHERE_VIDEO_MAX not supported yet\n");
884 else
885 FIXME("MCI_DGV_WHERE_VIDEO not supported yet\n");
886 goto out;
887 }
891 rc.right -= rc.left;
892 rc.bottom -= rc.top;
893 TRACE("MCI_DGV_WHERE_WINDOW_MAX %s\n", wine_dbgstr_rect(&rc));
894 } else {
895 IVideoWindow_GetWindowPosition(wma->vidwin, &rc.left, &rc.top, &rc.right, &rc.bottom);
896 TRACE("MCI_DGV_WHERE_WINDOW %s\n", wine_dbgstr_rect(&rc));
897 }
898 }
899 ret = 0;
900out:
901 lpParms->rc = rc;
902 return ret;
903}
HWND hWnd
Definition: settings.c:17
#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
#define MCIERR_NO_WINDOW
Definition: mmsystem.h:639
static __inline const char * wine_dbgstr_rect(const RECT *rect)
Definition: debug.h:219
BOOL WINAPI GetWindowRect(_In_ HWND, _Out_ LPRECT)
HWND WINAPI GetDesktopWindow(void)
Definition: window.c:656

Referenced by MCIQTZ_DriverProc().

◆ MCIQTZ_mciWindow()

static DWORD MCIQTZ_mciWindow ( UINT  wDevID,
DWORD  dwFlags,
LPMCI_DGV_WINDOW_PARMSW  lpParms 
)
static

Definition at line 908 of file mciqtz.c.

909{
910 WINE_MCIQTZ *wma = MCIQTZ_mciGetOpenDev(wDevID);
911
912 TRACE("(%04x, %08X, %p)\n", wDevID, dwFlags, lpParms);
913
914 if(!lpParms)
916
917 if (!wma)
919 if (dwFlags & MCI_TEST)
920 return 0;
921
922 if (dwFlags & MCI_DGV_WINDOW_HWND && (IsWindow(lpParms->hWnd) || !lpParms->hWnd)) {
923 LONG visible = OATRUE;
924 LONG style = 0;
925 TRACE("Setting hWnd to %p\n", lpParms->hWnd);
926 IVideoWindow_get_Visible(wma->vidwin, &visible);
927 IVideoWindow_put_Visible(wma->vidwin, OAFALSE);
928 IVideoWindow_get_WindowStyle(wma->vidwin, &style);
929 style &= ~WS_CHILD;
930 if (lpParms->hWnd)
931 IVideoWindow_put_WindowStyle(wma->vidwin, style|WS_CHILD);
932 else
933 IVideoWindow_put_WindowStyle(wma->vidwin, style);
934 IVideoWindow_put_Owner(wma->vidwin, (OAHWND)lpParms->hWnd);
935 IVideoWindow_put_MessageDrain(wma->vidwin, (OAHWND)lpParms->hWnd);
936 IVideoWindow_put_Visible(wma->vidwin, visible);
937 wma->parent = lpParms->hWnd;
938 }
940 TRACE("Setting nCmdShow to %d\n", lpParms->nCmdShow);
941 IVideoWindow_put_WindowState(wma->vidwin, lpParms->nCmdShow);
942 }
944 TRACE("Setting caption to %s\n", debugstr_w(lpParms->lpstrText));
945 IVideoWindow_put_Caption(wma->vidwin, lpParms->lpstrText);
946 }
947 return 0;
948}
#define MCI_DGV_WINDOW_STATE
Definition: digitalv.h:454
#define MCI_DGV_WINDOW_TEXT
Definition: digitalv.h:455
#define MCI_DGV_WINDOW_HWND
Definition: digitalv.h:453
BOOL WINAPI IsWindow(_In_opt_ HWND)

Referenced by MCIQTZ_DriverProc().

◆ MCIQTZ_notifyThread()

static DWORD CALLBACK MCIQTZ_notifyThread ( LPVOID  parm)
static

Definition at line 329 of file mciqtz.c.

330{
331 WINE_MCIQTZ* wma = (WINE_MCIQTZ *)parm;
332 HRESULT hr;
333 HANDLE handle[2];
334 DWORD n = 0, ret = 0;
335
336 handle[n++] = wma->stop_event;
337 IMediaEvent_GetEventHandle(wma->mevent, (OAEVENT *)&handle[n++]);
338
339 for (;;) {
340 DWORD r;
341 HANDLE old;
342
344 if (r == WAIT_OBJECT_0) {
345 TRACE("got stop event\n");
347 if (old)
349 break;
350 }
351 else if (r == WAIT_OBJECT_0+1) {
352 LONG event_code;
353 LONG_PTR p1, p2;
354 do {
355 hr = IMediaEvent_GetEvent(wma->mevent, &event_code, &p1, &p2, 0);
356 if (SUCCEEDED(hr)) {
357 TRACE("got event_code = 0x%02x\n", event_code);
358 IMediaEvent_FreeEventParams(wma->mevent, event_code, p1, p2);
359 }
360 } while (hr == S_OK && event_code != EC_COMPLETE);
361 if (hr == S_OK && event_code == EC_COMPLETE) {
362 /* Repeat the music by seeking and running again */
363 if (wma->mci_flags & MCI_DGV_PLAY_REPEAT) {
364 TRACE("repeat media as requested\n");
365 IMediaControl_Stop(wma->pmctrl);
366 IMediaSeeking_SetPositions(wma->seek,
367 &wma->seek_start,
369 &wma->seek_stop,
371 IMediaControl_Run(wma->pmctrl);
372 continue;
373 }
375 if (old)
377 break;
378 }
379 }
380 else {
381 TRACE("Unknown error (%d)\n", (int)r);
382 break;
383 }
384 }
385
386 hr = IMediaControl_Stop(wma->pmctrl);
387 if (FAILED(hr)) {
388 TRACE("Cannot stop filtergraph (hr = %x)\n", hr);
390 }
391
392 return ret;
393}
#define MCI_DGV_PLAY_REPEAT
Definition: digitalv.h:227
#define EC_COMPLETE
Definition: evcode.h:17
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLdouble n
Definition: glext.h:7729
#define S_OK
Definition: intsafe.h:52
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
DWORD WINAPI WaitForMultipleObjects(IN DWORD nCount, IN CONST HANDLE *lpHandles, IN BOOL bWaitAll, IN DWORD dwMilliseconds)
Definition: synch.c:151

Referenced by MCIQTZ_mciPlay().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( mciqtz  )

Variable Documentation

◆ MCIQTZ_hInstance

HINSTANCE MCIQTZ_hInstance = 0
static

Definition at line 41 of file mciqtz.c.

Referenced by DllMain(), and MCIQTZ_drvOpen().