build_store.c

Aqualung is an advanced music player primarily targeted for the GNU/Linux operating system, but als

/*                                                     -*- linux-c -*-
    Copyright (C) 2004 Tom Szilagyi

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    $Id: build_store.c,v 1.39 2006/10/01 20:03:40 tszilagyi Exp $
*/

#include <config.h>

#include <dirent.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <unistd.h>
#include <fnmatch.h>
#include <regex.h>
#include <gtk/gtk.h>
#include <sys/stat.h>

#ifdef _WIN32
#include <glib.h>
#else
#include <pthread.h>
#endif /* _WIN32*/

#include "common.h"
#include "i18n.h"
#include "options.h"
#include "music_browser.h"
#include "gui_main.h"
#include "meta_decoder.h"
#include "build_store.h"
#include "cddb_lookup.h"

#define BUILD_STORE   0
#define BUILD_ARTIST  1

#define ARTIST_SORT_NAME      0
#define ARTIST_SORT_NAME_LOW  1
#define ARTIST_SORT_DIR       2
#define ARTIST_SORT_DIR_LOW   3

#define RECORD_SORT_YEAR      0
#define RECORD_SORT_NAME      1
#define RECORD_SORT_NAME_LOW  2
#define RECORD_SORT_DIR       3
#define RECORD_SORT_DIR_LOW   4

#define CAP_ALL_WORDS   0
#define CAP_FIRST_WORD  1


extern options_t options;
extern GtkTreeStore * music_store;

extern GtkWidget * browser_window;
extern GtkWidget * gui_stock_label_button(gchar * blabel, const gchar * bstock);

extern GdkPixbuf * icon_artist;
extern GdkPixbuf * icon_record;
extern GdkPixbuf * icon_track;

#ifdef HAVE_SNDFILE
extern char * valid_extensions_sndfile[];
#endif /* HAVE_SNDFILE */

#ifdef HAVE_MPEG
extern char * valid_extensions_mpeg[];
#endif /* HAVE_MPEG */

#ifdef HAVE_MOD
extern char * valid_extensions_mod[];
#endif /* HAVE_MOD */

AQUALUNG_THREAD_DECLARE(build_thread_id)


int build_thread_state = BUILD_THREAD_FREE;
int build_type;

volatile int build_cancelled = 0;
volatile int write_data_locked = 0;

GtkTreeIter store_iter;
GtkTreeIter artist_iter;
int artist_iter_is_set = 0;
map_t * artist_name_map = NULL;

GtkWidget * build_prog_window = NULL;
GtkWidget * prog_cancel_button;
GtkWidget * prog_file_entry;
GtkWidget * prog_action_label;

GtkWidget * gen_check_excl;
GtkWidget * gen_entry_excl;
GtkWidget * gen_check_incl;
GtkWidget * gen_entry_incl;

GtkWidget * gen_check_cap;
GtkWidget * gen_combo_cap;
GtkWidget * gen_check_cap_pre;
GtkWidget * gen_entry_cap_pre;
GtkWidget * gen_check_cap_low;

GtkWidget * meta_check_enable;
GtkWidget * meta_check_wspace;
GtkWidget * meta_check_title;
GtkWidget * meta_check_artist;
GtkWidget * meta_check_record;
GtkWidget * meta_check_rva;
GtkWidget * meta_check_comment;

#ifdef HAVE_CDDB
GtkWidget * cddb_check_enable;
GtkWidget * cddb_check_title;
GtkWidget * cddb_check_artist;
GtkWidget * cddb_check_record;
#endif /* HAVE_CDDB */

GtkWidget * fs_radio_preset;
GtkWidget * fs_radio_regexp;
GtkWidget * fs_check_rm_number;
GtkWidget * fs_check_rm_ext;
GtkWidget * fs_check_underscore;
GtkWidget * fs_entry_regexp1;
GtkWidget * fs_entry_regexp2;
GtkWidget * fs_label_regexp;
GtkWidget * fs_label_repl;
GtkWidget * fs_label_input;
GtkWidget * fs_entry_input;
GtkWidget * fs_button_test;
GtkWidget * fs_entry_output;
GtkWidget * fs_label_error;

int artist_sort_by = ARTIST_SORT_NAME_LOW;
int record_sort_by = RECORD_SORT_YEAR;
int reset_existing_data = 0;
int add_year_to_comment = 0;

int pri_meta_first = 0;

