/*  This file is part of the KDE project.

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

This library is free software: you can redistribute it and/or modify

it under the terms of the GNU Lesser General Public License as published by

the Free Software Foundation, either version 2.1 or 3 of the License.

This library 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License

along with this library.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "backend.h"

#include "backendnode.h"

#include "audiooutput.h"

#include "effect.h"

#include "mediaobject.h"

#include "videowidget.h"

#include "volumeeffect.h"

//windows specific (DirectX Media Object)

#include <dmo.h>

#include <QtCore/QSettings>

#include <QtCore/QSet>

#include <QtCore/QVariant>

#include <QtCore/QtPlugin>

QT_BEGIN_NAMESPACE

Q_EXPORT_PLUGIN2(phonon_ds9, Phonon::DS9::Backend);

namespace Phonon

{

    namespace DS9

    {

        QMutex *Backend::directShowMutex = 0;

        bool Backend::AudioMoniker::operator==(const AudioMoniker &other)

        {

            return other->IsEqual(*this) == S_OK;

        }

        Backend::Backend(QObject *parent, const QVariantList &)

            : QObject(parent)

        {

            directShowMutex = &m_directShowMutex;

            ::CoInitialize(0);

            //registering meta types

            qRegisterMetaType<HRESULT>("HRESULT");

            qRegisterMetaType<Graph>("Graph");

        }

        Backend::~Backend()

        {

            m_audioOutputs.clear();

            m_audioEffects.clear();

            ::CoUninitialize();

            directShowMutex = 0;

        }

        QObject *Backend::createObject(BackendInterface::Class c, QObject *parent, const QList<QVariant> &args)

        {

            switch (c)

            {

            case MediaObjectClass:

                return new MediaObject(parent);

            case AudioOutputClass:

                return new AudioOutput(this, parent);

#ifndef QT_NO_PHONON_EFFECT

            case EffectClass:

                return new Effect(m_audioEffects[ args[0].toInt() ], parent);

#endif //QT_NO_PHONON_EFFECT

#ifndef QT_NO_PHONON_VIDEO

            case VideoWidgetClass:

                return new VideoWidget(qobject_cast<QWidget *>(parent));

#endif //QT_NO_PHONON_VIDEO

#ifndef QT_NO_PHONON_VOLUMEFADEREFFECT

            case VolumeFaderEffectClass:

                return new VolumeEffect(parent);

#endif //QT_NO_PHONON_VOLUMEFADEREFFECT

            default:

                return 0;

            }

        }

        bool Backend::supportsVideo() const

        {

#ifndef QT_NO_PHONON_VIDEO

            return true;

#else

            return false;

#endif //QT_NO_PHONON_VIDEO

        }

        QStringList Backend::availableMimeTypes() const

        {

            QStringList ret;

            {

                QSettings settings(QLatin1String("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Multimedia\\mplayer2\\mime types"), QSettings::NativeFormat);

                ret += settings.childGroups();

            }

            {

                QSettings settings(QLatin1String("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Multimedia\\wmplayer\\mime types"), QSettings::NativeFormat);

                ret += settings.childGroups();

            }

            ret.removeDuplicates();

            ret.replaceInStrings("\\", "/");

            qSort(ret);

            return ret;

        }

		Filter Backend::getAudioOutputFilter(int index) const

		{

			Filter ret;

			if (index >= 0 && index < m_audioOutputs.count()) {

				m_audioOutputs.at(index)->BindToObject(0, 0, IID_IBaseFilter, reinterpret_cast<void**>(&ret));

			} else {

				//just return the default audio renderer (not directsound)

				ret = Filter(CLSID_AudioRender, IID_IBaseFilter);

			}

			return ret;

		}

        QList<int> Backend::objectDescriptionIndexes(Phonon::ObjectDescriptionType type) const

        {

            QMutexLocker locker(&m_directShowMutex);

            QList<int> ret;

            switch(type)

            {

            case Phonon::AudioOutputDeviceType:

                {

#ifdef Q_OS_WINCE

					ret << 0; // only one audio device with index 0

#else

					ComPointer<ICreateDevEnum> devEnum(CLSID_SystemDeviceEnum, IID_ICreateDevEnum);

					if (!devEnum) {

						return ret; //it is impossible to enumerate the devices

					}

                    ComPointer<IEnumMoniker> enumMon;

                    HRESULT hr = devEnum->CreateClassEnumerator(CLSID_AudioRendererCategory, enumMon.pparam(), 0);

                    if (FAILED(hr)) {

                        break;

                    }

                    AudioMoniker mon;

                    //let's reorder the devices so that directshound appears first

                    int nbds = 0; //number of directsound devices

                    while (S_OK == enumMon->Next(1, mon.pparam(), 0)) {

                        LPOLESTR str = 0;

                        mon->GetDisplayName(0,0,&str);

                        const QString name = QString::fromWCharArray(str);

						ComPointer<IMalloc> alloc;

						::CoGetMalloc(1, alloc.pparam());

                        alloc->Free(str);

                        int insert_pos = 0;

                        if (!m_audioOutputs.contains(mon)) {

                            insert_pos = m_audioOutputs.count();

                            m_audioOutputs.append(mon);

                        } else {

                            insert_pos = m_audioOutputs.indexOf(mon);

                        }

                        if (name.contains(QLatin1String("DirectSound"))) {

                            ret.insert(nbds++, insert_pos);

                        } else {

                            ret.append(insert_pos);

                        }

                    }

#endif

					break;

                }

#ifndef QT_NO_PHONON_EFFECT

            case Phonon::EffectType:

                {

                    m_audioEffects.clear();

                    ComPointer<IEnumDMO> enumDMO;

                    HRESULT hr = ::DMOEnum(DMOCATEGORY_AUDIO_EFFECT, DMO_ENUMF_INCLUDE_KEYED, 0, 0, 0, 0, enumDMO.pparam());

                    if (SUCCEEDED(hr)) {

                        CLSID clsid;

                        while (S_OK == enumDMO->Next(1, &clsid, 0, 0)) {

                            ret += m_audioEffects.count();

                            m_audioEffects.append(clsid);

                        }

                    }

                    break;

                }

                break;

#endif //QT_NO_PHONON_EFFECT

            default:

                break;

            }

			return ret;

        }

        QHash<QByteArray, QVariant> Backend::objectDescriptionProperties(Phonon::ObjectDescriptionType type, int index) const

        {

            QMutexLocker locker(&m_directShowMutex);

            QHash<QByteArray, QVariant> ret;

            switch (type)

            {

            case Phonon::AudioOutputDeviceType:

                {

#ifdef Q_OS_WINCE

					ret["name"] = QLatin1String("default audio device");

#else

                    const AudioMoniker &mon = m_audioOutputs[index];

                    LPOLESTR str = 0;

                    HRESULT hr = mon->GetDisplayName(0,0, &str);

                    if (SUCCEEDED(hr)) {

                        QString name = QString::fromWCharArray(str);

						ComPointer<IMalloc> alloc;

						::CoGetMalloc(1, alloc.pparam());

                        alloc->Free(str);

                        ret["name"] = name.mid(name.indexOf('\\') + 1);

					}

#endif

                }

                break;

#ifndef QT_NO_PHONON_EFFECT

            case Phonon::EffectType:

                {

                    WCHAR name[80]; // 80 is clearly stated in the MSDN doc

                    HRESULT hr = ::DMOGetName(m_audioEffects[index], name);

                    if (SUCCEEDED(hr)) {

                        ret["name"] = QString::fromWCharArray(name);

                    }

                }

                break;

#endif //QT_NO_PHONON_EFFECT

            default:

                break;

            }

			return ret;

        }

        bool Backend::endConnectionChange(QSet<QObject *> objects)

        {

            //end of a transaction

            for(QSet<QObject *>::const_iterator it = objects.begin(); it != objects.end(); ++it) {

                if (BackendNode *node = qobject_cast<BackendNode*>(*it)) {

                    MediaObject *mo = node->mediaObject();

                    if (mo) {

                        switch(mo->transactionState)

                        {

                        case Phonon::ErrorState:

                        case Phonon::StoppedState:

                        case Phonon::LoadingState:

                            //nothing to do

                            break;

                        case Phonon::PausedState:

                            mo->transactionState = Phonon::StoppedState;

                            mo->pause();

                            break;

                        default:

                            mo->transactionState = Phonon::StoppedState;

                            mo->play();

                            break;

                        }

                        if (mo->state() == Phonon::ErrorState)

                            return false;

                    }

                }

            }

            return true;

        }

        bool Backend::startConnectionChange(QSet<QObject *> objects)

        {

            //let's save the state of the graph (before we stop it)

            for(QSet<QObject *>::const_iterator it = objects.begin(); it != objects.end(); ++it) {

                if (BackendNode *node = qobject_cast<BackendNode*>(*it)) {

                    if (MediaObject *mo = node->mediaObject()) {

                        if (mo->state() != Phonon::StoppedState) {

                            mo->transactionState = mo->state();

                            mo->ensureStopped(); //we have to stop the graph..

                            if (mo->state() == Phonon::ErrorState)

                                return false;

                        }

                    }

                }

            }

            return true;

        }

        bool Backend::connectNodes(QObject *_source, QObject *_sink)

        {

            BackendNode *source = qobject_cast<BackendNode*>(_source);

            if (!source) {

                return false;

            }

            BackendNode *sink = qobject_cast<BackendNode*>(_sink);

            if (!sink) {

                return false;

            }

            //setting the graph if needed

            if (source->mediaObject() == 0 && sink->mediaObject() == 0) {

                    //error: no graph selected

                    return false;

            } else if (source->mediaObject() && source->mediaObject() != sink->mediaObject()) {

                //this' graph becomes the common one

                source->mediaObject()->grabNode(sink);

            } else if (source->mediaObject() == 0) {

                //sink's graph becomes the common one

                sink->mediaObject()->grabNode(source);

            }

            return source->mediaObject()->connectNodes(source, sink);

        }

        bool Backend::disconnectNodes(QObject *_source, QObject *_sink)

        {

            BackendNode *source = qobject_cast<BackendNode*>(_source);

            if (!source) {

                return false;

            }

            BackendNode *sink = qobject_cast<BackendNode*>(_sink);

            if (!sink) {

                return false;

            }

            return source->mediaObject() == 0 ||

                source->mediaObject()->disconnectNodes(source, sink);

        }

    }

}

QT_END_NAMESPACE

#include "moc_backend.cpp"