1 /*  This file is part of the KDE project.

     2 

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

     4 

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

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

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

     8 

     9 This library is distributed in the hope that it will be useful,

    10 but WITHOUT ANY WARRANTY; without even the implied warranty of

    11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    12 GNU Lesser General Public License for more details.

    13 

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

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

    16 

    17 */

    18 

    19 #include <QStringList>

    20 #include <QtPlugin>

    21 

    22 #include <apgcli.h> // for RApaLsSession

    23 #include <apmrec.h> // for CDataTypeArray

    24 #include <apmstd.h> // for TDataType

    25 

    26 #include "abstractaudioeffect.h"

    27 #include "audiooutput.h"

    28 #include "audioplayer.h"

    29 #include "backend.h"

    30 #include "effectfactory.h"

    31 #include "mediaobject.h"

    32 #include "utils.h"

    33 #include "videowidget.h"

    34 

    35 QT_BEGIN_NAMESPACE

    36 

    37 using namespace Phonon;

    38 using namespace Phonon::MMF;

    39 

    40 /*! \class MMF::VolumeObserver

    41   \internal

    42 */

    43 

    44 /*! \class MMF::Backend

    45   \internal

    46 */

    47 

    48 Backend::Backend(QObject *parent)   : QObject(parent)

    49 {

    50     TRACE_CONTEXT(Backend::Backend, EBackend);

    51     TRACE_ENTRY_0();

    52 

    53     setProperty("identifier",     QLatin1String("phonon_mmf"));

    54     setProperty("backendName",    QLatin1String("MMF"));

    55     setProperty("backendComment", QLatin1String("Backend using Symbian Multimedia Framework (MMF)"));

    56     setProperty("backendVersion", QLatin1String("0.1"));

    57     setProperty("backendWebsite", QLatin1String("http://qt.nokia.com/"));

    58 

    59     TRACE_EXIT_0();

    60 }

    61 

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

    63 {

    64     TRACE_CONTEXT(Backend::createObject, EBackend);

    65     TRACE_ENTRY("class %d", c);

    66 

    67     QObject* result = 0;

    68 

    69     switch (c) {

    70     case AudioOutputClass:

    71         result = new AudioOutput(this, parent);

    72         break;

    73 

    74     case MediaObjectClass:

    75         result = new MediaObject(parent);

    76         break;

    77 

    78     case VolumeFaderEffectClass:

    79     case VisualizationClass:

    80     case VideoDataOutputClass:

    81     case EffectClass:

    82     {

    83         Q_ASSERT(args.count() == 1);

    84         Q_ASSERT(args.first().type() == QVariant::Int);

    85         const AbstractAudioEffect::Type effect = AbstractAudioEffect::Type(args.first().toInt());

    86 

    87         return EffectFactory::createAudioEffect(effect, parent);

    88     }

    89     case VideoWidgetClass:

    90         result = new VideoWidget(qobject_cast<QWidget *>(parent));

    91         break;

    92 

    93     default:

    94         TRACE_PANIC(InvalidBackendInterfaceClass);

    95     }

    96 

    97     TRACE_RETURN("0x%08x", result);

    98 }

    99 

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

   101 {

   102     TRACE_CONTEXT(Backend::objectDescriptionIndexes, EAudioApi);

   103     TRACE_ENTRY_0();

   104     QList<int> retval;

   105 

   106     switch(type)

   107     {

   108         case EffectType:

   109             retval.append(EffectFactory::effectIndexes());

   110             break;

   111         case AudioOutputDeviceType:

   112             // We only have one possible output device, but we need at least

   113             // one.

   114             retval.append(AudioOutput::AudioOutputDeviceID);

   115             break;

   116         default:

   117             ;

   118     }

   119 

   120     TRACE_EXIT_0();

   121     return retval;

   122 }

   123 

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

   125 {

   126     TRACE_CONTEXT(Backend::connectNodes, EBackend);

   127 

   128     switch (type) {

   129         case EffectType:

   130             return EffectFactory::audioEffectDescriptions(AbstractAudioEffect::Type(index));

   131         case AudioOutputDeviceType:

   132             return AudioOutput::audioOutputDescription(index);

   133         default:

   134             return QHash<QByteArray, QVariant>();

   135     }

   136 }

   137 

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

   139 {

   140     return true;

   141 }

   142 

   143 bool Backend::connectNodes(QObject *source, QObject *target)

   144 {

   145     TRACE_CONTEXT(Backend::connectNodes, EBackend);

   146     TRACE_ENTRY("source 0x%08x target 0x%08x", source, target);

   147     Q_ASSERT(qobject_cast<MediaNode *>(source));

   148     Q_ASSERT(qobject_cast<MediaNode *>(target));

   149 

   150     MediaNode *const mediaSource = static_cast<MediaNode *>(source);

   151     MediaNode *const mediaTarget = static_cast<MediaNode *>(target);

   152 

   153     return mediaSource->connectMediaNode(mediaTarget);

   154 }

   155 

   156 bool Backend::disconnectNodes(QObject *source, QObject *target)

   157 {

   158     TRACE_CONTEXT(Backend::disconnectNodes, EBackend);

   159     TRACE_ENTRY("source 0x%08x target 0x%08x", source, target);

   160     Q_ASSERT(qobject_cast<MediaNode *>(source));

   161     Q_ASSERT(qobject_cast<MediaNode *>(target));

   162 

   163     const bool result = static_cast<MediaNode *>(source)->disconnectMediaNode(static_cast<MediaNode *>(target));

   164 

   165     TRACE_RETURN("%d", result);

   166 }

   167 

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

   169 {

   170     return true;

   171 }

   172 

   173 void getAvailableMimeTypesL(QStringList& result)

   174 {

   175     RApaLsSession apaSession;

   176     User::LeaveIfError(apaSession.Connect());

   177     CleanupClosePushL(apaSession);

   178 

   179     static const TInt DataTypeArrayGranularity = 8;

   180     CDataTypeArray* array = new(ELeave) CDataTypeArray(DataTypeArrayGranularity);

   181     CleanupStack::PushL(array);

   182 

   183     apaSession.GetSupportedDataTypesL(*array);

   184 

   185     for (TInt i = 0; i < array->Count(); ++i) {

   186         const TPtrC mimeType = array->At(i).Des();

   187         const MediaType mediaType = Utils::mimeTypeToMediaType(mimeType);

   188         if (MediaTypeAudio == mediaType or MediaTypeVideo == mediaType) {

   189             result.append(qt_TDesC2QString(mimeType));

   190         }

   191     }

   192 

   193     CleanupStack::PopAndDestroy(2); // apaSession, array

   194 }

   195 

   196 QStringList Backend::availableMimeTypes() const

   197 {

   198     QStringList result;

   199 

   200     // There is no way to return an error from this function, so we just

   201     // have to trap and ignore exceptions...

   202     TRAP_IGNORE(getAvailableMimeTypesL(result));

   203 

   204     result.sort();

   205 

   206     return result;

   207 }

   208 

   209 Q_EXPORT_PLUGIN2(phonon_mmf, Phonon::MMF::Backend);

   210 

   211 QT_END_NAMESPACE

   212