apps/tagcache.h

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 by Miika Pekkarinen
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #ifdef HAVE_TAGCACHE
  22 #ifndef _TAGCACHE_H
  23 #define _TAGCACHE_H
  24
  25 #include "system.h"
  26 #include "metadata.h"
  27
  28 /**
  29  Note: When adding new tags, make sure to update index_entry_ec and tags_str in
  30  tagcache.c and bump up the header version too.
  31  */
  32 enum tag_type { tag_artist = 0, tag_album, tag_genre, tag_title,
  33     tag_filename, tag_composer, tag_comment, tag_albumartist, tag_grouping, tag_year,
  34     tag_discnumber, tag_tracknumber, tag_bitrate, tag_length, tag_playcount, tag_rating,
  35     tag_playtime, tag_lastplayed, tag_commitid, tag_mtime, tag_lastoffset,
  36     /* Real tags end here, count them. */
  37     TAG_COUNT,
  38     /* Virtual tags */
  39     tag_virt_basename, tag_virt_length_min, tag_virt_length_sec,
  40     tag_virt_playtime_min, tag_virt_playtime_sec,
  41     tag_virt_entryage, tag_virt_autoscore };
  42
  43 /* Maximum length of a single tag. */
  44 #define TAG_MAXLEN (MAX_PATH*2)
  45
  46 /* Allow a little drift to the filename ordering (should not be too high/low). */
  47 #define POS_HISTORY_COUNT 4
  48
  49 /* How much to pre-load entries while committing to prevent seeking. */
  50 #define IDX_BUF_DEPTH 64
  51
  52 /* Tag Cache Header version 'TCHxx'. Increment when changing internal structures. */
  53 #define TAGCACHE_MAGIC  0x5443480e
  54
  55 /* Dump store/restore header version 'TCSxx'. */
  56 #define TAGCACHE_STATEFILE_MAGIC 0x54435301
  57
  58 /* How much to allocate extra space for ramcache. */
  59 #define TAGCACHE_RESERVE 32768
  60
  61 /**
  62  * Define how long one entry must be at least (longer -> less memory at commit).
  63  * Must be at least 4 bytes in length for correct alignment.
  64  */
  65 #define TAGFILE_ENTRY_CHUNK_LENGTH   8
  66
  67 /* Used to guess the necessary buffer size at commit. */
  68 #define TAGFILE_ENTRY_AVG_LENGTH   16
  69
  70 /* How many entries to fetch to the seek table at once while searching. */
  71 #define SEEK_LIST_SIZE 32
  72
  73 /* Always strict align entries for best performance and binary compatibility. */
  74 #define TAGCACHE_STRICT_ALIGN 1
  75
  76 /* Max events in the internal tagcache command queue. */
  77 #define TAGCACHE_COMMAND_QUEUE_LENGTH 32
  78 /* Idle time before committing events in the command queue. */
  79 #define TAGCACHE_COMMAND_QUEUE_COMMIT_DELAY  HZ*2
  80
  81 #define TAGCACHE_MAX_FILTERS 4
  82 #define TAGCACHE_MAX_CLAUSES 32
  83
  84 /* Tag database files. */
  85
  86 /* Temporary database containing new tags to be committed to the main db. */
  87 #define TAGCACHE_FILE_TEMP       ROCKBOX_DIR "/database_tmp.tcd"
  88
  89 /* The main database master index and numeric data. */
  90 #define TAGCACHE_FILE_MASTER     ROCKBOX_DIR "/database_idx.tcd"
  91
  92 /* The main database string data. */
  93 #define TAGCACHE_FILE_INDEX      ROCKBOX_DIR "/database_%d.tcd"
  94
  95 /* ASCII dumpfile of the DB contents. */
  96 #define TAGCACHE_FILE_CHANGELOG  ROCKBOX_DIR "/database_changelog.txt"
  97
  98 /* Serialized DB. */
  99 #define TAGCACHE_STATEFILE       ROCKBOX_DIR "/database_state.tcd"
 100
 101 /* Tag to be used on untagged files. */
 102 #define UNTAGGED "<Untagged>"
 103
 104 /* Numeric tags (we can use these tags with conditional clauses). */
 105 #define TAGCACHE_NUMERIC_TAGS ((1LU << tag_year) | (1LU << tag_discnumber) | \
 106     (1LU << tag_tracknumber) | (1LU << tag_length) | (1LU << tag_bitrate) | \
 107     (1LU << tag_playcount) | (1LU << tag_rating) | (1LU << tag_playtime) | \
 108     (1LU << tag_lastplayed) | (1LU << tag_commitid) | (1LU << tag_mtime) | \
 109     (1LU << tag_lastoffset) | (1LU << tag_virt_basename) | \
 110     (1LU << tag_virt_length_min) | (1LU << tag_virt_length_sec) | \
 111     (1LU << tag_virt_playtime_min) | (1LU << tag_virt_playtime_sec) | \
 112     (1LU << tag_virt_entryage) | (1LU << tag_virt_autoscore))
 113
 114 #define TAGCACHE_IS_NUMERIC(tag) (BIT_N(tag) & TAGCACHE_NUMERIC_TAGS)
 115
 116 /* Flags */
 117 #define FLAG_DELETED     0x0001  /* Entry has been removed from db */
 118 #define FLAG_DIRCACHE    0x0002  /* Filename is a dircache pointer */
 119 #define FLAG_DIRTYNUM    0x0004  /* Numeric data has been modified */
 120 #define FLAG_TRKNUMGEN   0x0008  /* Track number has been generated  */
 121 #define FLAG_RESURRECTED 0x0010  /* Statistics data has been resurrected */
 122
 123 enum clause { clause_none, clause_is, clause_is_not, clause_gt, clause_gteq,
 124     clause_lt, clause_lteq, clause_contains, clause_not_contains,
 125     clause_begins_with, clause_not_begins_with, clause_ends_with,
 126     clause_not_ends_with, clause_oneof, clause_logical_or };
 127
 128 struct tagcache_stat {
 129     bool initialized;        /* Is tagcache currently busy? */
 130     bool readyvalid;         /* Has tagcache ready status been ascertained */
 131     bool ready;              /* Is tagcache ready to be used? */
 132     bool ramcache;           /* Is tagcache loaded in ram? */
 133     bool commit_delayed;     /* Has commit been delayed until next reboot? */
 134     bool econ;               /* Is endianess correction enabled? */
 135     int  commit_step;        /* Commit progress */
 136     int  ramcache_allocated; /* Has ram been allocated for ramcache? */
 137     int  ramcache_used;      /* How much ram has been really used */
 138     int  progress;           /* Current progress of disk scan */
 139     int  processed_entries;  /* Scanned disk entries so far */
 140     int  queue_length;       /* Command queue length */
 141     volatile const char
 142         *curentry;           /* Path of the current entry being scanned. */
 143     volatile bool syncscreen;/* Synchronous operation with debug screen? */
 144     // const char *uimessage;   /* Pending error message. Implement soon. */
 145 };
 146
 147 enum source_type {source_constant,
 148                   source_runtime,
 149                   source_current_path /* dont add items after this.
 150                                        it is used as an index
 151                                        into id3_to_search_mapping */
 152                  };
 153
 154 struct tagcache_search_clause
 155 {
 156     int tag;
 157     int type;
 158     bool numeric;
 159     int source;
 160     long numeric_data;
 161     char *str;
 162 };
 163
 164 struct tagcache_seeklist_entry {
 165     int32_t seek;
 166     int32_t flag;
 167     int32_t idx_id;
 168 };
 169
 170 struct tagcache_search {
 171     /* For internal use only. */
 172     int fd, masterfd;
 173     int idxfd[TAG_COUNT];
 174     struct tagcache_seeklist_entry seeklist[SEEK_LIST_SIZE];
 175     int seek_list_count;
 176     int32_t filter_tag[TAGCACHE_MAX_FILTERS];
 177     int32_t filter_seek[TAGCACHE_MAX_FILTERS];
 178     int filter_count;
 179     struct tagcache_search_clause *clause[TAGCACHE_MAX_CLAUSES];
 180     int clause_count;
 181     int list_position;
 182     int seek_pos;
 183     long position;
 184     int entry_count;
 185     bool valid;
 186     bool initialized;
 187     unsigned long *unique_list;
 188     int unique_list_capacity;
 189     int unique_list_count;
 190
 191     /* Exported variables. */
 192     bool ramsearch;      /* Is ram copy of the tagcache being used. */
 193     bool ramresult;      /* False if result is not static, and must be copied.
 194                             Currently always false since ramresult buffer is
 195                             movable */
 196     int type;            /* The tag type to be searched. Only nonvirtual tags */
 197     char *result;        /* The result data for all tags. */
 198     int result_len;      /* Length of the result including \0 */
 199     int32_t result_seek; /* Current position in the tag data. */
 200     int32_t idx_id;      /* Entry number in the master index. */
 201 };
 202
 203 void tagcache_build(const char *path);
 204
 205 #ifdef __PCTOOL__
 206 void tagcache_reverse_scan(void);
 207 #endif
 208
 209 const char* tagcache_tag_to_str(int tag);
 210
 211 #ifdef CPU_SH
 212 bool tagcache_is_numeric_tag(int type);
 213 #endif
 214 bool tagcache_find_index(struct tagcache_search *tcs, const char *filename);
 215 bool tagcache_check_clauses(struct tagcache_search *tcs,
 216                             struct tagcache_search_clause **clause, int count);
 217 bool tagcache_is_busy(void);
 218 bool tagcache_search(struct tagcache_search *tcs, int tag);
 219 void tagcache_search_set_uniqbuf(struct tagcache_search *tcs,
 220                                  void *buffer, long length);
 221 bool tagcache_search_add_filter(struct tagcache_search *tcs,
 222                                 int tag, int seek);
 223 bool tagcache_search_add_clause(struct tagcache_search *tcs,
 224                                 struct tagcache_search_clause *clause);
 225 bool tagcache_get_next(struct tagcache_search *tcs);
 226 bool tagcache_retrieve(struct tagcache_search *tcs, int idxid,
 227                        int tag, char *buf, long size);
 228 void tagcache_search_finish(struct tagcache_search *tcs);
 229 long tagcache_get_numeric(const struct tagcache_search *tcs, int tag);
 230 long tagcache_increase_serial(void);
 231 long tagcache_get_serial(void);
 232 bool tagcache_import_changelog(void);
 233 bool tagcache_create_changelog(struct tagcache_search *tcs);
 234 void tagcache_update_numeric(int idx_id, int tag, long data);
 235 bool tagcache_modify_numeric_entry(struct tagcache_search *tcs,
 236                                    int tag, long data);
 237
 238 struct tagcache_stat* tagcache_get_stat(void);
 239 int tagcache_get_commit_step(void);
 240 bool tagcache_prepare_shutdown(void);
 241 void tagcache_shutdown(void);
 242
 243 void tagcache_screensync_event(void);
 244 void tagcache_screensync_enable(bool state);
 245
 246 #ifdef HAVE_TC_RAMCACHE
 247 bool tagcache_is_ramcache(void);
 248 #ifdef HAVE_DIRCACHE
 249 bool tagcache_fill_tags(struct mp3entry *id3, const char *filename);
 250 #endif
 251 void tagcache_unload_ramcache(void);
 252 #endif
 253 void tagcache_init(void) INIT_ATTR;
 254 bool tagcache_is_initialized(void);
 255 bool tagcache_is_fully_initialized(void);
 256 bool tagcache_is_usable(void);
 257 void tagcache_start_scan(void);
 258 void tagcache_stop_scan(void);
 259 bool tagcache_update(void);
 260 bool tagcache_rebuild(void);
 261 int tagcache_get_max_commit_step(void);
 262 #endif
 263 #endif