static gboolean
rb_audiocd_plugin_can_reuse_stream_cb (RBPlayer *player,
const char *new_uri,
const char *stream_uri,
GstElement *stream_bin,
RBAudioCdPlugin *plugin)
{
const char *new_device;
const char *old_device;
/* can't do anything with non-cdda URIs */
if (g_str_has_prefix (new_uri, "cdda://") == FALSE ||
g_str_has_prefix (stream_uri, "cdda://") == FALSE) {
return FALSE;
}
/* check the device matches */
new_device = g_utf8_strrchr (new_uri, -1, '#');
old_device = g_utf8_strrchr (stream_uri, -1, '#');
if (strcmp (old_device, new_device) != 0) {
return FALSE;
}
return TRUE;
}
char *
rb_uri_get_short_path_name (const char *uri)
{
const char *start;
const char *end;
if (uri == NULL)
return NULL;
/* skip query string */
end = g_utf8_strchr (uri, -1, '?');
start = g_utf8_strrchr (uri, end ? (end - uri) : -1, '/');
if (start == NULL) {
/* no separator, just a single file name */
} else if ((start + 1 == end) || *(start + 1) == '\0') {
/* last character is the separator, so find the previous one */
end = start;
start = g_utf8_strrchr (uri, (end - uri)-1, '/');
if (start != NULL)
start++;
} else {
start++;
}
if (start == NULL)
start = uri;
if (end == NULL) {
return g_strdup (start);
} else {
return g_strndup (start, (end - start));
}
}
/**
* used for now only while loading a file before the 0.6.0 version
* reduce the exponant IN THE STRING of the amount because before the 0.6.0
* all the gdouble where saved with an exponent very big
* ie : in the file we have "12.340000"
* and that fonction return "12.34" wich will be nicely imported
* with gsb_data_transaction_set_amount_from_string
*
* \param amount_string
* \param exponent the exponent we want at the end (normally always 2, but if ever...)
*
* \return a newly allocated string with only 'exponent' digits after the separator (need to be freed). This function returns NULL if the amount_string parameter is NULL.
* */
gchar *utils_str_reduce_exponant_from_string ( const gchar *amount_string,
gint exponent )
{
gchar *return_string;
gchar *p;
gchar *mon_decimal_point;
gunichar decimal_point = (gunichar )-2;
struct lconv *conv = localeconv ( );
if ( !amount_string )
return NULL;
mon_decimal_point = g_locale_to_utf8 ( conv->mon_decimal_point,
-1, NULL, NULL, NULL );
if ( mon_decimal_point )
decimal_point = g_utf8_get_char_validated ( mon_decimal_point, -1 );
return_string = my_strdup ( amount_string );
if ( ( p = g_utf8_strrchr ( (const gchar *) return_string, -1, '.' ) ) )
{
if ( g_unichar_isdefined ( decimal_point )
&&
g_utf8_strchr ( p, 1, decimal_point ) == NULL )
{
gchar **tab;
tab = g_strsplit ( return_string, ".", 2 );
return_string = g_strjoinv ( mon_decimal_point, tab );
g_strfreev ( tab );
p = g_utf8_strrchr ( (const gchar *) return_string, -1,
decimal_point );
}
}
else if ( ( p = g_utf8_strrchr ( (const gchar *) return_string, -1, ',' ) ) )
{
if ( g_unichar_isdefined ( decimal_point )
&&
g_utf8_strchr ( p, 1, decimal_point ) == NULL )
{
gchar **tab;
tab = g_strsplit ( return_string, ",", 2 );
return_string = g_strjoinv ( mon_decimal_point, tab );
g_strfreev ( tab );
p = g_utf8_strrchr ( (const gchar *) return_string, -1,
decimal_point );
}
}
else
return NULL;
p[exponent + 1] = '\0';
return return_string;
}
static void
rb_audiocd_plugin_reuse_stream_cb (RBPlayer *player,
const char *new_uri,
const char *stream_uri,
GstElement *element,
RBAudioCdPlugin *plugin)
{
GstFormat track_format = gst_format_get_by_nick ("track");
char *track_str;
char *new_device;
guint track;
guint cdda_len;
/* get the new track number */
cdda_len = strlen ("cdda://");
new_device = g_utf8_strrchr (new_uri, -1, '#');
track_str = g_strndup (new_uri + cdda_len, new_device - (new_uri + cdda_len));
track = atoi (track_str);
g_free (track_str);
rb_debug ("seeking to track %d on CD device %s", track, new_device+1);
gst_element_seek (element,
1.0, track_format, GST_SEEK_FLAG_FLUSH,
GST_SEEK_TYPE_SET, track-1,
GST_SEEK_TYPE_NONE, -1);
}
static void
set_source_properties (GstElement *source, const char *uri, gboolean playback_mode)
{
const char *device;
if (g_str_has_prefix (uri, "cdda://") == FALSE)
return;
device = g_utf8_strrchr (uri, -1, '#');
if (device != NULL) {
device++; /* skip the # */
g_object_set (source, "device", device, NULL);
if (playback_mode) {
/* disable paranoia (if using cdparanoiasrc) and set read speed to 1 */
if (g_object_class_find_property (G_OBJECT_GET_CLASS (source), "paranoia-mode"))
g_object_set (source, "paranoia-mode", 0, NULL);
if (g_object_class_find_property (G_OBJECT_GET_CLASS (source), "read-speed"))
g_object_set (source, "read-speed", 1, NULL);
} else {
/* enable full paranoia; maybe this should be configurable. */
/* also, sound-juicer defaults to 8 (scratch) not 0xff (full) here.. */
if (g_object_class_find_property (G_OBJECT_GET_CLASS (source), "paranoia-mode"))
g_object_set (source, "paranoia-mode", 0xff, NULL);
}
}
}
/*******************************************************************************
* Description :
* Argurments :
* Return value :
* Modify :
* warning :
*******************************************************************************/
static int compare_unicode(const char *data0, const char *data1, void *mode_ptr)
{
const char *ptr0, *ptr1;
SortingMode mode = *((SortingMode*)mode_ptr);
ptr0 = g_utf8_strrchr(data0, -1, 0x002F);
ptr1 = g_utf8_strrchr(data1, -1, 0x002F);
ptr0 = ptr0 ? ptr0 + 1 : data0;
ptr1 = ptr1 ? ptr1 + 1 : data1;
if(mode & SORT_ASCEND) {
return g_utf8_collate(ptr0, ptr1);
}
else {
return g_utf8_collate(ptr1, ptr0);
}
}
gchar *
bracketted_to_string (gchar *bracketted,
const char *start_bracket,
const char *end_bracket)
{
const char *utfstart, *utfend, *utfstr;
int start_len, end_len, str_len;
if (!bracketted) return NULL;
utfstart = start_bracket;
utfend = end_bracket;
start_len = strlen (utfstart);
end_len = strlen (utfend);
str_len = strlen (bracketted);
utfstr = bracketted;
if (!strncmp (utfstr, utfstart, start_len)) {
utfstr += start_len;
str_len -= start_len;
}
if (str_len >= end_len && end_len > 0) {
if (g_utf8_strrchr (utfstr, str_len, g_utf8_get_char (utfend)))
str_len -= end_len;
}
return g_strndup (utfstr, str_len);
}
gchar *
rejilla_image_format_fix_path_extension (RejillaImageFormat format,
gboolean check_existence,
const gchar *path)
{
gchar *dot;
guint i = 0;
gchar *retval = NULL;
const gchar *suffix = NULL;;
const gchar *suffixes [] = {".iso",
".toc",
".cue",
".toc",
NULL };
/* search the last dot to check extension */
dot = g_utf8_strrchr (path, -1, '.');
if (dot && strlen (dot) < 5 && strlen (dot) > 1) {
if (format & REJILLA_IMAGE_FORMAT_BIN
&& strcmp (suffixes [0], dot))
*dot = '\0';
else if (format & REJILLA_IMAGE_FORMAT_CLONE
&& strcmp (suffixes [1], dot))
*dot = '\0';
else if (format & REJILLA_IMAGE_FORMAT_CUE
&& strcmp (suffixes [2], dot))
*dot = '\0';
else if (format & REJILLA_IMAGE_FORMAT_CDRDAO
&& strcmp (suffixes [3], dot))
*dot = '\0';
else
return g_strdup (path);
}
/* determine the proper suffix */
if (format & REJILLA_IMAGE_FORMAT_BIN)
suffix = suffixes [0];
else if (format & REJILLA_IMAGE_FORMAT_CLONE)
suffix = suffixes [1];
else if (format & REJILLA_IMAGE_FORMAT_CUE)
suffix = suffixes [2];
else if (format & REJILLA_IMAGE_FORMAT_CDRDAO)
suffix = suffixes [3];
else
return g_strdup (path);
/* make sure the file doesn't exist */
retval = g_strdup_printf ("%s%s", path, suffix);
if (!check_existence)
return retval;
while (g_file_test (retval, G_FILE_TEST_EXISTS)) {
g_free (retval);
retval = g_strdup_printf ("%s-%i%s", path, i, suffix);
i ++;
}
return retval;
}
static void fm_path_entry_changed(GtkEditable *editable, gpointer user_data)
{
FmPathEntry *entry = FM_PATH_ENTRY(editable);
FmPathEntryPrivate *priv = FM_PATH_ENTRY_GET_PRIVATE(entry);
GtkWidget* widget = GTK_WIDGET(entry);
const gchar *path_str, *sep;
/* find parent dir of current path */
path_str = gtk_entry_get_text( GTK_ENTRY(entry) );
sep = g_utf8_strrchr(path_str, -1, G_DIR_SEPARATOR);
if(sep) /* we found a parent dir */
{
int parent_len = (sep - path_str) + 1; /* includes the dir separator / */
if(!priv->parent_dir
|| priv->parent_len != parent_len
|| strncmp(priv->parent_dir, path_str, parent_len ))
{
/* parent dir has been changed, reload dir list */
ListSubDirNames* data = g_slice_new0(ListSubDirNames);
g_free(priv->parent_dir);
priv->parent_dir = g_strndup(path_str, parent_len);
priv->parent_len = parent_len;
/* g_debug("parent dir is changed to %s", priv->parent_dir); */
/* FIXME: convert utf-8 encoded path to on-disk encoding. */
data->entry = entry;
if(priv->parent_dir[0] == '~') /* special case for home dir */
{
char* expand = g_strconcat(g_get_home_dir(), priv->parent_dir + 1, NULL);
data->dir = g_file_new_for_commandline_arg(expand);
g_free(expand);
}
else
data->dir = g_file_new_for_commandline_arg(priv->parent_dir);
/* clear current model */
gtk_list_store_clear(GTK_LIST_STORE(priv->model));
/* cancel running dir-listing jobs */
if(priv->cancellable)
{
g_cancellable_cancel(priv->cancellable);
g_object_unref(priv->cancellable);
}
/* launch a new job to do dir listing */
data->cancellable = g_cancellable_new();
priv->cancellable = (GCancellable*)g_object_ref(data->cancellable);
g_io_scheduler_push_job(list_sub_dirs,
data, (GDestroyNotify)list_sub_dir_names_free,
G_PRIORITY_LOW, data->cancellable);
}
/* calculate the length of remaining part after / */
priv->typed_basename_len = strlen(sep + 1);
}
else /* clear all autocompletion thing. */
clear_completion(priv);
}
int
diagram_load_into(Diagram *diagram,
const char *filename,
DiaImportFilter *ifilter)
{
/* ToDo: move context further up in the callstack and to sth useful with it's content */
DiaContext *ctx = dia_context_new(_("Load Into"));
gboolean was_default = diagram->is_default;
if (!ifilter)
ifilter = filter_guess_import_filter(filename);
/* slightly hacked to avoid 'Not a Dia File' for .shape */
if (!ifilter && g_str_has_suffix (filename, ".shape"))
ifilter = filter_import_get_by_name ("dia-svg");
if (!ifilter) /* default to native format */
ifilter = &dia_import_filter;
dia_context_set_filename (ctx, filename);
if (ifilter->import_func(filename, diagram->data, ctx, ifilter->user_data)) {
if (ifilter != &dia_import_filter) {
/* When loading non-Dia files, change filename to reflect that saving
* will produce a Dia file. See bug #440093 */
if (strcmp (diagram->filename, filename) == 0) {
/* not a real load into but initial load */
gchar *old_filename = g_strdup (diagram->filename);
gchar *suffix_offset = g_utf8_strrchr(old_filename, -1, (gunichar)'.');
gchar *new_filename;
if (suffix_offset != NULL) {
new_filename = g_strndup(old_filename, suffix_offset - old_filename);
g_free(old_filename);
} else {
new_filename = old_filename;
}
old_filename = g_strconcat(new_filename, ".dia", NULL);
g_free(new_filename);
diagram_set_filename(diagram, old_filename);
g_free(old_filename);
diagram->unsaved = TRUE;
diagram_update_for_filename (diagram);
diagram_modified(diagram);
}
} else {
/* the initial diagram should have confirmed filename */
diagram->unsaved =
strcmp(filename, diagram->filename) == 0 ? FALSE : was_default;
}
diagram_set_modified(diagram, TRUE);
dia_context_release(ctx);
return TRUE;
} else {
dia_context_release(ctx);
return FALSE;
}
}
static gboolean
_evhelpers_filename_check_data_base64_prefix(const gchar *string)
{
gchar *c;
gsize s;
c = g_utf8_strchr(string, -1, ',');
s = c - string;
if ( ( c == NULL ) || ( s < strlen(";base64") ) )
return FALSE;
c = g_utf8_strrchr(string, s, ';');
if ( ( c == NULL ) || ( ! g_str_has_prefix(c, ";base64") ) )
return FALSE;
return TRUE;
}
/* The final " (xx, yy, zz, kk)" part of the string (if present) was
* added by us in _to_s(), we must remove it before setting the string
* back again.
*
* It may not be there if the user has changed the string.
*/
static char *
drop_tail( const char *data )
{
char *str;
char *p;
str = g_strdup( data );
p = str + strlen( str );
if( p > str &&
*g_utf8_prev_char( p ) == ')' &&
(p = g_utf8_strrchr( str, -1, (gunichar) '(')) &&
p > str &&
*(p = g_utf8_prev_char( p )) == ' ' )
*p = '\0';
return( str );
}
static gchar *
photos_utils_get_pixbuf_suffix_from_basename (const gchar *basename)
{
gchar *suffix;
gchar *suffix_start;
guint len;
/* FIXME: does this work for all locales? */
suffix_start = g_utf8_strrchr (basename, -1, '.');
if (suffix_start == NULL)
return NULL;
len = strlen (suffix_start) - 1;
suffix = g_strndup (suffix_start+1, len);
return suffix;
}
gchar * GetNameFromFileName(const gchar* lpszFileName, gchar * lpszName, gint nLen)
{
if (!lpszName || nLen == 0)return NULL;
lpszName[0] = 0;
gchar * lpszDot = g_utf8_strrchr(lpszFileName, MAX_PATH, '.');
if (lpszDot)
{
int nCpy = nLen - 1;
if (nCpy > lpszDot - lpszFileName)nCpy = lpszDot - lpszFileName;
memcpy(lpszName, lpszFileName, nCpy);
lpszName[nCpy] = 0;
}
else
{
strncpy(lpszName, lpszFileName, nLen);
}
return lpszName;
}
static void get_apps_history ( DRunModePrivateData *pd )
{
unsigned int length = 0;
gchar *path = g_build_filename ( cache_dir, DRUN_CACHE_FILE, NULL );
gchar **retv = history_get_list ( path, &length );
for ( unsigned int index = 0; index < length; index++ ) {
char **st = g_strsplit ( retv[index], ":::", 2 );
if ( st && st[0] && st[1] ) {
const gchar *basename = g_utf8_strrchr ( st[1], -1, G_DIR_SEPARATOR );
if ( basename == NULL || !read_desktop_file ( pd, st[0], st[1], ++basename ) ) {
history_remove ( path, retv[index] );
}
}
g_strfreev ( st );
}
g_strfreev ( retv );
g_free ( path );
pd->history_length = pd->cmd_list_length;
}
static gchar* fm_get_user_input_rename(GtkWindow* parent, const char* title, const char* msg, const char* default_text)
{
GtkDialog* dlg = _fm_get_user_input_dialog( parent, title, msg);
GtkEntry* entry = GTK_ENTRY(gtk_entry_new());
gtk_entry_set_activates_default(entry, TRUE);
if(default_text && default_text[0])
{
gtk_entry_set_text(entry, default_text);
/* only select filename part without extension name. */
if(default_text[1])
{
/* FIXME: handle the special case for *.tar.gz or *.tar.bz2
* We should exam the file extension with g_content_type_guess, and
* find out a longest valid extension name.
* For example, the extension name of foo.tar.gz is .tar.gz, not .gz. */
const char* dot = g_utf8_strrchr(default_text, -1, '.');
if(dot)
gtk_editable_select_region(GTK_EDITABLE(entry), 0, g_utf8_pointer_to_offset(default_text, dot));
else
gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
/*
const char* dot = default_text;
while( dot = g_utf8_strchr(dot + 1, -1, '.') )
{
gboolean uncertain;
char* type = g_content_type_guess(dot-1, NULL, 0, &uncertain);
if(!g_content_type_is_unknown(type))
{
g_free(type);
gtk_editable_select_region(entry, 0, g_utf8_pointer_to_offset(default_text, dot));
break;
}
g_free(type);
}
*/
}
}
return _fm_user_input_dialog_run(dlg, entry, NULL);
}
static GSList *
tracker_gsettings_get_all (gint *longest_name_length)
{
typedef struct {
const gchar *schema;
const gchar *path;
} SchemaWithPath;
TrackerMinerManager *manager;
GError *error = NULL;
GSettings *settings;
GSList *all = NULL;
GSList *l;
GSList *miners_available;
GSList *valid_schemas = NULL;
const gchar * const *schema;
gint len = 0;
SchemaWithPath components[] = {
{ "Store", "store" },
{ "Extract", "extract" },
{ "Writeback", "writeback" },
{ 0 }
};
SchemaWithPath *swp;
/* Don't auto-start the miners here */
manager = tracker_miner_manager_new_full (FALSE, &error);
if (!manager) {
g_printerr (_("Could not get GSettings for miners, manager could not be created, %s"),
error ? error->message : "unknown error");
g_printerr ("\n");
g_clear_error (&error);
return NULL;
}
miners_available = tracker_miner_manager_get_available (manager);
/* Get valid schemas so we don't try to load invalid ones */
for (schema = g_settings_list_schemas (); schema && *schema; schema++) {
if (!g_str_has_prefix (*schema, "org.freedesktop.Tracker.")) {
continue;
}
valid_schemas = g_slist_prepend (valid_schemas, g_strdup (*schema));
}
/* Store / General */
for (swp = components; swp && swp->schema; swp++) {
gchar *schema;
gchar *path;
schema = g_strdup_printf ("org.freedesktop.Tracker.%s", swp->schema);
path = g_strdup_printf ("/org/freedesktop/tracker/%s/", swp->path);
/* If miner doesn't have a schema, no point in getting config */
if (!tracker_string_in_gslist (schema, valid_schemas)) {
g_free (path);
g_free (schema);
continue;
}
len = MAX (len, strlen (swp->schema));
settings = g_settings_new_with_path (schema, path);
if (settings) {
ComponentGSettings *c = g_slice_new (ComponentGSettings);
c->name = g_strdup (swp->schema);
c->settings = settings;
c->is_miner = FALSE;
all = g_slist_prepend (all, c);
}
}
/* Miners */
for (l = miners_available; l; l = l->next) {
const gchar *name;
gchar *schema;
gchar *name_lowercase;
gchar *path;
gchar *miner;
miner = l->data;
if (!miner) {
continue;
}
name = g_utf8_strrchr (miner, -1, '.');
if (!name) {
continue;
}
name++;
name_lowercase = g_utf8_strdown (name, -1);
schema = g_strdup_printf ("org.freedesktop.Tracker.Miner.%s", name);
path = g_strdup_printf ("/org/freedesktop/tracker/miner/%s/", name_lowercase);
g_free (name_lowercase);
/* If miner doesn't have a schema, no point in getting config */
if (!tracker_string_in_gslist (schema, valid_schemas)) {
g_free (path);
g_free (schema);
continue;
}
settings = g_settings_new_with_path (schema, path);
g_free (path);
g_free (schema);
if (settings) {
ComponentGSettings *c = g_slice_new (ComponentGSettings);
c->name = g_strdup (name);
c->settings = settings;
c->is_miner = TRUE;
all = g_slist_prepend (all, c);
len = MAX (len, strlen (name));
}
}
g_slist_foreach (valid_schemas, (GFunc) g_free, NULL);
g_slist_free (valid_schemas);
g_slist_foreach (miners_available, (GFunc) g_free, NULL);
g_slist_free (miners_available);
g_object_unref (manager);
if (longest_name_length) {
*longest_name_length = len;
}
return g_slist_reverse (all);
}
/*
* @data: a m3u8 playlist text data, taking ownership
*/
static gboolean
gst_m3u8_update (GstM3U8 * self, gchar * data, gboolean * updated)
{
gint val, duration;
gchar *title, *end;
// gboolean discontinuity;
GstM3U8 *list;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (updated != NULL, FALSE);
*updated = TRUE;
/* check if the data changed since last update */
if (self->last_data && g_str_equal (self->last_data, data)) {
GST_DEBUG ("Playlist is the same as previous one");
*updated = FALSE;
g_free (data);
return TRUE;
}
if (!g_str_has_prefix (data, "#EXTM3U")) {
GST_WARNING ("Data doesn't start with #EXTM3U");
g_free (data);
return FALSE;
}
g_free (self->last_data);
self->last_data = data;
if (self->files) {
g_list_foreach (self->files, (GFunc) gst_m3u8_media_file_free, NULL);
g_list_free (self->files);
self->files = NULL;
}
list = NULL;
duration = -1;
title = NULL;
data += 7;
while (TRUE) {
end = g_utf8_strchr (data, -1, '\n'); /* FIXME: support \r\n */
if (end)
*end = '\0';
if (data[0] != '#') {
if (duration < 0 && list == NULL) {
GST_LOG ("%s: got line without EXTINF or EXTSTREAMINF, dropping", data);
goto next_line;
}
if (!gst_uri_is_valid (data)) {
gchar *slash;
if (!self->uri) {
GST_WARNING ("uri not set, can't build a valid uri");
goto next_line;
}
slash = g_utf8_strrchr (self->uri, -1, '/');
if (!slash) {
GST_WARNING ("Can't build a valid uri");
goto next_line;
}
*slash = '\0';
data = g_strdup_printf ("%s/%s", self->uri, data);
*slash = '/';
} else
data = g_strdup (data);
if (list != NULL) {
if (g_list_find_custom (self->lists, data,
(GCompareFunc) _m3u8_compare_uri)) {
GST_DEBUG ("Already have a list with this URI");
gst_m3u8_free (list);
g_free (data);
} else {
gst_m3u8_set_uri (list, data);
self->lists = g_list_append (self->lists, list);
}
list = NULL;
} else {
GstM3U8MediaFile *file;
file =
gst_m3u8_media_file_new (data, title, duration,
self->mediasequence++);
duration = -1;
title = NULL;
self->files = g_list_append (self->files, file);
}
} else if (g_str_has_prefix (data, "#EXT-X-ENDLIST")) {
self->endlist = TRUE;
} else if (g_str_has_prefix (data, "#EXT-X-VERSION:")) {
if (int_from_string (data + 15, &data, &val))
self->version = val;
} else if (g_str_has_prefix (data, "#EXT-X-STREAM-INF:")) {
gchar *v, *a;
if (list != NULL) {
GST_WARNING ("Found a list without a uri..., dropping");
gst_m3u8_free (list);
}
list = gst_m3u8_new ();
data = data + 18;
while (data && parse_attributes (&data, &a, &v)) {
if (g_str_equal (a, "BANDWIDTH")) {
if (!int_from_string (v, NULL, &list->bandwidth))
GST_WARNING ("Error while reading BANDWIDTH");
} else if (g_str_equal (a, "PROGRAM-ID")) {
if (!int_from_string (v, NULL, &list->program_id))
GST_WARNING ("Error while reading PROGRAM-ID");
} else if (g_str_equal (a, "CODECS")) {
g_free (list->codecs);
list->codecs = g_strdup (v);
} else if (g_str_equal (a, "RESOLUTION")) {
if (!int_from_string (v, &v, &list->width))
GST_WARNING ("Error while reading RESOLUTION width");
if (!v || *v != '=') {
GST_WARNING ("Missing height");
} else {
v = g_utf8_next_char (v);
if (!int_from_string (v, NULL, &list->height))
GST_WARNING ("Error while reading RESOLUTION height");
}
}
}
} else if (g_str_has_prefix (data, "#EXT-X-TARGETDURATION:")) {
if (int_from_string (data + 22, &data, &val))
self->targetduration = val;
} else if (g_str_has_prefix (data, "#EXT-X-MEDIA-SEQUENCE:")) {
if (int_from_string (data + 22, &data, &val))
self->mediasequence = val;
} else if (g_str_has_prefix (data, "#EXT-X-DISCONTINUITY")) {
/* discontinuity = TRUE; */
} else if (g_str_has_prefix (data, "#EXT-X-PROGRAM-DATE-TIME:")) {
/* <YYYY-MM-DDThh:mm:ssZ> */
GST_DEBUG ("FIXME parse date");
} else if (g_str_has_prefix (data, "#EXT-X-ALLOW-CACHE:")) {
g_free (self->allowcache);
self->allowcache = g_strdup (data + 19);
} else if (g_str_has_prefix (data, "#EXTINF:")) {
if (!int_from_string (data + 8, &data, &val)) {
GST_WARNING ("Can't read EXTINF duration");
goto next_line;
}
duration = val;
if (duration > self->targetduration)
GST_WARNING ("EXTINF duration > TARGETDURATION");
if (!data || *data != ',')
goto next_line;
data = g_utf8_next_char (data);
if (data != end) {
g_free (title);
title = g_strdup (data);
}
} else {
GST_LOG ("Ignored line: %s", data);
}
next_line:
if (!end)
break;
data = g_utf8_next_char (end); /* skip \n */
}
/* redorder playlists by bitrate */
if (self->lists)
self->lists =
g_list_sort (self->lists,
(GCompareFunc) gst_m3u8_compare_playlist_by_bitrate);
return TRUE;
}
gboolean
rb_uri_is_hidden (const char *text_uri)
{
return g_utf8_strrchr (text_uri, -1, '/')[1] == '.';
}
static char *
get_filename_from_list (GList *file_list)
{
GList *l;
GString *common_part = NULL;
gboolean matches = TRUE;
guint offset = 0;
const char *encoding;
gboolean use_utf8 = TRUE;
encoding = g_getenv ("G_FILENAME_ENCODING");
if (encoding != NULL && strcasecmp (encoding, "UTF-8") != 0)
use_utf8 = FALSE;
if (file_list == NULL)
return NULL;
common_part = g_string_new ("");
while (TRUE) {
gunichar cur_char = '\0';
for (l = file_list; l ; l = l->next) {
char *path = NULL, *name = NULL;
char *offset_name = NULL;
path = g_filename_from_uri ((char *) l->data, NULL, NULL);
if (!path)
break;
name = g_path_get_basename (path);
if (!use_utf8) {
char *tmp;
tmp = g_filename_to_utf8 (name, -1, NULL, NULL, NULL);
g_free (name);
name = tmp;
}
if (!name) {
g_free (path);
break;
}
if (offset >= g_utf8_strlen (name, -1)) {
g_free(name);
g_free(path);
matches = FALSE;
break;
}
offset_name = g_utf8_offset_to_pointer (name, offset);
if (offset_name == g_utf8_strrchr (name, -1, '.')) {
g_free (name);
g_free (path);
matches = FALSE;
break;
}
if (cur_char == '\0') {
cur_char = g_utf8_get_char (offset_name);
} else if (cur_char != g_utf8_get_char (offset_name)) {
g_free (name);
g_free (path);
matches = FALSE;
break;
}
g_free (name);
g_free (path);
}
if (matches == TRUE &&
cur_char != '\0' &&
cur_char != '-' &&
cur_char != '_') {
offset++;
common_part = g_string_append_unichar (common_part,
cur_char);
} else {
break;
}
}
if (g_utf8_strlen (common_part->str, -1) < 4) {
g_string_free (common_part, TRUE);
return NULL;
}
return g_string_free (common_part, FALSE);
}
static char *
impl_build_dest_uri (RBTransferTarget *target,
RhythmDBEntry *entry,
const char *media_type,
const char *extension)
{
RBAndroidSourcePrivate *priv = GET_PRIVATE (target);
const char *in_artist;
char *artist, *album, *title;
gulong track_number, disc_number;
char *number;
char *file = NULL;
char *storage_uri;
char *uri;
char *ext;
GFile *storage = NULL;
if (extension != NULL) {
ext = g_strconcat (".", extension, NULL);
} else {
ext = g_strdup ("");
}
in_artist = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_ALBUM_ARTIST);
if (in_artist[0] == '\0') {
in_artist = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_ARTIST);
}
artist = sanitize_path (in_artist);
album = sanitize_path (rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_ALBUM));
title = sanitize_path (rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_TITLE));
/* we really do need to fix this so untagged entries actually have NULL rather than
* a translated string.
*/
if (strcmp (artist, _("Unknown")) == 0 && strcmp (album, _("Unknown")) == 0 &&
g_str_has_suffix (rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION), title)) {
/* file isn't tagged, so just use the filename as-is, replacing the extension */
char *p;
p = g_utf8_strrchr (title, -1, '.');
if (p != NULL) {
*p = '\0';
}
file = g_strdup_printf ("%s%s", title, ext);
}
if (file == NULL) {
track_number = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_TRACK_NUMBER);
disc_number = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_DISC_NUMBER);
if (disc_number > 0)
number = g_strdup_printf ("%.02u.%.02u", (guint)disc_number, (guint)track_number);
else
number = g_strdup_printf ("%.02u", (guint)track_number);
/* artist/album/number - title */
file = g_strdup_printf (G_DIR_SEPARATOR_S "%s" G_DIR_SEPARATOR_S "%s" G_DIR_SEPARATOR_S "%s%%20-%%20%s%s",
artist, album, number, title, ext);
g_free (number);
}
g_free (artist);
g_free (album);
g_free (title);
g_free (ext);
/* pick storage container to use somehow
for (l = priv->storage; l != NULL; l = l->next) {
}
*/
if (priv->storage)
storage = priv->storage->data;
if (storage == NULL) {
rb_debug ("couldn't find a container to store anything in");
g_free (file);
return NULL;
}
storage_uri = g_file_get_uri (storage);
uri = g_strconcat (storage_uri, file, NULL);
g_free (file);
g_free (storage_uri);
return uri;
}
static char *
impl_build_dest_uri (RBRemovableMediaSource *source,
RhythmDBEntry *entry,
const char *mimetype,
const char *extension)
{
RBGenericPlayerSourcePrivate *priv = GENERIC_PLAYER_SOURCE_GET_PRIVATE (source);
char *artist, *album, *title;
gulong track_number, disc_number;
const char *folders;
char **audio_folders;
char *mount_path;
char *number;
char *file = NULL;
char *path;
char *ext;
rb_debug ("building dest uri for entry at %s", rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION));
if (extension != NULL) {
ext = g_strconcat (".", extension, NULL);
} else {
ext = g_strdup ("");
}
artist = sanitize_path (rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_ARTIST));
album = sanitize_path (rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_ALBUM));
title = sanitize_path (rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_TITLE));
/* we really do need to fix this so untagged entries actually have NULL rather than
* a translated string.
*/
if (strcmp (artist, _("Unknown")) == 0 && strcmp (album, _("Unknown")) == 0 &&
g_str_has_suffix (rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION), title)) {
/* file isn't tagged, so just use the filename as-is, replacing the extension */
char *p;
p = g_utf8_strrchr (title, -1, '.');
if (p != NULL) {
*p = '\0';
}
file = g_strdup_printf ("%s%s", title, ext);
}
if (file == NULL) {
int folder_depth;
track_number = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_TRACK_NUMBER);
disc_number = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_DISC_NUMBER);
if (disc_number > 0)
number = g_strdup_printf ("%.02u.%.02u", (guint)disc_number, (guint)track_number);
else
number = g_strdup_printf ("%.02u", (guint)track_number);
g_object_get (priv->device_info, "folder-depth", &folder_depth, NULL);
switch (folder_depth) {
case 0:
/* artist - album - number - title */
file = g_strdup_printf ("%s - %s - %s - %s%s",
artist, album, number, title, ext);
break;
case 1:
/* artist - album/number - title */
file = g_strdup_printf ("%s - %s" G_DIR_SEPARATOR_S "%s - %s%s",
artist, album, number, title, ext);
break;
default: /* use this for players that don't care */
case 2:
/* artist/album/number - title */
file = g_strdup_printf ("%s" G_DIR_SEPARATOR_S "%s" G_DIR_SEPARATOR_S "%s - %s%s",
artist, album, number, title, ext);
break;
}
g_free (number);
}
g_free (artist);
g_free (album);
g_free (title);
g_free (ext);
if (file == NULL)
return NULL;
g_object_get (priv->device_info, "audio-folders", &audio_folders, NULL);
if (audio_folders != NULL && g_strv_length (audio_folders) > 0) {
folders = g_strdup (audio_folders[0]);
} else {
folders = "";
}
g_strfreev (audio_folders);
mount_path = rb_generic_player_source_get_mount_path (RB_GENERIC_PLAYER_SOURCE (source));
path = g_build_filename (mount_path, folders, file, NULL);
g_free (file);
g_free (mount_path);
/* TODO: check for duplicates, or just overwrite by default? */
rb_debug ("dest file is %s", path);
return path;
}
static void
_j4status_io_server_add(J4statusIOContext *self, const gchar *server_desc)
{
GSocketAddress *address = NULL;
const gchar *path = NULL;
if ( g_str_has_prefix(server_desc, "tcp:") )
{
GInetAddress *inet_address;
const gchar *uri = server_desc + strlen("tcp:");
gchar *port_str = g_utf8_strrchr(uri, -1, ':');
if ( port_str == NULL )
{
/* No host, only port */
port_str = (gchar *) uri;
/* If you want IPv4, just use "0.0.0.0" */
inet_address = g_inet_address_new_any(G_SOCKET_FAMILY_IPV6);
}
else
{
*port_str = '\0';
++port_str;
inet_address = g_inet_address_new_from_string(uri);
}
guint64 port;
port = g_ascii_strtoull(port_str, NULL, 10);
if ( port > 65535 )
return;
address = g_inet_socket_address_new(inet_address, port);
}
#ifdef G_OS_UNIX
if ( g_str_has_prefix(server_desc, "unix:") )
{
path = server_desc + strlen("unix:");
address = g_unix_socket_address_new(path);
}
#endif /* G_OS_UNIX */
if ( address == NULL )
return;
gboolean need_free_server = _j4status_io_add_server(self);
GError *error = NULL;
gboolean r;
r = g_socket_listener_add_address(G_SOCKET_LISTENER(self->server), address, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_DEFAULT, NULL, NULL, &error);
g_object_unref(address);
if ( r )
{
if ( path != NULL )
self->paths_to_unlink = g_list_prepend(self->paths_to_unlink, g_strdup(path));
return;
}
g_warning("Couldn't add listener for '%s': %s", server_desc, error->message);
g_clear_error(&error);
if ( need_free_server )
{
g_object_unref(self->server);
self->server = NULL;
}
}
/* Trash everything. */
gboolean cmd_wipe_in_line(struct cmdline* cmd, enum direction dir) {
gchar* CR_l;
gchar* CR_r;
int chars;
switch (dir) {
case D_RIGHT: /* Clear to right (in this line) */
/* Find the ^M to the right. */
if (cmd->is_utf8) {
CR_r = g_utf8_strchr(
cmd->data->str + cmd->pos,
cmd->data->len - cmd->pos,
g_utf8_get_char("\015"));
}
else
CR_r = strchr(cmd->data->str + cmd->pos, '\015');
if (!CR_r) {
/* Erase everything to the right -- no ^Ms to take into
account. */
cmd->data = g_string_truncate(cmd->data, cmd->pos);
}
else {
/* Erase to the right up to the first ^M. */
if (cmd->is_utf8) {
chars = g_utf8_pointer_to_offset(
cmd->data->str + cmd->pos, CR_r);
}
else
chars = (CR_r - cmd->data->str) - cmd->pos;
cmd_del_chars(cmd, chars);
/* If we were at pos 0, this is the new pos 0; delete the
CR. */
if (cmd->pos == 0)
cmd_del_chars(cmd, 1);
}
break;
case D_LEFT: /* Clear to left -- I've never seen this happen. */
g_return_val_if_reached(FALSE);
break;
case D_ALL: /* Clear all (in this line). */
/* Find the ^M to the right. */
if (cmd->is_utf8) {
CR_r = g_utf8_strchr(
cmd->data->str + cmd->pos,
cmd->data->len - cmd->pos,
g_utf8_get_char("\015"));
}
else
CR_r = strchr(cmd->data->str + cmd->pos, '\015');
if (!CR_r)
CR_r = cmd->data->str + cmd->data->len;
/* Find the ^M to the left. */
if (cmd->is_utf8) {
CR_l = g_utf8_strrchr(cmd->data->str, cmd->pos,
g_utf8_get_char("\015"));
}
else
CR_l = g_strrstr_len(cmd->data->str, cmd->pos, "\015");
if (!CR_l)
CR_l = cmd->data->str;
/* Delete everything in-between. */
cmd->pos = CR_l - cmd->data->str;
if (cmd->is_utf8)
chars = g_utf8_pointer_to_offset(CR_l, CR_r);
else
chars = CR_r - CR_l;
cmd_del_chars(cmd, chars);
break;
default:
g_return_val_if_reached(FALSE);
break;
}
action_queue(A_SEND_CMD);
return TRUE;
}
static void
_j4status_io_add_stream(J4statusIOContext *self, const gchar *stream_desc)
{
J4statusIOStream *stream;
if ( g_strcmp0(stream_desc, "std") == 0 )
{
GOutputStream *out;
GInputStream *in;
#ifdef G_OS_UNIX
out = g_unix_output_stream_new(1, FALSE);
in = g_unix_input_stream_new(0, FALSE);
#else /* ! G_OS_UNIX */
return;
#endif /* ! G_OS_UNIX */
stream = _j4status_io_stream_new(self);
stream->out = g_data_output_stream_new(out);
stream->in = g_data_input_stream_new(in);
g_object_unref(out);
g_object_unref(in);
_j4status_io_stream_put_header(stream, self->header);
g_data_input_stream_read_line_async(stream->in, G_PRIORITY_DEFAULT, NULL, _j4status_io_stream_read_callback, stream);
goto end;
}
GSocketAddress *address = NULL;
if ( g_str_has_prefix(stream_desc, "tcp:") )
{
const gchar *uri = stream_desc + strlen("tcp:");
gchar *port_str = g_utf8_strrchr(uri, -1, ':');
if ( port_str == NULL )
/* No port, illegal stream description */
return;
*port_str = '\0';
++port_str;
guint64 port;
port = g_ascii_strtoull(port_str, NULL, 10);
if ( port > 65535 )
return;
GInetAddress *inet_address;
inet_address = g_inet_address_new_from_string(uri);
address = g_inet_socket_address_new(inet_address, port);
}
#ifdef G_OS_UNIX
if ( g_str_has_prefix(stream_desc, "unix:") )
{
const gchar *path = stream_desc + strlen("unix:");
address = g_unix_socket_address_new(path);
}
#endif /* G_OS_UNIX */
if ( address == NULL )
return;
stream = _j4status_io_stream_new(self);
stream->address = address;
_j4status_io_stream_connect(stream);
end:
self->streams = g_list_prepend(self->streams, stream);
}
/*
* Get mime-type info of the specified file (slow, but more accurate):
* To determine the mime-type of the file, mime_type_get_by_filename() is
* tried first. If the mime-type couldn't be determined, the content of
* the file will be checked, which is much more time-consuming.
* If statbuf is not NULL, it will be used to determine if the file is a directory,
* or if the file is an executable file; otherwise, the function will call stat()
* to gather this info itself. So if you already have stat info of the file,
* pass it to the function to prevent checking the file stat again.
* If you have basename of the file, pass it to the function can improve the
* efifciency, too. Otherwise, the function will try to get the basename of
* the specified file again.
*/
const char* mime_type_get_by_file( const char* filepath, struct stat64* statbuf, const char* basename )
{
const char* type;
struct stat64 _statbuf;
if( statbuf == NULL || G_UNLIKELY( S_ISLNK(statbuf->st_mode) ) )
{
statbuf = &_statbuf;
if( stat64 ( filepath, statbuf ) == -1 )
return XDG_MIME_TYPE_UNKNOWN;
}
if( S_ISDIR( statbuf->st_mode ) )
return XDG_MIME_TYPE_DIRECTORY;
if( basename == NULL )
{
basename = g_utf8_strrchr( filepath, -1, '/' );
if( G_LIKELY( basename ) )
++basename;
else
basename = filepath;
}
if( G_LIKELY(basename) )
{
type = mime_type_get_by_filename( basename, statbuf );
if( G_LIKELY( strcmp( type, XDG_MIME_TYPE_UNKNOWN ) ) )
return type;
type = NULL;
}
//sfm added check for fifo due to hang on one system with a particular pipe
// - is this needed?
if( G_LIKELY(statbuf->st_size > 0 && !S_ISFIFO( statbuf->st_mode ) ) )
{
int fd = -1;
char* data;
/* Open the file and map it into memory */
fd = open ( filepath, O_RDONLY, 0 );
if ( fd != -1 )
{
int len = mime_cache_max_extent < statbuf->st_size ? mime_cache_max_extent : statbuf->st_size;
#ifdef HAVE_MMAP
data = (char*) mmap( NULL, len, PROT_READ, MAP_SHARED, fd, 0 );
#else
/*
* FIXME: Can g_alloca() be used here? It's very fast, but is it safe?
* Actually, we can allocate a block of memory with the size of mime_cache_max_extent,
* then we don't need to do dynamic allocation/free every time, but multi-threading
* will be a nightmare, so...
*/
/* try to lock the common buffer */
if( G_LIKELY( G_TRYLOCK( mime_magic_buf ) ) )
data = mime_magic_buf;
else /* the buffer is in use, allocate new one */
data = g_malloc( len );
len = read( fd, data, len );
if( G_UNLIKELY( len == -1 ) )
{
if( G_LIKELY( data == mime_magic_buf ) )
G_UNLOCK( mime_magic_buf );
else
g_free( data );
data = (void*)-1;
}
#endif
if( data != (void*)-1 )
{
int i;
for( i = 0; ! type && i < n_caches; ++i )
type = mime_cache_lookup_magic( caches[i], data, len );
/* Check for executable file */
if( ! type && g_file_test( filepath, G_FILE_TEST_IS_EXECUTABLE ) )
type = XDG_MIME_TYPE_EXECUTABLE;
/* fallback: check for plain text */
if( ! type )
{
if( mime_type_is_data_plain_text( data, len > TEXT_MAX_EXTENT ? TEXT_MAX_EXTENT : len ) )
type = XDG_MIME_TYPE_PLAIN_TEXT;
}
#ifdef HAVE_MMAP
munmap ( (char*)data, len );
#else
if( G_LIKELY( data == mime_magic_buf ) )
G_UNLOCK( mime_magic_buf ); /* unlock the common buffer */
else /* we use our own buffer */
g_free( data );
#endif
}
close( fd );
}
}
else
{
/* empty file can be viewed as text file */
type = XDG_MIME_TYPE_PLAIN_TEXT;
}
return type && *type ? type : XDG_MIME_TYPE_UNKNOWN;
}
