GstEvent * event);
static GstFlowReturn gst_gio_base_sink_render (GstBaseSink * base_sink,
GstBuffer * buffer);
-static gboolean gst_gio_base_sink_query (GstPad * pad, GstQuery * query);
+static gboolean gst_gio_base_sink_query (GstPad * pad, GstQuery ** query);
static void
gst_gio_base_sink_class_init (GstGioBaseSinkClass * klass)
}
static gboolean
-gst_gio_base_sink_query (GstPad * pad, GstQuery * query)
+gst_gio_base_sink_query (GstPad * pad, GstQuery ** query)
{
GstGioBaseSink *sink = GST_GIO_BASE_SINK (GST_PAD_PARENT (pad));
GstFormat format;
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_POSITION:
- gst_query_parse_position (query, &format, NULL);
+ gst_query_parse_position (*query, &format, NULL);
switch (format) {
case GST_FORMAT_BYTES:
case GST_FORMAT_DEFAULT:
- gst_query_set_position (query, GST_FORMAT_BYTES, sink->position);
+ gst_query_set_position (*query, GST_FORMAT_BYTES, sink->position);
return TRUE;
default:
return FALSE;
}
case GST_QUERY_FORMATS:
- gst_query_set_formats (query, 2, GST_FORMAT_DEFAULT, GST_FORMAT_BYTES);
+ gst_query_set_formats (*query, 2, GST_FORMAT_DEFAULT, GST_FORMAT_BYTES);
return TRUE;
case GST_QUERY_URI:
if (GST_IS_URI_HANDLER (sink)) {
const gchar *uri;
uri = gst_uri_handler_get_uri (GST_URI_HANDLER (sink));
- gst_query_set_uri (query, uri);
+ gst_query_set_uri (*query, uri);
return TRUE;
}
return FALSE;
static GstFlowReturn gst_gio_base_src_create (GstBaseSrc * base_src,
guint64 offset, guint size, GstBuffer ** buf);
static gboolean gst_gio_base_src_query (GstBaseSrc * base_src,
- GstQuery * query);
+ GstQuery ** query);
static void
gst_gio_base_src_class_init (GstGioBaseSrcClass * klass)
}
static gboolean
-gst_gio_base_src_query (GstBaseSrc * base_src, GstQuery * query)
+gst_gio_base_src_query (GstBaseSrc * base_src, GstQuery ** query)
{
gboolean ret = FALSE;
GstGioBaseSrc *src = GST_GIO_BASE_SRC (base_src);
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_URI:
if (GST_IS_URI_HANDLER (src)) {
const gchar *uri = gst_uri_handler_get_uri (GST_URI_HANDLER (src));
- gst_query_set_uri (query, uri);
+ gst_query_set_uri (*query, uri);
ret = TRUE;
}
break;
GstBuffer * buffer);
static gboolean gst_gnome_vfs_sink_handle_event (GstBaseSink * basesink,
GstEvent * event);
-static gboolean gst_gnome_vfs_sink_query (GstPad * pad, GstQuery * query);
+static gboolean gst_gnome_vfs_sink_query (GstPad * pad, GstQuery ** query);
static guint gst_gnome_vfs_sink_signals[LAST_SIGNAL]; /* all 0 */
}
static gboolean
-gst_gnome_vfs_sink_query (GstPad * pad, GstQuery * query)
+gst_gnome_vfs_sink_query (GstPad * pad, GstQuery ** query)
{
GstGnomeVFSSink *sink;
GstFormat format;
sink = GST_GNOME_VFS_SINK (GST_PAD_PARENT (pad));
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_POSITION:
- gst_query_parse_position (query, &format, NULL);
+ gst_query_parse_position (*query, &format, NULL);
switch (format) {
case GST_FORMAT_DEFAULT:
case GST_FORMAT_BYTES:
- gst_query_set_position (query, GST_FORMAT_BYTES, sink->current_pos);
+ gst_query_set_position (*query, GST_FORMAT_BYTES, sink->current_pos);
return TRUE;
default:
return FALSE;
}
case GST_QUERY_FORMATS:
- gst_query_set_formats (query, 2, GST_FORMAT_DEFAULT, GST_FORMAT_BYTES);
+ gst_query_set_formats (*query, 2, GST_FORMAT_DEFAULT, GST_FORMAT_BYTES);
return TRUE;
case GST_QUERY_URI:
- gst_query_set_uri (query, sink->uri_name);
+ gst_query_set_uri (*query, sink->uri_name);
return TRUE;
default:
static gboolean gst_gnome_vfs_src_get_size (GstBaseSrc * src, guint64 * size);
static GstFlowReturn gst_gnome_vfs_src_create (GstBaseSrc * basesrc,
guint64 offset, guint size, GstBuffer ** buffer);
-static gboolean gst_gnome_vfs_src_query (GstBaseSrc * src, GstQuery * query);
+static gboolean gst_gnome_vfs_src_query (GstBaseSrc * src, GstQuery ** query);
#define gst_gnome_vfs_src_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (GstGnomeVFSSrc, gst_gnome_vfs_src, GST_TYPE_BASE_SRC,
}
static gboolean
-gst_gnome_vfs_src_query (GstBaseSrc * basesrc, GstQuery * query)
+gst_gnome_vfs_src_query (GstBaseSrc * basesrc, GstQuery ** query)
{
gboolean ret = FALSE;
GstGnomeVFSSrc *src = GST_GNOME_VFS_SRC (basesrc);
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_URI:
- gst_query_set_uri (query, src->uri_name);
+ gst_query_set_uri (*query, src->uri_name);
ret = TRUE;
break;
default:
static gboolean gst_visual_sink_event (GstPad * pad, GstEvent * event);
static gboolean gst_visual_src_event (GstPad * pad, GstEvent * event);
-static gboolean gst_visual_src_query (GstPad * pad, GstQuery * query);
+static gboolean gst_visual_src_query (GstPad * pad, GstQuery ** query);
static gboolean gst_visual_sink_setcaps (GstPad * pad, GstCaps * caps);
static gboolean gst_visual_src_setcaps (GstPad * pad, GstCaps * caps);
/* find a pool for the negotiated caps now */
query = gst_query_new_allocation (target, TRUE);
- if (gst_pad_peer_query (visual->srcpad, query)) {
+ if (gst_pad_peer_query (visual->srcpad, &query)) {
/* we got configuration from our peer, parse them */
gst_query_parse_allocation_params (query, &size, &min, &max, &prefix,
&alignment, &pool);
prefix = 0;
alignment = 1;
}
+ gst_query_unref (query);
if (pool == NULL) {
GstStructure *config;
}
static gboolean
-gst_visual_src_query (GstPad * pad, GstQuery * query)
+gst_visual_src_query (GstPad * pad, GstQuery ** query)
{
gboolean res;
GstVisual *visual;
visual = GST_VISUAL (gst_pad_get_parent (pad));
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_LATENCY:
{
/* We need to send the query upstream and add the returned latency to our
guint max_samples;
if ((res = gst_pad_peer_query (visual->sinkpad, query))) {
- gst_query_parse_latency (query, &us_live, &min_latency, &max_latency);
+ gst_query_parse_latency (*query, &us_live, &min_latency, &max_latency);
GST_DEBUG_OBJECT (visual, "Peer latency: min %"
GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
GST_TIME_ARGS (min_latency), GST_TIME_ARGS (max_latency));
- gst_query_set_latency (query, TRUE, min_latency, max_latency);
+ gst_query_set_latency (*query, TRUE, min_latency, max_latency);
}
break;
}
static void gst_ogg_pad_finalize (GObject * object);
static const GstQueryType *gst_ogg_pad_query_types (GstPad * pad);
-static gboolean gst_ogg_pad_src_query (GstPad * pad, GstQuery * query);
+static gboolean gst_ogg_pad_src_query (GstPad * pad, GstQuery ** query);
static gboolean gst_ogg_pad_event (GstPad * pad, GstEvent * event);
static GstCaps *gst_ogg_pad_getcaps (GstPad * pad);
static GstOggPad *gst_ogg_chain_get_stream (GstOggChain * chain,
}
static gboolean
-gst_ogg_pad_src_query (GstPad * pad, GstQuery * query)
+gst_ogg_pad_src_query (GstPad * pad, GstQuery ** query)
{
gboolean res = TRUE;
GstOggDemux *ogg;
ogg = GST_OGG_DEMUX (gst_pad_get_parent (pad));
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_DURATION:
{
GstFormat format;
gint64 total_time = -1;
- gst_query_parse_duration (query, &format, NULL);
+ gst_query_parse_duration (*query, &format, NULL);
/* can only get position in time */
if (format != GST_FORMAT_TIME)
goto wrong_format;
/* ask upstream for total length in bytes */
uquery = gst_query_new_duration (GST_FORMAT_BYTES);
- if (gst_pad_peer_query (ogg->sinkpad, uquery)) {
+ if (gst_pad_peer_query (ogg->sinkpad, &uquery)) {
gint64 length;
gst_query_parse_duration (uquery, NULL, &length);
}
}
- gst_query_set_duration (query, GST_FORMAT_TIME, total_time);
+ gst_query_set_duration (*query, GST_FORMAT_TIME, total_time);
break;
}
case GST_QUERY_SEEKING:
{
GstFormat format;
- gst_query_parse_seeking (query, &format, NULL, NULL, NULL);
+ gst_query_parse_seeking (*query, &format, NULL, NULL, NULL);
if (format == GST_FORMAT_TIME) {
gboolean seekable = FALSE;
gint64 stop = -1;
}
}
- gst_query_set_seeking (query, GST_FORMAT_TIME, seekable, 0, stop);
+ gst_query_set_seeking (*query, GST_FORMAT_TIME, seekable, 0, stop);
} else {
res = FALSE;
}
static const GstQueryType *gst_ogm_parse_get_sink_querytypes (GstPad * pad);
static gboolean gst_ogm_parse_sink_event (GstPad * pad, GstEvent * event);
-static gboolean gst_ogm_parse_sink_query (GstPad * pad, GstQuery * query);
+static gboolean gst_ogm_parse_sink_query (GstPad * pad, GstQuery ** query);
static gboolean gst_ogm_parse_sink_convert (GstPad * pad, GstFormat src_format,
gint64 src_value, GstFormat * dest_format, gint64 * dest_value);
}
static gboolean
-gst_ogm_parse_sink_query (GstPad * pad, GstQuery * query)
+gst_ogm_parse_sink_query (GstPad * pad, GstQuery ** query)
{
GstOgmParse *ogm = GST_OGM_PARSE (gst_pad_get_parent (pad));
GstFormat format;
gboolean res = FALSE;
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_POSITION:
{
gint64 val;
- gst_query_parse_position (query, &format, NULL);
+ gst_query_parse_position (*query, &format, NULL);
if (format != GST_FORMAT_DEFAULT && format != GST_FORMAT_TIME)
break;
if ((res = gst_ogm_parse_sink_convert (pad,
GST_FORMAT_DEFAULT, ogm->next_granulepos, &format, &val))) {
/* don't know the total length here.. */
- gst_query_set_position (query, format, val);
+ gst_query_set_position (*query, format, val);
}
break;
}
gint64 src_val, dest_val;
/* peel off input */
- gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
- if ((res = gst_ogm_parse_sink_convert (pad, src_fmt, src_val,
- &dest_fmt, &dest_val))) {
- gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
+ gst_query_parse_convert (*query, &src_fmt, &src_val, &dest_fmt,
+ &dest_val);
+ if ((res =
+ gst_ogm_parse_sink_convert (pad, src_fmt, src_val, &dest_fmt,
+ &dest_val))) {
+ gst_query_set_convert (*query, src_fmt, src_val, dest_fmt, dest_val);
}
break;
}
static gboolean gst_base_text_overlay_src_event (GstPad * pad,
GstEvent * event);
static gboolean gst_base_text_overlay_src_query (GstPad * pad,
- GstQuery * query);
+ GstQuery ** query);
static gboolean gst_base_text_overlay_video_event (GstPad * pad,
GstEvent * event);
}
static gboolean
-gst_base_text_overlay_src_query (GstPad * pad, GstQuery * query)
+gst_base_text_overlay_src_query (GstPad * pad, GstQuery ** query)
{
gboolean ret = FALSE;
GstBaseTextOverlay *overlay = NULL;
static GstStateChangeReturn theora_dec_change_state (GstElement * element,
GstStateChange transition);
static gboolean theora_dec_src_event (GstPad * pad, GstEvent * event);
-static gboolean theora_dec_src_query (GstPad * pad, GstQuery * query);
+static gboolean theora_dec_src_query (GstPad * pad, GstQuery ** query);
static gboolean theora_dec_src_convert (GstPad * pad,
GstFormat src_format, gint64 src_value,
GstFormat * dest_format, gint64 * dest_value);
#endif
static gboolean
-theora_dec_src_query (GstPad * pad, GstQuery * query)
+theora_dec_src_query (GstPad * pad, GstQuery ** query)
{
GstTheoraDec *dec;
dec = GST_THEORA_DEC (gst_pad_get_parent (pad));
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_POSITION:
{
gint64 value;
gint64 time;
/* parse format */
- gst_query_parse_position (query, &format, NULL);
+ gst_query_parse_position (*query, &format, NULL);
time = dec->last_timestamp;
time = gst_segment_to_stream_time (&dec->segment, GST_FORMAT_TIME, time);
GST_LOG_OBJECT (dec,
- "query %p: our time: %" GST_TIME_FORMAT, query, GST_TIME_ARGS (time));
+ "query %p: our time: %" GST_TIME_FORMAT, *query,
+ GST_TIME_ARGS (time));
if (!(res =
theora_dec_src_convert (pad, GST_FORMAT_TIME, time, &format,
&value)))
goto error;
- gst_query_set_position (query, format, value);
+ gst_query_set_position (*query, format, value);
GST_LOG_OBJECT (dec,
- "query %p: we return %" G_GINT64_FORMAT " (format %u)", query, value,
+ "query %p: we return %" G_GINT64_FORMAT " (format %u)", *query, value,
format);
break;
}
GstFormat src_fmt, dest_fmt;
gint64 src_val, dest_val;
- gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
+ gst_query_parse_convert (*query, &src_fmt, &src_val, &dest_fmt,
+ &dest_val);
if (!(res =
theora_dec_src_convert (pad, src_fmt, src_val, &dest_fmt,
&dest_val)))
goto error;
- gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
+ gst_query_set_convert (*query, src_fmt, src_val, dest_fmt, dest_val);
break;
}
default:
/* find a pool for the negotiated caps now */
query = gst_query_new_allocation (caps, TRUE);
- if (gst_pad_peer_query (dec->srcpad, query)) {
+ if (gst_pad_peer_query (dec->srcpad, &query)) {
GST_DEBUG_OBJECT (dec, "got downstream ALLOCATION hints");
/* we got configuration from our peer, parse them */
gst_query_parse_allocation_params (query, &size, &min, &max, &prefix,
prefix = 0;
alignment = 1;
}
+ gst_query_unref (query);
if (pool == NULL) {
GstStructure *config;
static GstStateChangeReturn theora_parse_change_state (GstElement * element,
GstStateChange transition);
static gboolean theora_parse_sink_event (GstPad * pad, GstEvent * event);
-static gboolean theora_parse_src_query (GstPad * pad, GstQuery * query);
+static gboolean theora_parse_src_query (GstPad * pad, GstQuery ** query);
static void
gst_theora_parse_class_init (GstTheoraParseClass * klass)
}
static gboolean
-theora_parse_src_query (GstPad * pad, GstQuery * query)
+theora_parse_src_query (GstPad * pad, GstQuery ** query)
{
GstTheoraParse *parse;
parse = GST_THEORA_PARSE (gst_pad_get_parent (pad));
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_POSITION:
{
gint64 frame, value;
frame = parse->prev_frame;
GST_LOG_OBJECT (parse,
- "query %p: we have current frame: %" G_GINT64_FORMAT, query, frame);
+ "query %p: we have current frame: %" G_GINT64_FORMAT, *query, frame);
/* parse format */
- gst_query_parse_position (query, &format, NULL);
+ gst_query_parse_position (*query, &format, NULL);
/* and convert to the final format in two steps with time as the
* intermediate step */
GST_LOG_OBJECT (parse,
"query %p: our time: %" GST_TIME_FORMAT " (conv to %s)",
- query, GST_TIME_ARGS (time), gst_format_get_name (format));
+ *query, GST_TIME_ARGS (time), gst_format_get_name (format));
if (!(res =
theora_parse_src_convert (pad, my_format, time, &format, &value)))
goto error;
- gst_query_set_position (query, format, value);
+ gst_query_set_position (*query, format, value);
GST_LOG_OBJECT (parse,
- "query %p: we return %" G_GINT64_FORMAT " (format %u)", query, value,
+ "query %p: we return %" G_GINT64_FORMAT " (format %u)", *query, value,
format);
break;
GstFormat src_fmt, dest_fmt;
gint64 src_val, dest_val;
- gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
+ gst_query_parse_convert (*query, &src_fmt, &src_val, &dest_fmt,
+ &dest_val);
if (!(res =
theora_parse_src_convert (pad, src_fmt, src_val, &dest_fmt,
&dest_val)))
goto error;
- gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
+ gst_query_set_convert (*query, src_fmt, src_val, dest_fmt, dest_val);
break;
}
default:
GstStateChange transition);
static gboolean vorbis_dec_src_event (GstPad * pad, GstEvent * event);
-static gboolean vorbis_dec_src_query (GstPad * pad, GstQuery * query);
+static gboolean vorbis_dec_src_query (GstPad * pad, GstQuery ** query);
static gboolean vorbis_dec_convert (GstPad * pad,
GstFormat src_format, gint64 src_value,
GstFormat * dest_format, gint64 * dest_value);
-static gboolean vorbis_dec_sink_query (GstPad * pad, GstQuery * query);
+static gboolean vorbis_dec_sink_query (GstPad * pad, GstQuery ** query);
static void
gst_vorbis_dec_class_init (GstVorbisDecClass * klass)
}
static gboolean
-vorbis_dec_src_query (GstPad * pad, GstQuery * query)
+vorbis_dec_src_query (GstPad * pad, GstQuery ** query)
{
GstVorbisDec *dec;
gboolean res = FALSE;
if (G_UNLIKELY (dec == NULL))
return FALSE;
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_POSITION:
{
gint64 value;
GstFormat format;
gint64 time;
- gst_query_parse_position (query, &format, NULL);
+ gst_query_parse_position (*query, &format, NULL);
/* we start from the last seen time */
time = dec->last_timestamp;
time = gst_segment_to_stream_time (&dec->segment, GST_FORMAT_TIME, time);
GST_LOG_OBJECT (dec,
- "query %p: our time: %" GST_TIME_FORMAT, query, GST_TIME_ARGS (time));
+ "query %p: our time: %" GST_TIME_FORMAT, *query,
+ GST_TIME_ARGS (time));
/* and convert to the final format */
if (!(res =
vorbis_dec_convert (pad, GST_FORMAT_TIME, time, &format, &value)))
goto error;
- gst_query_set_position (query, format, value);
+ gst_query_set_position (*query, format, value);
GST_LOG_OBJECT (dec,
- "query %p: we return %" G_GINT64_FORMAT " (format %u)", query, value,
+ "query %p: we return %" G_GINT64_FORMAT " (format %u)", *query, value,
format);
break;
GstFormat src_fmt, dest_fmt;
gint64 src_val, dest_val;
- gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
+ gst_query_parse_convert (*query, &src_fmt, &src_val, &dest_fmt,
+ &dest_val);
if (!(res =
vorbis_dec_convert (pad, src_fmt, src_val, &dest_fmt, &dest_val)))
goto error;
- gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
+ gst_query_set_convert (*query, src_fmt, src_val, dest_fmt, dest_val);
break;
}
default:
}
static gboolean
-vorbis_dec_sink_query (GstPad * pad, GstQuery * query)
+vorbis_dec_sink_query (GstPad * pad, GstQuery ** query)
{
GstVorbisDec *dec;
gboolean res;
dec = GST_VORBIS_DEC (gst_pad_get_parent (pad));
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_CONVERT:
{
GstFormat src_fmt, dest_fmt;
gint64 src_val, dest_val;
- gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
+ gst_query_parse_convert (*query, &src_fmt, &src_val, &dest_fmt,
+ &dest_val);
if (!(res =
vorbis_dec_convert (pad, src_fmt, src_val, &dest_fmt, &dest_val)))
goto error;
- gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
+ gst_query_set_convert (*query, src_fmt, src_val, dest_fmt, dest_val);
break;
}
default:
}
static gboolean
-gst_vorbis_enc_src_query (GstPad * pad, GstQuery * query)
+gst_vorbis_enc_src_query (GstPad * pad, GstQuery ** query)
{
gboolean res = TRUE;
GstVorbisEnc *vorbisenc;
GstFormat fmt, req_fmt;
gint64 pos, val;
- gst_query_parse_position (query, &req_fmt, NULL);
+ gst_query_parse_position (*query, &req_fmt, NULL);
if ((res = gst_pad_query_position (peerpad, &req_fmt, &val))) {
- gst_query_set_position (query, req_fmt, val);
+ gst_query_set_position (*query, req_fmt, val);
break;
}
break;
if ((res = gst_pad_query_convert (peerpad, fmt, pos, &req_fmt, &val))) {
- gst_query_set_position (query, req_fmt, val);
+ gst_query_set_position (*query, req_fmt, val);
}
break;
}
GstFormat fmt, req_fmt;
gint64 dur, val;
- gst_query_parse_duration (query, &req_fmt, NULL);
+ gst_query_parse_duration (*query, &req_fmt, NULL);
if ((res = gst_pad_query_duration (peerpad, &req_fmt, &val))) {
- gst_query_set_duration (query, req_fmt, val);
+ gst_query_set_duration (*query, req_fmt, val);
break;
}
break;
if ((res = gst_pad_query_convert (peerpad, fmt, dur, &req_fmt, &val))) {
- gst_query_set_duration (query, req_fmt, val);
+ gst_query_set_duration (*query, req_fmt, val);
}
break;
}
GstFormat src_fmt, dest_fmt;
gint64 src_val, dest_val;
- gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
+ gst_query_parse_convert (*query, &src_fmt, &src_val, &dest_fmt,
+ &dest_val);
if (!(res =
gst_vorbis_enc_convert_src (pad, src_fmt, src_val, &dest_fmt,
&dest_val)))
goto error;
- gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
+ gst_query_set_convert (*query, src_fmt, src_val, dest_fmt, dest_val);
break;
}
case GST_QUERY_LATENCY:
gint64 latency;
if ((res = gst_pad_query (peerpad, query))) {
- gst_query_parse_latency (query, &live, &min_latency, &max_latency);
+ gst_query_parse_latency (*query, &live, &min_latency, &max_latency);
latency = gst_vorbis_enc_get_latency (vorbisenc);
if (max_latency != -1)
max_latency += latency;
- gst_query_set_latency (query, live, min_latency, max_latency);
+ gst_query_set_latency (*query, live, min_latency, max_latency);
}
break;
}
}
static gboolean
-gst_vorbis_enc_sink_query (GstPad * pad, GstQuery * query)
+gst_vorbis_enc_sink_query (GstPad * pad, GstQuery ** query)
{
gboolean res = TRUE;
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_CONVERT:
{
GstFormat src_fmt, dest_fmt;
gint64 src_val, dest_val;
- gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
+ gst_query_parse_convert (*query, &src_fmt, &src_val, &dest_fmt,
+ &dest_val);
if (!(res =
gst_vorbis_enc_convert_sink (pad, src_fmt, src_val, &dest_fmt,
&dest_val)))
goto error;
- gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
+ gst_query_set_convert (*query, src_fmt, src_val, dest_fmt, dest_val);
break;
}
default:
static GstStateChangeReturn vorbis_parse_change_state (GstElement * element,
GstStateChange transition);
static gboolean vorbis_parse_sink_event (GstPad * pad, GstEvent * event);
-static gboolean vorbis_parse_src_query (GstPad * pad, GstQuery * query);
+static gboolean vorbis_parse_src_query (GstPad * pad, GstQuery ** query);
static gboolean vorbis_parse_convert (GstPad * pad,
GstFormat src_format, gint64 src_value,
GstFormat * dest_format, gint64 * dest_value);
}
static gboolean
-vorbis_parse_src_query (GstPad * pad, GstQuery * query)
+vorbis_parse_src_query (GstPad * pad, GstQuery ** query)
{
gint64 granulepos;
GstVorbisParse *parse;
parse = GST_VORBIS_PARSE (GST_PAD_PARENT (pad));
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_POSITION:
{
GstFormat format;
granulepos = parse->prev_granulepos;
- gst_query_parse_position (query, &format, NULL);
+ gst_query_parse_position (*query, &format, NULL);
/* and convert to the final format */
if (!(res =
value = (value - parse->segment_start) + parse->segment_time;
*/
- gst_query_set_position (query, format, value);
+ gst_query_set_position (*query, format, value);
GST_LOG_OBJECT (parse, "query %p: peer returned granulepos: %"
G_GUINT64_FORMAT " - we return %" G_GUINT64_FORMAT " (format %u)",
- query, granulepos, value, format);
+ *query, granulepos, value, format);
break;
}
parse->sinkpad);
goto error;
}
- if (!(res = gst_pad_query (GST_PAD_PEER (parse->sinkpad), query)))
+ if (!(res = gst_pad_peer_query (parse->sinkpad, query)))
goto error;
break;
}
GstFormat src_fmt, dest_fmt;
gint64 src_val, dest_val;
- gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
+ gst_query_parse_convert (*query, &src_fmt, &src_val, &dest_fmt,
+ &dest_val);
if (!(res =
vorbis_parse_convert (pad, src_fmt, src_val, &dest_fmt,
&dest_val)))
goto error;
- gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
+ gst_query_set_convert (*query, src_fmt, src_val, dest_fmt, dest_val);
break;
}
default:
static gboolean gst_app_src_is_seekable (GstBaseSrc * src);
static gboolean gst_app_src_check_get_range (GstBaseSrc * src);
static gboolean gst_app_src_do_get_size (GstBaseSrc * src, guint64 * size);
-static gboolean gst_app_src_query (GstBaseSrc * src, GstQuery * query);
+static gboolean gst_app_src_query (GstBaseSrc * src, GstQuery ** query);
static GstFlowReturn gst_app_src_push_buffer_action (GstAppSrc * appsrc,
GstBuffer * buffer);
}
static gboolean
-gst_app_src_query (GstBaseSrc * src, GstQuery * query)
+gst_app_src_query (GstBaseSrc * src, GstQuery ** query)
{
GstAppSrc *appsrc = GST_APP_SRC_CAST (src);
GstAppSrcPrivate *priv = appsrc->priv;
gboolean res;
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_LATENCY:
{
GstClockTime min, max;
max = priv->max_latency;
g_mutex_unlock (priv->mutex);
- gst_query_set_latency (query, live, min, max);
+ gst_query_set_latency (*query, live, min, max);
break;
}
default:
element, GstStateChange transition);
static gboolean gst_base_audio_sink_activate_pull (GstBaseSink * basesink,
gboolean active);
-static gboolean gst_base_audio_sink_query (GstElement * element, GstQuery *
+static gboolean gst_base_audio_sink_query (GstElement * element, GstQuery **
query);
static GstClock *gst_base_audio_sink_provide_clock (GstElement * elem);
GstCaps * caps);
static void gst_base_audio_sink_fixate (GstBaseSink * bsink, GstCaps * caps);
-static gboolean gst_base_audio_sink_query_pad (GstPad * pad, GstQuery * query);
+static gboolean gst_base_audio_sink_query_pad (GstPad * pad, GstQuery ** query);
/* static guint gst_base_audio_sink_signals[LAST_SIGNAL] = { 0 }; */
}
static gboolean
-gst_base_audio_sink_query_pad (GstPad * pad, GstQuery * query)
+gst_base_audio_sink_query_pad (GstPad * pad, GstQuery ** query)
{
gboolean res = FALSE;
GstBaseAudioSink *basesink;
basesink = GST_BASE_AUDIO_SINK (gst_pad_get_parent (pad));
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_CONVERT:
{
GstFormat src_fmt, dest_fmt;
GST_LOG_OBJECT (pad, "query convert");
if (basesink->ringbuffer) {
- gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, NULL);
+ gst_query_parse_convert (*query, &src_fmt, &src_val, &dest_fmt, NULL);
res = gst_ring_buffer_convert (basesink->ringbuffer, src_fmt, src_val,
dest_fmt, &dest_val);
if (res) {
- gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
+ gst_query_set_convert (*query, src_fmt, src_val, dest_fmt, dest_val);
}
}
break;
}
static gboolean
-gst_base_audio_sink_query (GstElement * element, GstQuery * query)
+gst_base_audio_sink_query (GstElement * element, GstQuery ** query)
{
gboolean res = FALSE;
GstBaseAudioSink *basesink;
basesink = GST_BASE_AUDIO_SINK (element);
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_LATENCY:
{
gboolean live, us_live;
min_latency = min_l;
max_latency = max_l;
}
- gst_query_set_latency (query, live, min_latency, max_latency);
+ gst_query_set_latency (*query, live, min_latency, max_latency);
}
break;
}
GST_LOG_OBJECT (basesink, "query convert");
if (basesink->ringbuffer) {
- gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, NULL);
+ gst_query_parse_convert (*query, &src_fmt, &src_val, &dest_fmt, NULL);
res = gst_ring_buffer_convert (basesink->ringbuffer, src_fmt, src_val,
dest_fmt, &dest_val);
if (res) {
- gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
+ gst_query_set_convert (*query, src_fmt, src_val, dest_fmt, dest_val);
}
}
break;
static void gst_base_audio_src_get_times (GstBaseSrc * bsrc,
GstBuffer * buffer, GstClockTime * start, GstClockTime * end);
static gboolean gst_base_audio_src_setcaps (GstBaseSrc * bsrc, GstCaps * caps);
-static gboolean gst_base_audio_src_query (GstBaseSrc * bsrc, GstQuery * query);
+static gboolean gst_base_audio_src_query (GstBaseSrc * bsrc, GstQuery ** query);
static void gst_base_audio_src_fixate (GstBaseSrc * bsrc, GstCaps * caps);
/* static guint gst_base_audio_src_signals[LAST_SIGNAL] = { 0 }; */
}
static gboolean
-gst_base_audio_src_query (GstBaseSrc * bsrc, GstQuery * query)
+gst_base_audio_src_query (GstBaseSrc * bsrc, GstQuery ** query)
{
GstBaseAudioSrc *src = GST_BASE_AUDIO_SRC (bsrc);
gboolean res = FALSE;
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_LATENCY:
{
GstClockTime min_latency, max_latency;
/* we are always live, the min latency is 1 segment and the max latency is
* the complete buffer of segments. */
- gst_query_set_latency (query, TRUE, min_latency, max_latency);
+ gst_query_set_latency (*query, TRUE, min_latency, max_latency);
res = TRUE;
break;
const GValue * value, GParamSpec * pspec);
static void gst_cdda_base_src_finalize (GObject * obj);
static const GstQueryType *gst_cdda_base_src_get_query_types (GstPad * pad);
-static gboolean gst_cdda_base_src_query (GstBaseSrc * src, GstQuery * query);
+static gboolean gst_cdda_base_src_query (GstBaseSrc * src, GstQuery ** query);
static gboolean gst_cdda_base_src_handle_event (GstBaseSrc * basesrc,
GstEvent * event);
static gboolean gst_cdda_base_src_do_seek (GstBaseSrc * basesrc,
}
static gboolean
-gst_cdda_base_src_query (GstBaseSrc * basesrc, GstQuery * query)
+gst_cdda_base_src_query (GstBaseSrc * basesrc, GstQuery ** query)
{
GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (basesrc);
gboolean started;
started = GST_OBJECT_FLAG_IS_SET (basesrc, GST_BASE_SRC_STARTED);
GST_LOG_OBJECT (src, "handling %s query",
- gst_query_type_get_name (GST_QUERY_TYPE (query)));
+ gst_query_type_get_name (GST_QUERY_TYPE (*query)));
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_DURATION:{
GstFormat dest_format;
gint64 dest_val;
guint sectors;
- gst_query_parse_duration (query, &dest_format, NULL);
+ gst_query_parse_duration (*query, &dest_format, NULL);
if (!started)
return FALSE;
if (dest_format == track_format) {
GST_LOG_OBJECT (src, "duration: %d tracks", src->num_tracks);
- gst_query_set_duration (query, track_format, src->num_tracks);
+ gst_query_set_duration (*query, track_format, src->num_tracks);
return TRUE;
}
return FALSE;
}
- gst_query_set_duration (query, dest_format, dest_val);
+ gst_query_set_duration (*query, dest_format, dest_val);
GST_LOG ("duration: %u sectors, %" G_GINT64_FORMAT " in format %s",
sectors, dest_val, gst_format_get_name (dest_format));
gint64 pos_sector;
gint64 dest_val;
- gst_query_parse_position (query, &dest_format, NULL);
+ gst_query_parse_position (*query, &dest_format, NULL);
if (!started)
return FALSE;
if (dest_format == track_format) {
GST_LOG_OBJECT (src, "position: track %d", src->cur_track);
- gst_query_set_position (query, track_format, src->cur_track);
+ gst_query_set_position (*query, track_format, src->cur_track);
return TRUE;
}
return FALSE;
}
- gst_query_set_position (query, dest_format, dest_val);
+ gst_query_set_position (*query, dest_format, dest_val);
GST_LOG ("position: sector %u, %" G_GINT64_FORMAT " in format %s",
(guint) pos_sector, dest_val, gst_format_get_name (dest_format));
GstFormat src_format, dest_format;
gint64 src_val, dest_val;
- gst_query_parse_convert (query, &src_format, &src_val, &dest_format,
+ gst_query_parse_convert (*query, &src_format, &src_val, &dest_format,
NULL);
if (!gst_cdda_base_src_convert (src, src_format, src_val, dest_format,
return FALSE;
}
- gst_query_set_convert (query, src_format, src_val, dest_format, dest_val);
+ gst_query_set_convert (*query, src_format, src_val, dest_format,
+ dest_val);
break;
}
default:{
}
if (dc->priv->seeking_query) {
- if (gst_element_query (pipeline, dc->priv->seeking_query)) {
+ if (gst_element_query (pipeline, &dc->priv->seeking_query)) {
gboolean seekable;
gst_query_parse_seeking (dc->priv->seeking_query, &format,
static gboolean gst_tag_demux_sink_activate (GstPad * sinkpad);
static GstStateChangeReturn gst_tag_demux_change_state (GstElement * element,
GstStateChange transition);
-static gboolean gst_tag_demux_pad_query (GstPad * pad, GstQuery * query);
+static gboolean gst_tag_demux_pad_query (GstPad * pad, GstQuery ** query);
static const GstQueryType *gst_tag_demux_get_query_types (GstPad * pad);
static gboolean gst_tag_demux_get_upstream_size (GstTagDemux * tagdemux);
static void gst_tag_demux_send_pending_events (GstTagDemux * tagdemux);
}
static gboolean
-gst_tag_demux_pad_query (GstPad * pad, GstQuery * query)
+gst_tag_demux_pad_query (GstPad * pad, GstQuery ** query)
{
/* For a position or duration query, adjust the returned
* bytes to strip off the end and start areas */
gst_object_unref (peer);
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_POSITION:
{
- gst_query_parse_position (query, &format, &result);
+ gst_query_parse_position (*query, &format, &result);
if (format == GST_FORMAT_BYTES) {
result -= demux->priv->strip_start;
- gst_query_set_position (query, format, result);
+ gst_query_set_position (*query, format, result);
}
break;
}
case GST_QUERY_DURATION:
{
- gst_query_parse_duration (query, &format, &result);
+ gst_query_parse_duration (*query, &format, &result);
if (format == GST_FORMAT_BYTES) {
result -= demux->priv->strip_start + demux->priv->strip_end;
- gst_query_set_duration (query, format, result);
+ gst_query_set_duration (*query, format, result);
}
break;
}
GValue * value, GParamSpec * pspec);
static gboolean gst_adder_setcaps (GstPad * pad, GstCaps * caps);
-static gboolean gst_adder_query (GstPad * pad, GstQuery * query);
+static gboolean gst_adder_query (GstPad * pad, GstQuery ** query);
static gboolean gst_adder_src_event (GstPad * pad, GstEvent * event);
static gboolean gst_adder_sink_event (GstPad * pad, GstEvent * event);
* cases work at least somewhat.
*/
static gboolean
-gst_adder_query_duration (GstAdder * adder, GstQuery * query)
+gst_adder_query_duration (GstAdder * adder, GstQuery ** query)
{
gint64 max;
gboolean res;
GValue item = { 0, };
/* parse format */
- gst_query_parse_duration (query, &format, NULL);
+ gst_query_parse_duration (*query, &format, NULL);
max = -1;
res = TRUE;
/* and store the max */
GST_DEBUG_OBJECT (adder, "Total duration in format %s: %"
GST_TIME_FORMAT, gst_format_get_name (format), GST_TIME_ARGS (max));
- gst_query_set_duration (query, format, max);
+ gst_query_set_duration (*query, format, max);
}
return res;
}
static gboolean
-gst_adder_query_latency (GstAdder * adder, GstQuery * query)
+gst_adder_query_latency (GstAdder * adder, GstQuery ** query)
{
GstClockTime min, max;
gboolean live;
peerquery = gst_query_new_latency ();
/* Ask peer for latency */
- res &= gst_pad_peer_query (pad, peerquery);
+ res &= gst_pad_peer_query (pad, &peerquery);
/* take max from all valid return values */
if (res) {
GST_DEBUG_OBJECT (adder, "Calculated total latency: live %s, min %"
GST_TIME_FORMAT ", max %" GST_TIME_FORMAT,
(live ? "yes" : "no"), GST_TIME_ARGS (min), GST_TIME_ARGS (max));
- gst_query_set_latency (query, live, min, max);
+ gst_query_set_latency (*query, live, min, max);
}
return res;
}
static gboolean
-gst_adder_query (GstPad * pad, GstQuery * query)
+gst_adder_query (GstPad * pad, GstQuery ** query)
{
GstAdder *adder = GST_ADDER (gst_pad_get_parent (pad));
gboolean res = FALSE;
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_POSITION:
{
GstFormat format;
- gst_query_parse_position (query, &format, NULL);
+ gst_query_parse_position (*query, &format, NULL);
switch (format) {
case GST_FORMAT_TIME:
/* FIXME, bring to stream time, might be tricky */
- gst_query_set_position (query, format, adder->timestamp);
+ gst_query_set_position (*query, format, adder->timestamp);
res = TRUE;
break;
case GST_FORMAT_DEFAULT:
- gst_query_set_position (query, format, adder->offset);
+ gst_query_set_position (*query, format, adder->offset);
res = TRUE;
break;
default:
GstEvent * event);
static gboolean gst_audio_resample_start (GstBaseTransform * base);
static gboolean gst_audio_resample_stop (GstBaseTransform * base);
-static gboolean gst_audio_resample_query (GstPad * pad, GstQuery * query);
+static gboolean gst_audio_resample_query (GstPad * pad, GstQuery ** query);
static const GstQueryType *gst_audio_resample_query_type (GstPad * pad);
#define gst_audio_resample_parent_class parent_class
}
static gboolean
-gst_audio_resample_query (GstPad * pad, GstQuery * query)
+gst_audio_resample_query (GstPad * pad, GstQuery ** query)
{
GstAudioResample *resample = GST_AUDIO_RESAMPLE (gst_pad_get_parent (pad));
GstBaseTransform *trans;
trans = GST_BASE_TRANSFORM (resample);
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_LATENCY:
{
GstClockTime min, max;
if ((peer = gst_pad_get_peer (GST_BASE_TRANSFORM_SINK_PAD (trans)))) {
if ((res = gst_pad_query (peer, query))) {
- gst_query_parse_latency (query, &live, &min, &max);
+ gst_query_parse_latency (*query, &live, &min, &max);
GST_DEBUG_OBJECT (resample, "Peer latency: min %"
GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
GST_TIME_ARGS (min), GST_TIME_ARGS (max));
- gst_query_set_latency (query, live, min, max);
+ gst_query_set_latency (*query, live, min, max);
}
gst_object_unref (peer);
}
static gboolean gst_audio_test_src_do_seek (GstBaseSrc * basesrc,
GstSegment * segment);
static gboolean gst_audio_test_src_query (GstBaseSrc * basesrc,
- GstQuery * query);
+ GstQuery ** query);
static void gst_audio_test_src_change_wave (GstAudioTestSrc * src);
}
static gboolean
-gst_audio_test_src_query (GstBaseSrc * basesrc, GstQuery * query)
+gst_audio_test_src_query (GstBaseSrc * basesrc, GstQuery ** query)
{
GstAudioTestSrc *src = GST_AUDIO_TEST_SRC (basesrc);
gboolean res = FALSE;
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_CONVERT:
{
GstFormat src_fmt, dest_fmt;
gint64 src_val, dest_val;
- gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
+ gst_query_parse_convert (*query, &src_fmt, &src_val, &dest_fmt,
+ &dest_val);
if (src_fmt == dest_fmt) {
dest_val = src_val;
goto done;
goto error;
}
done:
- gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
+ gst_query_set_convert (*query, src_fmt, src_val, dest_fmt, dest_val);
res = TRUE;
break;
}
}
static gboolean
-gst_stream_combiner_src_query (GstPad * pad, GstQuery * query)
+gst_stream_combiner_src_query (GstPad * pad, GstQuery ** query)
{
GstStreamCombiner *stream_combiner =
(GstStreamCombiner *) GST_PAD_PARENT (pad);
}
static gboolean
-gst_stream_splitter_src_query (GstPad * pad, GstQuery * query)
+gst_stream_splitter_src_query (GstPad * pad, GstQuery ** query)
{
GstStreamSplitter *stream_splitter =
(GstStreamSplitter *) GST_PAD_PARENT (pad);
GstStateChange transition);
static void gst_play_bin_handle_message (GstBin * bin, GstMessage * message);
-static gboolean gst_play_bin_query (GstElement * element, GstQuery * query);
+static gboolean gst_play_bin_query (GstElement * element, GstQuery ** query);
static GstTagList *gst_play_bin_get_video_tags (GstPlayBin * playbin,
gint stream);
query = gst_query_new_duration (formats[i]);
ret =
GST_ELEMENT_CLASS (parent_class)->query (GST_ELEMENT_CAST (playbin),
- query);
+ &query);
gst_play_bin_update_cached_duration_from_query (playbin, ret, query);
gst_query_unref (query);
}
}
static gboolean
-gst_play_bin_query (GstElement * element, GstQuery * query)
+gst_play_bin_query (GstElement * element, GstQuery ** query)
{
GstPlayBin *playbin = GST_PLAY_BIN (element);
gboolean ret;
*/
GST_PLAY_BIN_LOCK (playbin);
- if (GST_QUERY_TYPE (query) == GST_QUERY_DURATION) {
+ if (GST_QUERY_TYPE (*query) == GST_QUERY_DURATION) {
GstSourceGroup *group = playbin->curr_group;
gboolean pending;
gint i;
ret = FALSE;
- gst_query_parse_duration (query, &fmt, NULL);
+ gst_query_parse_duration (*query, &fmt, NULL);
for (i = 0; i < G_N_ELEMENTS (playbin->duration); i++) {
if (fmt == playbin->duration[i].format) {
ret = playbin->duration[i].valid;
- gst_query_set_duration (query, fmt,
+ gst_query_set_duration (*query, fmt,
(ret ? playbin->duration[i].duration : -1));
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->query (element, query);
- if (GST_QUERY_TYPE (query) == GST_QUERY_DURATION)
- gst_play_bin_update_cached_duration_from_query (playbin, ret, query);
+ if (GST_QUERY_TYPE (*query) == GST_QUERY_DURATION)
+ gst_play_bin_update_cached_duration_from_query (playbin, ret, *query);
GST_PLAY_BIN_UNLOCK (playbin);
return ret;
}
static gboolean
-gst_stream_synchronizer_query (GstPad * pad, GstQuery * query)
+gst_stream_synchronizer_query (GstPad * pad, GstQuery ** query)
{
GstPad *opad;
gboolean ret = FALSE;
- GST_LOG_OBJECT (pad, "Handling query %s", GST_QUERY_TYPE_NAME (query));
+ GST_LOG_OBJECT (pad, "Handling query %s", GST_QUERY_TYPE_NAME (*query));
opad = gst_stream_get_other_pad_from_pad (pad);
if (opad) {
static void handle_message (GstBin * bin, GstMessage * msg);
static gboolean gst_uri_decode_bin_query (GstElement * element,
- GstQuery * query);
+ GstQuery ** query);
static GstStateChangeReturn gst_uri_decode_bin_change_state (GstElement *
element, GstStateChange transition);
*/
typedef struct
{
- GstQuery *query;
+ GstQuery **query;
gint64 min;
gint64 max;
gboolean seekable;
g_value_set_boolean (ret, TRUE);
- gst_query_parse_duration (fold->query, NULL, &duration);
+ gst_query_parse_duration (*fold->query, NULL, &duration);
GST_DEBUG_OBJECT (item, "got duration %" G_GINT64_FORMAT, duration);
{
GstFormat format;
- gst_query_parse_duration (fold->query, &format, NULL);
+ gst_query_parse_duration (*fold->query, &format, NULL);
/* store max in query result */
- gst_query_set_duration (fold->query, format, fold->max);
+ gst_query_set_duration (*fold->query, format, fold->max);
GST_DEBUG ("max duration %" G_GINT64_FORMAT, fold->max);
}
g_value_set_boolean (ret, TRUE);
- gst_query_parse_position (fold->query, NULL, &position);
+ gst_query_parse_position (*fold->query, NULL, &position);
GST_DEBUG_OBJECT (item, "got position %" G_GINT64_FORMAT, position);
{
GstFormat format;
- gst_query_parse_position (fold->query, &format, NULL);
+ gst_query_parse_position (*fold->query, &format, NULL);
/* store max in query result */
- gst_query_set_position (fold->query, format, fold->max);
+ gst_query_set_position (*fold->query, format, fold->max);
GST_DEBUG_OBJECT (dec, "max position %" G_GINT64_FORMAT, fold->max);
}
g_value_set_boolean (ret, TRUE);
- gst_query_parse_latency (fold->query, &live, &min, &max);
+ gst_query_parse_latency (*fold->query, &live, &min, &max);
GST_DEBUG_OBJECT (item,
"got latency min %" GST_TIME_FORMAT ", max %" GST_TIME_FORMAT
decoder_query_latency_done (GstURIDecodeBin * dec, QueryFold * fold)
{
/* store max in query result */
- gst_query_set_latency (fold->query, fold->live, fold->min, fold->max);
+ gst_query_set_latency (*fold->query, fold->live, fold->min, fold->max);
GST_DEBUG_OBJECT (dec,
"latency min %" GST_TIME_FORMAT ", max %" GST_TIME_FORMAT
gboolean seekable;
g_value_set_boolean (ret, TRUE);
- gst_query_parse_seeking (fold->query, NULL, &seekable, NULL, NULL);
+ gst_query_parse_seeking (*fold->query, NULL, &seekable, NULL, NULL);
GST_DEBUG_OBJECT (item, "got seekable %d", seekable);
{
GstFormat format;
- gst_query_parse_seeking (fold->query, &format, NULL, NULL, NULL);
- gst_query_set_seeking (fold->query, format, fold->seekable, 0, -1);
+ gst_query_parse_seeking (*fold->query, &format, NULL, NULL, NULL);
+ gst_query_set_seeking (*fold->query, format, fold->seekable, 0, -1);
GST_DEBUG_OBJECT (dec, "seekable %d", fold->seekable);
}
* have normally. We should just query all source pads.
*/
static gboolean
-gst_uri_decode_bin_query (GstElement * element, GstQuery * query)
+gst_uri_decode_bin_query (GstElement * element, GstQuery ** query)
{
GstURIDecodeBin *decoder;
gboolean res = FALSE;
decoder = GST_URI_DECODE_BIN (element);
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_DURATION:
/* iterate and collect durations */
fold_func = (GstIteratorFoldFunction) decoder_query_duration_fold;
iter = gst_element_iterate_src_pads (element);
GST_DEBUG_OBJECT (element, "Sending query %p (type %d) to src pads",
- query, GST_QUERY_TYPE (query));
+ *query, GST_QUERY_TYPE (*query));
if (fold_init)
fold_init (decoder, &fold_data);
static gboolean gst_sub_parse_src_event (GstPad * pad, GstEvent * event);
-static gboolean gst_sub_parse_src_query (GstPad * pad, GstQuery * query);
+static gboolean gst_sub_parse_src_query (GstPad * pad, GstQuery ** query);
static gboolean gst_sub_parse_sink_event (GstPad * pad, GstEvent * event);
static GstStateChangeReturn gst_sub_parse_change_state (GstElement * element,
*/
static gboolean
-gst_sub_parse_src_query (GstPad * pad, GstQuery * query)
+gst_sub_parse_src_query (GstPad * pad, GstQuery ** query)
{
GstSubParse *self = GST_SUBPARSE (gst_pad_get_parent (pad));
gboolean ret = FALSE;
- GST_DEBUG ("Handling %s query", GST_QUERY_TYPE_NAME (query));
+ GST_DEBUG ("Handling %s query", GST_QUERY_TYPE_NAME (*query));
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_POSITION:{
GstFormat fmt;
- gst_query_parse_position (query, &fmt, NULL);
+ gst_query_parse_position (*query, &fmt, NULL);
if (fmt != GST_FORMAT_TIME) {
ret = gst_pad_peer_query (self->sinkpad, query);
} else {
ret = TRUE;
- gst_query_set_position (query, GST_FORMAT_TIME,
+ gst_query_set_position (*query, GST_FORMAT_TIME,
self->segment.last_stop);
}
}
ret = TRUE;
- gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);
+ gst_query_parse_seeking (*query, &fmt, NULL, NULL, NULL);
if (fmt == GST_FORMAT_TIME) {
GstQuery *peerquery = gst_query_new_seeking (GST_FORMAT_BYTES);
- seekable = gst_pad_peer_query (self->sinkpad, peerquery);
+ seekable = gst_pad_peer_query (self->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);
+ gst_query_set_seeking (*query, fmt, seekable, seekable ? 0 : -1, -1);
break;
}
static void gst_video_rate_swap_prev (GstVideoRate * videorate,
GstBuffer * buffer, gint64 time);
static gboolean gst_video_rate_event (GstPad * pad, GstEvent * event);
-static gboolean gst_video_rate_query (GstPad * pad, GstQuery * query);
+static gboolean gst_video_rate_query (GstPad * pad, GstQuery ** query);
static GstFlowReturn gst_video_rate_chain (GstPad * pad, GstBuffer * buffer);
static void gst_video_rate_set_property (GObject * object,
}
static gboolean
-gst_video_rate_query (GstPad * pad, GstQuery * query)
+gst_video_rate_query (GstPad * pad, GstQuery ** query)
{
GstVideoRate *videorate;
gboolean res = FALSE;
videorate = GST_VIDEO_RATE (gst_pad_get_parent (pad));
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_LATENCY:
{
GstClockTime min, max;
if ((peer = gst_pad_get_peer (videorate->sinkpad))) {
if ((res = gst_pad_query (peer, query))) {
- gst_query_parse_latency (query, &live, &min, &max);
+ gst_query_parse_latency (*query, &live, &min, &max);
GST_DEBUG_OBJECT (videorate, "Peer latency: min %"
GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
GST_TIME_FORMAT " max %" GST_TIME_FORMAT,
GST_TIME_ARGS (min), GST_TIME_ARGS (max));
- gst_query_set_latency (query, live, min, max);
+ gst_query_set_latency (*query, live, min, max);
}
gst_object_unref (peer);
}
static gboolean gst_video_test_src_is_seekable (GstBaseSrc * psrc);
static gboolean gst_video_test_src_do_seek (GstBaseSrc * bsrc,
GstSegment * segment);
-static gboolean gst_video_test_src_query (GstBaseSrc * bsrc, GstQuery * query);
+static gboolean gst_video_test_src_query (GstBaseSrc * bsrc, GstQuery ** query);
static void gst_video_test_src_get_times (GstBaseSrc * basesrc,
GstBuffer * buffer, GstClockTime * start, GstClockTime * end);
/* find a pool for the negotiated caps now */
query = gst_query_new_allocation (caps, TRUE);
- if (gst_pad_peer_query (bsrc->srcpad, query)) {
+ if (gst_pad_peer_query (bsrc->srcpad, &query)) {
/* we got configuration from our peer, parse them */
gst_query_parse_allocation_params (query, &size, &min, &max, &prefix,
&alignment, &pool);
alignment = 1;
pool = NULL;
}
+ gst_query_unref (query);
if (pool == NULL) {
GstStructure *config;
}
static gboolean
-gst_video_test_src_query (GstBaseSrc * bsrc, GstQuery * query)
+gst_video_test_src_query (GstBaseSrc * bsrc, GstQuery ** query)
{
gboolean res;
GstVideoTestSrc *src;
src = GST_VIDEO_TEST_SRC (bsrc);
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_CONVERT:
{
GstFormat src_fmt, dest_fmt;
gint64 src_val, dest_val;
- gst_query_parse_convert (query, &src_fmt, &src_val, &dest_fmt, &dest_val);
+ gst_query_parse_convert (*query, &src_fmt, &src_val, &dest_fmt,
+ &dest_val);
if (src_fmt == dest_fmt) {
dest_val = src_val;
goto done;
goto error;
}
done:
- gst_query_set_convert (query, src_fmt, src_val, dest_fmt, dest_val);
+ gst_query_set_convert (*query, src_fmt, src_val, dest_fmt, dest_val);
res = TRUE;
break;
}
static gboolean gst_v4lsrc_set_caps (GstBaseSrc * src, GstCaps * caps);
static GstCaps *gst_v4lsrc_get_caps (GstBaseSrc * src);
static GstFlowReturn gst_v4lsrc_create (GstPushSrc * src, GstBuffer ** out);
-static gboolean gst_v4lsrc_query (GstBaseSrc * bsrc, GstQuery * query);
+static gboolean gst_v4lsrc_query (GstBaseSrc * bsrc, GstQuery ** query);
static void gst_v4lsrc_fixate (GstBaseSrc * bsrc, GstCaps * caps);
static void gst_v4lsrc_set_property (GObject * object,
}
static gboolean
-gst_v4lsrc_query (GstBaseSrc * bsrc, GstQuery * query)
+gst_v4lsrc_query (GstBaseSrc * bsrc, GstQuery ** query)
{
GstV4lSrc *v4lsrc;
gboolean res = FALSE;
v4lsrc = GST_V4LSRC (bsrc);
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_LATENCY:
{
GstClockTime min_latency, max_latency;
/* we are always live, the min latency is 1 frame and the max latency is
* the complete buffer of frames. */
- gst_query_set_latency (query, TRUE, min_latency, max_latency);
+ gst_query_set_latency (*query, TRUE, min_latency, max_latency);
res = TRUE;
break;
}
static gboolean
-gst_xvimagesink_sink_query (GstPad * sinkpad, GstQuery * query)
+gst_xvimagesink_sink_query (GstPad * sinkpad, GstQuery ** query)
{
GstXvImageSink *xvimagesink = GST_XVIMAGESINK (GST_PAD_PARENT (sinkpad));
gboolean res = TRUE;
- switch (GST_QUERY_TYPE (query)) {
+ switch (GST_QUERY_TYPE (*query)) {
case GST_QUERY_ALLOCATION:
{
GstCaps *caps;
GstVideoFormat format;
gint width, height;
- gst_query_parse_allocation (query, &caps, &need_pool);
+ gst_query_parse_allocation (*query, &caps, &need_pool);
if (caps == NULL)
goto no_caps;
if (!gst_buffer_pool_set_config (pool, config))
goto config_failed;
}
- gst_query_set_allocation_params (query, size, 0, 0, 0, 16, pool);
+ gst_query_set_allocation_params (*query, size, 0, 0, 0, 16, pool);
/* we also support various metadata */
- gst_query_add_allocation_meta (query, GST_META_API_VIDEO);
+ gst_query_add_allocation_meta (*query, GST_META_API_VIDEO);
break;
}
default:
GstQuery *query;
query = gst_query_new_buffering (GST_FORMAT_PERCENT);
- if (gst_element_query (element, query)) {
+ if (gst_element_query (element, &query)) {
gint64 start, stop, buffering_total;
GstFormat format;
gdouble fill;
GstQuery *query;
query = gst_query_new_buffering (GST_FORMAT_PERCENT);
- if (gst_element_query (element, query)) {
+ if (gst_element_query (element, &query)) {
gint64 start, stop, buffering_total;
GstFormat format;
gdouble fill;
#include <gst/controller/gstinterpolationcontrolsource.h>
static void
-check_position (GstElement * elem, GstQuery * pos, const gchar * info)
+check_position (GstElement * elem, GstQuery ** pos, const gchar * info)
{
if (gst_element_query (elem, pos)) {
gint64 play_pos;
- gst_query_parse_position (pos, NULL, &play_pos);
+ gst_query_parse_position (*pos, NULL, &play_pos);
GST_INFO ("pos : %" GST_TIME_FORMAT " %s", GST_TIME_ARGS (play_pos), info);
} else {
GST_WARNING ("position query failed");
if (gst_element_set_state (bin,
GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE) {
- check_position (bin, pos, "start");
+ check_position (bin, &pos, "start");
if ((wait_ret = gst_clock_id_wait (clock_id, NULL)) != GST_CLOCK_OK) {
GST_WARNING ("clock_id_wait returned: %d", wait_ret);
}
}
gst_clock_id_unref (clock_id);
- check_position (bin, pos, "before seek to new pos");
+ check_position (bin, &pos, "before seek to new pos");
/* seek to 3:00 sec (back 2 sec) */
if (!gst_element_send_event (sink, pos_seek)) {
GST_WARNING ("element failed to seek to new position");
}
- check_position (bin, pos, "after seek to new pos");
+ check_position (bin, &pos, "after seek to new pos");
/* run for 2 seconds */
clock_id =
}
gst_clock_id_unref (clock_id);
- check_position (bin, pos, "before slow down rate change");
+ check_position (bin, &pos, "before slow down rate change");
/* change playback rate to 0.5 */
if (!gst_element_send_event (sink, rate_seek1)) {
GST_WARNING ("element failed to change playback rate");
}
- check_position (bin, pos, "after slow down rate change");
+ check_position (bin, &pos, "after slow down rate change");
/* run for 4 seconds */
clock_id =
}
gst_clock_id_unref (clock_id);
- check_position (bin, pos, "before reverse rate change");
+ check_position (bin, &pos, "before reverse rate change");
/* change playback rate to -1.0 */
if (!gst_element_send_event (sink, rate_seek2)) {
GST_WARNING ("element failed to change playback rate");
}
- check_position (bin, pos, "after reverse rate change");
+ check_position (bin, &pos, "after reverse rate change");
/* run for 7 seconds */
clock_id =
}
gst_clock_id_unref (clock_id);
- check_position (bin, pos, "done");
+ check_position (bin, &pos, "done");
gst_element_set_state (bin, GST_STATE_NULL);
}
gst_caps_unref (caps);
query = gst_query_new_duration (GST_FORMAT_TIME);
- if (gst_pad_query (pad, query)) {
+ if (gst_pad_query (pad, &query)) {
gint64 duration;
gst_query_parse_duration (query, NULL, &duration);
gst_caps_unref (caps);
query = gst_query_new_duration (GST_FORMAT_TIME);
- if (gst_pad_query (pad, query)) {
+ if (gst_pad_query (pad, &query)) {
gint64 duration;
gst_query_parse_duration (query, NULL, &duration);