X-Git-Url: http://vcs.maemo.org/git/?a=blobdiff_plain;f=qmafw-gst-subtitles-renderer%2Funittests%2Fut_MafwGstRendererWorker%2Fut_MafwGstRendererWorker.cpp;fp=qmafw-gst-subtitles-renderer%2Funittests%2Fut_MafwGstRendererWorker%2Fut_MafwGstRendererWorker.cpp;h=b881ef73c3a18ba8ca6700c998ba638611a1be6f;hb=226d35244df85a27c332d3a3ded1b25b3c7f4951;hp=0000000000000000000000000000000000000000;hpb=57ba96e291a055f69dbfd4ae9f1ae2390e36986e;p=mafwsubrenderer diff --git a/qmafw-gst-subtitles-renderer/unittests/ut_MafwGstRendererWorker/ut_MafwGstRendererWorker.cpp b/qmafw-gst-subtitles-renderer/unittests/ut_MafwGstRendererWorker/ut_MafwGstRendererWorker.cpp new file mode 100644 index 0000000..b881ef7 --- /dev/null +++ b/qmafw-gst-subtitles-renderer/unittests/ut_MafwGstRendererWorker/ut_MafwGstRendererWorker.cpp @@ -0,0 +1,1432 @@ +/* + * This file is part of QMAFW + * + * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights + * reserved. + * + * Contact: Visa Smolander + * + * This software, including documentation, is protected by copyright controlled + * by Nokia Corporation. All rights are reserved. Copying, including + * reproducing, storing, adapting or translating, any or all of this material + * requires the prior written consent of Nokia Corporation. This material also + * contains confidential information which may not be disclosed to others + * without the prior written consent of Nokia. + * + */ + +#include +#include +#include + +#include +#include +#include +#include + +#include "ut_MafwGstRendererWorker.h" +#include "mafw-gst-renderer-worker.h" +#include "mafw-gst-renderer-utils.h" + +static QUrl AUDIO_URI(QDir::currentPath() + QDir::separator() + + QString("media") + QDir::separator() + + QString("test.wav")); + +static QUrl VIDEO_URI(QDir::currentPath() + QDir::separator() + + QString("media") + QDir::separator() + + QString("test.avi")); + +static QUrl IMAGE_URI(QDir::currentPath() + QDir::separator() + + QString("media") + QDir::separator() + + QString("testframe.png")); + +static int WAIT_TIMEOUT = 3500; +static int EOS_TIMEOUT = 7000; +static int READY_DELAY = 65000; + +static bool NEVER_HAPPENING_EVENT = false; + +static int global_context_duration = 0; + +static QStringList globalGstFactoryRequests; +static GstElement *globalGstPipeline; + + +const gchar* g_getenv(const gchar *variable) +{ + Q_UNUSED(variable); + return NULL; +} + +gboolean convert_utf8(const gchar *src, gchar **dst) +{ + *dst = g_strdup(src); + return TRUE; +} + +gboolean uri_is_playlist(const gchar *uri) +{ + Q_UNUSED(uri); + return FALSE; +} + +gboolean uri_is_stream(const gchar *uri) +{ + Q_UNUSED(uri); + return FALSE; +} + +gint remap_gst_error_code(const GError *error) +{ + return error->code; +} + +void context_provider_set_map(const char* key, void* map, int free_map) +{ + Q_UNUSED(key); + Q_UNUSED(map); + Q_UNUSED(free_map); +} + +void *context_provider_map_new(void) +{ + + return NULL; +} + +void context_provider_map_free(void* map) +{ + Q_UNUSED(map); +} + +void context_provider_map_set_integer(void* map, const char* key, int value) +{ + Q_UNUSED(map); + + if( strcmp( key, "duration" )==0 ) + { + global_context_duration = value; + } +} + +void context_provider_map_set_double(void* map, const char* key, double value) +{ + Q_UNUSED(map); + Q_UNUSED(key); + Q_UNUSED(value); +} + +void context_provider_map_set_boolean(void* map, const char* key, int value) +{ + Q_UNUSED(map); + Q_UNUSED(key); + Q_UNUSED(value); +} + +void context_provider_map_set_string(void* map, const char* key, const char* value) +{ + Q_UNUSED(map); + Q_UNUSED(key); + Q_UNUSED(value); +} + +void context_provider_map_set_map(void* map, const char* key, void* value) +{ + Q_UNUSED(map); + Q_UNUSED(key); + Q_UNUSED(value); +} + +void context_provider_set_null(const char* key) +{ + Q_UNUSED(key); +} + +gboolean context_provider_init(DBusBusType bus_type, const char* bus_name) +{ + + Q_UNUSED(bus_type); + Q_UNUSED(bus_name); + + return TRUE; + +} + +void context_provider_stop(void) +{ +} + +void context_provider_install_key( + const char* key, + gboolean clear_values_on_subscribe, + ContextProviderSubscriptionChangedCallback subscription_changed_cb, + void* subscription_changed_cb_target) +{ + Q_UNUSED(key); + Q_UNUSED(clear_values_on_subscribe); + Q_UNUSED(subscription_changed_cb); + Q_UNUSED(subscription_changed_cb_target); +} + +GstElement *gst_element_factory_make(const gchar *factoryname, const gchar *name) +{ + GstElementFactory *factory; + GstElement *element; + const gchar *use_factoryname; + + g_return_val_if_fail(factoryname != NULL, NULL); + + globalGstFactoryRequests.append(factoryname); + + /* For testing, use playbin instead of playbin2 */ + if (g_str_equal(factoryname, "playbin2")) + { + use_factoryname = "playbin"; + } + else + { + use_factoryname = factoryname; + } + + GST_LOG("gstelementfactory: make \"%s\" \"%s\"", + use_factoryname, GST_STR_NULL (name)); + + factory = gst_element_factory_find(use_factoryname); + if (factory == NULL) + { + /* No factory */ + GST_INFO("no such element factory \"%s\"!", use_factoryname); + return NULL; + } + + GST_LOG_OBJECT(factory, "found factory %p", factory); + if (g_str_equal(use_factoryname, "pulsesink")) + { + element = gst_element_factory_make("fakesink", "pulsesink"); + g_object_set(G_OBJECT(element), "sync", TRUE, NULL); + } + else if (g_str_equal(use_factoryname, "alsasink")) + { + element = gst_element_factory_make("fakesink", "alsasink"); + g_object_set(G_OBJECT(element), "sync", TRUE, NULL); + } + else if (g_str_equal(use_factoryname, "xvimagesink") + || g_str_equal(use_factoryname, "omapxvsink")) + { + element = gst_element_factory_make("fakesink", "xvimagesink"); + g_object_set(G_OBJECT(element), "sync", TRUE, NULL); + } + else + { + element = gst_element_factory_create(factory, name); + if( !g_strcmp0(use_factoryname, "playbin") ) + { + globalGstPipeline = element; + } + } + gst_object_unref(factory); + + if (element == NULL) + { + /* Create failed */ + GST_INFO_OBJECT(factory, "couldn't create instance!"); + return NULL; + } + + GST_LOG("gstelementfactory: make \"%s\" \"%s\"",use_factoryname, + GST_STR_NULL(name)); + + /* Playbin will use fake renderer */ + if (g_str_equal(use_factoryname, "playbin")) + { + GstElement *audiorenderer = gst_element_factory_make("fakesink", + "audiorenderer"); + g_object_set(G_OBJECT(audiorenderer), "sync", TRUE, NULL); + g_object_set(G_OBJECT(element), "audio-sink", audiorenderer, NULL); + g_object_set(G_OBJECT(element), "video-sink", audiorenderer, NULL); + } + + return element; + +} +/* END OF STUB DEFINITIONS */ + +void ut_MafwGstRendererWorker::playCallback(MafwGstRendererWorker *worker, + gpointer owner) +{ + + Q_UNUSED(worker); + Q_UNUSED(owner); + qDebug() << __PRETTY_FUNCTION__; + + ut_MafwGstRendererWorker* self = + static_cast(owner); + self->m_gotPlayCallback = true; + +} + +void ut_MafwGstRendererWorker::pauseCallback(MafwGstRendererWorker *worker, + gpointer owner) +{ + Q_UNUSED(worker); + + qDebug() << __PRETTY_FUNCTION__; + + ut_MafwGstRendererWorker* self = + static_cast(owner); + self->m_gotPauseCallback = true; +} + +void ut_MafwGstRendererWorker::bufferingCallback(MafwGstRendererWorker *worker, + gpointer owner, + gdouble percent) +{ + Q_UNUSED(worker); + + qDebug() << __PRETTY_FUNCTION__; + + ut_MafwGstRendererWorker* self = + static_cast(owner); + self->m_receivedBufferStatus = percent; + self->m_gotBufferStatusCallback = true; +} + +void ut_MafwGstRendererWorker::eosCallback(MafwGstRendererWorker *worker, + gpointer owner) +{ + + Q_UNUSED(worker); + + qDebug() << __PRETTY_FUNCTION__; + + ut_MafwGstRendererWorker* self = + static_cast(owner); + self->m_gotEosCallback = true; + +} + +void ut_MafwGstRendererWorker::seekCallback(MafwGstRendererWorker *worker, + gpointer owner) +{ + + Q_UNUSED(worker); + + qDebug() << __PRETTY_FUNCTION__; + + ut_MafwGstRendererWorker* self = + static_cast(owner); + self->m_gotSeekCallback = true; + +} + +void ut_MafwGstRendererWorker::errorCallback(MafwGstRendererWorker *worker, + gpointer owner, + const GError *error) +{ + + Q_UNUSED(worker); + + ut_MafwGstRendererWorker* self = + static_cast(owner); + self->m_receivedErrorCode = error->code; + + if (error) + { + qCritical() << "error code: " << error->code << " message: " << + error->message; + } + self->m_gotErrorCallback = true; + +} + +void ut_MafwGstRendererWorker::propertyCallback(MafwGstRendererWorker *worker, + gpointer owner, + gint id, + GValue *value) +{ + + Q_UNUSED(worker); + Q_UNUSED(value); + + ut_MafwGstRendererWorker* self = + static_cast(owner); + self->m_receivedPropertyId = id; + self->m_gotPropertyCallback = true; + +} + +void ut_MafwGstRendererWorker::metadataCallback(MafwGstRendererWorker *worker, + gpointer owner, + gint key, + GType type, + gpointer value) +{ + + Q_UNUSED(worker); + Q_UNUSED(type); + Q_UNUSED(value); + + ut_MafwGstRendererWorker* self = + static_cast(owner); + self->m_receivedMetadata.append(key); + self->m_gotMetadataCallback = true; + +} + +void ut_MafwGstRendererWorker::blankingControlCallback(MafwGstRendererWorker *worker, + gpointer owner, gboolean prohibit) +{ + Q_UNUSED(worker); + + ut_MafwGstRendererWorker* self = + static_cast(owner); + self->m_blankingProhibited = prohibit; +} + +void ut_MafwGstRendererWorker::screenshotCallback(MafwGstRendererWorker *worker, + gpointer owner, GstBuffer *buffer, + const char *filename, gboolean cancel) +{ + Q_UNUSED(worker); + Q_UNUSED(buffer); + Q_UNUSED(filename); + if(!cancel) + { + ut_MafwGstRendererWorker* self = + static_cast(owner); + self->m_receivedMetadata.append(WORKER_METADATA_KEY_PAUSED_THUMBNAIL_URI); + self->m_gotMetadataCallback = true; + } +} + +void ut_MafwGstRendererWorker::basicPlaybackTestCase() +{ + + m_worker->notify_play_handler = &playCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii()); + + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotErrorCallback == false); + QCOMPARE( global_context_duration, 3 ); // 2.5 seconds is duration of test.wav + QVERIFY(m_blankingProhibited == false); + + //video-sink should not be created unless XID has been set + QVERIFY(!m_worker->vsink); +} + +void ut_MafwGstRendererWorker::basicVideoPlaybackTestCase() +{ + + m_worker->notify_play_handler = &playCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + + QVERIFY(!m_worker->vsink); + mafw_gst_renderer_worker_set_xid(m_worker, 0xffff); + QVERIFY(m_worker->vsink); + + mafw_gst_renderer_worker_play(m_worker, VIDEO_URI.toString().toAscii()); + m_worker->media.has_visual_content = true; // normally gst sets this but not in unittest for some reason + + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotErrorCallback == false); + QVERIFY(m_blankingProhibited == true); +} + +void ut_MafwGstRendererWorker::pauseFrameTestCase() +{ + + m_worker->notify_play_handler = &playCallback; + m_worker->notify_pause_handler = &pauseCallback; + m_worker->notify_metadata_handler = &metadataCallback; + m_worker->notify_property_handler = &propertyCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + m_worker->screenshot_handler = screenshotCallback; + + mafw_gst_renderer_worker_set_current_frame_on_pause(m_worker, TRUE); + QVERIFY(mafw_gst_renderer_worker_get_current_frame_on_pause(m_worker) == + TRUE); + QVERIFY(m_gotPropertyCallback == true); + QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_CURRENT_FRAME_ON_PAUSE); + + mafw_gst_renderer_worker_set_xid(m_worker, 0xffff); + QVERIFY(mafw_gst_renderer_worker_get_xid(m_worker) == 0xffff); + QVERIFY(m_gotPropertyCallback == true); + QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_XID); + m_gotPropertyCallback = false; + m_receivedPropertyId = -1; + + mafw_gst_renderer_worker_play(m_worker, VIDEO_URI.toString().toAscii()); + + /* post xwindow-id on bus since we are using fakesink instead of + * xvimagesink */ + GstBus *bus; + GstStructure *structure; + GstMessage *message; + structure = gst_structure_new("prepare-xwindow-id", "width", + G_TYPE_INT, 64, "height", G_TYPE_INT, 32, + NULL); + message = gst_message_new_element(NULL, structure); + bus = m_worker->bus; + gst_bus_post(bus, message); + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + + mafw_gst_renderer_worker_pause(m_worker); + waitForEvent(WAIT_TIMEOUT, NEVER_HAPPENING_EVENT); + + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotPauseCallback == true); + QVERIFY(m_gotMetadataCallback == true); + QVERIFY(m_gotErrorCallback == false); + QVERIFY(m_receivedMetadata.contains(WORKER_METADATA_KEY_PAUSED_THUMBNAIL_URI)); + +} + +void ut_MafwGstRendererWorker::pauseFrameCancelTestCase() +{ + m_worker->notify_play_handler = &playCallback; + m_worker->notify_pause_handler = &pauseCallback; + m_worker->notify_metadata_handler = &metadataCallback; + m_worker->notify_property_handler = &propertyCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + m_worker->screenshot_handler = screenshotCallback; + + mafw_gst_renderer_worker_set_current_frame_on_pause(m_worker, TRUE); + QVERIFY(mafw_gst_renderer_worker_get_current_frame_on_pause(m_worker) == + TRUE); + QVERIFY(m_gotPropertyCallback == true); + QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_CURRENT_FRAME_ON_PAUSE); + + mafw_gst_renderer_worker_set_xid(m_worker, 0xffff); + QVERIFY(mafw_gst_renderer_worker_get_xid(m_worker) == 0xffff); + QVERIFY(m_gotPropertyCallback == true); + QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_XID); + m_gotPropertyCallback = false; + m_receivedPropertyId = -1; + + mafw_gst_renderer_worker_play(m_worker, VIDEO_URI.toString().toAscii()); + + /* post xwindow-id on bus since we are using fakesink instead of + * xvimagesink */ + GstBus *bus; + GstStructure *structure; + GstMessage *message; + structure = gst_structure_new("prepare-xwindow-id", "width", + G_TYPE_INT, 64, "height", G_TYPE_INT, 32, + NULL); + message = gst_message_new_element(NULL, structure); + bus = m_worker->bus; + gst_bus_post(bus, message); + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + + mafw_gst_renderer_worker_pause(m_worker); + waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback); + mafw_gst_renderer_worker_resume(m_worker); + QTest::qWait(10); + + + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotPauseCallback == true); + QVERIFY(m_gotMetadataCallback == true); + QVERIFY(m_gotErrorCallback == false); + QVERIFY(!m_receivedMetadata.contains(WORKER_METADATA_KEY_PAUSED_THUMBNAIL_URI)); + + +} + +void ut_MafwGstRendererWorker::redirectMessageTestCase() +{ + m_worker->notify_play_handler = &playCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + + /* We just give random uri to renderer, because we ignore the error */ + /* We don't have to test with real RTSP stream, we just use local content */ + char *control = qstrdup(VIDEO_URI.toString().toAscii()); + + GstStructure *structure; + GstMessage *message; + structure = gst_structure_new("redirect", "new-location", + G_TYPE_STRING, control, NULL); + + // reset and construct the pipeline + mafw_gst_renderer_worker_stop(m_worker); + + // when worker receives "redirect" message, it should start playing the uri contained in the message. + message = gst_message_new_element(GST_OBJECT_CAST(m_worker->pipeline), structure); + gst_element_post_message(m_worker->pipeline, message); + + + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + + QVERIFY(m_gotPlayCallback == true); + QVERIFY(strcmp(control, m_worker->media.location) == 0); + QVERIFY(m_gotErrorCallback == false); + + delete[] control; +} + +void ut_MafwGstRendererWorker::slotTimeOut() +{ + qDebug() << "TIMEOUT!"; +} + +void ut_MafwGstRendererWorker::waitForEvent(gint ms, bool &hasEventOccurred) + +{ + qDebug() << __PRETTY_FUNCTION__; + + if (hasEventOccurred) + { + return; + } + + QTimer timer(this); + QObject::connect(&timer, SIGNAL(timeout()), this, SLOT(slotTimeOut())); + timer.setSingleShot(true); + timer.start(ms); + + while (!hasEventOccurred && timer.isActive()) + { + g_main_context_iteration(NULL, TRUE); + } +} + +void ut_MafwGstRendererWorker::bufferingTestCase() +{ + + m_worker->notify_play_handler = &playCallback; + m_worker->notify_buffer_status_handler = &bufferingCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + + mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii()); + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + + /* post the buffering msg on bus */ + GstBus *bus = 0; + GstMessage *message = 0; + + message = gst_message_new_buffering(NULL, 50); + bus = m_worker->bus; + gst_bus_post(bus, message); + + waitForEvent(WAIT_TIMEOUT, m_gotBufferStatusCallback); + + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_receivedBufferStatus == 50); + QVERIFY(m_gotErrorCallback == false); + +} + +void ut_MafwGstRendererWorker::rendererArtTestCase() +{ + + m_worker->notify_play_handler = &playCallback; + m_worker->notify_pause_handler = &pauseCallback; + m_worker->notify_metadata_handler = &metadataCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + + mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii()); + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + mafw_gst_renderer_worker_pause(m_worker); + waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback); + + /* post the renderer art tag on bus */ + gsize image_length = 0; + gchar *image = 0; + GstCaps *caps = 0; + GstBuffer *buffer = 0; + GstMessage *message = 0; + GstTagList *list = 0; + + QVERIFY(g_file_get_contents(IMAGE_URI.toLocalFile().toAscii(), + &image, + &image_length, + NULL)); + buffer = gst_buffer_new(); + gst_buffer_set_data(buffer, (guint8*)image, image_length); + caps = gst_caps_new_simple("image/png", "image-type", + GST_TYPE_TAG_IMAGE_TYPE, + GST_TAG_IMAGE_TYPE_FRONT_COVER, NULL); + gst_buffer_set_caps(buffer, caps); + + list = gst_tag_list_new(); + gst_tag_list_add(list, GST_TAG_MERGE_APPEND, GST_TAG_IMAGE, buffer, NULL); + + message = gst_message_new_tag(NULL, list); + gst_bus_post(m_worker->bus, message); + mafw_gst_renderer_worker_resume(m_worker); + + waitForEvent(WAIT_TIMEOUT, NEVER_HAPPENING_EVENT); + + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotPauseCallback == true); + QVERIFY(m_gotMetadataCallback == true); + QVERIFY(m_gotErrorCallback == false); + QVERIFY(m_receivedMetadata.contains(WORKER_METADATA_KEY_RENDERER_ART_URI)); + + gst_buffer_unref(buffer); + gst_caps_unref(caps); + g_free(image); + +} + +void ut_MafwGstRendererWorker::eosTestCase() +{ + + m_worker->notify_play_handler = &playCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->notify_eos_handler = &eosCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii()); + + waitForEvent(EOS_TIMEOUT, m_gotEosCallback); + + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotEosCallback == true); + QVERIFY(m_gotErrorCallback == false); + +} + +void ut_MafwGstRendererWorker::seekTestCase() +{ + + GError *error = 0; + + m_worker->notify_play_handler = &playCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->notify_seek_handler = &seekCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii()); + + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotErrorCallback == false); + + mafw_gst_renderer_worker_set_position(m_worker, + GST_SEEK_TYPE_SET, + 1, + &error); + + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotSeekCallback == true); + QVERIFY(m_gotErrorCallback == false); + QVERIFY(error == 0); + QVERIFY(mafw_gst_renderer_worker_get_position(m_worker) == 1); + +} + +void ut_MafwGstRendererWorker::invalidUriTestCase() +{ + + m_worker->notify_play_handler = &playCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + mafw_gst_renderer_worker_play(m_worker, "vjmksbhdfghrejggv"); + + waitForEvent(WAIT_TIMEOUT, m_gotErrorCallback); + + QVERIFY(m_gotPlayCallback == false); + QVERIFY(m_gotErrorCallback == true); + /* FIXME: new code for Gst errors? */ + /*QVERIFY(m_receivedErrorCode == WORKER_ERROR_UNABLE_TO_PERFORM);*/ + +} + +void ut_MafwGstRendererWorker::playAndStopTestCase() +{ + + m_worker->notify_play_handler = &playCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii()); + + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + QVERIFY(m_gotPlayCallback == true); + + mafw_gst_renderer_worker_stop(m_worker); + + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotErrorCallback == false); + +} + +void ut_MafwGstRendererWorker::playAndPauseTestCase() +{ + + m_worker->notify_play_handler = &playCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->notify_pause_handler = &pauseCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + mafw_gst_renderer_worker_set_xid(m_worker, 0xffff); + + mafw_gst_renderer_worker_play(m_worker, VIDEO_URI.toString().toAscii()); + m_worker->media.has_visual_content = true; // normally gst sets this but not in unittest for some reason + + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotPauseCallback == false); + QVERIFY(m_blankingProhibited == true); + + mafw_gst_renderer_worker_pause(m_worker); + waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback); + + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotPauseCallback == true); + QVERIFY(m_gotErrorCallback == false); + QVERIFY(m_blankingProhibited == false); +} + +void ut_MafwGstRendererWorker::pauseQuicklyAfterPlayTestCase() +{ + m_worker->notify_play_handler = &playCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->notify_pause_handler = &pauseCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + mafw_gst_renderer_worker_set_xid(m_worker, 0xffff); + + mafw_gst_renderer_worker_play(m_worker, VIDEO_URI.toString().toAscii()); + m_worker->media.has_visual_content = true; // normally gst sets this but not in unittest for some reason + mafw_gst_renderer_worker_pause(m_worker); + + waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback); + QVERIFY(m_gotPlayCallback == false); + QVERIFY(m_gotPauseCallback == true); + QVERIFY(m_blankingProhibited == false); + + m_gotPlayCallback = false; + m_gotPauseCallback = false; + + mafw_gst_renderer_worker_resume(m_worker); + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + waitForEvent(WAIT_TIMEOUT, m_blankingProhibited); + QCOMPARE(m_gotPlayCallback, true); + QCOMPARE(m_blankingProhibited, true); +} + +void ut_MafwGstRendererWorker::pauseAtTestCase() +{ + m_worker->notify_play_handler = &playCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->notify_pause_handler = &pauseCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + mafw_gst_renderer_worker_set_xid(m_worker, 0xffff); + + mafw_gst_renderer_worker_play(m_worker, VIDEO_URI.toString().toAscii()); + m_worker->media.has_visual_content = true; // normally gst sets this but not in unittest for some reason + //the video is only two seconds long + mafw_gst_renderer_worker_pause_at(m_worker, 1); + + waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback); + QVERIFY(m_gotPlayCallback == false); + QVERIFY(m_gotPauseCallback == true); + QVERIFY(m_blankingProhibited == false); + + QVERIFY(mafw_gst_renderer_worker_get_position(m_worker) == 1); + + m_gotPlayCallback = false; + m_gotPauseCallback = false; + + mafw_gst_renderer_worker_resume(m_worker); + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + waitForEvent(WAIT_TIMEOUT, m_blankingProhibited); + QCOMPARE(m_gotPlayCallback, true); + QCOMPARE(m_blankingProhibited, true); +} + +void ut_MafwGstRendererWorker::playAndPauseAndResumeTestCase() +{ + + m_worker->notify_play_handler = &playCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->notify_pause_handler = &pauseCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii()); + + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotPauseCallback == false); + + mafw_gst_renderer_worker_pause(m_worker); + waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback); + + m_gotPlayCallback = false; + mafw_gst_renderer_worker_resume(m_worker); + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotPauseCallback == true); + QVERIFY(m_gotErrorCallback == false); + +} + + +void ut_MafwGstRendererWorker::resumeDelayedTestCase() +{ + + m_worker->notify_play_handler = &playCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->notify_pause_handler = &pauseCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii()); + + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotPauseCallback == false); + + mafw_gst_renderer_worker_pause(m_worker); + waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback); + /* pipeline goes to ready after 60 seconds */ + waitForEvent(READY_DELAY, NEVER_HAPPENING_EVENT); + + m_gotPlayCallback = false; + mafw_gst_renderer_worker_resume(m_worker); + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotPauseCallback == true); + QVERIFY(m_gotErrorCallback == false); + +} + +void ut_MafwGstRendererWorker::getCurrentMetadataTestCase() +{ + + GHashTable *metadata = 0; + + m_worker->notify_play_handler = &playCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->notify_pause_handler = &pauseCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii()); + + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotPauseCallback == false); + + mafw_gst_renderer_worker_pause(m_worker); + waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback); + + metadata = mafw_gst_renderer_worker_get_current_metadata(m_worker); + QVERIFY(metadata); + QVERIFY(g_hash_table_size(metadata)); + + mafw_gst_renderer_worker_stop(m_worker); + metadata = mafw_gst_renderer_worker_get_current_metadata(m_worker); + QVERIFY(!metadata); + + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotPauseCallback == true); + QVERIFY(m_gotErrorCallback == false); + +} + +void ut_MafwGstRendererWorker::defaultConfigurationTestCase() +{ + QVERIFY2(sizeof(configuration) == 64, "You've (or somebody else) most likely changed the configuration struct! Update the unittests also!"); + + configuration * current_worker_conf = mafw_gst_renderer_worker_create_default_configuration(m_worker); + + QCOMPARE(current_worker_conf->asink, "pulsesink"); + QCOMPARE(current_worker_conf->vsink, "omapxvsink"); + QCOMPARE(current_worker_conf->buffer_time, 600000LL); + QCOMPARE(current_worker_conf->latency_time, 100000LL); + QCOMPARE(current_worker_conf->flags, 67); + + QCOMPARE(current_worker_conf->mobile_surround_music.state, 0U); + QCOMPARE(current_worker_conf->mobile_surround_music.color, 2); + QCOMPARE(current_worker_conf->mobile_surround_music.room, 2); + QCOMPARE(current_worker_conf->mobile_surround_video.state, 0U); + QCOMPARE(current_worker_conf->mobile_surround_video.color, 2); + QCOMPARE(current_worker_conf->mobile_surround_video.room, 2); + + QCOMPARE(current_worker_conf->milliseconds_to_pause_frame, 700U); + QCOMPARE(current_worker_conf->seconds_to_pause_to_ready, 3U); + QCOMPARE(current_worker_conf->use_dhmmixer, 1); + + //this well make valgrind happy. i.e. worker will handle memory cleanupping + mafw_gst_renderer_worker_set_configuration(m_worker, current_worker_conf); +} + +void ut_MafwGstRendererWorker::configurabilityTestCase() +{ + MafwGstRendererWorker *configWorker = mafw_gst_renderer_worker_new(this); + + configuration *config = mafw_gst_renderer_worker_create_default_configuration(configWorker); + + g_free(config->asink); + config->asink = g_strdup("test-sink"); + + //audio sink + QVERIFY(!globalGstFactoryRequests.contains("test-sink")); + mafw_gst_renderer_worker_set_configuration(configWorker, config); + mafw_gst_renderer_worker_stop(configWorker); + QVERIFY(globalGstFactoryRequests.contains("test-sink")); + globalGstFactoryRequests.clear(); + + mafw_gst_renderer_worker_exit(configWorker); + g_free(configWorker); + + + //video sink + configWorker = mafw_gst_renderer_worker_new(this); + config = mafw_gst_renderer_worker_create_default_configuration(configWorker); + g_free(config->vsink); + config->vsink = g_strdup("test-video-sink"); + + QVERIFY(!globalGstFactoryRequests.contains("test-video-sink")); + + mafw_gst_renderer_worker_set_configuration(configWorker, config); + //video-sink is not created unless xid has been set + mafw_gst_renderer_worker_set_xid(configWorker, 0xffff); + + mafw_gst_renderer_worker_stop(configWorker); + QVERIFY(globalGstFactoryRequests.contains("test-video-sink")); + + globalGstFactoryRequests.clear(); + mafw_gst_renderer_worker_exit(configWorker); + g_free(configWorker); + + + //NO dhmmixer + configWorker = mafw_gst_renderer_worker_new(this); + config = mafw_gst_renderer_worker_create_default_configuration(configWorker); + config->use_dhmmixer = 0; + + QVERIFY(!globalGstFactoryRequests.contains("nokiadhmmix")); + mafw_gst_renderer_worker_set_configuration(configWorker, config); + mafw_gst_renderer_worker_stop(configWorker); + QVERIFY(!globalGstFactoryRequests.contains("nokiadhmmix")); + + globalGstFactoryRequests.clear(); + mafw_gst_renderer_worker_exit(configWorker); + g_free(configWorker); + + //YES dhmmixer + configWorker = mafw_gst_renderer_worker_new(this); + config = mafw_gst_renderer_worker_create_default_configuration(configWorker); + config->use_dhmmixer = 1; + + QVERIFY(!globalGstFactoryRequests.contains("nokiadhmmix")); + mafw_gst_renderer_worker_set_configuration(configWorker, config); + mafw_gst_renderer_worker_stop(configWorker); + QVERIFY(globalGstFactoryRequests.contains("nokiadhmmix")); + + globalGstFactoryRequests.clear(); + mafw_gst_renderer_worker_exit(configWorker); + g_free(configWorker); +} + +void ut_MafwGstRendererWorker::pauseFrameConfigurabilityTestCase() +{ + + m_worker->notify_play_handler = &playCallback; + m_worker->notify_pause_handler = &pauseCallback; + m_worker->notify_metadata_handler = &metadataCallback; + m_worker->notify_property_handler = &propertyCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + m_worker->screenshot_handler = screenshotCallback; + + //let's change timeout values + configuration *config = mafw_gst_renderer_worker_create_default_configuration(m_worker); + config->milliseconds_to_pause_frame = 3000; + config->seconds_to_pause_to_ready = 6; + mafw_gst_renderer_worker_set_configuration(m_worker, config); + + + mafw_gst_renderer_worker_set_current_frame_on_pause(m_worker, TRUE); + QVERIFY(mafw_gst_renderer_worker_get_current_frame_on_pause(m_worker) == + TRUE); + QVERIFY(m_gotPropertyCallback == true); + QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_CURRENT_FRAME_ON_PAUSE); + + mafw_gst_renderer_worker_set_xid(m_worker, 0xffff); + QVERIFY(mafw_gst_renderer_worker_get_xid(m_worker) == 0xffff); + QVERIFY(m_gotPropertyCallback == true); + QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_XID); + m_gotPropertyCallback = false; + m_receivedPropertyId = -1; + + mafw_gst_renderer_worker_play(m_worker, VIDEO_URI.toString().toAscii()); + + /* post xwindow-id on bus since we are using fakesink instead of + * xvimagesink */ + GstBus *bus; + GstStructure *structure; + GstMessage *message; + structure = gst_structure_new("prepare-xwindow-id", "width", + G_TYPE_INT, 64, "height", G_TYPE_INT, 32, + NULL); + message = gst_message_new_element(NULL, structure); + bus = m_worker->bus; + gst_bus_post(bus, message); + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + + mafw_gst_renderer_worker_pause(m_worker); + QTest::qWait(2000); + + //no pause frame yet, let's make sure + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotPauseCallback == true); + QVERIFY(m_gotMetadataCallback == true); + QVERIFY(m_gotErrorCallback == false); + QVERIFY(!m_receivedMetadata.contains(WORKER_METADATA_KEY_PAUSED_THUMBNAIL_URI)); + + waitForEvent(WAIT_TIMEOUT, NEVER_HAPPENING_EVENT); + QVERIFY(m_receivedMetadata.contains(WORKER_METADATA_KEY_PAUSED_THUMBNAIL_URI)); + + mafw_gst_renderer_worker_stop(m_worker); + QTest::qWait(100); + config = mafw_gst_renderer_worker_create_default_configuration(m_worker); + mafw_gst_renderer_worker_set_configuration(m_worker, config); + +} + +void ut_MafwGstRendererWorker::setAndGetPropertiesTestCase() +{ + + m_worker->notify_error_handler = &errorCallback; + m_worker->notify_property_handler = &propertyCallback; + m_worker->notify_play_handler = &playCallback; + m_worker->notify_pause_handler = &pauseCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + + m_gotPropertyCallback = false; + m_receivedPropertyId = -1; + mafw_gst_renderer_worker_set_xid(m_worker, 0xffff); + QVERIFY(mafw_gst_renderer_worker_get_xid(m_worker) == 0xffff); + QVERIFY(m_gotPropertyCallback == true); + QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_XID); + m_gotPropertyCallback = false; + m_receivedPropertyId = -1; + + mafw_gst_renderer_worker_set_force_aspect_ratio(m_worker, FALSE); + QVERIFY(mafw_gst_renderer_worker_get_force_aspect_ratio(m_worker) == FALSE); + QVERIFY(m_gotPropertyCallback == true); + QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_FORCE_ASPECT_RATIO); + m_gotPropertyCallback = false; + m_receivedPropertyId = -1; + mafw_gst_renderer_worker_set_force_aspect_ratio(m_worker, TRUE); + QVERIFY(mafw_gst_renderer_worker_get_force_aspect_ratio(m_worker) == TRUE); + QVERIFY(m_gotPropertyCallback == true); + QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_FORCE_ASPECT_RATIO); + m_gotPropertyCallback = false; + m_receivedPropertyId = -1; + + mafw_gst_renderer_worker_set_current_frame_on_pause(m_worker, TRUE); + QVERIFY(mafw_gst_renderer_worker_get_current_frame_on_pause(m_worker) == + TRUE); + QVERIFY(m_gotPropertyCallback == true); + QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_CURRENT_FRAME_ON_PAUSE); + m_gotPropertyCallback = false; + m_receivedPropertyId = -1; + mafw_gst_renderer_worker_set_current_frame_on_pause(m_worker, FALSE); + QVERIFY(mafw_gst_renderer_worker_get_current_frame_on_pause(m_worker) == + FALSE); + QVERIFY(m_gotPropertyCallback == true); + QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_CURRENT_FRAME_ON_PAUSE); + m_gotPropertyCallback = false; + m_receivedPropertyId = -1; + + mafw_gst_renderer_worker_set_autopaint(m_worker, TRUE); + QVERIFY(mafw_gst_renderer_worker_get_autopaint(m_worker) == TRUE); + QVERIFY(m_gotPropertyCallback == true); + QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_AUTOPAINT); + m_gotPropertyCallback = false; + m_receivedPropertyId = -1; + mafw_gst_renderer_worker_set_autopaint(m_worker, FALSE); + QVERIFY(mafw_gst_renderer_worker_get_autopaint(m_worker) == FALSE); + QVERIFY(m_gotPropertyCallback == true); + QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_AUTOPAINT); + + mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii()); + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotPauseCallback == false); + + mafw_gst_renderer_worker_set_playback_speed(m_worker, 2); + QVERIFY(mafw_gst_renderer_worker_get_playback_speed(m_worker) == 2); + QVERIFY(m_gotPropertyCallback == true); + QVERIFY(m_receivedPropertyId == WORKER_PROPERTY_PLAYBACK_SPEED); + m_gotPropertyCallback = false; + m_receivedPropertyId = -1; + mafw_gst_renderer_worker_set_playback_speed(m_worker, float(-1)); + QCOMPARE(mafw_gst_renderer_worker_get_playback_speed(m_worker), float(-1)); + m_gotPropertyCallback = false; + m_receivedPropertyId = -1; + mafw_gst_renderer_worker_set_playback_speed(m_worker, float(2.5)); + QCOMPARE(mafw_gst_renderer_worker_get_playback_speed(m_worker), float(2.5)); + + render_rectangle rect = {1,2,3,4}; + m_gotPropertyCallback = false; + m_receivedPropertyId = -1; + + mafw_gst_renderer_worker_set_render_rectangle(m_worker, &rect); + QVERIFY(m_gotPropertyCallback); + QVERIFY(m_receivedPropertyId != -1); + const render_rectangle *storedRect = mafw_gst_renderer_worker_get_render_rectangle(m_worker); + //the pointer value should not be used, copy must be made + QVERIFY(&rect != storedRect ); + QCOMPARE(rect.x, storedRect->x); + QCOMPARE(rect.y, storedRect->y); + QCOMPARE(rect.width, storedRect->width); + QCOMPARE(rect.height, storedRect->height); + + m_gotPropertyCallback = false; + m_receivedPropertyId = -1; + + QVERIFY(m_gotErrorCallback == false); +} + +void ut_MafwGstRendererWorker::gettersTestCase() +{ + + m_worker->notify_error_handler = &errorCallback; + + QVERIFY(mafw_gst_renderer_worker_get_colorkey(m_worker) == -1); + QVERIFY(mafw_gst_renderer_worker_get_seekable(m_worker) == TRUE); + QVERIFY(m_gotErrorCallback == false); + +} + +void ut_MafwGstRendererWorker::mediaRouteTestCase() +{ + + GSList *list = NULL; + + m_worker->notify_play_handler = &playCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->notify_eos_handler = &eosCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + mafw_gst_renderer_worker_set_xid(m_worker, 0xffff); + + /* normal audio playback */ + mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii()); + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotErrorCallback == false); + + list = g_slist_append(list, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_SPEAKERS)); + list = g_slist_append(list, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY)); + mafw_gst_renderer_worker_notify_media_destination(m_worker, list); + g_slist_free(list); + list = NULL; + QVERIFY(g_slist_length(m_worker->destinations) == 2); + QVERIFY(g_slist_find(m_worker->destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_SPEAKERS))); + QVERIFY(g_slist_find(m_worker->destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY))); + + waitForEvent(EOS_TIMEOUT, m_gotEosCallback); + + QVERIFY(m_gotEosCallback == true); + QVERIFY(m_gotErrorCallback == false); + + /* normal video playback */ + m_gotPlayCallback = false; + m_gotEosCallback = false; + m_gotErrorCallback = false; + QVERIFY(m_blankingProhibited == false); + mafw_gst_renderer_worker_play(m_worker, VIDEO_URI.toString().toAscii()); + m_worker->media.has_visual_content = true; // normally gst sets this but not in unittest for some reason + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotErrorCallback == false); + QVERIFY(m_blankingProhibited == true); + + list = g_slist_append(list, GINT_TO_POINTER(WORKER_OUTPUT_HEADPHONE_JACK)); + list = g_slist_append(list, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY)); + mafw_gst_renderer_worker_notify_media_destination(m_worker, list); + g_slist_free(list); + list = NULL; + QVERIFY(g_slist_length(m_worker->destinations) == 2); + QVERIFY(g_slist_find(m_worker->destinations, GINT_TO_POINTER(WORKER_OUTPUT_HEADPHONE_JACK))); + QVERIFY(g_slist_find(m_worker->destinations, GINT_TO_POINTER(WORKER_OUTPUT_BUILTIN_DISPLAY))); + + waitForEvent(WAIT_TIMEOUT, m_gotEosCallback); + QVERIFY(m_gotEosCallback == true); + QVERIFY(m_gotErrorCallback == false); + +} + +void ut_MafwGstRendererWorker::setReadyTimeoutTestCase() +{ + + m_worker->notify_play_handler = &playCallback; + m_worker->notify_error_handler = &errorCallback; + m_worker->notify_pause_handler = &pauseCallback; + m_worker->notify_eos_handler = &eosCallback; + m_worker->blanking__control_handler = &blankingControlCallback; + + /* do some basic set calls first */ + mafw_gst_renderer_worker_set_ready_timeout(m_worker, 0); + QVERIFY(m_worker->config->seconds_to_pause_to_ready == 0); + mafw_gst_renderer_worker_set_ready_timeout(m_worker, 60); + QVERIFY(m_worker->config->seconds_to_pause_to_ready == 60); + + /* set timeout to 0, pause in the middle of the playback */ + mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii()); + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotErrorCallback == false); + + m_gotPlayCallback = false; + m_gotPauseCallback = false; + mafw_gst_renderer_worker_set_ready_timeout(m_worker, 0); + QVERIFY(m_worker->config->seconds_to_pause_to_ready == 0); + QTest::qWait(1500); + QVERIFY(m_worker->state == GST_STATE_PLAYING); + mafw_gst_renderer_worker_pause(m_worker); + waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback); + QVERIFY(m_worker->state == GST_STATE_PAUSED); + QTest::qWait(500); + QVERIFY(m_worker->state == GST_STATE_READY); + + m_gotPlayCallback = false; + m_gotPauseCallback = false; + + mafw_gst_renderer_worker_resume(m_worker); + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_worker->state == GST_STATE_PLAYING); + waitForEvent(WAIT_TIMEOUT, m_gotEosCallback); + QVERIFY(m_gotEosCallback == true); + + /* set timeout to 3, pause in the middle of the playback */ + mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii()); + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotErrorCallback == false); + + m_gotPlayCallback = false; + m_gotPauseCallback = false; + mafw_gst_renderer_worker_set_ready_timeout(m_worker, 3); + QVERIFY(m_worker->config->seconds_to_pause_to_ready == 3); + QTest::qWait(1500); + QVERIFY(m_worker->state == GST_STATE_PLAYING); + mafw_gst_renderer_worker_pause(m_worker); + waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback); + QVERIFY(m_worker->state == GST_STATE_PAUSED); + + m_gotPlayCallback = false; + m_gotPauseCallback = false; + QTest::qWait(4000); + QVERIFY(m_worker->state == GST_STATE_READY); + + mafw_gst_renderer_worker_resume(m_worker); + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_worker->state == GST_STATE_PLAYING); + waitForEvent(WAIT_TIMEOUT, m_gotEosCallback); + QVERIFY(m_gotEosCallback == true); + + /* set timeout to 0, pause in the middle of the playback after setting the + * timeout value --> we should go to ready immediately */ + mafw_gst_renderer_worker_play(m_worker, AUDIO_URI.toString().toAscii()); + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_gotErrorCallback == false); + mafw_gst_renderer_worker_set_ready_timeout(m_worker, 60); + QVERIFY(m_worker->config->seconds_to_pause_to_ready == 60); + + m_gotPlayCallback = false; + m_gotPauseCallback = false; + QTest::qWait(1500); + QVERIFY(m_worker->state == GST_STATE_PLAYING); + mafw_gst_renderer_worker_pause(m_worker); + waitForEvent(WAIT_TIMEOUT, m_gotPauseCallback); + QVERIFY(m_worker->state == GST_STATE_PAUSED); + mafw_gst_renderer_worker_set_ready_timeout(m_worker, 0); + QVERIFY(m_worker->config->seconds_to_pause_to_ready == 0); + QTest::qWait(500); + QVERIFY(m_worker->state == GST_STATE_READY); + + m_gotPlayCallback = false; + m_gotPauseCallback = false; + + mafw_gst_renderer_worker_resume(m_worker); + waitForEvent(WAIT_TIMEOUT, m_gotPlayCallback); + QVERIFY(m_gotPlayCallback == true); + QVERIFY(m_worker->state == GST_STATE_PLAYING); + waitForEvent(WAIT_TIMEOUT, m_gotEosCallback); + QVERIFY(m_gotEosCallback == true); + +} + +void ut_MafwGstRendererWorker::initTestCase() +{ + gst_init(0,0); +} + +void ut_MafwGstRendererWorker::init() +{ + + qDebug() << __PRETTY_FUNCTION__; + + m_worker = 0; + m_receivedErrorCode = -1; + m_receivedPropertyId = -1; + m_receivedBufferStatus = -1.0; + m_receivedMetadata.clear(); + m_gotPlayCallback = false; + m_gotEosCallback = false; + m_gotErrorCallback = false; + m_gotPauseCallback = false; + m_gotSeekCallback = false; + m_gotMetadataCallback = false; + m_gotPropertyCallback = false; + m_gotBufferStatusCallback = false; + m_blankingProhibited = false; + + global_context_duration = 0; + + bool ok; + QByteArray tmo = qgetenv("WAIT_TIMEOUT"); + int val = tmo.toInt(&ok, 10); + if (ok) + { + WAIT_TIMEOUT = val; + qDebug() << "WAIT_TIMEOUT is set to" << WAIT_TIMEOUT; + } + else + { + qDebug() << "Using default WAIT_TIMEOUT" << WAIT_TIMEOUT; + } + + const QString scheme("file"); + AUDIO_URI.setScheme(scheme); + VIDEO_URI.setScheme(scheme); + IMAGE_URI.setScheme(scheme); + + m_worker = mafw_gst_renderer_worker_new(this); + + QVERIFY(m_worker != 0); + + globalGstFactoryRequests.clear(); +} + +void ut_MafwGstRendererWorker::cleanup() +{ + QVERIFY(m_worker != 0); + + mafw_gst_renderer_worker_exit(m_worker); + g_free(m_worker); + + QVERIFY(m_blankingProhibited == false); + + m_gotPlayCallback = false; + m_gotErrorCallback = false; +} + +QTEST_MAIN(ut_MafwGstRendererWorker)