New Media Foundation samples

//

// DeviceResources.h - A wrapper for the Direct3D 12 device and swapchain

//

#pragma once

namespace DX

{

    // Provides an interface for an application that owns DeviceResources to be notified of the device being lost or created.

    interface IDeviceNotify

    {

        virtual void OnDeviceLost() = 0;

        virtual void OnDeviceRestored() = 0;

    };

    // Controls all the DirectX device resources.

    class DeviceResources

    {

    public:

        static const unsigned int c_AllowTearing    = 0x1;

        static const unsigned int c_EnableHDR       = 0x2;

        DeviceResources(DXGI_FORMAT backBufferFormat = DXGI_FORMAT_B8G8R8A8_UNORM,

                        DXGI_FORMAT depthBufferFormat = DXGI_FORMAT_D32_FLOAT,

                        UINT backBufferCount = 2,

                        D3D_FEATURE_LEVEL minFeatureLevel = D3D_FEATURE_LEVEL_11_0,

                        unsigned int flags = 0) noexcept(false);

        ~DeviceResources();

        void CreateDeviceResources();

        void CreateWindowSizeDependentResources();

        void SetWindow(HWND window, int width, int height);

        bool WindowSizeChanged(int width, int height);

        void HandleDeviceLost();

        void RegisterDeviceNotify(IDeviceNotify* deviceNotify) { m_deviceNotify = deviceNotify; }

        void Prepare(D3D12_RESOURCE_STATES beforeState = D3D12_RESOURCE_STATE_PRESENT);

        void Present(D3D12_RESOURCE_STATES beforeState = D3D12_RESOURCE_STATE_RENDER_TARGET);

        void WaitForGpu() noexcept;

        // Device Accessors.

        RECT GetOutputSize() const { return m_outputSize; }

        // Direct3D Accessors.

        ID3D12Device*               GetD3DDevice() const            { return m_d3dDevice.Get(); }

        IDXGISwapChain3*            GetSwapChain() const            { return m_swapChain.Get(); }

        IDXGIFactory4*              GetDXGIFactory() const          { return m_dxgiFactory.Get(); }

        D3D_FEATURE_LEVEL           GetDeviceFeatureLevel() const   { return m_d3dFeatureLevel; }

        ID3D12Resource*             GetRenderTarget() const         { return m_renderTargets[m_backBufferIndex].Get(); }

        ID3D12Resource*             GetDepthStencil() const         { return m_depthStencil.Get(); }

        ID3D12CommandQueue*         GetCommandQueue() const         { return m_commandQueue.Get(); }

        ID3D12CommandAllocator*     GetCommandAllocator() const     { return m_commandAllocators[m_backBufferIndex].Get(); }

        ID3D12GraphicsCommandList*  GetCommandList() const          { return m_commandList.Get(); }

        DXGI_FORMAT                 GetBackBufferFormat() const     { return m_backBufferFormat; }

        DXGI_FORMAT                 GetDepthBufferFormat() const    { return m_depthBufferFormat; }

        D3D12_VIEWPORT              GetScreenViewport() const       { return m_screenViewport; }

        D3D12_RECT                  GetScissorRect() const          { return m_scissorRect; }

        UINT                        GetCurrentFrameIndex() const    { return m_backBufferIndex; }

        UINT                        GetBackBufferCount() const      { return m_backBufferCount; }

        DXGI_COLOR_SPACE_TYPE       GetColorSpace() const           { return m_colorSpace; }

        unsigned int                GetDeviceOptions() const        { return m_options; }

        CD3DX12_CPU_DESCRIPTOR_HANDLE GetRenderTargetView() const

        {

            return CD3DX12_CPU_DESCRIPTOR_HANDLE(m_rtvDescriptorHeap->GetCPUDescriptorHandleForHeapStart(), m_backBufferIndex, m_rtvDescriptorSize);

        }

        CD3DX12_CPU_DESCRIPTOR_HANDLE GetDepthStencilView() const

        {

            return CD3DX12_CPU_DESCRIPTOR_HANDLE(m_dsvDescriptorHeap->GetCPUDescriptorHandleForHeapStart());

        }

    private:

        void MoveToNextFrame();