int excl_enabled = 1;
char ** excl_patternv = NULL;
int incl_enabled = 0;
char ** incl_patternv = NULL;

int cap_enabled = 0;
int cap_pre_enabled = 1;
int cap_low_enabled = 0;
int cap_mode = CAP_ALL_WORDS;
char ** cap_pre_stringv = NULL;

int rm_spaces_enabled = 1;

int meta_enable = 1;
int meta_wspace = 1;
int meta_title = 1;
int meta_artist = 1;
int meta_record = 1;
int meta_rva = 0;
int meta_comment = 0;

int cddb_enable = 1;
int cddb_title = 1;
int cddb_artist = 1;
int cddb_record = 1;

int fs_preset = 1;
int fs_rm_number = 1;
int fs_rm_ext = 1;
int fs_underscore = 1;

char fs_regexp[MAXLEN];
char fs_replacement[MAXLEN];
regex_t fs_compiled;

char root[MAXLEN];


void transform_filename(char * dest, char * src);


map_t *
map_new(char * str) {

	map_t * map;

	if ((map = (map_t *)malloc(sizeof(map_t))) == NULL) {
		fprintf(stderr, "build_store.c: map_new(): malloc error\n");
		return NULL;
	}

	strncpy(map->str, str, MAXLEN-1);
	map->count = 1;
	map->next = NULL;

	return map;
}

void
map_put(map_t ** map, char * str) {

	map_t * pmap;
	map_t * _pmap;

	if (*map == NULL) {
		*map = map_new(str);
	} else {

		for (_pmap = pmap = *map; pmap; _pmap = pmap, pmap = pmap->next) {

			char * key1 = g_utf8_casefold(str, -1);
			char * key2 = g_utf8_casefold(pmap->str, -1);

			if (!g_utf8_collate(key1, key2)) {
				pmap->count++;
				g_free(key1);
				g_free(key2);
				return;
			}

			g_free(key1);
			g_free(key2);
		}

		_pmap->next = map_new(str);
	}
}

char *
map_get_max(map_t * map) {

	map_t * pmap;
	int max = 0;
	char * str = NULL;

	for (pmap = map; pmap; pmap = pmap->next) {
		if (max < pmap->count) {
			str = pmap->str;
			max = pmap->count;
		}
	}

	return str;
}

void
map_free(map_t * map) {

	map_t * pmap;

	for (pmap = map; pmap; map = pmap) {
		pmap = map->next;
		free(map);
	}
}


char *
filter_string(const char * str) {

	int len;
	char * tmp;
	int i;
	int j;


	len = strlen(str);

	if (len == 0) {
		return NULL;
	}

	if ((tmp = (char *)malloc((len + 1) * sizeof(char))) == NULL) {
		fprintf(stderr, "build_store.c: filter_string(): malloc error\n");
		return NULL;
	}

	for (i = 0, j = 0; i < len; i++) {
		if (str[i] != ' ' &&
		    str[i] != '.' &&
		    str[i] != ',' &&
		    str[i] != '?' &&
		    str[i] != '!' &&
		    str[i] != '&' &&
		    str[i] != '\'' &&
		    str[i] != '"' &&
		    str[i] != '-' &&
		    str[i] != '_' &&
		    str[i] != '/' &&
		    str[i] != '(' &&
		    str[i] != ')' &&
		    str[i] != '[' &&
		    str[i] != ']' &&
		    str[i] != '{' &&
		    str[i] != '}') {
			tmp[j++] = str[i];
		}
	}

	tmp[j] = '\0';

	return tmp;
}

int
collate(const char * str1, const char * str2) {

	char * tmp1 = filter_string(str1);
	char * tmp2 = filter_string(str2);

	char * key1 = g_utf8_casefold(tmp1, -1);;
	char * key2 = g_utf8_casefold(tmp2, -1);;

	int i = g_utf8_collate(key1, key2);

	g_free(key1);
	g_free(key2);
	free(tmp1);
	free(tmp2);

	return i;
}


/* return:
     0: if iter was newly created
     1: if iter has already existed
*/

