/* copies the given caps */ static GstCaps * gst_csp_caps_remove_format_info (GstCaps * caps) { GstStructure *yuvst, *rgbst, *grayst; /* We know there's only one structure since we're given simple caps */ caps = gst_caps_copy (caps); yuvst = gst_caps_get_structure (caps, 0); gst_structure_set_name (yuvst, "video/x-raw-yuv"); gst_structure_remove_fields (yuvst, "format", "endianness", "depth", "bpp", "red_mask", "green_mask", "blue_mask", "alpha_mask", "palette_data", "color-matrix", NULL); rgbst = gst_structure_copy (yuvst); gst_structure_set_name (rgbst, "video/x-raw-rgb"); gst_structure_remove_fields (rgbst, "color-matrix", "chroma-site", NULL); grayst = gst_structure_copy (rgbst); gst_structure_set_name (grayst, "video/x-raw-gray"); gst_caps_append_structure (caps, rgbst); gst_caps_append_structure (caps, grayst); return caps; }
static GstCaps * gst_gl_filter_transform_caps (GstBaseTransform * bt, GstPadDirection direction, GstCaps * caps) { //GstGLFilter* filter = GST_GL_FILTER (bt); GstStructure *structure = gst_caps_get_structure (caps, 0); GstCaps *ret = gst_caps_copy (caps); const GValue *par = NULL; structure = gst_structure_copy (gst_caps_get_structure (ret, 0)); gst_structure_set (structure, "width", GST_TYPE_INT_RANGE, 1, G_MAXINT, "height", GST_TYPE_INT_RANGE, 1, G_MAXINT, NULL); gst_caps_merge_structure (ret, gst_structure_copy (structure)); if ((par = gst_structure_get_value (structure, "pixel-aspect-ratio"))) { gst_structure_set (structure, "pixel-aspect-ratio", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL); gst_caps_merge_structure (ret, structure); } else gst_structure_free (structure); GST_DEBUG_OBJECT (bt, "returning caps: %" GST_PTR_FORMAT, ret); return ret; }
static GstCaps * gst_alsa_detect_formats (GstObject * obj, snd_pcm_hw_params_t * hw_params, GstCaps * in_caps) { snd_pcm_format_mask_t *mask; GstStructure *s; GstCaps *caps; gint i; snd_pcm_format_mask_malloc (&mask); snd_pcm_hw_params_get_format_mask (hw_params, mask); caps = gst_caps_new_empty (); for (i = 0; i < gst_caps_get_size (in_caps); ++i) { GstStructure *scopy; gint w, width = 0, depth = 0; s = gst_caps_get_structure (in_caps, i); if (!gst_structure_has_name (s, "audio/x-raw-int")) { GST_DEBUG_OBJECT (obj, "skipping non-int format"); continue; } if (!gst_structure_get_int (s, "width", &width) || !gst_structure_get_int (s, "depth", &depth)) continue; if (width == 0 || (width % 8) != 0) continue; /* Only full byte widths are valid */ for (w = 0; w < G_N_ELEMENTS (pcmformats); w++) if (pcmformats[w].width == width && pcmformats[w].depth == depth) break; if (w == G_N_ELEMENTS (pcmformats)) continue; /* Unknown format */ if (snd_pcm_format_mask_test (mask, pcmformats[w].sformat) && snd_pcm_format_mask_test (mask, pcmformats[w].uformat)) { /* template contains { true, false } or just one, leave it as it is */ scopy = gst_structure_copy (s); } else if (snd_pcm_format_mask_test (mask, pcmformats[w].sformat)) { scopy = gst_structure_copy (s); gst_structure_set (scopy, "signed", G_TYPE_BOOLEAN, TRUE, NULL); } else if (snd_pcm_format_mask_test (mask, pcmformats[w].uformat)) { scopy = gst_structure_copy (s); gst_structure_set (scopy, "signed", G_TYPE_BOOLEAN, FALSE, NULL); } else { scopy = NULL; } if (scopy) { if (width > 8) { /* TODO: proper endianness detection, for now it's CPU endianness only */ gst_structure_set (scopy, "endianness", G_TYPE_INT, G_BYTE_ORDER, NULL); } gst_caps_append_structure (caps, scopy); } } snd_pcm_format_mask_free (mask); gst_caps_unref (in_caps); return caps; }
static GstCaps * _set_caps_features_with_passthrough (const GstCaps * caps, const gchar * feature_name, GstCapsFeatures * passthrough) { guint i, j, m, n; GstCaps *tmp; tmp = gst_caps_new_empty (); n = gst_caps_get_size (caps); for (i = 0; i < n; i++) { GstCapsFeatures *features, *orig_features; GstStructure *s = gst_caps_get_structure (caps, i); orig_features = gst_caps_get_features (caps, i); features = gst_caps_features_new (feature_name, NULL); if (gst_caps_features_is_any (orig_features)) { /* if we have any features, we add both the features with and without @passthrough */ gst_caps_append_structure_full (tmp, gst_structure_copy (s), gst_caps_features_copy (features)); m = gst_caps_features_get_size (passthrough); for (j = 0; j < m; j++) { const gchar *feature = gst_caps_features_get_nth (passthrough, j); /* if we already have the features */ if (gst_caps_features_contains (features, feature)) continue; gst_caps_features_add (features, feature); } } else { m = gst_caps_features_get_size (orig_features); for (j = 0; j < m; j++) { const gchar *feature = gst_caps_features_get_nth (orig_features, j); /* if we already have the features */ if (gst_caps_features_contains (features, feature)) continue; if (g_strcmp0 (feature, GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY) == 0) continue; if (gst_caps_features_contains (passthrough, feature)) { gst_caps_features_add (features, feature); } } } gst_caps_append_structure_full (tmp, gst_structure_copy (s), features); } return tmp; }
static GstCaps * gst_video_scale_transform_caps (GstBaseTransform * trans, GstPadDirection direction, GstCaps * caps) { GstCaps *ret; GstStructure *structure; /* this function is always called with a simple caps */ g_return_val_if_fail (GST_CAPS_IS_SIMPLE (caps), NULL); GST_DEBUG_OBJECT (trans, "Transforming caps %" GST_PTR_FORMAT " in direction %s", caps, (direction == GST_PAD_SINK) ? "sink" : "src"); ret = gst_caps_copy (caps); structure = gst_structure_copy (gst_caps_get_structure (ret, 0)); gst_structure_set (structure, "width", GST_TYPE_INT_RANGE, 1, G_MAXINT, "height", GST_TYPE_INT_RANGE, 1, G_MAXINT, NULL); /* if pixel aspect ratio, make a range of it */ if (gst_structure_has_field (structure, "pixel-aspect-ratio")) { gst_structure_set (structure, "pixel-aspect-ratio", GST_TYPE_FRACTION_RANGE, 1, G_MAXINT, G_MAXINT, 1, NULL); } gst_caps_append_structure (ret, structure); GST_DEBUG_OBJECT (trans, "returning caps: %" GST_PTR_FORMAT, ret); return ret; }
/* copies the given caps */ static GstCaps * gst_yuv_to_rgb_caps_remove_format_info (GstCaps * caps) { GstStructure *st; gint i, n; GstCaps *res; res = gst_caps_new_empty (); n = gst_caps_get_size (caps); for (i = 0; i < n; i++) { st = gst_caps_get_structure (caps, i); /* If this is already expressed by the existing caps * skip this structure */ if (i > 0 && gst_caps_is_subset_structure (res, st)) continue; st = gst_structure_copy (st); gst_structure_remove_fields (st, "format", "colorimetry", "chroma-site", NULL); gst_caps_append_structure (res, st); } return res; }
/* * \brief Build the sink of SU's pipeline, if this is a reidrection, modify the caps to pass it to the SP pipeline * \param pipeline the pipepline of the stream * \param input the las element of the pipeline, (avenc_mp4 or capsfilter) as we built our own source * \param caps the caps built from the SDP to replace if you have MPEG-4 or J2K video * \return GstElement* the last element added to the pipeline (RAW: return input, MPEG: mpeg4videoparse, J2k:capsfilter) */ static GstElement *handle_redirection_SU_pipeline ( GstElement *pipeline, GstCaps *caps, GstElement *input){ GstStructure *video_caps = gst_caps_get_structure( caps , 0 ); g_debug("handle_redirection_SU_pipeline: checks and handles Service User's pipeline for redirection"); /* in case MPEG4 video type has been detected */ if (gst_structure_has_name( video_caps, "video/mpeg")){ /* Add the MPEG-4 parser in SU pipeline */ GstElement *parser = gst_element_factory_make_log ("mpeg4videoparse", MPEG4PARSER_NAME); if ( !parser ) return NULL; g_debug("add %s to pipeline", MPEG4PARSER_NAME); gst_bin_add(GST_BIN(pipeline),parser); if ( !gst_element_link_log(input, parser)) return NULL; input = parser; } /* in case J2K video type has been detected */ else if ( g_strv_contains ( J2K_STR_NAMES, gst_structure_get_name(video_caps))){ GstElement *capsfilter = gst_element_factory_make_log("capsfilter", CAPSFITER_J2K_NAME ); GstCaps *caps_jpeg2000 = get_rtpj2kpay_allowed_caps(); /* Put the source in the pipeline */ g_object_set (capsfilter, "caps", caps_jpeg2000 , NULL); g_debug("add %s to pipeline", CAPSFITER_J2K_NAME ); gst_bin_add(GST_BIN(pipeline),capsfilter); if ( !gst_element_link_log(input,capsfilter )){ g_critical("JPEG2000 format can only be %s", gst_caps_to_string( caps_jpeg2000 ) ); return NULL; } input = capsfilter; } /* * Run a new typefind to update caps in order to succeed to run a last typefind in the pipeline of the SP of the * redirection. Update caps in consequence */ video_caps = type_detection(GST_BIN(pipeline), input, NULL); if( !video_caps ) return NULL; gst_caps_append_structure( caps , gst_structure_copy ( video_caps ) ); gst_caps_remove_structure ( caps, 0 ) ; return input; }
static void gst_pulsesrc_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstPulseSrc *pulsesrc = GST_PULSESRC_CAST (object); switch (prop_id) { case PROP_SERVER: g_free (pulsesrc->server); pulsesrc->server = g_value_dup_string (value); if (pulsesrc->probe) gst_pulseprobe_set_server (pulsesrc->probe, pulsesrc->server); break; case PROP_DEVICE: g_free (pulsesrc->device); pulsesrc->device = g_value_dup_string (value); break; case PROP_STREAM_PROPERTIES: if (pulsesrc->properties) gst_structure_free (pulsesrc->properties); pulsesrc->properties = gst_structure_copy (gst_value_get_structure (value)); if (pulsesrc->proplist) pa_proplist_free (pulsesrc->proplist); pulsesrc->proplist = gst_pulse_make_proplist (pulsesrc->properties); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static GstCaps * legacyresample_transform_caps (GstBaseTransform * base, GstPadDirection direction, GstCaps * caps) { const GValue *val; GstStructure *s; GstCaps *res; /* transform single caps into input_caps + input_caps with the rate * field set to our supported range. This ensures that upstream knows * about downstream's prefered rate(s) and can negotiate accordingly. */ res = gst_caps_copy (caps); /* first, however, check if the caps contain a range for the rate field, in * which case that side isn't going to care much about the exact sample rate * chosen and we should just assume things will get fixated to something sane * and we may just as well offer our full range instead of the range in the * caps. If the rate is not an int range value, it's likely to express a * real preference or limitation and we should maintain that structure as * preference by putting it first into the transformed caps, and only add * our full rate range as second option */ s = gst_caps_get_structure (res, 0); val = gst_structure_get_value (s, "rate"); if (val == NULL || GST_VALUE_HOLDS_INT_RANGE (val)) { /* overwrite existing range, or add field if it doesn't exist yet */ gst_structure_set (s, "rate", GST_TYPE_INT_RANGE, 1, G_MAXINT, NULL); } else { /* append caps with full range to existing caps with non-range rate field */ s = gst_structure_copy (s); gst_structure_set (s, "rate", GST_TYPE_INT_RANGE, 1, G_MAXINT, NULL); gst_caps_append_structure (res, s); } return res; }
void ges_base_xml_formatter_add_source (GESBaseXmlFormatter * self, const gchar * track_id, GstStructure * children_properties) { GESBaseXmlFormatterPrivate *priv = _GET_PRIV (self); GESTrackElement *element = NULL; if (track_id[0] != '-' && priv->current_clip) element = _get_element_by_track_id (priv, track_id, priv->current_clip); else if (track_id[0] != '-' && priv->current_pending_clip) { PendingChildProperties *pchildprops; pchildprops = g_slice_new0 (PendingChildProperties); pchildprops->track_id = g_strdup (track_id); pchildprops->structure = children_properties ? gst_structure_copy (children_properties) : NULL; priv->current_pending_clip->children_props = g_list_append (priv->current_pending_clip->children_props, pchildprops); return; } else { element = priv->current_track_element; } if (element == NULL) { GST_WARNING ("No current track element to which we can append children properties"); return; } gst_structure_foreach (children_properties, (GstStructureForeachFunc) _set_child_property, element); }
static void dvb_base_bin_pmt_info_cb (DvbBaseBin * dvbbasebin, GstStructure * pmt) { DvbBaseBinProgram *program; guint program_number; gst_structure_get_uint (pmt, "program-number", &program_number); program = dvb_base_bin_get_program (dvbbasebin, program_number); if (program == NULL) { GST_WARNING ("got PMT for program %d but program not in PAT", program_number); program = dvb_base_bin_add_program (dvbbasebin, program_number); } program->old_pmt = program->pmt; program->pmt = gst_structure_copy (pmt); /* activate the program if it's selected and either it's not active or its pmt * changed */ if (program->selected && (!program->active || program->old_pmt != NULL)) dvb_base_bin_activate_program (dvbbasebin, program); if (program->old_pmt) { gst_structure_free (program->old_pmt); program->old_pmt = NULL; } }
bool GStreamerFormatHelper::HaveElementsToProcessCaps(GstCaps* aCaps) { NS_ASSERTION(sLoadOK, "GStreamer library not linked"); GList* factories = GetFactories(); /* here aCaps contains [containerCaps, [codecCaps1, [codecCaps2, ...]]] so process * caps structures individually as we want one element for _each_ * structure */ for (unsigned int i = 0; i < gst_caps_get_size(aCaps); i++) { GstStructure* s = gst_caps_get_structure(aCaps, i); GstCaps* caps = gst_caps_new_full(gst_structure_copy(s), nullptr); bool found = false; for (GList *elem = factories; elem; elem = elem->next) { if (SupportsCaps(GST_ELEMENT_FACTORY_CAST(elem->data), caps)) { found = true; break; } } gst_caps_unref(caps); if (!found) { return false; } } return true; }
/* copies the given caps */ static GstCaps * gst_video_convert_caps_remove_format_info (GstCaps * caps) { GstStructure *st; GstCapsFeatures *f; gint i, n; GstCaps *res; res = gst_caps_new_empty (); n = gst_caps_get_size (caps); for (i = 0; i < n; i++) { st = gst_caps_get_structure (caps, i); f = gst_caps_get_features (caps, i); /* If this is already expressed by the existing caps * skip this structure */ if (i > 0 && gst_caps_is_subset_structure_full (res, st, f)) continue; st = gst_structure_copy (st); /* Only remove format info for the cases when we can actually convert */ if (!gst_caps_features_is_any (f) && gst_caps_features_is_equal (f, GST_CAPS_FEATURES_MEMORY_SYSTEM_MEMORY)) gst_structure_remove_fields (st, "format", "colorimetry", "chroma-site", NULL); gst_caps_append_structure_full (res, st, gst_caps_features_copy (f)); } return res; }
/** * gst_dvbsub_overlay_intersect_by_feature: * * Creates a new #GstCaps based on the following filtering rule. * * For each individual caps contained in given caps, if the * caps uses the given caps feature, keep a version of the caps * with the feature and an another one without. Otherwise, intersect * the caps with the given filter. * * Returns: the new #GstCaps */ static GstCaps * gst_dvbsub_overlay_intersect_by_feature (GstCaps * caps, const gchar * feature, GstCaps * filter) { int i, caps_size; GstCaps *new_caps; new_caps = gst_caps_new_empty (); caps_size = gst_caps_get_size (caps); for (i = 0; i < caps_size; i++) { GstStructure *caps_structure = gst_caps_get_structure (caps, i); GstCapsFeatures *caps_features = gst_caps_features_copy (gst_caps_get_features (caps, i)); GstCaps *filtered_caps; GstCaps *simple_caps = gst_caps_new_full (gst_structure_copy (caps_structure), NULL); gst_caps_set_features (simple_caps, 0, caps_features); if (gst_caps_features_contains (caps_features, feature)) { gst_caps_append (new_caps, gst_caps_copy (simple_caps)); gst_caps_features_remove (caps_features, feature); filtered_caps = gst_caps_ref (simple_caps); } else { filtered_caps = gst_caps_intersect_full (simple_caps, filter, GST_CAPS_INTERSECT_FIRST); } gst_caps_unref (simple_caps); gst_caps_append (new_caps, filtered_caps); } return new_caps; }
static gboolean gst_vaapidecode_ensure_allowed_caps(GstVaapiDecode *decode) { GstCaps *decode_caps; guint i, n_decode_caps; if (decode->allowed_caps) return TRUE; if (!gst_vaapidecode_ensure_display(decode)) goto error_no_display; decode_caps = gst_vaapi_display_get_decode_caps(decode->display); if (!decode_caps) goto error_no_decode_caps; n_decode_caps = gst_caps_get_size(decode_caps); decode->allowed_caps = gst_caps_new_empty(); if (!decode->allowed_caps) goto error_no_memory; for (i = 0; i < n_decode_caps; i++) { GstStructure *structure; structure = gst_caps_get_structure(decode_caps, i); if (!structure) continue; structure = gst_structure_copy(structure); if (!structure) continue; gst_structure_remove_field(structure, "profile"); gst_structure_set( structure, "width", GST_TYPE_INT_RANGE, 1, G_MAXINT, "height", GST_TYPE_INT_RANGE, 1, G_MAXINT, NULL ); gst_caps_merge_structure(decode->allowed_caps, structure); } gst_caps_unref(decode_caps); return TRUE; /* ERRORS */ error_no_display: { GST_DEBUG("failed to retrieve VA display"); return FALSE; } error_no_decode_caps: { GST_DEBUG("failed to retrieve VA decode caps"); return FALSE; } error_no_memory: { GST_DEBUG("failed to allocate allowed-caps set"); gst_caps_unref(decode_caps); return FALSE; } }
static GstStructure * get_channel_free_structure (const GstStructure * in_structure) { GstStructure *s = gst_structure_copy (in_structure); gst_structure_remove_field (s, "channels"); return s; }
static GstCaps * gst_video_scale_transform_caps (GstBaseTransform * trans, GstPadDirection direction, GstCaps * caps, GstCaps * filter) { GstCaps *ret; GstStructure *structure; GstCapsFeatures *features; gint i, n; GST_DEBUG_OBJECT (trans, "Transforming caps %" GST_PTR_FORMAT " in direction %s", caps, (direction == GST_PAD_SINK) ? "sink" : "src"); ret = gst_caps_new_empty (); n = gst_caps_get_size (caps); for (i = 0; i < n; i++) { structure = gst_caps_get_structure (caps, i); features = gst_caps_get_features (caps, i); /* If this is already expressed by the existing caps * skip this structure */ if (i > 0 && gst_caps_is_subset_structure_full (ret, structure, features)) continue; /* make copy */ structure = gst_structure_copy (structure); /* If the features are non-sysmem we can only do passthrough */ if (!gst_caps_features_is_any (features) && gst_caps_features_is_equal (features, GST_CAPS_FEATURES_MEMORY_SYSTEM_MEMORY)) { gst_structure_set (structure, "width", GST_TYPE_INT_RANGE, 1, G_MAXINT, "height", GST_TYPE_INT_RANGE, 1, G_MAXINT, NULL); /* if pixel aspect ratio, make a range of it */ if (gst_structure_has_field (structure, "pixel-aspect-ratio")) { gst_structure_set (structure, "pixel-aspect-ratio", GST_TYPE_FRACTION_RANGE, 1, G_MAXINT, G_MAXINT, 1, NULL); } } gst_caps_append_structure_full (ret, structure, gst_caps_features_copy (features)); } if (filter) { GstCaps *intersection; intersection = gst_caps_intersect_full (filter, ret, GST_CAPS_INTERSECT_FIRST); gst_caps_unref (ret); ret = intersection; } GST_DEBUG_OBJECT (trans, "returning caps: %" GST_PTR_FORMAT, ret); return ret; }
static GstSample * _gst_sample_copy (GstSample * sample) { GstSample *copy; copy = gst_sample_new (sample->buffer, sample->caps, &sample->segment, gst_structure_copy (sample->info)); return copy; }
static gboolean structure_can_intersect (const GstStructure *st1, const GstStructure *st2) { /* Since there is no API to intersect GstStructures, we cheat (thanks * for the idea, tpm!) and make caps from the structuresa */ GstCaps *caps1, *caps2; gboolean ret; caps1 = gst_caps_new_full (gst_structure_copy (st1), NULL); caps2 = gst_caps_new_full (gst_structure_copy (st2), NULL); ret = gst_caps_can_intersect (caps1, caps2); gst_caps_unref (caps1); gst_caps_unref (caps2); return ret; }
EXPORT_C #endif GstTagList * gst_tag_list_copy (const GstTagList * list) { g_return_val_if_fail (GST_IS_TAG_LIST (list), NULL); return GST_TAG_LIST (gst_structure_copy ((GstStructure *) list)); }
static GstCaps* gst_imx_blitter_video_transform_transform_caps(GstBaseTransform *transform, G_GNUC_UNUSED GstPadDirection direction, GstCaps *caps, GstCaps *filter) { GstCaps *tmpcaps1, *tmpcaps2, *result; GstStructure *structure; gint i, n; tmpcaps1 = gst_caps_new_empty(); n = gst_caps_get_size(caps); for (i = 0; i < n; i++) { structure = gst_caps_get_structure(caps, i); /* If this is already expressed by the existing caps * skip this structure */ if ((i > 0) && gst_caps_is_subset_structure(tmpcaps1, structure)) continue; /* make copy */ structure = gst_structure_copy(structure); gst_structure_set( structure, "width", GST_TYPE_INT_RANGE, 64, G_MAXINT, "height", GST_TYPE_INT_RANGE, 64, G_MAXINT, NULL ); /* colorimetry is not supported by the videotransform element */ gst_structure_remove_fields(structure, "format", "colorimetry", "chroma-site", NULL); /* if pixel aspect ratio, make a range of it */ if (gst_structure_has_field(structure, "pixel-aspect-ratio")) { gst_structure_set( structure, "pixel-aspect-ratio", GST_TYPE_FRACTION_RANGE, 1, G_MAXINT, G_MAXINT, 1, NULL ); } gst_caps_append_structure(tmpcaps1, structure); } /* filter the resulting caps if necessary */ if (filter != NULL) { tmpcaps2 = gst_caps_intersect_full(filter, tmpcaps1, GST_CAPS_INTERSECT_FIRST); gst_caps_unref(tmpcaps1); tmpcaps1 = tmpcaps2; } result = tmpcaps1; GST_DEBUG_OBJECT(transform, "transformed %" GST_PTR_FORMAT " into %" GST_PTR_FORMAT, (gpointer)caps, (gpointer)result); return result; }
static void check_filter_varargs (const gchar * name, GstEvent * event, gint num_buffers, const gchar * prop, va_list varargs) { static const struct { const int width, height; } resolutions[] = { { 384, 288}, { 385, 289}, { 385, 385}}; gint i, n, r; gint size; GstCaps *allcaps, *templ = gst_caps_from_string (VIDEO_CAPS_TEMPLATE_STRING); allcaps = gst_caps_normalize (templ); n = gst_caps_get_size (allcaps); for (i = 0; i < n; i++) { GstStructure *s = gst_caps_get_structure (allcaps, i); GstCaps *caps = gst_caps_new_empty (); gst_caps_append_structure (caps, gst_structure_copy (s)); /* try various resolutions */ for (r = 0; r < G_N_ELEMENTS (resolutions); ++r) { GstVideoInfo info; va_list args_cp; caps = gst_caps_make_writable (caps); gst_caps_set_simple (caps, "width", G_TYPE_INT, resolutions[r].width, "height", G_TYPE_INT, resolutions[r].height, "framerate", GST_TYPE_FRACTION, 25, 1, NULL); GST_DEBUG ("Testing with caps: %" GST_PTR_FORMAT, caps); gst_video_info_from_caps (&info, caps); size = GST_VIDEO_INFO_SIZE (&info); if (event) gst_event_ref (event); va_copy (args_cp, varargs); check_filter_caps (name, event, caps, size, num_buffers, prop, args_cp); va_end (args_cp); } gst_caps_unref (caps); } gst_caps_unref (allcaps); if (event) gst_event_unref (event); }
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; }
/* For each raw video structure, adds a variant with format unset */ static gboolean fix_video_caps_format(GstCapsFeatures *f, GstStructure *s, gpointer user_data) { GstCaps *ret = GST_CAPS(user_data); OWR_UNUSED(f); gst_caps_append_structure(ret, gst_structure_copy(s)); /* Don't mess with non-raw structures */ if (!gst_structure_has_name(s, "video/x-raw")) goto done; if (gst_structure_has_field(s, "format")) { GstStructure *tmp = gst_structure_copy(s); gst_structure_remove_field(tmp, "format"); gst_caps_append_structure(ret, tmp); } done: return TRUE; }
static GstCaps * gst_ffmpegscale_transform_caps (GstBaseTransform * trans, GstPadDirection direction, GstCaps * caps, GstCaps * filter) { GstCaps *ret; GstStructure *structure; const GValue *par; /* this function is always called with a simple caps */ g_return_val_if_fail (GST_CAPS_IS_SIMPLE (caps), NULL); structure = gst_caps_get_structure (caps, 0); ret = gst_caps_copy (caps); structure = gst_structure_copy (gst_caps_get_structure (ret, 0)); gst_structure_set (structure, "width", GST_TYPE_INT_RANGE, 1, G_MAXINT, "height", GST_TYPE_INT_RANGE, 1, G_MAXINT, NULL); ret = gst_caps_merge_structure (ret, gst_structure_copy (structure)); /* if pixel aspect ratio, make a range of it */ if ((par = gst_structure_get_value (structure, "pixel-aspect-ratio"))) { gst_structure_set (structure, "pixel-aspect-ratio", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL); ret = gst_caps_merge_structure (ret, structure); } else { gst_structure_free (structure); } /* now also unfix colour space format */ gst_caps_append (ret, gst_ffmpegscale_caps_remove_format_info (ret)); GST_DEBUG_OBJECT (trans, "returning caps: %" GST_PTR_FORMAT, ret); return ret; }
/* For each raw video structure, adds a variant with framerate unset */ static gboolean fix_video_caps_framerate(GstCapsFeatures *f, GstStructure *s, gpointer user_data) { GstCaps *ret = GST_CAPS(user_data); gint fps_n, fps_d; gst_caps_append_structure_full(ret, gst_structure_copy(s), f ? gst_caps_features_copy(f) : NULL); /* Don't mess with non-raw structures */ if (!gst_structure_has_name(s, "video/x-raw")) goto done; /* If possible try to limit the framerate at the source already */ if (gst_structure_get_fraction(s, "framerate", &fps_n, &fps_d)) { GstStructure *tmp = gst_structure_copy(s); gst_structure_remove_field(tmp, "framerate"); gst_caps_append_structure_full(ret, tmp, f ? gst_caps_features_copy(f) : NULL); } done: return TRUE; }
/** * gst_buffer_pool_get_config: * @pool: a #GstBufferPool * * Get a copy of the current configuration of the pool. This configuration * can either be modified and used for the gst_buffer_pool_set_config() call * or it must be freed after usage. * * Returns: (transfer full): a copy of the current configuration of @pool. use * gst_structure_free() after usage or gst_buffer_pool_set_config(). */ GstStructure * gst_buffer_pool_get_config (GstBufferPool * pool) { GstStructure *result; g_return_val_if_fail (GST_IS_BUFFER_POOL (pool), NULL); GST_BUFFER_POOL_LOCK (pool); result = gst_structure_copy (pool->priv->config); GST_BUFFER_POOL_UNLOCK (pool); return result; }
static GstRTSPToken * _gst_rtsp_token_copy (GstRTSPTokenImpl * token) { GstRTSPTokenImpl *copy; GstStructure *structure; structure = gst_structure_copy (token->structure); copy = g_slice_new0 (GstRTSPTokenImpl); gst_rtsp_token_init (copy, structure); return (GstRTSPToken *) copy; }
/****************************************************************************** * gst_tiprepencbuf_transform_caps * Most platforms require that the exact same caps are used on both ends. * DM6467 can also convert from Y8C8/NV16 to NV12. *****************************************************************************/ static GstCaps* gst_tiprepencbuf_transform_caps(GstBaseTransform * trans, GstPadDirection direction, GstCaps * caps) { GstTIPrepEncBuf *prepencbuf = GST_TIPREPENCBUF(trans); GstCaps *supported_caps; GstStructure *caps_struct; g_return_val_if_fail(GST_IS_CAPS(caps), NULL); /* We always support the same caps on both sides */ supported_caps = gst_caps_copy(caps); /* On DM6467, we also support conversion from Y8C8/NV16 to NV12 */ if (prepencbuf->device == Cpu_Device_DM6467) { switch (direction) { case GST_PAD_SINK: caps_struct = gst_structure_copy(gst_caps_get_structure(caps, 0)); gst_structure_set(caps_struct, "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC('N', 'V', '1', '2'), (gchar *) NULL); gst_caps_append_structure(supported_caps, caps_struct); break; case GST_PAD_SRC: caps_struct = gst_structure_copy(gst_caps_get_structure(caps, 0)); gst_structure_set(caps_struct, "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC('N', 'V', '1', '6'), (gchar *) NULL); gst_caps_append_structure(supported_caps, caps_struct); break; case GST_PAD_UNKNOWN: break; } } return supported_caps; }
static GstCaps * extend_caps (GstCaps * caps, gboolean add_private) { guint i, n; GstCaps *ncaps = gst_caps_new_empty (); n = gst_caps_get_size (caps); for (i = 0; i < n; i++) { GstStructure *s = gst_caps_get_structure (caps, i); if (add_private && !gst_structure_has_name (s, "audio/x-private1-ac3")) { GstStructure *ns = gst_structure_copy (s); gst_structure_set_name (ns, "audio/x-private1-ac3"); gst_caps_append_structure (ncaps, ns); } else if (!add_private && gst_structure_has_name (s, "audio/x-private1-ac3")) { GstStructure *ns = gst_structure_copy (s); gst_structure_set_name (ns, "audio/x-ac3"); gst_caps_append_structure (ncaps, ns); ns = gst_structure_copy (s); gst_structure_set_name (ns, "audio/x-eac3"); gst_caps_append_structure (ncaps, ns); } else if (!add_private) { gst_caps_append_structure (ncaps, gst_structure_copy (s)); } } if (add_private) { gst_caps_append (caps, ncaps); } else { gst_caps_unref (caps); caps = ncaps; } return caps; }