static void
guess_audio_profile (GstDiscovererInfo *info,
gchar **name,
gchar **mime,
GList *profiles)
{
GList *i;
GUPnPDLNAProfile *profile;
GstEncodingProfile *enc_profile;
for (i = profiles; i; i = i->next) {
profile = (GUPnPDLNAProfile *)(i->data);
enc_profile = gupnp_dlna_profile_get_encoding_profile (profile);
gupnp_dlna_debug ("Checking DLNA profile %s",
gupnp_dlna_profile_get_name (profile));
if (!check_audio_profile (info, enc_profile))
gupnp_dlna_debug (" Audio did not match");
else if (!check_container (info, enc_profile))
gupnp_dlna_debug (" Container did not match");
else {
*name = g_strdup
(gupnp_dlna_profile_get_name (profile));
*mime = g_strdup
(gupnp_dlna_profile_get_mime (profile));
break;
}
}
}
/**
* gupnp_dlna_discoverer_get_profile:
* @self: The #GUPnPDLNADiscoverer object
* @name: The name of the DLNA profile to be retrieved
*
* Given @name, this finds the corresponding DLNA profile information (stored
* as a #GUPnPDLNAProfile).
*
* Returns: (transfer full): a #GUPnPDLNAProfile on success, NULL otherwise.
**/
GUPnPDLNAProfile *
gupnp_dlna_discoverer_get_profile (GUPnPDLNADiscoverer *self,
const gchar *name)
{
GList *i;
GUPnPDLNADiscovererClass *klass;
GUPnPDLNADiscovererPrivate *priv = GET_PRIVATE (self);
gboolean relaxed = priv->relaxed_mode;
gboolean extended = priv->extended_mode;
g_return_val_if_fail (self != NULL, NULL);
klass = GUPNP_DLNA_DISCOVERER_GET_CLASS (self);
for (i = klass->profiles_list [relaxed][extended];
i != NULL;
i = i->next) {
GUPnPDLNAProfile *profile = (GUPnPDLNAProfile *) i->data;
if (g_str_equal (gupnp_dlna_profile_get_name (profile), name)) {
g_object_ref (profile);
return profile;
}
}
return NULL;
}
static void
print_profile (GUPnPDLNAProfile *profile, gpointer unused)
{
GstEncodingProfile *enc_profile;
const GList *tmp;
gchar *caps_str;
enc_profile = gupnp_dlna_profile_get_encoding_profile (profile);
tmp = gst_encoding_container_profile_get_profiles
(GST_ENCODING_CONTAINER_PROFILE (enc_profile));
g_print ("%s %-30s%-35s",
gupnp_dlna_profile_get_extended (profile) ? "*" : " ",
gupnp_dlna_profile_get_name (profile),
gupnp_dlna_profile_get_mime (profile));
if (verbose) {
caps_str = gst_caps_to_string
(gst_encoding_profile_get_format (enc_profile));
g_print ("\n`- container: %s\n", caps_str);
g_free (caps_str);
while (tmp) {
print_caps (gst_encoding_profile_get_format
(GST_ENCODING_PROFILE (tmp->data)));
tmp = tmp->next;
}
}
g_print ("\n");
gst_encoding_profile_unref (enc_profile);
}
static void
guess_video_profile (GstDiscovererInfo *info,
gchar **name,
gchar **mime,
GList *profiles)
{
GUPnPDLNAProfile *profile = NULL;
GstEncodingProfile *enc_profile;
GList *i;
for (i = profiles; i; i = i->next) {
profile = (GUPnPDLNAProfile *)(i->data);
enc_profile = gupnp_dlna_profile_get_encoding_profile (profile);
gupnp_dlna_debug ("Checking DLNA profile %s",
gupnp_dlna_profile_get_name (profile));
if (check_video_profile (info, enc_profile)) {
*name = g_strdup (gupnp_dlna_profile_get_name (profile));
*mime = g_strdup (gupnp_dlna_profile_get_mime (profile));
break;
}
}
}
static void
guess_image_profile (GstDiscovererStreamInfo *info,
gchar **name,
gchar **mime,
GList *profiles)
{
GstCaps *caps;
GList *i;
gboolean found = FALSE;
GUPnPDLNAProfile *profile;
GstEncodingProfile *enc_profile;
const GstDiscovererVideoInfo *video_info =
GST_DISCOVERER_VIDEO_INFO (info);
if (!info || !gst_discoverer_video_info_is_image (video_info))
return;
caps = caps_from_video_stream_info (info);
for (i = profiles; !found && i; i = i->next) {
profile = (GUPnPDLNAProfile *)(i->data);
enc_profile = gupnp_dlna_profile_get_encoding_profile (profile);
/* Optimisation TODO: this can be pre-computed */
if (!is_video_profile (enc_profile))
continue;
if (match_profile (enc_profile,
caps,
GST_TYPE_ENCODING_VIDEO_PROFILE)) {
/* Found a match */
*name = g_strdup (gupnp_dlna_profile_get_name (profile));
*mime = g_strdup (gupnp_dlna_profile_get_mime (profile));
break;
}
}
gst_caps_unref (caps);
}
static void prv_compute_mime_and_dlna_header(const gchar *filename,
gchar **mime_type,
gchar **dlna_header,
GError **error)
{
gchar *uri;
GString *header;
GUPnPDLNAProfile *profile;
GUPnPDLNAProfileGuesser *guesser;
gboolean relaxed_mode = TRUE;
gboolean extended_mode = TRUE;
const char *profile_name;
const char *dlna_mime_type;
GUPnPDLNAOperation operation;
GUPnPDLNAFlags flags;
GUPnPDLNAConversion conversion;
gchar *content_type = NULL;
*mime_type = NULL;
*dlna_header = NULL;
*error = NULL;
header = g_string_new("");
guesser = gupnp_dlna_profile_guesser_new(relaxed_mode, extended_mode);
uri = g_filename_to_uri(filename, NULL, error);
if (uri == NULL) {
DLEYNA_LOG_WARNING("Unable to convert filename: %s", filename);
if (*error) {
DLEYNA_LOG_WARNING("Error: %s", (*error)->message);
g_error_free(*error);
*error = NULL;
}
goto on_error;
}
profile = gupnp_dlna_profile_guesser_guess_profile_sync(guesser,
uri,
5000,
NULL,
error);
if (profile == NULL) {
DLEYNA_LOG_WARNING("Unable to guess profile for URI: %s", uri);
if (*error) {
DLEYNA_LOG_WARNING("Error: %s", (*error)->message);
g_error_free(*error);
*error = NULL;
}
goto on_error;
}
profile_name = gupnp_dlna_profile_get_name(profile);
if (profile_name != NULL)
g_string_append_printf(header, "DLNA.ORG_PN=%s;", profile_name);
operation = GUPNP_DLNA_OPERATION_RANGE;
g_string_append_printf(header, "DLNA.ORG_OP=%.2x;", operation);
conversion = GUPNP_DLNA_CONVERSION_NONE;
g_string_append_printf(header, "DLNA.ORG_CI=%.2x;", conversion);
dlna_mime_type = gupnp_dlna_profile_get_mime(profile);
if (dlna_mime_type != NULL) {
*mime_type = g_strdup(dlna_mime_type);
flags = GUPNP_DLNA_FLAGS_BACKGROUND_TRANSFER_MODE;
flags |= GUPNP_DLNA_FLAGS_CONNECTION_STALL;
flags |= GUPNP_DLNA_FLAGS_DLNA_V15;
if (g_content_type_is_a(dlna_mime_type, "image/*")) {
flags |= GUPNP_DLNA_FLAGS_INTERACTIVE_TRANSFER_MODE;
} else if (g_content_type_is_a(dlna_mime_type, "audio/*") ||
g_content_type_is_a(dlna_mime_type, "video/*")) {
flags |= GUPNP_DLNA_FLAGS_STREAMING_TRANSFER_MODE;
} else {
DLEYNA_LOG_WARNING("Unsupported Mime Type: %s",
dlna_mime_type);
goto on_error;
}
g_string_append_printf(header, "DLNA.ORG_FLAGS=%.8x", flags);
g_string_append_printf(header, "000000000000000000000000");
} else {
DLEYNA_LOG_WARNING("Unable to discover mime_type");
}
on_error:
if (*mime_type == NULL) {
content_type = g_content_type_guess(filename, NULL, 0, NULL);
if (content_type != NULL) {
*mime_type = g_content_type_get_mime_type(content_type);
if (*mime_type == NULL)
*error = g_error_new(DLEYNA_SERVER_ERROR,
DLEYNA_ERROR_BAD_MIME,
"Unable to determine MIME Type for %s",
filename);
g_free(content_type);
} else {
*error = g_error_new(DLEYNA_SERVER_ERROR,
DLEYNA_ERROR_BAD_MIME,
"Unable to determine Content Type for %s",
filename);
}
}
DLEYNA_LOG_DEBUG("contentFeatures.dlna.org: %s", header->str);
g_object_unref(guesser);
g_free(uri);
if (*mime_type)
*dlna_header = g_string_free(header, FALSE);
else
(void) g_string_free(header, TRUE);
return;
}