        void GetAdapter(IDXGIAdapter1** ppAdapter);

        void UpdateColorSpace();

        static const size_t MAX_BACK_BUFFER_COUNT = 3;

        UINT                                                m_backBufferIndex;

        // Direct3D objects.

        Microsoft::WRL::ComPtr<ID3D12Device>                m_d3dDevice;

        Microsoft::WRL::ComPtr<ID3D12CommandQueue>          m_commandQueue;

        Microsoft::WRL::ComPtr<ID3D12GraphicsCommandList>   m_commandList;

        Microsoft::WRL::ComPtr<ID3D12CommandAllocator>      m_commandAllocators[MAX_BACK_BUFFER_COUNT];

        // Swap chain objects.

        Microsoft::WRL::ComPtr<IDXGIFactory4>               m_dxgiFactory;

        Microsoft::WRL::ComPtr<IDXGISwapChain3>             m_swapChain;

        Microsoft::WRL::ComPtr<ID3D12Resource>              m_renderTargets[MAX_BACK_BUFFER_COUNT];

        Microsoft::WRL::ComPtr<ID3D12Resource>              m_depthStencil;

        // Presentation fence objects.

        Microsoft::WRL::ComPtr<ID3D12Fence>                 m_fence;

        UINT64                                              m_fenceValues[MAX_BACK_BUFFER_COUNT];

        Microsoft::WRL::Wrappers::Event                     m_fenceEvent;

        // Direct3D rendering objects.

        Microsoft::WRL::ComPtr<ID3D12DescriptorHeap>        m_rtvDescriptorHeap;

        Microsoft::WRL::ComPtr<ID3D12DescriptorHeap>        m_dsvDescriptorHeap;

        UINT                                                m_rtvDescriptorSize;

        D3D12_VIEWPORT                                      m_screenViewport;

        D3D12_RECT                                          m_scissorRect;

        // Direct3D properties.

        DXGI_FORMAT                                         m_backBufferFormat;

        DXGI_FORMAT                                         m_depthBufferFormat;

        UINT                                                m_backBufferCount;

        D3D_FEATURE_LEVEL                                   m_d3dMinFeatureLevel;

        // Cached device properties.

        HWND                                                m_window;

        D3D_FEATURE_LEVEL                                   m_d3dFeatureLevel;

        DWORD                                               m_dxgiFactoryFlags;

        RECT                                                m_outputSize;

        // HDR Support

        DXGI_COLOR_SPACE_TYPE                               m_colorSpace;

        // DeviceResources options (see flags above)

        unsigned int                                        m_options;

        // The IDeviceNotify can be held directly as it owns the DeviceResources.

        IDeviceNotify*                                      m_deviceNotify;

    };

}

//--------------------------------------------------------------------------------------

// Main.cpp

//

// Entry point for Windows desktop application.

//

// Advanced Technology Group (ATG)

// Copyright (C) Microsoft Corporation. All rights reserved.

//--------------------------------------------------------------------------------------

#include "pch.h"

#include "VideoTexturePC12.h"

using namespace DirectX;

namespace

{

    std::unique_ptr<Sample> g_sample;

};

LPCWSTR g_szAppName = L"VideoTexturePC12";

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

// Indicates to hybrid graphics systems to prefer the discrete part by default

extern "C"

{

    __declspec(dllexport) DWORD NvOptimusEnablement = 0x00000001;

    __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;

}

// Entry point

int WINAPI wWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPWSTR lpCmdLine, _In_ int nCmdShow)

