static void gst_base_audio_src_fixate (GstBaseSrc * bsrc, GstCaps * caps) { GstStructure *s; gint width, depth; s = gst_caps_get_structure (caps, 0); /* fields for all formats */ gst_structure_fixate_field_nearest_int (s, "rate", 44100); gst_structure_fixate_field_nearest_int (s, "channels", 2); gst_structure_fixate_field_nearest_int (s, "width", 16); /* fields for int */ if (gst_structure_has_field (s, "depth")) { gst_structure_get_int (s, "width", &width); /* round width to nearest multiple of 8 for the depth */ depth = GST_ROUND_UP_8 (width); gst_structure_fixate_field_nearest_int (s, "depth", depth); } if (gst_structure_has_field (s, "signed")) gst_structure_fixate_field_boolean (s, "signed", TRUE); if (gst_structure_has_field (s, "endianness")) gst_structure_fixate_field_nearest_int (s, "endianness", G_BYTE_ORDER); }
/* this function is a bit of a last resort */ static GstCaps * gst_v4l2src_fixate (GstBaseSrc * basesrc, GstCaps * caps) { GstStructure *structure; gint i; GST_DEBUG_OBJECT (basesrc, "fixating caps %" GST_PTR_FORMAT, caps); caps = gst_caps_make_writable (caps); for (i = 0; i < gst_caps_get_size (caps); ++i) { structure = gst_caps_get_structure (caps, i); /* We are fixating to a reasonable 320x200 resolution and the maximum framerate resolution for that size */ if (gst_structure_has_field (structure, "width")) gst_structure_fixate_field_nearest_int (structure, "width", 320); if (gst_structure_has_field (structure, "height")) gst_structure_fixate_field_nearest_int (structure, "height", 200); if (gst_structure_has_field (structure, "framerate")) gst_structure_fixate_field_nearest_fraction (structure, "framerate", G_MAXINT, 1); if (gst_structure_has_field (structure, "format")) gst_structure_fixate_field (structure, "format"); } GST_DEBUG_OBJECT (basesrc, "fixated caps %" GST_PTR_FORMAT, caps); caps = GST_BASE_SRC_CLASS (parent_class)->fixate (basesrc, caps); return caps; }
static GstCaps * gst_inter_video_src_fixate (GstBaseSrc * src, GstCaps * caps) { GstInterVideoSrc *intervideosrc = GST_INTER_VIDEO_SRC (src); GstStructure *structure; GST_DEBUG_OBJECT (intervideosrc, "fixate"); caps = gst_caps_make_writable (caps); structure = gst_caps_get_structure (caps, 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); if (gst_structure_has_field (structure, "pixel-aspect-ratio")) gst_structure_fixate_field_nearest_fraction (structure, "pixel-aspect-ratio", 1, 1); if (gst_structure_has_field (structure, "color-matrix")) gst_structure_fixate_field_string (structure, "color-matrix", "sdtv"); if (gst_structure_has_field (structure, "chroma-site")) gst_structure_fixate_field_string (structure, "chroma-site", "mpeg2"); if (gst_structure_has_field (structure, "interlaced")) gst_structure_fixate_field_boolean (structure, "interlaced", FALSE); return caps; }
static GstCaps * gst_video_test_src_src_fixate (GstBaseSrc * bsrc, GstCaps * caps) { GstStructure *structure; caps = gst_caps_make_writable (caps); structure = gst_caps_get_structure (caps, 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); if (gst_structure_has_field (structure, "pixel-aspect-ratio")) gst_structure_fixate_field_nearest_fraction (structure, "pixel-aspect-ratio", 1, 1); if (gst_structure_has_field (structure, "colorimetry")) gst_structure_fixate_field_string (structure, "colorimetry", "bt601"); if (gst_structure_has_field (structure, "chroma-site")) gst_structure_fixate_field_string (structure, "chroma-site", "mpeg2"); if (gst_structure_has_field (structure, "interlace-mode")) gst_structure_fixate_field_string (structure, "interlace-mode", "progressive"); caps = GST_BASE_SRC_CLASS (parent_class)->fixate (bsrc, caps); return caps; }
bool tcam_gst_fixate_caps (GstCaps* caps) { if (caps == nullptr || gst_caps_is_empty(caps) || gst_caps_is_any(caps)) { return FALSE; } GstStructure* structure = gst_caps_get_structure(caps, 0); if (gst_structure_has_field(structure, "width")) { gst_structure_fixate_field_nearest_int(structure, "width", G_MAXINT); } if (gst_structure_has_field(structure, "height")) { gst_structure_fixate_field_nearest_int(structure, "height", G_MAXINT); } if (gst_structure_has_field(structure, "framerate")) { gst_structure_fixate_field_nearest_fraction(structure, "framerate", G_MAXINT, 1); } return TRUE; }
static gboolean _cleanup_fields (const Properties * field_names, GstStructure * structure, GError ** error) { guint i; for (i = 0; field_names[i].long_name; i++) { gboolean exists = FALSE; /* Move shortly named fields to longname variante */ if (gst_structure_has_field (structure, field_names[i].short_name)) { exists = TRUE; if (gst_structure_has_field (structure, field_names[i].long_name)) { *error = g_error_new (GES_ERROR, 0, "Using short and long name" " at the same time for property: %s, which one should I use?!", field_names[i].long_name); return FALSE; } else { const GValue *val = gst_structure_get_value (structure, field_names[i].short_name); gst_structure_set_value (structure, field_names[i].long_name, val); gst_structure_remove_field (structure, field_names[i].short_name); } } else if (gst_structure_has_field (structure, field_names[i].long_name)) { exists = TRUE; } if (exists) { if (field_names[i].type == GST_TYPE_CLOCK_TIME) { if (_convert_to_clocktime (structure, field_names[i].long_name, 0) == 0) { *error = g_error_new (GES_ERROR, 0, "Could not convert" " %s to GstClockTime", field_names[i].long_name); return FALSE; } } } if (field_names[i].new_name && gst_structure_has_field (structure, field_names[i].long_name)) { const GValue *val = gst_structure_get_value (structure, field_names[i].long_name); gst_structure_set_value (structure, field_names[i].new_name, val); gst_structure_remove_field (structure, field_names[i].long_name); } } return TRUE; }
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; }
GstStructure * kms_stats_get_element_stats (GstStructure * stats) { GstStructure *element_stats; const GValue *value; if (!gst_structure_has_field (stats, KMS_MEDIA_ELEMENT_FIELD)) { return NULL; } value = gst_structure_get_value (stats, KMS_MEDIA_ELEMENT_FIELD); if (!GST_VALUE_HOLDS_STRUCTURE (value)) { return NULL; } element_stats = (GstStructure *) gst_value_get_structure (value); if (g_strcmp0 (KMS_ELEMENT_STATS_STRUCT_NAME, gst_structure_get_name (element_stats)) != 0) { return NULL; } return element_stats; }
static gboolean gst_rtp_ssrc_demux_src_event (GstPad * pad, GstObject * parent, GstEvent * event) { GstRtpSsrcDemux *demux; const GstStructure *s; demux = GST_RTP_SSRC_DEMUX (parent); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_CUSTOM_UPSTREAM: case GST_EVENT_CUSTOM_BOTH: case GST_EVENT_CUSTOM_BOTH_OOB: s = gst_event_get_structure (event); if (s && !gst_structure_has_field (s, "ssrc")) { GstRtpSsrcDemuxPad *dpad = find_demux_pad_for_pad (demux, pad); if (dpad) { GstStructure *ws; event = gst_event_make_writable (event); ws = gst_event_writable_structure (event); gst_structure_set (ws, "ssrc", G_TYPE_UINT, dpad->ssrc, NULL); } } break; default: break; } return gst_pad_event_default (pad, parent, event); }
static void gst_hlsdemux_test_set_input_data (const GstHlsDemuxTestCase * test_case, const GstHlsDemuxTestInputData * input, GstTestHTTPSrcInput * output) { output->size = input->size; output->context = (gpointer) input; if (output->size == 0) { output->size = strlen ((gchar *) input->payload); } fail_unless (input->uri != NULL); if (g_str_has_suffix (input->uri, ".m3u8")) { output->response_headers = gst_structure_new ("response-headers", "Content-Type", G_TYPE_STRING, "application/vnd.apple.mpegurl", NULL); } else if (g_str_has_suffix (input->uri, ".ts")) { output->response_headers = gst_structure_new ("response-headers", "Content-Type", G_TYPE_STRING, "video/mp2t", NULL); } if (gst_structure_has_field (test_case->state, "requests")) { GstHlsDemuxTestAppendUriContext context = { g_quark_from_string ("requests"), input->uri }; gst_structure_map_in_place (test_case->state, append_request_uri, &context); } else { GValue requests = G_VALUE_INIT; GValue uri_val = G_VALUE_INIT; g_value_init (&requests, GST_TYPE_ARRAY); g_value_init (&uri_val, G_TYPE_STRING); g_value_set_string (&uri_val, input->uri); gst_value_array_append_value (&requests, &uri_val); gst_structure_set_value (test_case->state, "requests", &requests); g_value_unset (&uri_val); g_value_unset (&requests); } }
/* doesn't return a ref to the pixbuf */ static GdkPixbuf * check_message_pixbuf (GstMessage * msg, const gchar * name, gint channels, gboolean has_alpha) { GdkPixbuf *pixbuf; const GstStructure *s; fail_unless (gst_message_get_structure (msg) != NULL); s = gst_message_get_structure (msg); fail_unless_equals_string (gst_structure_get_name (s), name); fail_unless (gst_structure_has_field (s, "pixbuf")); fail_unless (gst_structure_has_field_typed (s, "pixel-aspect-ratio", GST_TYPE_FRACTION)); pixbuf = GDK_PIXBUF (g_value_get_object (gst_structure_get_value (s, "pixbuf"))); fail_unless (GDK_IS_PIXBUF (pixbuf)); fail_unless_equals_int (gdk_pixbuf_get_n_channels (pixbuf), channels); fail_unless_equals_int (gdk_pixbuf_get_has_alpha (pixbuf), has_alpha); fail_unless_equals_int (gdk_pixbuf_get_width (pixbuf), 319); fail_unless_equals_int (gdk_pixbuf_get_height (pixbuf), 241); return pixbuf; }
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; }
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 gboolean validate_h263_codecs (CodecCap *codec_cap) { /* we assume we have just one structure per caps as it should be */ GstStructure *media_struct = gst_caps_get_structure (codec_cap->caps, 0); const gchar *name = gst_structure_get_name (media_struct); GstStructure *rtp_struct; const gchar *encoding_name; if (!name) return FALSE; /* let's check if it's h263 */ if (strcmp (name, "video/x-h263")) return TRUE; /* If we don't have a h263version field, accept everything */ if (!gst_structure_has_field (media_struct, "h263version")) return TRUE; rtp_struct = gst_caps_get_structure (codec_cap->rtp_caps, 0); if (!rtp_struct) return FALSE; encoding_name = gst_structure_get_string (rtp_struct, "encoding-name"); /* If there is no encoding name, we have a problem, lets refuse it */ if (!encoding_name) return FALSE; if (struct_field_has_line (media_struct, "h263version", "h263")) { /* baseline H263 can only be encoding name H263 or H263-1998 */ if (strcmp (encoding_name, "H263") && strcmp (encoding_name, "H263-1998")) return FALSE; } else if (struct_field_has_line (media_struct, "h263version", "h263p")) { /* has to be H263-1998 */ if (strcmp (encoding_name, "H263-1998")) return FALSE; } else if (struct_field_has_line (media_struct, "h263version", "h263pp")) { /* has to be H263-2000 */ if (strcmp (encoding_name, "H263-2000")) return FALSE; } /* if no h263version specified, we assume it's all h263 versions */ return TRUE; }
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 gboolean gst_wavpack_dec_sink_set_caps (GstPad * pad, GstCaps * caps) { GstWavpackDec *dec = GST_WAVPACK_DEC (gst_pad_get_parent (pad)); GstStructure *structure = gst_caps_get_structure (caps, 0); /* Check if we can set the caps here already */ if (gst_structure_get_int (structure, "channels", &dec->channels) && gst_structure_get_int (structure, "rate", &dec->sample_rate) && gst_structure_get_int (structure, "width", &dec->depth)) { GstCaps *caps; GstAudioChannelPosition *pos; caps = gst_caps_new_simple ("audio/x-raw-int", "rate", G_TYPE_INT, dec->sample_rate, "channels", G_TYPE_INT, dec->channels, "depth", G_TYPE_INT, dec->depth, "width", G_TYPE_INT, 32, "endianness", G_TYPE_INT, G_BYTE_ORDER, "signed", G_TYPE_BOOLEAN, TRUE, NULL); /* If we already have the channel layout set from upstream * take this */ if (gst_structure_has_field (structure, "channel-positions")) { pos = gst_audio_get_channel_positions (structure); if (pos != NULL && dec->channels > 2) { GstStructure *new_str = gst_caps_get_structure (caps, 0); gst_audio_set_channel_positions (new_str, pos); dec->channel_mask = gst_wavpack_get_channel_mask_from_positions (pos, dec->channels); } if (pos != NULL) g_free (pos); } GST_DEBUG_OBJECT (dec, "setting caps %" GST_PTR_FORMAT, caps); /* should always succeed */ gst_pad_set_caps (dec->srcpad, caps); gst_caps_unref (caps); /* send GST_TAG_AUDIO_CODEC and GST_TAG_BITRATE tags before something * is decoded or after the format has changed */ gst_wavpack_dec_post_tags (dec); } gst_object_unref (dec); return TRUE; }
static GstPadProbeReturn buffer_probe_cb (GstPad * pad, GstPadProbeInfo * info, gpointer user_data) { GstBuffer *buffer = GST_PAD_PROBE_INFO_BUFFER (info); GstMapInfo map; gst_buffer_map (buffer, &map, GST_MAP_READ); if (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_HEADER)) { GstCaps *caps; GstStructure *s; const GValue *sh; GArray *buffers; GstBuffer *buf; int i; gboolean found = FALSE; n_in_caps++; caps = gst_pad_get_current_caps (pad); s = gst_caps_get_structure (caps, 0); fail_unless (gst_structure_has_field (s, "streamheader")); sh = gst_structure_get_value (s, "streamheader"); buffers = g_value_peek_pointer (sh); assert_equals_int (buffers->len, 3); for (i = 0; i < 3; ++i) { GValue *val; GstMapInfo map2; val = &g_array_index (buffers, GValue, i); buf = g_value_peek_pointer (val); fail_unless (GST_IS_BUFFER (buf)); gst_buffer_map (buf, &map2, GST_MAP_READ); if (map2.size == map.size) { if (memcmp (map2.data, map.data, map.size) == 0) { found = TRUE; } } gst_buffer_unmap (buf, &map2); } fail_unless (found, "Did not find incoming HEADER buffer %p on caps", buffer); gst_caps_unref (caps); } gst_buffer_unmap (buffer, &map); return TRUE; }
// only on the sink gboolean gst_rtp_sv3v_depay_setcaps (GstBaseRTPDepayload * filter, GstCaps * caps) { GstStructure *structure = gst_caps_get_structure (caps, 0); gint clock_rate = 90000; // default if (gst_structure_has_field (structure, "clock-rate")) gst_structure_get_int (structure, "clock-rate", &clock_rate); filter->clock_rate = clock_rate; return TRUE; }
gboolean gst_goo_util_structure_is_parsed (GstStructure *structure) { if (gst_structure_has_field (structure, "parsed")) { gboolean parsed = FALSE; gst_structure_get_boolean (structure, "parsed", &parsed); if (parsed) return TRUE; } if (gst_structure_has_field (structure, "framed")) { gboolean framed = FALSE; gst_structure_get_boolean (structure, "framed", &framed); if (framed) return TRUE; } if (gst_structure_has_field (structure, "codec_data")) { const GValue *codec_data = NULL; codec_data = gst_structure_get_value (structure, "codec_data"); if (codec_data != NULL) return TRUE; } return FALSE; }
static gboolean structure_is_subset (const GstStructure *st1, const GstStructure *st2) { int i; for (i = 0; i < gst_structure_n_fields (st2); i++) { const gchar *name = gst_structure_nth_field_name (st2, i); if (!gst_structure_has_field(st1, name)) { gupnp_dlna_debug (" missing field %s", name); return FALSE; } } return TRUE; }
static void set_appsink_caps (GstElement * appsink, const GstCaps * caps, KmsRecordingProfile profile) { GstStructure *str; GstCaps *sinkcaps; sinkcaps = gst_caps_copy (caps); str = gst_caps_get_structure (sinkcaps, 0); if (str == NULL) { GST_ERROR_OBJECT (appsink, "Can not get caps at index 0 from %" GST_PTR_FORMAT, sinkcaps); goto end; } if (!gst_structure_has_field (str, "framerate")) { GST_DEBUG_OBJECT (appsink, "No framerate in caps %" GST_PTR_FORMAT, sinkcaps); } else { GST_DEBUG_OBJECT (appsink, "Removing framerate from caps %" GST_PTR_FORMAT, sinkcaps); gst_structure_remove_field (str, "framerate"); } switch (profile) { case KMS_RECORDING_PROFILE_WEBM: case KMS_RECORDING_PROFILE_WEBM_VIDEO_ONLY: /* Allow renegotiation of width and height because webmmux supports it */ gst_structure_remove_field (str, "width"); gst_structure_remove_field (str, "height"); break; default: /* No to allow height and width renegotiation */ break; } GST_DEBUG_OBJECT (appsink, "Setting sink caps %" GST_PTR_FORMAT, sinkcaps); g_object_set (appsink, "caps", sinkcaps, NULL); end: gst_caps_unref (sinkcaps); }
/* Clamp the framerate in a caps structure to be a smaller range then * [1...max_rate], otherwise return false */ static gboolean gst_video_max_rate_clamp_structure (GstStructure * s, gint maxrate, gint * min_num, gint * min_denom, gint * max_num, gint * max_denom) { gboolean ret = FALSE; if (!gst_structure_has_field (s, "framerate")) { /* No framerate field implies any framerate, clamping would result in * [1..max_rate] so not a real subset */ goto out; } else { const GValue *v; GValue intersection = { 0, }; GValue clamp = { 0, }; gint tmp_num, tmp_denom; g_value_init (&clamp, GST_TYPE_FRACTION_RANGE); gst_value_set_fraction_range_full (&clamp, 0, 1, maxrate, 1); v = gst_structure_get_value (s, "framerate"); ret = gst_value_intersect (&intersection, v, &clamp); g_value_unset (&clamp); if (!ret) goto out; gst_value_fraction_get_extremes (&intersection, min_num, min_denom, max_num, max_denom); gst_value_fraction_get_extremes (v, &tmp_num, &tmp_denom, max_num, max_denom); if (gst_util_fraction_compare (*max_num, *max_denom, maxrate, 1) > 0) { *max_num = maxrate; *max_denom = 1; } gst_structure_take_value (s, "framerate", &intersection); } out: return ret; }
static gboolean gst_ffmpegcsp_structure_is_alpha (GstStructure * s) { const gchar *name; name = gst_structure_get_name (s); if (g_str_equal (name, "video/x-raw-rgb")) { return gst_structure_has_field (s, "alpha_mask"); } else if (g_str_equal (name, "video/x-raw-yuv")) { guint32 fourcc; if (!gst_structure_get_fourcc (s, "format", &fourcc)) return FALSE; return (fourcc == GST_MAKE_FOURCC ('A', 'Y', 'U', 'V')); } return FALSE; }
/* 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 void mpeg_video_parse_check_caps (guint version, guint8 * seq, gint size) { GstCaps *caps; GstStructure *s; GstBuffer *buf; const GValue *val; GstMapInfo map; ctx_headers[0].data = seq; ctx_headers[0].size = size; /* parser does not really care that mpeg1 and mpeg2 frame data * should be a bit different */ caps = gst_parser_test_get_output_caps (mpeg2_iframe, sizeof (mpeg2_iframe), NULL); fail_unless (caps != NULL); /* Check that the negotiated caps are as expected */ /* When codec_data is present, parser assumes that data is version 4 */ GST_LOG ("mpegvideo output caps: %" GST_PTR_FORMAT, caps); s = gst_caps_get_structure (caps, 0); fail_unless (gst_structure_has_name (s, "video/mpeg")); fail_unless_structure_field_int_equals (s, "mpegversion", version); fail_unless_structure_field_int_equals (s, "width", 32); fail_unless_structure_field_int_equals (s, "height", 24); fail_unless (gst_structure_has_field (s, "codec_data")); /* check codec-data in more detail */ val = gst_structure_get_value (s, "codec_data"); fail_unless (val != NULL); buf = gst_value_get_buffer (val); fail_unless (buf != NULL); gst_buffer_map (buf, &map, GST_MAP_READ); /* codec-data = header - GOP */ assert_equals_int (map.size, size - 8); fail_unless (memcmp (map.data, seq, map.size) == 0); gst_buffer_unmap (buf, &map); gst_caps_unref (caps); }
static gboolean gst_rtp_pt_demux_src_event (GstPad * pad, GstObject * parent, GstEvent * event) { GstRtpPtDemux *demux; const GstStructure *s; demux = GST_RTP_PT_DEMUX (parent); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_CUSTOM_UPSTREAM: case GST_EVENT_CUSTOM_BOTH: case GST_EVENT_CUSTOM_BOTH_OOB: s = gst_event_get_structure (event); if (s && !gst_structure_has_field (s, "payload")) { GSList *walk; GST_OBJECT_LOCK (demux); for (walk = demux->srcpads; walk; walk = g_slist_next (walk)) { GstRtpPtDemuxPad *dpad = (GstRtpPtDemuxPad *) walk->data; if (dpad->pad == pad) { GstStructure *ws; event = GST_EVENT_CAST (gst_mini_object_make_writable (GST_MINI_OBJECT_CAST (event))); ws = gst_event_writable_structure (event); gst_structure_set (ws, "payload", G_TYPE_UINT, dpad->pt, NULL); break; } } GST_OBJECT_UNLOCK (demux); } break; default: break; } return gst_pad_event_default (pad, parent, event); }
/* return the caps that can be used on out_pad given in_caps on in_pad */ static gboolean gst_video_rate_transformcaps (GstPad * in_pad, GstCaps * in_caps, GstPad * out_pad, GstCaps ** out_caps) { GstCaps *intersect; const GstCaps *in_templ; gint i; GSList *extra_structures = NULL; GSList *iter; in_templ = gst_pad_get_pad_template_caps (in_pad); intersect = gst_caps_intersect (in_caps, in_templ); /* all possible framerates are allowed */ for (i = 0; i < gst_caps_get_size (intersect); i++) { GstStructure *structure; structure = gst_caps_get_structure (intersect, i); if (gst_structure_has_field (structure, "framerate")) { GstStructure *copy_structure; copy_structure = gst_structure_copy (structure); gst_structure_set (copy_structure, "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL); extra_structures = g_slist_append (extra_structures, copy_structure); } } /* append the extra structures */ for (iter = extra_structures; iter != NULL; iter = g_slist_next (iter)) { gst_caps_append_structure (intersect, (GstStructure *) iter->data); } g_slist_free (extra_structures); *out_caps = intersect; return TRUE; }
static gboolean gst_rtp_ssrc_demux_src_event (GstPad * pad, GstEvent * event) { GstRtpSsrcDemux *demux; const GstStructure *s; demux = GST_RTP_SSRC_DEMUX (gst_pad_get_parent (pad)); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_CUSTOM_UPSTREAM: case GST_EVENT_CUSTOM_BOTH: case GST_EVENT_CUSTOM_BOTH_OOB: s = gst_event_get_structure (event); if (s && !gst_structure_has_field (s, "ssrc")) { GSList *walk; for (walk = demux->srcpads; walk; walk = g_slist_next (walk)) { GstRtpSsrcDemuxPad *dpad = (GstRtpSsrcDemuxPad *) walk->data; if (dpad->rtp_pad == pad || dpad->rtcp_pad == pad) { event = GST_EVENT_CAST (gst_mini_object_make_writable (GST_MINI_OBJECT_CAST (event))); gst_structure_set (event->structure, "ssrc", G_TYPE_UINT, dpad->ssrc, NULL); break; } } } break; default: break; } gst_object_unref (demux); return gst_pad_event_default (pad, event); }
static void gst_opus_dec_negotiate (GstOpusDec * dec, const GstAudioChannelPosition * pos) { GstCaps *caps = gst_pad_get_allowed_caps (GST_AUDIO_DECODER_SRC_PAD (dec)); GstStructure *s; GstAudioInfo info; if (caps) { caps = gst_caps_truncate (caps); caps = gst_caps_make_writable (caps); s = gst_caps_get_structure (caps, 0); if (gst_structure_has_field (s, "rate")) gst_structure_fixate_field_nearest_int (s, "rate", dec->sample_rate); else gst_structure_set (s, "rate", G_TYPE_INT, dec->sample_rate, NULL); gst_structure_get_int (s, "rate", &dec->sample_rate); if (gst_structure_has_field (s, "channels")) gst_structure_fixate_field_nearest_int (s, "channels", dec->n_channels); else gst_structure_set (s, "channels", G_TYPE_INT, dec->n_channels, NULL); gst_structure_get_int (s, "channels", &dec->n_channels); gst_caps_unref (caps); } if (dec->n_channels == 0) { GST_DEBUG_OBJECT (dec, "Using a default of 2 channels"); dec->n_channels = 2; pos = NULL; } if (dec->sample_rate == 0) { GST_DEBUG_OBJECT (dec, "Using a default of 48kHz sample rate"); dec->sample_rate = 48000; } GST_INFO_OBJECT (dec, "Negotiated %d channels, %d Hz", dec->n_channels, dec->sample_rate); /* pass valid order to audio info */ if (pos) { memcpy (dec->opus_pos, pos, sizeof (pos[0]) * dec->n_channels); gst_audio_channel_positions_to_valid_order (dec->opus_pos, dec->n_channels); } /* set up source format */ gst_audio_info_init (&info); gst_audio_info_set_format (&info, GST_AUDIO_FORMAT_S16, dec->sample_rate, dec->n_channels, pos ? dec->opus_pos : NULL); gst_audio_decoder_set_output_format (GST_AUDIO_DECODER (dec), &info); /* but we still need the opus order for later reordering */ if (pos) { memcpy (dec->opus_pos, pos, sizeof (pos[0]) * dec->n_channels); gst_audio_channel_positions_to_valid_order (dec->opus_pos, dec->n_channels); } else { dec->opus_pos[0] = GST_AUDIO_CHANNEL_POSITION_INVALID; } dec->info = info; }
static GstFlowReturn mpegtsmux_create_streams (MpegTsMux * mux) { GstFlowReturn ret = GST_FLOW_OK; GSList *walk = mux->collect->data; /* Create the streams */ while (walk) { GstCollectData *c_data = (GstCollectData *) walk->data; MpegTsPadData *ts_data = (MpegTsPadData *) walk->data; gchar *name = NULL; walk = g_slist_next (walk); if (ts_data->prog_id == -1) { name = GST_PAD_NAME (c_data->pad); if (mux->prog_map != NULL && gst_structure_has_field (mux->prog_map, name)) { gint idx; gboolean ret = gst_structure_get_int (mux->prog_map, name, &idx); if (!ret) { GST_ELEMENT_ERROR (mux, STREAM, MUX, ("Reading program map failed. Assuming default"), (NULL)); idx = DEFAULT_PROG_ID; } if (idx < 0 || idx >= MAX_PROG_NUMBER) { GST_DEBUG_OBJECT (mux, "Program number %d associate with pad %s out " "of range (max = %d); DEFAULT_PROGRAM = %d is used instead", idx, name, MAX_PROG_NUMBER, DEFAULT_PROG_ID); idx = DEFAULT_PROG_ID; } ts_data->prog_id = idx; } else { ts_data->prog_id = DEFAULT_PROG_ID; } } ts_data->prog = mux->programs[ts_data->prog_id]; if (ts_data->prog == NULL) { ts_data->prog = tsmux_program_new (mux->tsmux); if (ts_data->prog == NULL) goto no_program; tsmux_set_pmt_interval (ts_data->prog, mux->pmt_interval); mux->programs[ts_data->prog_id] = ts_data->prog; } if (ts_data->stream == NULL) { ret = mpegtsmux_create_stream (mux, ts_data, c_data->pad); if (ret != GST_FLOW_OK) goto no_stream; } } return GST_FLOW_OK; no_program: GST_ELEMENT_ERROR (mux, STREAM, MUX, ("Could not create new program"), (NULL)); return GST_FLOW_ERROR; no_stream: GST_ELEMENT_ERROR (mux, STREAM, MUX, ("Could not create handler for stream"), (NULL)); return ret; }