build_store.c

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

			tmp[j++] = str[i];
			continue;
		} else {
			if (i + 1 < len && str[i + 1] != ' ') {
				tmp[j++] = ' ';
				continue;
			}
		}
	}

	tmp[j] = '\0';

	strncpy(str, tmp, MAXLEN-1);
}

void
process_meta(build_record_t * record) {

	build_track_t * ptrack;
	metadata * meta = meta_new();

	map_t * map_artist = NULL;
	map_t * map_record = NULL;
	map_t * map_year = NULL;

	char tmp[MAXLEN];

	for (ptrack = record->tracks; ptrack; ptrack = ptrack->next) {

		meta = meta_new();

		if (meta_read(meta, ptrack->filename)) {
			if (meta_artist &&
			    !record->artist_valid && meta_get_artist(meta, tmp)) {
				if (!meta_wspace || !is_all_wspace(tmp)) {
					map_put(&map_artist, tmp);
				}
			}
			if (meta_record &&
			    !record->record_valid && meta_get_record(meta, tmp)) {
				if (!meta_wspace || !is_all_wspace(tmp)) {
					map_put(&map_record, tmp);
				}
			}
			if (meta_title &&
			    !ptrack->valid && meta_get_title(meta, ptrack->name)) {
				if (!meta_wspace || !is_all_wspace(ptrack->name)) {
					ptrack->valid = 1;
				}
			}
			if (!record->year_valid && meta_get_year(meta, tmp)) {
				if (!meta_wspace || !is_all_wspace(tmp)) {
					long y = strtol(tmp, NULL, 10);
					if (is_valid_year(y)) {
						map_put(&map_year, tmp);
					}
				}
			}
			if (meta_rva) {
				meta_get_rva(meta, &ptrack->rva);
			}
			if (meta_comment && meta_get_comment(meta, tmp)) {
				if (!meta_wspace || !is_all_wspace(tmp)) {
					strncpy(ptrack->comment, tmp, MAXLEN-1);
				}
			}
		}

		meta_free(meta);
	}

	if (map_artist) {
		char * max = map_get_max(map_artist);

		if (max) {
			strncpy(record->artist, max, MAXLEN-1);
			record->artist_valid = 1;
		}
	}

	if (map_record) {
		char * max = map_get_max(map_record);

		if (max) {
			strncpy(record->record, max, MAXLEN-1);
			record->record_valid = 1;
		}
	}

	if (map_year) {
		char * max = map_get_max(map_year);

		if (max) {
			strncpy(record->year, max, MAXLEN-1);
			record->year_valid = 1;
		}
	}

	map_free(map_artist);
	map_free(map_record);
	map_free(map_year);
}


void
add_new_track(GtkTreeIter * record_iter, build_track_t * ptrack, int i) {

	GtkTreeIter iter;
	char sort_name[3];

	snprintf(sort_name, 3, "%02d", i + 1);

	gtk_tree_store_append(music_store, &iter, record_iter);

	if (ptrack->rva > 0.1f) { /* rva unmeasured */
		gtk_tree_store_set(music_store, &iter,
				   0, ptrack->name,
				   1, sort_name,
				   2, ptrack->filename,
				   3, ptrack->comment,
				   4, ptrack->duration,
				   5, 1.0f,
				   6, 0.0f,
				   7, -1.0f,
				   -1);
                if (options.enable_ms_tree_icons) {
                        gtk_tree_store_set(music_store, &iter, 9, icon_track, -1);
                }
	} else {
		gtk_tree_store_set(music_store, &iter,
				   0, ptrack->name,
				   1, sort_name,
				   2, ptrack->filename,
				   3, ptrack->comment,
				   4, ptrack->duration,
				   5, 1.0f,
				   6, ptrack->rva,
				   7, 1.0f,
				   -1);
                if (options.enable_ms_tree_icons) {
                        gtk_tree_store_set(music_store, &iter, 9, icon_track, -1);
                }
	}
}


