static void
event_loop (GstElement * pipe)
{
GstBus *bus;
GstMessage *message = NULL;
bus = gst_element_get_bus (GST_ELEMENT (pipe));
while (TRUE) {
message = gst_bus_poll (bus, GST_MESSAGE_ANY, -1);
g_assert (message != NULL);
switch (message->type) {
case GST_MESSAGE_EOS:
gst_message_unref (message);
return;
case GST_MESSAGE_WARNING:
case GST_MESSAGE_ERROR:{
GError *gerror;
gchar *debug;
gst_message_parse_error (message, &gerror, &debug);
gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug);
gst_message_unref (message);
g_error_free (gerror);
g_free (debug);
return;
}
default:
gst_message_unref (message);
break;
}
}
}
static void
event_loop (GstElement * pipe)
{
GstBus *bus;
GstMessage *message = NULL;
bus = gst_element_get_bus (GST_ELEMENT (pipe));
while (TRUE) {
message = gst_bus_timed_pop_filtered (bus, GST_MESSAGE_ANY, -1);
g_assert (message != NULL);
switch (message->type) {
case GST_MESSAGE_EOS:
g_message ("got EOS");
gst_message_unref (message);
return;
case GST_MESSAGE_WARNING:
case GST_MESSAGE_ERROR:
{
GError *gerror;
gchar *debug;
gst_message_parse_error (message, &gerror, &debug);
gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug);
gst_message_unref (message);
g_error_free (gerror);
g_free (debug);
return;
}
case GST_MESSAGE_STEP_DONE:
{
GstFormat format;
guint64 amount;
gdouble rate;
gboolean flush, intermediate;
guint64 duration;
gboolean eos;
gst_message_parse_step_done (message, &format, &amount, &rate,
&flush, &intermediate, &duration, &eos);
if (format == GST_FORMAT_DEFAULT) {
g_message ("step done: %" GST_TIME_FORMAT " skipped in %"
G_GUINT64_FORMAT " frames", GST_TIME_ARGS (duration), amount);
} else {
g_message ("step done: %" GST_TIME_FORMAT " skipped",
GST_TIME_ARGS (duration));
}
return;
}
default:
gst_message_unref (message);
break;
}
}
}
static void
message_received (GstBus * bus, GstMessage * message, GstPipeline * bin)
{
GST_INFO ("bus message from \"%" GST_PTR_FORMAT "\": %" GST_PTR_FORMAT,
GST_MESSAGE_SRC (message), message);
switch (message->type) {
case GST_MESSAGE_EOS:
if (!strcmp ("pipeline_send",
GST_OBJECT_NAME (GST_MESSAGE_SRC (message))))
send_pipeline_eos = TRUE;
else if (!strcmp ("pipeline_receive",
GST_OBJECT_NAME (GST_MESSAGE_SRC (message))))
receive_pipeline_eos = TRUE;
else
fail ("Unknown pipeline: %s",
GST_OBJECT_NAME (GST_MESSAGE_SRC (message)));
break;
case GST_MESSAGE_WARNING:{
GError *gerror;
gchar *debug;
gst_message_parse_warning (message, &gerror, &debug);
gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug);
g_error_free (gerror);
g_free (debug);
break;
}
case GST_MESSAGE_ERROR:{
GError *gerror;
gchar *debug;
gst_message_parse_error (message, &gerror, &debug);
gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug);
g_error_free (gerror);
g_free (debug);
fail ("Error!");
break;
}
default:
break;
}
}
static gboolean
bus_handler (GstBus * bus, GstMessage * message, gpointer data)
{
GMainLoop *loop = (GMainLoop *) data;
switch (message->type) {
case GST_MESSAGE_EOS:
g_main_loop_quit (loop);
break;
case GST_MESSAGE_WARNING:
case GST_MESSAGE_ERROR:{
GError *gerror;
gchar *debug;
if (message->type == GST_MESSAGE_WARNING)
gst_message_parse_warning (message, &gerror, &debug);
else
gst_message_parse_error (message, &gerror, &debug);
gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug);
gst_message_unref (message);
g_error_free (gerror);
g_free (debug);
g_main_loop_quit (loop);
break;
}
case GST_MESSAGE_TAG:
{
GstTagList *tag_list;
gchar *fpr, *p;
gst_message_parse_tag (message, &tag_list);
fail_unless (gst_tag_list_get_string (tag_list, "ofa-fingerprint", &fpr));
p = fpr;
while (*p) {
fail_unless (g_ascii_isalnum (*p) || *p == '=' || *p == '+'
|| *p == '/');
p++;
}
g_free (fpr);
gst_tag_list_unref (tag_list);
found_fingerprint = TRUE;
g_main_loop_quit (loop);
break;
}
default:
break;
}
return TRUE;
}
static void
play_file (const gint delay, const gchar * uri)
{
GstStateChangeReturn sret;
GstMessage *msg;
GstElement *play;
guint wait_nanosecs;
play = gst_element_factory_make ("playbin", "playbin");
g_object_set (play, "uri", uri, NULL);
g_printerr ("Playing %s\n", uri);
sret = gst_element_set_state (play, GST_STATE_PLAYING);
if (sret != GST_STATE_CHANGE_ASYNC && sret != GST_STATE_CHANGE_SUCCESS) {
g_printerr ("ERROR: state change failed, sret=%d\n", sret);
goto next;
}
wait_nanosecs = g_random_int_range (0, GST_MSECOND * delay);
msg = gst_bus_poll (GST_ELEMENT_BUS (play),
GST_MESSAGE_ERROR | GST_MESSAGE_EOS, wait_nanosecs);
if (msg) {
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_ERROR:
{
GError *gerror;
gchar *debug;
gst_message_parse_error (msg, &gerror, &debug);
gst_object_default_error (GST_MESSAGE_SRC (msg), gerror, debug);
g_clear_error (&gerror);
g_free (debug);
break;
}
case GST_MESSAGE_EOS:
g_printerr ("Got EOS\n");
break;
default:
g_printerr ("Got unexpected %s messge\n", GST_MESSAGE_TYPE_NAME (msg));
break;
}
gst_message_unref (msg);
goto next;
}
/* on to the next one */
g_print (".");
next:
gst_element_set_state (play, GST_STATE_NULL);
gst_object_unref (play);
}
static gboolean
bus_handler (GstBus * bus, GstMessage * message, gpointer data)
{
GMainLoop *loop = (GMainLoop *) data;
switch (message->type) {
case GST_MESSAGE_EOS:
g_main_loop_quit (loop);
break;
case GST_MESSAGE_WARNING:
case GST_MESSAGE_ERROR:{
GError *gerror;
gchar *debug;
gst_message_parse_error (message, &gerror, &debug);
gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug);
g_error_free (gerror);
g_free (debug);
g_main_loop_quit (loop);
break;
}
case GST_MESSAGE_TAG:{
if (received_tags == NULL) {
gst_message_parse_tag (message, &received_tags);
} else {
GstTagList *tl = NULL, *ntl = NULL;
gst_message_parse_tag (message, &tl);
if (tl) {
ntl = gst_tag_list_merge (received_tags, tl, GST_TAG_MERGE_PREPEND);
if (ntl) {
GST_LOG ("taglists merged: %" GST_PTR_FORMAT, ntl);
gst_tag_list_free (received_tags);
received_tags = ntl;
}
gst_tag_list_free (tl);
}
}
break;
}
default:
break;
}
return TRUE;
}
static gboolean
cb_papaya_pipeline_bus(GstBus *streambus,
GstMessage *msg,
gpointer data)
{
switch (GST_MESSAGE_TYPE(msg)){
case GST_MESSAGE_ERROR:
{
GError *err = NULL;
gchar *debug = NULL;
gst_message_parse_error (msg, &err, &debug);
gst_object_default_error (GST_MESSAGE_SRC(msg), err, debug);
g_print("\n");
g_error_free(err);
if (debug)
g_free(debug);
}
case GST_MESSAGE_WARNING:
{
/*
g_print("***WARNING*** !");
GError *err;
gchar *debug;
gst_message_parse_warning(msg, &err, &debug);
g_print("Warning: %s\n", err->message);
g_error_free(err);
if(debug)
g_free(debug);
*/
}
case GST_MESSAGE_EOS:
{
/* do nothing, handled elsewhere */
}
default:
break;
}
return TRUE;
};
static gboolean
bus_cb (GstBus * bus, GstMessage * msg, gpointer user_data)
{
GMainLoop *loop = user_data;
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_ERROR:{
GError *err = NULL;
gchar *dbg;
gst_message_parse_error (msg, &err, &dbg);
gst_object_default_error (msg->src, err, dbg);
g_clear_error (&err);
g_free (dbg);
g_main_loop_quit (loop);
break;
}
default:
break;
}
return TRUE;
}
static gboolean
bus_handler (GstBus * bus, GstMessage * message, gpointer data)
{
GMainLoop *loop = (GMainLoop *) data;
switch (message->type) {
case GST_MESSAGE_EOS:
g_main_loop_quit (loop);
break;
case GST_MESSAGE_WARNING:
case GST_MESSAGE_ERROR:{
GError *gerror;
gchar *debug;
gst_message_parse_error (message, &gerror, &debug);
gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug);
gst_message_unref (message);
g_error_free (gerror);
g_free (debug);
g_main_loop_quit (loop);
break;
}
case GST_MESSAGE_ELEMENT:
{
const GstStructure *s = gst_message_get_structure (message);
const gchar *name = gst_structure_get_name (s);
fail_unless (strcmp (name, "imperfect-timestamp") != 0);
fail_unless (strcmp (name, "imperfect-offset") != 0);
break;
}
default:
break;
}
return TRUE;
}
void IKGSTAudioPlayer::event_loop(GstElement * pipe)
{
GstBus *bus;
GstMessage *message = NULL;
bus = gst_element_get_bus(GST_ELEMENT(pipe));
bool loop = true;
while(loop)
{
message = gst_bus_poll(bus, GST_MESSAGE_ANY, -1);
g_assert(message != NULL);
switch(message->type)
{
case GST_MESSAGE_EOS:
gst_message_unref(message);
loop = false;//return
break;
case GST_MESSAGE_WARNING:
case GST_MESSAGE_ERROR:
{
GError *gerror;
gchar *debug;
gst_message_parse_error(message, &gerror, &debug);
gst_object_default_error(GST_MESSAGE_SRC(message), gerror, debug);
gst_message_unref(message);
g_error_free(gerror);
g_free(debug);
loop = false;//return
}
break;
default:
gst_message_unref(message);
break;
}
}
gst_object_unref(bus);
}
bool mmsGstPlay(GstElement *pipelineX) {
pipeline = pipelineX;
GstState state, pending;
caught_error = event_loop (pipeline, FALSE, GST_STATE_PLAYING);
if (caught_error) {
fprintf (stderr, "ERROR: pipeline doesn't want to preroll.\n");
} else {
GstClockTime tfthen, tfnow;
GstClockTimeDiff diff;
fprintf (stderr, "Setting pipeline to PLAYING ...\n");
if (gst_element_set_state (pipeline,
GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE) {
GstMessage *err_msg;
GstBus *bus;
fprintf (stderr, "ERROR: pipeline doesn't want to play.\n");
bus = gst_element_get_bus (pipeline);
if ((err_msg = gst_bus_poll (bus, GST_MESSAGE_ERROR, 0))) {
GError *gerror;
gchar *debug;
gst_message_parse_error (err_msg, &gerror, &debug);
gst_object_default_error (GST_MESSAGE_SRC (err_msg), gerror, debug);
gst_message_unref (err_msg);
g_error_free (gerror);
g_free (debug);
}
gst_object_unref (bus);
mmsGstFree();
return false;
}
tfthen = gst_util_get_timestamp ();
caught_error = event_loop (pipeline, TRUE, GST_STATE_PLAYING);
tfnow = gst_util_get_timestamp ();
diff = GST_CLOCK_DIFF (tfthen, tfnow);
g_print ("Execution ended after %" G_GUINT64_FORMAT " ns.\n", diff);
}
/* iterate mainloop to process pending stuff */
while (g_main_context_iteration (NULL, FALSE));
fprintf (stderr, "Setting pipeline to PAUSED ...\n");
gst_element_set_state (pipeline, GST_STATE_PAUSED);
if (!caught_error)
gst_element_get_state (pipeline, &state, &pending, GST_CLOCK_TIME_NONE);
fprintf (stderr, "Setting pipeline to READY ...\n");
gst_element_set_state (pipeline, GST_STATE_READY);
gst_element_get_state (pipeline, &state, &pending, GST_CLOCK_TIME_NONE);
// playback is finished
return true;
}
/* returns TRUE if there was an error or we caught a keyboard interrupt. */
static gboolean
event_loop (GstElement * pipeline, gboolean blocking, GstState target_state)
{
GstBus *bus;
GstMessage *message = NULL;
gboolean res = FALSE;
gboolean buffering = FALSE;
bus = gst_element_get_bus (GST_ELEMENT (pipeline));
#ifndef DISABLE_FAULT_HANDLER
g_timeout_add (50, (GSourceFunc) check_intr, pipeline);
#endif
while (TRUE) {
message = gst_bus_poll (bus, GST_MESSAGE_ANY, blocking ? -1 : 0);
/* if the poll timed out, only when !blocking */
if (message == NULL)
goto exit;
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_NEW_CLOCK:
{
GstClock *clock;
gst_message_parse_new_clock (message, &clock);
g_print ("New clock: %s\n", (clock ? GST_OBJECT_NAME (clock) : "NULL"));
break;
}
case GST_MESSAGE_EOS:
g_print ("Got EOS from element \"%s\".\n",
GST_STR_NULL (GST_ELEMENT_NAME (GST_MESSAGE_SRC (message))));
goto exit;
case GST_MESSAGE_TAG:
if (tags) {
GstTagList *tags;
gst_message_parse_tag (message, &tags);
g_print ("FOUND TAG : found by element \"%s\".\n",
GST_STR_NULL (GST_ELEMENT_NAME (GST_MESSAGE_SRC (message))));
gst_tag_list_foreach (tags, print_tag, NULL);
gst_tag_list_free (tags);
}
break;
case GST_MESSAGE_INFO:{
GError *gerror;
gchar *debug;
gchar *name = gst_object_get_path_string (GST_MESSAGE_SRC (message));
gst_message_parse_info (message, &gerror, &debug);
if (debug) {
g_print ("INFO:\n%s\n", debug);
}
g_error_free (gerror);
g_free (debug);
g_free (name);
break;
}
case GST_MESSAGE_WARNING:{
GError *gerror;
gchar *debug;
gchar *name = gst_object_get_path_string (GST_MESSAGE_SRC (message));
/* dump graph on warning */
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (pipeline),
GST_DEBUG_GRAPH_SHOW_ALL, "gst-launch.warning");
gst_message_parse_warning (message, &gerror, &debug);
g_print ("WARNING: from element %s: %s\n", name, gerror->message);
if (debug) {
g_print ("Additional debug info:\n%s\n", debug);
}
g_error_free (gerror);
g_free (debug);
g_free (name);
break;
}
case GST_MESSAGE_ERROR:{
GError *gerror;
gchar *debug;
/* dump graph on error */
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (pipeline),
GST_DEBUG_GRAPH_SHOW_ALL, "gst-launch.error");
gst_message_parse_error (message, &gerror, &debug);
gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug);
g_error_free (gerror);
g_free (debug);
/* we have an error */
res = TRUE;
goto exit;
}
case GST_MESSAGE_STATE_CHANGED:{
GstState old, newX, pending;
gst_message_parse_state_changed (message, &old, &newX, &pending);
/* we only care about pipeline state change messages */
if (GST_MESSAGE_SRC (message) != GST_OBJECT_CAST (pipeline))
break;
/* dump graph for pipeline state changes */
{
gchar *dump_name = g_strdup_printf ("gst-launch.%s_%s",
gst_element_state_get_name (old),
gst_element_state_get_name (newX));
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (pipeline),
GST_DEBUG_GRAPH_SHOW_ALL, dump_name);
g_free (dump_name);
}
/* ignore when we are buffering since then we mess with the states
* ourselves. */
if (buffering) {
fprintf (stderr,
"Prerolled, waiting for buffering to finish...\n");
break;
}
/* if we reached the final target state, exit */
if (target_state == GST_STATE_PAUSED && newX == target_state)
goto exit;
/* else not an interesting message */
break;
}
case GST_MESSAGE_BUFFERING:{
gint percent;
gst_message_parse_buffering (message, &percent);
fprintf (stderr, "%s %d%% \r", "buffering...", percent);
/* no state management needed for live pipelines */
if (is_live)
break;
if (percent == 100) {
/* a 100% message means buffering is done */
buffering = FALSE;
/* if the desired state is playing, go back */
if (target_state == GST_STATE_PLAYING) {
fprintf (stderr,
"Done buffering, setting pipeline to PLAYING ...\n");
gst_element_set_state (pipeline, GST_STATE_PLAYING);
} else
goto exit;
} else {
/* buffering busy */
if (buffering == FALSE && target_state == GST_STATE_PLAYING) {
/* we were not buffering but PLAYING, PAUSE the pipeline. */
fprintf (stderr, "Buffering, setting pipeline to PAUSED ...\n");
gst_element_set_state (pipeline, GST_STATE_PAUSED);
}
buffering = TRUE;
}
break;
}
case GST_MESSAGE_LATENCY:
{
fprintf (stderr, "Redistribute latency...\n");
gst_bin_recalculate_latency (GST_BIN (pipeline));
break;
}
case GST_MESSAGE_APPLICATION:{
const GstStructure *s;
s = gst_message_get_structure (message);
if (gst_structure_has_name (s, "GstLaunchInterrupt")) {
/* this application message is posted when we caught an interrupt and
* we need to stop the pipeline. */
fprintf (stderr, "Interrupt: Stopping pipeline ...\n");
/* return TRUE when we caught an interrupt */
res = TRUE;
goto exit;
}
}
default:
/* just be quiet by default */
break;
}
if (message)
gst_message_unref (message);
}
g_assert_not_reached ();
exit:
{
if (message)
gst_message_unref (message);
gst_object_unref (bus);
return res;
}
}
static gboolean
bus_message (GstBus * bus, GstMessage * message, App * app)
{
gchar *sourceName;
GstObject *source;
gchar *string;
GstState current_state;
if (!message)
return FALSE;
source = GST_MESSAGE_SRC (message);
if (!GST_IS_OBJECT (source))
return FALSE;
sourceName = gst_object_get_name (source);
if (gst_message_get_structure (message))
string = gst_structure_to_string (gst_message_get_structure (message));
else
string = g_strdup (GST_MESSAGE_TYPE_NAME (message));
GST_DEBUG("gst_message from %s: %s", sourceName, string);
g_free (string);
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_ERROR:
{
GError *gerror;
gchar *debug;
gst_message_parse_error (message, &gerror, &debug);
gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug);
g_error_free (gerror);
g_free (debug);
g_main_loop_quit (app->loop);
break;
}
case GST_MESSAGE_WARNING:
{
GError *gerror;
gchar *debug;
gst_message_parse_warning (message, &gerror, &debug);
gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug);
g_error_free (gerror);
g_free (debug);
// g_main_loop_quit (app->loop);
break;
}
case GST_MESSAGE_EOS:
g_message ("received EOS");
g_main_loop_quit (app->loop);
break;
case GST_MESSAGE_ASYNC_DONE:
break;
case GST_MESSAGE_ELEMENT:
{
const GstStructure *msgstruct = gst_message_get_structure (message);
if (msgstruct) {
const gchar *eventname = gst_structure_get_name (msgstruct);
if (!strcmp (eventname, "seekable"))
app->is_seekable = TRUE;
}
break;
}
case GST_MESSAGE_STATE_CHANGED:
{
GstState old_state, new_state;
GstStateChange transition;
if (GST_MESSAGE_SRC (message) != GST_OBJECT (app->tsdemux))
break;
gst_message_parse_state_changed (message, &old_state, &new_state, NULL);
transition = (GstStateChange) GST_STATE_TRANSITION (old_state, new_state);
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
{
}
break;
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
break;
case GST_STATE_CHANGE_READY_TO_NULL:
break;
}
break;
}
case GST_MESSAGE_SEGMENT_DONE:
{
GST_DEBUG ("GST_MESSAGE_SEGMENT_DONE!!!");
do_seek (app);
}
default:
break;
}
gst_element_get_state (app->pipeline, ¤t_state, NULL, 0);
if (app->current_segment == 0 && app->segment_count /*&& app->is_seekable*/
&& current_state == GST_STATE_PLAYING)
do_seek (app);
GST_DEBUG_BIN_TO_DOT_FILE(GST_BIN(app->pipeline),GST_DEBUG_GRAPH_SHOW_ALL,"bdremux_pipelinegraph_message");
return TRUE;
}
