git.maemo.org Git - mafwsubrenderer/blob - qmafw-gst-subtitles-renderer/unittests/ut_MafwGstRendererWorker/ut_MafwGstRendererWorker.cpp

   1 /*
   2  * This file is part of QMAFW
   3  *
   4  * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights
   5  * reserved.
   6  *
   7  * Contact: Visa Smolander <visa.smolander@nokia.com>
   8  *
   9  * This software, including documentation, is protected by copyright controlled
  10  * by Nokia Corporation. All rights are reserved. Copying, including
  11  * reproducing, storing, adapting or translating, any or all of this material
  12  * requires the prior written consent of Nokia Corporation. This material also
  13  * contains confidential information which may not be disclosed to others
  14  * without the prior written consent of Nokia.
  15  *
  16  */
  17
  18 #include <QDir>
  19 #include <QUrl>
  20 #include <QTimer>
  21
  22 #include <glib.h>
  23 #include <gst/gst.h>
  24 #include <gst/tag/tag.h>
  25 #include <context_provider.h>
  26
  27 #include "ut_MafwGstRendererWorker.h"
  28 #include "mafw-gst-renderer-worker.h"
  29 #include "mafw-gst-renderer-utils.h"
  30
  31 static QUrl AUDIO_URI(QDir::currentPath() + QDir::separator() +
  32                       QString("media") + QDir::separator() +
  33                       QString("test.wav"));
  34
  35 static QUrl VIDEO_URI(QDir::currentPath() + QDir::separator() +
  36                       QString("media") + QDir::separator() +
  37                       QString("test.avi"));
  38
  39 static QUrl IMAGE_URI(QDir::currentPath() + QDir::separator() +
  40                       QString("media") + QDir::separator() +
  41                       QString("testframe.png"));
  42
  43 static int WAIT_TIMEOUT = 3500;
  44 static int EOS_TIMEOUT = 7000;
  45 static int READY_DELAY = 65000;
  46
  47 static bool NEVER_HAPPENING_EVENT = false;
  48
  49 static int global_context_duration = 0;
  50
  51 static QStringList globalGstFactoryRequests;
  52 static GstElement *globalGstPipeline;
  53
  54
  55 const gchar* g_getenv(const gchar *variable)
  56 {
  57     Q_UNUSED(variable);
  58     return NULL;
  59 }
  60
  61 gboolean convert_utf8(const gchar *src, gchar **dst)
  62 {
  63     *dst = g_strdup(src);
  64     return TRUE;
  65 }
  66
  67 gboolean uri_is_playlist(const gchar *uri)
  68 {
  69     Q_UNUSED(uri);
  70     return FALSE;
  71 }
  72
  73 gboolean uri_is_stream(const gchar *uri)
  74 {
  75     Q_UNUSED(uri);
  76     return FALSE;
  77 }
  78
  79 gint remap_gst_error_code(const GError *error)
  80 {
  81     return error->code;
  82 }
  83
  84 void context_provider_set_map(const char* key, void* map, int free_map)
  85 {
  86     Q_UNUSED(key);
  87     Q_UNUSED(map);
  88     Q_UNUSED(free_map);
  89 }
  90
  91 void *context_provider_map_new(void)
  92 {
  93
  94     return NULL;
  95 }
  96
  97 void context_provider_map_free(void* map)
  98 {
  99     Q_UNUSED(map);
 100 }
 101
 102 void context_provider_map_set_integer(void* map, const char* key, int value)
 103 {
 104     Q_UNUSED(map);
 105
 106     if( strcmp( key, "duration" )==0 )
 107     {
 108         global_context_duration = value;
 109     }
 110 }
 111
 112 void context_provider_map_set_double(void* map, const char* key, double value)
 113 {
 114     Q_UNUSED(map);
 115     Q_UNUSED(key);
 116     Q_UNUSED(value);
 117 }
 118
 119 void context_provider_map_set_boolean(void* map, const char* key, int value)
 120 {
 121     Q_UNUSED(map);
 122     Q_UNUSED(key);
 123     Q_UNUSED(value);
 124 }
 125
 126 void context_provider_map_set_string(void* map, const char* key, const char* value)
 127 {
 128     Q_UNUSED(map);
 129     Q_UNUSED(key);
 130     Q_UNUSED(value);
 131 }
 132
 133 void context_provider_map_set_map(void* map, const char* key, void* value)
 134 {
 135     Q_UNUSED(map);
 136     Q_UNUSED(key);
 137     Q_UNUSED(value);
 138 }
 139
 140 void context_provider_set_null(const char* key)
 141 {
 142     Q_UNUSED(key);
 143 }
 144
 145 gboolean context_provider_init(DBusBusType bus_type, const char* bus_name)
 146 {
 147
 148     Q_UNUSED(bus_type);
 149     Q_UNUSED(bus_name);
 150
 151     return TRUE;
 152
 153 }
 154
 155 void context_provider_stop(void)
 156 {
 157 }
 158
 159 void context_provider_install_key(
 160     const char* key,
 161     gboolean clear_values_on_subscribe,
 162     ContextProviderSubscriptionChangedCallback subscription_changed_cb,
 163     void* subscription_changed_cb_target)
 164 {
 165     Q_UNUSED(key);
 166     Q_UNUSED(clear_values_on_subscribe);
 167     Q_UNUSED(subscription_changed_cb);
 168     Q_UNUSED(subscription_changed_cb_target);
 169 }
 170
 171 GstElement *gst_element_factory_make(const gchar *factoryname, const gchar *name)
 172 {
 173     GstElementFactory *factory;
 174     GstElement *element;
 175     const gchar *use_factoryname;
 176
 177     g_return_val_if_fail(factoryname != NULL, NULL);
 178
 179     globalGstFactoryRequests.append(factoryname);
 180
 181     /* For testing, use playbin instead of playbin2 */
 182     if (g_str_equal(factoryname, "playbin2"))
 183     {
 184         use_factoryname = "playbin";
 185     }
 186     else
 187     {
 188         use_factoryname = factoryname;
 189     }
 190
 191     GST_LOG("gstelementfactory: make \"%s\" \"%s\"",
 192             use_factoryname, GST_STR_NULL (name));
 193
 194     factory = gst_element_factory_find(use_factoryname);
 195     if (factory == NULL)
 196     {
 197         /* No factory */
 198         GST_INFO("no such element factory \"%s\"!", use_factoryname);
 199         return NULL;
 200     }
 201
 202     GST_LOG_OBJECT(factory, "found factory %p", factory);
 203     if (g_str_equal(use_factoryname, "pulsesink"))
 204     {
 205         element = gst_element_factory_make("fakesink", "pulsesink");
 206         g_object_set(G_OBJECT(element), "sync", TRUE, NULL);
 207     }
 208     else if (g_str_equal(use_factoryname, "alsasink"))
 209     {
 210         element = gst_element_factory_make("fakesink", "alsasink");
 211         g_object_set(G_OBJECT(element), "sync", TRUE, NULL);
 212     }
 213     else if (g_str_equal(use_factoryname, "xvimagesink")
 214         || g_str_equal(use_factoryname, "omapxvsink"))
 215     {
 216         element = gst_element_factory_make("fakesink", "xvimagesink");
 217         g_object_set(G_OBJECT(element), "sync", TRUE, NULL);
 218     }
 219     else
 220     {
 221         element = gst_element_factory_create(factory, name);
 222         if( !g_strcmp0(use_factoryname, "playbin") )
 223         {
 224             globalGstPipeline = element;
 225         }
 226     }
 227     gst_object_unref(factory);
 228
 229     if (element == NULL)
 230     {
 231         /* Create failed */
 232         GST_INFO_OBJECT(factory, "couldn't create instance!");
 233         return NULL;
 234     }
 235
 236     GST_LOG("gstelementfactory: make \"%s\" \"%s\"",use_factoryname,
 237             GST_STR_NULL(name));
 238
 239     /* Playbin will use fake renderer */
 240     if (g_str_equal(use_factoryname, "playbin"))
 241     {
 242         GstElement *audiorenderer = gst_element_factory_make("fakesink",
 243                                                              "audiorenderer");
 244         g_object_set(G_OBJECT(audiorenderer), "sync", TRUE, NULL);
 245         g_object_set(G_OBJECT(element), "audio-sink", audiorenderer, NULL);
 246         g_object_set(G_OBJECT(element), "video-sink", audiorenderer, NULL);
 247     }
 248
 249     return element;
 250
 251 }
 252 /* END OF STUB DEFINITIONS */
 253
 254 void ut_MafwGstRendererWorker::playCallback(MafwGstRendererWorker *worker,
 255                                             gpointer owner)
 256 {
 257
 258     Q_UNUSED(worker);
 259     Q_UNUSED(owner);
 260     qDebug() << __PRETTY_FUNCTION__;
 261
 262     ut_MafwGstRendererWorker* self =
 263         static_cast<ut_MafwGstRendererWorker*>(owner);
 264     self->m_gotPlayCallback = true;
 265
 266 }
 267
 268 void ut_MafwGstRendererWorker::pauseCallback(MafwGstRendererWorker *worker,
 269                                              gpointer owner)
 270 {
 271     Q_UNUSED(worker);
 272
 273     qDebug() << __PRETTY_FUNCTION__;
 274
 275     ut_MafwGstRendererWorker* self =
 276         static_cast<ut_MafwGstRendererWorker*>(owner);
 277     self->m_gotPauseCallback = true;
 278 }
 279
 280 void ut_MafwGstRendererWorker::bufferingCallback(MafwGstRendererWorker *worker,
 281                                                  gpointer owner,
 282                                                  gdouble percent)
 283 {
 284     Q_UNUSED(worker);
 285
 286     qDebug() << __PRETTY_FUNCTION__;
 287
 288     ut_MafwGstRendererWorker* self =
 289         static_cast<ut_MafwGstRendererWorker*>(owner);
 290     self->m_receivedBufferStatus = percent;
 291     self->m_gotBufferStatusCallback = true;
 292 }
 293
 294 void ut_MafwGstRendererWorker::eosCallback(MafwGstRendererWorker *worker,
 295                                            gpointer owner)
 296 {
 297
 298     Q_UNUSED(worker);
 299
 300     qDebug() << __PRETTY_FUNCTION__;
 301
 302     ut_MafwGstRendererWorker* self =
 303         static_cast<ut_MafwGstRendererWorker*>(owner);
 304     self->m_gotEosCallback = true;
 305
 306 }
 307
 308 void ut_MafwGstRendererWorker::seekCallback(MafwGstRendererWorker *worker,
 309                                             gpointer owner)
 310 {
 311
 312     Q_UNUSED(worker);
 313
 314     qDebug() << __PRETTY_FUNCTION__;
 315
 316     ut_MafwGstRendererWorker* self =
 317         static_cast<ut_MafwGstRendererWorker*>(owner);
 318     self->m_gotSeekCallback = true;
 319
 320 }
 321
 322 void ut_MafwGstRendererWorker::errorCallback(MafwGstRendererWorker *worker,
 323                                              gpointer owner,
 324                                              const GError *error)
 325 {
 326
 327     Q_UNUSED(worker);
 328
 329     ut_MafwGstRendererWorker* self =
 330         static_cast<ut_MafwGstRendererWorker*>(owner);
 331     self->m_receivedErrorCode = error->code;
 332
 333     if (error)
 334     {
 335         qCritical() << "error code: " << error->code << " message: " <<
 336             error->message;
 337     }
 338     self->m_gotErrorCallback = true;
 339
 340 }
 341
 342 void ut_MafwGstRendererWorker::propertyCallback(MafwGstRendererWorker *worker,
 343                                                 gpointer owner,
 344                                                 gint id,
 345                                                 GValue *value)
 346 {
 347
 348     Q_UNUSED(worker);
 349     Q_UNUSED(value);
 350
 351     ut_MafwGstRendererWorker* self =
 352         static_cast<ut_MafwGstRendererWorker*>(owner);
 353     self->m_receivedPropertyId = id;
 354     self->m_gotPropertyCallback = true;
 355
 356 }
 357
 358 void ut_MafwGstRendererWorker::metadataCallback(MafwGstRendererWorker *worker,
 359                                                 gpointer owner,
 360                                                 gint key,
 361                                                 GType type,
 362                                                 gpointer value)
 363 {
 364
 365     Q_UNUSED(worker);
 366     Q_UNUSED(type);
 367     Q_UNUSED(value);
 368
 369     ut_MafwGstRendererWorker* self =
 370         static_cast<ut_MafwGstRendererWorker*>(owner);
 371     self->m_receivedMetadata.append(key);
 372     self->m_gotMetadataCallback = true;
 373
 374 }
 375
 376 void ut_MafwGstRendererWorker::blankingControlCallback(MafwGstRendererWorker *worker,
 377                                    gpointer owner, gboolean prohibit)
 378 {
 379     Q_UNUSED(worker);
 380
 381     ut_MafwGstRendererWorker* self =
 382         static_cast<ut_MafwGstRendererWorker*>(owner);
 383     self->m_blankingProhibited = prohibit;
 384 }
 385
 386 void ut_MafwGstRendererWorker::screenshotCallback(MafwGstRendererWorker *worker,
 387                                                   gpointer owner, GstBuffer *buffer,
 388                                                   const char *filename, gboolean cancel)
 389 {
 390     Q_UNUSED(worker);
 391     Q_UNUSED(buffer);
 392     Q_UNUSED(filename);
 393     if(!cancel)
 394     {
 395         ut_MafwGstRendererWorker* self =
 396             static_cast<ut_MafwGstRendererWorker*>(owner);
 397         self->m_receivedMetadata.append(WORKER_METADATA_KEY_PAUSED_THUMBNAIL_URI);
 398         self->m_gotMetadataCallback = true;
 399     }
 400 }
 401
 402 void ut_MafwGstRendererWorker::basicPlaybackTestCase()
 403 {
 404
 405     m_worker->notify_play_handler = &playCallback;
 406     m_worker->notify_error_handler = &errorCallback;
 407     m_worker->blanking__control_handler = &blankingControlCallback;
 408     mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii());
 409
 410     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
 411
 412     QVERIFY(m_gotPlayCallback == true);
 413     QVERIFY(m_gotErrorCallback == false);
 414     QCOMPARE( global_context_duration, 3 ); // 2.5 seconds is duration of test.wav
 415     QVERIFY(m_blankingProhibited == false);
 416
 417     //video-sink should not be created unless XID has been set
 418     QVERIFY(!m_worker->vsink);
 419 }
 420
 421 void ut_MafwGstRendererWorker::basicVideoPlaybackTestCase()
 422 {
 423
 424     m_worker->notify_play_handler = &playCallback;
 425     m_worker->notify_error_handler = &errorCallback;
 426     m_worker->blanking__control_handler = &blankingControlCallback;
 427
 428     QVERIFY(!m_worker->vsink);
 429     mafw_gst_renderer_worker_set_xid(m_worker, 0xffff);
 430     QVERIFY(m_worker->vsink);
 431
 432     mafw_gst_renderer_worker_play(m_worker, VIDEO_URI.toString().toAscii());
 433     m_worker->media.has_visual_content = true; // normally gst sets this but not in unittest for some reason
 434
 435     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
 436
 437     QVERIFY(m_gotPlayCallback == true);
 438     QVERIFY(m_gotErrorCallback == false);
 439     QVERIFY(m_blankingProhibited == true);
 440 }
 441
 442 void ut_MafwGstRendererWorker::pauseFrameTestCase()
 443 {
 444
 445     m_worker->notify_play_handler = &playCallback;
 446     m_worker->notify_pause_handler = &pauseCallback;
 447     m_worker->notify_metadata_handler = &metadataCallback;
 448     m_worker->notify_property_handler = &propertyCallback;
 449     m_worker->notify_error_handler = &errorCallback;
 450     m_worker->blanking__control_handler = &blankingControlCallback;
 451     m_worker->screenshot_handler = screenshotCallback;
 452
 453     mafw_gst_renderer_worker_set_current_frame_on_pause(m_worker, TRUE);
 454     QVERIFY(mafw_gst_renderer_worker_get_current_frame_on_pause(m_worker) ==
 455             TRUE);
 456     QVERIFY(m_gotPropertyCallback == true);
 457     QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_CURRENT_FRAME_ON_PAUSE);
 458
 459     mafw_gst_renderer_worker_set_xid(m_worker, 0xffff);
 460     QVERIFY(mafw_gst_renderer_worker_get_xid(m_worker) == 0xffff);
 461     QVERIFY(m_gotPropertyCallback == true);
 462     QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_XID);
 463     m_gotPropertyCallback = false;
 464     m_receivedPropertyId = -1;
 465
 466     mafw_gst_renderer_worker_play(m_worker, VIDEO_URI.toString().toAscii());
 467
 468     /* post xwindow-id on bus since we are using fakesink instead of
 469      * xvimagesink */
 470     GstBus *bus;
 471     GstStructure *structure;
 472     GstMessage *message;
 473     structure = gst_structure_new("prepare-xwindow-id", "width",
 474                                   G_TYPE_INT, 64, "height", G_TYPE_INT, 32,
 475                                   NULL);
 476     message = gst_message_new_element(NULL, structure);
 477     bus = m_worker->bus;
 478     gst_bus_post(bus, message);
 479     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
 480
 481     mafw_gst_renderer_worker_pause(m_worker);
 482     waitForEvent(WAIT_TIMEOUT, NEVER_HAPPENING_EVENT);
 483
 484     QVERIFY(m_gotPlayCallback == true);
 485     QVERIFY(m_gotPauseCallback == true);
 486     QVERIFY(m_gotMetadataCallback == true);
 487     QVERIFY(m_gotErrorCallback == false);
 488     QVERIFY(m_receivedMetadata.contains(WORKER_METADATA_KEY_PAUSED_THUMBNAIL_URI));
 489
 490 }
 491
 492 void ut_MafwGstRendererWorker::pauseFrameCancelTestCase()
 493 {
 494     m_worker->notify_play_handler = &playCallback;
 495     m_worker->notify_pause_handler = &pauseCallback;
 496     m_worker->notify_metadata_handler = &metadataCallback;
 497     m_worker->notify_property_handler = &propertyCallback;
 498     m_worker->notify_error_handler = &errorCallback;
 499     m_worker->blanking__control_handler = &blankingControlCallback;
 500     m_worker->screenshot_handler = screenshotCallback;
 501
 502     mafw_gst_renderer_worker_set_current_frame_on_pause(m_worker, TRUE);
 503     QVERIFY(mafw_gst_renderer_worker_get_current_frame_on_pause(m_worker) ==
 504             TRUE);
 505     QVERIFY(m_gotPropertyCallback == true);
 506     QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_CURRENT_FRAME_ON_PAUSE);
 507
 508     mafw_gst_renderer_worker_set_xid(m_worker, 0xffff);
 509     QVERIFY(mafw_gst_renderer_worker_get_xid(m_worker) == 0xffff);
 510     QVERIFY(m_gotPropertyCallback == true);
 511     QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_XID);
 512     m_gotPropertyCallback = false;
 513     m_receivedPropertyId = -1;
 514
 515     mafw_gst_renderer_worker_play(m_worker, VIDEO_URI.toString().toAscii());
 516
 517     /* post xwindow-id on bus since we are using fakesink instead of
 518      * xvimagesink */
 519     GstBus *bus;
 520     GstStructure *structure;
 521     GstMessage *message;
 522     structure = gst_structure_new("prepare-xwindow-id", "width",
 523                                   G_TYPE_INT, 64, "height", G_TYPE_INT, 32,
 524                                   NULL);
 525     message = gst_message_new_element(NULL, structure);
 526     bus = m_worker->bus;
 527     gst_bus_post(bus, message);
 528     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
 529
 530     mafw_gst_renderer_worker_pause(m_worker);
 531     waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback);
 532     mafw_gst_renderer_worker_resume(m_worker);
 533     QTest::qWait(10);
 534
 535
 536     QVERIFY(m_gotPlayCallback == true);
 537     QVERIFY(m_gotPauseCallback == true);
 538     QVERIFY(m_gotMetadataCallback == true);
 539     QVERIFY(m_gotErrorCallback == false);
 540     QVERIFY(!m_receivedMetadata.contains(WORKER_METADATA_KEY_PAUSED_THUMBNAIL_URI));
 541
 542
 543 }
 544
 545 void ut_MafwGstRendererWorker::redirectMessageTestCase()
 546 {
 547     m_worker->notify_play_handler = &playCallback;
 548     m_worker->notify_error_handler = &errorCallback;
 549     m_worker->blanking__control_handler = &blankingControlCallback;
 550
 551     /* We just give random uri to renderer, because we ignore the error */
 552     /* We don't have to test with real RTSP stream, we just use local content */
 553     char *control = qstrdup(VIDEO_URI.toString().toAscii());
 554
 555     GstStructure *structure;
 556     GstMessage *message;
 557     structure = gst_structure_new("redirect", "new-location",
 558                                   G_TYPE_STRING, control, NULL);
 559
 560         // reset and construct the pipeline
 561     mafw_gst_renderer_worker_stop(m_worker);
 562
 563         // when worker receives "redirect" message, it should start playing the uri contained in the message.
 564     message = gst_message_new_element(GST_OBJECT_CAST(m_worker->pipeline), structure);
 565     gst_element_post_message(m_worker->pipeline, message);
 566
 567
 568     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
 569
 570     QVERIFY(m_gotPlayCallback == true);
 571     QVERIFY(strcmp(control, m_worker->media.location) == 0);
 572     QVERIFY(m_gotErrorCallback == false);
 573
 574     delete[] control;
 575 }
 576
 577 void ut_MafwGstRendererWorker::slotTimeOut()
 578 {
 579     qDebug() << "TIMEOUT!";
 580 }
 581
 582 void ut_MafwGstRendererWorker::waitForEvent(gint ms, bool &hasEventOccurred)
 583
 584 {
 585     qDebug() << __PRETTY_FUNCTION__;
 586
 587     if (hasEventOccurred)
 588     {
 589         return;
 590     }
 591
 592     QTimer timer(this);
 593     QObject::connect(&timer, SIGNAL(timeout()), this, SLOT(slotTimeOut()));
 594     timer.setSingleShot(true);
 595     timer.start(ms);
 596
 597     while (!hasEventOccurred && timer.isActive())
 598     {
 599         g_main_context_iteration(NULL, TRUE);
 600     }
 601 }
 602
 603 void ut_MafwGstRendererWorker::bufferingTestCase()
 604 {
 605
 606     m_worker->notify_play_handler = &playCallback;
 607     m_worker->notify_buffer_status_handler = &bufferingCallback;
 608     m_worker->notify_error_handler = &errorCallback;
 609     m_worker->blanking__control_handler = &blankingControlCallback;
 610
 611     mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii());
 612     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
 613
 614     /* post the buffering msg on bus */
 615     GstBus *bus = 0;
 616     GstMessage *message = 0;
 617
 618     message = gst_message_new_buffering(NULL, 50);
 619     bus = m_worker->bus;
 620     gst_bus_post(bus, message);
 621
 622     waitForEvent(WAIT_TIMEOUT, m_gotBufferStatusCallback);
 623
 624     QVERIFY(m_gotPlayCallback == true);
 625     QVERIFY(m_receivedBufferStatus == 50);
 626     QVERIFY(m_gotErrorCallback == false);
 627
 628 }
 629
 630 void ut_MafwGstRendererWorker::rendererArtTestCase()
 631 {
 632
 633     m_worker->notify_play_handler = &playCallback;
 634     m_worker->notify_pause_handler = &pauseCallback;
 635     m_worker->notify_metadata_handler = &metadataCallback;
 636     m_worker->notify_error_handler = &errorCallback;
 637     m_worker->blanking__control_handler = &blankingControlCallback;
 638
 639     mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii());
 640     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
 641     mafw_gst_renderer_worker_pause(m_worker);
 642     waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback);
 643
 644     /* post the renderer art tag on bus */
 645     gsize image_length = 0;
 646     gchar *image = 0;
 647     GstCaps *caps = 0;
 648     GstBuffer *buffer = 0;
 649     GstMessage *message = 0;
 650     GstTagList *list = 0;
 651
 652     QVERIFY(g_file_get_contents(IMAGE_URI.toLocalFile().toAscii(),
 653                                 &image,
 654                                 &image_length,
 655                                 NULL));
 656     buffer = gst_buffer_new();
 657     gst_buffer_set_data(buffer, (guint8*)image, image_length);
 658     caps = gst_caps_new_simple("image/png", "image-type",
 659                                GST_TYPE_TAG_IMAGE_TYPE,
 660                                GST_TAG_IMAGE_TYPE_FRONT_COVER, NULL);
 661     gst_buffer_set_caps(buffer, caps);
 662
 663     list = gst_tag_list_new();
 664     gst_tag_list_add(list, GST_TAG_MERGE_APPEND, GST_TAG_IMAGE, buffer, NULL);
 665
 666     message = gst_message_new_tag(NULL, list);
 667     gst_bus_post(m_worker->bus, message);
 668     mafw_gst_renderer_worker_resume(m_worker);
 669
 670     waitForEvent(WAIT_TIMEOUT, NEVER_HAPPENING_EVENT);
 671
 672     QVERIFY(m_gotPlayCallback == true);
 673     QVERIFY(m_gotPauseCallback == true);
 674     QVERIFY(m_gotMetadataCallback == true);
 675     QVERIFY(m_gotErrorCallback == false);
 676     QVERIFY(m_receivedMetadata.contains(WORKER_METADATA_KEY_RENDERER_ART_URI));
 677
 678     gst_buffer_unref(buffer);
 679     gst_caps_unref(caps);
 680     g_free(image);
 681
 682 }
 683
 684 void ut_MafwGstRendererWorker::eosTestCase()
 685 {
 686
 687     m_worker->notify_play_handler = &playCallback;
 688     m_worker->notify_error_handler = &errorCallback;
 689     m_worker->notify_eos_handler = &eosCallback;
 690     m_worker->blanking__control_handler = &blankingControlCallback;
 691     mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii());
 692
 693     waitForEvent(EOS_TIMEOUT, m_gotEosCallback);
 694
 695     QVERIFY(m_gotPlayCallback == true);
 696     QVERIFY(m_gotEosCallback == true);
 697     QVERIFY(m_gotErrorCallback == false);
 698
 699 }
 700
 701 void ut_MafwGstRendererWorker::seekTestCase()
 702 {
 703
 704     GError *error = 0;
 705
 706     m_worker->notify_play_handler = &playCallback;
 707     m_worker->notify_error_handler = &errorCallback;
 708     m_worker->notify_seek_handler = &seekCallback;
 709     m_worker->blanking__control_handler = &blankingControlCallback;
 710     mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii());
 711
 712     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
 713
 714     QVERIFY(m_gotPlayCallback == true);
 715     QVERIFY(m_gotErrorCallback == false);
 716
 717     mafw_gst_renderer_worker_set_position(m_worker,
 718                                           GST_SEEK_TYPE_SET,
 719                                           1,
 720                                           &error);
 721
 722     QVERIFY(m_gotPlayCallback == true);
 723     QVERIFY(m_gotSeekCallback == true);
 724     QVERIFY(m_gotErrorCallback == false);
 725     QVERIFY(error == 0);
 726     QVERIFY(mafw_gst_renderer_worker_get_position(m_worker) == 1);
 727
 728 }
 729
 730 void ut_MafwGstRendererWorker::invalidUriTestCase()
 731 {
 732
 733     m_worker->notify_play_handler = &playCallback;
 734     m_worker->notify_error_handler = &errorCallback;
 735     m_worker->blanking__control_handler = &blankingControlCallback;
 736     mafw_gst_renderer_worker_play(m_worker, "vjmksbhdfghrejggv");
 737
 738     waitForEvent(WAIT_TIMEOUT, m_gotErrorCallback);
 739
 740     QVERIFY(m_gotPlayCallback == false);
 741     QVERIFY(m_gotErrorCallback == true);
 742     /* FIXME: new code for Gst errors? */
 743     /*QVERIFY(m_receivedErrorCode == WORKER_ERROR_UNABLE_TO_PERFORM);*/
 744
 745 }
 746
 747 void ut_MafwGstRendererWorker::playAndStopTestCase()
 748 {
 749
 750     m_worker->notify_play_handler = &playCallback;
 751     m_worker->notify_error_handler = &errorCallback;
 752     m_worker->blanking__control_handler = &blankingControlCallback;
 753     mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii());
 754
 755     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
 756     QVERIFY(m_gotPlayCallback == true);
 757
 758     mafw_gst_renderer_worker_stop(m_worker);
 759
 760     QVERIFY(m_gotPlayCallback == true);
 761     QVERIFY(m_gotErrorCallback == false);
 762
 763 }
 764
 765 void ut_MafwGstRendererWorker::playAndPauseTestCase()
 766 {
 767
 768     m_worker->notify_play_handler = &playCallback;
 769     m_worker->notify_error_handler = &errorCallback;
 770     m_worker->notify_pause_handler = &pauseCallback;
 771     m_worker->blanking__control_handler = &blankingControlCallback;
 772     mafw_gst_renderer_worker_set_xid(m_worker, 0xffff);
 773
 774     mafw_gst_renderer_worker_play(m_worker, VIDEO_URI.toString().toAscii());
 775     m_worker->media.has_visual_content = true; // normally gst sets this but not in unittest for some reason
 776
 777     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
 778     QVERIFY(m_gotPlayCallback == true);
 779     QVERIFY(m_gotPauseCallback == false);
 780     QVERIFY(m_blankingProhibited == true);
 781
 782     mafw_gst_renderer_worker_pause(m_worker);
 783     waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback);
 784
 785     QVERIFY(m_gotPlayCallback == true);
 786     QVERIFY(m_gotPauseCallback == true);
 787     QVERIFY(m_gotErrorCallback == false);
 788     QVERIFY(m_blankingProhibited == false);
 789 }
 790
 791 void ut_MafwGstRendererWorker::pauseQuicklyAfterPlayTestCase()
 792 {
 793     m_worker->notify_play_handler = &playCallback;
 794     m_worker->notify_error_handler = &errorCallback;
 795     m_worker->notify_pause_handler = &pauseCallback;
 796     m_worker->blanking__control_handler = &blankingControlCallback;
 797     mafw_gst_renderer_worker_set_xid(m_worker, 0xffff);
 798
 799     mafw_gst_renderer_worker_play(m_worker, VIDEO_URI.toString().toAscii());
 800     m_worker->media.has_visual_content = true; // normally gst sets this but not in unittest for some reason
 801     mafw_gst_renderer_worker_pause(m_worker);
 802
 803     waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback);
 804     QVERIFY(m_gotPlayCallback == false);
 805     QVERIFY(m_gotPauseCallback == true);
 806     QVERIFY(m_blankingProhibited == false);
 807
 808     m_gotPlayCallback = false;
 809     m_gotPauseCallback = false;
 810
 811     mafw_gst_renderer_worker_resume(m_worker);
 812     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
 813     waitForEvent(WAIT_TIMEOUT, m_blankingProhibited);
 814     QCOMPARE(m_gotPlayCallback, true);
 815     QCOMPARE(m_blankingProhibited, true);
 816 }
 817
 818 void ut_MafwGstRendererWorker::pauseAtTestCase()
 819 {
 820     m_worker->notify_play_handler = &playCallback;
 821     m_worker->notify_error_handler = &errorCallback;
 822     m_worker->notify_pause_handler = &pauseCallback;
 823     m_worker->blanking__control_handler = &blankingControlCallback;
 824     mafw_gst_renderer_worker_set_xid(m_worker, 0xffff);
 825
 826     mafw_gst_renderer_worker_play(m_worker, VIDEO_URI.toString().toAscii());
 827     m_worker->media.has_visual_content = true; // normally gst sets this but not in unittest for some reason
 828     //the video is only two seconds long
 829     mafw_gst_renderer_worker_pause_at(m_worker, 1);
 830
 831     waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback);
 832     QVERIFY(m_gotPlayCallback == false);
 833     QVERIFY(m_gotPauseCallback == true);
 834     QVERIFY(m_blankingProhibited == false);
 835
 836     QVERIFY(mafw_gst_renderer_worker_get_position(m_worker) == 1);
 837
 838     m_gotPlayCallback = false;
 839     m_gotPauseCallback = false;
 840
 841     mafw_gst_renderer_worker_resume(m_worker);
 842     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
 843     waitForEvent(WAIT_TIMEOUT, m_blankingProhibited);
 844     QCOMPARE(m_gotPlayCallback, true);
 845     QCOMPARE(m_blankingProhibited, true);
 846 }
 847
 848 void ut_MafwGstRendererWorker::playAndPauseAndResumeTestCase()
 849 {
 850
 851     m_worker->notify_play_handler = &playCallback;
 852     m_worker->notify_error_handler = &errorCallback;
 853     m_worker->notify_pause_handler = &pauseCallback;
 854     m_worker->blanking__control_handler = &blankingControlCallback;
 855     mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii());
 856
 857     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
 858     QVERIFY(m_gotPlayCallback == true);
 859     QVERIFY(m_gotPauseCallback == false);
 860
 861     mafw_gst_renderer_worker_pause(m_worker);
 862     waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback);
 863
 864     m_gotPlayCallback = false;
 865     mafw_gst_renderer_worker_resume(m_worker);
 866     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
 867
 868     QVERIFY(m_gotPlayCallback == true);
 869     QVERIFY(m_gotPauseCallback == true);
 870     QVERIFY(m_gotErrorCallback == false);
 871
 872 }
 873
 874
 875 void ut_MafwGstRendererWorker::resumeDelayedTestCase()
 876 {
 877
 878     m_worker->notify_play_handler = &playCallback;
 879     m_worker->notify_error_handler = &errorCallback;
 880     m_worker->notify_pause_handler = &pauseCallback;
 881     m_worker->blanking__control_handler = &blankingControlCallback;
 882     mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii());
 883
 884     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
 885     QVERIFY(m_gotPlayCallback == true);
 886     QVERIFY(m_gotPauseCallback == false);
 887
 888     mafw_gst_renderer_worker_pause(m_worker);
 889     waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback);
 890     /* pipeline goes to ready after 60 seconds */
 891     waitForEvent(READY_DELAY, NEVER_HAPPENING_EVENT);
 892
 893     m_gotPlayCallback = false;
 894     mafw_gst_renderer_worker_resume(m_worker);
 895     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
 896
 897     QVERIFY(m_gotPlayCallback == true);
 898     QVERIFY(m_gotPauseCallback == true);
 899     QVERIFY(m_gotErrorCallback == false);
 900
 901 }
 902
 903 void ut_MafwGstRendererWorker::getCurrentMetadataTestCase()
 904 {
 905
 906     GHashTable *metadata = 0;
 907
 908     m_worker->notify_play_handler = &playCallback;
 909     m_worker->notify_error_handler = &errorCallback;
 910     m_worker->notify_pause_handler = &pauseCallback;
 911     m_worker->blanking__control_handler = &blankingControlCallback;
 912     mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii());
 913
 914     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
 915     QVERIFY(m_gotPlayCallback == true);
 916     QVERIFY(m_gotPauseCallback == false);
 917
 918     mafw_gst_renderer_worker_pause(m_worker);
 919     waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback);
 920
 921     metadata = mafw_gst_renderer_worker_get_current_metadata(m_worker);
 922     QVERIFY(metadata);
 923     QVERIFY(g_hash_table_size(metadata));
 924
 925     mafw_gst_renderer_worker_stop(m_worker);
 926     metadata = mafw_gst_renderer_worker_get_current_metadata(m_worker);
 927     QVERIFY(!metadata);
 928
 929     QVERIFY(m_gotPlayCallback == true);
 930     QVERIFY(m_gotPauseCallback == true);
 931     QVERIFY(m_gotErrorCallback == false);
 932
 933 }
 934
 935 void ut_MafwGstRendererWorker::defaultConfigurationTestCase()
 936 {
 937     QVERIFY2(sizeof(configuration) == 64, "You've (or somebody else) most likely changed the configuration struct! Update the unittests also!");
 938
 939     configuration * current_worker_conf = mafw_gst_renderer_worker_create_default_configuration(m_worker);
 940
 941     QCOMPARE(current_worker_conf->asink, "pulsesink");
 942     QCOMPARE(current_worker_conf->vsink, "omapxvsink");
 943     QCOMPARE(current_worker_conf->buffer_time, 600000LL);
 944     QCOMPARE(current_worker_conf->latency_time, 100000LL);
 945     QCOMPARE(current_worker_conf->flags, 67);
 946
 947     QCOMPARE(current_worker_conf->mobile_surround_music.state, 0U);
 948     QCOMPARE(current_worker_conf->mobile_surround_music.color, 2);
 949     QCOMPARE(current_worker_conf->mobile_surround_music.room, 2);
 950     QCOMPARE(current_worker_conf->mobile_surround_video.state, 0U);
 951     QCOMPARE(current_worker_conf->mobile_surround_video.color, 2);
 952     QCOMPARE(current_worker_conf->mobile_surround_video.room, 2);
 953
 954     QCOMPARE(current_worker_conf->milliseconds_to_pause_frame, 700U);
 955     QCOMPARE(current_worker_conf->seconds_to_pause_to_ready, 3U);
 956     QCOMPARE(current_worker_conf->use_dhmmixer, 1);
 957
 958     //this well make valgrind happy. i.e. worker will handle memory cleanupping
 959     mafw_gst_renderer_worker_set_configuration(m_worker, current_worker_conf);
 960 }
 961
 962 void ut_MafwGstRendererWorker::configurabilityTestCase()
 963 {
 964     MafwGstRendererWorker *configWorker = mafw_gst_renderer_worker_new(this);
 965
 966     configuration *config = mafw_gst_renderer_worker_create_default_configuration(configWorker);
 967
 968     g_free(config->asink);
 969     config->asink = g_strdup("test-sink");
 970
 971     //audio sink
 972     QVERIFY(!globalGstFactoryRequests.contains("test-sink"));
 973     mafw_gst_renderer_worker_set_configuration(configWorker, config);
 974     mafw_gst_renderer_worker_stop(configWorker);
 975     QVERIFY(globalGstFactoryRequests.contains("test-sink"));
 976     globalGstFactoryRequests.clear();
 977
 978     mafw_gst_renderer_worker_exit(configWorker);
 979     g_free(configWorker);
 980
 981
 982     //video sink
 983     configWorker = mafw_gst_renderer_worker_new(this);
 984     config = mafw_gst_renderer_worker_create_default_configuration(configWorker);
 985     g_free(config->vsink);
 986     config->vsink = g_strdup("test-video-sink");
 987
 988     QVERIFY(!globalGstFactoryRequests.contains("test-video-sink"));
 989
 990     mafw_gst_renderer_worker_set_configuration(configWorker, config);
 991     //video-sink is not created unless xid has been set
 992     mafw_gst_renderer_worker_set_xid(configWorker, 0xffff);
 993
 994     mafw_gst_renderer_worker_stop(configWorker);
 995     QVERIFY(globalGstFactoryRequests.contains("test-video-sink"));
 996
 997     globalGstFactoryRequests.clear();
 998     mafw_gst_renderer_worker_exit(configWorker);
 999     g_free(configWorker);
1000
1001
1002     //NO dhmmixer
1003     configWorker = mafw_gst_renderer_worker_new(this);
1004     config = mafw_gst_renderer_worker_create_default_configuration(configWorker);
1005     config->use_dhmmixer = 0;
1006
1007     QVERIFY(!globalGstFactoryRequests.contains("nokiadhmmix"));
1008     mafw_gst_renderer_worker_set_configuration(configWorker, config);
1009     mafw_gst_renderer_worker_stop(configWorker);
1010     QVERIFY(!globalGstFactoryRequests.contains("nokiadhmmix"));
1011
1012     globalGstFactoryRequests.clear();
1013     mafw_gst_renderer_worker_exit(configWorker);
1014     g_free(configWorker);
1015
1016     //YES dhmmixer
1017     configWorker = mafw_gst_renderer_worker_new(this);
1018     config = mafw_gst_renderer_worker_create_default_configuration(configWorker);
1019     config->use_dhmmixer = 1;
1020
1021     QVERIFY(!globalGstFactoryRequests.contains("nokiadhmmix"));
1022     mafw_gst_renderer_worker_set_configuration(configWorker, config);
1023     mafw_gst_renderer_worker_stop(configWorker);
1024     QVERIFY(globalGstFactoryRequests.contains("nokiadhmmix"));
1025
1026     globalGstFactoryRequests.clear();
1027     mafw_gst_renderer_worker_exit(configWorker);
1028     g_free(configWorker);
1029 }
1030
1031 void ut_MafwGstRendererWorker::pauseFrameConfigurabilityTestCase()
1032 {
1033
1034     m_worker->notify_play_handler = &playCallback;
1035     m_worker->notify_pause_handler = &pauseCallback;
1036     m_worker->notify_metadata_handler = &metadataCallback;
1037     m_worker->notify_property_handler = &propertyCallback;
1038     m_worker->notify_error_handler = &errorCallback;
1039     m_worker->blanking__control_handler = &blankingControlCallback;
1040     m_worker->screenshot_handler = screenshotCallback;
1041
1042     //let's change timeout values
1043     configuration *config = mafw_gst_renderer_worker_create_default_configuration(m_worker);
1044     config->milliseconds_to_pause_frame = 3000;
1045     config->seconds_to_pause_to_ready = 6;
1046     mafw_gst_renderer_worker_set_configuration(m_worker, config);
1047
1048
1049     mafw_gst_renderer_worker_set_current_frame_on_pause(m_worker, TRUE);
1050     QVERIFY(mafw_gst_renderer_worker_get_current_frame_on_pause(m_worker) ==
1051             TRUE);
1052     QVERIFY(m_gotPropertyCallback == true);
1053     QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_CURRENT_FRAME_ON_PAUSE);
1054
1055     mafw_gst_renderer_worker_set_xid(m_worker, 0xffff);
1056     QVERIFY(mafw_gst_renderer_worker_get_xid(m_worker) == 0xffff);
1057     QVERIFY(m_gotPropertyCallback == true);
1058     QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_XID);
1059     m_gotPropertyCallback = false;
1060     m_receivedPropertyId = -1;
1061
1062     mafw_gst_renderer_worker_play(m_worker, VIDEO_URI.toString().toAscii());
1063
1064     /* post xwindow-id on bus since we are using fakesink instead of
1065      * xvimagesink */
1066     GstBus *bus;
1067     GstStructure *structure;
1068     GstMessage *message;
1069     structure = gst_structure_new("prepare-xwindow-id", "width",
1070                                   G_TYPE_INT, 64, "height", G_TYPE_INT, 32,
1071                                   NULL);
1072     message = gst_message_new_element(NULL, structure);
1073     bus = m_worker->bus;
1074     gst_bus_post(bus, message);
1075     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
1076
1077     mafw_gst_renderer_worker_pause(m_worker);
1078     QTest::qWait(2000);
1079
1080     //no pause frame yet, let's make sure
1081     QVERIFY(m_gotPlayCallback == true);
1082     QVERIFY(m_gotPauseCallback == true);
1083     QVERIFY(m_gotMetadataCallback == true);
1084     QVERIFY(m_gotErrorCallback == false);
1085     QVERIFY(!m_receivedMetadata.contains(WORKER_METADATA_KEY_PAUSED_THUMBNAIL_URI));
1086
1087     waitForEvent(WAIT_TIMEOUT, NEVER_HAPPENING_EVENT);
1088     QVERIFY(m_receivedMetadata.contains(WORKER_METADATA_KEY_PAUSED_THUMBNAIL_URI));
1089
1090     mafw_gst_renderer_worker_stop(m_worker);
1091     QTest::qWait(100);
1092     config = mafw_gst_renderer_worker_create_default_configuration(m_worker);
1093     mafw_gst_renderer_worker_set_configuration(m_worker, config);
1094
1095 }
1096
1097 void ut_MafwGstRendererWorker::setAndGetPropertiesTestCase()
1098 {
1099
1100     m_worker->notify_error_handler = &errorCallback;
1101     m_worker->notify_property_handler = &propertyCallback;
1102     m_worker->notify_play_handler = &playCallback;
1103     m_worker->notify_pause_handler = &pauseCallback;
1104     m_worker->blanking__control_handler = &blankingControlCallback;
1105
1106     m_gotPropertyCallback = false;
1107     m_receivedPropertyId = -1;
1108     mafw_gst_renderer_worker_set_xid(m_worker, 0xffff);
1109     QVERIFY(mafw_gst_renderer_worker_get_xid(m_worker) == 0xffff);
1110     QVERIFY(m_gotPropertyCallback == true);
1111     QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_XID);
1112     m_gotPropertyCallback = false;
1113     m_receivedPropertyId = -1;
1114
1115     mafw_gst_renderer_worker_set_force_aspect_ratio(m_worker, FALSE);
1116     QVERIFY(mafw_gst_renderer_worker_get_force_aspect_ratio(m_worker) == FALSE);
1117     QVERIFY(m_gotPropertyCallback == true);
1118     QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_FORCE_ASPECT_RATIO);
1119     m_gotPropertyCallback = false;
1120     m_receivedPropertyId = -1;
1121     mafw_gst_renderer_worker_set_force_aspect_ratio(m_worker, TRUE);
1122     QVERIFY(mafw_gst_renderer_worker_get_force_aspect_ratio(m_worker) == TRUE);
1123     QVERIFY(m_gotPropertyCallback == true);
1124     QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_FORCE_ASPECT_RATIO);
1125     m_gotPropertyCallback = false;
1126     m_receivedPropertyId = -1;
1127
1128     mafw_gst_renderer_worker_set_current_frame_on_pause(m_worker, TRUE);
1129     QVERIFY(mafw_gst_renderer_worker_get_current_frame_on_pause(m_worker) ==
1130             TRUE);
1131     QVERIFY(m_gotPropertyCallback == true);
1132     QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_CURRENT_FRAME_ON_PAUSE);
1133     m_gotPropertyCallback = false;
1134     m_receivedPropertyId = -1;
1135     mafw_gst_renderer_worker_set_current_frame_on_pause(m_worker, FALSE);
1136     QVERIFY(mafw_gst_renderer_worker_get_current_frame_on_pause(m_worker) ==
1137             FALSE);
1138     QVERIFY(m_gotPropertyCallback == true);
1139     QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_CURRENT_FRAME_ON_PAUSE);
1140     m_gotPropertyCallback = false;
1141     m_receivedPropertyId = -1;
1142
1143     mafw_gst_renderer_worker_set_autopaint(m_worker, TRUE);
1144     QVERIFY(mafw_gst_renderer_worker_get_autopaint(m_worker) == TRUE);
1145     QVERIFY(m_gotPropertyCallback == true);
1146     QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_AUTOPAINT);
1147     m_gotPropertyCallback = false;
1148     m_receivedPropertyId = -1;
1149     mafw_gst_renderer_worker_set_autopaint(m_worker, FALSE);
1150     QVERIFY(mafw_gst_renderer_worker_get_autopaint(m_worker) == FALSE);
1151     QVERIFY(m_gotPropertyCallback == true);
1152     QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_AUTOPAINT);
1153
1154     mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii());
1155     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
1156     QVERIFY(m_gotPlayCallback == true);
1157     QVERIFY(m_gotPauseCallback == false);
1158
1159     mafw_gst_renderer_worker_set_playback_speed(m_worker, 2);
1160     QVERIFY(mafw_gst_renderer_worker_get_playback_speed(m_worker) == 2);
1161     QVERIFY(m_gotPropertyCallback == true);
1162     QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_PLAYBACK_SPEED);
1163     m_gotPropertyCallback = false;
1164     m_receivedPropertyId = -1;
1165     mafw_gst_renderer_worker_set_playback_speed(m_worker, float(-1));
1166     QCOMPARE(mafw_gst_renderer_worker_get_playback_speed(m_worker), float(-1));
1167     m_gotPropertyCallback = false;
1168     m_receivedPropertyId = -1;
1169     mafw_gst_renderer_worker_set_playback_speed(m_worker, float(2.5));
1170     QCOMPARE(mafw_gst_renderer_worker_get_playback_speed(m_worker), float(2.5));
1171
1172     render_rectangle rect = {1,2,3,4};
1173     m_gotPropertyCallback = false;
1174     m_receivedPropertyId = -1;
1175
1176     mafw_gst_renderer_worker_set_render_rectangle(m_worker, &rect);
1177     QVERIFY(m_gotPropertyCallback);
1178     QVERIFY(m_receivedPropertyId != -1);
1179     const render_rectangle *storedRect = mafw_gst_renderer_worker_get_render_rectangle(m_worker);
1180     //the pointer value should not be used, copy must be made
1181     QVERIFY(&rect != storedRect );
1182     QCOMPARE(rect.x, storedRect->x);
1183     QCOMPARE(rect.y, storedRect->y);
1184     QCOMPARE(rect.width, storedRect->width);
1185     QCOMPARE(rect.height, storedRect->height);
1186
1187     m_gotPropertyCallback = false;
1188     m_receivedPropertyId = -1;
1189
1190     QVERIFY(m_gotErrorCallback == false);
1191 }
1192
1193 void ut_MafwGstRendererWorker::gettersTestCase()
1194 {
1195
1196     m_worker->notify_error_handler = &errorCallback;
1197
1198     QVERIFY(mafw_gst_renderer_worker_get_colorkey(m_worker) == -1);
1199     QVERIFY(mafw_gst_renderer_worker_get_seekable(m_worker) == TRUE);
1200     QVERIFY(m_gotErrorCallback == false);
1201
1202 }
1203
1204 void ut_MafwGstRendererWorker::mediaRouteTestCase()
1205 {
1206
1207     GSList *list = NULL;
1208
1209     m_worker->notify_play_handler = &playCallback;
1210     m_worker->notify_error_handler = &errorCallback;
1211     m_worker->notify_eos_handler = &eosCallback;
1212     m_worker->notify_error_handler = &errorCallback;
1213     m_worker->blanking__control_handler = &blankingControlCallback;
1214     mafw_gst_renderer_worker_set_xid(m_worker, 0xffff);
1215
1216     /* normal audio playback */
1217     mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii());
1218     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
1219     QVERIFY(m_gotPlayCallback == true);
1220     QVERIFY(m_gotErrorCallback == false);
1221
1222     list = g_slist_append(list, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_SPEAKERS));
1223     list = g_slist_append(list, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY));
1224     mafw_gst_renderer_worker_notify_media_destination(m_worker, list);
1225     g_slist_free(list);
1226     list = NULL;
1227     QVERIFY(g_slist_length(m_worker->destinations) == 2);
1228     QVERIFY(g_slist_find(m_worker->destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_SPEAKERS)));
1229     QVERIFY(g_slist_find(m_worker->destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY)));
1230
1231     waitForEvent(EOS_TIMEOUT, m_gotEosCallback);
1232
1233     QVERIFY(m_gotEosCallback == true);
1234     QVERIFY(m_gotErrorCallback == false);
1235
1236     /* normal video playback */
1237     m_gotPlayCallback = false;
1238     m_gotEosCallback = false;
1239     m_gotErrorCallback = false;
1240     QVERIFY(m_blankingProhibited == false);
1241     mafw_gst_renderer_worker_play(m_worker, VIDEO_URI.toString().toAscii());
1242     m_worker->media.has_visual_content = true; // normally gst sets this but not in unittest for some reason
1243     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
1244     QVERIFY(m_gotPlayCallback == true);
1245     QVERIFY(m_gotErrorCallback == false);
1246     QVERIFY(m_blankingProhibited == true);
1247
1248     list = g_slist_append(list, GINT_TO_POINTER(WORKER_OUTPUT_HEADPHONE_JACK));
1249     list = g_slist_append(list, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY));
1250     mafw_gst_renderer_worker_notify_media_destination(m_worker, list);
1251     g_slist_free(list);
1252     list = NULL;
1253     QVERIFY(g_slist_length(m_worker->destinations) == 2);
1254     QVERIFY(g_slist_find(m_worker->destinations, GINT_TO_POINTER(WORKER_OUTPUT_HEADPHONE_JACK)));
1255     QVERIFY(g_slist_find(m_worker->destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY)));
1256
1257     waitForEvent(WAIT_TIMEOUT, m_gotEosCallback);
1258     QVERIFY(m_gotEosCallback == true);
1259     QVERIFY(m_gotErrorCallback == false);
1260
1261 }
1262
1263 void ut_MafwGstRendererWorker::setReadyTimeoutTestCase()
1264 {
1265
1266     m_worker->notify_play_handler = &playCallback;
1267     m_worker->notify_error_handler = &errorCallback;
1268     m_worker->notify_pause_handler = &pauseCallback;
1269     m_worker->notify_eos_handler = &eosCallback;
1270     m_worker->blanking__control_handler = &blankingControlCallback;
1271
1272     /* do some basic set calls first */
1273     mafw_gst_renderer_worker_set_ready_timeout(m_worker, 0);
1274     QVERIFY(m_worker->config->seconds_to_pause_to_ready == 0);
1275     mafw_gst_renderer_worker_set_ready_timeout(m_worker, 60);
1276     QVERIFY(m_worker->config->seconds_to_pause_to_ready == 60);
1277
1278     /* set timeout to 0, pause in the middle of the playback */
1279     mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii());
1280     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
1281     QVERIFY(m_gotPlayCallback == true);
1282     QVERIFY(m_gotErrorCallback == false);
1283
1284     m_gotPlayCallback = false;
1285     m_gotPauseCallback = false;
1286     mafw_gst_renderer_worker_set_ready_timeout(m_worker, 0);
1287     QVERIFY(m_worker->config->seconds_to_pause_to_ready == 0);
1288     QTest::qWait(1500);
1289     QVERIFY(m_worker->state == GST_STATE_PLAYING);
1290     mafw_gst_renderer_worker_pause(m_worker);
1291     waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback);
1292     QVERIFY(m_worker->state == GST_STATE_PAUSED);
1293     QTest::qWait(500);
1294     QVERIFY(m_worker->state == GST_STATE_READY);
1295
1296     m_gotPlayCallback = false;
1297     m_gotPauseCallback = false;
1298
1299     mafw_gst_renderer_worker_resume(m_worker);
1300     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
1301     QVERIFY(m_gotPlayCallback == true);
1302     QVERIFY(m_worker->state == GST_STATE_PLAYING);
1303     waitForEvent(WAIT_TIMEOUT, m_gotEosCallback);
1304     QVERIFY(m_gotEosCallback == true);
1305
1306     /* set timeout to 3, pause in the middle of the playback */
1307     mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii());
1308     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
1309     QVERIFY(m_gotPlayCallback == true);
1310     QVERIFY(m_gotErrorCallback == false);
1311
1312     m_gotPlayCallback = false;
1313     m_gotPauseCallback = false;
1314     mafw_gst_renderer_worker_set_ready_timeout(m_worker, 3);
1315     QVERIFY(m_worker->config->seconds_to_pause_to_ready == 3);
1316     QTest::qWait(1500);
1317     QVERIFY(m_worker->state == GST_STATE_PLAYING);
1318     mafw_gst_renderer_worker_pause(m_worker);
1319     waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback);
1320     QVERIFY(m_worker->state == GST_STATE_PAUSED);
1321
1322     m_gotPlayCallback = false;
1323     m_gotPauseCallback = false;
1324     QTest::qWait(4000);
1325     QVERIFY(m_worker->state == GST_STATE_READY);
1326
1327     mafw_gst_renderer_worker_resume(m_worker);
1328     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
1329     QVERIFY(m_gotPlayCallback == true);
1330     QVERIFY(m_worker->state == GST_STATE_PLAYING);
1331     waitForEvent(WAIT_TIMEOUT, m_gotEosCallback);
1332     QVERIFY(m_gotEosCallback == true);
1333
1334     /* set timeout to 0, pause in the middle of the playback after setting the
1335      * timeout value --> we should go to ready immediately */
1336     mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii());
1337     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
1338     QVERIFY(m_gotPlayCallback == true);
1339     QVERIFY(m_gotErrorCallback == false);
1340     mafw_gst_renderer_worker_set_ready_timeout(m_worker, 60);
1341     QVERIFY(m_worker->config->seconds_to_pause_to_ready == 60);
1342
1343     m_gotPlayCallback = false;
1344     m_gotPauseCallback = false;
1345     QTest::qWait(1500);
1346     QVERIFY(m_worker->state == GST_STATE_PLAYING);
1347     mafw_gst_renderer_worker_pause(m_worker);
1348     waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback);
1349     QVERIFY(m_worker->state == GST_STATE_PAUSED);
1350     mafw_gst_renderer_worker_set_ready_timeout(m_worker, 0);
1351     QVERIFY(m_worker->config->seconds_to_pause_to_ready == 0);
1352     QTest::qWait(500);
1353     QVERIFY(m_worker->state == GST_STATE_READY);
1354
1355     m_gotPlayCallback = false;
1356     m_gotPauseCallback = false;
1357
1358     mafw_gst_renderer_worker_resume(m_worker);
1359     waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback);
1360     QVERIFY(m_gotPlayCallback == true);
1361     QVERIFY(m_worker->state == GST_STATE_PLAYING);
1362     waitForEvent(WAIT_TIMEOUT, m_gotEosCallback);
1363     QVERIFY(m_gotEosCallback == true);
1364
1365 }
1366
1367 void ut_MafwGstRendererWorker::initTestCase()
1368 {
1369     gst_init(0,0);
1370 }
1371
1372 void ut_MafwGstRendererWorker::init()
1373 {
1374
1375     qDebug() << __PRETTY_FUNCTION__;
1376
1377     m_worker = 0;
1378     m_receivedErrorCode = -1;
1379     m_receivedPropertyId = -1;
1380     m_receivedBufferStatus = -1.0;
1381     m_receivedMetadata.clear();
1382     m_gotPlayCallback = false;
1383     m_gotEosCallback = false;
1384     m_gotErrorCallback = false;
1385     m_gotPauseCallback = false;
1386     m_gotSeekCallback = false;
1387     m_gotMetadataCallback = false;
1388     m_gotPropertyCallback = false;
1389     m_gotBufferStatusCallback = false;
1390     m_blankingProhibited = false;
1391
1392     global_context_duration = 0;
1393
1394     bool ok;
1395     QByteArray tmo = qgetenv("WAIT_TIMEOUT");
1396     int val = tmo.toInt(&ok, 10);
1397     if (ok)
1398     {
1399         WAIT_TIMEOUT = val;
1400         qDebug() << "WAIT_TIMEOUT is set to" << WAIT_TIMEOUT;
1401     }
1402     else
1403     {
1404         qDebug() << "Using default WAIT_TIMEOUT" << WAIT_TIMEOUT;
1405     }
1406
1407     const QString scheme("file");
1408     AUDIO_URI.setScheme(scheme);
1409     VIDEO_URI.setScheme(scheme);
1410     IMAGE_URI.setScheme(scheme);
1411
1412     m_worker = mafw_gst_renderer_worker_new(this);
1413
1414     QVERIFY(m_worker != 0);
1415
1416     globalGstFactoryRequests.clear();
1417 }
1418
1419 void ut_MafwGstRendererWorker::cleanup()
1420 {
1421     QVERIFY(m_worker != 0);
1422
1423     mafw_gst_renderer_worker_exit(m_worker);
1424     g_free(m_worker);
1425
1426     QVERIFY(m_blankingProhibited == false);
1427
1428     m_gotPlayCallback = false;
1429     m_gotErrorCallback = false;
1430 }
1431
1432 QTEST_MAIN(ut_MafwGstRendererWorker)