{

    UNREFERENCED_PARAMETER(hPrevInstance);

    UNREFERENCED_PARAMETER(lpCmdLine);

    if (!XMVerifyCPUSupport())

        return 1;

    Microsoft::WRL::Wrappers::RoInitializeWrapper initialize(RO_INIT_MULTITHREADED);

    if (FAILED(initialize))

        return 1;

    // Verify Media Foundation is available to handle Windows N Editions

    //

    // This specific detection implementation only works on Windows 8.x or Windows 10 systems

    //

    // Note we need to use /DELAYLOAD:"mfplat.dll" as well.

    //

    // See https://blogs.msdn.microsoft.com/chuckw/2010/08/13/who-moved-my-windows-media-cheese/

    HRESULT hr = MFStartup(MF_VERSION);

    if (hr == E_NOTIMPL)

    {

        OutputDebugStringA(

            "This application requires Window Media Components.\n"

            "\n"

            "To install Windows Media components, install the\n"

            "\"Media Feature Pack\" for your OS.\n"

            "\n"

            "https://support.microsoft.com/en-us/kb/3145500");

        return 1;

    }

    DX::ThrowIfFailed(hr);

    MFShutdown();

    g_sample = std::make_unique<Sample>();

    // Register class and create window

    {

        // Register class

        WNDCLASSEX wcex;

        wcex.cbSize = sizeof(WNDCLASSEX);

        wcex.style = CS_HREDRAW | CS_VREDRAW;

        wcex.lpfnWndProc = WndProc;

        wcex.cbClsExtra = 0;

        wcex.cbWndExtra = 0;

        wcex.hInstance = hInstance;

        wcex.hIcon = LoadIcon(hInstance, L"IDI_ICON");

        wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);

        wcex.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);

        wcex.lpszMenuName = nullptr;

        wcex.lpszClassName = L"VideoTexturePC12WindowClass";

        wcex.hIconSm = LoadIcon(wcex.hInstance, L"IDI_ICON");

        if (!RegisterClassEx(&wcex))

            return 1;

        // Create window

        int w, h;

        g_sample->GetDefaultSize(w, h);

        RECT rc;

        rc.top = 0;

        rc.left = 0;

        rc.right = static_cast<LONG>(w); 

        rc.bottom = static_cast<LONG>(h);

        AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, FALSE);

        HWND hwnd = CreateWindowEx(0, L"VideoTexturePC12WindowClass", g_szAppName, WS_OVERLAPPEDWINDOW,

            CW_USEDEFAULT, CW_USEDEFAULT, rc.right - rc.left, rc.bottom - rc.top, nullptr, nullptr, hInstance,

            nullptr);

        // Change to CreateWindowEx(WS_EX_TOPMOST, L"VideoTexturePC12WindowClass", g_szAppName, WS_POPUP,

        // to default to fullscreen.

        if (!hwnd)

            return 1;

        ShowWindow(hwnd, nCmdShow);

        // Change nCmdShow to SW_SHOWMAXIMIZED to default to fullscreen.

        SetWindowLongPtr(hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(g_sample.get()) );

        GetClientRect(hwnd, &rc);

        g_sample->Initialize(hwnd, rc.right - rc.left, rc.bottom - rc.top);

    }

    // Main message loop

    MSG msg = {};

    while (WM_QUIT != msg.message)

    {

        if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))

        {

            TranslateMessage(&msg);

            DispatchMessage(&msg);

        }

        else

        {

            g_sample->Tick();

        }

    }

    g_sample.reset();

    CoUninitialize();

    return (int) msg.wParam;

}

// Windows procedure

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

