static gboolean gst_raw_parse_sink_activate (GstPad * sinkpad) { if (gst_pad_check_pull_range (sinkpad)) { GST_RAW_PARSE (GST_PAD_PARENT (sinkpad))->mode = GST_ACTIVATE_PULL; return gst_pad_activate_pull (sinkpad, TRUE); } else { GST_RAW_PARSE (GST_PAD_PARENT (sinkpad))->mode = GST_ACTIVATE_PUSH; return gst_pad_activate_push (sinkpad, TRUE); } }
static GstStateChangeReturn gst_raw_parse_change_state (GstElement * element, GstStateChange transition) { GstRawParse *rp = GST_RAW_PARSE (element); GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; switch (transition) { case GST_STATE_CHANGE_READY_TO_PAUSED: gst_segment_init (&rp->segment, GST_FORMAT_TIME); rp->segment.position = 0; default: break; } if (GST_ELEMENT_CLASS (parent_class)->change_state) ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PAUSED_TO_READY: gst_raw_parse_reset (rp); break; default: break; } return ret; }
static gboolean gst_raw_parse_sink_activatepull (GstPad * sinkpad, gboolean active) { GstRawParse *rp = GST_RAW_PARSE (gst_pad_get_parent (sinkpad)); gboolean result; if (active) { GstFormat format; gint64 duration; /* get the duration in bytes */ format = GST_FORMAT_BYTES; result = gst_pad_query_peer_duration (sinkpad, &format, &duration); if (result) { GST_DEBUG_OBJECT (rp, "got duration %" GST_TIME_FORMAT, GST_TIME_ARGS (duration)); rp->upstream_length = duration; /* convert to time */ gst_raw_parse_convert (rp, format, duration, GST_FORMAT_TIME, &duration); } else { rp->upstream_length = -1; duration = -1; } gst_segment_set_duration (&rp->segment, GST_FORMAT_TIME, duration); result = gst_raw_parse_handle_seek_pull (rp, NULL); } else { result = gst_pad_stop_task (sinkpad); } gst_object_unref (rp); return result; }
void gst_audio_parse_update_frame_size (GstAudioParse * ap) { gint framesize, width; switch (ap->format) { case GST_AUDIO_PARSE_FORMAT_ALAW: case GST_AUDIO_PARSE_FORMAT_MULAW: width = 8; break; case GST_AUDIO_PARSE_FORMAT_RAW: default: { GstAudioInfo info; gst_audio_info_init (&info); /* rate, etc do not really matter here */ gst_audio_info_set_format (&info, ap->raw_format, 44100, ap->channels, NULL); width = GST_AUDIO_INFO_WIDTH (&info); break; } } framesize = (width / 8) * ap->channels; gst_raw_parse_set_framesize (GST_RAW_PARSE (ap), framesize); }
static gboolean gst_raw_parse_sink_event (GstPad * pad, GstObject * parent, GstEvent * event) { GstRawParse *rp = GST_RAW_PARSE (parent); gboolean ret; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_EOS: case GST_EVENT_FLUSH_STOP: /* Only happens in push mode */ gst_raw_parse_reset (rp); ret = gst_pad_push_event (rp->srcpad, event); break; case GST_EVENT_SEGMENT: { GstSegment segment; /* Only happens in push mode */ gst_event_copy_segment (event, &segment); if (segment.format != GST_FORMAT_TIME) { gst_event_unref (event); ret = gst_raw_parse_convert (rp, segment.format, segment.start, GST_FORMAT_TIME, (gint64 *) & segment.start); ret &= gst_raw_parse_convert (rp, segment.format, segment.time, GST_FORMAT_TIME, (gint64 *) & segment.time); ret &= gst_raw_parse_convert (rp, segment.format, segment.stop, GST_FORMAT_TIME, (gint64 *) & segment.stop); if (!ret) { GST_ERROR_OBJECT (rp, "Failed converting to GST_FORMAT_TIME format (%d)", segment.format); break; } segment.format = GST_FORMAT_TIME; event = gst_event_new_segment (&segment); } gst_segment_copy_into (&segment, &rp->segment); if (rp->start_segment) gst_event_unref (rp->start_segment); rp->start_segment = event; ret = TRUE; break; } default: ret = gst_pad_event_default (pad, parent, event); break; } return ret; }
static void gst_audio_parse_init (GstAudioParse * ap) { ap->format = GST_AUDIO_PARSE_FORMAT_RAW; ap->raw_format = GST_AUDIO_FORMAT_S16; ap->channels = 2; ap->interleaved = TRUE; gst_audio_parse_update_frame_size (ap); gst_raw_parse_set_fps (GST_RAW_PARSE (ap), 44100, 1); }
static void gst_raw_parse_dispose (GObject * object) { GstRawParse *rp = GST_RAW_PARSE (object); if (rp->adapter) { g_object_unref (rp->adapter); rp->adapter = NULL; } G_OBJECT_CLASS (parent_class)->dispose (object); }
void gst_video_parse_update_frame_size (GstVideoParse * vp) { gint framesize; GstVideoInfo info; gst_video_info_init (&info); gst_video_info_set_format (&info, vp->format, vp->width, vp->height); framesize = GST_VIDEO_INFO_SIZE (&info); gst_raw_parse_set_framesize (GST_RAW_PARSE (vp), framesize); }
static void gst_video_parse_init (GstVideoParse * vp) { vp->width = 320; vp->height = 240; vp->format = GST_VIDEO_FORMAT_I420; vp->par_n = 1; vp->par_d = 1; gst_video_parse_update_frame_size (vp); gst_raw_parse_set_fps (GST_RAW_PARSE (vp), 25, 1); }
static void gst_audio_parse_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstAudioParse *ap = GST_AUDIO_PARSE (object); g_return_if_fail (!gst_raw_parse_is_negotiated (GST_RAW_PARSE (ap))); switch (prop_id) { case PROP_FORMAT: ap->format = g_value_get_enum (value); break; case PROP_RAW_FORMAT: ap->raw_format = g_value_get_enum (value); break; case PROP_RATE: gst_raw_parse_set_fps (GST_RAW_PARSE (ap), g_value_get_int (value), 1); break; case PROP_CHANNELS: ap->channels = g_value_get_int (value); break; case PROP_INTERLEAVED: ap->interleaved = g_value_get_boolean (value); break; case PROP_CHANNEL_POSITIONS: if (ap->channel_positions) g_value_array_free (ap->channel_positions); ap->channel_positions = g_value_dup_boxed (value); break; case PROP_USE_SINK_CAPS: ap->use_sink_caps = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } gst_audio_parse_update_frame_size (ap); }
static void gst_video_parse_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstVideoParse *vp = GST_VIDEO_PARSE (object); g_return_if_fail (!gst_raw_parse_is_negotiated (GST_RAW_PARSE (vp))); switch (prop_id) { case PROP_FORMAT: vp->format = g_value_get_enum (value); break; case PROP_WIDTH: vp->width = g_value_get_int (value); break; case PROP_HEIGHT: vp->height = g_value_get_int (value); break; case PROP_FRAMERATE: gst_raw_parse_set_fps (GST_RAW_PARSE (vp), gst_value_get_fraction_numerator (value), gst_value_get_fraction_denominator (value)); break; case PROP_PAR: vp->par_n = gst_value_get_fraction_numerator (value); vp->par_d = gst_value_get_fraction_denominator (value); break; case PROP_INTERLACED: vp->interlaced = g_value_get_boolean (value); break; case PROP_TOP_FIELD_FIRST: vp->top_field_first = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } gst_video_parse_update_frame_size (vp); }
static GstFlowReturn gst_raw_parse_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer) { GstRawParse *rp = GST_RAW_PARSE (parent); GstFlowReturn ret = GST_FLOW_OK; GstRawParseClass *rp_class = GST_RAW_PARSE_GET_CLASS (rp); guint buffersize, available; if (G_UNLIKELY (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT))) { GST_DEBUG_OBJECT (rp, "received DISCONT buffer"); gst_adapter_clear (rp->adapter); rp->discont = TRUE; } if (!gst_raw_parse_set_src_caps (rp)) goto no_caps; if (rp->start_segment) { GST_DEBUG_OBJECT (rp, "sending start segment"); gst_pad_push_event (rp->srcpad, rp->start_segment); rp->start_segment = NULL; } gst_adapter_push (rp->adapter, buffer); available = gst_adapter_available (rp->adapter); if (rp_class->multiple_frames_per_buffer) { buffersize = available; buffersize -= buffersize % rp->framesize; } else { buffersize = rp->framesize; } while (buffersize > 0 && gst_adapter_available (rp->adapter) >= buffersize) { buffer = gst_adapter_take_buffer (rp->adapter, buffersize); ret = gst_raw_parse_push_buffer (rp, buffer); if (ret != GST_FLOW_OK) break; } done: return ret; /* ERRORS */ no_caps: { GST_ERROR_OBJECT (rp, "could not set caps"); ret = GST_FLOW_NOT_NEGOTIATED; goto done; } }
static gboolean gst_raw_parse_sink_activatemode (GstPad * sinkpad, GstObject * parent, GstPadMode mode, gboolean active) { GstRawParse *rp = GST_RAW_PARSE (parent); gboolean result; switch (mode) { case GST_PAD_MODE_PULL: if (active) { GstFormat format; gint64 duration; /* get the duration in bytes */ format = GST_FORMAT_BYTES; result = gst_pad_peer_query_duration (sinkpad, format, &duration); if (result) { GST_DEBUG_OBJECT (rp, "got duration %" GST_TIME_FORMAT, GST_TIME_ARGS (duration)); rp->upstream_length = duration; /* convert to time */ gst_raw_parse_convert (rp, format, duration, GST_FORMAT_TIME, &duration); } else { rp->upstream_length = -1; duration = -1; } rp->segment.duration = duration; rp->push_stream_start = TRUE; result = gst_raw_parse_handle_seek_pull (rp, NULL); rp->mode = mode; } else { result = gst_pad_stop_task (sinkpad); } return result; case GST_PAD_MODE_PUSH: rp->mode = mode; return TRUE; default: return FALSE; } }
static gboolean gst_raw_parse_src_event (GstPad * pad, GstObject * parent, GstEvent * event) { GstRawParse *rp = GST_RAW_PARSE (parent); gboolean ret; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_SEEK: if (rp->mode == GST_PAD_MODE_PUSH) ret = gst_raw_parse_handle_seek_push (rp, event); else ret = gst_raw_parse_handle_seek_pull (rp, event); break; default: ret = gst_pad_event_default (rp->srcpad, parent, event); break; } return ret; }
static gboolean gst_raw_parse_src_event (GstPad * pad, GstEvent * event) { GstRawParse *rp = GST_RAW_PARSE (gst_pad_get_parent (pad)); gboolean ret; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_SEEK: if (rp->mode == GST_ACTIVATE_PUSH) ret = gst_raw_parse_handle_seek_push (rp, event); else ret = gst_raw_parse_handle_seek_pull (rp, event); break; default: ret = gst_pad_event_default (rp->srcpad, event); break; } gst_object_unref (rp); return ret; }
static void gst_video_parse_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstVideoParse *vp = GST_VIDEO_PARSE (object); switch (prop_id) { case PROP_FORMAT: g_value_set_enum (value, vp->format); break; case PROP_WIDTH: g_value_set_int (value, vp->width); break; case PROP_HEIGHT: g_value_set_int (value, vp->height); break; case PROP_FRAMERATE:{ gint fps_n, fps_d; gst_raw_parse_get_fps (GST_RAW_PARSE (vp), &fps_n, &fps_d); gst_value_set_fraction (value, fps_n, fps_d); break; } case PROP_PAR: gst_value_set_fraction (value, vp->par_n, vp->par_d); break; case PROP_INTERLACED: g_value_set_boolean (value, vp->interlaced); break; case PROP_TOP_FIELD_FIRST: g_value_set_boolean (value, vp->top_field_first); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_audio_parse_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstAudioParse *ap = GST_AUDIO_PARSE (object); switch (prop_id) { case PROP_FORMAT: g_value_set_enum (value, ap->format); break; case PROP_RAW_FORMAT: g_value_set_enum (value, ap->raw_format); break; case PROP_RATE:{ gint fps_n, fps_d; gst_raw_parse_get_fps (GST_RAW_PARSE (ap), &fps_n, &fps_d); g_value_set_int (value, fps_n); break; } case PROP_CHANNELS: g_value_set_int (value, ap->channels); break; case PROP_INTERLEAVED: g_value_set_boolean (value, ap->interleaved); break; case PROP_CHANNEL_POSITIONS: g_value_set_boxed (value, ap->channel_positions); break; case PROP_USE_SINK_CAPS: g_value_set_boolean (value, ap->use_sink_caps); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static GstCaps * gst_audio_parse_get_caps (GstRawParse * rp) { GstAudioParse *ap = GST_AUDIO_PARSE (rp); GstCaps *caps, *ncaps; GstAudioInfo info; gint fps_n, fps_d; const GValue *val; if (ap->use_sink_caps) { gint rate; GstCaps *caps = gst_pad_get_current_caps (rp->sinkpad); gst_audio_info_from_caps (&info, caps); rate = GST_AUDIO_INFO_RATE (&info); gst_raw_parse_set_fps (GST_RAW_PARSE (ap), rate, 1); return caps; } gst_raw_parse_get_fps (rp, &fps_n, &fps_d); gst_audio_parse_setup_channel_positions (ap); /* yes, even when format not raw */ gst_audio_info_init (&info); gst_audio_info_set_format (&info, ap->raw_format, fps_n, ap->channels, ap->channel_order); info.layout = ap->interleaved ? GST_AUDIO_LAYOUT_INTERLEAVED : GST_AUDIO_LAYOUT_NON_INTERLEAVED; caps = gst_audio_info_to_caps (&info); switch (ap->format) { case GST_AUDIO_PARSE_FORMAT_RAW: break; case GST_AUDIO_PARSE_FORMAT_ALAW: ncaps = gst_caps_new_simple ("audio/x-alaw", "rate", G_TYPE_INT, fps_n, "channels", G_TYPE_INT, ap->channels, NULL); /* pick mask stuff from faked raw format */ val = gst_structure_get_value (gst_caps_get_structure (caps, 0), "channel-mask"); if (val) gst_caps_set_value (ncaps, "channel-mask", val); gst_caps_unref (caps); caps = ncaps; break; case GST_AUDIO_PARSE_FORMAT_MULAW: ncaps = gst_caps_new_simple ("audio/x-mulaw", "rate", G_TYPE_INT, fps_n, "channels", G_TYPE_INT, ap->channels, NULL); /* pick mask stuff from faked raw format */ val = gst_structure_get_value (gst_caps_get_structure (caps, 0), "channel-mask"); if (val) gst_caps_set_value (ncaps, "channel-mask", val); gst_caps_unref (caps); caps = ncaps; break; default: caps = gst_caps_new_empty (); GST_ERROR_OBJECT (rp, "unexpected format %d", ap->format); break; } return caps; }
static gboolean gst_raw_parse_sink_event (GstPad * pad, GstEvent * event) { GstRawParse *rp = GST_RAW_PARSE (gst_pad_get_parent (pad)); gboolean ret; switch (GST_EVENT_TYPE (event)) { case GST_EVENT_EOS: case GST_EVENT_FLUSH_STOP: /* Only happens in push mode */ gst_raw_parse_reset (rp); ret = gst_pad_push_event (rp->srcpad, event); break; case GST_EVENT_NEWSEGMENT: { GstClockTimeDiff start, stop, time; gdouble rate, arate; gboolean update; GstFormat format; /* Only happens in push mode */ gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format, &start, &stop, &time); if (format == GST_FORMAT_TIME) { gst_segment_set_newsegment_full (&rp->segment, update, rate, arate, GST_FORMAT_TIME, start, stop, time); ret = gst_pad_push_event (rp->srcpad, event); } else { gst_event_unref (event); ret = gst_raw_parse_convert (rp, format, start, GST_FORMAT_TIME, &start); ret &= gst_raw_parse_convert (rp, format, time, GST_FORMAT_TIME, &time); ret &= gst_raw_parse_convert (rp, format, stop, GST_FORMAT_TIME, &stop); if (!ret) { GST_ERROR_OBJECT (rp, "Failed converting to GST_FORMAT_TIME format (%d)", format); break; } gst_segment_set_newsegment_full (&rp->segment, update, rate, arate, GST_FORMAT_TIME, start, stop, time); /* create new segment with the fields converted to time */ event = gst_event_new_new_segment_full (update, rate, arate, GST_FORMAT_TIME, start, stop, time); ret = gst_pad_push_event (rp->srcpad, event); } break; } default: ret = gst_pad_event_default (rp->sinkpad, event); break; } gst_object_unref (rp); return ret; }
static void gst_raw_parse_loop (GstElement * element) { GstRawParse *rp = GST_RAW_PARSE (element); GstRawParseClass *rp_class = GST_RAW_PARSE_GET_CLASS (rp); GstFlowReturn ret; GstBuffer *buffer; gint size; if (!gst_raw_parse_set_src_caps (rp)) goto no_caps; if (rp->start_segment) { GST_DEBUG_OBJECT (rp, "sending start segment"); gst_pad_push_event (rp->srcpad, rp->start_segment); rp->start_segment = NULL; } if (rp_class->multiple_frames_per_buffer && rp->framesize < 4096) size = 4096 - (4096 % rp->framesize); else size = rp->framesize; if (rp->segment.rate >= 0) { if (rp->offset + size > rp->upstream_length) { GstFormat fmt = GST_FORMAT_BYTES; if (!gst_pad_peer_query_duration (rp->sinkpad, fmt, &rp->upstream_length)) { GST_WARNING_OBJECT (rp, "Could not get upstream duration, trying to pull frame by frame"); size = rp->framesize; } else if (rp->upstream_length < rp->offset + rp->framesize) { ret = GST_FLOW_EOS; goto pause; } else if (rp->offset + size > rp->upstream_length) { size = rp->upstream_length - rp->offset; size -= size % rp->framesize; } } } else { if (rp->offset == 0) { ret = GST_FLOW_EOS; goto pause; } else if (rp->offset < size) { size -= rp->offset; } rp->offset -= size; } buffer = NULL; ret = gst_pad_pull_range (rp->sinkpad, rp->offset, size, &buffer); if (ret != GST_FLOW_OK) { GST_DEBUG_OBJECT (rp, "pull_range (%" G_GINT64_FORMAT ", %u) " "failed, flow: %s", rp->offset, size, gst_flow_get_name (ret)); buffer = NULL; goto pause; } if (gst_buffer_get_size (buffer) < size) { GST_DEBUG_OBJECT (rp, "Short read at offset %" G_GINT64_FORMAT ", got only %" G_GSIZE_FORMAT " of %u bytes", rp->offset, gst_buffer_get_size (buffer), size); if (size > rp->framesize) { gst_buffer_set_size (buffer, gst_buffer_get_size (buffer) - gst_buffer_get_size (buffer) % rp->framesize); } else { gst_buffer_unref (buffer); buffer = NULL; ret = GST_FLOW_EOS; goto pause; } } ret = gst_raw_parse_push_buffer (rp, buffer); if (ret != GST_FLOW_OK) goto pause; return; /* ERRORS */ no_caps: { GST_ERROR_OBJECT (rp, "could not negotiate caps"); ret = GST_FLOW_NOT_NEGOTIATED; goto pause; } pause: { const gchar *reason = gst_flow_get_name (ret); GST_LOG_OBJECT (rp, "pausing task, reason %s", reason); gst_pad_pause_task (rp->sinkpad); if (ret == GST_FLOW_EOS) { if (rp->segment.flags & GST_SEEK_FLAG_SEGMENT) { GstClockTime stop; GST_LOG_OBJECT (rp, "Sending segment done"); if ((stop = rp->segment.stop) == -1) stop = rp->segment.duration; gst_element_post_message (GST_ELEMENT_CAST (rp), gst_message_new_segment_done (GST_OBJECT_CAST (rp), rp->segment.format, stop)); gst_pad_push_event (rp->srcpad, gst_event_new_segment_done (rp->segment.format, stop)); } else { GST_LOG_OBJECT (rp, "Sending EOS, at end of stream"); gst_pad_push_event (rp->srcpad, gst_event_new_eos ()); } } else if (ret == GST_FLOW_NOT_LINKED || ret < GST_FLOW_EOS) { GST_ELEMENT_ERROR (rp, STREAM, FAILED, ("Internal data stream error."), ("stream stopped, reason %s", reason)); gst_pad_push_event (rp->srcpad, gst_event_new_eos ()); } return; } }
static gboolean gst_raw_parse_src_query (GstPad * pad, GstObject * parent, GstQuery * query) { GstRawParse *rp = GST_RAW_PARSE (parent); gboolean ret = FALSE; GST_DEBUG ("src_query %s", gst_query_type_get_name (GST_QUERY_TYPE (query))); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_POSITION: { GstFormat format; gint64 time, value; GST_LOG ("query position"); gst_query_parse_position (query, &format, NULL); time = rp->segment.position; ret = gst_raw_parse_convert (rp, GST_FORMAT_TIME, time, format, &value); gst_query_set_position (query, format, value); break; } case GST_QUERY_DURATION:{ gint64 duration; GstFormat format; GstQuery *bquery; GST_LOG ("query duration"); ret = gst_pad_peer_query (rp->sinkpad, query); if (ret) goto done; gst_query_parse_duration (query, &format, NULL); /* We only handle TIME and DEFAULT format */ if (format != GST_FORMAT_TIME && format != GST_FORMAT_DEFAULT) goto error; bquery = gst_query_new_duration (GST_FORMAT_BYTES); ret = gst_pad_peer_query (rp->sinkpad, bquery); if (!ret) { gst_query_unref (bquery); goto error; } gst_query_parse_duration (bquery, NULL, &duration); gst_query_unref (bquery); ret = gst_raw_parse_convert (rp, GST_FORMAT_BYTES, duration, format, &duration); if (ret) gst_query_set_duration (query, format, duration); break; } case GST_QUERY_CONVERT: { GstFormat src_fmt, dest_fmt; gint64 src_val, dest_val; GST_LOG ("query convert"); gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val); ret = gst_raw_parse_convert (rp, src_fmt, src_val, dest_fmt, &dest_val); if (!ret) goto error; gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val); break; } case GST_QUERY_SEEKING:{ GstFormat fmt; ret = TRUE; gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL); if (fmt != GST_FORMAT_TIME && fmt != GST_FORMAT_DEFAULT && fmt != GST_FORMAT_BYTES) { gst_query_set_seeking (query, fmt, FALSE, -1, -1); } else if (rp->mode == GST_PAD_MODE_PUSH) { GstQuery *peerquery = gst_query_new_seeking (GST_FORMAT_BYTES); gboolean seekable; seekable = gst_pad_peer_query (rp->sinkpad, peerquery); if (seekable) gst_query_parse_seeking (peerquery, NULL, &seekable, NULL, NULL); gst_query_unref (peerquery); gst_query_set_seeking (query, fmt, seekable, seekable ? 0 : -1, -1); } else { gst_query_set_seeking (query, fmt, TRUE, 0, -1); } break; } default: /* else forward upstream */ ret = gst_pad_query_default (rp->sinkpad, parent, query); break; } done: return ret; /* ERRORS */ error: { GST_DEBUG_OBJECT (rp, "query failed"); goto done; } }