/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "directshowplayerservice.h"

#include "directshowaudioendpointcontrol.h"

#include "directshowiosource.h"

#include "directshowmetadatacontrol.h"

#include "directshowplayercontrol.h"

#include "directshowvideorenderercontrol.h"

#include "vmr9videowindowcontrol.h"

#include "../../src/multimedia/qmediacontent.h"

#include <QtCore/qcoreapplication.h>

#include <QtCore/qdatetime.h>

#include <QtCore/qthread.h>

#include <QtCore/qvarlengtharray.h>

Q_GLOBAL_STATIC(DirectShowEventLoop, qt_directShowEventLoop)

class DirectShowPlayerServiceThread : public QThread

{

public:

    DirectShowPlayerServiceThread(DirectShowPlayerService *service)

        : m_service(service)

    {

    }

protected:

    void run() { m_service->run(); }

private:

    DirectShowPlayerService *m_service;

};

DirectShowPlayerService::DirectShowPlayerService(QObject *parent)

    : QMediaService(parent)

    , m_playerControl(0)

    , m_metaDataControl(0)

    , m_videoRendererControl(0)

    , m_videoWindowControl(0)

    , m_audioEndpointControl(0)

    , m_taskThread(0)

    , m_loop(qt_directShowEventLoop())

    , m_pendingTasks(0)

    , m_executingTask(0)

    , m_executedTasks(0)

    , m_taskHandle(::CreateEvent(0, 0, 0, 0))

    , m_eventHandle(0)

    , m_graphStatus(NoMedia)

    , m_stream(0)

    , m_graph(0)

    , m_source(0)

    , m_audioOutput(0)

    , m_videoOutput(0)

    , m_rate(1.0)

    , m_position(0)

    , m_duration(0)

    , m_buffering(false)

    , m_seekable(false)

    , m_atEnd(false)

{

    m_playerControl = new DirectShowPlayerControl(this);

    m_metaDataControl = new DirectShowMetaDataControl(this);

    m_audioEndpointControl = new DirectShowAudioEndpointControl(this);

    m_taskThread = new DirectShowPlayerServiceThread(this);

    m_taskThread->start();

}

DirectShowPlayerService::~DirectShowPlayerService()

{

    {

        QMutexLocker locker(&m_mutex);

        releaseGraph();

        m_pendingTasks = Shutdown;

        ::SetEvent(m_taskHandle);

    }

    m_taskThread->wait();

    delete m_taskThread;

    if (m_audioOutput) {

        m_audioOutput->Release();

        m_audioOutput = 0;

    }

    if (m_videoOutput) {

        m_videoOutput->Release();

        m_videoOutput = 0;

    }

    delete m_playerControl;

    delete m_audioEndpointControl;

    delete m_metaDataControl;

    delete m_videoRendererControl;

    delete m_videoWindowControl;

    ::CloseHandle(m_taskHandle);

}

{

        return m_playerControl;

        return m_audioEndpointControl;

        return m_metaDataControl;

}

void DirectShowPlayerService::load(const QMediaContent &media, QIODevice *stream)

{

    QMutexLocker locker(&m_mutex);

    m_pendingTasks = 0;

    if (m_graph)

        releaseGraph();

    m_resources = media.resources();

    m_stream = stream;

    m_error = QMediaPlayer::NoError;

    m_errorString = QString();

    m_position = 0;

    m_duration = 0;

    m_streamTypes = 0;

    m_executedTasks = 0;

    m_buffering = false;

    m_seekable = false;

    m_atEnd = false;

    m_metaDataControl->updateGraph(0, 0);

    if (m_resources.isEmpty() && !stream) {

        m_pendingTasks = 0;

        m_graphStatus = NoMedia;

        m_url.clear();

    } else if (stream && (!stream->isReadable() || stream->isSequential())) {

        m_pendingTasks = 0;

        m_graphStatus = InvalidMedia;

        m_error = QMediaPlayer::ResourceError;

    } else {

        // {36b73882-c2c8-11cf-8b46-00805f6cef60}

        static const GUID iid_IFilterGraph2 = {

            0x36b73882, 0xc2c8, 0x11cf, {0x8b, 0x46, 0x00, 0x80, 0x5f, 0x6c, 0xef, 0x60} };

        m_graphStatus = Loading;

        m_graph = com_new<IFilterGraph2>(CLSID_FilterGraph, iid_IFilterGraph2);

        if (stream)

            m_pendingTasks = SetStreamSource;

        else

            m_pendingTasks = SetUrlSource;

        ::SetEvent(m_taskHandle);

    }

    m_playerControl->updateError(m_error, m_errorString);

    m_playerControl->updateMediaInfo(m_duration, m_streamTypes, m_seekable);

    m_playerControl->updateState(QMediaPlayer::StoppedState);

    m_playerControl->updatePosition(m_position);

    updateStatus();

}

