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 void kms_connection_attr_ext_add_ips (KmsISdpMediaExtension * ext, GstSDPMedia * media, GArray * ips) { gint i; for (i = 0; i < ips->len; i++) { gchar *nettype, *addrtype, *address; guint ttl, addr_number; const GstStructure *addr; GValue *val; val = &g_array_index (ips, GValue, i); if (!GST_VALUE_HOLDS_STRUCTURE (val)) { GST_WARNING_OBJECT (ext, "Inavalid address provided"); continue; } addr = gst_value_get_structure (val); nettype = addrtype = address = NULL; if (gst_structure_get (addr, "nettype", G_TYPE_STRING, &nettype, "addrtype", G_TYPE_STRING, &addrtype, "address", G_TYPE_STRING, &address, "ttl", G_TYPE_UINT, &ttl, "addrnumber", G_TYPE_UINT, &addr_number, NULL)) { gst_sdp_media_add_connection (media, nettype, addrtype, address, ttl, addr_number); } g_free (nettype); g_free (addrtype); g_free (address); } }
static JsonNode * snra_json_value_to_node (const GValue *value) { JsonNode *n = NULL; if (GST_VALUE_HOLDS_STRUCTURE (value)) { const GstStructure *s = gst_value_get_structure (value); n = snra_json_from_gst_structure (s); } else if (GST_VALUE_HOLDS_ARRAY (value)) { guint count = gst_value_array_get_size (value); guint i; JsonArray *arr = json_array_sized_new (count); for (i = 0; i < count; i++) { const GValue *sub_val = gst_value_array_get_value (value, i); JsonNode *tmp = snra_json_value_to_node (sub_val); if (tmp) json_array_add_element (arr, tmp); } n = json_node_new (JSON_NODE_ARRAY); json_node_take_array (n, arr); } else { n = json_node_new (JSON_NODE_VALUE); json_node_set_value (n, value); } return n; }
static const GstStructure * get_structure_from_value (const GValue * val) { if (!GST_VALUE_HOLDS_STRUCTURE (val)) { return NULL; } return gst_value_get_structure (val); }
static void collectRTCDataChannelStats (std::map <std::string, std::shared_ptr<Stats>> &statsReport, double timestamp, const GstStructure *stats) { gint i, n; n = gst_structure_n_fields (stats); for (i = 0; i < n; i++) { std::shared_ptr<RTCDataChannelStats> rtcDataStats; const GValue *value; const gchar *name; name = gst_structure_nth_field_name (stats, i); if (!g_str_has_prefix (name, "data-channel-") ) { continue; } value = gst_structure_get_value (stats, name); if (!GST_VALUE_HOLDS_STRUCTURE (value) ) { gchar *str_val; str_val = g_strdup_value_contents (value); GST_WARNING ("Unexpected field type (%s) = %s", name, str_val); g_free (str_val); continue; } rtcDataStats = createtRTCDataChannelStats (gst_value_get_structure (value) ); rtcDataStats->setTimestamp (timestamp); statsReport[rtcDataStats->getId ()] = rtcDataStats; } std::shared_ptr<RTCPeerConnectionStats> peerConnStats = createtRTCPeerConnectionStats (stats); peerConnStats->setTimestamp (timestamp); statsReport[peerConnStats->getId ()] = peerConnStats; }
static void remove_not_supported_codecs_from_array (GstElement *element, GArray *codecs) { guint i; if (codecs == NULL) { return; } for (i = 0; i < codecs->len; i++) { GValue *v = &g_array_index (codecs, GValue, i); const GstStructure *s; const gchar *codec_name; gboolean supported = FALSE; if (!GST_VALUE_HOLDS_STRUCTURE (v) ) { GST_WARNING_OBJECT (element, "Value into array is not a GstStructure"); continue; } s = gst_value_get_structure (v); codec_name = gst_structure_get_name (s); for (std::vector<std::string>::iterator it = supported_codecs.begin(); it != supported_codecs.end(); ++it) { if (g_str_has_prefix (codec_name, (*it).c_str() ) ) { supported = TRUE; break; } } if (!supported) { GST_INFO_OBJECT (element, "Removing not supported codec '%s'", codec_name); g_array_remove_index (codecs, i); i--; } } }
const GstStructure * kms_utils_get_structure_by_name (const GstStructure * str, const gchar * name) { const GValue *value; value = gst_structure_get_value (str, name); if (value == NULL) { return NULL; } if (!GST_VALUE_HOLDS_STRUCTURE (value)) { gchar *str_val; str_val = g_strdup_value_contents (value); GST_WARNING ("Unexpected field type (%s) = %s", name, str_val); g_free (str_val); return NULL; } return gst_value_get_structure (value); }
static gboolean kms_sdp_sdes_ext_add_offer_crypto_attrs (KmsISdpMediaExtension * ext, GstSDPMedia * offer, GArray * keys, GError ** error) { gboolean ret = TRUE; guint i; for (i = 0; i < keys->len; i++) { const GstStructure *str; SrtpCryptoSuite crypto; gchar *key, *lifetime; guint tag, *mki, *len; GValue *val; key = lifetime = NULL; mki = len = NULL; val = &g_array_index (keys, GValue, i); if (!GST_VALUE_HOLDS_STRUCTURE (val)) { g_set_error (error, KMS_SDP_AGENT_ERROR, SDP_AGENT_INVALID_PARAMETER, "Can not add crypto attribute for key %u", i); return FALSE; } str = gst_value_get_structure (val); if (!gst_structure_get (str, KMS_SDES_TAG_FIELD, G_TYPE_UINT, &tag, KMS_SDES_KEY_FIELD, G_TYPE_STRING, &key, KMS_SDES_CRYPTO, G_TYPE_UINT, &crypto, NULL)) { g_set_error (error, KMS_SDP_AGENT_ERROR, SDP_AGENT_INVALID_PARAMETER, "Can not add crypto attribute for key %u", i); ret = FALSE; } if (ret) { guint m, l; /* get optional parameters */ gst_structure_get (str, KMS_SDES_LIFETIME, G_TYPE_STRING, &lifetime, NULL); if (gst_structure_get (str, KMS_SDES_MKI, G_TYPE_UINT, &m, KMS_SDES_LENGTH, G_TYPE_UINT, &l, NULL)) { mki = &m; len = &l; } ret = kms_sdp_sdes_ext_add_crypto_attr (ext, offer, tag, key, crypto, lifetime, mki, len, error); } g_free (key); g_free (lifetime); if (!ret) { /* Something went wrong */ break; } } return ret; }
static void handle_player_info (G_GNUC_UNUSED SoupSession *session, SoupMessage *msg, SnraClient *client) { SoupBuffer *buffer; if (msg->status_code < 200 || msg->status_code >= 300) return; buffer = soup_message_body_flatten (msg->response_body); if (json_parser_load_from_data (client->json, buffer->data, buffer->length, NULL)) { const GValue *v1; GArray *player_info = NULL; gsize i; JsonNode *root = json_parser_get_root (client->json); GstStructure *s1 = snra_json_to_gst_structure (root); if (s1 == NULL) return; /* Invalid chunk */ v1 = gst_structure_get_value (s1, "player-clients"); if (!GST_VALUE_HOLDS_ARRAY (v1)) goto failed; player_info = g_array_sized_new (TRUE, TRUE, sizeof (SnraPlayerInfo), gst_value_array_get_size (v1)); for (i = 0; i < gst_value_array_get_size (v1); i++) { SnraPlayerInfo info; const GValue *v2 = gst_value_array_get_value (v1, i); const GstStructure *s2; gint64 client_id; if (!GST_VALUE_HOLDS_STRUCTURE (v2)) goto failed; s2 = gst_value_get_structure (v2); if (!snra_json_structure_get_int64 (s2, "client-id", &client_id)) goto failed; info.id = client_id; if (!snra_json_structure_get_boolean (s2, "enabled", &info.enabled)) goto failed; if (!snra_json_structure_get_double (s2, "volume", &info.volume)) goto failed; if (!(info.host = g_strdup (gst_structure_get_string (s2, "host")))) goto failed; g_array_append_val (player_info, info); } free_player_info (client->player_info); client->player_info = player_info; player_info = NULL; g_signal_emit (client, signals[SIGNAL_PLAYER_INFO_CHANGED], 0); failed: if (player_info) free_player_info (player_info); gst_structure_free (s1); } }
/* If a parent is non-NULL, collected stream information will be appended to it * (and where the information exists, it will be overriden) */ static GstDiscovererStreamInfo * parse_stream_topology (GstDiscoverer * dc, const GstStructure * topology, GstDiscovererStreamInfo * parent) { GstDiscovererStreamInfo *res = NULL; GstCaps *caps = NULL; const GValue *nval = NULL; GST_DEBUG ("parsing: %" GST_PTR_FORMAT, topology); nval = gst_structure_get_value (topology, "next"); if (nval == NULL || GST_VALUE_HOLDS_STRUCTURE (nval)) { GstStructure *st = find_stream_for_node (dc, topology); gboolean add_to_list = TRUE; if (st) { res = collect_information (dc, st, parent); gst_structure_free (st); } else { /* Didn't find a stream structure, so let's just use the caps we have */ res = collect_information (dc, topology, parent); } if (nval == NULL) { /* FIXME : aggregate with information from main streams */ GST_DEBUG ("Coudn't find 'next' ! might be the last entry"); } else { GstCaps *caps; const GstStructure *st; st = gst_value_get_structure (nval); GST_DEBUG ("next is a structure %" GST_PTR_FORMAT, st); if (!parent) parent = res; if (gst_structure_id_get (st, _CAPS_QUARK, GST_TYPE_CAPS, &caps, NULL)) { if (gst_caps_can_intersect (parent->caps, caps)) { /* We sometimes get an extra sub-stream from the parser. If this is * the case, we just replace the parent caps with this stream's caps * since they might contain more information */ gst_caps_unref (parent->caps); parent->caps = caps; parse_stream_topology (dc, st, parent); add_to_list = FALSE; } else if (child_is_raw_stream (parent->caps, caps)) { /* This is the "raw" stream corresponding to the parent. This * contains more information than the parent, tags etc. */ parse_stream_topology (dc, st, parent); add_to_list = FALSE; gst_caps_unref (caps); } else { GstDiscovererStreamInfo *next = parse_stream_topology (dc, st, NULL); res->next = next; next->previous = res; } } } if (add_to_list) { dc->priv->current_info->stream_list = g_list_append (dc->priv->current_info->stream_list, res); } } else if (GST_VALUE_HOLDS_LIST (nval)) { guint i, len; GstDiscovererContainerInfo *cont; GstTagList *tags; if (!gst_structure_id_get (topology, _CAPS_QUARK, GST_TYPE_CAPS, &caps, NULL)) GST_WARNING ("Couldn't find caps !"); len = gst_value_list_get_size (nval); GST_DEBUG ("next is a list of %d entries", len); cont = (GstDiscovererContainerInfo *) gst_mini_object_new (GST_TYPE_DISCOVERER_CONTAINER_INFO); cont->parent.caps = caps; res = (GstDiscovererStreamInfo *) cont; if (gst_structure_id_has_field (topology, _TAGS_QUARK)) { GstTagList *tmp; gst_structure_id_get (topology, _TAGS_QUARK, GST_TYPE_STRUCTURE, &tags, NULL); GST_DEBUG ("Merge tags %" GST_PTR_FORMAT, tags); tmp = gst_tag_list_merge (cont->parent.tags, (GstTagList *) tags, GST_TAG_MERGE_APPEND); gst_tag_list_free (tags); if (cont->parent.tags) gst_tag_list_free (cont->parent.tags); cont->parent.tags = tmp; GST_DEBUG ("Container info tags %" GST_PTR_FORMAT, tmp); } for (i = 0; i < len; i++) { const GValue *subv = gst_value_list_get_value (nval, i); const GstStructure *subst = gst_value_get_structure (subv); GstDiscovererStreamInfo *substream; GST_DEBUG ("%d %" GST_PTR_FORMAT, i, subst); substream = parse_stream_topology (dc, subst, NULL); substream->previous = res; cont->streams = g_list_append (cont->streams, gst_discoverer_stream_info_ref (substream)); } } return res; }