gboolean
write_data_to_store(gpointer data) {

	build_record_t * record = (build_record_t *)data;
	build_track_t * ptrack = NULL;
	int result = 0;
	int i;

	GtkTreeIter record_iter;


	if (build_type == BUILD_STORE) {

		char * low1 = g_utf8_strdown(record->artist_d_name, -1);
		char * low2 = g_utf8_strdown(record->artist, -1);

		if (artist_iter_is_set) {
			result = artist_get_iter_for_record(&artist_iter, &record_iter, record);
		} else {
			result = store_get_iter_for_artist_and_record(&store_iter,
								      &artist_iter,
								      &record_iter,
								      record);
			artist_iter_is_set = 1;

			gtk_tree_store_set(music_store, &artist_iter, 0, record->artist, -1);
		}

		if (strcmp(low1, low2)) {
			char * max = NULL;
			map_put(&artist_name_map, record->artist);
			max = map_get_max(artist_name_map);
			gtk_tree_store_set(music_store, &artist_iter, 0, max, -1);
		}

		g_free(low1);
		g_free(low2);

	} else {
		result = artist_get_iter_for_record(&artist_iter, &record_iter, record);
	}

	if (result == 0) {
		for (i = 0, ptrack = record->tracks; ptrack; i++, ptrack = ptrack->next) {
			add_new_track(&record_iter, ptrack, i);
		}
	}

	if (result == 1) {
		for (i = 0, ptrack = record->tracks; ptrack; i++, ptrack = ptrack->next) {

			GtkTreeIter iter;
			int has_track = 0;
			int j = 0;

			while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(music_store),
							     &iter, &record_iter, j++)) {
				char * file = NULL;

				gtk_tree_model_get(GTK_TREE_MODEL(music_store),
						   &iter, 2, &file, -1);

				if (!strcmp(file, ptrack->filename)) {
					has_track = 1;
					g_free(file);
					break;
				}

				g_free(file);
			}

			if (has_track) {
				if (reset_existing_data) {
					if (ptrack->rva > 0.1f) { /* rva unmeasured */
						gtk_tree_store_set(music_store, &iter,
								   0, ptrack->name,
								   4, ptrack->duration,
								   -1);
                                                if (options.enable_ms_tree_icons) {
                                                        gtk_tree_store_set(music_store, &iter,
                                                                           9, icon_track, -1);
                                                }
					} else {
						gtk_tree_store_set(music_store, &iter,
								   0, ptrack->name,
								   4, ptrack->duration,
								   6, ptrack->rva,
								   7, 1.0f,
								   -1);
                                                if (options.enable_ms_tree_icons) {
                                                        gtk_tree_store_set(music_store, &iter,
                                                                           9, icon_track, -1);
                                                }
					}
				}
			} else {
				add_new_track(&record_iter, ptrack, i);
			}
		}
	}

	music_store_mark_changed(&store_iter);

	write_data_locked = 0;

	return FALSE;
}


