static gboolean gst_shape_wipe_src_query (GstPad * pad, GstObject * parent, GstQuery * query) { GstShapeWipe *self = GST_SHAPE_WIPE (parent); gboolean ret; GST_LOG_OBJECT (pad, "Handling query of type '%s'", gst_query_type_get_name (GST_QUERY_TYPE (query))); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_CAPS: { GstCaps *filter, *caps; gst_query_parse_caps (query, &filter); caps = gst_shape_wipe_src_getcaps (pad, filter); gst_query_set_caps_result (query, caps); gst_caps_unref (caps); ret = TRUE; break; } default: ret = gst_pad_peer_query (self->video_sinkpad, query); break; } return ret; }
static gboolean gst_wasapi_src_query (GstBaseSrc * src, GstQuery * query) { GstWasapiSrc *self = GST_WASAPI_SRC (src); gboolean ret = FALSE; GST_DEBUG_OBJECT (self, "query for %s", gst_query_type_get_name (GST_QUERY_TYPE (query))); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_LATENCY:{ GstClockTime min_latency, max_latency; min_latency = self->latency + self->period_time; max_latency = min_latency; GST_DEBUG_OBJECT (self, "reporting latency of min %" 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); ret = TRUE; break; } default: ret = GST_BASE_SRC_CLASS (parent_class)->query (src, query); break; } return ret; }
static gboolean gst_shape_wipe_mask_sink_query (GstPad * pad, GstObject * parent, GstQuery * query) { gboolean ret; GST_LOG_OBJECT (pad, "Handling query of type '%s'", gst_query_type_get_name (GST_QUERY_TYPE (query))); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_CAPS: { GstCaps *filter, *caps; gst_query_parse_caps (query, &filter); caps = gst_shape_wipe_mask_sink_getcaps (pad, filter); gst_query_set_caps_result (query, caps); gst_caps_unref (caps); ret = TRUE; break; } default: ret = gst_pad_query_default (pad, parent, query); break; } return ret; }
static gboolean gst_image_freeze_sink_query (GstPad * pad, GstObject * parent, GstQuery * query) { GstImageFreeze *self = GST_IMAGE_FREEZE (parent); gboolean ret; GST_LOG_OBJECT (pad, "Handling query of type '%s'", gst_query_type_get_name (GST_QUERY_TYPE (query))); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_CAPS: { GstCaps *caps; gst_query_parse_caps (query, &caps); caps = gst_image_freeze_sink_getcaps (self, caps); gst_query_set_caps_result (query, caps); gst_caps_unref (caps); ret = TRUE; break; } default: ret = gst_pad_query_default (pad, parent, query); } return ret; }
static gboolean gst_jp2k_decimator_query (GstPad * pad, GstQuery * query) { GstJP2kDecimator *self = GST_JP2K_DECIMATOR (gst_pad_get_parent (pad)); gboolean ret; GstPad *otherpad; otherpad = (pad == self->srcpad) ? self->sinkpad : self->srcpad; GST_LOG_OBJECT (pad, "Handling query of type '%s'", gst_query_type_get_name (GST_QUERY_TYPE (query))); ret = gst_pad_peer_query (otherpad, query); gst_object_unref (self); return ret; }
static gboolean gst_segment_clip_query (GstPad * pad, GstQuery * query) { GstSegmentClip *self = GST_SEGMENT_CLIP (gst_pad_get_parent (pad)); gboolean ret; GstPad *otherpad; otherpad = (pad == self->srcpad) ? self->sinkpad : self->srcpad; GST_LOG_OBJECT (pad, "Handling query of type '%s'", gst_query_type_get_name (GST_QUERY_TYPE (query))); ret = gst_pad_peer_query (otherpad, query); gst_object_unref (self); return ret; }
static gboolean gst_shape_wipe_src_query (GstPad * pad, GstQuery * query) { GstShapeWipe *self = GST_SHAPE_WIPE (gst_pad_get_parent (pad)); gboolean ret; GstPad *peer = gst_pad_get_peer (self->video_sinkpad); GST_DEBUG_OBJECT (pad, "Handling query of type '%s'", gst_query_type_get_name (GST_QUERY_TYPE (query))); if (!peer) { GST_INFO_OBJECT (pad, "No peer yet"); ret = FALSE; } else { ret = gst_pad_query (peer, query); gst_object_unref (peer); } gst_object_unref (self); return ret; }
static gboolean gst_cdxa_parse_src_query (GstPad * srcpad, GstQuery * query) { GstCDXAParse *cdxa = GST_CDXA_PARSE (gst_pad_get_parent (srcpad)); gboolean res = FALSE; GST_DEBUG_OBJECT (cdxa, "Handling %s query", gst_query_type_get_name (GST_QUERY_TYPE (query))); res = gst_pad_query_default (srcpad, query); if (res) { GstFormat format; gint64 val; switch (GST_QUERY_TYPE (query)) { case GST_QUERY_DURATION: gst_query_parse_duration (query, &format, &val); if (format == GST_FORMAT_BYTES) { val = gst_cdxa_parse_convert_sink_to_src_offset (cdxa, val); gst_query_set_duration (query, format, val); } break; case GST_QUERY_POSITION: gst_query_parse_position (query, &format, &val); if (format == GST_FORMAT_BYTES) { val = gst_cdxa_parse_convert_sink_to_src_offset (cdxa, val); gst_query_set_position (query, format, val); } break; default: break; } } gst_object_unref (cdxa); return res; }
static gboolean owr_inter_src_internal_src_query(GstPad *pad, GstObject *parent, GstQuery *query) { OwrInterSrc *self = OWR_INTER_SRC(gst_object_get_parent(parent)); GstPad *otherpad; gboolean ret = FALSE; if (!self) return ret; GST_LOG_OBJECT(pad, "Handling query of type '%s'", gst_query_type_get_name(GST_QUERY_TYPE(query))); otherpad = g_weak_ref_get(&self->sink_sinkpad); if (otherpad) { ret = gst_pad_peer_query(otherpad, query); gst_object_unref(otherpad); } gst_object_unref(self); return ret; }
static gboolean gst_segment_clip_query (GstPad * pad, GstObject * parent, GstQuery * query) { GstSegmentClip *self = GST_SEGMENT_CLIP (parent); gboolean ret; GST_LOG_OBJECT (pad, "Handling query of type '%s'", gst_query_type_get_name (GST_QUERY_TYPE (query))); if (GST_QUERY_TYPE (query) == GST_QUERY_CAPS) { GstCaps *caps; gst_query_parse_caps (query, &caps); caps = gst_segment_clip_getcaps (self, pad, caps); gst_query_set_caps_result (query, caps); gst_caps_unref (caps); ret = TRUE; } else { ret = gst_pad_query_default (pad, parent, query); } return ret; }
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; } }
static gboolean gst_cdaudio_query (GstElement * element, GstQuery * query) { GstCDAudio *cdaudio; gboolean res = TRUE; gulong micros; gdouble seconds; cdaudio = GST_CDAUDIO (element); GST_LOG_OBJECT (element, "handling %s query", gst_query_type_get_name (GST_QUERY_TYPE (query))); /* take new snapshot every 1000 miliseconds */ seconds = g_timer_elapsed (cdaudio->timer, µs); if (micros > 1000 || seconds > 1) { cd_stat (cdaudio->cd_desc, &cdaudio->info); g_timer_start (cdaudio->timer); } switch (GST_QUERY_TYPE (query)) { case GST_QUERY_DURATION: { GstFormat dest_format; gint64 dest_val; gst_query_parse_duration (query, &dest_format, NULL); switch (dest_format) { case GST_FORMAT_TIME: dest_val = (cdaudio->info.disc_length.minutes * 60 + cdaudio->info.disc_length.seconds) * GST_SECOND; break; default: { if (dest_format == track_format) { dest_val = cdaudio->info.disc_total_tracks; } else { res = FALSE; } break; } } if (res) gst_query_set_duration (query, dest_format, dest_val); break; } case GST_QUERY_POSITION: { GstFormat dest_format; gint64 dest_val; gst_query_parse_position (query, &dest_format, NULL); switch (dest_format) { case GST_FORMAT_TIME: dest_val = (cdaudio->info.disc_time.minutes * 60 + cdaudio->info.disc_time.seconds) * GST_SECOND; break; default: { if (dest_format == track_format) { dest_val = cdaudio->info.disc_current_track; } else { res = FALSE; } break; } } if (res) gst_query_set_position (query, dest_format, dest_val); break; } default: res = FALSE; break; } return res; }
static gboolean stereosplit_sink_query (GstPad * pad, GstObject * parent, GstQuery * query) { GstGLStereoSplit *split = GST_GL_STEREOSPLIT (parent); GST_DEBUG_OBJECT (split, "sink query %s", gst_query_type_get_name (GST_QUERY_TYPE (query))); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_CONTEXT: { const gchar *context_type; GstContext *context, *old_context; gboolean ret; ret = gst_gl_handle_context_query ((GstElement *) split, query, &split->display, &split->other_context); if (split->display) gst_gl_display_filter_gl_api (split->display, SUPPORTED_GL_APIS); gst_query_parse_context_type (query, &context_type); if (g_strcmp0 (context_type, "gst.gl.local_context") == 0) { GstStructure *s; gst_query_parse_context (query, &old_context); if (old_context) context = gst_context_copy (old_context); else context = gst_context_new ("gst.gl.local_context", FALSE); s = gst_context_writable_structure (context); gst_structure_set (s, "context", GST_GL_TYPE_CONTEXT, split->context, NULL); gst_query_set_context (query, context); gst_context_unref (context); ret = split->context != NULL; } GST_LOG_OBJECT (split, "context query of type %s %i", context_type, ret); if (ret) return ret; return gst_pad_query_default (pad, parent, query); } case GST_QUERY_ALLOCATION: { return stereosplit_propose_allocation (split, query); } case GST_QUERY_ACCEPT_CAPS: { GstCaps *possible, *caps; gboolean allowed; gst_query_parse_accept_caps (query, &caps); if (!(possible = gst_pad_query_caps (split->sink_pad, caps))) return FALSE; allowed = gst_caps_is_subset (caps, possible); gst_caps_unref (possible); gst_query_set_accept_caps_result (query, allowed); return allowed; } case GST_QUERY_CAPS: { GstCaps *filter, *left, *right, *combined, *ret, *templ_caps; gst_query_parse_caps (query, &filter); /* Calculate what downstream can collectively support */ if (!(left = gst_pad_peer_query_caps (split->left_pad, NULL))) return FALSE; if (!(right = gst_pad_peer_query_caps (split->right_pad, NULL))) return FALSE; /* Strip out multiview mode and flags that might break the * intersection, since we can convert. * We could keep downstream preferred flip/flopping and list * separated as preferred in the future which might * theoretically allow us an easier conversion, but it's not essential */ left = strip_mview_fields (left, GST_VIDEO_MULTIVIEW_FLAGS_NONE); right = strip_mview_fields (right, GST_VIDEO_MULTIVIEW_FLAGS_NONE); combined = gst_caps_intersect (left, right); gst_caps_unref (left); gst_caps_unref (right); /* Intersect peer caps with our template formats */ templ_caps = gst_pad_get_pad_template_caps (split->left_pad); ret = gst_caps_intersect_full (combined, templ_caps, GST_CAPS_INTERSECT_FIRST); gst_caps_unref (templ_caps); gst_caps_unref (combined); combined = ret; if (!combined || gst_caps_is_empty (combined)) { gst_caps_unref (combined); return FALSE; } /* Convert from the src pad caps to input formats we support */ ret = stereosplit_transform_caps (split, GST_PAD_SRC, combined, filter); gst_caps_unref (combined); combined = ret; /* Intersect with the sink pad template then */ templ_caps = gst_pad_get_pad_template_caps (split->sink_pad); ret = gst_caps_intersect_full (combined, templ_caps, GST_CAPS_INTERSECT_FIRST); gst_caps_unref (templ_caps); GST_LOG_OBJECT (split, "Returning sink pad caps %" GST_PTR_FORMAT, ret); gst_query_set_caps_result (query, ret); return !gst_caps_is_empty (ret); } default: return gst_pad_query_default (pad, parent, query); } }
static gboolean gst_image_freeze_src_query (GstPad * pad, GstObject * parent, GstQuery * query) { GstImageFreeze *self = GST_IMAGE_FREEZE (parent); gboolean ret = FALSE; GST_LOG_OBJECT (pad, "Handling query of type '%s'", gst_query_type_get_name (GST_QUERY_TYPE (query))); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_CONVERT: { GstFormat src_format, dest_format; gint64 src_value, dest_value; gst_query_parse_convert (query, &src_format, &src_value, &dest_format, &dest_value); ret = gst_image_freeze_convert (self, src_format, src_value, &dest_format, &dest_value); if (ret) gst_query_set_convert (query, src_format, src_value, dest_format, dest_value); break; } case GST_QUERY_POSITION: { GstFormat format; gint64 position; gst_query_parse_position (query, &format, NULL); switch (format) { case GST_FORMAT_DEFAULT: { g_mutex_lock (&self->lock); position = self->offset; g_mutex_unlock (&self->lock); ret = TRUE; break; } case GST_FORMAT_TIME: { g_mutex_lock (&self->lock); position = self->segment.position; g_mutex_unlock (&self->lock); ret = TRUE; break; } default: break; } if (ret) { gst_query_set_position (query, format, position); GST_DEBUG_OBJECT (pad, "Returning position %" G_GINT64_FORMAT " in format %s", position, gst_format_get_name (format)); } else { GST_DEBUG_OBJECT (pad, "Position query failed"); } break; } case GST_QUERY_DURATION: { GstFormat format; gint64 duration; gst_query_parse_duration (query, &format, NULL); switch (format) { case GST_FORMAT_TIME: { g_mutex_lock (&self->lock); duration = self->segment.stop; g_mutex_unlock (&self->lock); ret = TRUE; break; } case GST_FORMAT_DEFAULT: { g_mutex_lock (&self->lock); duration = self->segment.stop; if (duration != -1) duration = gst_util_uint64_scale (duration, self->fps_n, GST_SECOND * self->fps_d); g_mutex_unlock (&self->lock); ret = TRUE; break; } default: break; } if (ret) { gst_query_set_duration (query, format, duration); GST_DEBUG_OBJECT (pad, "Returning duration %" G_GINT64_FORMAT " in format %s", duration, gst_format_get_name (format)); } else { GST_DEBUG_OBJECT (pad, "Duration query failed"); } break; } case GST_QUERY_SEEKING: { GstFormat format; gboolean seekable; gst_query_parse_seeking (query, &format, NULL, NULL, NULL); seekable = (format == GST_FORMAT_TIME || format == GST_FORMAT_DEFAULT); gst_query_set_seeking (query, format, seekable, (seekable ? 0 : -1), -1); ret = TRUE; break; } default: ret = FALSE; break; } return ret; }