static GstCaps * gst_gl_mixer_pad_sink_getcaps (GstPad * pad, GstGLMixer * mix, GstCaps * filter) { GstCaps *srccaps; GstCaps *template_caps; GstCaps *filtered_caps; GstCaps *returned_caps; gboolean had_current_caps = TRUE; template_caps = gst_pad_get_pad_template_caps (pad); srccaps = gst_pad_get_current_caps (pad); if (srccaps == NULL) { had_current_caps = FALSE; srccaps = template_caps; } else { srccaps = gst_caps_merge (srccaps, gst_gl_mixer_update_caps (mix, srccaps)); } filtered_caps = srccaps; if (filter) filtered_caps = gst_caps_intersect (srccaps, filter); returned_caps = gst_caps_intersect (filtered_caps, template_caps); if (filter) gst_caps_unref (filtered_caps); if (had_current_caps) gst_caps_unref (template_caps); GST_DEBUG_OBJECT (pad, "returning %" GST_PTR_FORMAT, returned_caps); return returned_caps; }
/* we can only accept caps that we and downstream can handle. * if we have filtercaps set, use those to constrain the target caps. */ static GstCaps * gst_adder_sink_getcaps (GstPad * pad) { GstAdder *adder; GstCaps *result, *peercaps, *sinkcaps, *filter_caps; adder = GST_ADDER (GST_PAD_PARENT (pad)); GST_OBJECT_LOCK (adder); /* take filter */ if ((filter_caps = adder->filter_caps)) gst_caps_ref (filter_caps); GST_OBJECT_UNLOCK (adder); /* get the downstream possible caps */ peercaps = gst_pad_peer_get_caps (adder->srcpad); /* get the allowed caps on this sinkpad, we use the fixed caps function so * that it does not call recursively in this function. */ sinkcaps = gst_pad_get_fixed_caps_func (pad); if (peercaps) { /* restrict with filter-caps if any */ if (filter_caps) { GST_DEBUG_OBJECT (adder, "filtering peer caps"); result = gst_caps_intersect (peercaps, filter_caps); gst_caps_unref (peercaps); peercaps = result; } /* if the peer has caps, intersect */ GST_DEBUG_OBJECT (adder, "intersecting peer and template caps"); result = gst_caps_intersect (peercaps, sinkcaps); gst_caps_unref (peercaps); gst_caps_unref (sinkcaps); } else { /* the peer has no caps (or there is no peer), just use the allowed caps * of this sinkpad. */ /* restrict with filter-caps if any */ if (filter_caps) { GST_DEBUG_OBJECT (adder, "no peer caps, using filtered sinkcaps"); result = gst_caps_intersect (sinkcaps, filter_caps); gst_caps_unref (sinkcaps); } else { GST_DEBUG_OBJECT (adder, "no peer caps, using sinkcaps"); result = sinkcaps; } } if (filter_caps) gst_caps_unref (filter_caps); GST_LOG_OBJECT (adder, "getting caps on pad %p,%s to %" GST_PTR_FORMAT, pad, GST_PAD_NAME (pad), result); return result; }
static GstCaps * gst_frei0r_mixer_get_caps (GstPad * pad) { GstFrei0rMixer *self = GST_FREI0R_MIXER (gst_pad_get_parent (pad)); GstCaps *caps = NULL; if (self->caps) { caps = gst_caps_ref (self->caps); } else { GstCaps *tmp, *tmp1; tmp = gst_caps_copy (gst_pad_get_pad_template_caps (self->src)); tmp1 = gst_pad_peer_get_caps (pad); if (tmp1) { caps = gst_caps_intersect (tmp, tmp1); gst_caps_unref (tmp1); gst_caps_unref (tmp); } else { caps = tmp; } tmp = caps; tmp1 = gst_pad_peer_get_caps (self->sink0); if (tmp1) { caps = gst_caps_intersect (tmp, tmp1); gst_caps_unref (tmp); gst_caps_unref (tmp1); } tmp = caps; tmp1 = gst_pad_peer_get_caps (self->sink1); if (tmp1) { caps = gst_caps_intersect (tmp, tmp1); gst_caps_unref (tmp); gst_caps_unref (tmp1); } if (self->sink2) { tmp = caps; tmp1 = gst_pad_peer_get_caps (self->sink2); if (tmp1) { caps = gst_caps_intersect (tmp, tmp1); gst_caps_unref (tmp); gst_caps_unref (tmp1); } } } gst_object_unref (self); return caps; }
static GstCaps * gst_frame_store_getcaps (GstPad *pad) { GstFrameStore *fs; GstPad *otherpad; GstCaps *caps; const GstCaps *tcaps; fs = GST_FRAME_STORE (gst_pad_get_parent (pad)); otherpad = (pad == fs->srcpad ? fs->sinkpad : fs->srcpad); caps = gst_pad_peer_get_caps (otherpad); tcaps = gst_pad_get_pad_template_caps (pad); if (caps) { GstCaps *icaps; icaps = gst_caps_intersect (caps, tcaps); gst_caps_unref (caps); caps = icaps; } else { caps = gst_caps_copy(tcaps); } gst_object_unref (fs); return caps; }
static gboolean same_clock_rate_fold (const GValue * item, GValue * ret, gpointer user_data) { GstPad *mypad = user_data; GstPad *pad = g_value_get_object (item); GstCaps *peercaps; GstCaps *accumcaps; GstCaps *intersect; if (pad == mypad) return TRUE; accumcaps = g_value_get_boxed (ret); peercaps = gst_pad_peer_query_caps (pad, accumcaps); if (!peercaps) { g_warning ("no peercaps"); return TRUE; } peercaps = gst_caps_make_writable (peercaps); clear_caps (peercaps, TRUE); intersect = gst_caps_intersect (accumcaps, peercaps); g_value_take_boxed (ret, intersect); gst_caps_unref (peercaps); return !gst_caps_is_empty (intersect); }
static GstCaps * fs_videoanyrate_transform_caps (GstBaseTransform *trans, GstPadDirection direction, GstCaps *caps, GstCaps *filter) { GstCaps *mycaps = gst_caps_copy (caps); guint i; if (gst_caps_get_size (mycaps) == 0) return mycaps; GST_DEBUG_OBJECT (trans, "Transforming caps"); for (i = 0; i < gst_caps_get_size (mycaps); i++) { GstStructure *s; s = gst_caps_get_structure (mycaps, i); if (gst_structure_has_field (s, "framerate")) gst_structure_set (s, "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL); } if (filter) { GstCaps *intersected = gst_caps_intersect (mycaps, filter); gst_caps_unref (mycaps); mycaps = intersected; } return mycaps; }
/* we can only accept caps that we and downstream can handle. */ static GstCaps * gst_live_adder_sink_getcaps (GstPad * pad) { GstLiveAdder *adder; GstCaps *result, *peercaps, *sinkcaps; adder = GST_LIVE_ADDER (GST_PAD_PARENT (pad)); /* get the downstream possible caps */ peercaps = gst_pad_peer_get_caps (adder->srcpad); /* get the allowed caps on this sinkpad, we use the fixed caps function so * that it does not call recursively in this function. */ sinkcaps = gst_pad_get_fixed_caps_func (pad); if (peercaps) { /* if the peer has caps, intersect */ GST_DEBUG_OBJECT (adder, "intersecting peer and template caps"); result = gst_caps_intersect (peercaps, sinkcaps); gst_caps_unref (peercaps); gst_caps_unref (sinkcaps); } else { /* the peer has no caps (or there is no peer), just use the allowed caps * of this sinkpad. */ GST_DEBUG_OBJECT (adder, "no peer caps, using sinkcaps"); result = sinkcaps; } return result; }
static GstCaps * gst_decklink_audio_src_get_caps (GstBaseSrc * bsrc, GstCaps * filter) { GstDecklinkAudioSrc *self = GST_DECKLINK_AUDIO_SRC_CAST (bsrc); GstCaps *caps; // We don't support renegotiation caps = gst_pad_get_current_caps (GST_BASE_SRC_PAD (bsrc)); if (!caps) { GstCaps *channel_filter, *templ; templ = gst_pad_get_pad_template_caps (GST_BASE_SRC_PAD (bsrc)); channel_filter = gst_caps_new_simple ("audio/x-raw", "channels", G_TYPE_INT, self->channels, NULL); caps = gst_caps_intersect (channel_filter, templ); gst_caps_unref (channel_filter); gst_caps_unref (templ); } if (filter) { GstCaps *tmp = gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST); gst_caps_unref (caps); caps = tmp; } return caps; }
static GstCaps * gst_gdk_pixbuf_get_capslist (void) { GSList *slist; GSList *slist0; GstCaps *capslist = NULL; GstCaps *return_caps = NULL; GstCaps *tmpl_caps; capslist = gst_caps_new_empty (); slist0 = gdk_pixbuf_get_formats (); for (slist = slist0; slist; slist = g_slist_next (slist)) { GdkPixbufFormat *pixbuf_format; char **mimetypes; char **mimetype; pixbuf_format = slist->data; mimetypes = gdk_pixbuf_format_get_mime_types (pixbuf_format); for (mimetype = mimetypes; *mimetype; mimetype++) { gst_caps_append_structure (capslist, gst_structure_new (*mimetype, NULL)); } g_strfreev (mimetypes); } g_slist_free (slist0); tmpl_caps = gst_static_caps_get (&gst_gdk_pixbuf_sink_template.static_caps); return_caps = gst_caps_intersect (capslist, tmpl_caps); gst_caps_unref (tmpl_caps); gst_caps_unref (capslist); return return_caps; }
GstCaps * gst_opus_dec_getcaps (GstAudioDecoder * dec, GstCaps * filter) { GstCaps *caps, *proxy_filter = NULL, *ret; if (filter) { proxy_filter = gst_caps_copy (filter); gst_opus_dec_caps_extend_channels_options (proxy_filter); gst_opus_dec_caps_extend_rate_options (proxy_filter); } caps = gst_audio_decoder_proxy_getcaps (dec, NULL, proxy_filter); if (proxy_filter) gst_caps_unref (proxy_filter); if (caps) { caps = gst_caps_make_writable (caps); gst_opus_dec_caps_extend_channels_options (caps); gst_opus_dec_caps_extend_rate_options (caps); } if (filter) { ret = gst_caps_intersect (caps, filter); gst_caps_unref (caps); } else { ret = caps; } return ret; }
static GstCaps * gst_video_convert_fixate_caps (GstBaseTransform * trans, GstPadDirection direction, GstCaps * caps, GstCaps * othercaps) { GstCaps *result; GST_DEBUG_OBJECT (trans, "trying to fixate othercaps %" GST_PTR_FORMAT " based on caps %" GST_PTR_FORMAT, othercaps, caps); result = gst_caps_intersect (othercaps, caps); if (gst_caps_is_empty (result)) { gst_caps_unref (result); result = othercaps; } else { gst_caps_unref (othercaps); } GST_DEBUG_OBJECT (trans, "now fixating %" GST_PTR_FORMAT, result); result = gst_caps_make_writable (result); gst_video_convert_fixate_format (trans, caps, result); /* fixate remaining fields */ result = gst_caps_fixate (result); return result; }
static GstCaps * mulawenc_getcaps (GstPad * pad) { GstMuLawEnc *mulawenc; GstPad *otherpad; GstCaps *othercaps, *result; const GstCaps *templ; const gchar *name; gint i; mulawenc = GST_MULAWENC (GST_PAD_PARENT (pad)); /* figure out the name of the caps we are going to return */ if (pad == mulawenc->srcpad) { name = "audio/x-mulaw"; otherpad = mulawenc->sinkpad; } else { name = "audio/x-raw-int"; otherpad = mulawenc->srcpad; } /* get caps from the peer, this can return NULL when there is no peer */ othercaps = gst_pad_peer_get_caps (otherpad); /* get the template caps to make sure we return something acceptable */ templ = gst_pad_get_pad_template_caps (pad); if (othercaps) { /* there was a peer */ othercaps = gst_caps_make_writable (othercaps); /* go through the caps and remove the fields we don't want */ for (i = 0; i < gst_caps_get_size (othercaps); i++) { GstStructure *structure; structure = gst_caps_get_structure (othercaps, i); /* adjust the name */ gst_structure_set_name (structure, name); if (pad == mulawenc->srcpad) { /* remove the fields we don't want */ gst_structure_remove_fields (structure, "width", "depth", "endianness", "signed", NULL); } else { /* add fixed fields */ gst_structure_set (structure, "width", G_TYPE_INT, 16, "depth", G_TYPE_INT, 16, "endianness", G_TYPE_INT, G_BYTE_ORDER, "signed", G_TYPE_BOOLEAN, TRUE, NULL); } } /* filter against the allowed caps of the pad to return our result */ result = gst_caps_intersect (othercaps, templ); gst_caps_unref (othercaps); } else { /* there was no peer, return the template caps */ result = gst_caps_copy (templ); } return result; }
static GstCaps * gst_interlace_getcaps (GstPad * pad) { GstInterlace *interlace; GstPad *otherpad; GstCaps *othercaps; GstCaps *icaps; interlace = GST_INTERLACE (gst_pad_get_parent (pad)); otherpad = (pad == interlace->srcpad) ? interlace->sinkpad : interlace->srcpad; othercaps = gst_pad_peer_get_caps (otherpad); if (othercaps == NULL) { icaps = gst_caps_copy (gst_pad_get_pad_template_caps (otherpad)); } else { icaps = gst_caps_intersect (othercaps, gst_pad_get_pad_template_caps (otherpad)); gst_caps_unref (othercaps); } gst_caps_set_simple (icaps, "interlaced", G_TYPE_BOOLEAN, pad == interlace->srcpad ? TRUE : FALSE, NULL); return icaps; }
static gboolean mx_gst_pad_is_compatible(MxGstGraphElementPad *src, MxGstGraphElementPad *dest) { GstCaps *src_caps = gst_pad_get_caps(src->priv->pad); GstCaps *dest_caps = gst_pad_get_caps(dest->priv->pad); if( (GST_PAD_SRC != gst_pad_get_direction(src->priv->pad)) || (GST_PAD_SINK != gst_pad_get_direction(dest->priv->pad)) ) { return FALSE; } if(gst_caps_is_any(src_caps) || gst_caps_is_any(dest_caps)) { return TRUE; } if(gst_caps_is_empty(src_caps) || gst_caps_is_empty(dest_caps)) { return FALSE; } return !gst_caps_is_empty(gst_caps_intersect(src_caps, dest_caps)); }
static GstCaps * gst_rtp_jitter_buffer_getcaps (GstPad * pad) { GstRtpJitterBuffer *jitterbuffer; GstRtpJitterBufferPrivate *priv; GstPad *other; GstCaps *caps; const GstCaps *templ; jitterbuffer = GST_RTP_JITTER_BUFFER (gst_pad_get_parent (pad)); priv = jitterbuffer->priv; other = (pad == priv->srcpad ? priv->sinkpad : priv->srcpad); caps = gst_pad_peer_get_caps (other); templ = gst_pad_get_pad_template_caps (pad); if (caps == NULL) { GST_DEBUG_OBJECT (jitterbuffer, "copy template"); caps = gst_caps_copy (templ); } else { GstCaps *intersect; GST_DEBUG_OBJECT (jitterbuffer, "intersect with template"); intersect = gst_caps_intersect (caps, templ); gst_caps_unref (caps); caps = intersect; } gst_object_unref (jitterbuffer); return caps; }
static GstCaps * gst_dvd_spu_video_proxy_getcaps (GstPad * pad, GstCaps * filter) { GstDVDSpu *dvdspu = GST_DVD_SPU (gst_pad_get_parent (pad)); GstCaps *caps; GstPad *otherpad; /* Proxy the getcaps between videosink and the srcpad, ignoring the * subpicture sink pad */ otherpad = (pad == dvdspu->srcpad) ? dvdspu->videosinkpad : dvdspu->srcpad; caps = gst_pad_peer_query_caps (otherpad, filter); if (caps) { GstCaps *temp, *templ; templ = gst_pad_get_pad_template_caps (otherpad); temp = gst_caps_intersect (caps, templ); gst_caps_unref (templ); gst_caps_unref (caps); caps = temp; } else { caps = gst_pad_get_pad_template_caps (pad); } gst_object_unref (dvdspu); return caps; }
GstCaps* bayer_transform_intersect (const GstCaps* bayer, const GstCaps* raw) { GstCaps* caps2 = gst_caps_copy(raw); gst_caps_change_name(caps2, "video/x-bayer"); GstCaps* caps1 = gst_caps_intersect((GstCaps*)bayer, caps2); return caps1; }
static gboolean gst_decklink_sink_videosink_query (GstPad * pad, GstObject * parent, GstQuery * query) { gboolean res; GstDecklinkSink *decklinksink; decklinksink = GST_DECKLINK_SINK (parent); GST_DEBUG_OBJECT (decklinksink, "query"); switch (GST_QUERY_TYPE (query)) { case GST_QUERY_CAPS:{ GstCaps *mode_caps, *filter, *caps; /* FIXME: do we change mode if incoming caps change? If yes, we * should probably return the template caps instead */ mode_caps = gst_decklink_mode_get_caps (decklinksink->mode); gst_query_parse_caps (query, &filter); caps = gst_caps_intersect (mode_caps, filter); gst_caps_unref (mode_caps); gst_query_set_caps_result (query, caps); gst_caps_unref (caps); break; } default: res = gst_pad_query_default (pad, parent, query); break; } return res; }
static GstCaps * gst_vdp_sink_get_allowed_caps (GstVdpDevice * device, GValue * par) { GstCaps *templ_caps, *allowed_caps, *caps; gint i; allowed_caps = gst_vdp_output_buffer_get_allowed_caps (device); templ_caps = gst_static_pad_template_get_caps (&sink_template); caps = gst_caps_intersect (allowed_caps, templ_caps); gst_caps_unref (allowed_caps); gst_caps_unref (templ_caps); if (!par) par = gst_vdp_sink_calculate_par (device->display); for (i = 0; i < gst_caps_get_size (caps); i++) { GstStructure *structure; structure = gst_caps_get_structure (caps, i); gst_structure_set_value (structure, "pixel-aspect-ratio", par); } return caps; }
static gboolean gst_rtp_h263p_pay_setcaps (GstRTPBasePayload * payload, GstCaps * caps) { gboolean res; GstCaps *peercaps; gchar *encoding_name = NULL; g_return_val_if_fail (gst_caps_is_fixed (caps), FALSE); peercaps = gst_pad_peer_query_caps (GST_RTP_BASE_PAYLOAD_SRCPAD (payload), NULL); if (peercaps) { GstCaps *intersect = gst_caps_intersect (peercaps, gst_pad_get_pad_template_caps (GST_RTP_BASE_PAYLOAD_SRCPAD (payload))); gst_caps_unref (peercaps); if (!gst_caps_is_empty (intersect)) { GstStructure *s = gst_caps_get_structure (intersect, 0); encoding_name = g_strdup (gst_structure_get_string (s, "encoding-name")); } gst_caps_unref (intersect); } if (!encoding_name) encoding_name = g_strdup ("H263-1998"); gst_rtp_base_payload_set_options (payload, "video", TRUE, (gchar *) encoding_name, 90000); res = gst_rtp_base_payload_set_outcaps (payload, NULL); g_free (encoding_name); return res; }
/* * cheese_camera_device_filter_caps: * @device: the #CheeseCameraDevice * @caps: the #GstCaps that the device supports * @formats: an array of strings of video formats, in the form axb, where a and * b are in units of pixels * * Filter the supplied @caps with %CHEESE_MAXIMUM_RATE to only allow @formats * which can reach the desired framerate. * * Returns: the filtered #GstCaps */ static GstCaps * cheese_camera_device_filter_caps (CheeseCameraDevice *device, GstCaps *caps, const gchar const *formats[]) { GstCaps *filter; GstCaps *allowed; gsize i; filter = gst_caps_new_empty (); for (i = 0; formats[i] != NULL; i++) { gst_caps_append (filter, gst_caps_new_simple (formats[i], "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, CHEESE_MAXIMUM_RATE, 1, NULL)); } allowed = gst_caps_intersect (caps, filter); GST_DEBUG ("Supported caps %" GST_PTR_FORMAT, caps); GST_DEBUG ("Filter caps %" GST_PTR_FORMAT, filter); GST_DEBUG ("Filtered caps %" GST_PTR_FORMAT, allowed); gst_caps_unref (filter); return allowed; }
static GstCaps * gst_genicamsrc_get_caps (GstBaseSrc * bsrc, GstCaps * filter) { GstGenicamSrc *src = GST_GENICAM_SRC (bsrc); GstCaps *caps; if (src->hDS == NULL) { caps = gst_pad_get_pad_template_caps (GST_BASE_SRC_PAD (src)); } else { caps = gst_caps_copy (src->caps); } GST_DEBUG_OBJECT (src, "The caps before filtering are %" GST_PTR_FORMAT, caps); if (filter && caps) { GstCaps *tmp = gst_caps_intersect (caps, filter); gst_caps_unref (caps); caps = tmp; } GST_DEBUG_OBJECT (src, "The caps after filtering are %" GST_PTR_FORMAT, caps); return caps; }
static GstCaps * gst_mse_getcaps (GstPad * pad) { GstMSE *fs; GstCaps *caps; GstCaps *icaps; GstCaps *peercaps; fs = GST_MSE (gst_pad_get_parent (pad)); caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad)); if (pad != fs->srcpad) { peercaps = gst_pad_peer_get_caps (fs->srcpad); if (peercaps) { icaps = gst_caps_intersect (caps, peercaps); gst_caps_unref (caps); gst_caps_unref (peercaps); caps = icaps; } } if (pad != fs->sinkpad_ref) { peercaps = gst_pad_peer_get_caps (fs->sinkpad_ref); if (peercaps) { icaps = gst_caps_intersect (caps, peercaps); gst_caps_unref (caps); gst_caps_unref (peercaps); caps = icaps; } } if (pad != fs->sinkpad_test) { peercaps = gst_pad_peer_get_caps (fs->sinkpad_test); if (peercaps) { icaps = gst_caps_intersect (caps, peercaps); gst_caps_unref (caps); gst_caps_unref (peercaps); caps = icaps; } } gst_object_unref (fs); return caps; }
static GstCaps * gst_rtp_mux_getcaps (GstPad * pad, GstRTPMux * mux, GstCaps * filter) { GstCaps *caps = NULL; GstIterator *iter = NULL; GValue v = { 0 }; GstIteratorResult res; GstCaps *peercaps; GstCaps *othercaps; GstCaps *tcaps; GstCaps *other_filtered; peercaps = gst_pad_peer_query_caps (mux->srcpad, filter); if (peercaps) { tcaps = gst_pad_get_pad_template_caps (pad); othercaps = gst_caps_intersect_full (peercaps, tcaps, GST_CAPS_INTERSECT_FIRST); gst_caps_unref (peercaps); } else { tcaps = gst_pad_get_pad_template_caps (mux->srcpad); if (filter) othercaps = gst_caps_intersect_full (filter, tcaps, GST_CAPS_INTERSECT_FIRST); else othercaps = gst_caps_copy (tcaps); } gst_caps_unref (tcaps); clear_caps (othercaps, FALSE); other_filtered = gst_caps_copy (othercaps); clear_caps (other_filtered, TRUE); g_value_init (&v, GST_TYPE_CAPS); iter = gst_element_iterate_sink_pads (GST_ELEMENT (mux)); do { gst_value_set_caps (&v, other_filtered); res = gst_iterator_fold (iter, same_clock_rate_fold, &v, pad); gst_iterator_resync (iter); } while (res == GST_ITERATOR_RESYNC); gst_iterator_free (iter); gst_caps_unref (other_filtered); caps = gst_caps_intersect ((GstCaps *) gst_value_get_caps (&v), othercaps); g_value_unset (&v); gst_caps_unref (othercaps); if (res == GST_ITERATOR_ERROR) { gst_caps_unref (caps); caps = gst_caps_new_empty (); } return caps; }
static gboolean gst_vdp_vpp_sink_setcaps (GstPad * pad, GstCaps * caps) { GstVdpVideoPostProcess *vpp = GST_VDP_VIDEO_POST_PROCESS (gst_pad_get_parent (pad)); GstStructure *structure; GstCaps *output_caps, *allowed_caps, *src_caps; gboolean res; /* extract interlaced flag */ structure = gst_caps_get_structure (caps, 0); gst_structure_get_boolean (structure, "interlaced", &vpp->interlaced); allowed_caps = gst_pad_get_allowed_caps (vpp->srcpad); structure = gst_caps_get_structure (allowed_caps, 0); output_caps = gst_vdp_video_to_output_caps (caps); src_caps = gst_caps_intersect (output_caps, allowed_caps); gst_caps_truncate (src_caps); if (gst_caps_is_empty (src_caps)) goto invalid_caps; GST_DEBUG ("output_caps: %" GST_PTR_FORMAT " allowed_caps: %" GST_PTR_FORMAT " src_caps: %" GST_PTR_FORMAT, output_caps, allowed_caps, src_caps); gst_caps_unref (output_caps); gst_caps_unref (allowed_caps); if (gst_vdp_vpp_is_interlaced (vpp)) { gint fps_n, fps_d; structure = gst_caps_get_structure (src_caps, 0); if (!gst_structure_get_fraction (structure, "framerate", &fps_n, &fps_d)) { gst_caps_unref (src_caps); goto invalid_caps; } gst_fraction_double (&fps_n, &fps_d); gst_structure_set (structure, "framerate", GST_TYPE_FRACTION, fps_n, fps_d, NULL); gst_structure_remove_field (structure, "interlaced"); vpp->field_duration = gst_util_uint64_scale (GST_SECOND, fps_d, fps_n); } res = gst_pad_set_caps (vpp->srcpad, src_caps); done: gst_object_unref (vpp); return res; invalid_caps: GST_ERROR_OBJECT (vpp, "invalid caps: %" GST_PTR_FORMAT, caps); res = FALSE; goto done; }
static gboolean gst_imx_compositor_sink_query(GstImxBPAggregator *aggregator, GstImxBPAggregatorPad *pad, GstQuery *query) { switch (GST_QUERY_TYPE(query)) { case GST_QUERY_CAPS: { /* Custom caps query response. Take the sinkpad template caps, * optionally filter them, and return them as the result. * This ensures that the caps that the derived class supports * for input data are actually used (by default, the aggregator * base classes try to keep input and output caps equal) */ GstCaps *filter, *caps; gst_query_parse_caps(query, &filter); caps = gst_pad_get_pad_template_caps(GST_PAD(pad)); if (filter != NULL) { GstCaps *unfiltered_caps = gst_caps_make_writable(caps); caps = gst_caps_intersect(unfiltered_caps, filter); gst_caps_unref(unfiltered_caps); } GST_DEBUG_OBJECT(aggregator, "responding to CAPS query with caps %" GST_PTR_FORMAT, (gpointer)caps); gst_query_set_caps_result(query, caps); gst_caps_unref(caps); return TRUE; } case GST_QUERY_ACCEPT_CAPS: { /* Custom accept_caps query response. Simply check if * the supplied caps are a valid subset of the sinkpad's * template caps. This is done for the same reasons * as the caps query response above. */ GstCaps *accept_caps = NULL, *template_caps = NULL; gboolean ret; gst_query_parse_accept_caps(query, &accept_caps); template_caps = gst_pad_get_pad_template_caps(GST_PAD(pad)); ret = gst_caps_is_subset(accept_caps, template_caps); GST_DEBUG_OBJECT(aggregator, "responding to ACCEPT_CAPS query with value %d (acceptcaps: %" GST_PTR_FORMAT " template caps %" GST_PTR_FORMAT ")", ret, (gpointer)accept_caps, (gpointer)template_caps); gst_query_set_accept_caps_result(query, ret); return TRUE; } default: return GST_IMXBP_AGGREGATOR_CLASS(gst_imx_compositor_parent_class)->sink_query(aggregator, pad, query); } }
/** * gst_factory_list_filter: * @array: a #GValueArray to filter * @caps: a #GstCaps * * Filter out all the elementfactories in @array that can handle @caps as * input. * * Returns: a #GValueArray of #GstElementFactory elements. Use * g_value_array_free() after usage. */ GValueArray * gst_factory_list_filter (GValueArray * array, const GstCaps * caps) { GValueArray *result; gint i; result = g_value_array_new (0); GST_DEBUG ("finding factories"); /* loop over all the factories */ for (i = 0; i < array->n_values; i++) { GValue *value; GstElementFactory *factory; const GList *templates; GList *walk; value = g_value_array_get_nth (array, i); factory = g_value_get_object (value); /* get the templates from the element factory */ templates = gst_element_factory_get_static_pad_templates (factory); for (walk = (GList *) templates; walk; walk = g_list_next (walk)) { GstStaticPadTemplate *templ = walk->data; /* we only care about the sink templates */ if (templ->direction == GST_PAD_SINK) { GstCaps *intersect; GstCaps *tmpl_caps; /* try to intersect the caps with the caps of the template */ tmpl_caps = gst_static_caps_get (&templ->static_caps); /* FIXME, intersect is not the right method, we ideally want to check * for a subset here */ intersect = gst_caps_intersect (caps, tmpl_caps); gst_caps_unref (tmpl_caps); /* check if the intersection is empty */ if (!gst_caps_is_empty (intersect)) { /* non empty intersection, we can use this element */ GValue resval = { 0, }; g_value_init (&resval, G_TYPE_OBJECT); g_value_set_object (&resval, factory); g_value_array_append (result, &resval); g_value_unset (&resval); gst_caps_unref (intersect); break; } gst_caps_unref (intersect); } } } return result; }
static GstCaps * gst_alpha_color_transform_caps (GstBaseTransform * btrans, GstPadDirection direction, GstCaps * caps, GstCaps * filter) { GstCaps *tmpl_caps = NULL; GstCaps *result = NULL, *local_caps = NULL; guint i; local_caps = gst_caps_new_empty (); for (i = 0; i < gst_caps_get_size (caps); i++) { GstStructure *structure = gst_structure_copy (gst_caps_get_structure (caps, i)); /* Remove any specific parameter from the structure */ gst_structure_remove_field (structure, "format"); gst_structure_remove_field (structure, "colorimetry"); gst_structure_remove_field (structure, "chroma-site"); gst_structure_set_name (structure, "video/x-raw"); gst_caps_append_structure (local_caps, structure); } /* Get the appropriate template */ if (direction == GST_PAD_SINK) { tmpl_caps = gst_static_pad_template_get_caps (&src_template); } else if (direction == GST_PAD_SRC) { tmpl_caps = gst_static_pad_template_get_caps (&sink_template); } /* Intersect with our template caps */ result = gst_caps_intersect (local_caps, tmpl_caps); gst_caps_unref (tmpl_caps); gst_caps_unref (local_caps); result = gst_caps_simplify (result); GST_LOG_OBJECT (btrans, "transformed %" GST_PTR_FORMAT " to %" GST_PTR_FORMAT, caps, result); if (filter) { GstCaps *intersection; GST_DEBUG_OBJECT (btrans, "Using filter caps %" GST_PTR_FORMAT, filter); intersection = gst_caps_intersect_full (filter, result, GST_CAPS_INTERSECT_FIRST); gst_caps_unref (result); result = intersection; GST_DEBUG_OBJECT (btrans, "Intersection %" GST_PTR_FORMAT, result); } return result; }
static GstCaps * gst_capsfilter_transform_caps (GstBaseTransform * base, GstPadDirection direction, GstCaps * caps) { GstCapsFilter *capsfilter = GST_CAPSFILTER (base); GstCaps *ret; ret = gst_caps_intersect (caps, capsfilter->filter_caps); return ret; }
static MXFMetadataFileDescriptor * mxf_up_get_rgba_descriptor (GstPadTemplate * tmpl, GstCaps * caps, MXFEssenceElementWriteFunc * handler, gpointer * mapping_data) { MXFMetadataRGBAPictureEssenceDescriptor *ret; guint i; GstCaps *tmp, *intersection; MXFUPMappingData *md = g_new0 (MXFUPMappingData, 1); *mapping_data = md; ret = (MXFMetadataRGBAPictureEssenceDescriptor *) gst_mini_object_new (MXF_TYPE_METADATA_RGBA_PICTURE_ESSENCE_DESCRIPTOR); for (i = 0; i < G_N_ELEMENTS (_rgba_mapping_table); i++) { tmp = gst_caps_from_string (_rgba_mapping_table[i].caps); intersection = gst_caps_intersect (caps, tmp); gst_caps_unref (tmp); if (!gst_caps_is_empty (intersection)) { gst_caps_unref (intersection); ret->n_pixel_layout = _rgba_mapping_table[i].n_pixel_layout; ret->pixel_layout = g_new0 (guint8, ret->n_pixel_layout * 2); md->fourcc = _rgba_mapping_table[i].fourcc; md->bpp = _rgba_mapping_table[i].n_pixel_layout; memcpy (ret->pixel_layout, _rgba_mapping_table[i].pixel_layout, ret->n_pixel_layout * 2); break; } gst_caps_unref (intersection); } if (md->fourcc == 0) { GST_ERROR ("Invalid caps %" GST_PTR_FORMAT, caps); gst_mini_object_unref (GST_MINI_OBJECT_CAST (ret)); return NULL; } memcpy (&ret->parent.parent.essence_container, &up_essence_container_ul, 16); if (!mxf_metadata_generic_picture_essence_descriptor_from_caps (&ret->parent, caps)) { gst_mini_object_unref (GST_MINI_OBJECT_CAST (ret)); return NULL; } md->width = ret->parent.stored_width; md->height = ret->parent.stored_height; *handler = mxf_up_write_func; return (MXFMetadataFileDescriptor *) ret; }