1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

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

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <QtTest/QtTest>

    43 

    44 #include <QtCore/qtimer.h>

    45 

    46 #include <qmediaobject.h>

    47 #include <qmediaservice.h>

    48 #include <qmetadatacontrol.h>

    49 #include <qmediaplayer.h>

    50 

    51 QTM_USE_NAMESPACE

    52 class tst_QMediaObject : public QObject

    53 {

    54     Q_OBJECT

    55 

    56 public slots:

    57     void initTestCase_data();

    58     void initTestCase();

    59     void cleanupTestCase();

    60     void init();

    61     void cleanup();

    62 

    63 private slots:

    64     void isMetaDataAvailable();

    65     void isWritable();

    66     void metaData();

    67     void availableMetaData();

    68     void setMetaData();

    69     void extendedMetaData();

    70     void availableExtendedMetaData();

    71     void setExtendedMetaData();

    72 

    73 private:

    74     QString metaDataKeyAsString(QtMedia::MetaData key) const;

    75 };

    76 

    77 void tst_QMediaObject::initTestCase_data()

    78 {

    79     QTest::addColumn<bool>("valid");

    80     //QTest::addColumn<QMediaPlayer::State>("state");

    81     //QTest::addColumn<QMediaPlayer::MediaStatus>("status");

    82     QTest::addColumn<QMediaContent>("mediaContent");

    83     QTest::addColumn<bool>("metaDataAvailable");

    84     QTest::addColumn<bool>("metaDataWritable"); // Is this needed ???

    85     //QTest::addColumn<int>("bufferStatus");

    86     //QTest::addColumn<qreal>("playbackRate");

    87     //QTest::addColumn<QMediaPlayer::Error>("error");

    88     //QTest::addColumn<QString>("errorString");

    89 

    90     QTest::newRow("TestDataNull")

    91     << false // valid

    92     //<< QMediaPlayer::StoppedState // state

    93     //<< QMediaPlayer::UnknownMediaStatus // status

    94     << QMediaContent() // mediaContent

    95     << false // metaDataAvailable

    96     << false; // metaDataWritable

    97     //<< 0 // bufferStatus

    98     //<< qreal(0) // playbackRate

    99     //<< QMediaPlayer::NoError // error

   100     //<< QString(); // errorString

   101 

   102     /*

   103     QTest::newRow("test_3gp.3gp")

   104     << true // valid

   105     //<< QMediaPlayer::StoppedState // state

   106     //<< QMediaPlayer::UnknownMediaStatus // status

   107     << QMediaContent(QUrl("file:///C:/data/testfiles/test_3gp.3gp")) // mediaContent

   108     << qint64(-1) // duration

   109     << qint64(0) // position

   110     << false // seekable

   111     << 0 // volume

   112     << false // muted

   113     << false; // videoAvailable

   114     //<< 0 // bufferStatus

   115     //<< qreal(0) // playbackRate

   116     //<< QMediaPlayer::NoError // error

   117     //<< QString(); // errorString

   118     */

   119 

   120     QTest::newRow("test_amr.amr")

   121     << true // valid

   122     //<< QMediaPlayer::StoppedState // state

   123     //<< QMediaPlayer::UnknownMediaStatus // status

   124     << QMediaContent(QUrl("file:///C:/data/testfiles/test_amr.amr")) // mediaContent

   125     << false // metaDataAvailable

   126     << false; // metaDataWritable

   127     //<< 0 // bufferStatus

   128     //<< qreal(0) // playbackRate

   129     //<< QMediaPlayer::NoError // error

   130     //<< QString(); // errorString

   131 

   132     QTest::newRow("test_flash_video.flv")

   133     << true // valid

   134     //<< QMediaPlayer::StoppedState // state

   135     //<< QMediaPlayer::UnknownMediaStatus // status

   136     << QMediaContent(QUrl("file:///C:/data/testfiles/test_flash_video.flv")) // mediaContent

   137     << false // metaDataAvailable

   138     << false; // metaDataWritable

   139     //<< 0 // bufferStatus

   140     //<< qreal(0) // playbackRate

   141     //<< QMediaPlayer::NoError // error

   142     //<< QString(); // errorString

   143 

   144     QTest::newRow("test_invalid_extension_mp4.xyz")

   145     << true // valid

   146     //<< QMediaPlayer::StoppedState // state

   147     //<< QMediaPlayer::UnknownMediaStatus // status

   148     << QMediaContent(QUrl("file:///C:/data/testfiles/test_invalid_extension_mp4.xyz")) // mediaContent

   149     << false // metaDataAvailable

   150     << false; // metaDataWritable

   151     //<< 0 // bufferStatus

   152     //<< qreal(0) // playbackRate

   153     //<< QMediaPlayer::NoError // error

   154     //<< QString(); // errorString

   155 

   156     QTest::newRow("test_invalid_extension_wav.xyz")

   157     << true // valid

   158     //<< QMediaPlayer::StoppedState // state

   159     //<< QMediaPlayer::UnknownMediaStatus // status

   160     << QMediaContent(QUrl("file:///C:/data/testfiles/test_invalid_extension_wav.xyz")) // mediaContent

   161     << false // metaDataAvailable

   162     << false; // metaDataWritable

   163     //<< 0 // bufferStatus

   164     //<< qreal(0) // playbackRate

   165     //<< QMediaPlayer::NoError // error

   166     //<< QString(); // errorString

   167 

   168     QTest::newRow("test_mp3.mp3")

   169     << true // valid

   170     //<< QMediaPlayer::StoppedState // state

   171     //<< QMediaPlayer::UnknownMediaStatus // status

   172     << QMediaContent(QUrl("file:///C:/data/testfiles/test_mp3.mp3")) // mediaContent

   173 #if !defined(__WINS__) || !defined(__WINSCW__)

   174     << true // metaDataAvailable

   175 #else

   176     << false // metaDataAvailable

   177 #endif // !defined(__WINS__) || defined(__WINSCW__)

   178     << false; // metaDataWritable

   179     //<< 0 // bufferStatus

   180     //<< qreal(0) // playbackRate

   181     //<< QMediaPlayer::NoError // error

   182     //<< QString(); // errorString

   183 

   184     QTest::newRow("test_mp3_no_metadata.mp3")

   185     << true // valid

   186     //<< QMediaPlayer::StoppedState // state

   187     //<< QMediaPlayer::UnknownMediaStatus // status

   188     << QMediaContent(QUrl("file:///C:/data/testfiles/test_mp3_no_metadata.mp3")) // mediaContent

   189     << false // metaDataAvailable

   190     << false; // metaDataWritable

   191     //<< 0 // bufferStatus

   192     //<< qreal(0) // playbackRate

   193     //<< QMediaPlayer::NoError // error

   194     //<< QString(); // errorString

   195 

   196     QTest::newRow("test_mp4.mp4")

   197     << true // valid

   198     //<< QMediaPlayer::StoppedState // state

   199     //<< QMediaPlayer::UnknownMediaStatus // status

   200     << QMediaContent(QUrl("file:///C:/data/testfiles/test_mp4.mp4")) // mediaContent

   201 #if defined(__WINS__) || defined(__WINSCW__)

   202     << true // metaDataAvailable

   203 #else

   204     << false // metaDataAvailable

   205 #endif // !defined(__WINS__) || defined(__WINSCW__)

   206     << false; // metaDataWritable

   207     //<< 0 // bufferStatus

   208     //<< qreal(0) // playbackRate

   209     //<< QMediaPlayer::NoError // error

   210     //<< QString(); // errorString

   211 

   212     QTest::newRow("test_wav.wav")

   213     << true // valid

   214     //<< QMediaPlayer::StoppedState // state

   215     //<< QMediaPlayer::UnknownMediaStatus // status

   216     << QMediaContent(QUrl("file:///C:/data/testfiles/test_wav.wav")) // mediaContent

   217     << false // metaDataAvailable

   218     << false; // metaDataWritable

   219     //<< 0 // bufferStatus

   220     //<< qreal(0) // playbackRate

   221     //<< QMediaPlayer::NoError // error

   222     //<< QString(); // errorString

   223 

   224     QTest::newRow("test_wmv9.wmv")

   225     << true // valid

   226     //<< QMediaPlayer::StoppedState // state

   227     //<< QMediaPlayer::UnknownMediaStatus // status

   228     << QMediaContent(QUrl("file:///C:/data/testfiles/test_wmv9.wmv")) // mediaContent

   229     << false // metaDataAvailable

   230     << false; // metaDataWritable

   231     //<< 0 // bufferStatus

   232     //<< qreal(0) // playbackRate

   233     //<< QMediaPlayer::NoError // error

   234     //<< QString(); // errorString

   235 

   236 

   237     QTest::newRow("test youtube stream")

   238     << true // valid

   239     //<< QMediaPlayer::StoppedState // state

   240     //<< QMediaPlayer::UnknownMediaStatus // status

   241     << QMediaContent(QUrl("rtsp://v3.cache4.c.youtube.com/CkgLENy73wIaPwlU2rm7yu8PFhMYESARFEIJbXYtZ29vZ2xlSARSB3JlbGF0ZWRaDkNsaWNrVGh1bWJuYWlsYPi6_IXT2rvpSgw=/0/0/0/video.3gp")) // mediaContent

   242     << false // metaDataAvailable

   243     << false; // metaDataWritable

   244     //<< 0 // bufferStatus

   245     //<< qreal(0) // playbackRate

   246     //<< QMediaPlayer::NoError // error

   247     //<< QString(); // errorString

   248 

   249 }

   250 

   251 void tst_QMediaObject::initTestCase()

   252 {

   253 }

   254 

   255 void tst_QMediaObject::cleanupTestCase()

   256 {

   257 }

   258 

   259 void tst_QMediaObject::init()

   260 {

   261     qRegisterMetaType<QMediaContent>("QMediaContent");

   262 }

   263 

   264 void tst_QMediaObject::cleanup()

   265 {

   266 }

   267 

   268 void tst_QMediaObject::isMetaDataAvailable()

   269 {

   270     QFETCH_GLOBAL(bool, metaDataAvailable);

   271     QFETCH_GLOBAL(QMediaContent, mediaContent);

   272 //    qWarning() << mediaContent.canonicalUrl();

   273     QMediaPlayer player;

   274 

   275     player.setMedia(mediaContent);

   276     QTest::qWait(700); 

   277     QVERIFY(player.isMetaDataAvailable() == metaDataAvailable);

   278 }

   279 

   280 void tst_QMediaObject::isWritable()

   281 {

   282     QFETCH_GLOBAL(bool, metaDataWritable);

   283     QFETCH_GLOBAL(QMediaContent, mediaContent);

   284 //    qWarning() << mediaContent.canonicalUrl();

   285     QMediaPlayer player;

   286 

   287     player.setMedia(mediaContent);

   288     QTest::qWait(700);

   289     QVERIFY(player.isMetaDataWritable() == metaDataWritable);

   290 }

   291 

   292 void tst_QMediaObject::metaData()

   293 {

   294     QFETCH_GLOBAL(QMediaContent, mediaContent);

   295     QFETCH_GLOBAL(bool, metaDataAvailable);

   296 //    qWarning() << mediaContent.canonicalUrl();

   297     QMediaPlayer player;

   298 

   299     player.setMedia(mediaContent);

   300     QTest::qWait(700);

   301     const QString artist(QLatin1String("Artist"));

   302     const QString title(QLatin1String("Title"));

   303 

   304     if (player.isMetaDataAvailable()) {

   305         QEXPECT_FAIL("", "player.metaData(QtMedia::AlbumArtist) failed: ", Continue);

   306         QCOMPARE(player.metaData(QtMedia::AlbumArtist).toString(), artist);

   307         QEXPECT_FAIL("", "player.metaData(QtMedia::Title) failed: ", Continue);

   308         QCOMPARE(player.metaData(QtMedia::Title).toString(), title);

   309     }

   310 }

   311 

   312 void tst_QMediaObject::availableMetaData()

   313 {

   314     QFETCH_GLOBAL(QMediaContent, mediaContent);

   315     QFETCH_GLOBAL(bool, metaDataAvailable);

   316 //    qWarning() << mediaContent.canonicalUrl();

   317     QMediaPlayer player;

   318 

   319     player.setMedia(mediaContent);

   320     QTest::qWait(700);    

   321 

   322     if (player.isMetaDataAvailable()) {

   323         QList<QtMedia::MetaData> metaDataKeys = player.availableMetaData();

   324         QEXPECT_FAIL("", "metaDataKeys.count() failed: ", Continue);

   325         QVERIFY(metaDataKeys.count() > 0);

   326 //        qWarning() << "metaDataKeys.count: " << metaDataKeys.count();

   327         QEXPECT_FAIL("", "metaDataKeys.contains(QtMedia::AlbumArtist) failed: ", Continue);

   328         QVERIFY(metaDataKeys.contains(QtMedia::AlbumArtist));

   329         QEXPECT_FAIL("", "metaDataKeys.contains(QtMedia::Title) failed: ", Continue);

   330         QVERIFY(metaDataKeys.contains(QtMedia::Title));

   331     }

   332 }

   333 

   334 void tst_QMediaObject::setMetaData()

   335 {

   336     QFETCH_GLOBAL(QMediaContent, mediaContent);

   337 //    qWarning() << mediaContent.canonicalUrl();

   338     QMediaPlayer player;

   339 

   340     player.setMedia(mediaContent);

   341     QTest::qWait(700); 

   342 

   343     QString title("Titletest");

   344     if (player.isMetaDataWritable()) {

   345         player.setMetaData(QtMedia::Title, title); 

   346         QCOMPARE(player.metaData(QtMedia::Title).toString(), title);

   347     }

   348 }

   349 

   350 void tst_QMediaObject::extendedMetaData()

   351 {

   352     QFETCH_GLOBAL(QMediaContent, mediaContent);

   353 //    qWarning() << mediaContent.canonicalUrl();

   354     QMediaPlayer player;

   355 

   356     player.setMedia(mediaContent);

   357     QTest::qWait(700);

   358     const QString artist(QLatin1String("Artist"));

   359     const QString title(QLatin1String("Title"));

   360 

   361     if (player.isMetaDataAvailable()) {  

   362         QEXPECT_FAIL("", "player.extendedMetaData(QtMedia::AlbumArtist) failed: ", Continue);

   363         QCOMPARE(player.extendedMetaData(metaDataKeyAsString(QtMedia::AlbumArtist)).toString(), artist);

   364         QEXPECT_FAIL("", "player.extendedMetaData(QtMedia::Title) failed: ", Continue);

   365         QCOMPARE(player.extendedMetaData(metaDataKeyAsString(QtMedia::Title)).toString(), title);

   366     }

   367 }

   368 

   369 void tst_QMediaObject::availableExtendedMetaData()

   370 {

   371     QFETCH_GLOBAL(QMediaContent, mediaContent);

   372 //    qWarning() << mediaContent.canonicalUrl();

   373     QMediaPlayer player;

   374 

   375     player.setMedia(mediaContent);

   376     QTest::qWait(700);

   377     const QString artist(QLatin1String("Artist"));

   378     const QString title(QLatin1String("Title"));

   379     

   380     if (player.isMetaDataAvailable()) {

   381         QStringList metaDataKeys = player.availableExtendedMetaData();

   382         QVERIFY(metaDataKeys.count() > 0);

   383 /*        qWarning() << "metaDataKeys.count: " << metaDataKeys.count();

   384         int count = metaDataKeys.count();

   385         count = count-1;

   386         int i = 0;

   387         while(count >= i)

   388             {            

   389             qWarning() << "metaDataKeys " << i <<". " << metaDataKeys.at(i);

   390             i++;

   391             }*/

   392         QEXPECT_FAIL("", "metaDataKeys.contains(QtMedia::AlbumArtist) failed: ", Continue);

   393         QVERIFY(metaDataKeys.contains(metaDataKeyAsString(QtMedia::AlbumArtist)));

   394         QEXPECT_FAIL("", "metaDataKeys.contains(QtMedia::AlbumArtist) failed: ", Continue);

   395         QVERIFY(metaDataKeys.contains(metaDataKeyAsString(QtMedia::Title)));

   396     }

   397 }

   398 

   399 void tst_QMediaObject::setExtendedMetaData()

   400 {

   401     QFETCH_GLOBAL(QMediaContent, mediaContent);

   402 //    qWarning() << mediaContent.canonicalUrl();

   403     QMediaPlayer player;

   404 

   405     player.setMedia(mediaContent);

   406     QTest::qWait(700);

   407     const QString title(QLatin1String("Titletest"));

   408 

   409     if (player.isMetaDataWritable()) {

   410         player.setExtendedMetaData(metaDataKeyAsString(QtMedia::Title), title);  

   411         QCOMPARE(player.metaData(QtMedia::Title).toString(), title);

   412     }

   413 }

   414 

   415 QString tst_QMediaObject::metaDataKeyAsString(QtMedia::MetaData key) const

   416 {

   417     switch(key) {

   418         case QtMedia::Title: return "title";

   419         case QtMedia::AlbumArtist: return "artist";

   420         case QtMedia::Comment: return "comment";

   421         case QtMedia::Genre: return "genre";

   422         case QtMedia::Year: return "year";

   423         case QtMedia::Copyright: return "copyright";

   424         case QtMedia::AlbumTitle: return "album";

   425         case QtMedia::Composer: return "composer";

   426         case QtMedia::TrackNumber: return "albumtrack";

   427         case QtMedia::AudioBitRate: return "audiobitrate";

   428         case QtMedia::VideoBitRate: return "videobitrate";

   429         case QtMedia::Duration: return "duration";

   430         case QtMedia::MediaType: return "contenttype";

   431         case QtMedia::SubTitle: // TODO: Find the matching metadata keys

   432         case QtMedia::Description:

   433         case QtMedia::Category:

   434         case QtMedia::Date:

   435         case QtMedia::UserRating:

   436         case QtMedia::Keywords:

   437         case QtMedia::Language:

   438         case QtMedia::Publisher:

   439         case QtMedia::ParentalRating:

   440         case QtMedia::RatingOrganisation:

   441         case QtMedia::Size:

   442         case QtMedia::AudioCodec:

   443         case QtMedia::AverageLevel:

   444         case QtMedia::ChannelCount:

   445         case QtMedia::PeakValue:

   446         case QtMedia::SampleRate:

   447         case QtMedia::Author:

   448         case QtMedia::ContributingArtist:

   449         case QtMedia::Conductor:

   450         case QtMedia::Lyrics:

   451         case QtMedia::Mood:

   452         case QtMedia::TrackCount:

   453         case QtMedia::CoverArtUrlSmall:

   454         case QtMedia::CoverArtUrlLarge:

   455         case QtMedia::Resolution:

   456         case QtMedia::PixelAspectRatio:

   457         case QtMedia::VideoFrameRate:

   458         case QtMedia::VideoCodec:

   459         case QtMedia::PosterUrl:

   460         case QtMedia::ChapterNumber:

   461         case QtMedia::Director:

   462         case QtMedia::LeadPerformer:

   463         case QtMedia::Writer:

   464         case QtMedia::CameraManufacturer:

   465         case QtMedia::CameraModel:

   466         case QtMedia::Event:

   467         case QtMedia::Subject:

   468         default:

   469             break;

   470     }

   471 

   472     return QString();

   473 }

   474 

   475 QTEST_MAIN(tst_QMediaObject)

   476 

   477 #include "tst_qmediaobject_s60.moc"