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 GstCaps * gst_video_rate_getcaps (GstPad * pad) { GstVideoRate *videorate; GstPad *otherpad; GstCaps *caps; videorate = GST_VIDEO_RATE (GST_PAD_PARENT (pad)); otherpad = (pad == videorate->srcpad) ? videorate->sinkpad : videorate->srcpad; /* we can do what the peer can */ caps = gst_pad_peer_get_caps (otherpad); if (caps) { GstCaps *transform; gst_video_rate_transformcaps (otherpad, caps, pad, &transform); gst_caps_unref (caps); caps = transform; } else { /* no peer, our padtemplate is enough then */ caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad)); } return caps; }
/* 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 * rsn_stream_selector_getcaps (GstPad * pad) { GstPad *otherpad; GstObject *parent; GstCaps *caps; otherpad = rsn_stream_selector_get_linked_pad (pad, FALSE); parent = gst_object_get_parent (GST_OBJECT (pad)); if (!otherpad) { GST_DEBUG_OBJECT (parent, "Pad %s:%s not linked, returning ANY", GST_DEBUG_PAD_NAME (pad)); caps = gst_caps_new_any (); } else { GST_DEBUG_OBJECT (parent, "Pad %s:%s is linked (to %s:%s), returning peer caps", GST_DEBUG_PAD_NAME (pad), GST_DEBUG_PAD_NAME (otherpad)); /* if the peer has caps, use those. If the pad is not linked, this function * returns NULL and we return ANY */ if (!(caps = gst_pad_peer_get_caps (otherpad))) caps = gst_caps_new_any (); gst_object_unref (otherpad); } gst_object_unref (parent); return caps; }
static gboolean gst_rtp_h263p_pay_setcaps (GstBaseRTPPayload * 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_get_caps (GST_BASE_RTP_PAYLOAD_SRCPAD (payload)); if (peercaps) { GstCaps *intersect = gst_caps_intersect (peercaps, gst_pad_get_pad_template_caps (GST_BASE_RTP_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_basertppayload_set_options (payload, "video", TRUE, (gchar *) encoding_name, 90000); res = gst_basertppayload_set_outcaps (payload, NULL); g_free (encoding_name); return res; }
static GstCaps * gst_speex_enc_sink_getcaps (GstPad * pad) { GstCaps *caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad)); GstCaps *peercaps = NULL; GstSpeexEnc *enc = GST_SPEEX_ENC (gst_pad_get_parent_element (pad)); peercaps = gst_pad_peer_get_caps (enc->srcpad); if (peercaps) { if (!gst_caps_is_empty (peercaps) && !gst_caps_is_any (peercaps)) { GstStructure *ps = gst_caps_get_structure (peercaps, 0); GstStructure *s = gst_caps_get_structure (caps, 0); gint rate, channels; if (gst_structure_get_int (ps, "rate", &rate)) { gst_structure_fixate_field_nearest_int (s, "rate", rate); } if (gst_structure_get_int (ps, "channels", &channels)) { gst_structure_fixate_field_nearest_int (s, "channels", channels); } } gst_caps_unref (peercaps); } gst_object_unref (enc); return caps; }
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 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_caps_debug_getcaps (GstPad * pad) { GstCaps *caps; GstCapsDebug *capsdebug; gchar *s; GstPad *otherpad; capsdebug = GST_CAPS_DEBUG (gst_pad_get_parent (pad)); otherpad = (pad == capsdebug->srcpad) ? capsdebug->sinkpad : capsdebug->srcpad; GST_INFO ("%s called getcaps", THISPAD); caps = gst_pad_peer_get_caps (otherpad); s = gst_caps_to_string (caps); GST_INFO ("%s returned %s", OTHERPAD, s); g_free (s); if (caps == NULL) caps = gst_caps_new_any (); gst_object_unref (capsdebug); 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_valve_getcaps (GstPad * pad) { GstValve *valve = GST_VALVE (gst_pad_get_parent (pad)); GstCaps *caps; if (pad == valve->sinkpad) caps = gst_pad_peer_get_caps (valve->srcpad); else caps = gst_pad_peer_get_caps (valve->sinkpad); if (caps == NULL) caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad)); gst_object_unref (valve); return 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_smokeenc_getcaps (GstPad * pad) { GstSmokeEnc *smokeenc = GST_SMOKEENC (gst_pad_get_parent (pad)); GstPad *otherpad; GstCaps *result, *caps; const GstCaps *tcaps; const char *name; int i; GstStructure *structure = NULL; /* we want to proxy properties like width, height and framerate from the other end of the element */ otherpad = (pad == smokeenc->srcpad) ? smokeenc->sinkpad : smokeenc->srcpad; /* get template caps, we always need this to fiter the peer caps */ tcaps = gst_pad_get_pad_template_caps (otherpad); /* get any constraints on the peer pad */ caps = gst_pad_peer_get_caps (otherpad); if (caps == NULL) caps = gst_caps_copy (tcaps); else caps = gst_caps_make_writable (caps); /* intersect with the template */ result = gst_caps_intersect (caps, tcaps); gst_caps_unref (caps); if (pad == smokeenc->srcpad) { name = "video/x-smoke"; } else { name = "video/x-raw-yuv"; } /* we can only copy width, height, framerate from one side to the other */ for (i = 0; i < gst_caps_get_size (result); i++) { structure = gst_caps_get_structure (result, i); gst_structure_set_name (structure, name); gst_structure_remove_field (structure, "format"); /* ... but for the sink pad, we only do I420 anyway, so add that */ if (pad == smokeenc->sinkpad) { gst_structure_set (structure, "format", GST_TYPE_FOURCC, GST_STR_FOURCC ("I420"), NULL); } } gst_object_unref (smokeenc); return result; }
static GstCaps * mulawenc_getcaps (GstPad * pad) { GstMuLawEnc *mulawenc; GstPad *otherpad; GstCaps *base_caps, *othercaps; mulawenc = GST_MULAWENC (GST_PAD_PARENT (pad)); base_caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad)); if (pad == mulawenc->srcpad) { otherpad = mulawenc->sinkpad; } else { otherpad = mulawenc->srcpad; } othercaps = gst_pad_peer_get_caps (otherpad); if (othercaps) { GstStructure *structure; const GValue *orate, *ochans; const GValue *rate, *chans; GValue irate = { 0 }, ichans = { 0}; if (gst_caps_is_empty (othercaps) || gst_caps_is_any (othercaps)) goto done; structure = gst_caps_get_structure (othercaps, 0); orate = gst_structure_get_value (structure, "rate"); ochans = gst_structure_get_value (structure, "channels"); if (!orate || !ochans) goto done; structure = gst_caps_get_structure (base_caps, 0); rate = gst_structure_get_value (structure, "rate"); chans = gst_structure_get_value (structure, "channels"); if (!rate || !chans) goto done; gst_value_intersect (&irate, orate, rate); gst_value_intersect (&ichans, ochans, chans); /* Set the samplerate/channels on the to-be-returned caps */ structure = gst_caps_get_structure (base_caps, 0); gst_structure_set_value (structure, "rate", &irate); gst_structure_set_value (structure, "channels", &ichans); done: gst_caps_unref (othercaps); } return base_caps; }
static GstCaps* fs_funnel_getcaps (GstPad * pad) { FsFunnel *funnel = FS_FUNNEL (gst_pad_get_parent (pad)); GstCaps *caps; caps = gst_pad_peer_get_caps (funnel->srcpad); if (caps == NULL) caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad)); gst_object_unref (funnel); return caps; }
static gboolean gst_vis_src_negotiate (GstVisual * visual) { GstCaps *othercaps, *target, *intersect; GstStructure *structure; GstCaps *caps; caps = gst_pad_get_caps (visual->srcpad); /* see what the peer can do */ othercaps = gst_pad_peer_get_caps (visual->srcpad); if (othercaps) { intersect = gst_caps_intersect (othercaps, caps); gst_caps_unref (othercaps); gst_caps_unref (caps); if (gst_caps_is_empty (intersect)) goto no_format; target = gst_caps_copy_nth (intersect, 0); gst_caps_unref (intersect); } else { /* need a copy, we'll be modifying it when fixating */ target = gst_caps_copy (caps); gst_caps_unref (caps); } /* fixate in case something is not fixed. This does nothing if the value is * already fixed. For video we always try to fixate to something like * 320x240x30 by convention. */ structure = gst_caps_get_structure (target, 0); gst_structure_fixate_field_nearest_int (structure, "width", 320); gst_structure_fixate_field_nearest_int (structure, "height", 240); gst_structure_fixate_field_nearest_fraction (structure, "framerate", 30, 1); gst_pad_set_caps (visual->srcpad, target); gst_caps_unref (target); return TRUE; /* ERRORS */ no_format: { GST_ELEMENT_ERROR (visual, STREAM, FORMAT, (NULL), ("could not negotiate output format")); gst_caps_unref (intersect); return FALSE; } }
static GstCaps * gst_selector_pad_getcaps (GstPad * pad) { RsnStreamSelector *sel; GstCaps *caps; sel = RSN_STREAM_SELECTOR (gst_pad_get_parent (pad)); GST_DEBUG_OBJECT (sel, "Getting caps of srcpad peer"); caps = gst_pad_peer_get_caps (sel->srcpad); if (caps == NULL) caps = gst_caps_new_any (); gst_object_unref (sel); return caps; }
static GstCaps * gst_audio_ringbuffer_getcaps (GstPad * pad) { GstAudioRingbuffer *ringbuffer; GstPad *otherpad; GstCaps *result; ringbuffer = GST_AUDIO_RINGBUFFER (GST_PAD_PARENT (pad)); otherpad = (pad == ringbuffer->srcpad ? ringbuffer->sinkpad : ringbuffer->srcpad); result = gst_pad_peer_get_caps (otherpad); if (result == NULL) result = gst_caps_new_any (); return result; }
static void check_peer_caps (GstPad * pad, const char *expected, const char *name) { GstCaps *caps; GstCaps *expected_caps; caps = gst_pad_peer_get_caps (pad); fail_unless (caps != NULL); expected_caps = gst_caps_from_string (expected); fail_unless (expected_caps != NULL); check_caps_identical (caps, expected_caps, name); gst_caps_unref (caps); gst_caps_unref (expected_caps); }
static GstCaps * create_src_caps (GstOmxBaseFilter21 *omx_base) { GstCaps *caps; GstOmxBaseFilter21 *self; int width, height; GstStructure *struc; self = GST_OMX_BASE_FILTER21 (omx_base); caps = gst_pad_peer_get_caps (omx_base->srcpad); if (gst_caps_is_empty (caps)) { width = 1920; height = 1088; } else { GstStructure *s; s = gst_caps_get_structure (caps, 0); if (!(gst_structure_get_int (s, "width", &width) && gst_structure_get_int (s, "height", &height))) { width = 1920; height = 1088; } } caps = gst_caps_new_empty (); struc = gst_structure_new (("video/x-raw-yuv"), "width", G_TYPE_INT, width, "height", G_TYPE_INT, height, "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'), NULL); gst_caps_append_structure (caps, struc); return caps; }
static GstCaps * gst_rtp_depay_getcaps (GstPad * pad) { GstRTPDepay *src; GstPad *other; GstCaps *caps; src = GST_RTP_DEPAY (GST_PAD_PARENT (pad)); other = pad == src->src_rtp ? src->sink_rtp : src->src_rtp; caps = gst_pad_peer_get_caps (other); if (caps == NULL) caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad)); return caps; }
static gboolean gst_teletextdec_push_preroll_buffer (GstTeletextDec * teletext) { GstFlowReturn ret; GstBuffer *buf; gboolean res = TRUE; GstStructure *structure; const gchar *mimetype; GstCaps *out_caps, *peer_caps, *pad_caps; /* the stream is sparse, we send a dummy buffer for preroll */ peer_caps = gst_pad_peer_get_caps (teletext->srcpad); pad_caps = gst_pad_get_caps (teletext->srcpad); out_caps = gst_caps_intersect (pad_caps, peer_caps); if (gst_caps_is_empty (out_caps)) { res = FALSE; goto beach; } gst_caps_truncate (out_caps); structure = gst_caps_get_structure (out_caps, 0); mimetype = gst_structure_get_name (structure); if (g_strcmp0 (mimetype, "video/x-raw-rgb") == 0) { /* omit preroll buffer for this format */ goto beach; } buf = gst_buffer_new_and_alloc (1); GST_BUFFER_DATA (buf)[0] = 0; gst_buffer_set_caps (buf, out_caps); ret = gst_pad_push (teletext->srcpad, buf); if (ret != GST_FLOW_OK) res = FALSE; beach: { gst_caps_unref (out_caps); gst_caps_unref (pad_caps); gst_caps_unref (peer_caps); return res; } }
/* we can only accept caps that we and downstream can handle. */ static GstCaps * gst_interleave_sink_getcaps (GstPad * pad) { GstInterleave *self = GST_INTERLEAVE (gst_pad_get_parent (pad)); GstCaps *result, *peercaps, *sinkcaps; GST_OBJECT_LOCK (self); /* If we already have caps on one of the sink pads return them */ if (self->sinkcaps) { result = gst_caps_copy (self->sinkcaps); } else { /* get the downstream possible caps */ peercaps = gst_pad_peer_get_caps (self->src); /* get the allowed caps on this sinkpad */ sinkcaps = gst_caps_copy (gst_pad_get_pad_template_caps (pad)); __remove_channels (sinkcaps); if (peercaps) { __remove_channels (peercaps); /* if the peer has caps, intersect */ GST_DEBUG_OBJECT (pad, "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 (pad, "no peer caps, using sinkcaps"); result = sinkcaps; } __set_channels (result, 1); } GST_OBJECT_UNLOCK (self); gst_object_unref (self); GST_DEBUG_OBJECT (pad, "Returning caps %" GST_PTR_FORMAT, result); return result; }
static gboolean gst_monoscope_src_negotiate (GstMonoscope * monoscope) { GstCaps *othercaps, *target, *intersect; GstStructure *structure; const GstCaps *templ; templ = gst_pad_get_pad_template_caps (monoscope->srcpad); GST_DEBUG_OBJECT (monoscope, "performing negotiation"); /* see what the peer can do */ othercaps = gst_pad_peer_get_caps (monoscope->srcpad); if (othercaps) { intersect = gst_caps_intersect (othercaps, templ); gst_caps_unref (othercaps); if (gst_caps_is_empty (intersect)) goto no_format; target = gst_caps_copy_nth (intersect, 0); gst_caps_unref (intersect); } else { target = gst_caps_ref ((GstCaps *) templ); } structure = gst_caps_get_structure (target, 0); gst_structure_fixate_field_nearest_int (structure, "width", 320); gst_structure_fixate_field_nearest_int (structure, "height", 240); gst_structure_fixate_field_nearest_fraction (structure, "framerate", 25, 1); gst_pad_set_caps (monoscope->srcpad, target); gst_caps_unref (target); return TRUE; no_format: { gst_caps_unref (intersect); return FALSE; } }
static gboolean gst_goom_src_negotiate (GstGoom * goom) { GstCaps *othercaps, *target; GstStructure *structure; const GstCaps *templ; templ = gst_pad_get_pad_template_caps (goom->srcpad); GST_DEBUG_OBJECT (goom, "performing negotiation"); /* see what the peer can do */ othercaps = gst_pad_peer_get_caps (goom->srcpad); if (othercaps) { target = gst_caps_intersect (othercaps, templ); gst_caps_unref (othercaps); if (gst_caps_is_empty (target)) goto no_format; gst_caps_truncate (target); } else { target = gst_caps_ref ((GstCaps *) templ); } structure = gst_caps_get_structure (target, 0); gst_structure_fixate_field_nearest_int (structure, "width", DEFAULT_WIDTH); gst_structure_fixate_field_nearest_int (structure, "height", DEFAULT_HEIGHT); gst_structure_fixate_field_nearest_fraction (structure, "framerate", DEFAULT_FPS_N, DEFAULT_FPS_D); gst_pad_set_caps (goom->srcpad, target); gst_caps_unref (target); return TRUE; no_format: { gst_caps_unref (target); return FALSE; } }
static GstCaps * gst_compare_getcaps (GstPad * pad) { GstCompare *comp; GstPad *otherpad; GstCaps *result; comp = GST_COMPARE (gst_pad_get_parent (pad)); if (G_UNLIKELY (comp == NULL)) return gst_caps_new_any (); otherpad = (pad == comp->srcpad ? comp->sinkpad : comp->srcpad); result = gst_pad_peer_get_caps (otherpad); if (result == NULL) result = gst_caps_new_any (); gst_object_unref (comp); return result; }
static GstCaps * rsn_parsetter_src_getcaps (GstPad * pad) { RsnParSetter *parset = RSN_PARSETTER (gst_pad_get_parent (pad)); GstCaps *ret; const GstCaps *templ_caps = gst_pad_get_pad_template_caps (pad); ret = gst_pad_peer_get_caps (parset->sinkpad); if (ret == NULL) ret = gst_caps_copy (templ_caps); else { GstCaps *temp; temp = gst_caps_intersect (templ_caps, ret); gst_caps_unref (ret); ret = rsn_parsetter_convert_caps (parset, temp, parset->is_widescreen); gst_caps_unref (temp); } gst_object_unref (parset); return ret; }
static GstCaps * gst_segment_clip_getcaps (GstPad * pad) { GstSegmentClip *self = GST_SEGMENT_CLIP (gst_pad_get_parent (pad)); GstPad *otherpad; GstCaps *tmp, *ret; otherpad = (pad == self->srcpad) ? self->sinkpad : self->srcpad; tmp = gst_pad_peer_get_caps (otherpad); if (tmp) { ret = gst_caps_intersect (tmp, gst_pad_get_pad_template_caps (pad)); gst_caps_unref (tmp); } else { ret = gst_caps_copy (gst_pad_get_pad_template_caps (pad)); } gst_object_unref (self); GST_LOG_OBJECT (pad, "Returning caps: %" GST_PTR_FORMAT, ret); return ret; }