doubango-android/plugins/pluginDirectShow/internals/DSUtils.cxx

/* Copyright (C) 2011-2013 Doubango Telecom <http://www.doubango.org>
*
* This file is part of Open Source Doubango Framework.
*
* DOUBANGO is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* DOUBANGO is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with DOUBANGO.
*/
#include "internals/DSUtils.h"

#if defined (_WIN32_WCE)
#include <atlbase.h>
#include <atlstr.h>
#else
#include <atlconv.h>
#include <d3d9.h>
#endif

#include "tsk_debug.h"

HWND GetMainWindow()
{
    HWND hWnd;
    if (!(hWnd = GetActiveWindow())) {
        if (!(hWnd = GetForegroundWindow())) {
#if !defined(_WIN32_WCE)
            if (!(hWnd = GetConsoleWindow())) {
                return NULL;
            }
#endif
        }
    }
    return hWnd;
}

bool IsMainThread()
{
    HWND hWnd = GetMainWindow();
    if (hWnd) {
        DWORD mainTid = GetWindowThreadProcessId(hWnd, NULL);
        DWORD currentTid = GetCurrentThreadId();
        return (mainTid == currentTid);
    }
    return false;
}

bool IsD3D9Supported()
{
#if defined(_WIN32_WCE)
    return false;
#else
    static bool g_bChecked = false;
    static bool g_bSupported = false;

    if (g_bChecked) {
        return g_bSupported;
    }
    g_bChecked = true;
    HRESULT hr = S_OK;
    IDirect3D9* pD3D = NULL;
    D3DDISPLAYMODE mode = { 0 };
    D3DPRESENT_PARAMETERS pp = {0};
    IDirect3DDevice9* pDevice = NULL;

    if (!(pD3D = Direct3DCreate9(D3D_SDK_VERSION))) {
        hr = E_OUTOFMEMORY;
        goto bail;
    }

    hr = pD3D->GetAdapterDisplayMode(
             D3DADAPTER_DEFAULT,
             &mode
         );
    if (FAILED(hr)) {
        goto bail;
    }

    hr = pD3D->CheckDeviceType(
             D3DADAPTER_DEFAULT,
             D3DDEVTYPE_HAL,
             mode.Format,
             D3DFMT_X8R8G8B8,
             TRUE    // windowed
         );
    if (FAILED(hr)) {
        goto bail;
    }
    pp.BackBufferFormat = D3DFMT_X8R8G8B8;
    pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    pp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
    pp.Windowed = TRUE;
    pp.hDeviceWindow = GetDesktopWindow();
    hr = pD3D->CreateDevice(
             D3DADAPTER_DEFAULT,
             D3DDEVTYPE_HAL,
             pp.hDeviceWindow,
             D3DCREATE_HARDWARE_VERTEXPROCESSING,
             &pp,
             &pDevice
         );
    if (FAILED(hr)) {
        goto bail;
    }

    // Everythings is OK
    g_bSupported = true;
    TSK_DEBUG_INFO("D3D9 supported");

bail:
    if (!g_bSupported) {
        TSK_DEBUG_WARN("D3D9 not supported");
    }
    SAFE_RELEASE(pDevice);
    SAFE_RELEASE(pD3D);
    return g_bSupported;
#endif /* _WIN32_WCE */
}

IPin *GetPin(IBaseFilter *filter, PIN_DIRECTION direction)
{
    IEnumPins	*enumPins = NULL;
    IPin		*pin = NULL;

    HRESULT hr = filter->EnumPins(&enumPins);
    if(!enumPins) {
        return NULL;
    }

    for(;;) {
        ULONG fetched = 0;
        PIN_DIRECTION pinDir = PIN_DIRECTION(-1);
        pin = NULL;

        if (FAILED(enumPins->Next(1, &pin, &fetched))) {
            enumPins->Release();
            return NULL;
        }

        if (fetched == 1 && pin) {
            pin->QueryDirection(&pinDir);
            if(pinDir == direction) {
                break;
            }
            pin->Release();
        }
    }

    enumPins->Release();
    return pin;
}

HRESULT ConnectFilters(IGraphBuilder *graphBuilder, IBaseFilter *source, IBaseFilter *destination, AM_MEDIA_TYPE *mediaType)
{
    HRESULT hr;

    IPin *outPin = GetPin(source, PINDIR_OUTPUT);
    IPin *inPin = GetPin(destination, PINDIR_INPUT);

    if (mediaType != NULL) {
        hr = graphBuilder->ConnectDirect(outPin, inPin, mediaType);
    }
    else {
        hr = graphBuilder->Connect(outPin, inPin);
    }

    SAFE_RELEASE(outPin);
    SAFE_RELEASE(inPin);

    return hr;
}

HRESULT DisconnectFilters(IGraphBuilder *graphBuilder, IBaseFilter *source, IBaseFilter *destination)
{
    HRESULT hr;

    IPin *outPin = GetPin(source, PINDIR_OUTPUT);
    IPin *inPin = GetPin(destination, PINDIR_INPUT);

    if (inPin) {
        hr = graphBuilder->Disconnect(inPin);
    }

    if (outPin) {
        hr = graphBuilder->Disconnect(outPin);
    }

    SAFE_RELEASE(outPin);
    SAFE_RELEASE(inPin);

    return hr;
}

bool DisconnectAllFilters(IGraphBuilder *graphBuilder)
{
    IEnumFilters* filterEnum = NULL;
    IBaseFilter* currentFilter = NULL;
    ULONG fetched;
    HRESULT hr;

    hr = graphBuilder->EnumFilters(&filterEnum);
    if (FAILED(hr)) {
        SAFE_RELEASE(filterEnum);
        return false;
    }

    while(filterEnum->Next(1, &currentFilter, &fetched) == S_OK) {
        hr = DisconnectFilters(graphBuilder, currentFilter, currentFilter);
        SAFE_RELEASE(currentFilter);
    }
    SAFE_RELEASE(filterEnum);
    SAFE_RELEASE(currentFilter);
    return true;
}

