* \sa mood_item, mood_open().
*/
struct mood {
- /** the name of this mood */
+ /** The name of this mood. */
char *name;
/** The list of mood items of type \p accept. */
struct list_head accept_list;
return 1;
}
-static int compute_mood_score(const struct osl_row *row, long *result)
+static int compute_mood_score(const struct osl_row *aft_row, struct mood *m,
+ long *result)
{
struct mood_item *item;
int match = 0;
long score_arg_sum = 0, score = 0;
- if (!current_mood)
+ if (!m)
return -E_NO_MOOD;
/* reject audio file if it matches any entry in the deny list */
- list_for_each_entry(item, ¤t_mood->deny_list, mood_item_node)
- if (add_item_score(row, item, &score, &score_arg_sum) > 0)
+ list_for_each_entry(item, &m->deny_list, mood_item_node)
+ if (add_item_score(aft_row, item, &score, &score_arg_sum) > 0)
return -E_NOT_ADMISSIBLE;
- list_for_each_entry(item, ¤t_mood->accept_list, mood_item_node)
- if (add_item_score(row, item, &score, &score_arg_sum) > 0)
+ list_for_each_entry(item, &m->accept_list, mood_item_node)
+ if (add_item_score(aft_row, item, &score, &score_arg_sum) > 0)
match = 1;
/* reject if there is no matching entry in the accept list */
- if (!match && !list_empty(¤t_mood->accept_list))
+ if (!match && !list_empty(&m->accept_list))
return -E_NOT_ADMISSIBLE;
- list_for_each_entry(item, ¤t_mood->score_list, mood_item_node)
- add_item_score(row, item, &score, &score_arg_sum);
+ list_for_each_entry(item, &m->score_list, mood_item_node)
+ add_item_score(aft_row, item, &score, &score_arg_sum);
if (score_arg_sum)
score /= score_arg_sum;
*result = score;
ML_SCORE
};
+struct mood_line_parser_data {
+ struct mood *m;
+ unsigned line_num;
+};
+
/*
* <accept [with score <score>] | deny [with score <score>] | score <score>>
* [if] [not] <mood_method> [options]
static int parse_mood_line(char *mood_line, void *data)
{
- struct mood *m = data;
+ struct mood_line_parser_data *mlpd = data;
char **argv;
char *delim = " \t";
unsigned num_words;
struct mood_item *mi = NULL;
char *buf = para_strdup(mood_line);
+ mlpd->line_num++;
num_words = split_args(buf, &argv, delim);
ret = 1;
if (!num_words) /* empty line */
goto out;
mi->method = &mood_methods[i];
success:
- if (mlt == ML_ACCEPT)
- para_list_add(&mi->mood_item_node, &m->accept_list);
- else if (mlt == ML_DENY)
- para_list_add(&mi->mood_item_node, &m->deny_list);
- else
- para_list_add(&mi->mood_item_node, &m->score_list);
+ if (mlpd->m) {
+ if (mlt == ML_ACCEPT)
+ para_list_add(&mi->mood_item_node, &mlpd->m->accept_list);
+ else if (mlt == ML_DENY)
+ para_list_add(&mi->mood_item_node, &mlpd->m->deny_list);
+ else
+ para_list_add(&mi->mood_item_node, &mlpd->m->score_list);
+ }
PARA_DEBUG_LOG("%s entry added, method: %p\n", mlt == ML_ACCEPT? "accept" :
(mlt == ML_DENY? "deny" : "score"), mi->method);
ret = 1;
return ret;
}
-static int load_mood(const struct osl_row *row)
+static int load_mood(const struct osl_row *mood_row, struct mood **m)
{
- int ret;
- struct mood *new_mood, *old_mood = current_mood;
- struct osl_object objs[NUM_BLOB_COLUMNS];
+ char *mood_name;
+ struct osl_object mood_def;
+ struct mood_line_parser_data mlpd = {.line_num = 0};
+ int ret = mood_get_name_and_def_by_row(mood_row, &mood_name, &mood_def);
- ret = osl_get_object(moods_table, row, BLOBCOL_NAME, &objs[BLOBCOL_NAME]);
if (ret < 0)
return ret;
- if (objs[BLOBCOL_NAME].size <= 1)
+ if (!*mood_name)
return -E_DUMMY_ROW;
- ret = osl_open_disk_object(moods_table, row, BLOBCOL_DEF, &objs[BLOBCOL_DEF]);
- if (ret < 0)
- return ret;
- new_mood = alloc_new_mood((char*)objs[BLOBCOL_NAME].data);
- current_mood = new_mood;
- ret = for_each_line_ro(objs[BLOBCOL_DEF].data, objs[BLOBCOL_DEF].size,
- parse_mood_line, ¤t_mood);
- osl_close_disk_object(&objs[BLOBCOL_DEF]);
+ mlpd.m = alloc_new_mood(mood_name);
+ ret = for_each_line_ro(mood_def.data, mood_def.size,
+ parse_mood_line, &mlpd);
+ osl_close_disk_object(&mood_def);
if (ret < 0) {
- PARA_ERROR_LOG("unable to load mood %s: %d\n",
- (char *)objs[BLOBCOL_NAME].data, ret);
- destroy_mood(new_mood);
- current_mood = old_mood;
+ PARA_ERROR_LOG("unable to load mood %s: %s\n", mlpd.m->name,
+ PARA_STRERROR(-ret));
+ destroy_mood(mlpd.m);
return ret;
}
- destroy_mood(old_mood);
- current_mood = new_mood;
- PARA_INFO_LOG("loaded mood %s\n", current_mood->name);
+ PARA_INFO_LOG("loaded mood %s\n", mlpd.m->name);
+ *m = mlpd.m;
return 1;
}
-/* returns -E_MOOD_LOADED on _success_ to terminate the loop */
-static int mood_loop(struct osl_row *row, __a_unused void *private_data)
+/*
+ * Calls load_mood() and reverts its error value: It returns -E_MOOD_LOADED
+ * on _success_, and 1 on errors. This way the loop over all moods stops at the
+ * first valid mood.
+ */
+static int load_mood_loop_func(struct osl_row *mood_row, void *data)
{
- int ret = load_mood(row);
+ struct mood **m = data;
+ int ret = load_mood(mood_row, m);
if (ret < 0) {
if (ret != -E_DUMMY_ROW)
PARA_NOTICE_LOG("invalid mood (%d), trying next mood\n", ret);
return -E_MOOD_LOADED;
}
-static int load_first_available_mood(void)
+static int load_first_available_mood(struct mood **m)
{
- int ret = osl_rbtree_loop(moods_table, BLOBCOL_NAME, NULL,
- mood_loop);
+ int ret = osl_rbtree_loop(moods_table, BLOBCOL_NAME, m,
+ load_mood_loop_func);
if (ret == -E_MOOD_LOADED) /* success */
return 1;
if (ret < 0)
return -E_NO_MOOD;
}
+static int check_mood(struct osl_row *mood_row, void *data)
+{
+ struct para_buffer *pb = data;
+ char *mood_name;
+ struct osl_object mood_def;
+ struct mood_line_parser_data mlpd = {.line_num = 0};
+
+ int ret = mood_get_name_and_def_by_row(mood_row, &mood_name, &mood_def);
+
+ if (ret < 0) {
+ para_printf(pb, "failed to get mood definition\n");
+ return ret;
+ }
+ if (!*mood_name) /* ignore dummy row */
+ goto out;
+ para_printf(pb, "checking mood %s...\n", mood_name);
+ ret = for_each_line_ro(mood_def.data, mood_def.size,
+ parse_mood_line, &mlpd);
+ if (ret < 0)
+ para_printf(pb, "%s line %u: %s\n", mood_name, mlpd.line_num,
+ PARA_STRERROR(-ret));
+out:
+ osl_close_disk_object(&mood_def);
+ return 1;
+}
+
+/**
+ * Check all moods for syntax errors.
+ *
+ * \param query Unused.
+ * \param result: Contains check messages.
+ */
+int mood_check_callback(__a_unused const struct osl_object *query,
+ struct osl_object *result)
+{
+ struct para_buffer pb = {.buf = NULL};
+
+ para_printf(&pb, "checking moods...\n");
+ osl_rbtree_loop(moods_table, BLOBCOL_ID, &pb,
+ check_mood);
+ result->data = pb.buf;
+ result->size = pb.size;
+ return 1;
+}
+
#if 0
static unsigned int_log2(uint64_t x)
{
/** The temporary array of admissible files. */
struct admissible_array {
+ /** Files are admissible wrt. this mood. */
+ struct mood *m;
/** The size of the array */
unsigned size;
/** Pointer to the array of admissible files. */
*
* \return Negative on errors, positive on success.
*/
-static int add_if_admissible(struct osl_row *aft_row, void *private_data)
+static int add_if_admissible(struct osl_row *aft_row, void *data)
{
+ struct admissible_array *aa = data;
int ret;
- struct admissible_array *aa = private_data;
long score = 0;
- score = 0;
- ret = compute_mood_score(aft_row, &score);
+ ret = compute_mood_score(aft_row, aa->m, &score);
if (ret < 0)
return (ret == -E_NOT_ADMISSIBLE)? 1 : ret;
if (statistics.num >= aa->size) {
}
/**
- * Compute the new score of an audio file.
+ * Compute the new score of an audio file wrt. the current mood.
*
* \param aft_row Determines the audio file.
* \param old_afsi The audio file selector info before updating.
if (ret < 0)
return ret;
was_admissible = ret;
- ret = compute_mood_score(aft_row, &score);
+ ret = compute_mood_score(aft_row, current_mood, &score);
is_admissible = (ret > 0);
if (!was_admissible && !is_admissible)
return 1;
}
/**
- * Open the given mood.
+ * Change the current mood.
*
* \param mood_name The name of the mood to open.
*
* the dummy mood that accepts every audio file and uses a scoring method
* based only on the \a last_played information.
*
+ * If there is already an open mood, it will be closed first.
+ *
* \return Positive on success, negative on errors. Loading the dummy mood
* always succeeds.
*
* \sa struct admissible_file_info, struct admissible_array, struct
* afs_info::last_played, mood_close().
*/
-int mood_open(char *mood_name)
+int change_current_mood(char *mood_name)
{
int i, ret;
struct admissible_array aa = {
};
if (!mood_name) {
- ret = load_first_available_mood();
+ struct mood *m;
+ ret = load_first_available_mood(&m);
if (ret < 0)
return ret;
+ destroy_mood(current_mood);
+ current_mood = m;
} else if (*mood_name) {
+ struct mood *m;
struct osl_row *row;
struct osl_object obj = {
.data = mood_name,
PARA_NOTICE_LOG("no such mood: %s\n", mood_name);
return ret;
}
- ret = load_mood(row);
+ ret = load_mood(row, &m);
if (ret < 0)
return ret;
+ destroy_mood(current_mood);
+ current_mood = m;
} else {
destroy_mood(current_mood);
current_mood = alloc_new_mood("dummy");
}
+ aa.m = current_mood;
PARA_NOTICE_LOG("loaded mood %s\n", current_mood->name);
PARA_INFO_LOG("%s\n", "computing statistics of admissible files");
ret = audio_file_loop(&aa, add_if_admissible);
* Free all resources of the current mood which were allocated during
* mood_open().
*/
-void mood_close(void)
+void close_current_mood(void)
{
destroy_mood(current_mood);
current_mood = NULL;
*
* \sa mood_open(), mood_close().
*/
-int mood_reload(void)
+int reload_current_mood(void)
{
int ret;
char *mood_name;
return 1;
score_shutdown(0);
mood_name = para_strdup(current_mood->name);
- mood_close();
- ret = mood_open(mood_name);
+ close_current_mood();
+ ret = change_current_mood(mood_name);
free(mood_name);
return ret;
}