Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
rockbox/apps/tagcache.h
Michael Sevakis 31b7122867 Implement time-based resume and playback start. 
This complements offset-based resume and playback start funcionality.
The implementation is global on both HWCODEC and SWCODEC.

Basically, if either the specified elapsed or offset are non-zero,
it indicates a mid-track resume.

To resume by time only, set elapsed to nonzero and offset to zero.
To resume by offset only, set offset to nonzero and elapsed to zero.

Which one the codec uses and which has priority is up to the codec;
however, using an elapsed time covers more cases:

* Codecs not able to use an offset such as VGM or other atomic
formats

* Starting playback at a nonzero elapsed time from a source that
contains no offset, such as a cuesheet

The change re-versions pretty much everything from tagcache to nvram.

Change-Id: Ic7aebb24e99a03ae99585c5e236eba960d163f38
Reviewed-on: http://gerrit.rockbox.org/516
Reviewed-by: Michael Sevakis <jethead71@rockbox.org>
Tested: Michael Sevakis <jethead71@rockbox.org>
2014-03-10 04:12:30 +01:00

261 lines
10 KiB
C
Raw Blame History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2005 by Miika Pekkarinen
*
* 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 software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#ifdef HAVE_TAGCACHE
#ifndef _TAGCACHE_H
#define _TAGCACHE_H
#include "config.h"
#include "system.h"
#include "metadata.h"
/**
Note: When adding new tags, make sure to update index_entry_ec and tags_str in
tagcache.c and bump up the header version too.
*/
enum tag_type { tag_artist = 0, tag_album, tag_genre, tag_title,
tag_filename, tag_composer, tag_comment, tag_albumartist, tag_grouping, tag_year,
tag_discnumber, tag_tracknumber, tag_bitrate, tag_length, tag_playcount, tag_rating,
tag_playtime, tag_lastplayed, tag_commitid, tag_mtime, tag_lastelapsed,
tag_lastoffset,
/* Real tags end here, count them. */
TAG_COUNT,
/* Virtual tags */
tag_virt_basename, tag_virt_length_min, tag_virt_length_sec,
tag_virt_playtime_min, tag_virt_playtime_sec,
tag_virt_entryage, tag_virt_autoscore };
/* Maximum length of a single tag. */
#define TAG_MAXLEN (MAX_PATH*2)
/* Allow a little drift to the filename ordering (should not be too high/low). */
#define POS_HISTORY_COUNT 4
/* How much to pre-load entries while committing to prevent seeking. */
#define IDX_BUF_DEPTH 64
/* Tag Cache Header version 'TCHxx'. Increment when changing internal structures. */
#define TAGCACHE_MAGIC 0x5443480f
/* Dump store/restore header version 'TCSxx'. */
#define TAGCACHE_STATEFILE_MAGIC 0x54435301
/* How much to allocate extra space for ramcache. */
#define TAGCACHE_RESERVE 32768
/**
* Define how long one entry must be at least (longer -> less memory at commit).
* Must be at least 4 bytes in length for correct alignment.
*/
#define TAGFILE_ENTRY_CHUNK_LENGTH 8
/* Used to guess the necessary buffer size at commit. */
#define TAGFILE_ENTRY_AVG_LENGTH 16
/* How many entries to fetch to the seek table at once while searching. */
#define SEEK_LIST_SIZE 32
/* Always strict align entries for best performance and binary compatibility. */
#define TAGCACHE_STRICT_ALIGN 1
/* Max events in the internal tagcache command queue. */
#define TAGCACHE_COMMAND_QUEUE_LENGTH 32
/* Idle time before committing events in the command queue. */
#define TAGCACHE_COMMAND_QUEUE_COMMIT_DELAY HZ*2
#define TAGCACHE_MAX_FILTERS 4
#define TAGCACHE_MAX_CLAUSES 32
/* Tag database files. */
/* Temporary database containing new tags to be committed to the main db. */
#define TAGCACHE_FILE_TEMP ROCKBOX_DIR "/database_tmp.tcd"
/* The main database master index and numeric data. */
#define TAGCACHE_FILE_MASTER ROCKBOX_DIR "/database_idx.tcd"
/* The main database string data. */
#define TAGCACHE_FILE_INDEX ROCKBOX_DIR "/database_%d.tcd"
/* ASCII dumpfile of the DB contents. */
#define TAGCACHE_FILE_CHANGELOG ROCKBOX_DIR "/database_changelog.txt"
/* Serialized DB. */
#define TAGCACHE_STATEFILE ROCKBOX_DIR "/database_state.tcd"
/* Tag to be used on untagged files. */
#define UNTAGGED "<Untagged>"
/* Numeric tags (we can use these tags with conditional clauses). */
#define TAGCACHE_NUMERIC_TAGS ((1LU << tag_year) | (1LU << tag_discnumber) | \
(1LU << tag_tracknumber) | (1LU << tag_length) | (1LU << tag_bitrate) | \
(1LU << tag_playcount) | (1LU << tag_rating) | (1LU << tag_playtime) | \
(1LU << tag_lastplayed) | (1LU << tag_commitid) | (1LU << tag_mtime) | \
(1LU << tag_lastelapsed) | (1LU << tag_lastoffset) | \
(1LU << tag_virt_basename) | (1LU << tag_virt_length_min) | \
(1LU << tag_virt_length_sec) | (1LU << tag_virt_playtime_min) | \
(1LU << tag_virt_playtime_sec) | (1LU << tag_virt_entryage) | \
(1LU << tag_virt_autoscore))
#define TAGCACHE_IS_NUMERIC(tag) (BIT_N(tag) & TAGCACHE_NUMERIC_TAGS)
/* Flags */
#define FLAG_DELETED 0x0001 /* Entry has been removed from db */
#define FLAG_DIRCACHE 0x0002 /* Filename is a dircache pointer */
#define FLAG_DIRTYNUM 0x0004 /* Numeric data has been modified */
#define FLAG_TRKNUMGEN 0x0008 /* Track number has been generated */
#define FLAG_RESURRECTED 0x0010 /* Statistics data has been resurrected */
enum clause { clause_none, clause_is, clause_is_not, clause_gt, clause_gteq,
clause_lt, clause_lteq, clause_contains, clause_not_contains,
clause_begins_with, clause_not_begins_with, clause_ends_with,
clause_not_ends_with, clause_oneof, clause_logical_or };
struct tagcache_stat {
bool initialized; /* Is tagcache currently busy? */
bool readyvalid; /* Has tagcache ready status been ascertained */
bool ready; /* Is tagcache ready to be used? */
bool ramcache; /* Is tagcache loaded in ram? */
bool commit_delayed; /* Has commit been delayed until next reboot? */
bool econ; /* Is endianess correction enabled? */
int commit_step; /* Commit progress */
int ramcache_allocated; /* Has ram been allocated for ramcache? */
int ramcache_used; /* How much ram has been really used */
int progress; /* Current progress of disk scan */
int processed_entries; /* Scanned disk entries so far */
int queue_length; /* Command queue length */
volatile const char
*curentry; /* Path of the current entry being scanned. */
volatile bool syncscreen;/* Synchronous operation with debug screen? */
// const char *uimessage; /* Pending error message. Implement soon. */
};
enum source_type {source_constant,
source_runtime,
source_current_path /* dont add items after this.
it is used as an index
into id3_to_search_mapping */
};
struct tagcache_search_clause
{
int tag;
int type;
bool numeric;
int source;
long numeric_data;
char *str;
};
struct tagcache_seeklist_entry {
int32_t seek;
int32_t flag;
int32_t idx_id;
};
struct tagcache_search {
/* For internal use only. */
int fd, masterfd;
int idxfd[TAG_COUNT];
struct tagcache_seeklist_entry seeklist[SEEK_LIST_SIZE];
int seek_list_count;
int32_t filter_tag[TAGCACHE_MAX_FILTERS];
int32_t filter_seek[TAGCACHE_MAX_FILTERS];
int filter_count;
struct tagcache_search_clause *clause[TAGCACHE_MAX_CLAUSES];
int clause_count;
int list_position;
int seek_pos;
long position;
int entry_count;
bool valid;
bool initialized;
unsigned long *unique_list;
int unique_list_capacity;
int unique_list_count;
/* Exported variables. */
bool ramsearch; /* Is ram copy of the tagcache being used. */
bool ramresult; /* False if result is not static, and must be copied.
Currently always false since ramresult buffer is
movable */
int type; /* The tag type to be searched. Only nonvirtual tags */
char *result; /* The result data for all tags. */
int result_len; /* Length of the result including \0 */
int32_t result_seek; /* Current position in the tag data. */
int32_t idx_id; /* Entry number in the master index. */
};
#ifdef __PCTOOL__
void tagcache_reverse_scan(void);
/* call this directly instead of tagcache_build in order to not pull
* on global_settings */
void do_tagcache_build(const char *path[]);
#endif
const char* tagcache_tag_to_str(int tag);
bool tagcache_find_index(struct tagcache_search *tcs, const char *filename);
bool tagcache_check_clauses(struct tagcache_search *tcs,
struct tagcache_search_clause **clause, int count);
bool tagcache_search(struct tagcache_search *tcs, int tag);
void tagcache_search_set_uniqbuf(struct tagcache_search *tcs,
void *buffer, long length);
bool tagcache_search_add_filter(struct tagcache_search *tcs,
int tag, int seek);
bool tagcache_search_add_clause(struct tagcache_search *tcs,
struct tagcache_search_clause *clause);
bool tagcache_get_next(struct tagcache_search *tcs);
bool tagcache_retrieve(struct tagcache_search *tcs, int idxid,
int tag, char *buf, long size);
void tagcache_search_finish(struct tagcache_search *tcs);
long tagcache_get_numeric(const struct tagcache_search *tcs, int tag);
long tagcache_increase_serial(void);
bool tagcache_import_changelog(void);
bool tagcache_create_changelog(struct tagcache_search *tcs);
void tagcache_update_numeric(int idx_id, int tag, long data);
bool tagcache_modify_numeric_entry(struct tagcache_search *tcs,
int tag, long data);
struct tagcache_stat* tagcache_get_stat(void);
int tagcache_get_commit_step(void);
bool tagcache_prepare_shutdown(void);
void tagcache_shutdown(void);
void tagcache_screensync_event(void);
void tagcache_screensync_enable(bool state);
#ifdef HAVE_TC_RAMCACHE
#ifdef HAVE_DIRCACHE
bool tagcache_fill_tags(struct mp3entry *id3, const char *filename);
#endif
void tagcache_unload_ramcache(void);
#endif
void tagcache_init(void) INIT_ATTR;
bool tagcache_is_initialized(void);
bool tagcache_is_fully_initialized(void);
bool tagcache_is_usable(void);
void tagcache_start_scan(void);
void tagcache_stop_scan(void);
bool tagcache_update(void);
bool tagcache_rebuild(void);
int tagcache_get_max_commit_step(void);
#endif
#endif
Reference in a new issue View git blame Copy permalink