static VOID NTAPI
GuiDeinitFrontEnd(IN OUT PFRONTEND This)
{
PGUI_CONSOLE_DATA GuiData = This->Context;
DPRINT("Send PM_DESTROY_CONSOLE message and wait on hGuiTermEvent...\n");
PostThreadMessageW(GuiData->InputThreadId, PM_DESTROY_CONSOLE, 0, (LPARAM)GuiData);
NtWaitForSingleObject(GuiData->hGuiTermEvent, FALSE, NULL);
DPRINT("hGuiTermEvent set\n");
NtClose(GuiData->hGuiTermEvent);
GuiData->hGuiTermEvent = NULL;
CloseDesktop(GuiData->Desktop); // NtUserCloseDesktop
CloseWindowStation(GuiData->WinSta); // NtUserCloseWindowStation
DPRINT("Destroying icons !! - GuiData->hIcon = 0x%p ; ghDefaultIcon = 0x%p ; GuiData->hIconSm = 0x%p ; ghDefaultIconSm = 0x%p\n",
GuiData->hIcon, ghDefaultIcon, GuiData->hIconSm, ghDefaultIconSm);
if (GuiData->hIcon != NULL && GuiData->hIcon != ghDefaultIcon)
{
DPRINT("Destroy hIcon\n");
DestroyIcon(GuiData->hIcon);
}
if (GuiData->hIconSm != NULL && GuiData->hIconSm != ghDefaultIconSm)
{
DPRINT("Destroy hIconSm\n");
DestroyIcon(GuiData->hIconSm);
}
This->Context = NULL;
DeleteCriticalSection(&GuiData->Lock);
ConsoleFreeHeap(GuiData);
DPRINT("Quit GuiDeinitFrontEnd\n");
}
static ULONG WINAPI DSoundRender_Release(IBaseFilter * iface)
{
DSoundRenderImpl *This = impl_from_IBaseFilter(iface);
ULONG refCount = BaseRendererImpl_Release(iface);
TRACE("(%p)->() Release from %d\n", This, refCount + 1);
if (!refCount)
{
if (This->threadid) {
PostThreadMessageW(This->threadid, WM_APP, 0, 0);
WaitForSingleObject(This->advisethread, INFINITE);
CloseHandle(This->advisethread);
}
if (This->dsbuffer)
IDirectSoundBuffer_Release(This->dsbuffer);
This->dsbuffer = NULL;
if (This->dsound)
IDirectSound_Release(This->dsound);
This->dsound = NULL;
BasicAudio_Destroy(&This->basicAudio);
CloseHandle(This->blocked);
TRACE("Destroying Audio Renderer\n");
CoTaskMemFree(This);
return 0;
}
else
return refCount;
}
void Bang::Execute(HWND hCaller, LPCWSTR pwzParams) const
{
if (GetCurrentThreadId() != m_dwThreadID)
{
ThreadedBangCommand * pInfo = new ThreadedBangCommand(hCaller,
m_pwzCommand, pwzParams);
if (pInfo != nullptr)
{
// target thread releases pInfo
PostThreadMessageW(m_dwThreadID, LM_THREAD_BANGCOMMAND,
(WPARAM)pInfo, 0);
}
}
else
{
if (m_bEX)
{
m_bBangEX(hCaller, m_pwzCommand, pwzParams);
}
else
{
m_bBang(hCaller, pwzParams);
}
}
}
static BOOL SystemClockPostMessageToAdviseThread(SystemClockImpl* This, UINT iMsg) {
if (FALSE == This->adviseThreadActive) {
BOOL res;
This->adviseThread = CreateThread(NULL, 0, SystemClockAdviseThread, This, 0, &This->adviseThreadId);
if (NULL == This->adviseThread) return FALSE;
SetThreadPriority(This->adviseThread, THREAD_PRIORITY_TIME_CRITICAL);
This->adviseThreadActive = TRUE;
while(1) {
res = PostThreadMessageW(This->adviseThreadId, iMsg, 0, 0);
/* Let the thread creates its message queue (with MsgWaitForMultipleObjects call) by yielding and retrying */
if (!res && (GetLastError() == ERROR_INVALID_THREAD_ID))
Sleep(0);
else
break;
}
return res;
}
return PostThreadMessageW(This->adviseThreadId, iMsg, 0, 0);
}
static HRESULT WINAPI ReferenceClock_Unadvise(IReferenceClock *iface,
DWORD_PTR dwAdviseCookie)
{
DSoundRenderImpl *This = impl_from_IReferenceClock(iface);
TRACE("(%p/%p)->(%p)\n", This, iface, (void*)dwAdviseCookie);
if (!This->advisethread || !dwAdviseCookie)
return S_FALSE;
PostThreadMessageW(This->threadid, WM_APP+3, dwAdviseCookie, 0);
return S_OK;
}
static HRESULT WINAPI DSoundRender_BreakConnect(BaseRenderer* iface)
{
DSoundRenderImpl *This = impl_from_BaseRenderer(iface);
TRACE("(%p)->()\n", iface);
if (This->threadid) {
PostThreadMessageW(This->threadid, WM_APP, 0, 0);
LeaveCriticalSection(This->renderer.pInputPin->pin.pCritSec);
WaitForSingleObject(This->advisethread, INFINITE);
EnterCriticalSection(This->renderer.pInputPin->pin.pCritSec);
CloseHandle(This->advisethread);
}
if (This->dsbuffer)
IDirectSoundBuffer_Release(This->dsbuffer);
This->dsbuffer = NULL;
return S_OK;
}
static HRESULT WINAPI ReferenceClock_AdviseTime(IReferenceClock *iface,
REFERENCE_TIME rtBaseTime,
REFERENCE_TIME rtStreamTime,
HEVENT hEvent,
DWORD_PTR *pdwAdviseCookie)
{
DSoundRenderImpl *This = impl_from_IReferenceClock(iface);
REFERENCE_TIME when = rtBaseTime + rtStreamTime;
REFERENCE_TIME future;
TRACE("(%p/%p)->(%s, %s, %p, %p)\n", This, iface, wine_dbgstr_longlong(rtBaseTime), wine_dbgstr_longlong(rtStreamTime), (void*)hEvent, pdwAdviseCookie);
if (when <= 0)
return E_INVALIDARG;
if (!pdwAdviseCookie)
return E_POINTER;
EnterCriticalSection(&This->renderer.filter.csFilter);
future = when - This->play_time;
if (!This->threadid && This->dsbuffer) {
This->thread_wait = CreateEventW(0, 0, 0, 0);
This->advisethread = CreateThread(NULL, 0, DSoundAdviseThread, This, 0, &This->threadid);
WaitForSingleObject(This->thread_wait, INFINITE);
CloseHandle(This->thread_wait);
}
LeaveCriticalSection(&This->renderer.filter.csFilter);
/* If it's in the past or the next millisecond, trigger immediately */
if (future <= 10000) {
SetEvent((HANDLE)hEvent);
*pdwAdviseCookie = 0;
} else {
struct dsoundrender_timer *t = HeapAlloc(GetProcessHeap(), 0, sizeof(*t));
t->next = NULL;
t->start = when;
t->periodicity = 0;
t->handle = (HANDLE)hEvent;
t->cookie = InterlockedIncrement(&cookie_counter);
PostThreadMessageW(This->threadid, WM_APP+1, (WPARAM)t, 0);
*pdwAdviseCookie = t->cookie;
}
return S_OK;
}
static ULONG WINAPI VideoRendererInner_Release(IUnknown * iface)
{
ICOM_THIS_MULTI(VideoRendererImpl, IInner_vtbl, iface);
ULONG refCount = BaseRendererImpl_Release(&This->renderer.filter.IBaseFilter_iface);
TRACE("(%p/%p)->() Release from %d\n", This, iface, refCount + 1);
if (!refCount)
{
BaseWindowImpl_DoneWithWindow(&This->baseControlWindow.baseWindow);
PostThreadMessageW(This->ThreadID, WM_QUIT, 0, 0);
WaitForSingleObject(This->hThread, INFINITE);
CloseHandle(This->hThread);
CloseHandle(This->hEvent);
TRACE("Destroying Video Renderer\n");
CoTaskMemFree(This);
return 0;
}
else
return refCount;
}
static HRESULT WINAPI ReferenceClock_AdvisePeriodic(IReferenceClock *iface,
REFERENCE_TIME rtStartTime,
REFERENCE_TIME rtPeriodTime,
HSEMAPHORE hSemaphore,
DWORD_PTR *pdwAdviseCookie)
{
DSoundRenderImpl *This = impl_from_IReferenceClock(iface);
struct dsoundrender_timer *t;
TRACE("(%p/%p)->(%s, %s, %p, %p)\n", This, iface, wine_dbgstr_longlong(rtStartTime), wine_dbgstr_longlong(rtPeriodTime), (void*)hSemaphore, pdwAdviseCookie);
if (rtStartTime <= 0 || rtPeriodTime <= 0)
return E_INVALIDARG;
if (!pdwAdviseCookie)
return E_POINTER;
EnterCriticalSection(&This->renderer.filter.csFilter);
if (!This->threadid && This->dsbuffer) {
This->thread_wait = CreateEventW(0, 0, 0, 0);
This->advisethread = CreateThread(NULL, 0, DSoundAdviseThread, This, 0, &This->threadid);
WaitForSingleObject(This->thread_wait, INFINITE);
CloseHandle(This->thread_wait);
}
LeaveCriticalSection(&This->renderer.filter.csFilter);
t = HeapAlloc(GetProcessHeap(), 0, sizeof(*t));
t->next = NULL;
t->start = rtStartTime;
t->periodicity = rtPeriodTime;
t->handle = (HANDLE)hSemaphore;
t->cookie = InterlockedIncrement(&cookie_counter);
PostThreadMessageW(This->threadid, WM_APP+1, (WPARAM)t, 0);
*pdwAdviseCookie = t->cookie;
return S_OK;
}
static ULONG WINAPI VideoRendererInner_Release(IUnknown *iface)
{
VideoRendererImpl *This = impl_from_IUnknown(iface);
ULONG refCount = BaseRendererImpl_Release(&This->renderer.filter.IBaseFilter_iface);
TRACE("(%p)->(): new ref = %d\n", This, refCount);
if (!refCount)
{
BaseControlWindow_Destroy(&This->baseControlWindow);
BaseControlVideo_Destroy(&This->baseControlVideo);
PostThreadMessageW(This->ThreadID, WM_QUIT, 0, 0);
WaitForSingleObject(This->hThread, INFINITE);
CloseHandle(This->hThread);
CloseHandle(This->hEvent);
TRACE("Destroying Video Renderer\n");
CoTaskMemFree(This);
return 0;
}
else
return refCount;
}
/******************************************************************
* mmTaskSignal (WINMM.@)
*/
BOOL WINAPI mmTaskSignal(DWORD tid)
{
return PostThreadMessageW(tid, WM_USER, 0, 0);
}
static NTSTATUS NTAPI
GuiInitFrontEnd(IN OUT PFRONTEND This,
IN PCONSRV_CONSOLE Console)
{
PGUI_INIT_INFO GuiInitInfo;
PGUI_CONSOLE_DATA GuiData;
if (This == NULL || Console == NULL || This->Context2 == NULL)
return STATUS_INVALID_PARAMETER;
ASSERT(This->Console == Console);
GuiInitInfo = This->Context2;
/* Terminal data allocation */
GuiData = ConsoleAllocHeap(HEAP_ZERO_MEMORY, sizeof(*GuiData));
if (!GuiData)
{
DPRINT1("CONSRV: Failed to create GUI_CONSOLE_DATA\n");
return STATUS_UNSUCCESSFUL;
}
/// /* HACK */ Console->FrontEndIFace.Context = (PVOID)GuiData; /* HACK */
GuiData->Console = Console;
GuiData->ActiveBuffer = Console->ActiveBuffer;
GuiData->hWindow = NULL;
GuiData->IsWindowVisible = GuiInitInfo->IsWindowVisible;
/* The console can be resized */
Console->FixedSize = FALSE;
InitializeCriticalSection(&GuiData->Lock);
/*
* Set up GUI data
*/
RtlCopyMemory(&GuiData->GuiInfo, &GuiInitInfo->TermInfo, sizeof(GuiInitInfo->TermInfo));
/* Initialize the icon handles */
if (GuiInitInfo->hIcon != NULL)
GuiData->hIcon = GuiInitInfo->hIcon;
else
GuiData->hIcon = ghDefaultIcon;
if (GuiInitInfo->hIconSm != NULL)
GuiData->hIconSm = GuiInitInfo->hIconSm;
else
GuiData->hIconSm = ghDefaultIconSm;
ASSERT(GuiData->hIcon && GuiData->hIconSm);
/* Mouse is shown by default with its default cursor shape */
GuiData->hCursor = ghDefaultCursor;
GuiData->MouseCursorRefCount = 0;
/* A priori don't ignore mouse signals */
GuiData->IgnoreNextMouseSignal = FALSE;
/* Initialize HACK FOR CORE-8394. See conwnd.c!OnMouse for more details. */
GuiData->HackCORE8394IgnoreNextMove = FALSE;
/* Close button and the corresponding system menu item are enabled by default */
GuiData->IsCloseButtonEnabled = TRUE;
/* There is no user-reserved menu id range by default */
GuiData->CmdIdLow = GuiData->CmdIdHigh = 0;
/* Initialize the selection */
RtlZeroMemory(&GuiData->Selection, sizeof(GuiData->Selection));
GuiData->Selection.dwFlags = CONSOLE_NO_SELECTION;
RtlZeroMemory(&GuiData->dwSelectionCursor, sizeof(GuiData->dwSelectionCursor));
GuiData->LineSelection = FALSE; // Default to block selection
// TODO: Retrieve the selection mode via the registry.
GuiData->InputThreadId = GuiInitInfo->InputThreadId;
GuiData->WinSta = GuiInitInfo->WinSta;
GuiData->Desktop = GuiInitInfo->Desktop;
/* Finally, finish to initialize the frontend structure */
This->Context = GuiData;
ConsoleFreeHeap(This->Context2);
This->Context2 = NULL;
/*
* We need to wait until the GUI has been fully initialized
* to retrieve custom settings i.e. WindowSize etc...
* Ideally we could use SendNotifyMessage for this but its not
* yet implemented.
*/
NtCreateEvent(&GuiData->hGuiInitEvent, EVENT_ALL_ACCESS,
NULL, SynchronizationEvent, FALSE);
NtCreateEvent(&GuiData->hGuiTermEvent, EVENT_ALL_ACCESS,
NULL, SynchronizationEvent, FALSE);
DPRINT("GUI - Checkpoint\n");
/* Create the terminal window */
PostThreadMessageW(GuiData->InputThreadId, PM_CREATE_CONSOLE, 0, (LPARAM)GuiData);
/* Wait until initialization has finished */
NtWaitForSingleObject(GuiData->hGuiInitEvent, FALSE, NULL);
DPRINT("OK we created the console window\n");
NtClose(GuiData->hGuiInitEvent);
GuiData->hGuiInitEvent = NULL;
/* Check whether we really succeeded in initializing the terminal window */
if (GuiData->hWindow == NULL)
{
DPRINT("GuiInitConsole - We failed at creating a new terminal window\n");
GuiDeinitFrontEnd(This);
return STATUS_UNSUCCESSFUL;
}
return STATUS_SUCCESS;
}