{

    PAINTSTRUCT ps;

    HDC hdc;

    static bool s_in_sizemove = false;

    static bool s_in_suspend = false;

    static bool s_minimized = false;

    static bool s_fullscreen = false;

    // Set s_fullscreen to true if defaulting to fullscreen.

    auto sample = reinterpret_cast<Sample*>(GetWindowLongPtr(hWnd, GWLP_USERDATA));

    switch (message)

    {

    case WM_PAINT:

        if (s_in_sizemove && sample)

        {

            sample->Tick();

        }

        else

        {

            hdc = BeginPaint(hWnd, &ps);

            EndPaint(hWnd, &ps);

        }

        break;

    case WM_MOVE:

        if (sample)

        {

            sample->OnWindowMoved();

        }

        break;

    case WM_SIZE:

        if (wParam == SIZE_MINIMIZED)

        {

            if (!s_minimized)

            {

                s_minimized = true;

                if (!s_in_suspend && sample)

                    sample->OnSuspending();

                s_in_suspend = true;

            }

        }

        else if (s_minimized)

        {

            s_minimized = false;

            if (s_in_suspend && sample)

                sample->OnResuming();

            s_in_suspend = false;

        }

        else if (!s_in_sizemove && sample)

        {

            sample->OnWindowSizeChanged(LOWORD(lParam), HIWORD(lParam));

        }

        break;

    case WM_ENTERSIZEMOVE:

        s_in_sizemove = true;

        break;

    case WM_EXITSIZEMOVE:

        s_in_sizemove = false;

        if (sample)

        {

            RECT rc;

            GetClientRect(hWnd, &rc);

            sample->OnWindowSizeChanged(rc.right - rc.left, rc.bottom - rc.top);

        }

        break;

    case WM_GETMINMAXINFO:

        {

            auto info = reinterpret_cast<MINMAXINFO*>(lParam);

            info->ptMinTrackSize.x = 320;

            info->ptMinTrackSize.y = 200;

        }

        break;

    case WM_ACTIVATEAPP:

        if (sample)

        {

            Keyboard::ProcessMessage(message, wParam, lParam);

            Mouse::ProcessMessage(message, wParam, lParam);

            if (wParam)

            {

                sample->OnActivated();

            }

            else

            {

                sample->OnDeactivated();

            }

        }

        break;

    case WM_POWERBROADCAST:

        switch (wParam)

        {

        case PBT_APMQUERYSUSPEND:

            if (!s_in_suspend && sample)

                sample->OnSuspending();

            s_in_suspend = true;

            return TRUE;

        case PBT_APMRESUMESUSPEND:

            if (!s_minimized)

            {

                if (s_in_suspend && sample)

                    sample->OnResuming();

                s_in_suspend = false;

            }

            return TRUE;

        }

        break;

    case WM_DESTROY:

        PostQuitMessage(0);

        break;

    case WM_INPUT:

    case WM_MOUSEMOVE:

    case WM_LBUTTONDOWN:

    case WM_LBUTTONUP:

    case WM_RBUTTONDOWN:

    case WM_RBUTTONUP:

    case WM_MBUTTONDOWN:

    case WM_MBUTTONUP:

    case WM_MOUSEWHEEL:

    case WM_XBUTTONDOWN:

    case WM_XBUTTONUP:

    case WM_MOUSEHOVER:

        Mouse::ProcessMessage(message, wParam, lParam);

        break;

    case WM_KEYDOWN:

    case WM_KEYUP:

    case WM_SYSKEYUP:

        Keyboard::ProcessMessage(message, wParam, lParam);

        break;

    case WM_SYSKEYDOWN:

        if (wParam == VK_RETURN && (lParam & 0x60000000) == 0x20000000)

        {

            // Implements the classic ALT+ENTER fullscreen toggle

            if (s_fullscreen)

            {

                SetWindowLongPtr(hWnd, GWL_STYLE, WS_OVERLAPPEDWINDOW);

                SetWindowLongPtr(hWnd, GWL_EXSTYLE, 0);

                int width = 800;

                int height = 600;

                if (sample)

                    sample->GetDefaultSize(width, height);

                ShowWindow(hWnd, SW_SHOWNORMAL);

                SetWindowPos(hWnd, HWND_TOP, 0, 0, width, height, SWP_NOMOVE | SWP_NOZORDER | SWP_FRAMECHANGED);

            }

            else

            {

                SetWindowLongPtr(hWnd, GWL_STYLE, 0);

                SetWindowLongPtr(hWnd, GWL_EXSTYLE, WS_EX_TOPMOST);

                SetWindowPos(hWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);

                ShowWindow(hWnd, SW_SHOWMAXIMIZED);

            }

            s_fullscreen = !s_fullscreen;

        }

        Keyboard::ProcessMessage(message, wParam, lParam);

        break;

    case WM_MENUCHAR:

        // A menu is active and the user presses a key that does not correspond

        // to any mnemonic or accelerator key. Ignore so we don't produce an error beep.

        return MAKELRESULT(0, MNC_CLOSE);

    }

    return DefWindowProc(hWnd, message, wParam, lParam);

}

// Exit helper

void ExitSample()

{

    PostQuitMessage(0);

}

//--------------------------------------------------------------------------------------

// File: MediaEnginePlayer.cpp

//

// Copyright (c) Microsoft Corporation. All rights reserved.

// Licensed under the MIT License.

//-------------------------------------------------------------------------------------