int
store_get_iter_for_artist_and_record(GtkTreeIter * store_iter,
				     GtkTreeIter * artist_iter,
				     GtkTreeIter * record_iter,
				     build_record_t * record) {
	int i;
	int j;

	i = 0;
	while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(music_store),
					     artist_iter, store_iter, i++)) {

		char * artist_name;

		gtk_tree_model_get(GTK_TREE_MODEL(music_store), artist_iter,
				   0, &artist_name, -1);

		if (collate(record->artist, artist_name)) {
			continue;
		}

		j = 0;
		while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(music_store),
						     record_iter, artist_iter, j++)) {
			char * record_name;

			gtk_tree_model_get(GTK_TREE_MODEL(music_store), record_iter,
					   0, &record_name, -1);

			if (!collate(record->record, record_name)) {
				return 1;
			}
		}

		/* create record */
		gtk_tree_store_append(music_store, record_iter, artist_iter);
		gtk_tree_store_set(music_store, record_iter,
				   0, record->record, 1, record->record_sort_name,
				   2, "", 3, record->record_comment, -1);
                if (options.enable_ms_tree_icons) {
                        gtk_tree_store_set(music_store, record_iter, 9, icon_record, -1);
                }

		return 0;
	}

	/* create both artist and record */
	gtk_tree_store_append(music_store, artist_iter, store_iter);
	gtk_tree_store_set(music_store, artist_iter,
			   0, record->artist, 1, record->artist_sort_name, 2, "", 3, "", -1);
        if (options.enable_ms_tree_icons) {
                gtk_tree_store_set(music_store, artist_iter, 9, icon_artist, -1);
        }

	gtk_tree_store_append(music_store, record_iter, artist_iter);
	gtk_tree_store_set(music_store, record_iter,
			   0, record->record, 1, record->record_sort_name,
			   2, "", 3, record->record_comment, -1);
        if (options.enable_ms_tree_icons) {
                gtk_tree_store_set(music_store, record_iter, 9, icon_record, -1);
        }

	return 0;
}

int
artist_get_iter_for_record(GtkTreeIter * artist_iter,
			   GtkTreeIter * record_iter,
			   build_record_t * record) {
	int i = 0;

	while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(music_store),
					     record_iter, artist_iter, i++)) {
		char * record_name;

		gtk_tree_model_get(GTK_TREE_MODEL(music_store), record_iter,
				   0, &record_name, -1);

		if (!collate(record->record, record_name)) {
			return 1;
		}
	}

	/* create record */
	gtk_tree_store_append(music_store, record_iter, artist_iter);
	gtk_tree_store_set(music_store, record_iter,
			   0, record->record, 1, record->record_sort_name,
			   2, "", 3, record->record_comment, -1);
        if (options.enable_ms_tree_icons) {
                gtk_tree_store_set(music_store, record_iter, 9, icon_record, -1);
        }
	return 0;
}


void
meta_check_enable_toggled(GtkWidget * widget, gpointer * data) {

	gboolean state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(meta_check_enable));

	gtk_widget_set_sensitive(meta_check_wspace, state);
	gtk_widget_set_sensitive(meta_check_title, state);
	gtk_widget_set_sensitive(meta_check_artist, state);
	gtk_widget_set_sensitive(meta_check_record, state);
	gtk_widget_set_sensitive(meta_check_rva, state);
	gtk_widget_set_sensitive(meta_check_comment, state);
}


#ifdef HAVE_CDDB
void
cddb_check_enable_toggled(GtkWidget * widget, gpointer * data) {

	gboolean state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cddb_check_enable));

	gtk_widget_set_sensitive(cddb_check_title, state);
	gtk_widget_set_sensitive(cddb_check_artist, state);
	gtk_widget_set_sensitive(cddb_check_record, state);
}
#endif /* HAVE_CDDB */


void
fs_radio_preset_toggled(GtkWidget * widget, gpointer * data) {

	gboolean state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(fs_radio_preset));

	gtk_widget_set_sensitive(fs_check_rm_number, state);
	gtk_widget_set_sensitive(fs_check_rm_ext, state);
	gtk_widget_set_sensitive(fs_check_underscore, state);

	gtk_widget_set_sensitive(fs_entry_regexp1, !state);
	gtk_widget_set_sensitive(fs_entry_regexp2, !state);
	gtk_widget_set_sensitive(fs_label_regexp, !state);
	gtk_widget_set_sensitive(fs_label_repl, !state);
	gtk_widget_set_sensitive(fs_label_error, !state);
}


void
gen_check_excl_toggled(GtkWidget * widget, gpointer * data) {

	gboolean state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gen_check_excl));
	gtk_widget_set_sensitive(gen_entry_excl, state);
}