/* * Copyright (C) 2009 Nokia Corporation. * Copyright (C) 2007, 2008 OpenedHand Ltd. * * Authors: Zeeshan Ali (Khattak) * * Jorn Baayen * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ /** * SECTION:gupnp-protocol-info * @short_description: UPnP AV ProtocolInfo * * #GUPnPProtocolInfo provides a convenient API to deal with ProtocolInfo * strings used in UPnP AV specifications. */ #include #include #include "gupnp-protocol-info.h" #include "gupnp-av-error.h" G_DEFINE_TYPE (GUPnPProtocolInfo, gupnp_protocol_info, G_TYPE_OBJECT); struct _GUPnPProtocolInfoPrivate { char *protocol; char *network; char *mime_type; char *dlna_profile; char **play_speeds; GUPnPDLNAConversion dlna_conversion; GUPnPDLNAOperation dlna_operation; GUPnPDLNAFlags dlna_flags; }; enum { PROP_0, PROP_PROTOCOL, PROP_NETWORK, PROP_MIME_TYPE, PROP_DLNA_PROFILE, PROP_PLAY_SPEEDS, PROP_DLNA_CONVERSION, PROP_DLNA_OPERATION, PROP_DLNA_FLAGS }; static void parse_additional_info (const char *additional_info, GUPnPProtocolInfo *info) { char **tokens = NULL; short i; if (strcmp (additional_info, "*") == 0) return; tokens = g_strsplit (additional_info, ";", -1); if (tokens == NULL) { g_warning ("Invalid additional info in DIDL-Lite info: %s", additional_info); return; } for (i = 0; tokens[i]; i++) { char *p; p = g_strstr_len (tokens[i], strlen (tokens[i]), "DLNA.ORG_PN="); if (p != NULL) { p += 12; /* end of "DLNA.ORG_PN=" */ gupnp_protocol_info_set_dlna_profile (info, p); continue; } p = g_strstr_len (tokens[i], strlen (tokens[i]), "DLNA.ORG_PS="); if (p != NULL) { char **play_speeds; p += 12; /* end of "DLNA.ORG_PS=" */ play_speeds = g_strsplit (p, ",", -1); gupnp_protocol_info_set_play_speeds (info, (const char **) play_speeds); g_strfreev (play_speeds); continue; } p = g_strstr_len (tokens[i], strlen (tokens[i]), "DLNA.ORG_CI="); if (p != NULL) { p += 12; /* end of "DLNA.ORG_CI=" */ gupnp_protocol_info_set_dlna_conversion (info, atoi (p)); continue; } p = g_strstr_len (tokens[i], strlen (tokens[i]), "DLNA.ORG_OP="); if (p != NULL) { p += 12; /* end of "DLNA.ORG_OP=" */ gupnp_protocol_info_set_dlna_operation (info, strtoul (p, NULL, 16)); continue; } p = g_strstr_len (tokens[i], strlen (tokens[i]), "DLNA.ORG_FLAGS="); if (p != NULL) { p += 15; /* end of "DLNA.ORG_FLAGS=" */ if (strlen (p) > 8) p[8] = '\0'; gupnp_protocol_info_set_dlna_flags (info, strtoul (p, NULL, 16)); continue; } } g_strfreev (tokens); } static gboolean is_transport_compat (GUPnPProtocolInfo *info1, GUPnPProtocolInfo *info2) { const char *protocol1; const char *protocol2; protocol1 = gupnp_protocol_info_get_protocol (info1); protocol2 = gupnp_protocol_info_get_protocol (info2); if (protocol1[0] != '*' && protocol2[0] != '*' && g_ascii_strcasecmp (protocol1, protocol2) != 0) return FALSE; else if (g_ascii_strcasecmp ("internal", protocol1) == 0 && strcmp (gupnp_protocol_info_get_network (info1), gupnp_protocol_info_get_network (info2)) != 0) /* Host must be the same in case of INTERNAL protocol */ return FALSE; else return TRUE; } static gboolean is_content_format_compat (GUPnPProtocolInfo *info1, GUPnPProtocolInfo *info2) { const char *mime_type1; const char *mime_type2; mime_type1 = gupnp_protocol_info_get_mime_type (info1); mime_type2 = gupnp_protocol_info_get_mime_type (info2); if (mime_type1 [0] != '*' && mime_type2 [0] != '*' && g_ascii_strcasecmp (mime_type1, mime_type2) != 0 && /* Handle special case for LPCM: It is the only content type that * make use of mime-type parameters that we know of. * * Example: audio/L16;rate=44100;channels=2 */ !((g_ascii_strcasecmp (mime_type1, "audio/L16") == 0 && g_ascii_strncasecmp (mime_type2, "audio/L16", 9) == 0) || (g_ascii_strcasecmp (mime_type2, "audio/L16") == 0 && g_ascii_strncasecmp (mime_type1, "audio/L16", 9) == 0))) return FALSE; else return TRUE; } static gboolean is_additional_info_compat (GUPnPProtocolInfo *info1, GUPnPProtocolInfo *info2) { const char *profile1; const char *profile2; profile1 = gupnp_protocol_info_get_dlna_profile (info1); profile2 = gupnp_protocol_info_get_dlna_profile (info2); if (profile1 == NULL || profile2 == NULL || profile1 [0] == '*' || profile2 [0] == '*' || g_ascii_strcasecmp (profile1, profile2) == 0) return TRUE; else return FALSE; } static void add_dlna_info (GString *str, GUPnPProtocolInfo *info) { const char *dlna_profile; const char **speeds; GUPnPDLNAConversion conversion; GUPnPDLNAOperation operation; GUPnPDLNAFlags flags; dlna_profile = gupnp_protocol_info_get_dlna_profile (info); if (dlna_profile == NULL) { g_string_append_printf (str, ":"); } else { g_string_append_printf (str, ":DLNA.ORG_PN=%s;", dlna_profile); } operation = gupnp_protocol_info_get_dlna_operation (info); if (operation != GUPNP_DLNA_OPERATION_NONE && /* the OP parameter is only allowed for the "http-get" * and "rtsp-rtp-udp" protocols */ (strcmp (gupnp_protocol_info_get_protocol (info), "http-get") == 0 || strcmp (gupnp_protocol_info_get_protocol (info), "rtsp-rtp-udp") == 0)) g_string_append_printf (str, "DLNA.ORG_OP=%.2x;", operation); /* Specify PS parameter if list of play speeds is provided */ speeds = gupnp_protocol_info_get_play_speeds (info); if (speeds != NULL) { int i; g_string_append (str, "DLNA.ORG_PS="); for (i = 0; speeds[i]; i++) { g_string_append (str, speeds[i]); if (speeds[i + 1]) g_string_append_c (str, ','); } g_string_append_c (str, ';'); } conversion = gupnp_protocol_info_get_dlna_conversion (info); /* omit the CI parameter for non-converted content */ if (conversion != GUPNP_DLNA_CONVERSION_NONE) g_string_append_printf (str, "DLNA.ORG_CI=%d;", conversion); flags = gupnp_protocol_info_get_dlna_flags (info); /* Omit the FLAGS parameter if no or DLNA profile are set */ if (flags != GUPNP_DLNA_FLAGS_NONE && dlna_profile != NULL) { g_string_append_printf (str, "DLNA.ORG_FLAGS=%.8x", flags); /* append 24 reserved hex-digits */ g_string_append_printf (str, "0000" "0000" "0000" "0000" "0000" "0000"); } /* if nothing of the above was set, use the "match all" rule */ switch (str->str[str->len - 1]) { case ':': g_string_append_c (str, '*'); break; case ';': g_string_erase (str, str->len - 1, 1); break; default: break; } } static void gupnp_protocol_info_init (GUPnPProtocolInfo *info) { info->priv = G_TYPE_INSTANCE_GET_PRIVATE (info, GUPNP_TYPE_PROTOCOL_INFO, GUPnPProtocolInfoPrivate); info->priv->dlna_conversion = GUPNP_DLNA_CONVERSION_NONE; info->priv->dlna_operation = GUPNP_DLNA_OPERATION_NONE; info->priv->dlna_flags = GUPNP_DLNA_FLAGS_NONE; } static void gupnp_protocol_info_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GUPnPProtocolInfo *info; info = GUPNP_PROTOCOL_INFO (object); switch (property_id) { case PROP_PROTOCOL: gupnp_protocol_info_set_protocol (info, g_value_get_string (value)); break; case PROP_NETWORK: gupnp_protocol_info_set_network (info, g_value_get_string (value)); break; case PROP_MIME_TYPE: gupnp_protocol_info_set_mime_type (info, g_value_get_string (value)); break; case PROP_DLNA_PROFILE: gupnp_protocol_info_set_dlna_profile (info, g_value_get_string (value)); break; case PROP_PLAY_SPEEDS: gupnp_protocol_info_set_play_speeds (info, g_value_get_boxed (value)); break; case PROP_DLNA_CONVERSION: gupnp_protocol_info_set_dlna_conversion (info, g_value_get_flags (value)); break; case PROP_DLNA_OPERATION: gupnp_protocol_info_set_dlna_operation (info, g_value_get_flags (value)); break; case PROP_DLNA_FLAGS: gupnp_protocol_info_set_dlna_flags (info, g_value_get_flags (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } } static void gupnp_protocol_info_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GUPnPProtocolInfo *info; info = GUPNP_PROTOCOL_INFO (object); switch (property_id) { case PROP_PROTOCOL: g_value_set_string (value, gupnp_protocol_info_get_protocol (info)); break; case PROP_NETWORK: g_value_set_string (value, gupnp_protocol_info_get_network (info)); break; case PROP_MIME_TYPE: g_value_set_string (value, gupnp_protocol_info_get_mime_type (info)); break; case PROP_DLNA_PROFILE: g_value_set_string (value, gupnp_protocol_info_get_dlna_profile (info)); break; case PROP_PLAY_SPEEDS: g_value_set_boxed (value, gupnp_protocol_info_get_play_speeds (info)); break; case PROP_DLNA_CONVERSION: g_value_set_flags (value, gupnp_protocol_info_get_dlna_conversion (info)); break; case PROP_DLNA_OPERATION: g_value_set_flags (value, gupnp_protocol_info_get_dlna_operation (info)); break; case PROP_DLNA_FLAGS: g_value_set_flags (value, gupnp_protocol_info_get_dlna_flags (info)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } } static void gupnp_protocol_info_finalize (GObject *object) { GObjectClass *object_class; GUPnPProtocolInfoPrivate *priv; priv = GUPNP_PROTOCOL_INFO (object)->priv; if (priv->protocol) g_free (priv->protocol); if (priv->network) g_free (priv->network); if (priv->mime_type) g_free (priv->mime_type); if (priv->dlna_profile) g_free (priv->dlna_profile); if (priv->play_speeds) g_strfreev (priv->play_speeds); object_class = G_OBJECT_CLASS (gupnp_protocol_info_parent_class); object_class->finalize (object); } static void gupnp_protocol_info_class_init (GUPnPProtocolInfoClass *klass) { GObjectClass *object_class; object_class = G_OBJECT_CLASS (klass); object_class->set_property = gupnp_protocol_info_set_property; object_class->get_property = gupnp_protocol_info_get_property; object_class->finalize = gupnp_protocol_info_finalize; g_type_class_add_private (klass, sizeof (GUPnPProtocolInfoPrivate)); /** * GUPnPProtocolInfo:protocol: * * The protocol of this info. **/ g_object_class_install_property (object_class, PROP_PROTOCOL, g_param_spec_string ("protocol", "Protocol", "The protocol of this info.", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB)); /** * GUPnPProtocolInfo:network: * * The network this info is associated with. **/ g_object_class_install_property (object_class, PROP_NETWORK, g_param_spec_string ("network", "Network", "The network this info is associated" " with.", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB)); /** * GUPnPProtocolInfo:mime-type: * * The MIME-type of this info. **/ g_object_class_install_property (object_class, PROP_MIME_TYPE, g_param_spec_string ("mime-type", "MIMEType", "The MIME-type of this info.", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB)); /** * GUPnPProtocolInfo:dlna-profile: * * The DLNA profile of this info. **/ g_object_class_install_property (object_class, PROP_DLNA_PROFILE, g_param_spec_string ("dlna-profile", "DLNAProfile", "The DLNA profile of this info.", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB)); /** * GUPnPProtocolInfo:play-speeds: * * The allowed play speeds on this info in the form of array of * strings. **/ g_object_class_install_property (object_class, PROP_PLAY_SPEEDS, g_param_spec_boxed ("play-speeds", "PlaySpeeds", "The allowed play speeds on this" " info in the form of array of" " strings.", G_TYPE_STRV, G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB)); /** * GUPnPProtocolInfo:dlna-conversion: * * The DLNA conversion flags. **/ g_object_class_install_property (object_class, PROP_DLNA_CONVERSION, g_param_spec_flags ("dlna-conversion", "DLNAConversion", "The DLNA conversion flags.", GUPNP_TYPE_DLNA_CONVERSION, GUPNP_DLNA_CONVERSION_NONE, G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB)); /** * GUPnPProtocolInfo:dlna-operation: * * The DLNA operation flags. **/ g_object_class_install_property (object_class, PROP_DLNA_OPERATION, g_param_spec_flags ("dlna-operation", "DLNAOperation", "The DLNA operation flags.", GUPNP_TYPE_DLNA_OPERATION, GUPNP_DLNA_OPERATION_NONE, G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB)); /** * GUPnPProtocolInfo:dlna-flags: * * Various generic DLNA flags. **/ g_object_class_install_property (object_class, PROP_DLNA_FLAGS, g_param_spec_flags ("dlna-flags", "DLNAFlags", "Various generic DLNA flags.", GUPNP_TYPE_DLNA_FLAGS, GUPNP_DLNA_FLAGS_NONE, G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB)); } /** * gupnp_protocol_info_new: * * Return value: A new #GUPnPProtocolInfo object. Unref after usage. **/ GUPnPProtocolInfo * gupnp_protocol_info_new (void) { return g_object_new (GUPNP_TYPE_PROTOCOL_INFO, NULL); } /** * gupnp_protocol_info_new_from_string: * @protocol_info: The protocol info string * @error: The location where to store any error, or NULL * * Parses the @protocol_info string and creates a new #GUPnPProtocolInfo object * as a result. * * Return value: A new #GUPnPProtocolInfo object. Unref after usage. **/ GUPnPProtocolInfo * gupnp_protocol_info_new_from_string (const char *protocol_info, GError **error) { GUPnPProtocolInfo *info; char **tokens; g_return_val_if_fail (protocol_info != NULL, NULL); tokens = g_strsplit (protocol_info, ":", 4); if (tokens[0] == NULL || tokens[1] == NULL || tokens[2] == NULL || tokens[3] == NULL) { g_set_error (error, GUPNP_PROTOCOL_ERROR, GUPNP_PROTOCOL_ERROR_INVALID_SYNTAX, "Failed to parse protocolInfo string: \n%s", protocol_info); g_strfreev (tokens); return NULL; } info = gupnp_protocol_info_new (); gupnp_protocol_info_set_protocol (info, tokens[0]); gupnp_protocol_info_set_network (info, tokens[1]); gupnp_protocol_info_set_mime_type (info, tokens[2]); parse_additional_info (tokens[3], info); g_strfreev (tokens); return info; } /** * gupnp_protocol_info_to_string: * @info: The #GUPnPProtocolInfo * * Provides the string representation of @info. * * Return value: String representation of @info. #g_free after usage. **/ char * gupnp_protocol_info_to_string (GUPnPProtocolInfo *info) { GString *str; const char *protocol; const char *mime_type; const char *network; g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info), NULL); protocol = gupnp_protocol_info_get_protocol (info); mime_type = gupnp_protocol_info_get_mime_type (info); network = gupnp_protocol_info_get_network (info); g_return_val_if_fail (protocol != NULL, NULL); g_return_val_if_fail (mime_type != NULL, NULL); str = g_string_new (""); g_string_append (str, protocol); g_string_append_c (str, ':'); if (network != NULL) g_string_append (str, network); else g_string_append_c (str, '*'); g_string_append_c (str, ':'); g_string_append (str, mime_type); add_dlna_info (str, info); return g_string_free (str, FALSE); } /** * gupnp_protocol_info_get_protocol: * @info: A #GUPnPProtocolInfo * * Get the protocol of this info. * * Return value: The protocol of this info or %NULL. This string should not * be freed. **/ const char * gupnp_protocol_info_get_protocol (GUPnPProtocolInfo *info) { g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info), NULL); return info->priv->protocol; } /** * gupnp_protocol_info_get_network: * @info: A #GUPnPProtocolInfo * * Get the network this info is associated with. * * Return value: The network string or %NULL. This string should not be freed. **/ const char * gupnp_protocol_info_get_network (GUPnPProtocolInfo *info) { g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info), NULL); return info->priv->network; } /** * gupnp_protocol_info_get_mime_type: * @info: A #GUPnPProtocolInfo * * Get the MIME-type of this info. * * Return value: The MIME-type of this info or %NULL. This string should not * be freed. **/ const char * gupnp_protocol_info_get_mime_type (GUPnPProtocolInfo *info) { g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info), NULL); return info->priv->mime_type; } /** * gupnp_protocol_info_get_dlna_profile: * @info: A #GUPnPProtocolInfo * * Get the DLNA profile of this info. * * Return value: The DLNA profile of this info or %NULL. This string should * not be freed. **/ const char * gupnp_protocol_info_get_dlna_profile (GUPnPProtocolInfo *info) { g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info), NULL); return info->priv->dlna_profile; } /** * gupnp_protocol_info_get_play_speeds: * @info: A #GUPnPProtocolInfo * * Get the allowed play speeds on this info in the form of array of strings. * * Returns: (transfer none): The allowed play speeds as array of strings or %NULL. This * return array and it's content must not be modified or freed. **/ const char ** gupnp_protocol_info_get_play_speeds (GUPnPProtocolInfo *info) { g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info), NULL); return (const char **) info->priv->play_speeds; } /** * gupnp_protocol_info_get_dlna_conversion: * @info: A #GUPnPProtocolInfo * * Get the DLNA conversion flags. * * Return value: The DLNA conversion flags. **/ GUPnPDLNAConversion gupnp_protocol_info_get_dlna_conversion (GUPnPProtocolInfo *info) { g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info), GUPNP_DLNA_CONVERSION_NONE); return info->priv->dlna_conversion; } /** * gupnp_protocol_info_get_dlna_operation: * @info: A #GUPnPProtocolInfo * * Get the DLNA operation flags. * * Return value: The DLNA operation flags. **/ GUPnPDLNAOperation gupnp_protocol_info_get_dlna_operation (GUPnPProtocolInfo *info) { g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info), GUPNP_DLNA_OPERATION_NONE); return info->priv->dlna_operation; } /** * gupnp_protocol_info_get_dlna_flags: * @info: A #GUPnPProtocolInfo * * Get the gereric DLNA flags. * * Return value: The generic DLNA flags. **/ GUPnPDLNAFlags gupnp_protocol_info_get_dlna_flags (GUPnPProtocolInfo *info) { g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info), GUPNP_DLNA_FLAGS_NONE); return info->priv->dlna_flags; } /** * gupnp_protocol_info_set_protocol: * @info: A #GUPnPProtocolInfo * @protocol: The protocol string * * Set the protocol of this info. **/ void gupnp_protocol_info_set_protocol (GUPnPProtocolInfo *info, const char *protocol) { g_return_if_fail (GUPNP_IS_PROTOCOL_INFO (info)); if (info->priv->protocol) g_free (info->priv->protocol); info->priv->protocol = g_strdup (protocol); g_object_notify (G_OBJECT (info), "protocol"); } /** * gupnp_protocol_info_set_network: * @info: A #GUPnPProtocolInfo * @network: The network string * * Set the network this info is associated with. **/ void gupnp_protocol_info_set_network (GUPnPProtocolInfo *info, const char *network) { g_return_if_fail (GUPNP_IS_PROTOCOL_INFO (info)); if (info->priv->network) g_free (info->priv->network); info->priv->network = g_strdup (network); g_object_notify (G_OBJECT (info), "network"); } /** * gupnp_protocol_info_set_mime_type: * @info: A #GUPnPProtocolInfo * @mime_type: The MIME-type string * * Set the MIME-type of this info. **/ void gupnp_protocol_info_set_mime_type (GUPnPProtocolInfo *info, const char *mime_type) { g_return_if_fail (GUPNP_IS_PROTOCOL_INFO (info)); if (info->priv->mime_type) g_free (info->priv->mime_type); info->priv->mime_type = g_strdup (mime_type); g_object_notify (G_OBJECT (info), "mime-type"); } /** * gupnp_protocol_info_set_dlna_profile: * @info: A #GUPnPProtocolInfo * @profile: The DLNA profile string * * Set the DLNA profile of this info. **/ void gupnp_protocol_info_set_dlna_profile (GUPnPProtocolInfo *info, const char *profile) { g_return_if_fail (GUPNP_IS_PROTOCOL_INFO (info)); if (info->priv->dlna_profile) g_free (info->priv->dlna_profile); info->priv->dlna_profile = g_strdup (profile); g_object_notify (G_OBJECT (info), "dlna-profile"); } /** * gupnp_protocol_info_set_play_speeds: * @info: A #GUPnPProtocolInfo * @speeds: The allowed play speeds * * Set the allowed play speeds on this info in the form of array of strings. **/ void gupnp_protocol_info_set_play_speeds (GUPnPProtocolInfo *info, const char **speeds) { g_return_if_fail (GUPNP_IS_PROTOCOL_INFO (info)); if (info->priv->play_speeds) g_strfreev (info->priv->play_speeds); info->priv->play_speeds = (char **) g_boxed_copy (G_TYPE_STRV, speeds); g_object_notify (G_OBJECT (info), "play-speeds"); } /** * gupnp_protocol_info_set_dlna_conversion: * @info: A #GUPnPProtocolInfo * @conversion: The bitwise OR of one or more DLNA conversion flags * * Set the DLNA conversion flags. **/ void gupnp_protocol_info_set_dlna_conversion (GUPnPProtocolInfo *info, GUPnPDLNAConversion conversion) { g_return_if_fail (GUPNP_IS_PROTOCOL_INFO (info)); info->priv->dlna_conversion = conversion; g_object_notify (G_OBJECT (info), "dlna-conversion"); } /** * gupnp_protocol_info_set_dlna_operation: * @info: A #GUPnPProtocolInfo * @operation: The bitwise OR of one or more DLNA operation flags * * Set the DLNA operation flags. **/ void gupnp_protocol_info_set_dlna_operation (GUPnPProtocolInfo *info, GUPnPDLNAOperation operation) { g_return_if_fail (GUPNP_IS_PROTOCOL_INFO (info)); info->priv->dlna_operation = operation; g_object_notify (G_OBJECT (info), "dlna-operation"); } /** * gupnp_protocol_info_set_dlna_flags: * @info: A #GUPnPProtocolInfo * @flags: The bitwise OR of one or more generic DLNA flags * * Set the gereric DLNA flags. **/ void gupnp_protocol_info_set_dlna_flags (GUPnPProtocolInfo *info, GUPnPDLNAFlags flags) { g_return_if_fail (GUPNP_IS_PROTOCOL_INFO (info)); info->priv->dlna_flags = flags; g_object_notify (G_OBJECT (info), "dlna-flags"); } /** * gupnp_protocol_info_is_compatible: * @info1: The first #GUPnPProtocolInfo * @info2: The second #GUPnPProtocolInfo * * Checks if the given protocolInfo string is compatible with @info. * * Return value: #TRUE if @protocol_info is compatible with @info, otherwise * #FALSE. **/ gboolean gupnp_protocol_info_is_compatible (GUPnPProtocolInfo *info1, GUPnPProtocolInfo *info2) { g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info1), FALSE); g_return_val_if_fail (GUPNP_IS_PROTOCOL_INFO (info2), FALSE); return is_transport_compat (info1, info2) && is_content_format_compat (info1, info2) && is_additional_info_compat (info1, info2); }