static void
handle_current_sync (GstDiscoverer * dc)
{
GTimer *timer;
gdouble deadline = ((gdouble) dc->priv->timeout) / GST_SECOND;
GstMessage *msg;
gboolean done = FALSE;
timer = g_timer_new ();
g_timer_start (timer);
do {
/* poll bus with timeout */
/* FIXME : make the timeout more fine-tuned */
if ((msg = gst_bus_timed_pop (dc->priv->bus, GST_SECOND / 2))) {
done = handle_message (dc, msg);
gst_message_unref (msg);
}
} while (!done && (g_timer_elapsed (timer, NULL) < deadline));
/* return result */
if (!done) {
GST_DEBUG ("we timed out! Setting result to TIMEOUT");
dc->priv->current_info->result = GST_DISCOVERER_TIMEOUT;
}
GST_DEBUG ("Done");
g_timer_stop (timer);
g_timer_destroy (timer);
}
/* test that you get the messages with pop from another thread. */
static gpointer
pop_thread (gpointer data)
{
GstBus *bus = GST_BUS_CAST (data);
guint i;
for (i = 0; i < 10; i++)
gst_message_unref (gst_bus_timed_pop (bus, GST_CLOCK_TIME_NONE));
return NULL;
}
void Music::Playing_state_code(void)
{
//BUILDER COMMENT. DO NOT REMOVE. begin Playing_state_code
#ifdef WEBOTS
return;
#endif
GstMessage* message = gst_bus_timed_pop(bus, 0);
if ((message != NULL) && (GST_MESSAGE_TYPE(message) == GST_MESSAGE_EOS)) {
isStopPress = true;
}
//BUILDER COMMENT. DO NOT REMOVE. end Playing_state_code
}
/* This function is called as a separate thread, playing the sound. */
static void
games_sound_thread_run (gchar * data, gchar * user_data)
{
const char *dir;
char *uri;
gboolean done = FALSE;
GstBus *bus;
bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
/* Set URL for sound to play. */
dir = games_runtime_get_directory (GAMES_RUNTIME_SOUND_DIRECTORY);
uri = g_strdup_printf ("file:///%s/%s.ogg", dir, (char *) data);
g_object_set (G_OBJECT (pipeline), "uri", uri, NULL);
g_free (uri);
/* Set playbin to playing state. */
gst_element_set_state (pipeline, GST_STATE_PLAYING);
do {
GstMessage *message;
/* wait for message on the bus */
message = gst_bus_timed_pop (bus, GST_CLOCK_TIME_NONE);
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_EOS:
done = TRUE;
break;
case GST_MESSAGE_ERROR:{
GError *err;
gchar *debug;
gst_message_parse_error (message, &err, &debug);
_games_debug_print (GAMES_DEBUG_SOUND,
"Error playing sound: %s\n", err->message);
g_error_free (err);
g_free (debug);
done = TRUE;
break;
}
default:
break;
}
gst_message_unref (message);
}
while (!done);
gst_element_set_state (pipeline, GST_STATE_NULL);
}
void ly_mdh_new_with_uri_full_loop_cb (LyMdhMetadata *md, GstElement *element, gboolean block)
{
GstBus *bus;
GstMessage *message;
gboolean done = FALSE;
bus = gst_element_get_bus(element);
g_return_if_fail(bus!=NULL);
while(!done && !ly_mdh_md_eos)
{
if(block)
message = gst_bus_timed_pop(bus, GST_CLOCK_TIME_NONE);
else
message = gst_bus_timed_pop(bus, 0);
if(message==NULL)
{
gst_object_unref(bus);
return;
}
done = ly_mdh_new_with_uri_full_bus_cb(bus, message, md);
gst_message_unref(message);
}
gst_object_unref(bus);
}
void LightPopThread::run ()
{
while (!ShouldStop_)
{
const auto msg = gst_bus_timed_pop (Bus_, GST_SECOND);
if (!msg)
continue;
QMetaObject::invokeMethod (Handler_,
"handleMessage",
Qt::QueuedConnection,
Q_ARG (GstMessage_ptr, std::shared_ptr<GstMessage> (msg, gst_message_unref)));
if (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_ERROR)
{
QMutexLocker locker { &PauseMutex_ };
PauseWC_.wait (&PauseMutex_);
}
}
}
void RgAnalyser::HandleErrorMsg (GstMessage *msg)
{
GError *gerror = nullptr;
gchar *debug = nullptr;
gst_message_parse_error (msg, &gerror, &debug);
const auto& msgStr = QString::fromUtf8 (gerror->message);
const auto& debugStr = QString::fromUtf8 (debug);
const auto code = gerror->code;
const auto domain = gerror->domain;
g_error_free (gerror);
g_free (debug);
qWarning () << Q_FUNC_INFO
<< domain
<< code
<< msgStr
<< debugStr;
if (IsDraining_)
return;
IsDraining_ = true;
const auto bus = gst_pipeline_get_bus (GST_PIPELINE (Pipeline_));
while (const auto msg = gst_bus_timed_pop (bus, 0.01 * GST_SECOND))
handleMessage (std::shared_ptr<GstMessage> (msg, gst_message_unref));
IsDraining_ = false;
gst_element_set_state (Pipeline_, GST_STATE_NULL);
PopThread_->Resume ();
const auto trackInfoPos = std::find_if (Result_.Tracks_.begin (), Result_.Tracks_.end (),
[this] (const TrackRgResult& info) { return info.TrackPath_ == CurrentPath_; });
if (trackInfoPos == Result_.Tracks_.end ())
Result_.Tracks_.append ({ CurrentPath_, 0, 0 });
CheckFinish ();
}
void MsgPopThread::run ()
{
while (!ShouldStop_.load (std::memory_order_relaxed))
{
const auto msg = gst_bus_timed_pop (Bus_, Multiplier_ * GST_SECOND);
if (!msg)
continue;
QMetaObject::invokeMethod (SourceObj_,
"handleMessage",
Qt::QueuedConnection,
Q_ARG (GstMessage_ptr, std::shared_ptr<GstMessage> (msg, gst_message_unref)));
if (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_ERROR)
{
BusDrainMutex_.lock ();
BusDrainWC_.wait (&BusDrainMutex_);
BusDrainMutex_.unlock ();
qDebug () << "bus drained, continuing";
}
}
}
// ----------------------------------------------------------------------------
// Retrieve and process a bus message
bool
GStreamerImportFileHandle::ProcessBusMessage(bool & success)
{
bool cont = true;
// Default to no errors
success = true;
// Get the next message
GstMessage *msg = gst_bus_timed_pop(mBus, 100 * GST_MSECOND);
if (!msg)
{
// Timed out...not an error
return cont;
}
#if defined(__WXDEBUG__)
gchar *objname = NULL;
if (msg->src != NULL)
{
objname = gst_object_get_name(msg->src);
}
wxLogMessage(wxT("GStreamer: Got %s%s%s"),
wxString::FromUTF8(GST_MESSAGE_TYPE_NAME(msg)).c_str(),
objname ? wxT(" from ") : wxT(""),
objname ? wxString::FromUTF8(objname).c_str() : wxT(""));
if (objname != NULL)
{
g_free(objname);
}
#endif
// Handle based on message type
switch (GST_MESSAGE_TYPE(msg))
{
// Handle error message from gstreamer
case GST_MESSAGE_ERROR:
{
GError *err = NULL;
gchar *debug = NULL;
gst_message_parse_error(msg, &err, &debug);
if (err)
{
wxString m;
m.Printf(wxT("%s%s%s"),
wxString::FromUTF8(err->message).c_str(),
debug ? wxT("\n") : wxT(""),
debug ? wxString::FromUTF8(debug).c_str() : wxT(""));
#if defined(_DEBUG)
wxMessageBox(m, wxT("GStreamer Error:"));
#else
wxLogMessage(wxT("GStreamer Error: %s"), m.c_str());
#endif
g_error_free(err);
}
if (debug)
{
g_free(debug);
}
success = false;
cont = false;
}
break;
// Handle warning message from gstreamer
case GST_MESSAGE_WARNING:
{
GError *err = NULL;
gchar *debug = NULL;
gst_message_parse_warning(msg, &err, &debug);
if (err)
{
wxLogMessage(wxT("GStreamer Warning: %s%s%s"),
wxString::FromUTF8(err->message).c_str(),
debug ? wxT("\n") : wxT(""),
debug ? wxString::FromUTF8(debug).c_str() : wxT(""));
g_error_free(err);
}
if (debug)
{
g_free(debug);
}
}
break;
// Handle warning message from gstreamer
case GST_MESSAGE_INFO:
{
GError *err = NULL;
gchar *debug = NULL;
gst_message_parse_info(msg, &err, &debug);
if (err)
{
wxLogMessage(wxT("GStreamer Info: %s%s%s"),
wxString::FromUTF8(err->message).c_str(),
debug ? wxT("\n") : wxT(""),
debug ? wxString::FromUTF8(debug).c_str() : wxT(""));
g_error_free(err);
}
if (debug)
{
g_free(debug);
}
}
break;
// Handle metadata tags
case GST_MESSAGE_TAG:
{
GstTagList *tags = NULL;
// Retrieve tag list from message...just ignore failure
gst_message_parse_tag(msg, &tags);
if (tags)
{
// Go process the list
OnTag(GST_APP_SINK(GST_MESSAGE_SRC(msg)), tags);
// Done with list
gst_tag_list_unref(tags);
}
}
break;
// Pre-roll is done...will happen for each group
// (like with chained OGG files)
case GST_MESSAGE_ASYNC_DONE:
{
// If this is the first async-done message, then tell
// caller to end loop, but leave it active so that
// gstreamer threads can still queue up.
//
// We'll receive multiple async-done messages for chained
// ogg files, so ignore the message the 2nd and subsequent
// occurrences.
if (!mAsyncDone)
{
cont = false;
mAsyncDone = true;
}
}
break;
// End of the stream (and all sub-streams)
case GST_MESSAGE_EOS:
{
// Terminate loop
cont = false;
}
break;
}
// Release the message
gst_message_unref(msg);
return cont;
}
/**
* ly_gla_fina:
*
* Create a new allocate LyMdhMetadata type structure based on a uri. It fills
* all fields in metadata struct.
*
* Returns: a newly allocated metadata struct.
*/
LyMdhMetadata* ly_mdh_new_with_uri_full (char *uri)
{
/*
* test file
*/
char *prefix=ly_gla_uri_get_prefix(uri);
char *path=ly_gla_uri_get_path(uri);
if(!g_str_equal(prefix, "file://"))
{
g_free(prefix);
ly_log_put_with_flag(G_LOG_LEVEL_DEBUG, _("Cannot open file: %s. unsupported protocol!"), uri);
return NULL;
}
g_free(prefix);
if(!g_file_test(path, G_FILE_TEST_EXISTS))
{
g_free(path);
ly_log_put_with_flag(G_LOG_LEVEL_DEBUG, _("Cannot open file: %s. file not found!"), uri);
return NULL;
}
g_free(path);
ly_mdh_pipeline=NULL;
ly_mdh_md_eos=FALSE;
/*
* create and initial metadata
*/
LyMdhMetadata *metadata=ly_mdh_new();
g_strlcpy(metadata->uri, uri, sizeof(metadata->uri));
/*
* build the pipeline
*/
GstFormat fmt=GST_FORMAT_TIME;
GstElement *urisrc;
GstElement *decodebin;
GstElement *fakesink;
GstBus *bus=NULL;
gint changeTimeout = 0;
GstStateChangeReturn rt;
GstMessage *msg;
ly_mdh_pipeline=gst_pipeline_new("pipeline");
urisrc=gst_element_make_from_uri(GST_URI_SRC,metadata->uri,"urisrc");
decodebin=gst_element_factory_make("decodebin","decodebin");
fakesink=gst_element_factory_make("fakesink","fakesink");
gst_bin_add_many(GST_BIN(ly_mdh_pipeline),urisrc,decodebin,fakesink,NULL);
gst_element_link(urisrc,decodebin);
g_signal_connect_object(G_OBJECT(decodebin),"new-decoded-pad",G_CALLBACK(ly_mdh_new_with_uri_pipe_cb),fakesink,0);
bus = gst_pipeline_get_bus(GST_PIPELINE(ly_mdh_pipeline));
gst_element_set_state(ly_mdh_pipeline,GST_STATE_NULL);
gst_element_set_state(ly_mdh_pipeline,GST_STATE_READY);
rt = gst_element_set_state(ly_mdh_pipeline,GST_STATE_PAUSED);
if(!rt)
{
if(ly_mdh_pipeline!=NULL)
gst_object_unref(GST_OBJECT(ly_mdh_pipeline));
ly_mdh_md_eos=FALSE;
ly_mdh_pipeline=NULL;
return FALSE;
}
while(rt==GST_STATE_CHANGE_ASYNC && !ly_mdh_md_eos && changeTimeout < 5)
{
msg = gst_bus_timed_pop(bus, 1 * GST_SECOND);
if(msg!=NULL)
{
ly_mdh_new_with_uri_full_bus_cb(bus, msg, metadata);
gst_message_unref(msg);
changeTimeout = 0;
}
else
changeTimeout++;
rt = gst_element_get_state(ly_mdh_pipeline, NULL, NULL, 0);
}
gst_object_unref(bus);
ly_mdh_new_with_uri_full_loop_cb(metadata, ly_mdh_pipeline, FALSE);
if(rt!=GST_STATE_CHANGE_SUCCESS)
{
gst_element_set_state(ly_mdh_pipeline,GST_STATE_NULL);
if(ly_mdh_pipeline!=NULL)
gst_object_unref(GST_OBJECT(ly_mdh_pipeline));
return FALSE;
}
/*
* get duration
*/
gint64 dura=0;
gst_element_query_duration(ly_mdh_pipeline,&fmt,&dura);
char *duration=ly_mdh_time_int2str(dura);
g_strlcpy(metadata->duration,duration,sizeof(metadata->duration));
g_free(duration);
rt = gst_element_set_state(ly_mdh_pipeline,GST_STATE_NULL);
gst_object_unref(ly_mdh_pipeline);
char *str;
if(g_str_equal(metadata->title,"")||g_str_equal(metadata->title,"unknown"))
{
str=ly_gla_uri_get_filename(uri);
g_strlcpy(metadata->title,str,sizeof(metadata->title));
g_free(str);
}
ly_mdh_pipeline=NULL;
ly_mdh_md_eos=FALSE;
return metadata;
}