void DirectShowPlayerService::doSetUrlSource(QMutexLocker *locker)

{

    IBaseFilter *source = 0;

    QMediaResource resource = m_resources.takeFirst();

    QUrl url = resource.url();

    HRESULT hr = E_FAIL;

    if (url.scheme() == QLatin1String("http") || url.scheme() == QLatin1String("https")) {

        static const GUID clsid_WMAsfReader = {

            0x187463a0, 0x5bb7, 0x11d3, {0xac, 0xbe, 0x00, 0x80, 0xc7, 0x5e, 0x24, 0x6e} };

        // {56a868a6-0ad4-11ce-b03a-0020af0ba770}

        static const GUID iid_IFileSourceFilter = {

            0x56a868a6, 0x0ad4, 0x11ce, {0xb0, 0x3a, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70} };

        if (IFileSourceFilter *fileSource = com_new<IFileSourceFilter>(

                clsid_WMAsfReader, iid_IFileSourceFilter)) {

            locker->unlock();

            hr = fileSource->Load(reinterpret_cast<const OLECHAR *>(url.toString().utf16()), 0);

            locker->relock();

            if (SUCCEEDED(hr)) {

                source = com_cast<IBaseFilter>(fileSource, IID_IBaseFilter);

                if (!SUCCEEDED(hr = m_graph->AddFilter(source, L"Source")) && source) {

                    source->Release();

                    source = 0;

                }

            }

            fileSource->Release();

        }

    } else if (url.scheme() == QLatin1String("qrc")) {

        DirectShowRcSource *rcSource = new DirectShowRcSource(m_loop);

        if (rcSource->open(url) && SUCCEEDED(hr = m_graph->AddFilter(rcSource, L"Source")))

            source = rcSource;

        else

            rcSource->Release();

    }

    if (!SUCCEEDED(hr)) {

        locker->unlock();

        hr = m_graph->AddSourceFilter(

                reinterpret_cast<const OLECHAR *>(url.toString().utf16()), L"Source", &source);

        locker->relock();

    }

    if (SUCCEEDED(hr)) {

        m_executedTasks = SetSource;

        m_pendingTasks |= Render;

        if (m_audioOutput)

            m_pendingTasks |= SetAudioOutput;

        if (m_videoOutput)

            m_pendingTasks |= SetVideoOutput;

        if (m_rate != 1.0)

            m_pendingTasks |= SetRate;

        m_source = source;

    } else if (!m_resources.isEmpty()) {

        m_pendingTasks |= SetUrlSource;

    } else {

        m_pendingTasks = 0;

        m_graphStatus = InvalidMedia;

        switch (hr) {

        case VFW_E_UNKNOWN_FILE_TYPE:

            m_error = QMediaPlayer::FormatError;

            m_errorString = QString();

            break;

        case E_OUTOFMEMORY:

        case VFW_E_CANNOT_LOAD_SOURCE_FILTER:

        case VFW_E_NOT_FOUND:

            m_error = QMediaPlayer::ResourceError;

            m_errorString = QString();

        default:

            m_error = QMediaPlayer::ResourceError;

            m_errorString = QString();

            qWarning("DirectShowPlayerService::doSetUrlSource: Unresolved error code %x", uint(hr));

            break;

        }

        QCoreApplication::postEvent(this, new QEvent(QEvent::Type(Error)));

    }

}

void DirectShowPlayerService::doSetStreamSource(QMutexLocker *locker)

{

    DirectShowIOSource *source = new DirectShowIOSource(m_loop);

    source->setDevice(m_stream);

    if (SUCCEEDED(m_graph->AddFilter(source, L"Source"))) {

        m_executedTasks = SetSource;

        m_pendingTasks |= Render;

        if (m_audioOutput)

            m_pendingTasks |= SetAudioOutput;

        if (m_videoOutput)

            m_pendingTasks |= SetVideoOutput;

        if (m_rate != 1.0)

            m_pendingTasks |= SetRate;

        m_source = source;

    } else {

        source->Release();

        m_pendingTasks = 0;

        m_graphStatus = InvalidMedia;

        m_error = QMediaPlayer::ResourceError;

        m_errorString = QString();

        QCoreApplication::postEvent(this, new QEvent(QEvent::Type(Error)));

    }

}

void DirectShowPlayerService::doRender(QMutexLocker *locker)