void
process_record(char * dir_record, char * artist_d_name, char * record_d_name) {

	struct timespec req_time;
	struct timespec rem_time;

	int i;
	struct dirent ** ent_track;
	char basename[MAXLEN];
	char filename[MAXLEN];

	build_record_t record;

	int num_tracks = 0;

	build_track_t * ptrack = NULL;
	build_track_t * last_track = NULL;
	float duration;

	char * utf8;

	req_time.tv_sec = 0;
        req_time.tv_nsec = 10000000;

	record.artist[0] = '\0';
	record.record[0] = '\0';
	record.year[0] = '\0';

	record.record_comment[0] = '\0';
	record.artist_sort_name[0] = '\0';
	record.record_sort_name[0] = '\0';

	record.artist_valid = 0;
	record.record_valid = 0;
	record.year_valid = 0;

	record.tracks = NULL;

	utf8 = g_filename_display_name(artist_d_name);
	record.artist_d_name[0] = '\0';
	strncpy(record.artist_d_name, utf8, MAXLEN-1);
	g_free(utf8);

	g_idle_add(set_prog_action_label, (gpointer) _("Scanning files"));

	for (i = 0; i < scandir(dir_record, &ent_track, filter, alphasort); i++) {

		strncpy(basename, ent_track[i]->d_name, MAXLEN-1);
		snprintf(filename, MAXLEN-1, "%s/%s", dir_record, ent_track[i]->d_name);

		if (is_dir(filename)) {
			continue;
		}

		if (excl_enabled) {
			int i;
			int match = 0;
			for (i = 0; excl_patternv[i]; i++) {

				if (*(excl_patternv[i]) == '\0') {
					continue;
				}

				utf8 = g_locale_to_utf8(basename, -1, NULL, NULL, NULL);

				if (utf8 == NULL) {
					match = 1;
					break;
				}

				if (fnmatch(excl_patternv[i], utf8, FNM_CASEFOLD) == 0) {
					match = 1;
					g_free(utf8);
					break;
				}
				g_free(utf8);
			}

			if (match) {
				continue;
			}
		}

		if (incl_enabled) {
			int i;
			int match = 0;
			for (i = 0; incl_patternv[i]; i++) {

				if (*(incl_patternv[i]) == '\0') {
					continue;
				}

				utf8 = g_locale_to_utf8(basename, -1, NULL, NULL, NULL);

				if (utf8 == NULL) {
					match = 0;
					break;
				}

				if (fnmatch(incl_patternv[i], utf8, FNM_CASEFOLD) == 0) {
					match = 1;
					g_free(utf8);
					break;
				}
				g_free(utf8);
			}

			if (!match) {
				continue;
			}
		}

		if ((duration = get_file_duration(filename)) > 0.0f) {

			build_track_t * track;

			if ((track = (build_track_t *)malloc(sizeof(build_track_t))) == NULL) {
				fprintf(stderr, "build_store.c: process_record(): malloc error\n");
				return;
			} else {
				strncpy(track->filename, filename, MAXLEN-1);
				strncpy(track->d_name, ent_track[i]->d_name, MAXLEN-1);
				track->name[0] = '\0';
				track->comment[0] = '\0';
				track->duration = duration;
				track->rva = 1.0f;
				track->valid = 0;
				track->next = NULL;

				num_tracks++;
			}

			if (record.tracks == NULL) {
				record.tracks = last_track = track;
			} else {
				last_track->next = track;
				last_track = track;
			}
		}
	}

	if (record.tracks == NULL) {
		return;
	}

	/* metadata and cddb */

	if (pri_meta_first) {
		if (meta_enable) {
			g_idle_add(set_prog_action_label, (gpointer) _("Processing metadata"));
			process_meta(&record);
		}
	} else {
#ifdef HAVE_CDDB
		if (cddb_enable) {
			g_idle_add(set_prog_action_label, (gpointer) _("CDDB lookup"));
			cddb_get_batch(&record, cddb_title, cddb_artist, cddb_record);
		}
#endif /* HAVE_CDDB */
	}

	if (record.artist_valid && record.record_valid && num_invalid_tracks(&record) == 0 &&
	    (pri_meta_first || !meta_rva) &&
	    (record.year_valid || (record_sort_by != RECORD_SORT_YEAR && !add_year_to_comment))) {
		goto finish;
	}

	if (!pri_meta_first) {
		if (meta_enable) {
			g_idle_add(set_prog_action_label, (gpointer) _("Processing metadata"));
			process_meta(&record);
		}
	} else {
#ifdef HAVE_CDDB
		if (cddb_enable) {
			g_idle_add(set_prog_action_label, (gpointer) _("CDDB lookup"));
			cddb_get_batch(&record, cddb_title, cddb_artist, cddb_record);
		}
#endif /* HAVE_CDDB */
	}

	if (record.artist_valid && record.record_valid && num_invalid_tracks(&record) == 0) {
		goto finish;
	}

	/* filesystem */

	g_idle_add(set_prog_action_label, (gpointer) _("File name transformation"));

	if (!record.artist_valid) {
		strncpy(record.artist, record.artist_d_name, MAXLEN-1);
		record.artist_valid = 1;
	}

	if (!record.record_valid) {
		utf8 = g_filename_display_name(record_d_name);
		strncpy(record.record, utf8, MAXLEN-1);
		record.record_valid = 1;
		g_free(utf8);
	}

	for (i = 0, ptrack = record.tracks; ptrack; i++, ptrack = ptrack->next) {

		if (!ptrack->valid) {
			utf8 = g_filename_display_name(ptrack->d_name);
			transform_filename(ptrack->name, utf8);
			ptrack->valid = 1;
			g_free(utf8);
		}
	}


	/* add tracks to music store */

 finish:

	switch (artist_sort_by) {
	case ARTIST_SORT_NAME:
		strncpy(record.artist_sort_name, record.artist, MAXLEN-1);
		break;
	case ARTIST_SORT_NAME_LOW:
		utf8 = g_utf8_strdown(record.artist, -1);
		strncpy(record.artist_sort_name, utf8, MAXLEN-1);
		g_free(utf8);
		break;
	case ARTIST_SORT_DIR:
		utf8 = g_filename_display_name(artist_d_name);
		strncpy(record.artist_sort_name, utf8, MAXLEN-1);
		g_free(utf8);
		break;
	case ARTIST_SORT_DIR_LOW:
		utf8 = g_utf8_strdown(record.artist_d_name, -1);
		strncpy(record.artist_sort_name, u