bool QGstreamerGLTextureRenderer::processBusMessage(const QGstreamerMessage &message)
{
GstMessage* gm = message.rawMessage();
#ifdef GL_TEXTURE_SINK_DEBUG
qDebug() << Q_FUNC_INFO << GST_MESSAGE_TYPE_NAME(gm);
#endif
if (GST_MESSAGE_TYPE(gm) == GST_MESSAGE_STATE_CHANGED &&
GST_MESSAGE_SRC(gm) == GST_OBJECT_CAST(m_videoSink)) {
GstState oldState;
GstState newState;
gst_message_parse_state_changed(gm, &oldState, &newState, 0);
#ifdef GL_TEXTURE_SINK_DEBUG
qDebug() << Q_FUNC_INFO << "State changed:" << oldState << newState;
#endif
if (newState == GST_STATE_READY || newState == GST_STATE_NULL) {
stopRenderer();
}
if (oldState == GST_STATE_READY && newState == GST_STATE_PAUSED) {
updateNativeVideoSize();
}
}
return false;
}
/* Process messages from GStreamer */
static gboolean handle_message (GstBus *bus, GstMessage *msg, CustomData *data) {
GError *err;
gchar *debug_info;
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_ERROR:
gst_message_parse_error (msg, &err, &debug_info);
g_printerr ("Error received from element %s: %s\n", GST_OBJECT_NAME (msg->src), err->message);
g_printerr ("Debugging information: %s\n", debug_info ? debug_info : "none");
g_clear_error (&err);
g_free (debug_info);
g_main_loop_quit (data->main_loop);
break;
case GST_MESSAGE_EOS:
g_print ("End-Of-Stream reached.\n");
g_main_loop_quit (data->main_loop);
break;
case GST_MESSAGE_STATE_CHANGED: {
GstState old_state, new_state, pending_state;
gst_message_parse_state_changed (msg, &old_state, &new_state, &pending_state);
if (GST_MESSAGE_SRC (msg) == GST_OBJECT (data->playbin2)) {
if (new_state == GST_STATE_PLAYING) {
/* Once we are in the playing state, analyze the streams */
analyze_streams (data);
}
}
} break;
default:
break;
}
/* We want to keep receiving messages */
return TRUE;
}
MbEvent *
handle_state_change_message (GstMessage *message)
{
MbEvent *mb_event = NULL;
GstState old_state, new_state;
GstElement *source = (GstElement *) message->src;
gst_message_parse_state_changed (message, &old_state, &new_state, NULL);
if (new_state == GST_STATE_PLAYING)
{
if (source == _mb_global_data.pipeline)
{
g_mutex_lock (&(_mb_global_data.mutex));
if (_mb_global_data.initialized == FALSE)
{
if (_mb_global_data.clock_provider == NULL)
_mb_global_data.clock_provider =
gst_element_get_clock(_mb_global_data.pipeline);
_mb_global_data.initialized = TRUE;
mb_event = create_app_event (MB_APP_INIT_DONE);
}
g_mutex_unlock (&(_mb_global_data.mutex));
}
else
{
if (strcmp (G_OBJECT_TYPE_NAME(G_OBJECT (source)), "GstBin") == 0)
mb_event = create_state_change_event (MB_BEGIN,
GST_ELEMENT_NAME (source));
}
}
return mb_event;
}
/*!
* \brief handleMessage
* Handles gstreamer bus messages. Mainly for debugging purposes and ensuring clean shutdown on error
*/
void handleMessage(GstElement * pipeline)
{
GError *err = NULL;
gchar *debug = NULL;
GstBus* bus = NULL;
GstStreamStatusType tp;
GstElement * elem = NULL;
GstMessage* msg = NULL;
bus = gst_element_get_bus(pipeline);
while(gst_bus_have_pending(bus)) {
msg = gst_bus_pop(bus);
//printf("Got %s message\n", GST_MESSAGE_TYPE_NAME(msg));
if(gst_is_missing_plugin_message(msg))
{
//ERROR(1, "GStreamer: your gstreamer installation is missing a required plugin\n");
fprintf(stderr, "GStreamer: your gstreamer installation is missing a required plugin\n");
}
else
{
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_STATE_CHANGED:
GstState oldstate, newstate, pendstate;
gst_message_parse_state_changed(msg, &oldstate, &newstate, &pendstate);
//fprintf(stderr, "state changed from %s to %s (pending: %s)\n", gst_element_state_get_name(oldstate),
// gst_element_state_get_name(newstate), gst_element_state_get_name(pendstate));
break;
case GST_MESSAGE_ERROR:
gst_message_parse_error(msg, &err, &debug);
//fprintf(stderr, "GStreamer Plugin: Embedded video playback halted; module %s reported: %s\n",
// gst_element_get_name(GST_MESSAGE_SRC (msg)), err->message);
g_error_free(err);
g_free(debug);
gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_NULL);
break;
case GST_MESSAGE_EOS:
//fprintf(stderr, "reached the end of the stream.");
break;
case GST_MESSAGE_STREAM_STATUS:
gst_message_parse_stream_status(msg,&tp,&elem);
//fprintf(stderr, "stream status: elem %s, %i\n", GST_ELEMENT_NAME(elem), tp);
break;
default:
//fprintf(stderr, "unhandled message\n");
break;
}
}
gst_message_unref(msg);
}
gst_object_unref(GST_OBJECT(bus));
}
static void handle_message (CustomData *data, GstMessage *msg) {
GError *err;
gchar *debug_info;
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_ERROR:
gst_message_parse_error (msg, &err, &debug_info);
g_printerr ("Error received from element %s: %s\n", GST_OBJECT_NAME (msg->src), err->message);
g_printerr ("Debugging information: %s\n", debug_info ? debug_info : "none");
g_clear_error (&err);
g_free (debug_info);
data->terminate = TRUE;
break;
case GST_MESSAGE_EOS:
g_print ("End-Of-Stream reached.\n");
data->terminate = TRUE;
break;
case GST_MESSAGE_DURATION:
/* The duration has changed, mark the current one as invalid */
data->duration = GST_CLOCK_TIME_NONE;
break;
case GST_MESSAGE_STATE_CHANGED: {
GstState old_state, new_state, pending_state;
gst_message_parse_state_changed (msg, &old_state, &new_state, &pending_state);
if (GST_MESSAGE_SRC (msg) == GST_OBJECT (data->playbin2)) {
g_print ("Pipeline state changed from %s to %s:\n",
gst_element_state_get_name (old_state), gst_element_state_get_name (new_state));
/* Remember whether we are in the PLAYING state or not */
data->playing = (new_state == GST_STATE_PLAYING);
if (data->playing) {
/* We just moved to PLAYING. Check if seeking is possible */
GstQuery *query;
gint64 start, end;
query = gst_query_new_seeking (GST_FORMAT_TIME);
if (gst_element_query (data->playbin2, query)) {
gst_query_parse_seeking (query, NULL, &data->seek_enabled, &start, &end);
if (data->seek_enabled) {
g_print ("Seeking is ENABLED from %" GST_TIME_FORMAT " to %" GST_TIME_FORMAT "\n",
GST_TIME_ARGS (start), GST_TIME_ARGS (end));
} else {
g_print ("Seeking is DISABLED for this stream.\n");
}
}
else {
g_printerr ("Seeking query failed.");
}
gst_query_unref (query);
}
}
} break;
default:
/* We should not reach here */
g_printerr ("Unexpected message received.\n");
break;
}
gst_message_unref (msg);
}
static gboolean
bus_callback (GstBus * bus, GstMessage * message, gpointer data)
{
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_ERROR:{
GError *err;
gchar *debug;
gst_message_parse_error (message, &err, &debug);
g_print ("Error: %s\n", err->message);
g_error_free (err);
g_free (debug);
/* Write debug graph to file */
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (camerabin),
GST_DEBUG_GRAPH_SHOW_ALL, "camerabin.error");
g_main_loop_quit (loop);
break;
}
case GST_MESSAGE_STATE_CHANGED:
if (GST_IS_BIN (GST_MESSAGE_SRC (message))) {
GstState oldstate, newstate;
gst_message_parse_state_changed (message, &oldstate, &newstate, NULL);
GST_DEBUG_OBJECT (GST_MESSAGE_SRC (message), "state-changed: %s -> %s",
gst_element_state_get_name (oldstate),
gst_element_state_get_name (newstate));
}
break;
case GST_MESSAGE_EOS:
/* end-of-stream */
GST_INFO ("got eos() - should not happen");
g_main_loop_quit (loop);
break;
case GST_MESSAGE_ELEMENT:
if (GST_MESSAGE_SRC (message) == (GstObject *) camerabin) {
const GstStructure *structure = gst_message_get_structure (message);
if (gst_structure_has_name (structure, "image-done")) {
#ifndef GST_DISABLE_GST_DEBUG
const gchar *fname = gst_structure_get_string (structure, "filename");
GST_DEBUG ("image done: %s", fname);
#endif
if (capture_count < capture_total) {
g_idle_add ((GSourceFunc) run_pipeline, NULL);
} else {
g_main_loop_quit (loop);
}
}
}
break;
default:
/* unhandled message */
break;
}
return TRUE;
}
/* Notify UI about pipeline state changes */
static void state_changed_cb (GstBus *bus, GstMessage *msg, CustomData *data) {
GstState old_state, new_state, pending_state;
gst_message_parse_state_changed (msg, &old_state, &new_state, &pending_state);
/* Only pay attention to messages coming from the pipeline, not its children */
if (GST_MESSAGE_SRC (msg) == GST_OBJECT (data->pipeline)) {
gchar *message = g_strdup_printf("State changed to %s", gst_element_state_get_name(new_state));
set_ui_message(message, data);
g_free (message);
}
}
static gboolean bus_call (GstBus *bus,GstMessage *msg, gpointer data) {
if (gst_is_video_overlay_prepare_window_handle_message (msg)) {
if (0 != g_video_xid) {
GstVideoOverlay *overlay;
// GST_MESSAGE_SRC (message) will be the video sink element
overlay = GST_VIDEO_OVERLAY (GST_MESSAGE_SRC (msg));
gst_video_overlay_set_window_handle (overlay, g_video_xid);
} else {
g_warning ("Should have obtained video_window_handle by now!");
}
}
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_EOS:
g_print ("####################### Stream Ends\n");
gtk_main_quit();
break;
case GST_MESSAGE_ERROR: {
gchar *debug;
GError *error;
gst_message_parse_error (msg, &error, &debug);
g_free (debug);
g_printerr ("####################### Error: %s\n", error->message);
g_error_free (error);
gtk_main_quit();
break;
}
case GST_MESSAGE_STATE_CHANGED: {
GstState oldState;
GstState newState;
GstState pendingState;
gst_message_parse_state_changed(msg, &oldState, &newState, &pendingState);
g_printf("####################### oldState:%d, newState:%d, pendingState:%d!\n", oldState, newState, pendingState);
break;
}
case GST_MESSAGE_STREAM_STATUS: {
GstStreamStatusType statusType;
GstElement* owner = NULL;
gst_message_parse_stream_status(msg, &statusType, &owner);
g_printf("####################### statusType:%d, owner:%p!\n", statusType, owner);
break;
}
default:
break;
}
return TRUE;
}
void GStreamerBaseFrameSourceImpl::handleGStreamerMessages()
{
GstMessage* msg = NULL;
GError *err = NULL;
gchar *debug = NULL;
GstStreamStatusType tp;
GstElement * elem = NULL;
if (!bus)
return;
while (gst_bus_have_pending(bus))
{
msg = gst_bus_pop(bus);
if (gst_is_missing_plugin_message(msg))
{
printf("GStreamer: your gstreamer installation is missing a required plugin!\n");
end = true;
}
else
{
switch (GST_MESSAGE_TYPE(msg))
{
case GST_MESSAGE_STATE_CHANGED:
GstState oldstate, newstate, pendstate;
gst_message_parse_state_changed(msg, &oldstate, &newstate, &pendstate);
break;
case GST_MESSAGE_ERROR:
{
gst_message_parse_error(msg, &err, &debug);
std::unique_ptr<char[], GlibDeleter> name(gst_element_get_name(GST_MESSAGE_SRC (msg)));
printf("GStreamer Plugin: Embedded video playback halted; module %s reported: %s\n",
name.get(), err->message);
g_error_free(err);
g_free(debug);
end = true;
break;
}
case GST_MESSAGE_EOS:
end = true;
break;
case GST_MESSAGE_STREAM_STATUS:
gst_message_parse_stream_status(msg,&tp,&elem);
break;
default:
break;
}
}
gst_message_unref(msg);
}
}
static void
manage_state_change(GstMessage *msg, GstElement *pipeline) {
GstState old_state, new_state, pending_state;
gst_message_parse_state_changed(msg, &old_state, &new_state, &pending_state);
if (msg->src == GST_OBJECT(pipeline) &&
new_state == GST_STATE_PAUSED && ! looping) {
/* the pipeline is ready for the initial loop to be set*/
set_up_loop(pipeline, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SEGMENT);
looping = TRUE;
}
}
/* This function is called when the pipeline changes states. We use it to
* keep track of the current state. */
static void state_changed_cb (GstBus *bus, GstMessage *msg, CustomData *data) {
GstState old_state, new_state, pending_state;
gst_message_parse_state_changed (msg, &old_state, &new_state, &pending_state);
if (GST_MESSAGE_SRC (msg) == GST_OBJECT (data->playbin)) {
data->state = new_state;
g_print ("State set to %s\n", gst_element_state_get_name (new_state));
if (old_state == GST_STATE_READY && new_state == GST_STATE_PAUSED) {
/* For extra responsiveness, we refresh the GUI as soon as we reach the PAUSED state */
refresh_ui (data);
}
}
}
static VALUE
state_changed_parse(VALUE self)
{
GstState old_state, new_state, pending_state;
gst_message_parse_state_changed(SELF(self),
&old_state, &new_state, &pending_state);
return rb_ary_new3(3,
GST_STATE2RVAL(old_state),
GST_STATE2RVAL(new_state),
GST_STATE2RVAL(pending_state));
}
static void
state_cb (GstBus * bus, GstMessage * msg, PlayState * state)
{
if (msg->src == GST_OBJECT (state->pipe)) {
GstState old_state, new_state, pending_state;
gst_message_parse_state_changed (msg, &old_state, &new_state,
&pending_state);
if (new_state == GST_STATE_PLAYING)
g_print ("Decoding ...\n");
}
}
static void
state_changed_cb (GstBus * bus, GstMessage * msg, APP_STATE_T * state)
{
GstState old_state, new_state, pending_state;
if (GST_MESSAGE_SRC (msg) == GST_OBJECT (state->pipeline)) {
gst_message_parse_state_changed (msg, &old_state, &new_state,
&pending_state);
g_print ("State changed to %s\n", gst_element_state_get_name (new_state));
if (old_state == GST_STATE_PAUSED && new_state == GST_STATE_READY) {
g_main_loop_quit (state->main_loop);
}
}
}
static GstBusSyncReply
bus_sync_signal_handler (GstBus * bus, GstMessage * msg, gpointer data)
{
KmsRecorderEndpoint *self = KMS_RECORDER_ENDPOINT (data);
if (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_ERROR) {
ErrorData *data;
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (self),
GST_DEBUG_GRAPH_SHOW_ALL, GST_ELEMENT_NAME (self));
kms_base_media_muxer_dot_file (self->priv->mux);
GST_ERROR_OBJECT (self, "Message %" GST_PTR_FORMAT, msg);
data = create_error_data (self, msg);
GST_ERROR_OBJECT (self, "Error: %" GST_PTR_FORMAT, msg);
gst_task_pool_push (self->priv->pool, kms_recorder_endpoint_post_error,
data, NULL);
} else if (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_EOS) {
gst_task_pool_push (self->priv->pool, kms_recorder_endpoint_on_eos_message,
self, NULL);
} else if ((GST_MESSAGE_TYPE (msg) == GST_MESSAGE_STATE_CHANGED)
&& (GST_OBJECT_CAST (KMS_BASE_MEDIA_MUXER_GET_PIPELINE (self->
priv->mux)) == GST_MESSAGE_SRC (msg))) {
GstState new_state, pending;
gst_message_parse_state_changed (msg, NULL, &new_state, &pending);
if (pending == GST_STATE_VOID_PENDING || (pending == GST_STATE_NULL
&& new_state == GST_STATE_READY)) {
GST_DEBUG_OBJECT (self, "Pipeline changed state to %d", new_state);
switch (new_state) {
case GST_STATE_PLAYING:
kms_recorder_endpoint_state_changed (self,
KMS_URI_ENDPOINT_STATE_START);
break;
case GST_STATE_READY:
kms_recorder_endpoint_state_changed (self,
KMS_URI_ENDPOINT_STATE_STOP);
break;
default:
GST_DEBUG_OBJECT (self, "Not raising event");
break;
}
}
}
return GST_BUS_PASS;
}
static gboolean audioBusMessage(GstBus * /*bus*/, GstMessage *message, gpointer data)
{
GstState old_state, new_state;
if ((GST_MESSAGE_TYPE(message) == GST_MESSAGE_STATE_CHANGED) &&
((GstElement *)(message->src) == ((AVMuxEncode *)data)->m_audioPipeline)){
gst_message_parse_state_changed (message, &old_state, &new_state, NULL);
g_print ("Audio element %s changed state from %s to %s.\n",
GST_OBJECT_NAME (message->src),
gst_element_state_get_name (old_state),
gst_element_state_get_name (new_state));
}
return TRUE;
}
bool QGstreamerVideoWidgetControl::processBusMessage(const QGstreamerMessage &message)
{
GstMessage* gm = message.rawMessage();
if (GST_MESSAGE_TYPE(gm) == GST_MESSAGE_STATE_CHANGED &&
GST_MESSAGE_SRC(gm) == GST_OBJECT_CAST(m_videoSink)) {
GstState oldState;
GstState newState;
gst_message_parse_state_changed(gm, &oldState, &newState, 0);
if (oldState == GST_STATE_READY && newState == GST_STATE_PAUSED)
updateNativeVideoSize();
}
return false;
}
static gboolean
bus_call(GstBus *bus,
GstMessage *msg,
gpointer data)
{
GMainLoop *loop = (GMainLoop *)data;
GstState old_state, new_state;
switch (GST_MESSAGE_TYPE(msg)) {
case GST_MESSAGE_STATE_CHANGED:
gst_message_parse_state_changed (msg, &old_state, &new_state, NULL);
if(msg->src == GST_OBJECT(app.pipeline) && new_state == GST_STATE_READY && old_state == GST_STATE_NULL) {
g_debug ("Element %s changed state from %s to %s.\n",
GST_OBJECT_NAME (msg->src),
gst_element_state_get_name (old_state),
gst_element_state_get_name (new_state));
if(app.ready_callback) {
app.ready_callback();
}
}
break;
case GST_MESSAGE_EOS:
g_warning("End of stream\n");
g_main_loop_quit(loop);
break;
case GST_MESSAGE_ERROR: {
gchar *debug;
GError *error;
gst_message_parse_error(msg, &error, &debug);
// g_free(debug);
g_printerr("Error: %s\n", error->message);
g_printerr("Debug: %s\n", debug);
g_error_free(error);
g_main_loop_quit(loop);
break;
}
default:
break;
}
return TRUE;
}
gboolean bus_callback(GstBus* sender, GstMessage* message, void* data)
{
gPlay* gplay = reinterpret_cast<gPlay*> (data);
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_STATE_CHANGED:
{
GstState newState;
gst_message_parse_state_changed(message, NULL, &newState, NULL);
std::string message_name(GST_MESSAGE_SRC_NAME(message));//TODO: Avoid this copy using glib
if (message_name.compare("playbin") == 0){
gplay->on_state_changed(newState);
}
}
break;
case GST_MESSAGE_TAG:
{
GstTagList* tag_list = 0;
gst_message_parse_tag(message, &tag_list);
Track t;
track_from_tag(tag_list, &t);
gplay->on_tag_found(t);
gst_tag_list_free(tag_list);
}
break;
case GST_MESSAGE_EOS:
gplay->on_eos();
break;
case GST_MESSAGE_STREAM_STATUS:
GstStreamStatusType message_type;
gst_message_parse_stream_status(message, &message_type, NULL);
g_print("Stream status: %d\n", message_type);
break;
default:
g_print("Message from %s: %s\n", GST_MESSAGE_SRC_NAME(message), gst_message_type_get_name(GST_MESSAGE_TYPE(message)));
break;
}
//TODO: Should I dispose message?
return true;
}
static void
_check_message_received (GstBus * bus, GstMessage * message, gpointer user_data)
{
GMainLoop *main_loop = (GMainLoop *) user_data;
GST_DEBUG_OBJECT (GST_MESSAGE_SRC (message), "%s: %" GST_PTR_FORMAT,
GST_MESSAGE_TYPE_NAME (message), message);
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_STATE_CHANGED:
if (GST_IS_PIPELINE (GST_MESSAGE_SRC (message))) {
GstState oldstate, newstate, pending;
gst_message_parse_state_changed (message, &oldstate, &newstate,
&pending);
switch (GST_STATE_TRANSITION (oldstate, newstate)) {
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
goto done;
break;
default:
break;
}
}
break;
case GST_MESSAGE_ERROR:
GST_WARNING_OBJECT (GST_MESSAGE_SRC (message), "error: %" GST_PTR_FORMAT,
message);
_check_run_main_loop_error = TRUE;
goto done;
case GST_MESSAGE_SEGMENT_DONE:
case GST_MESSAGE_EOS:
if (GST_IS_PIPELINE (GST_MESSAGE_SRC (message))) {
GST_INFO_OBJECT (GST_MESSAGE_SRC (message), "%s: %" GST_PTR_FORMAT,
GST_MESSAGE_TYPE_NAME (message), message);
goto done;
}
break;
default:
GST_WARNING_OBJECT (GST_MESSAGE_SRC (message), "unexpected messges: %s",
GST_MESSAGE_TYPE_NAME (message));
}
return;
done:
if (g_main_loop_is_running (main_loop))
g_main_loop_quit (main_loop);
}
static gboolean bus_call (GstBus *bus,GstMessage *msg, gpointer data){
GMainLoop *loop = (GMainLoop *) data;
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_EOS:
g_print ("Stream Ends\n");
g_main_loop_quit (loop);
break;
case GST_MESSAGE_ERROR: {
gchar *debug;
GError *error;
gst_message_parse_error (msg, &error, &debug);
g_free (debug);
g_printerr ("Error: %s\n", error->message);
g_error_free (error);
g_main_loop_quit (loop);
break;
}
case GST_MESSAGE_STATE_CHANGED: {
GstState oldState;
GstState newState;
GstState pendingState;
gst_message_parse_state_changed(msg, &oldState, &newState, &pendingState);
g_printf("oldState:%d, newState:%d, pendingState:%d!\n", oldState, newState, pendingState);
break;
}
case GST_MESSAGE_STREAM_STATUS: {
GstStreamStatusType statusType;
GstElement* owner = NULL;
gst_message_parse_stream_status(msg, &statusType, &owner);
g_printf("statusType:%d, owner:%p!\n", statusType, owner);
break;
}
default:
break;
}
return TRUE;
}
static gboolean
gst_bus_message (GstBus * bus, GstMessage * message, void *unused)
{
(void)bus;
(void)unused;
DEBUGF(" [gst] got BUS message %s\n",
gst_message_type_get_name (GST_MESSAGE_TYPE (message)));
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_ERROR:
{
GError *err;
gchar *debug;
gst_message_parse_error (message, &err, &debug);
DEBUGF("[gst] Received error: Src: %s, msg: %s\n", GST_MESSAGE_SRC_NAME(message), err->message);
g_error_free (err);
g_free (debug);
}
g_main_loop_quit (pcm_loop);
break;
case GST_MESSAGE_EOS:
gst_element_set_state (GST_ELEMENT(gst_pipeline), GST_STATE_NULL);
break;
case GST_MESSAGE_STATE_CHANGED:
{
GstState old_state, new_state;
gst_message_parse_state_changed (message, &old_state, &new_state, NULL);
DEBUGF("[gst] Element %s changed state from %s to %s.\n",
GST_MESSAGE_SRC_NAME(message),
gst_element_state_get_name (old_state),
gst_element_state_get_name (new_state));
break;
}
default:
break;
}
return TRUE;
}
void CvCapture_GStreamer::handleMessage()
{
GstBus* bus = gst_element_get_bus(pipeline);
while(gst_bus_have_pending(bus)) {
GstMessage* msg = gst_bus_pop(bus);
// printf("Got %s message\n", GST_MESSAGE_TYPE_NAME(msg));
switch (GST_MESSAGE_TYPE (msg)) {
case GST_MESSAGE_STATE_CHANGED:
GstState oldstate, newstate, pendstate;
gst_message_parse_state_changed(msg, &oldstate, &newstate, &pendstate);
// printf("state changed from %d to %d (%d)\n", oldstate, newstate, pendstate);
break;
case GST_MESSAGE_ERROR: {
GError *err;
gchar *debug;
gst_message_parse_error(msg, &err, &debug);
fprintf(stderr, "GStreamer Plugin: Embedded video playback halted; module %s reported: %s\n",
gst_element_get_name(GST_MESSAGE_SRC (msg)), err->message);
g_error_free(err);
g_free(debug);
gst_element_set_state(pipeline, GST_STATE_NULL);
break;
}
case GST_MESSAGE_EOS:
// CV_WARN("NetStream has reached the end of the stream.");
break;
default:
// CV_WARN("unhandled message\n");
break;
}
gst_message_unref(msg);
}
gst_object_unref(GST_OBJECT(bus));
}
void GstPlayer::handleStateChangeMessage(GstMessage *msg){
GstState old_state, new_state;
gst_message_parse_state_changed (msg, &old_state, &new_state, NULL);
QString objectNamePlayer = gstObjectName;
if( objectNamePlayer == GST_OBJECT_NAME (msg->src)){
if(new_state == GST_STATE_PLAYING || old_state == GST_STATE_PLAYING){
QLOG_TRACE() << "[GST] "<< this <<
gst_element_state_get_name (old_state) <<
"->"<< gst_element_state_get_name (new_state);
}
switch(new_state){
case GST_STATE_VOID_PENDING:
loaded=false;
playing=false;
break;
case GST_STATE_READY:
loaded=true;
playing=false;
break;
case GST_STATE_NULL:
loaded=false;
playing=false;
break;
case GST_STATE_PAUSED:
loaded=true;
playing=false;
if(playingRequested){
QLOG_TRACE() << "Queued request. Ask to play!";
playingRequested = false;
this->requestPlay();
}
break;
case GST_STATE_PLAYING:
loaded=true;
playing=true;
break;
}
//QLOG_TRACE() << "GstPlayer: emit state change";
this->stateChanged();
}
}
void state_changed_cb(GstBus *bus, GstMessage *msg, CustomData *data)
{
GstState old_state, new_state, pending_state;
gst_message_parse_state_changed(msg, &old_state, &new_state, &pending_state);
/* Only pay attention to messages coming from the pipeline, not its children */
if (GST_MESSAGE_SRC(msg) == GST_OBJECT(data->pipeline))
{
data->state = new_state;
if (new_state == GST_STATE_PLAYING)
{
data->buffering_time = 0;
gplayer_playback_running(data);
if (GST_CLOCK_TIME_IS_VALID(data->desired_position))
{
execute_seek(data->desired_position, data);
}
}
}
}
/* This function is called when the pipeline changes states. We use it to
* keep track of the current state. */
static void state_changed_cb (GstBus *bus, GstMessage *msg, CustomData *data) {
GstState old_state, new_state, pending_state;
gst_message_parse_state_changed (msg, &old_state, &new_state, &pending_state);
if (GST_MESSAGE_SRC (msg) == GST_OBJECT (data->pipeline)) {
data->state = new_state;
g_print ("State set to %s\n", gst_element_state_get_name (new_state));
/* update playPauseImage */
if (data->state == GST_STATE_PAUSED || data->state == GST_STATE_READY) {
_set_playPauseImage(data, GTK_STOCK_MEDIA_PLAY);
} else {
_set_playPauseImage(data, GTK_STOCK_MEDIA_PAUSE);
}
if (old_state == GST_STATE_READY && new_state == GST_STATE_PAUSED) {
/* For extra responsiveness, we refresh the GUI as soon as we reach the PAUSED state */
refresh_ui (data);
}
}
}
static gboolean
bus_callback (GstBus * bus, GstMessage * message, gpointer data)
{
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_ERROR:{
GError *err;
gchar *debug;
gst_message_parse_error (message, &err, &debug);
g_print ("Error: %s\n", err->message);
g_error_free (err);
g_free (debug);
/* Write debug graph to file */
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (camera_bin),
GST_DEBUG_GRAPH_SHOW_ALL, "camerabin.error");
g_main_loop_quit (loop);
break;
}
case GST_MESSAGE_STATE_CHANGED:
if (GST_IS_BIN (GST_MESSAGE_SRC (message))) {
GstState oldstate, newstate;
gst_message_parse_state_changed (message, &oldstate, &newstate, NULL);
GST_DEBUG_OBJECT (GST_MESSAGE_SRC (message), "state-changed: %s -> %s",
gst_element_state_get_name (oldstate),
gst_element_state_get_name (newstate));
}
break;
case GST_MESSAGE_EOS:
/* end-of-stream */
GST_INFO ("got eos() - should not happen");
g_main_loop_quit (loop);
break;
default:
/* unhandled message */
break;
}
return TRUE;
}
static gboolean mybusfunc(GstBus *bus, GstMessage *message, gpointer user_data)
{
GMainLoop *loop = (GMainLoop *) user_data;
GstState prev_state, curr_state;
GError *err = NULL;
gchar *debug_info = NULL;
g_print("Got %s\n", GST_MESSAGE_TYPE_NAME(message));
switch (GST_MESSAGE_TYPE(message)) {
case GST_MESSAGE_EOS:
g_print("End of stream\n");
g_main_loop_quit(loop);
break;
case GST_MESSAGE_ERROR:
gst_message_parse_error(message, &err, &debug_info);
g_printerr("Error from element %s: %s\n", GST_OBJECT_NAME(message->src), err->message);
g_printerr("Debugging info: %s\n", (debug_info) ? debug_info : "none");
g_error_free(err);
g_free(debug_info);
g_main_loop_quit(loop);
break;
case GST_MESSAGE_STATE_CHANGED:
gst_message_parse_state_changed(message, &prev_state, &curr_state, NULL);
g_print("Element %s changed from %s to %s\n",
GST_OBJECT_NAME(message->src),
gst_element_state_get_name(prev_state),
gst_element_state_get_name(curr_state));
break;
default:
g_print("Unhandled messages");
break;
}
g_print("\n");
return TRUE;
}
/* Notify UI about pipeline state changes */
static void state_changed_cb (GstBus *bus, GstMessage *msg, CustomData *data) {
GstState old_state, new_state, pending_state;
gst_message_parse_state_changed (msg, &old_state, &new_state, &pending_state);
/* Only pay attention to messages coming from the pipeline, not its children */
if (GST_MESSAGE_SRC (msg) == GST_OBJECT (data->pipeline)) {
data->state = new_state;
gchar *message = g_strdup_printf("State changed to %s", gst_element_state_get_name(new_state));
set_ui_message(message, data);
g_free (message);
/* The Ready to Paused state change is particularly interesting: */
if (old_state == GST_STATE_READY && new_state == GST_STATE_PAUSED) {
/* By now the sink already knows the media size */
check_media_size(data);
/* If there was a scheduled seek, perform it now that we have moved to the Paused state */
if (GST_CLOCK_TIME_IS_VALID (data->desired_position))
execute_seek (data->desired_position, data);
}
}
}
void GstEnginePipeline::StateChangedMessageReceived(GstMessage* msg) {
if (msg->src != GST_OBJECT(pipeline_)) {
// We only care about state changes of the whole pipeline.
return;
}
GstState old_state, new_state, pending;
gst_message_parse_state_changed(msg, &old_state, &new_state, &pending);
if (!pipeline_is_initialised_ && (new_state == GST_STATE_PAUSED || new_state == GST_STATE_PLAYING)) {
pipeline_is_initialised_ = true;
if (pending_seek_nanosec_ != -1 && pipeline_is_connected_) {
QMetaObject::invokeMethod(this, "Seek", Qt::QueuedConnection,
Q_ARG(qint64, pending_seek_nanosec_));
}
}
if (pipeline_is_initialised_ && new_state != GST_STATE_PAUSED && new_state != GST_STATE_PLAYING) {
pipeline_is_initialised_ = false;
}
}