bool RemoveAllFilters(IGraphBuilder *graphBuilder)
{
    IEnumFilters* filterEnum = NULL;
    IBaseFilter* currentFilter = NULL;
    ULONG fetched;
    HRESULT hr;

    hr = graphBuilder->EnumFilters(&filterEnum);
    if (FAILED(hr)) {
        return false;
    }

    while(filterEnum->Next(1, &currentFilter, &fetched) == S_OK) {
        hr = graphBuilder->RemoveFilter(currentFilter);
        if (FAILED(hr)) {
            SAFE_RELEASE(filterEnum);
            return false;
        }
        SAFE_RELEASE(currentFilter);
        filterEnum->Reset();
    }

    SAFE_RELEASE(filterEnum);
    SAFE_RELEASE(currentFilter);
    return true;
}


#include "internals/DSDisplay.h"
#include "internals/DSGrabber.h"

#define WM_CREATE_DISPLAY_ON_UI_THREAD				(WM_USER + 101)
#define WM_CREATE_GRABBER_ON_UI_THREAD				(WM_CREATE_DISPLAY_ON_UI_THREAD + 1)
#define WM_CREATE_ON_UI_THREAD_TIMEOUT		1000

// C Callback that dispatch event to create display on UI thread
static LRESULT CALLBACK __create__WndProcWindow(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    HANDLE* event = reinterpret_cast<HANDLE*>(wParam);
    BOOL* isScreenCast = reinterpret_cast<BOOL*>(GetProp(hWnd, TEXT("screnCast")));

    if(event && lParam) {
        switch(uMsg) {
        case WM_CREATE_DISPLAY_ON_UI_THREAD: {
            HRESULT hr;
            DSDisplay** ppDisplay = reinterpret_cast<DSDisplay**>(lParam);
            *ppDisplay = new DSDisplay(&hr);
            SetEvent(event);
            break;
        }
        case WM_CREATE_GRABBER_ON_UI_THREAD: {
            HRESULT hr;
            DSGrabber** ppGrabber = reinterpret_cast<DSGrabber**>(lParam);
            *ppGrabber = new DSGrabber(&hr, *isScreenCast);
            SetEvent(event);
            break;
        }
        }
    }
    return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

int createOnCurrentThead(HWND hWnd, void** ppRet, BOOL display, BOOL screnCast)
{
    HRESULT hr;
    if(display) {
        *ppRet = new DSDisplay(&hr);
    }
    else {
        *ppRet = new DSGrabber(&hr, screnCast);
    }
    if(FAILED(hr)) {
        TSK_DEBUG_ERROR("Failed to created DirectShow %s", display ? "Display" : "Grabber");
        SAFE_DELETE_PTR(*ppRet);
        return -2;
    }
    return 0;
}

int createOnUIThead(HWND hWnd, void** ppRet, BOOL display, BOOL screnCast)
{
    static BOOL __isScreenCastFalse = FALSE;
    static BOOL __isScreenCastTrue = TRUE;
    if(!ppRet) {
        TSK_DEBUG_ERROR("Invalid parameter");
        return -1;
    }

    if (IsMainThread()) {
        return createOnCurrentThead(hWnd, ppRet, display, screnCast);
    }
    else {
        TSK_DEBUG_INFO("Create DirectShow element on worker thread");
        HANDLE event = NULL;
        int ret = 0;
        DWORD retWait, retryCount = 3;

        if(!hWnd) {
            if (!(hWnd = FindWindow(NULL, TEXT("Boghe - IMS/RCS Client")))) {
                if(!(hWnd = GetMainWindow())) {
                    TSK_DEBUG_ERROR("No Window handle could be used");
                    return -2;
                }
            }
        }
#if defined(_WIN32_WCE)
        WNDPROC wndProc = (WNDPROC) SetWindowLong(hWnd, GWL_WNDPROC, (LONG) __create__WndProcWindow);
#else
        WNDPROC wndProc = (WNDPROC) SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR) __create__WndProcWindow);
#endif
        if (!wndProc) {
            TSK_DEBUG_ERROR("SetWindowLongPtr() failed with errcode=%d", GetLastError());
            return createOnCurrentThead(hWnd, ppRet, display, screnCast);
        }

        if (!(event = CreateEvent(NULL, TRUE, FALSE, NULL))) {
            TSK_DEBUG_ERROR("Failed to create new event");
            ret = -4;
            goto bail;
        }
        SetProp(hWnd, TEXT("screnCast"), screnCast ? &__isScreenCastTrue : &__isScreenCastFalse);
        if (!PostMessage(hWnd, display ? WM_CREATE_DISPLAY_ON_UI_THREAD : WM_CREATE_GRABBER_ON_UI_THREAD, reinterpret_cast<WPARAM>(event), reinterpret_cast<LPARAM>(ppRet))) {
            TSK_DEBUG_ERROR("PostMessageA() failed");
            ret = -5;
            goto bail;
        }

        do {
            retWait = WaitForSingleObject(event, WM_CREATE_ON_UI_THREAD_TIMEOUT);
        }
        while (retryCount-- > 0 && (retWait == WAIT_TIMEOUT));

bail:
        // restore
        if (hWnd && wndProc) {
#if defined(_WIN32_WCE)
            SetWindowLong(hWnd, GWL_WNDPROC, (LONG)wndProc);
#else
            SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)wndProc);
#endif
        }
        if (event) {
            CloseHandle(event);
        }

        return ret;
    }
}