{

    m_pendingTasks |= m_executedTasks & (Play | Pause);

    if (IMediaControl *control = com_cast<IMediaControl>(m_graph, IID_IMediaControl)) {

        control->Stop();

        control->Release();

    }

    if (m_pendingTasks & SetAudioOutput) {

        m_graph->AddFilter(m_audioOutput, L"AudioOutput");

        m_pendingTasks ^= SetAudioOutput;

        m_executedTasks |= SetAudioOutput;

    }

    if (m_pendingTasks & SetVideoOutput) {

        m_graph->AddFilter(m_videoOutput, L"VideoOutput");

        m_pendingTasks ^= SetVideoOutput;

        m_executedTasks |= SetVideoOutput;

    }

    IFilterGraph2 *graph = m_graph;

    graph->AddRef();

    QVarLengthArray<IBaseFilter *, 16> filters;

    m_source->AddRef();

    filters.append(m_source);

    bool rendered = false;

    HRESULT renderHr = S_OK;

    while (!filters.isEmpty()) {

        IEnumPins *pins = 0;

        IBaseFilter *filter = filters[filters.size() - 1];

        filters.removeLast();

        if (!(m_pendingTasks & ReleaseFilters) && SUCCEEDED(filter->EnumPins(&pins))) {

            int outputs = 0;

            for (IPin *pin = 0; pins->Next(1, &pin, 0) == S_OK; pin->Release()) {

                PIN_DIRECTION direction;

                if (pin->QueryDirection(&direction) == S_OK && direction == PINDIR_OUTPUT) {

                    ++outputs;

                    IPin *peer = 0;

                    if (pin->ConnectedTo(&peer) == S_OK) {

                        PIN_INFO peerInfo;

                        if (SUCCEEDED(peer->QueryPinInfo(&peerInfo)))

                            filters.append(peerInfo.pFilter);

                        peer->Release();

                    } else {

                        locker->unlock();

                        HRESULT hr;

                        if (SUCCEEDED(hr = graph->RenderEx(

                                pin, /*AM_RENDEREX_RENDERTOEXISTINGRENDERERS*/ 1, 0))) {

                            rendered = true;

                        } else if (renderHr == S_OK || renderHr == VFW_E_NO_DECOMPRESSOR){

                            renderHr = hr;

                        }

                        locker->relock();

                    }

                }

            }

            pins->Release();

            if (outputs == 0)

                rendered = true;

        }

        filter->Release();

    }

    if (m_audioOutput && !isConnected(m_audioOutput, PINDIR_INPUT)) {

        graph->RemoveFilter(m_audioOutput);

        m_executedTasks &= ~SetAudioOutput;

    }

    if (m_videoOutput && !isConnected(m_videoOutput, PINDIR_INPUT)) {

        graph->RemoveFilter(m_videoOutput);

        m_executedTasks &= ~SetVideoOutput;

    }

    graph->Release();

    if (!(m_pendingTasks & ReleaseFilters)) {

        if (rendered) {

            if (!(m_executedTasks & FinalizeLoad))

                m_pendingTasks |= FinalizeLoad;

        } else {

            m_pendingTasks = 0;

            m_graphStatus = InvalidMedia;

            if (!m_audioOutput && !m_videoOutput) {

                m_error = QMediaPlayer::ResourceError;

                m_errorString = QString();

            } else {

                switch (renderHr) {

                case VFW_E_UNSUPPORTED_AUDIO:

                case VFW_E_UNSUPPORTED_VIDEO:

                case VFW_E_UNSUPPORTED_STREAM:

                    m_error = QMediaPlayer::FormatError;

                    m_errorString = QString();

                default:

                    m_error = QMediaPlayer::ResourceError;

                    m_errorString = QString();

                    qWarning("DirectShowPlayerService::doRender: Unresolved error code %x",

                             uint(renderHr));

                }

            }

            QCoreApplication::postEvent(this, new QEvent(QEvent::Type(Error)));

        }

        m_executedTasks |= Render;

    }

    m_loop->wake();

}

void DirectShowPlayerService::doFinalizeLoad(QMutexLocker *locker)

{

    if (m_graphStatus != Loaded) {

        if (IMediaEvent *event = com_cast<IMediaEvent>(m_graph, IID_IMediaEvent)) {

            event->GetEventHandle(reinterpret_cast<OAEVENT *>(&m_eventHandle));

            event->Release();

        }

        if (IMediaSeeking *seeking = com_cast<IMediaSeeking>(m_graph, IID_IMediaSeeking)) {

            LONGLONG duration = 0;

            seeking->GetDuration(&duration);

            m_duration = duration / 10;

            DWORD capabilities = 0;

            seeking->GetCapabilities(&capabilities);

            m_seekable = capabilities & AM_SEEKING_CanSeekAbsolute;

            seeking->Release();

        }

    }

    if ((m_executedTasks & SetOutputs) == SetOutputs) {

        m_streamTypes = AudioStream | VideoStream;

    } else {

        m_streamTypes = findStreamTypes(m_source);

    }

    m_executedTasks |= FinalizeLoad;