Takes no arguments and matches an audio file if and only if no
attributes are set.
- played_rarely
-
-Takes no arguments and matches all audio files where the number of
-times this audio file was selected is below the average.
-
- is_set attribute_name
+ is_set <attribute_name>
Takes the name of an attribute and matches iff that attribute is set.
- path_matches pattern
+ path_matches <pattern>
Takes a filename pattern and matches iff the path of the audio file
matches the pattern.
+ artist_matches <pattern>
+ album_matches <pattern>
+ title_matches <pattern>
+ comment_matches <pattern>
+
+Takes an extended regular expression and matches iff the text of the
+corresponding tag of the audio file matches the pattern. If the tag
+is not set, the empty string is matched against the pattern.
+
+ year ~ <num>
+ bitrate ~ <num>
+ frequency ~ <num>
+ channels ~ <num>
+
+Takes a comparator ~ of the set {<, =, <=, >, >=, !=} and a number
+<num>. Matches an audio file iff the condition <val> ~ <num> is
+satisfied where val is the corresponding value of the audio file
+(bitrate in kbit/s, frequency in Hz, channel count, value of the
+year tag).
+
+The year tag is special as its value is undefined if the audio file
+has no year tag or the content of the year tag is not a number. Such
+audio files never match. Another difference is the special treatment
+if the year tag is a two-digit number. In this case either 1900 or
+2000 are added to the tag value, depending on whether the number is
+greater than 2000 plus the current year.
+
----------
Mood usage
#include "sched.h"
#include "signal.h"
#include "fd.h"
+#include "mood.h"
/** The osl tables used by afs. \sa blob.c. */
enum afs_table_num {
};
static struct afs_table afs_tables[NUM_AFS_TABLES] = {
- [TBLNUM_AUDIO_FILES] = {.init = aft_init},
- [TBLNUM_ATTRIBUTES] = {.init = attribute_init},
- [TBLNUM_SCORES] = {.init = score_init},
- [TBLNUM_MOODS] = {.init = moods_init},
- [TBLNUM_LYRICS] = {.init = lyrics_init},
- [TBLNUM_IMAGES] = {.init = images_init},
- [TBLNUM_PLAYLIST] = {.init = playlists_init},
+ [TBLNUM_AUDIO_FILES] = {.init = aft_init, .name = "audio_files"},
+ [TBLNUM_ATTRIBUTES] = {.init = attribute_init, .name = "attributes"},
+ [TBLNUM_SCORES] = {.init = score_init, .name = "scores"},
+ [TBLNUM_MOODS] = {.init = moods_init, .name = "moods"},
+ [TBLNUM_LYRICS] = {.init = lyrics_init, .name = "lyrics"},
+ [TBLNUM_IMAGES] = {.init = images_init, .name = "images"},
+ [TBLNUM_PLAYLIST] = {.init = playlists_init, .name = "playlists"},
};
struct command_task {
{
uint32_t table_mask = *(uint32_t *)query->data;
int i, ret;
- char *buf;
+ struct para_buffer pb = {.buf = NULL};
close_afs_tables();
for (i = 0; i < NUM_AFS_TABLES; i++) {
ret = t->create(database_dir);
if (ret < 0)
goto out;
+ para_printf(&pb, "successfully created %s table\n", t->name);
}
ret = open_afs_tables();
out:
- if (ret >= 0)
- buf = make_message("successfully created afs table(s)\n");
- else
- buf = make_message("%s\n", para_strerror(-ret));
- pass_buffer_as_shm(buf, strlen(buf), &fd);
- free(buf);
+ if (ret < 0)
+ para_printf(&pb, "%s\n", para_strerror(-ret));
+ if (pb.buf)
+ pass_buffer_as_shm(pb.buf, pb.offset, &fd);
+ free(pb.buf);
}
int com_init(struct rc4_context *rc4c, int argc, char * const * const argv)
int audio_file_loop(void *private_data, osl_rbtree_loop_func *func);
void aft_check_callback(int fd, __a_unused const struct osl_object *query);
-/* mood */
-int change_current_mood(char *mood_name);
-void close_current_mood(void);
-int reload_current_mood(void);
-void mood_check_callback(int fd, __a_unused const struct osl_object *query);
-
-
/* playlist */
int playlist_open(char *name);
void playlist_close(void);
void aft_init(struct afs_table *t)
{
- t->name = audio_file_table_desc.name;
t->open = aft_open;
t->close = aft_close;
t->create = aft_create;
*/
void attribute_init(struct afs_table *t)
{
- t->name = attribute_table_desc.name;
t->open = attribute_open;
t->close = attribute_close;
t->create = attribute_create;
#define DEFINE_BLOB_INIT(table_name) \
void table_name ## _init(struct afs_table *t) \
{ \
- t->name = table_name ## _table_desc.name; \
t->open = table_name ## _open; \
t->close = table_name ## _close; \
t->create = table_name ## _create;\
playlist sha1 sched audiod grab_client filter_common wav_filter compress_filter
http_recv dccp_recv recv_common write_common file_write audiod_command
client_common recv stdout filter stdin audioc write client exec send_common ggo
-udp_recv udp_send color fec fecdec_filter prebuffer_filter"
+udp_recv udp_send color fec fecdec_filter prebuffer_filter mm"
all_executables="server recv filter audioc write client afh"
server_cmdline_objs="server.cmdline server_command_list afs_command_list"
server_errlist_objs="server afh_common mp3_afh vss command net string signal
- time daemon crypt http_send close_on_fork
+ time daemon crypt http_send close_on_fork mm
ipc dccp_send fd user_list chunk_queue afs aft mood score attribute
blob playlist sha1 sched acl send_common udp_send color fec"
server_ldflags="-losl"
void get_random_bytes_or_die(unsigned char *buf, int num);
void init_random_seed_or_die(void);
+/**
+ * Used on the server-side for client-server communication encryption.
+ *
+ * The traffic between (the forked child of) para_server and the remote
+ * client process is crypted by a RC4 session key. This structure contains
+ * the RC4 keys and the file descriptor for which these keys should be used.
+ */
struct rc4_context {
+ /** The socket file descriptor. */
int fd;
+ /** Key used for sending data. */
RC4_KEY recv_key;
+ /** Key used for receiving data. */
RC4_KEY send_key;
};
int rc4_send_bin_buffer(struct rc4_context *rc4c, const char *buf, size_t len);
#define MOOD_ERRORS \
- PARA_ERROR(MOOD_SYNTAX, "mood syntax error"), \
PARA_ERROR(NO_MOOD, "no mood available"), \
- PARA_ERROR(NOT_ADMISSIBLE, "file is not admissible"), \
PARA_ERROR(DUMMY_ROW, "attempted to access blob dummy object"), \
+#define MM_ERRORS \
+ PARA_ERROR(MOOD_SYNTAX, "mood syntax error"), \
+
+
#define ATTRIBUTE_ERRORS \
PARA_ERROR(ATTR_SYNTAX, "attribute syntax error"), \
PARA_ERROR(NO_ATTRIBUTES, "no attributes defined yet"), \
static int update_item(int item_num, char *buf)
{
- free(stat_content[item_num]);
- stat_content[item_num] = para_strdup(buf);
+ char **c = stat_content + item_num;
+
+ free(*c);
+ if (buf && buf[0])
+ goto dup;
+ switch (item_num) {
+ case SI_ARTIST:
+ *c = para_strdup("(artist tag not set)");
+ goto print;
+ case SI_TITLE:
+ *c = para_strdup("(title tag not set)");
+ goto print;
+ case SI_YEAR:
+ *c = para_strdup("????");
+ goto print;
+ case SI_ALBUM:
+ *c = para_strdup("(album tag not set)");
+ goto print;
+ case SI_COMMENT:
+ *c = para_strdup("(comment tag not set)");
+ goto print;
+ }
+dup:
+ *c = para_strdup(buf);
+print:
print_stat_item(item_num);
return 1;
}
--- /dev/null
+/*
+ * Copyright (C) 2007-2009 Andre Noll <maan@systemlinux.org>
+ *
+ * Licensed under the GPL v2. For licencing details see COPYING.
+ */
+
+/** \file mm.c Paraslash's mood methods. */
+
+#include <time.h>
+#include <regex.h>
+#include <fnmatch.h>
+#include <osl.h>
+
+#include "para.h"
+#include "error.h"
+#include "string.h"
+#include "afh.h"
+#include "afs.h"
+#include "mm.h"
+
+#define MOOD_COMPARATORS \
+ MC(LESS, <) \
+ MC(LESS_OR_EQUAL, <=) \
+ MC(EQUAL, =) \
+ MC(EQUAL2, ==) \
+ MC(NOT_EQUAL, !=) \
+ MC(NOT_EQUAL2, <>) \
+ MC(GREATER, >) \
+ MC(GREATER_OR_EQUAL, >=) \
+
+#define MC(a, b) MC_ ## a,
+enum mood_comparator_id {MOOD_COMPARATORS NUM_MOOD_COMPARATORS};
+#undef MC
+#define MC(a, b) # b,
+const char const *mood_comparators[] = {MOOD_COMPARATORS};
+#undef MC
+
+static int parse_mood_comparator(const char *word)
+{
+ int i;
+
+ for (i = 0; i < NUM_MOOD_COMPARATORS; i++)
+ if (!strcmp(word, mood_comparators[i]))
+ return i;
+ return -E_MOOD_SYNTAX;
+}
+
+struct mm_compare_num_data {
+ /** <, <=, =, !=, >=, or >. */
+ enum mood_comparator_id id;
+ /** The value given at the mood line. */
+ int32_t arg;
+};
+
+static int mm_compare_num_score_function(int32_t val,
+ const struct mm_compare_num_data *cnd)
+{
+ int res;
+ int32_t arg = cnd->arg;
+
+ switch (cnd->id) {
+ case MC_LESS:
+ res = val < arg; break;
+ case MC_LESS_OR_EQUAL:
+ res = val <= arg; break;
+ case MC_EQUAL:
+ case MC_EQUAL2:
+ res = val == arg; break;
+ case MC_NOT_EQUAL:
+ case MC_NOT_EQUAL2:
+ res = val != arg; break;
+ case MC_GREATER:
+ res = val > arg; break;
+ case MC_GREATER_OR_EQUAL:
+ res = val >= arg; break;
+ default:
+ PARA_EMERG_LOG("BUG: invalid mood comparator\n");
+ exit(EXIT_FAILURE);
+ }
+ return res? 100 : -100;
+}
+
+static int mm_compare_num_parser(int argc, char **argv, void **private)
+{
+ int ret;
+ enum mood_comparator_id id;
+ int32_t arg;
+ struct mm_compare_num_data *cnd;
+ if (argc != 2)
+ return -E_MOOD_SYNTAX;
+ ret = parse_mood_comparator(argv[1]);
+ if (ret < 0)
+ return ret;
+ id = ret;
+ ret = para_atoi32(argv[2], &arg);
+ if (ret < 0)
+ return ret;
+ cnd = para_malloc(sizeof(struct mm_compare_num_data));
+ cnd->id = id;
+ cnd->arg = arg;
+ *private = cnd;
+ return 1;
+}
+
+static int mm_regex_parser(int argc, char **argv, void **private)
+{
+ regex_t *preg;
+ int ret;
+
+ if (argc != 1)
+ return -E_MOOD_SYNTAX;
+ preg = para_malloc(sizeof(*preg));
+ ret = para_regcomp(preg, argv[1], REG_EXTENDED | REG_NOSUB);
+ if (ret < 0) {
+ free(preg);
+ return ret;
+ }
+ *private = preg;
+ return 1;
+}
+
+static int mm_regex_score_function(const regex_t *preg, const char *pattern)
+{
+ return regexec(preg, pattern, 0, NULL, 0) == 0? 100 : -100;
+}
+
+static void mm_regex_cleanup(void *private)
+{
+ regex_t *preg = private;
+ regfree(preg);
+ free(preg);
+}
+
+static int mm_artist_matches_score_function(__a_unused const char *path,
+ __a_unused const struct afs_info *afsi,
+ const struct afh_info *afhi,
+ const void *private)
+{
+ return mm_regex_score_function(private, afhi->tags.artist);
+}
+
+static int mm_title_matches_score_function(__a_unused const char *path,
+ __a_unused const struct afs_info *afsi,
+ const struct afh_info *afhi,
+ const void *private)
+{
+ return mm_regex_score_function(private, afhi->tags.title);
+}
+
+static int mm_album_matches_score_function(__a_unused const char *path,
+ __a_unused const struct afs_info *afsi,
+ const struct afh_info *afhi,
+ const void *private)
+{
+ return mm_regex_score_function(private, afhi->tags.album);
+}
+
+static int mm_comment_matches_score_function(__a_unused const char *path,
+ __a_unused const struct afs_info *afsi,
+ const struct afh_info *afhi,
+ const void *private)
+{
+ return mm_regex_score_function(private, afhi->tags.comment);
+}
+
+static int mm_bitrate_score_function(__a_unused const char *path,
+ __a_unused const struct afs_info *afsi,
+ const struct afh_info *afhi,
+ const void *private)
+{
+ return mm_compare_num_score_function(afhi->bitrate, private);
+}
+
+static int mm_frequency_score_function(__a_unused const char *path,
+ __a_unused const struct afs_info *afsi,
+ const struct afh_info *afhi,
+ const void *private)
+{
+ return mm_compare_num_score_function(afhi->frequency, private);
+}
+
+static int mm_channels_score_function(__a_unused const char *path,
+ __a_unused const struct afs_info *afsi,
+ const struct afh_info *afhi,
+ const void *private)
+{
+ return mm_compare_num_score_function(afhi->channels, private);
+}
+
+struct mm_year_data {
+ /** Comparator and year given at the mood line. */
+ struct mm_compare_num_data *cnd;
+ /** Used to detect Y2K issues. */
+ int32_t current_year;
+};
+
+static int mm_year_parser(int argc, char **argv, void **private)
+{
+ int ret = -E_MOOD_SYNTAX;
+ struct mm_year_data *mmyd = para_malloc(sizeof(*mmyd));
+ time_t current_time;
+ struct tm *gmt;
+
+ ret = mm_compare_num_parser(argc, argv, (void **)&mmyd->cnd);
+ if (ret < 0)
+ goto err;
+ current_time = time(NULL);
+ gmt = gmtime(¤t_time);
+ /* tm_year is the number of years since 1900 */
+ mmyd->current_year = gmt->tm_year + 1900;
+ *private = mmyd;
+ return 1;
+err:
+ free(mmyd);
+ return ret;
+}
+
+static int mm_year_score_function(__a_unused const char *path,
+ __a_unused const struct afs_info *afsi,
+ const struct afh_info *afhi,
+ const void *private)
+{
+ const struct mm_year_data *mmyd = private;
+ int32_t tag_year;
+ int ret = para_atoi32(afhi->tags.year, &tag_year);
+
+ if (ret < 0) /* year tag not present or not a number */
+ return -100;
+ if (tag_year < 0)
+ return -100;
+ /* try to work around Y2K issues */
+ if (tag_year < 100) {
+ tag_year += 1900;
+ if (tag_year + 100 <= mmyd->current_year)
+ tag_year += 100; /* assume tag_year >= 2000 */
+ }
+ return mm_compare_num_score_function(tag_year, mmyd->cnd);
+}
+
+static void mm_year_cleanup(void *private)
+{
+ struct mm_year_data *mmyd = private;
+
+ free(mmyd->cnd);
+ free(mmyd);
+}
+
+static int mm_no_attributes_set_parser(int argc, __a_unused char **argv,
+ __a_unused void **ignored)
+{
+ return argc? -E_MOOD_SYNTAX : 1;
+}
+
+static int mm_no_attributes_set_score_function(__a_unused const char *path,
+ const struct afs_info *afsi,
+ __a_unused const struct afh_info *afhi,
+ __a_unused const void *data)
+{
+ if (!afsi->attributes)
+ return 100;
+ return -100;
+}
+
+static int mm_path_matches_score_function(const char *path,
+ __a_unused const struct afs_info *afsi,
+ __a_unused const struct afh_info *afhi,
+ const void *data)
+{
+ if (fnmatch(data, path, 0))
+ return -100;
+ return 100;
+}
+
+static int mm_path_matches_parser(int argc, char **argv, void **data)
+{
+ if (argc != 1)
+ return -E_MOOD_SYNTAX;
+ *data = para_strdup(argv[1]);
+ return 1;
+}
+
+static void mm_path_matches_cleanup(void *data)
+{
+ free(data);
+}
+
+static int mm_is_set_parser(int argc, char **argv, void **bitnum)
+{
+ int ret;
+ unsigned char c, *res;
+
+ if (argc != 1)
+ return -E_MOOD_SYNTAX;
+ ret = get_attribute_bitnum_by_name(argv[1], &c);
+ if (ret < 0)
+ return ret;
+ res = para_malloc(1);
+ *res = c;
+ *bitnum = res;
+ return 1;
+}
+
+static int mm_is_set_score_function(__a_unused const char *path,
+ __a_unused const struct afs_info *afsi,
+ __a_unused const struct afh_info *afhi,
+ const void *data)
+{
+ const unsigned char *bn = data;
+ if (afsi->attributes & (1ULL << *bn))
+ return 100;
+ return -100;
+}
+
+#define DEFINE_MOOD_METHOD(_name) \
+.parser = mm_ ## _name ## _parser, \
+.score_function = mm_ ## _name ## _score_function, \
+.name = #_name
+
+#define DEFINE_MOOD_METHOD_WITH_CLEANUP(_name) \
+ DEFINE_MOOD_METHOD(_name), \
+ .cleanup = mm_ ## _name ## _cleanup
+
+#define DEFINE_REGEX_MOOD_METHOD(_name) \
+ .name = #_name, \
+ .parser = mm_regex_parser, \
+ .score_function = mm_ ## _name ## _score_function, \
+ .cleanup = mm_regex_cleanup
+
+#define DEFINE_COMPARE_NUM_MOOD_METHOD(_name) \
+ .name = #_name, \
+ .parser = mm_compare_num_parser, \
+ .score_function = mm_ ## _name ## _score_function
+
+const struct mood_method mood_methods[] = {
+ {DEFINE_MOOD_METHOD(no_attributes_set)},
+ {DEFINE_MOOD_METHOD(is_set)},
+ {DEFINE_MOOD_METHOD_WITH_CLEANUP(path_matches)},
+ {DEFINE_MOOD_METHOD_WITH_CLEANUP(year)},
+ {DEFINE_REGEX_MOOD_METHOD(artist_matches)},
+ {DEFINE_REGEX_MOOD_METHOD(title_matches)},
+ {DEFINE_REGEX_MOOD_METHOD(album_matches)},
+ {DEFINE_REGEX_MOOD_METHOD(comment_matches)},
+ {DEFINE_COMPARE_NUM_MOOD_METHOD(bitrate)},
+ {DEFINE_COMPARE_NUM_MOOD_METHOD(frequency)},
+ {DEFINE_COMPARE_NUM_MOOD_METHOD(channels)},
+ {.parser = NULL}
+};
--- /dev/null
+/*
+ * Copyright (C) 2007-2009 Andre Noll <maan@systemlinux.org>
+ *
+ * Licensed under the GPL v2. For licencing details see COPYING.
+ */
+
+/** \file mm.h Symbols and declarations for mood methods. */
+
+/**
+ * Assign scores according to a mood_method.
+ *
+ * Each mood_method has its own mood_score_function. The first three parameters
+ * passed to that function are informations about the audio file whose score is
+ * to be computed. The data argument depends on the mood method this function
+ * is used for. It usually is the argument given at the end of a mood line.
+ *
+ * Mood score functions must return values between -100 and +100 inclusively.
+ * Boolean score functions should always return either -100 or +100.
+ *
+ * \sa struct mood_method, mood_parser.
+ */
+typedef int mood_score_function(const char *path, const struct afs_info *afsi,
+ const struct afh_info *afhi, const void *data);
+
+/**
+ * Pre-process a mood line.
+ *
+ * The mood_parser of a mood_method is called once at mood open time for each
+ * line of the current mood definition that contains the mood_method's name as
+ * a keyword. The line is passed to the mood_parser as the first argument. The
+ * mood_parser must determine whether the line is syntactically correct and
+ * return a positive value if so and a negative value otherwise.
+ *
+ * Some mood parsers pre-process the data given in the mood line to compute a
+ * structure which depends of the particular mood_method and which is used
+ * later in the mood_score_function of the mood_method. The mood_parser may
+ * store a pointer to its structure via the void** pointer.
+ *
+ * \sa mood_open(), mood_cleanup_function, mood_score_function.
+ */
+typedef int mood_parser(int, char **, void **);
+
+/**
+ * Deallocate resources which were allocated by the mood_parser.
+ *
+ * This optional function of a mood_method is used to free any resources
+ * allocated in mood_open() by the mood_parser. The argument passed is a
+ * pointer to the mood_method specific data structure that was returned by the
+ * mood_parser.
+ *
+ * \sa mood_parser.
+ */
+typedef void mood_cleanup_function(void *);
+
+/**
+ * Used for scoring and to determine whether a file is admissible.
+ */
+struct mood_method {
+ /** The name of the method. */
+ const char *name;
+ /** Pointer to the mood parser. */
+ mood_parser *parser;
+ /** Pointer to the score function */
+ mood_score_function *score_function;
+ /** Optional cleanup function. */
+ mood_cleanup_function *cleanup;
+};
+
+/** The array of available mood methods. */
+extern const struct mood_method mood_methods[];
/** \file mood.c Paraslash's mood handling functions. */
-#include <time.h>
#include <regex.h>
-#include <fnmatch.h>
#include <osl.h>
#include "para.h"
#include "afs.h"
#include "list.h"
#include "ipc.h"
+#include "mm.h"
/**
* Contains statistical data of the currently admissible audio files.
};
struct afs_statistics statistics;
-/**
- * Assign scores according to a mood_method.
- *
- * Each mood_method has its own mood_score_function. The first three parameters
- * passed to that function are informations about the audio file whose score is
- * to be computed. The data argument depends on the mood method this function
- * is used for. It usually is the argument given at the end of a mood line.
- *
- * Mood score functions must return values between -100 and +100 inclusively.
- * Boolean score functions should always return either -100 or +100.
- *
- * \sa struct mood_method, mood_parser.
- */
-typedef int mood_score_function(const char *path, const struct afs_info *afsi,
- const struct afh_info *afhi, const void *data);
-
-/**
- * Pre-process a mood line.
- *
- * The mood_parser of a mood_method is called once at mood open time for each
- * line of the current mood definition that contains the mood_method's name as
- * a keyword. The line is passed to the mood_parser as the first argument. The
- * mood_parser must determine whether the line is syntactically correct and
- * return a positive value if so and a negative value otherwise.
- *
- * Some mood parsers pre-process the data given in the mood line to compute a
- * structure which depends of the particular mood_method and which is used
- * later in the mood_score_function of the mood_method. The mood_parser may
- * store a pointer to its structure via the void** pointer.
- *
- * \sa mood_open(), mood_cleanup_function, mood_score_function.
- */
-typedef int mood_parser(int, char **, void **);
-
-/**
- * Deallocate resources which were allocated by the mood_parser.
- *
- * This optional function of a mood_method is used to free any resources
- * allocated in mood_open() by the mood_parser. The argument passed is a
- * pointer to the mood_method specific data structure that was returned by the
- * mood_parser.
- *
- * \sa mood_parser.
- */
-typedef void mood_cleanup_function(void *);
-
-/**
- * Used for scoring and to determine whether a file is admissible.
- */
-struct mood_method {
- /** The name of the method. */
- const char *name;
- /** Pointer to the mood parser. */
- mood_parser *parser;
- /** Pointer to the score function */
- mood_score_function *score_function;
- /** Optional cleanup function. */
- mood_cleanup_function *cleanup;
-};
-
/**
* Each line of the current mood corresponds to a mood_item.
*/
return res;
}
-#define MOOD_COMPARATORS \
- MC(LESS, <) \
- MC(LESS_OR_EQUAL, <=) \
- MC(EQUAL, =) \
- MC(EQUAL2, ==) \
- MC(NOT_EQUAL, !=) \
- MC(NOT_EQUAL2, <>) \
- MC(GREATER, >) \
- MC(GREATER_OR_EQUAL, >=) \
-
-#define MC(a, b) MC_ ## a,
-enum mood_comparator_id {MOOD_COMPARATORS NUM_MOOD_COMPARATORS};
-#undef MC
-#define MC(a, b) # b,
-const char const *mood_comparators[] = {MOOD_COMPARATORS};
-#undef MC
-
-static int parse_mood_comparator(const char *word)
-{
- int i;
-
- for (i = 0; i < NUM_MOOD_COMPARATORS; i++)
- if (!strcmp(word, mood_comparators[i]))
- return i;
- return -E_MOOD_SYNTAX;
-}
-
-static int compare_int32(int32_t a, int32_t b, enum mood_comparator_id id)
-{
- int res;
-
- switch (id) {
- case MC_LESS:
- res = a < b; break;
- case MC_LESS_OR_EQUAL:
- res = a <= b; break;
- case MC_EQUAL:
- case MC_EQUAL2:
- res = a == b; break;
- case MC_NOT_EQUAL:
- case MC_NOT_EQUAL2:
- res = a != b; break;
- case MC_GREATER:
- res = a > b; break;
- case MC_GREATER_OR_EQUAL:
- res = a >= b; break;
- default:
- PARA_EMERG_LOG("BUG: invalid mood comparator\n");
- exit(EXIT_FAILURE);
- }
- return res? 100 : -100;
-}
-
-struct mm_year_data {
- /** The year given at the mood line. */
- int32_t year;
- /** Used to detect Y2K issues. */
- int32_t current_year;
- /** <, <=, =, !=, >=, or >. */
- enum mood_comparator_id id;
-};
-
-static int mm_year_parser(int argc, char **argv, void **private)
-{
- int ret = -E_MOOD_SYNTAX;
- struct mm_year_data *mmyd = para_malloc(sizeof(*mmyd));
- time_t current_time;
- struct tm *gmt;
-
- if (argc != 2)
- goto err;
- ret = parse_mood_comparator(argv[1]);
- mmyd->id = ret;
- if (ret < 0)
- goto err;
- ret = para_atoi32(argv[2], &mmyd->year);
- if (ret < 0)
- goto err;
- current_time = time(NULL);
- gmt = gmtime(¤t_time);
- /* tm_year is the number of years since 1900 */
- mmyd->current_year = gmt->tm_year + 1900;
- *private = mmyd;
- return 1;
-err:
- free(mmyd);
- return ret;
-}
-
-static int mm_year_score_function(__a_unused const char *path,
- __a_unused const struct afs_info *afsi,
- const struct afh_info *afhi,
- const void *private)
-{
- const struct mm_year_data *mmyd = private;
- int32_t tag_year;
- int ret = para_atoi32(afhi->tags.year, &tag_year);
-
- if (ret < 0) /* year tag not present or not a number */
- return -100;
- if (tag_year < 0)
- return -100;
- /* try to work around Y2K issues */
- if (tag_year < 100) {
- tag_year += 1900;
- if (tag_year + 100 <= mmyd->current_year)
- tag_year += 100; /* assume tag_year >= 2000 */
- }
- return compare_int32(tag_year, mmyd->year, mmyd->id);
-}
-
-static void mm_year_cleanup(void *private)
-{
- free(private);
-}
-
-static int mm_no_attributes_set_parser(int argc, __a_unused char **argv,
- __a_unused void **ignored)
-{
- return argc? -E_MOOD_SYNTAX : 1;
-}
-
-static int mm_no_attributes_set_score_function(__a_unused const char *path,
- const struct afs_info *afsi,
- __a_unused const struct afh_info *afhi,
- __a_unused const void *data)
-{
- if (!afsi->attributes)
- return 100;
- return -100;
-}
-
-static int mm_played_rarely_score_function(__a_unused const char *path,
- const struct afs_info *afsi,
- __a_unused const struct afh_info *afhi,
- __a_unused const void *data)
-{
- unsigned num;
- int ret = get_num_admissible_files(&num);
-
- if (ret < 0)
- return 0;
- if (statistics.num_played_sum - num * afsi->num_played
- > int_sqrt(statistics.num_played_qd * num))
- return 100;
- return -100;
-}
-
-static int mm_played_rarely_parser(int argc, __a_unused char **argv,
- __a_unused void **ignored)
-{
- return argc? -E_MOOD_SYNTAX : 1;
-}
-
-static int mm_path_matches_score_function(const char *path,
- __a_unused const struct afs_info *afsi,
- __a_unused const struct afh_info *afhi,
- const void *data)
-{
- if (fnmatch(data, path, 0))
- return -100;
- return 100;
-}
-
-static int mm_path_matches_parser(int argc, char **argv, void **data)
-{
- if (argc != 1)
- return -E_MOOD_SYNTAX;
- *data = para_strdup(argv[1]);
- return 1;
-}
-
-static void mm_path_matches_cleanup(void *data)
-{
- free(data);
-}
-
-static int mm_is_set_parser(int argc, char **argv, void **bitnum)
-{
- int ret;
- unsigned char c, *res;
-
- if (argc != 1)
- return -E_MOOD_SYNTAX;
- ret = get_attribute_bitnum_by_name(argv[1], &c);
- if (ret < 0)
- return ret;
- res = para_malloc(1);
- *res = c;
- *bitnum = res;
- return 1;
-}
-
-static int mm_is_set_score_function(__a_unused const char *path,
- __a_unused const struct afs_info *afsi,
- __a_unused const struct afh_info *afhi,
- const void *data)
-{
- const unsigned char *bn = data;
- if (afsi->attributes & (1ULL << *bn))
- return 100;
- return -100;
-}
-
-/* returns 1 if row matches score item, negative otherwise */
-static int add_item_score(const struct osl_row *row, struct mood_item *item, long *score,
+/* returns 1 if row matches score item, 0 if not. */
+static int get_item_score(struct mood_item *item, const struct afs_info *afsi,
+ const struct afh_info *afhi, const char *path, long *score,
long *score_arg_sum)
{
- struct afs_info afsi;
- struct afh_info afhi;
- char *path;
- int ret;
+ int ret, match = 1;
*score_arg_sum += item->random_score? 100 : PARA_ABS(item->score_arg);
ret = 100;
if (item->method) {
- ret = get_afsi_of_row(row, &afsi);
- if (ret< 0)
- return ret;
- ret = get_afhi_of_row(row, &afhi);
- if (ret< 0)
- return ret;
- ret = get_audio_file_path_of_row(row, &path);
- if (ret< 0)
- return ret;
- ret = item->method->score_function(path, &afsi, &afhi,
+ ret = item->method->score_function(path, afsi, afhi,
item->parser_data);
if ((ret < 0 && !item->logical_not) || (ret >= 0 && item->logical_not))
- return -1; /* no match */
+ match = 0; /* no match */
}
if (item->random_score)
- *score += PARA_ABS(ret) * para_random(100);
+ *score = PARA_ABS(ret) * para_random(100);
else
- *score += PARA_ABS(ret) * item->score_arg;
- return 1;
+ *score = PARA_ABS(ret) * item->score_arg;
+ return match;
}
+/* returns 1 if row admissible, 0 if not, negative on errors */
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;
+ int ret, match = 0;
+ long score_arg_sum = 0, score = 0, item_score;
+ struct afs_info afsi;
+ struct afh_info afhi;
+ char *path;
if (!m)
return -E_NO_MOOD;
+ ret = get_afsi_of_row(aft_row, &afsi);
+ if (ret< 0)
+ return ret;
+ ret = get_afhi_of_row(aft_row, &afhi);
+ if (ret< 0)
+ return ret;
+ ret = get_audio_file_path_of_row(aft_row, &path);
+ if (ret< 0)
+ return ret;
/* reject audio file if it matches any entry in the deny list */
- 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, &m->accept_list, mood_item_node)
- if (add_item_score(aft_row, item, &score, &score_arg_sum) > 0)
- match = 1;
+ list_for_each_entry(item, &m->deny_list, mood_item_node) {
+ ret = get_item_score(item, &afsi, &afhi, path, &item_score,
+ &score_arg_sum);
+ if (ret > 0) /* not admissible */
+ return 0;
+ score += item_score;
+ }
+ list_for_each_entry(item, &m->accept_list, mood_item_node) {
+ ret = get_item_score(item, &afsi, &afhi, path, &item_score,
+ &score_arg_sum);
+ if (ret == 0)
+ continue;
+ match = 1;
+ score += item_score;
+ }
/* reject if there is no matching entry in the accept list */
if (!match && !list_empty(&m->accept_list))
- return -E_NOT_ADMISSIBLE;
- list_for_each_entry(item, &m->score_list, mood_item_node)
- add_item_score(aft_row, item, &score, &score_arg_sum);
+ return 0;
+ list_for_each_entry(item, &m->score_list, mood_item_node) {
+ ret = get_item_score(item, &afsi, &afhi, path, &item_score,
+ &score_arg_sum);
+ score += item_score;
+ }
if (score_arg_sum)
score /= score_arg_sum;
*result = score;
return 1;
}
-#define DEFINE_MOOD_METHOD(_name) \
-.parser = mm_ ## _name ## _parser, \
-.score_function = mm_ ## _name ## _score_function, \
-.name = #_name
-
-#define DEFINE_MOOD_METHOD_WITH_CLEANUP(_name) \
- DEFINE_MOOD_METHOD(_name), \
- .cleanup = mm_ ## _name ## _cleanup
-
-static const struct mood_method mood_methods[] = {
- {DEFINE_MOOD_METHOD(no_attributes_set)},
- {DEFINE_MOOD_METHOD(played_rarely)},
- {DEFINE_MOOD_METHOD(is_set)},
- {DEFINE_MOOD_METHOD_WITH_CLEANUP(path_matches)},
- {DEFINE_MOOD_METHOD_WITH_CLEANUP(year)},
- {.parser = NULL}
-};
-
static void cleanup_list_entry(struct mood_item *item)
{
if (item->method && item->method->cleanup)
* \param aft_row The audio file to be added.
* \param private_data Pointer to a struct admissible_file_info.
*
- * \return Negative on errors, positive on success.
+ * \return 1 if row admissible, 0 if not, negative on errors.
*/
static int add_if_admissible(struct osl_row *aft_row, void *data)
{
long score = 0;
ret = compute_mood_score(aft_row, aa->m, &score);
- if (ret < 0)
- return (ret == -E_NOT_ADMISSIBLE)? 1 : ret;
+ if (ret <= 0)
+ return ret;
if (statistics.num >= aa->size) {
aa->size *= 2;
aa->size += 100;
return ret;
was_admissible = ret;
ret = compute_mood_score(aft_row, current_mood, &score);
+ if (ret < 0)
+ return ret;
is_admissible = (ret > 0);
if (!was_admissible && !is_admissible)
return 1;
memset(&statistics, 0, sizeof(statistics));
}
-
/**
* Change the current mood.
*
--- /dev/null
+/*
+ * Copyright (C) 2007-2009 Andre Noll <maan@systemlinux.org>
+ *
+ * Licensed under the GPL v2. For licencing details see COPYING.
+ */
+
+/** \file mood.h Functions exported by mood.h. */
+
+int change_current_mood(char *mood_name);
+void close_current_mood(void);
+int reload_current_mood(void);
+void mood_check_callback(int fd, __a_unused const struct osl_object *query);
projects / paraslash.git / commitdiff