#include "pch.h"

#include "MediaEnginePlayer.h"

using Microsoft::WRL::ComPtr;

namespace

{

    class MediaEngineNotify : public IMFMediaEngineNotify

    {

        long m_cRef;

        IMFNotify* m_pCB;

    public:

        MediaEngineNotify() noexcept :

            m_cRef(1),

            m_pCB(nullptr)

        {

        }

        STDMETHODIMP QueryInterface(REFIID riid, void** ppv)

        {

            if (__uuidof(IMFMediaEngineNotify) == riid)

            {

                *ppv = static_cast<IMFMediaEngineNotify*>(this);

            }

            else

            {

                *ppv = nullptr;

                return E_NOINTERFACE;

            }

            AddRef();

            return S_OK;

        }

        STDMETHODIMP_(ULONG) AddRef()

        {

            return InterlockedIncrement(&m_cRef);

        }

        STDMETHODIMP_(ULONG) Release()

        {

            LONG cRef = InterlockedDecrement(&m_cRef);

            if (cRef == 0)

            {

                delete this;

            }

            return cRef;

        }

        void SetCallback(IMFNotify* pCB)

        {

            m_pCB = pCB;

        }

        // EventNotify is called when the Media Engine sends an event.

        STDMETHODIMP EventNotify(DWORD meEvent, DWORD_PTR param1, DWORD)

        {

            if (meEvent == MF_MEDIA_ENGINE_EVENT_NOTIFYSTABLESTATE)

            {

                SetEvent(reinterpret_cast<HANDLE>(param1));

            }

            else

            {

                m_pCB->OnMediaEngineEvent(meEvent);

            }

            return S_OK;

        }

    };

}

MediaEnginePlayer::MediaEnginePlayer() noexcept :

    m_bkgColor{},

    m_isPlaying(false),

    m_isInfoReady(false),

    m_isFinished(false)

{

}

MediaEnginePlayer::~MediaEnginePlayer()

{

    Shutdown();

    MFShutdown();

}

void MediaEnginePlayer::Initialize(IDXGIFactory4* dxgiFactory, ID3D12Device* device, DXGI_FORMAT format)

