/* * Set the value of a property for the client src. */ static void gst_dccp_client_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstDCCPClientSrc *src = GST_DCCP_CLIENT_SRC (object); switch (prop_id) { case PROP_PORT: src->port = g_value_get_int (value); break; case PROP_HOST: if (!g_value_get_string (value)) { g_warning ("host property cannot be NULL"); break; } g_free (src->host); src->host = g_strdup (g_value_get_string (value)); break; case PROP_SOCK_FD: src->sock_fd = g_value_get_int (value); break; case PROP_CLOSED: src->closed = g_value_get_boolean (value); break; case PROP_CCID: src->ccid = g_value_get_int (value); break; case PROP_CAPS: { const GstCaps *new_caps_val = gst_value_get_caps (value); GstCaps *new_caps; GstCaps *old_caps; if (new_caps_val == NULL) { new_caps = gst_caps_new_any (); } else { new_caps = gst_caps_copy (new_caps_val); } old_caps = src->caps; src->caps = new_caps; if (old_caps) gst_caps_unref (old_caps); gst_pad_set_caps (GST_BASE_SRC (src)->srcpad, new_caps); break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
GstCaps * gst_vdp_output_buffer_get_allowed_caps (GstVdpDevice * device) { GstCaps *caps, *rgb_caps; gint i; g_return_val_if_fail (GST_IS_VDP_DEVICE (device), NULL); caps = gst_caps_new_empty (); rgb_caps = gst_caps_new_empty (); for (i = 0; i < G_N_ELEMENTS (rgba_formats); i++) { VdpStatus status; VdpBool is_supported; guint max_w, max_h; status = device->vdp_output_surface_query_capabilities (device->device, rgba_formats[i].format, &is_supported, &max_w, &max_h); if (status != VDP_STATUS_OK && status != VDP_STATUS_INVALID_RGBA_FORMAT) { GST_ERROR_OBJECT (device, "Could not get query VDPAU output surface capabilites, " "Error returned from vdpau was: %s", device->vdp_get_error_string (status)); goto error; } if (is_supported) { GstCaps *format_caps; format_caps = gst_caps_new_simple ("video/x-vdpau-output", "rgba-format", G_TYPE_INT, rgba_formats[i].format, "width", GST_TYPE_INT_RANGE, 1, max_w, "height", GST_TYPE_INT_RANGE, 1, max_h, NULL); gst_caps_append (caps, format_caps); format_caps = gst_static_caps_get (&rgba_formats[i].caps); format_caps = gst_caps_copy (format_caps); gst_caps_set_simple (format_caps, "width", GST_TYPE_INT_RANGE, 1, 8192, "height", GST_TYPE_INT_RANGE, 1, 8192, NULL); gst_caps_append (rgb_caps, format_caps); } } gst_caps_append (caps, rgb_caps); error: 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; 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); g_value_init (&v, GST_TYPE_CAPS); iter = gst_element_iterate_sink_pads (GST_ELEMENT (mux)); do { gst_value_set_caps (&v, othercaps); res = gst_iterator_fold (iter, same_clock_rate_fold, &v, pad); gst_iterator_resync (iter); } while (res == GST_ITERATOR_RESYNC); gst_iterator_free (iter); caps = (GstCaps *) gst_value_get_caps (&v); if (res == GST_ITERATOR_ERROR) { gst_caps_unref (caps); caps = gst_caps_new_empty (); } gst_caps_unref (othercaps); return caps; }
static GstCaps * gst_image_freeze_sink_getcaps (GstImageFreeze * self, GstCaps * filter) { GstCaps *ret, *tmp, *templ; GstPad *pad; pad = self->sinkpad; if (gst_pad_has_current_caps (pad)) { ret = gst_pad_get_current_caps (pad); goto done; } if (filter) { filter = gst_caps_copy (filter); gst_image_freeze_remove_fps (self, filter); } templ = gst_pad_get_pad_template_caps (pad); tmp = gst_pad_peer_query_caps (self->srcpad, filter); if (tmp) { GST_LOG_OBJECT (self, "peer caps %" GST_PTR_FORMAT, tmp); ret = gst_caps_intersect (tmp, templ); gst_caps_unref (tmp); } else { GST_LOG_OBJECT (self, "going to copy"); ret = gst_caps_copy (templ); } gst_caps_unref (templ); if (filter) gst_caps_unref (filter); ret = gst_caps_make_writable (ret); gst_image_freeze_remove_fps (self, ret); done: GST_LOG_OBJECT (pad, "Returning caps: %" GST_PTR_FORMAT, ret); return ret; }
static GstCaps * gst_audioflinger_sink_getcaps (GstBaseSink * bsink) { GstAudioFlingerSink *audioflinger_sink; GstCaps *caps; audioflinger_sink = GST_AUDIOFLINGERSINK (bsink); GST_DEBUG_OBJECT (audioflinger_sink, "enter,%p", audioflinger_sink->audioflinger_device); if (audioflinger_sink->audioflinger_device == NULL || audioflinger_sink->m_init == FALSE) { caps = gst_caps_copy (gst_pad_get_pad_template_caps (GST_BASE_SINK_PAD (bsink))); } else if (audioflinger_sink->probed_caps) { caps = gst_caps_copy (audioflinger_sink->probed_caps); } else { caps = gst_caps_new_any (); if (caps && !gst_caps_is_empty (caps)) { audioflinger_sink->probed_caps = gst_caps_copy (caps); } } return 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; }
void gst_raw_parse_class_set_src_pad_template (GstRawParseClass * klass, const GstCaps * allowed_caps) { GstElementClass *element_class = GST_ELEMENT_CLASS (klass); g_return_if_fail (GST_IS_RAW_PARSE_CLASS (klass)); g_return_if_fail (allowed_caps != NULL); g_return_if_fail (GST_IS_CAPS (allowed_caps)); gst_element_class_add_pad_template (element_class, gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS, gst_caps_copy (allowed_caps))); }
static GstStateChangeReturn gst_timidity_change_state (GstElement * element, GstStateChange transition) { GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; GstTimidity *timidity = GST_TIMIDITY (element); if (!timidity->initialized) { GST_WARNING ("Timidity renderer is not initialized"); return GST_STATE_CHANGE_FAILURE; } switch (transition) { case GST_STATE_CHANGE_NULL_TO_READY: timidity->out_caps = gst_caps_copy (gst_pad_get_pad_template_caps (timidity->srcpad)); timidity->mididata = NULL; break; case GST_STATE_CHANGE_READY_TO_PAUSED: timidity->mididata_size = 0; break; case GST_STATE_CHANGE_PAUSED_TO_PLAYING: break; default: break; } ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); switch (transition) { case GST_STATE_CHANGE_PLAYING_TO_PAUSED: break; case GST_STATE_CHANGE_PAUSED_TO_READY: if (timidity->song) mid_song_free (timidity->song); timidity->song = NULL; timidity->mididata_size = 0; if (timidity->mididata) { g_free (timidity->mididata); timidity->mididata = NULL; } break; case GST_STATE_CHANGE_READY_TO_NULL: gst_caps_unref (timidity->out_caps); break; default: break; } return ret; }
static GstCaps * gst_ivtc_transform_caps (GstBaseTransform * trans, GstPadDirection direction, GstCaps * caps, GstCaps * filter) { GstCaps *othercaps; int i; othercaps = gst_caps_copy (caps); if (direction == GST_PAD_SRC) { GValue value = G_VALUE_INIT; GValue v = G_VALUE_INIT; g_value_init (&value, GST_TYPE_LIST); g_value_init (&v, G_TYPE_STRING); g_value_set_string (&v, "interleaved"); gst_value_list_append_value (&value, &v); g_value_set_string (&v, "mixed"); gst_value_list_append_value (&value, &v); g_value_set_string (&v, "progressive"); gst_value_list_append_value (&value, &v); for (i = 0; i < gst_caps_get_size (othercaps); i++) { GstStructure *structure = gst_caps_get_structure (othercaps, i); gst_structure_set_value (structure, "interlace-mode", &value); gst_structure_remove_field (structure, "framerate"); } g_value_reset (&value); g_value_reset (&v); } else { for (i = 0; i < gst_caps_get_size (othercaps); i++) { GstStructure *structure = gst_caps_get_structure (othercaps, i); gst_structure_set (structure, "interlace-mode", G_TYPE_STRING, "progressive", NULL); gst_structure_remove_field (structure, "framerate"); } } if (filter) { GstCaps *intersect; intersect = gst_caps_intersect (othercaps, filter); gst_caps_unref (othercaps); othercaps = intersect; } return othercaps; }
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; } }
GstCaps * copy_and_clean_caps (const GstCaps * caps) { GstStructure *s; GstCaps *ret; ret = gst_caps_copy (caps); /* make caps easier to interpret, remove common fields that are likely * to be irrelevant for determining the right plugin (ie. mostly fields * where template caps usually have the standard MIN - MAX range as value) */ s = gst_caps_get_structure (ret, 0); gst_structure_remove_field (s, "codec_data"); gst_structure_remove_field (s, "streamheader"); gst_structure_remove_field (s, "palette_data"); gst_structure_remove_field (s, "pixel-aspect-ratio"); gst_structure_remove_field (s, "framerate"); gst_structure_remove_field (s, "leaf_size"); gst_structure_remove_field (s, "packet_size"); gst_structure_remove_field (s, "block_align"); gst_structure_remove_field (s, "metadata-interval"); /* icy caps */ /* decoders/encoders almost always handle the usual width/height/channel/rate * range (and if we don't remove this then the app will have a much harder * time blacklisting formats it has unsuccessfully tried to install before) */ gst_structure_remove_field (s, "width"); gst_structure_remove_field (s, "depth"); gst_structure_remove_field (s, "height"); gst_structure_remove_field (s, "channels"); gst_structure_remove_field (s, "rate"); /* parsed, framed, stream-format and alignment are going to be handled by * parsers and not relevant for decoders/encoders usually */ gst_structure_remove_field (s, "parsed"); gst_structure_remove_field (s, "framed"); gst_structure_remove_field (s, "stream-format"); gst_structure_remove_field (s, "alignment"); /* rtp fields */ gst_structure_remove_field (s, "config"); gst_structure_remove_field (s, "clock-rate"); gst_structure_remove_field (s, "timestamp-offset"); gst_structure_remove_field (s, "maxps"); gst_structure_remove_field (s, "seqnum-offset"); gst_structure_remove_field (s, "npt-start"); gst_structure_remove_field (s, "npt-stop"); gst_structure_remove_field (s, "play-speed"); gst_structure_remove_field (s, "play-scale"); gst_structure_remove_field (s, "dynamic_range"); return ret; }
static GstCaps * gst_vdp_sink_getcaps (GstBaseSink * bsink) { VdpSink *vdp_sink; GstCaps *caps; vdp_sink = GST_VDP_SINK (bsink); if (vdp_sink->caps) caps = gst_caps_copy (vdp_sink->caps); else caps = gst_static_pad_template_get_caps (&sink_template); return caps; }
EXPORT_C #endif void gst_audio_filter_class_add_pad_templates (GstAudioFilterClass * klass, const GstCaps * allowed_caps) { GstElementClass *element_class = GST_ELEMENT_CLASS (klass); GstPadTemplate *pad_template; g_return_if_fail (GST_IS_AUDIO_FILTER_CLASS (klass)); g_return_if_fail (allowed_caps != NULL); g_return_if_fail (GST_IS_CAPS (allowed_caps)); pad_template = gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS, gst_caps_copy (allowed_caps)); gst_element_class_add_pad_template (element_class, pad_template); gst_object_unref (pad_template); pad_template = gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, gst_caps_copy (allowed_caps)); gst_element_class_add_pad_template (element_class, pad_template); gst_object_unref (pad_template); }
static GstCaps * gst_vdp_output_src_pad_getcaps (GstPad * pad) { GstVdpOutputSrcPad *vdp_pad = (GstVdpOutputSrcPad *) pad; const GstCaps *templ_caps; if (vdp_pad->caps) return gst_caps_ref (vdp_pad->caps); else if ((templ_caps = gst_pad_get_pad_template_caps (pad))) return gst_caps_copy (templ_caps); return NULL; }
static GstCaps * _caps_intersect_texture_target (GstCaps * caps, GstGLTextureTarget target_mask) { GValue targets = G_VALUE_INIT; GstCaps *ret, *target; target = gst_caps_copy (caps); gst_gl_value_set_texture_target_from_mask (&targets, target_mask); gst_caps_set_value (target, "texture-target", &targets); ret = gst_caps_intersect_full (caps, target, GST_CAPS_INTERSECT_FIRST); gst_caps_unref (target); return ret; }
static GstCaps * gst_decklink_sink_audiosink_getcaps (GstPad * pad) { GstDecklinkSink *decklinksink; GstCaps *caps; decklinksink = GST_DECKLINK_SINK (gst_pad_get_parent (pad)); GST_DEBUG_OBJECT (decklinksink, "getcaps"); caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad)); gst_object_unref (decklinksink); return caps; }
GstCaps * gst_gl_caps_replace_all_caps_features (const GstCaps * caps, const gchar * feature_name) { GstCaps *tmp = gst_caps_copy (caps); guint n = gst_caps_get_size (tmp); guint i = 0; for (i = 0; i < n; i++) { gst_caps_set_features (tmp, i, gst_caps_features_from_string (feature_name)); } return tmp; }
static GstCaps * audioresample_transform_caps (GstBaseTransform * base, GstPadDirection direction, GstCaps * caps) { GstCaps *res; GstStructure *structure; /* transform caps gives one single caps so we can just replace * the rate property with our range. */ res = gst_caps_copy (caps); structure = gst_caps_get_structure (res, 0); gst_structure_set (structure, "rate", GST_TYPE_INT_RANGE, 1, G_MAXINT, NULL); return res; }
static GstCaps * gst_ffmpegaudioresample_transform_caps (GstBaseTransform * trans, GstPadDirection direction, GstCaps * caps) { GstCaps *retcaps; GstStructure *struc; retcaps = gst_caps_copy (caps); struc = gst_caps_get_structure (retcaps, 0); gst_structure_set (struc, "rate", GST_TYPE_INT_RANGE, 1, G_MAXINT, NULL); GST_LOG_OBJECT (trans, "returning caps %" GST_PTR_FORMAT, retcaps); return retcaps; }
static GstCaps * gst_decklink_src_audio_src_getcaps (GstPad * pad) { GstDecklinkSrc *decklinksrc; GstCaps *caps; decklinksrc = GST_DECKLINK_SRC (gst_pad_get_parent (pad)); GST_DEBUG_OBJECT (decklinksrc, "getcaps"); caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad)); gst_object_unref (decklinksrc); return caps; }
static GstCaps * gst_aravis_get_caps (GstBaseSrc * src) { GstAravis* gst_aravis = GST_ARAVIS(src); GstCaps *caps; if (gst_aravis->all_caps != NULL) caps = gst_caps_copy (gst_aravis->all_caps); else caps = gst_caps_new_any (); GST_LOG_OBJECT (gst_aravis, "Available caps = %" GST_PTR_FORMAT, caps); return caps; }
static GstCaps * gst_xvidenc_getcaps (GstPad * pad) { GstXvidEnc *xvidenc; GstPad *peer; GstCaps *caps; /* If we already have caps return them */ if (GST_PAD_CAPS (pad)) return gst_caps_ref (GST_PAD_CAPS (pad)); xvidenc = GST_XVIDENC (gst_pad_get_parent (pad)); if (!xvidenc) return gst_caps_new_empty (); peer = gst_pad_get_peer (xvidenc->srcpad); if (peer) { const GstCaps *templcaps; GstCaps *peercaps; guint i, n; peercaps = gst_pad_get_caps (peer); /* Translate peercaps to YUV */ peercaps = gst_caps_make_writable (peercaps); n = gst_caps_get_size (peercaps); for (i = 0; i < n; i++) { GstStructure *s = gst_caps_get_structure (peercaps, i); gst_structure_set_name (s, "video/x-raw-yuv"); gst_structure_remove_field (s, "mpegversion"); gst_structure_remove_field (s, "systemstream"); } templcaps = gst_pad_get_pad_template_caps (pad); caps = gst_caps_intersect (peercaps, templcaps); gst_caps_unref (peercaps); gst_object_unref (peer); peer = NULL; } else { caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad)); } gst_object_unref (xvidenc); return caps; }
static gboolean gst_srtp_dec_sink_setcaps (GstPad * pad, GstObject * parent, GstCaps * caps, gboolean is_rtcp) { GstSrtpDec *filter = GST_SRTP_DEC (parent); GstPad *otherpad; GstStructure *ps; gboolean ret = FALSE; g_return_val_if_fail (gst_caps_is_fixed (caps), FALSE); ps = gst_caps_get_structure (caps, 0); if (gst_structure_has_field_typed (ps, "ssrc", G_TYPE_UINT) && gst_structure_has_field_typed (ps, "roc", G_TYPE_UINT) && gst_structure_has_field_typed (ps, "srtp-cipher", G_TYPE_STRING) && gst_structure_has_field_typed (ps, "srtp-auth", G_TYPE_STRING) && gst_structure_has_field_typed (ps, "srtcp-cipher", G_TYPE_STRING) && gst_structure_has_field_typed (ps, "srtcp-auth", G_TYPE_STRING)) { guint ssrc; gst_structure_get_uint (ps, "ssrc", &ssrc); if (!update_session_stream_from_caps (filter, ssrc, caps)) { GST_WARNING_OBJECT (pad, "Could not create session from pad caps: %" GST_PTR_FORMAT, caps); return FALSE; } } caps = gst_caps_copy (caps); ps = gst_caps_get_structure (caps, 0); gst_structure_remove_fields (ps, "srtp-key", "srtp-cipher", "srtp-auth", "srtcp-cipher", "srtcp-auth", NULL); if (is_rtcp) gst_structure_set_name (ps, "application/x-rtcp"); else gst_structure_set_name (ps, "application/x-rtp"); otherpad = gst_pad_get_element_private (pad); ret = gst_pad_set_caps (otherpad, caps); gst_caps_unref (caps); return ret; }
static GstVideoCodecState * copy_video_codec_state (const GstVideoCodecState * in_state) { GstVideoCodecState *state; g_return_val_if_fail (in_state != NULL, NULL); state = g_slice_new0 (GstVideoCodecState); state->ref_count = 1; state->info = in_state->info; state->caps = gst_caps_copy (in_state->caps); if (in_state->codec_data) state->codec_data = gst_buffer_copy_deep (in_state->codec_data); return state; }
static void _encoding_profile_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstEncodingProfile *prof = (GstEncodingProfile *) object; switch (prop_id) { case PROP_RESTRICTION_CAPS: gst_encoding_profile_set_restriction (prof, gst_caps_copy (gst_value_get_caps (value))); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static GstCaps * gst_sunaudiosink_getcaps (GstBaseSink * bsink) { GstPadTemplate *pad_template; GstCaps *caps = NULL; GstSunAudioSink *sunaudiosink = GST_SUNAUDIO_SINK (bsink); GST_DEBUG_OBJECT (sunaudiosink, "getcaps called"); pad_template = gst_static_pad_template_get (&gst_sunaudiosink_factory); caps = gst_caps_copy (gst_pad_template_get_caps (pad_template)); gst_object_unref (pad_template); return caps; }
/* copies the given caps */ static GstCaps * gst_ffmpegscale_caps_remove_format_info (GstCaps * caps) { int i; GstStructure *structure; caps = gst_caps_copy (caps); for (i = 0; i < gst_caps_get_size (caps); i++) { structure = gst_caps_get_structure (caps, i); gst_structure_remove_field (structure, "format"); } return caps; }
static GstCaps * _set_caps_features (const GstCaps * caps, const gchar * feature_name) { GstCaps *tmp = gst_caps_copy (caps); guint n = gst_caps_get_size (tmp); guint i = 0; for (i = 0; i < n; i++) { GstCapsFeatures *features; features = gst_caps_features_new (feature_name, NULL); gst_caps_set_features (tmp, i, features); } return tmp; }
static gboolean _append_accept_caps_failure_details (GstValidatePadMonitor * monitor, GString * str) { gint i, j; GstCaps *refused_caps = gst_caps_copy (monitor->last_refused_caps); GstCaps *possible_caps = gst_pad_query_caps (monitor->pad, NULL); gchar *caps_str = gst_caps_to_string (monitor->last_refused_caps); StructureIncompatibleFieldsInfo info = { .str = str, .found = FALSE }; g_string_append_printf (str, "\n Caps negotiation failed at pad '%s' as it refused caps: %s", gst_validate_reporter_get_name (GST_VALIDATE_REPORTER (monitor)), caps_str); g_free (caps_str); for (i = 0; i < gst_caps_get_size (refused_caps); i++) { GstStructure *refused_struct = gst_caps_get_structure (refused_caps, i); const gchar *filter_name; const gchar *refused_name = gst_structure_get_name (refused_struct); for (j = 0; j < gst_caps_get_size (possible_caps); j++) { info.caps_struct_num = i, info.filter_caps_struct_num = j, info.filter = gst_caps_get_structure (possible_caps, j); filter_name = gst_structure_get_name (info.filter); if (g_strcmp0 (refused_name, filter_name)) { g_string_append_printf (str, "\n -> Downstream caps struct %d name '%s' differs from " "filter caps struct %d name '%s'", i, refused_name, j, filter_name); continue; } gst_structure_foreach (refused_struct, (GstStructureForeachFunc) _find_structure_incompatible_fields, &info); } } gst_caps_unref (possible_caps); return TRUE; }
static GstCaps * gst_jpegenc_getcaps (GstPad * pad) { GstJpegEnc *jpegenc = GST_JPEGENC (gst_pad_get_parent (pad)); GstCaps *caps, *othercaps; const GstCaps *templ; gint i, j; GstStructure *structure = NULL; /* we want to proxy properties like width, height and framerate from the other end of the element */ othercaps = gst_pad_get_allowed_caps (jpegenc->srcpad); if (othercaps == NULL || gst_caps_is_empty (othercaps) || gst_caps_is_any (othercaps)) { caps = gst_caps_copy (gst_pad_get_pad_template_caps (pad)); goto done; } caps = gst_caps_new_empty (); templ = gst_pad_get_pad_template_caps (pad); for (i = 0; i < gst_caps_get_size (templ); i++) { /* pick fields from peer caps */ for (j = 0; j < gst_caps_get_size (othercaps); j++) { GstStructure *s = gst_caps_get_structure (othercaps, j); const GValue *val; structure = gst_structure_copy (gst_caps_get_structure (templ, i)); if ((val = gst_structure_get_value (s, "width"))) gst_structure_set_value (structure, "width", val); if ((val = gst_structure_get_value (s, "height"))) gst_structure_set_value (structure, "height", val); if ((val = gst_structure_get_value (s, "framerate"))) gst_structure_set_value (structure, "framerate", val); gst_caps_merge_structure (caps, structure); } } done: gst_caps_replace (&othercaps, NULL); gst_object_unref (jpegenc); return caps; }