static struct target_dir_entry *
get_entry_by_normname(struct target_dir_hash *dh, const char *norm)
{
unsigned int hashcode;
struct target_dir_entry *de;
hashcode = djb_hash(norm);
de = dh->buckets[hashcode % NUM_DIR_HASH_BUCKETS];
while (de && strcmp(de->normalized_name, norm))
de = de->next;
return de;
}
static void
delete_entry_by_normname(struct target_dir_hash *dh, const char *norm)
{
unsigned int hashcode;
struct target_dir_entry **ent;
hashcode = djb_hash(norm);
ent = &dh->buckets[hashcode % NUM_DIR_HASH_BUCKETS];
while (*ent && strcmp((*ent)->normalized_name, norm))
ent = &(*ent)->next;
if (*ent)
*ent = (*ent)->next;
}
struct target_dir_entry *
dir_hash_create_dir(struct target_dir_hash *dh, const char *casename, const char *targetnorm)
{
unsigned int hashcode;
struct target_dir_entry *de, *parent_de;
char *parentname = NULL;
char *parentcase = NULL;
struct target_dir_entry **ent;
if (!dh->root.normalized_name)
{
dh->root.normalized_name = strdup("");
dh->root.case_name = strdup("");
hashcode = djb_hash("");
dh->buckets[hashcode % NUM_DIR_HASH_BUCKETS] = &dh->root;
}
de = get_entry_by_normname(dh, targetnorm);
if (de)
return de;
chop_dirname(targetnorm, &parentname);
chop_dirname(casename, &parentcase);
parent_de = dir_hash_create_dir(dh, parentcase, parentname);
free(parentname);
free(parentcase);
hashcode = djb_hash(targetnorm);
de = calloc(1, sizeof(*de));
de->parent = parent_de;
de->normalized_name = strdup(targetnorm);
de->case_name = strdup(chop_filename(casename));
de->next = parent_de->child;
parent_de->child = de;
ent = &dh->buckets[hashcode % NUM_DIR_HASH_BUCKETS];
while ((*ent))
{
ent = &(*ent)->next;
}
*ent = de;
return de;
}
GvdbItem *
gvdb_hash_table_insert (GHashTable *table,
const gchar *key)
{
GvdbItem *item;
item = g_slice_new0 (GvdbItem);
item->key = g_strdup (key);
item->hash_value = djb_hash (key);
g_hash_table_insert (table, g_strdup (key), item);
return item;
}
static void
hash_table_insert (gpointer key,
gpointer value,
gpointer data)
{
guint32 hash_value, bucket;
HashTable *table = data;
GvdbItem *item = value;
hash_value = djb_hash (key);
bucket = hash_value % table->n_buckets;
item->next = table->buckets[bucket];
table->buckets[bucket] = item;
}
struct dmap_query_field_map *
daap_query_field_lookup(char *field)
{
struct dmap_query_field_map dqfm;
avl_node_t *node;
dqfm.hash = djb_hash(field, strlen(field));
node = avl_search(dmap_query_fields_hash, &dqfm);
if (!node)
return NULL;
return (struct dmap_query_field_map *)node->item;
}
int
daap_query_init(void)
{
avl_node_t *node;
struct dmap_query_field_map *dqfm;
int i;
dmap_query_fields_hash = avl_alloc_tree(dmap_query_field_map_compare, NULL);
if (!dmap_query_fields_hash)
{
DPRINTF(E_FATAL, L_DAAP, "DAAP query init could not allocate AVL tree\n");
return -1;
}
for (i = 0; dmap_query_fields[i].hash == 0; i++)
{
dmap_query_fields[i].hash = djb_hash(dmap_query_fields[i].dmap_field, strlen(dmap_query_fields[i].dmap_field));
node = avl_insert(dmap_query_fields_hash, &dmap_query_fields[i]);
if (!node)
{
if (errno != EEXIST)
DPRINTF(E_FATAL, L_DAAP, "DAAP query init failed; AVL insert error: %s\n", strerror(errno));
else
{
node = avl_search(dmap_query_fields_hash, &dmap_query_fields[i]);
dqfm = node->item;
DPRINTF(E_FATAL, L_DAAP, "DAAP query init failed; WARNING: duplicate hash key\n");
DPRINTF(E_FATAL, L_DAAP, "Hash %x, string %s\n", dmap_query_fields[i].hash, dmap_query_fields[i].dmap_field);
DPRINTF(E_FATAL, L_DAAP, "Hash %x, string %s\n", dqfm->hash, dqfm->dmap_field);
}
goto avl_insert_fail;
}
}
return 0;
avl_insert_fail:
avl_free_tree(dmap_query_fields_hash);
return -1;
}
static void
write_kerning(Kerning_Table* t, char a, char b, f32 value)
{
u32 key = djb_hash(a,b) % t->capacity;
//printf("%i %f\n", key,(f32)value);
int tries = 0;
while(true)
{
if(tries > 1000)
{
printf("Too many tries\n");
break;
}
if(t->count >= t->capacity)
{
printf("Kerning Table Maxed Out\n");
break;
}
if(key >= t->capacity)
{
//printf("Wrapping\n");
key = 0;
}
if(t->keys[key].key == -1) //emtpy
{
t->keys[key].code_point_a = a;
t->keys[key].code_point_b = b;
t->keys[key].key = t->count;
//printf("%i %i %i %f\n", a,b,t->count, value);
t->values[t->count] = value;
t->count++;
break;
}
key++;
tries++;
}
if(tries > t->max_tries) t->max_tries = tries;
}
static time_t
stat_path(const char *path)
{
size_t val = djb_hash(path) % STAT_HASH_SIZE;
struct stat_cache_hash *h = &stat_hash_table[val];
struct stat_cache *e;
struct stat sb;
SLIST_FOREACH(e, h, hash_link) {
if (strcmp(path, e->path) == 0)
return e->mtime;
}
e = xmalloc(sizeof(*e));
e->path = xstrdup(path);
if (stat(path, &sb) == -1)
e->mtime = -1;
else
e->mtime = sb.st_mtime;
SLIST_INSERT_HEAD(h, e, hash_link);
return e->mtime;
}
static int
register_services(char *ffid, int no_rsp, int no_daap)
{
cfg_t *lib;
char *libname;
char *password;
char *txtrecord[10];
char records[9][128];
int port;
uint32_t hash;
int i;
int ret;
srand((unsigned int)time(NULL));
lib = cfg_getsec(cfg, "library");
libname = cfg_getstr(lib, "name");
hash = djb_hash(libname, strlen(libname));
for (i = 0; i < (sizeof(records) / sizeof(records[0])); i++)
{
memset(records[i], 0, 128);
txtrecord[i] = records[i];
}
txtrecord[9] = NULL;
snprintf(txtrecord[0], 128, "txtvers=1");
snprintf(txtrecord[1], 128, "Database ID=%0X", hash);
snprintf(txtrecord[2], 128, "Machine ID=%0X", hash);
snprintf(txtrecord[3], 128, "Machine Name=%s", libname);
snprintf(txtrecord[4], 128, "mtd-version=%s", VERSION);
snprintf(txtrecord[5], 128, "iTSh Version=131073"); /* iTunes 6.0.4 */
snprintf(txtrecord[6], 128, "Version=196610"); /* iTunes 6.0.4 */
password = cfg_getstr(lib, "password");
snprintf(txtrecord[7], 128, "Password=%s", (password) ? "true" : "false");
if (ffid)
snprintf(txtrecord[8], 128, "ffid=%s", ffid);
else
snprintf(txtrecord[8], 128, "ffid=%08x", rand());
DPRINTF(E_INFO, L_MAIN, "Registering rendezvous names\n");
port = cfg_getint(lib, "port");
/* Register web server service - disabled since we have no web interface */
/* ret = mdns_register(libname, "_http._tcp", port, txtrecord);
if (ret < 0)
return ret;
*/
/* Register RSP service */
if (!no_rsp)
{
ret = mdns_register(libname, "_rsp._tcp", port, txtrecord);
if (ret < 0)
return ret;
}
/* Register DAAP service */
if (!no_daap)
{
ret = mdns_register(libname, "_daap._tcp", port, txtrecord);
if (ret < 0)
return ret;
}
for (i = 0; i < (sizeof(records) / sizeof(records[0])); i++)
{
memset(records[i], 0, 128);
}
snprintf(txtrecord[0], 128, "txtvers=1");
snprintf(txtrecord[1], 128, "DbId=%016" PRIX64, libhash);
snprintf(txtrecord[2], 128, "DvTy=iTunes");
snprintf(txtrecord[3], 128, "DvSv=2306"); /* Magic number! Yay! */
snprintf(txtrecord[4], 128, "Ver=131073"); /* iTunes 6.0.4 */
snprintf(txtrecord[5], 128, "OSsi=0x1F5"); /* Magic number! Yay! */
snprintf(txtrecord[6], 128, "CtlN=%s", libname);
/* Terminator */
txtrecord[7] = NULL;
/* The group name for the touch-able service advertising is a 64bit hash
* but is different from the DbId in iTunes. For now we'll use a hash of
* the library name for both, and we'll change that if needed.
*/
/* Use as scratch space for the hash */
snprintf(records[7], 128, "%016" PRIX64, libhash);
/* Register touch-able service, for Remote.app */
ret = mdns_register(records[7], "_touch-able._tcp", port, txtrecord);
if (ret < 0)
return ret;
return 0;
}
int32_t partitioner_cb (const RdKafka::Topic *topic, const std::string *key,
int32_t partition_cnt, void *msg_opaque) {
return djb_hash(key->c_str(), key->size()) % partition_cnt;
}
static size_t
hash_entry(const char *path)
{
return djb_hash(path) % HASH_SIZE;
}
void platform_event_rescan_idev(arcan_evctx* ctx)
{
if (iodev.sticks_init)
SDL_QuitSubSystem(SDL_INIT_JOYSTICK);
SDL_Init(SDL_INIT_JOYSTICK);
SDL_JoystickEventState(SDL_ENABLE);
int n_joys = SDL_NumJoysticks();
iodev.sticks_init = true;
if (n_joys == 0){
drop_joytbl(ctx);
return;
}
/*
* (Re) scan/open all joysticks,
* look for matching / already present devices
* and copy their settings.
*/
size_t jsz = sizeof(struct arcan_stick) * n_joys;
struct arcan_stick* joys = malloc(jsz);
memset(joys, '\0', jsz);
for (int i = 0; i < n_joys; i++) {
struct arcan_stick* dj = &joys[i];
struct arcan_stick* sj = NULL;
unsigned long hashid = djb_hash(SDL_JoystickName(i));
/* find existing */
if (iodev.joys){
for (int j = 0; j < iodev.n_joy; j++){
if (iodev.joys[j].hashid == hashid){
sj = &iodev.joys[j];
break;
}
}
/* if found, copy to new table */
if (sj){
memcpy(dj, sj, sizeof(struct arcan_stick));
if (dj->hats){
dj->hattbls = malloc(dj->hats * sizeof(unsigned));
memcpy(dj->hattbls, sj->hattbls, sizeof(unsigned) * sj->hats);
}
if (dj->axis){
dj->adata = malloc(dj->axis * sizeof(struct axis_opts));
memcpy(dj->adata, sj->adata, sizeof(struct axis_opts) * sj->axis);
}
dj->handle = SDL_JoystickOpen(i);
continue;
}
}
/* otherwise add as new entry */
strncpy(dj->label, SDL_JoystickName(i), 255);
dj->hashid = djb_hash(SDL_JoystickName(i));
dj->handle = SDL_JoystickOpen(i);
dj->devnum = gen_devid(dj->hashid);
dj->axis = SDL_JoystickNumAxes(joys[i].handle);
dj->buttons = SDL_JoystickNumButtons(joys[i].handle);
dj->balls = SDL_JoystickNumBalls(joys[i].handle);
dj->hats = SDL_JoystickNumHats(joys[i].handle);
if (dj->hats > 0){
size_t dst_sz = joys[i].hats * sizeof(unsigned);
dj->hattbls = malloc(dst_sz);
memset(joys[i].hattbls, 0, dst_sz);
}
if (dj->axis > 0){
size_t ad_sz = sizeof(struct axis_opts) * dj->axis;
dj->adata = malloc(ad_sz);
memset(dj->adata, '\0', ad_sz);
for (int i = 0; i < dj->axis; i++){
dj->adata[i].mode = ARCAN_ANALOGFILTER_AVG;
/* these values are sortof set
* based on the SixAxis (common enough, and noisy enough) */
dj->adata[i].lower = -32765;
dj->adata[i].deadzone = 5000;
dj->adata[i].upper = 32768;
dj->adata[i].kernel_sz = 1;
}
}
/* notify the rest of the system about the added device */
struct arcan_event addev = {
.category = EVENT_IO,
.io.kind = EVENT_IO_STATUS,
.io.devkind = EVENT_IDEVKIND_STATUS,
.io.devid = dj->devnum,
.io.input.status.devkind = EVENT_IDEVKIND_GAMEDEV,
.io.input.status.action = EVENT_IDEV_ADDED
};
snprintf((char*) &addev.io.label, sizeof(addev.io.label) /
sizeof(addev.io.label[0]), "%s", dj->label);
arcan_event_enqueue(ctx, &addev);
}
iodev.n_joy = n_joys;
iodev.joys = joys;
}
void platform_event_keyrepeat(arcan_evctx* ctx, int* rate, int* delay)
{
/* sdl repeat start disabled */
static int cur_rep, cur_del;
bool upd = false;
if (*rate < 0){
*rate = cur_rep;
}
else{
int tmp = *rate;
*rate = cur_rep;
cur_rep = tmp;
upd = true;
}
if (*delay < 0){
*delay = cur_del;
}
else{
int tmp = *delay;
*delay = cur_del;
cur_del = tmp;
upd = true;
}
if (upd)
SDL_EnableKeyRepeat(cur_del, cur_rep);
}
void platform_event_deinit(arcan_evctx* ctx)
{
if (iodev.sticks_init){
SDL_QuitSubSystem(SDL_INIT_JOYSTICK);
iodev.sticks_init = false;
}
}
void platform_event_reset(arcan_evctx* ctx)
{
platform_event_deinit(ctx);
}
static int
metadata_packet_get(struct http_icy_metadata *metadata, AVFormatContext *fmtctx)
{
uint8_t *buffer;
char *icy_token;
char *ptr;
char *end;
av_opt_get(fmtctx, "icy_metadata_packet", AV_OPT_SEARCH_CHILDREN, &buffer);
if (!buffer)
return -1;
icy_token = strtok((char *)buffer, ";");
while (icy_token != NULL)
{
ptr = strchr(icy_token, '=');
if (!ptr || (ptr[1] == '\0'))
{
icy_token = strtok(NULL, ";");
continue;
}
ptr++;
if (ptr[0] == '\'')
ptr++;
end = strrchr(ptr, '\'');
if (end)
*end = '\0';
if ((strncmp(icy_token, "StreamTitle", strlen("StreamTitle")) == 0) && !metadata->title)
{
metadata->title = ptr;
/* Dash separates artist from title, if no dash assume all is title */
ptr = strstr(ptr, " - ");
if (ptr)
{
*ptr = '\0';
metadata->title = strdup(metadata->title);
*ptr = ' ';
metadata->artist = strdup(ptr + 3);
}
else
metadata->title = strdup(metadata->title);
}
else if ((strncmp(icy_token, "StreamUrl", strlen("StreamUrl")) == 0) && !metadata->artwork_url)
{
metadata->artwork_url = strdup(ptr);
}
if (end)
*end = '\'';
icy_token = strtok(NULL, ";");
}
av_free(buffer);
if (metadata->title)
metadata->hash = djb_hash(metadata->title, strlen(metadata->title));
return 0;
}
/* Thread: scan */
static void
process_inotify_file(struct watch_info *wi, char *path, struct inotify_event *ie)
{
struct stat sb;
uint32_t path_hash;
char *deref = NULL;
char *file = path;
char *dir;
char dir_vpath[PATH_MAX];
int type;
int i;
int dir_id;
char *ptr;
int ret;
DPRINTF(E_DBG, L_SCAN, "File event: 0x%x, cookie 0x%x, wd %d\n", ie->mask, ie->cookie, wi->wd);
path_hash = djb_hash(path, strlen(path));
if (ie->mask & IN_DELETE)
{
DPRINTF(E_DBG, L_SCAN, "File deleted: %s\n", path);
db_file_delete_bypath(path);
db_pl_delete_bypath(path);
cache_artwork_delete_by_path(path);
}
if (ie->mask & IN_MOVED_FROM)
{
DPRINTF(E_DBG, L_SCAN, "File moved from: %s\n", path);
db_file_disable_bypath(path, path, ie->cookie);
db_pl_disable_bypath(path, path, ie->cookie);
}
if (ie->mask & IN_ATTRIB)
{
DPRINTF(E_DBG, L_SCAN, "File attributes changed: %s\n", path);
// Ignore the IN_ATTRIB if we just got an IN_CREATE
for (i = 0; i < INCOMINGFILES_BUFFER_SIZE; i++)
{
if (incomingfiles_buffer[i] == path_hash)
return;
}
#ifdef HAVE_EUIDACCESS
if (euidaccess(path, R_OK) < 0)
#else
if (access(path, R_OK) < 0)
#endif
{
DPRINTF(E_LOG, L_SCAN, "File access to '%s' failed: %s\n", path, strerror(errno));
db_file_delete_bypath(path);
cache_artwork_delete_by_path(path);
}
else if ((file_type_get(path) == FILE_REGULAR) && (db_file_id_bypath(path) <= 0)) // TODO Playlists
{
DPRINTF(E_LOG, L_SCAN, "File access to '%s' achieved\n", path);
ie->mask |= IN_CLOSE_WRITE;
}
}
if (ie->mask & IN_MOVED_TO)
{
DPRINTF(E_DBG, L_SCAN, "File moved to: %s\n", path);
ret = db_file_enable_bycookie(ie->cookie, path);
if (ret > 0)
{
// If file was successfully enabled, update the directory id
dir = strdup(path);
ptr = strrchr(dir, '/');
dir[(ptr - dir)] = '\0';
ret = create_virtual_path(dir, dir_vpath, sizeof(dir_vpath));
if (ret >= 0)
{
dir_id = db_directory_id_byvirtualpath(dir_vpath);
if (dir_id > 0)
{
ret = db_file_update_directoryid(path, dir_id);
if (ret < 0)
DPRINTF(E_LOG, L_SCAN, "Error updating directory id for file: %s\n", path);
}
}
free(dir);
}
else
{
/* It's not a known media file, so it's either a new file
* or a playlist, known or not.
* We want to scan the new file and we want to rescan the
* playlist to update playlist items (relative items).
*/
ie->mask |= IN_CLOSE_WRITE;
db_pl_enable_bycookie(ie->cookie, path);
}
}
if (ie->mask & IN_CREATE)
{
DPRINTF(E_DBG, L_SCAN, "File created: %s\n", path);
ret = lstat(path, &sb);
if (ret < 0)
{
DPRINTF(E_LOG, L_SCAN, "Could not lstat() '%s': %s\n", path, strerror(errno));
return;
}
// Add to the list of files where we ignore IN_ATTRIB until the file is closed again
if (S_ISREG(sb.st_mode))
{
DPRINTF(E_SPAM, L_SCAN, "Incoming file created '%s' (%d), index %d\n", path, (int)path_hash, incomingfiles_idx);
incomingfiles_buffer[incomingfiles_idx] = path_hash;
incomingfiles_idx = (incomingfiles_idx + 1) % INCOMINGFILES_BUFFER_SIZE;
}
else if (S_ISFIFO(sb.st_mode))
ie->mask |= IN_CLOSE_WRITE;
}
if (ie->mask & IN_CLOSE_WRITE)
{
DPRINTF(E_DBG, L_SCAN, "File closed: %s\n", path);
// File has been closed so remove from the IN_ATTRIB ignore list
for (i = 0; i < INCOMINGFILES_BUFFER_SIZE; i++)
if (incomingfiles_buffer[i] == path_hash)
{
DPRINTF(E_SPAM, L_SCAN, "Incoming file closed '%s' (%d), index %d\n", path, (int)path_hash, i);
incomingfiles_buffer[i] = 0;
}
ret = lstat(path, &sb);
if (ret < 0)
{
DPRINTF(E_LOG, L_SCAN, "Could not lstat() '%s': %s\n", path, strerror(errno));
return;
}
if (S_ISLNK(sb.st_mode))
{
deref = m_realpath(path);
if (!deref)
{
DPRINTF(E_LOG, L_SCAN, "Could not dereference symlink '%s': %s\n", path, strerror(errno));
return;
}
file = deref;
ret = stat(deref, &sb);
if (ret < 0)
{
DPRINTF(E_LOG, L_SCAN, "Could not stat() '%s': %s\n", file, strerror(errno));
free(deref);
return;
}
if (S_ISDIR(sb.st_mode))
{
process_inotify_dir(wi, deref, ie);
free(deref);
return;
}
}
type = 0;
if (check_speciallib(path, "compilations"))
type |= F_SCAN_TYPE_COMPILATION;
if (check_speciallib(path, "podcasts"))
type |= F_SCAN_TYPE_PODCAST;
if (check_speciallib(path, "audiobooks"))
type |= F_SCAN_TYPE_AUDIOBOOK;
dir_id = get_parent_dir_id(file);
if (S_ISREG(sb.st_mode))
{
process_file(file, sb.st_mtime, sb.st_size, F_SCAN_TYPE_FILE | type, 0, dir_id);
}
else if (S_ISFIFO(sb.st_mode))
process_file(file, sb.st_mtime, sb.st_size, F_SCAN_TYPE_PIPE | type, 0, dir_id);
if (deref)
free(deref);
}
}