{

    // Initialize Media Foundation (see Main.cpp for code to handle Windows N Editions)

    DX::ThrowIfFailed(MFStartup(MF_VERSION));

    // Create our own device to avoid threading issues

    auto adapterLuid = device->GetAdapterLuid();

    ComPtr<IDXGIAdapter1> adapter;

    for (UINT adapterIndex = 0;

        DXGI_ERROR_NOT_FOUND != dxgiFactory->EnumAdapters1(

            adapterIndex,

            adapter.ReleaseAndGetAddressOf());

        ++adapterIndex)

    {

        DXGI_ADAPTER_DESC1 desc;

        DX::ThrowIfFailed(adapter->GetDesc1(&desc));

        if (desc.AdapterLuid.LowPart == adapterLuid.LowPart

            && desc.AdapterLuid.HighPart == adapterLuid.HighPart)

        {

            // Found the same adapter as our DX12 device

            break;

        }

    };

#if defined(NDEBUG)

    if (!adapter)

    {

        throw std::exception("No matching device for DirectX 12 found");

    }

#else

    if (!adapter)

    {

        if (FAILED(dxgiFactory->EnumWarpAdapter(IID_PPV_ARGS(adapter.ReleaseAndGetAddressOf()))))

        {

            throw std::exception("WARP12 not available. Enable the 'Graphics Tools' optional feature");

        }

        DXGI_ADAPTER_DESC1 desc;

        DX::ThrowIfFailed(adapter->GetDesc1(&desc));

        if (desc.AdapterLuid.LowPart != adapterLuid.LowPart

            || desc.AdapterLuid.HighPart != adapterLuid.HighPart)

        {

            throw std::exception("No matching device for DirectX 12 found");

        }

    }

#endif

    ComPtr<ID3D11Device> baseDevice;

    DX::ThrowIfFailed(

        D3D11CreateDevice(

        adapter.Get(),

#if defined(NDEBUG)

        D3D_DRIVER_TYPE_UNKNOWN,

#else

        adapter ? D3D_DRIVER_TYPE_UNKNOWN : D3D_DRIVER_TYPE_WARP,

#endif

        0,

        D3D11_CREATE_DEVICE_VIDEO_SUPPORT | D3D11_CREATE_DEVICE_BGRA_SUPPORT,

        nullptr,

        0,

        D3D11_SDK_VERSION,

        baseDevice.GetAddressOf(),

        nullptr,

        nullptr

    ));

    ComPtr<ID3D10Multithread> multithreaded;

    DX::ThrowIfFailed(baseDevice.As(&multithreaded));

    multithreaded->SetMultithreadProtected(TRUE);

    DX::ThrowIfFailed(baseDevice.As(&m_device));

    // Setup Media Engine

    Microsoft::WRL::ComPtr<IMFDXGIDeviceManager> dxgiManager;

    UINT resetToken;

    DX::ThrowIfFailed(MFCreateDXGIDeviceManager(&resetToken, dxgiManager.GetAddressOf()));

    DX::ThrowIfFailed(dxgiManager->ResetDevice(m_device.Get(), resetToken));

    // Create our event callback object.

    ComPtr<MediaEngineNotify> spNotify = new MediaEngineNotify();

    if (spNotify == nullptr)

    {

        DX::ThrowIfFailed(E_OUTOFMEMORY);

    }

    spNotify->SetCallback(this);

    // Set configuration attribiutes.

    ComPtr<IMFAttributes> attributes;

    DX::ThrowIfFailed(MFCreateAttributes(attributes.GetAddressOf(), 1));

    DX::ThrowIfFailed(attributes->SetUnknown(MF_MEDIA_ENGINE_DXGI_MANAGER, reinterpret_cast<IUnknown*>(dxgiManager.Get())));

    DX::ThrowIfFailed(attributes->SetUnknown(MF_MEDIA_ENGINE_CALLBACK, reinterpret_cast<IUnknown*>(spNotify.Get())));

    DX::ThrowIfFailed(attributes->SetUINT32(MF_MEDIA_ENGINE_VIDEO_OUTPUT_FORMAT, format));

    // Create MediaEngine.

    ComPtr<IMFMediaEngineClassFactory> mfFactory;

    DX::ThrowIfFailed(

        CoCreateInstance(CLSID_MFMediaEngineClassFactory,

        nullptr,

        CLSCTX_ALL,

        IID_PPV_ARGS(mfFactory.GetAddressOf())));

    DX::ThrowIfFailed(

        mfFactory->CreateInstance(0,

        attributes.Get(),

        m_mediaEngine.ReleaseAndGetAddressOf()));

    // Create MediaEngineEx

    DX::ThrowIfFailed(m_mediaEngine.As(&m_engineEx));

}

void MediaEnginePlayer::Shutdown()

{

    if (m_mediaEngine)

    {

        m_mediaEngine->Shutdown();

    }

}

void MediaEnginePlayer::Play()

{

    if (m_isPlaying)

        return;

    if (m_mediaEngine)

    {

        DX::ThrowIfFailed(m_mediaEngine->Play());

        m_isPlaying = true;

        m_isFinished = false;

    }

}

void MediaEnginePlayer::SetMuted(bool muted)

{

    if (m_mediaEngine)

    {

        DX::ThrowIfFailed(m_mediaEngine->SetMuted(muted));

    }

}

void MediaEnginePlayer::SetSource(_In_z_ const wchar_t* sourceUri)

{

    static BSTR bstrURL = nullptr;

    if (bstrURL != nullptr)

    {

        ::CoTaskMemFree(bstrURL);

        bstrURL = nullptr;

    }

    size_t cchAllocationSize = 1 + ::wcslen(sourceUri);

    bstrURL = reinterpret_cast<BSTR>(::CoTaskMemAlloc(sizeof(wchar_t)*(cchAllocationSize)));

    if (bstrURL == 0)

    {

        DX::ThrowIfFailed(E_OUTOFMEMORY);

    }

    wcscpy_s(bstrURL, cchAllocationSize, sourceUri);

    m_isPlaying = false;

    m_isInfoReady = false;

    m_isFinished = false;

    if (m_mediaEngine)

    {