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

**

** Copyright (C) 2009 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 "directshowvideooutputcontrol.h"

#include "directshowvideorenderercontrol.h"

#include "vmr9videowindowcontrol.h"

#include <QtCore/qcoreapplication.h>

#include <QtCore/qdatetime.h>

#include <QtCore/qthread.h>

#include <QtCore/qvarlengtharray.h>

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_videoOutputControl(0)

    , m_videoRendererControl(0)

    , m_videoWindowControl(0)

    , m_taskThread(0)

    , 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_videoOutputControl = new DirectShowVideoOutputControl; 

    m_audioEndpointControl = new DirectShowAudioEndpointControl(this);

    m_videoWindowControl = new Vmr9VideoWindowControl;

    m_taskThread = new DirectShowPlayerServiceThread(this);

    m_taskThread->start();

    connect(m_videoOutputControl, SIGNAL(outputChanged()), this, SLOT(videoOutputChanged()));

    connect(m_videoRendererControl, SIGNAL(filterChanged()), this, SLOT(videoOutputChanged()));

}

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_videoOutputControl;

    delete m_videoRendererControl;

    delete m_videoWindowControl;

    ::CloseHandle(m_taskHandle);

}

QMediaControl *DirectShowPlayerService::control(const char *name) const

{

    if (qstrcmp(name, QMediaPlayerControl_iid) == 0)

        return m_playerControl;

    else if (qstrcmp(name, QAudioEndpointSelector_iid) == 0)

        return m_audioEndpointControl;

    else if (qstrcmp(name, QMetaDataControl_iid) == 0)

        return m_metaDataControl;

    else if (qstrcmp(name, QVideoOutputControl_iid) == 0)

        return m_videoOutputControl;

    else if (qstrcmp(name, QVideoRendererControl_iid) == 0)

        return m_videoRendererControl;

    else if (qstrcmp(name, QVideoWindowControl_iid) == 0)

        return m_videoWindowControl;

    else

        return 0;

}

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_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 {

        m_graphStatus = Loading;

        if (stream)

            m_pendingTasks = SetStreamSource;

        else

            m_pendingTasks = SetUrlSource;

        ::SetEvent(m_taskHandle);

    }

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

    m_playerControl->updateState(QMediaPlayer::StoppedState);

    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")) {

            locker->unlock();

            locker->relock();

            if (SUCCEEDED(hr)) {

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

                    source->Release();

                    source = 0;

                }

            }

            fileSource->Release();

        }

    }

    if (!SUCCEEDED(hr)) {

        locker->unlock();

        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;

            break;

        case E_OUTOFMEMORY:

        case VFW_E_CANNOT_LOAD_SOURCE_FILTER:

        case VFW_E_NOT_FOUND:

            m_error = QMediaPlayer::ResourceError;

        default:

            m_error = QMediaPlayer::ResourceError;

            break;

        }

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

    }

}

void DirectShowPlayerService::doSetStreamSource(QMutexLocker *locker)

{

    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;

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

    }

}

void DirectShowPlayerService::doRender(QMutexLocker *locker)

{

    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;

                            filters.append(peerInfo.pFilter);

                        peer->Release();

                    } else {

                        locker->unlock();

                        HRESULT hr;

                        if (SUCCEEDED(hr = graph->RenderEx(

                            rendered = true;

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

                            renderHr = hr;

                        }

                        locker->relock();

                    }

                }

            }

            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;

            } else {

                switch (renderHr) {

                case VFW_E_UNSUPPORTED_AUDIO:

                case VFW_E_UNSUPPORTED_VIDEO:

                case VFW_E_UNSUPPORTED_STREAM:

                    m_error = QMediaPlayer::FormatError;

                default:

                    m_error = QMediaPlayer::ResourceError;

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

                }

            }

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

        }

        m_executedTasks |= Render;

    }

}

void DirectShowPlayerService::doFinalizeLoad(QMutexLocker *locker)

{

    if (m_graphStatus != Loaded) {

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

            event->Release();

        }

            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;

    m_graphStatus = Loaded;

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

}

void DirectShowPlayerService::releaseGraph()

{

    if (m_graph) {

        if (m_executingTask != 0) {

                progress->AbortOperation();

                progress->Release();

            }

            m_graph->Abort();

        }

        m_pendingTasks = ReleaseGraph;

        ::SetEvent(m_taskHandle);