--- /dev/null
+/*
+ * This file is part of QMAFW
+ *
+ * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights
+ * reserved.
+ *
+ * Contact: Visa Smolander <visa.smolander@nokia.com>
+ *
+ * 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 <QDir>
+#include <QUrl>
+#include <QTimer>
+
+#include <glib.h>
+#include <gst/gst.h>
+#include <gst/tag/tag.h>
+#include <context_provider.h>
+
+#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<ut_MafwGstRendererWorker*>(owner);
+ self->m_gotPlayCallback = true;
+
+}
+
+void ut_MafwGstRendererWorker::pauseCallback(MafwGstRendererWorker *worker,
+ gpointer owner)
+{
+ Q_UNUSED(worker);
+
+ qDebug() << __PRETTY_FUNCTION__;
+
+ ut_MafwGstRendererWorker* self =
+ static_cast<ut_MafwGstRendererWorker*>(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<ut_MafwGstRendererWorker*>(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<ut_MafwGstRendererWorker*>(owner);
+ self->m_gotEosCallback = true;
+
+}
+
+void ut_MafwGstRendererWorker::seekCallback(MafwGstRendererWorker *worker,
+ gpointer owner)
+{
+
+ Q_UNUSED(worker);
+
+ qDebug() << __PRETTY_FUNCTION__;
+
+ ut_MafwGstRendererWorker* self =
+ static_cast<ut_MafwGstRendererWorker*>(owner);
+ self->m_gotSeekCallback = true;
+
+}
+
+void ut_MafwGstRendererWorker::errorCallback(MafwGstRendererWorker *worker,
+ gpointer owner,
+ const GError *error)
+{
+
+ Q_UNUSED(worker);
+
+ ut_MafwGstRendererWorker* self =
+ static_cast<ut_MafwGstRendererWorker*>(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<ut_MafwGstRendererWorker*>(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<ut_MafwGstRendererWorker*>(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<ut_MafwGstRendererWorker*>(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<ut_MafwGstRendererWorker*>(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)
projects / mafwsubrenderer / blobdiff