MyFavMirrors/owntone-server
1
0
Fork 0
mirror of https://github.com/owntone/owntone-server.git synced 2024-12-25 06:35:57 -05:00
Code Issues Packages Projects Releases Wiki Activity

Artwork caching (pull request #61), and also:

Browse Source 
- introduced new section in config file for sqlite pragma settings,
added config for artwork cache
- added setting of pragma synchronous, cache size and journal mode to
daap cache
This commit is contained in:
chme 2014-11-10 22:53:08 +01:00 committed by ejurgensen
parent 61a4da215c
commit 7578bb1205
18 changed files with 2142 additions and 1197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
forked-daapd.conf
View File

@ -19,11 +19,11 @@ general {
admin_password = "unused"
# Enable/disable IPv6
ipv6 = no
# Location of DAAP cache
# daapcache_path = "/var/cache/forked-daapd/daapcache.db"
# Location of cache database
# cache_path = "/var/cache/forked-daapd/cache.db"
# DAAP requests that take longer than this threshold (in msec) get their
# replies cached for next time. Set to 0 to disable caching.
# daapcache_threshold = 1000
# cache_daap_threshold = 1000
}
# Library configuration
@ -137,3 +137,25 @@ spotify {
# 0: No preference (default), 1: 96kbps, 2: 160kbps, 3: 320kbps
# bitrate = 0
}
# SQLite configuration (allows to modify the operation of the SQLite databases)
# Make sure to read the SQLite documentation for the corresponding PRAGMA statements as
# changing them from the defaults may increase the possibility of database corruptions!
# By default the SQLite default values are used.
sqlite {
# Cache size in number of db pages for the library database
# (SQLite default page size is 1024 bytes and cache size is 2000 pages)
# pragma_cache_size_library = 2000
# Cache size in number of db pages for the daap cache database
# (SQLite default page size is 1024 bytes and cache size is 2000 pages)
# pragma_cache_size_cache = 2000
# Sets the journal mode for the database
# DELETE (default), TRUNCATE, PERSIST, MEMORY, WAL, OFF
# pragma_journal_mode = DELETE
# Change the setting of the "synchronous" flag
# 0: OFF, 1: NORMAL, 2: FULL (default)
# pragma_synchronous = 2
}

2
src/Makefile.am
View File

@ -96,7 +96,7 @@ forked_daapd_SOURCES = main.c \
db.c db.h \
logger.c logger.h \
conffile.c conffile.h \
daap_cache.h daap_cache.c \
cache.h cache.c \
filescanner.c filescanner.h \
filescanner_ffmpeg.c filescanner_playlist.c filescanner_icy.c $(ITUNES_SRC) \
mdns_avahi.c mdns.h \

407
src/artwork.c
View File

@ -37,6 +37,7 @@
#include "misc.h"
#include "logger.h"
#include "conffile.h"
#include "cache.h"
#if LIBAVFORMAT_VERSION_MAJOR >= 53
# include "avio_evbuffer.h"
@ -56,7 +57,6 @@ static const char *cover_extension[] =
"jpg", "png",
};
static int
artwork_read(char *filename, struct evbuffer *evbuf)
{
@ -152,7 +152,7 @@ rescale_needed(AVCodecContext *src, int max_w, int max_h, int *target_w, int *ta
}
static int
artwork_rescale(AVFormatContext *src_ctx, int s, int out_w, int out_h, int format, struct evbuffer *evbuf)
artwork_rescale(AVFormatContext *src_ctx, int s, int out_w, int out_h, struct evbuffer *evbuf)
{
uint8_t *buf;
uint8_t *outbuf;
@ -220,35 +220,29 @@ artwork_rescale(AVFormatContext *src_ctx, int s, int out_w, int out_h, int forma
dst_fmt->video_codec = AV_CODEC_ID_NONE;
/* Try to keep same codec if possible */
if ((src->codec_id == AV_CODEC_ID_PNG) && (format & ART_CAN_PNG))
if (src->codec_id == AV_CODEC_ID_PNG)
dst_fmt->video_codec = AV_CODEC_ID_PNG;
else if ((src->codec_id == AV_CODEC_ID_MJPEG) && (format & ART_CAN_JPEG))
else if (src->codec_id == AV_CODEC_ID_MJPEG)
dst_fmt->video_codec = AV_CODEC_ID_MJPEG;
/* If not possible, select new codec */
if (dst_fmt->video_codec == AV_CODEC_ID_NONE)
{
if (format & ART_CAN_PNG)
dst_fmt->video_codec = AV_CODEC_ID_PNG;
else if (format & ART_CAN_JPEG)
dst_fmt->video_codec = AV_CODEC_ID_MJPEG;
dst_fmt->video_codec = AV_CODEC_ID_PNG;
}
#else
dst_fmt->video_codec = CODEC_ID_NONE;
/* Try to keep same codec if possible */
if ((src->codec_id == CODEC_ID_PNG) && (format & ART_CAN_PNG))
if (src->codec_id == CODEC_ID_PNG)
dst_fmt->video_codec = CODEC_ID_PNG;
else if ((src->codec_id == CODEC_ID_MJPEG) && (format & ART_CAN_JPEG))
else if (src->codec_id == CODEC_ID_MJPEG)
dst_fmt->video_codec = CODEC_ID_MJPEG;
/* If not possible, select new codec */
if (dst_fmt->video_codec == CODEC_ID_NONE)
{
if (format & ART_CAN_PNG)
dst_fmt->video_codec = CODEC_ID_PNG;
else if (format & ART_CAN_JPEG)
dst_fmt->video_codec = CODEC_ID_MJPEG;
dst_fmt->video_codec = CODEC_ID_PNG;
}
#endif
@ -624,7 +618,7 @@ artwork_rescale(AVFormatContext *src_ctx, int s, int out_w, int out_h, int forma
}
static int
artwork_get(char *filename, int max_w, int max_h, int format, struct evbuffer *evbuf)
artwork_get(char *filename, int max_w, int max_h, struct evbuffer *evbuf)
{
AVFormatContext *src_ctx;
int s;
@ -675,7 +669,7 @@ artwork_get(char *filename, int max_w, int max_h, int format, struct evbuffer *e
if (src_ctx->streams[s]->codec->codec_id == CODEC_ID_PNG)
#endif
{
format_ok = (format & ART_CAN_PNG) ? ART_FMT_PNG : 0;
format_ok = ART_FMT_PNG;
break;
}
#if LIBAVCODEC_VERSION_MAJOR >= 55 || (LIBAVCODEC_VERSION_MAJOR == 54 && LIBAVCODEC_VERSION_MINOR >= 35)
@ -684,7 +678,7 @@ artwork_get(char *filename, int max_w, int max_h, int format, struct evbuffer *e
else if (src_ctx->streams[s]->codec->codec_id == CODEC_ID_MJPEG)
#endif
{
format_ok = (format & ART_CAN_JPEG) ? ART_FMT_JPEG : 0;
format_ok = ART_FMT_JPEG;
break;
}
}
@ -711,7 +705,7 @@ artwork_get(char *filename, int max_w, int max_h, int format, struct evbuffer *e
ret = format_ok;
}
else
ret = artwork_rescale(src_ctx, s, target_w, target_h, format, evbuf);
ret = artwork_rescale(src_ctx, s, target_w, target_h, evbuf);
#if LIBAVFORMAT_VERSION_MAJOR >= 54 || (LIBAVFORMAT_VERSION_MAJOR == 53 && LIBAVFORMAT_VERSION_MINOR >= 21)
avformat_close_input(&src_ctx);
@ -730,7 +724,7 @@ artwork_get(char *filename, int max_w, int max_h, int format, struct evbuffer *e
#if LIBAVFORMAT_VERSION_MAJOR >= 55 || (LIBAVFORMAT_VERSION_MAJOR == 54 && LIBAVFORMAT_VERSION_MINOR >= 6)
static int
artwork_get_embedded_image(char *filename, int max_w, int max_h, int format, struct evbuffer *evbuf)
artwork_get_embedded_image(char *filename, int max_w, int max_h, struct evbuffer *evbuf)
{
AVFormatContext *src_ctx;
AVStream *src_st;
@ -772,7 +766,7 @@ artwork_get_embedded_image(char *filename, int max_w, int max_h, int format, str
if (src_ctx->streams[s]->codec->codec_id == CODEC_ID_PNG)
#endif
{
format_ok = (format & ART_CAN_PNG) ? ART_FMT_PNG : 0;
format_ok = ART_FMT_PNG;
break;
}
#if LIBAVCODEC_VERSION_MAJOR >= 55 || (LIBAVCODEC_VERSION_MAJOR == 54 && LIBAVCODEC_VERSION_MINOR >= 35)
@ -781,7 +775,7 @@ artwork_get_embedded_image(char *filename, int max_w, int max_h, int format, str
else if (src_ctx->streams[s]->codec->codec_id == CODEC_ID_MJPEG)
#endif
{
format_ok = (format & ART_CAN_JPEG) ? ART_FMT_JPEG : 0;
format_ok = ART_FMT_JPEG;
break;
}
}
@ -827,7 +821,7 @@ artwork_get_embedded_image(char *filename, int max_w, int max_h, int format, str
{
DPRINTF(E_DBG, L_ART, "Artwork too large, rescaling image\n");
ret = artwork_rescale(src_ctx, s, target_w, target_h, format, evbuf);
ret = artwork_rescale(src_ctx, s, target_w, target_h, evbuf);
}
avformat_close_input(&src_ctx);
@ -843,66 +837,18 @@ artwork_get_embedded_image(char *filename, int max_w, int max_h, int format, str
#endif
static int
artwork_get_own_image(char *path, int max_w, int max_h, int format, struct evbuffer *evbuf)
artwork_get_dir_image(char *path, int max_w, int max_h, char *filename, struct evbuffer *evbuf)
{
char artwork[PATH_MAX];
char *ptr;
int len;
int i;
int ret;
ret = snprintf(artwork, sizeof(artwork), "%s", path);
if ((ret < 0) || (ret >= sizeof(artwork)))
{
DPRINTF(E_INFO, L_ART, "Artwork path exceeds PATH_MAX\n");
return -1;
}
ptr = strrchr(artwork, '.');
if (ptr)
*ptr = '\0';
len = strlen(artwork);
for (i = 0; i < (sizeof(cover_extension) / sizeof(cover_extension[0])); i++)
{
ret = snprintf(artwork + len, sizeof(artwork) - len, ".%s", cover_extension[i]);
if ((ret < 0) || (ret >= sizeof(artwork) - len))
{
DPRINTF(E_INFO, L_ART, "Artwork path exceeds PATH_MAX (ext %s)\n", cover_extension[i]);
continue;
}
DPRINTF(E_SPAM, L_ART, "Trying own artwork file %s\n", artwork);
ret = access(artwork, F_OK);
if (ret < 0)
continue;
break;
}
if (i == (sizeof(cover_extension) / sizeof(cover_extension[0])))
return -1;
DPRINTF(E_DBG, L_ART, "Found own artwork file %s\n", artwork);
return artwork_get(artwork, max_w, max_h, format, evbuf);
}
static int
artwork_get_dir_image(char *path, int isdir, int max_w, int max_h, int format, struct evbuffer *evbuf)
{
char artwork[PATH_MAX];
char *ptr;
char parentdir[PATH_MAX];
int i;
int j;
int len;
int ret;
cfg_t *lib;
int nbasenames;
int nextensions;
char *ptr;
ret = snprintf(artwork, sizeof(artwork), "%s", path);
if ((ret < 0) || (ret >= sizeof(artwork)))
@ -912,13 +858,6 @@ artwork_get_dir_image(char *path, int isdir, int max_w, int max_h, int format, s
return -1;
}
if (!isdir)
{
ptr = strrchr(artwork, '/');
if (ptr)
*ptr = '\0';
}
len = strlen(artwork);
lib = cfg_getsec(cfg, "library");
@ -927,9 +866,11 @@ artwork_get_dir_image(char *path, int isdir, int max_w, int max_h, int format, s
if (nbasenames == 0)
return -1;
nextensions = sizeof(cover_extension) / sizeof(cover_extension[0]);
for (i = 0; i < nbasenames; i++)
{
for (j = 0; j < (sizeof(cover_extension) / sizeof(cover_extension[0])); j++)
for (j = 0; j < nextensions; j++)
{
ret = snprintf(artwork + len, sizeof(artwork) - len, "/%s.%s", cfg_getnstr(lib, "artwork_basenames", i), cover_extension[j]);
if ((ret < 0) || (ret >= sizeof(artwork) - len))
@ -945,82 +886,59 @@ artwork_get_dir_image(char *path, int isdir, int max_w, int max_h, int format, s
if (ret < 0)
continue;
// If artwork file exists (ret == 0), exit the loop
break;
}
if (j < (sizeof(cover_extension) / sizeof(cover_extension[0])))
// In case the previous loop exited early, we found an existing artwork file and exit the outer loop
if (j < nextensions)
break;
}
// If the loop for directory artwork did not exit early, look for parent directory artwork
if (i == nbasenames)
return -1;
DPRINTF(E_DBG, L_ART, "Found directory artwork file %s\n", artwork);
return artwork_get(artwork, max_w, max_h, format, evbuf);
}
static int
artwork_get_parentdir_image(char *path, int isdir, int max_w, int max_h, int format, struct evbuffer *evbuf)
{
char artwork[PATH_MAX];
char parentdir[PATH_MAX];
char *ptr;
int len;
int i;
int ret;
ret = snprintf(artwork, sizeof(artwork), "%s", path);
if ((ret < 0) || (ret >= sizeof(artwork)))
{
DPRINTF(E_INFO, L_ART, "Artwork path exceeds PATH_MAX\n");
return -1;
}
if (!isdir)
{
ptr = strrchr(artwork, '/');
if (ptr)
*ptr = '\0';
}
ptr = strrchr(artwork, '/');
if ((!ptr) || (strlen(ptr) <= 1))
return -1;
strcpy(parentdir, ptr + 1);
ptr = strrchr(artwork, '/');
if ((!ptr) || (strlen(ptr) <= 1))
return -1;
strcpy(parentdir, ptr + 1);
len = strlen(artwork);
len = strlen(artwork);
for (i = 0; i < (sizeof(cover_extension) / sizeof(cover_extension[0])); i++)
{
ret = snprintf(artwork + len, sizeof(artwork) - len, "/%s.%s", parentdir, cover_extension[i]);
if ((ret < 0) || (ret >= sizeof(artwork) - len))
for (i = 0; i < nextensions; i++)
{
DPRINTF(E_INFO, L_ART, "Artwork path exceeds PATH_MAX (%s.%s)\n", parentdir, cover_extension[i]);
ret = snprintf(artwork + len, sizeof(artwork) - len, "/%s.%s", parentdir, cover_extension[i]);
if ((ret < 0) || (ret >= sizeof(artwork) - len))
{
DPRINTF(E_INFO, L_ART, "Artwork path exceeds PATH_MAX (%s.%s)\n", parentdir, cover_extension[i]);
continue;
}
continue;
DPRINTF(E_SPAM, L_ART, "Trying parent directory artwork file %s\n", artwork);
ret = access(artwork, F_OK);
if (ret < 0)
continue;
break;
}
DPRINTF(E_SPAM, L_ART, "Trying parent directory artwork file %s\n", artwork);
ret = access(artwork, F_OK);
if (ret < 0)
continue;
break;
if (i == nextensions)
return -1;
}
if (i == (sizeof(cover_extension) / sizeof(cover_extension[0])))
return -1;
DPRINTF(E_DBG, L_ART, "Found directory artwork file %s\n", artwork);
strcpy(filename, artwork);
DPRINTF(E_DBG, L_ART, "Found parent directory artwork file %s\n", artwork);
return artwork_get(artwork, max_w, max_h, format, evbuf);
return artwork_get(artwork, max_w, max_h, evbuf);
}
static int
artwork_get_item_path(char *path, int artwork, uint32_t data_kind, int nodir, int max_w, int max_h, int format, struct evbuffer *evbuf)
artwork_get_item_path(char *path, int artwork, int max_w, int max_h, struct evbuffer *evbuf)
{
int ret;
@ -1031,43 +949,16 @@ artwork_get_item_path(char *path, int artwork, uint32_t data_kind, int nodir, in
break;
#ifdef HAVE_SPOTIFY_H
case ARTWORK_SPOTIFY:
if (!(format & ART_CAN_JPEG))
break;
ret = spotify_artwork_get(evbuf, path, max_w, max_h);
(ret < 0) ? (ret = 0) : (ret = ART_FMT_JPEG);
break;
#endif
#if LIBAVFORMAT_VERSION_MAJOR >= 55 || (LIBAVFORMAT_VERSION_MAJOR == 54 && LIBAVFORMAT_VERSION_MINOR >= 6)
case ARTWORK_EMBEDDED:
ret = artwork_get_embedded_image(path, max_w, max_h, format, evbuf);
ret = artwork_get_embedded_image(path, max_w, max_h, evbuf);
/* Fall through if embedded artwork not found */
if (ret > 0)
break;
break;
#endif
default:
/* Not a normal file */
if (data_kind != 0)
break;
/* Look for basename(filename).{png,jpg} */
ret = artwork_get_own_image(path, max_w, max_h, format, evbuf);
if (ret > 0)
break;
if (nodir)
break;
/* Look for basedir(filename)/{artwork,cover}.{png,jpg} */
ret = artwork_get_dir_image(path, 0, max_w, max_h, format, evbuf);
if (ret > 0)
break;
/* Look for parentdir(filename).{png,jpg} */
ret = artwork_get_parentdir_image(path, 0, max_w, max_h, format, evbuf);
if (ret > 0)
break;
}
if (ret > 0)
@ -1076,46 +967,62 @@ artwork_get_item_path(char *path, int artwork, uint32_t data_kind, int nodir, in
return -1;
}
int
artwork_get_item(int id, int max_w, int max_h, int format, struct evbuffer *evbuf)
{
struct media_file_info *mfi;
int ret;
DPRINTF(E_DBG, L_ART, "Artwork request for item %d\n", id);
mfi = db_file_fetch_byid(id);
if (!mfi)
return -1;
ret = artwork_get_item_path(mfi->path, mfi->artwork, mfi->data_kind, 0, max_w, max_h, format, evbuf);
if (ret < 0)
DPRINTF(E_DBG, L_ART, "No artwork found for item id %d (%s)\n", id, mfi->fname);
free_mfi(mfi, 0);
return ret;
}
int
artwork_get_group(int id, int max_w, int max_h, int format, struct evbuffer *evbuf)
/*
* Get the artwork image for the given persistentid and the given maximum width/height
*
* The function first checks if there is a cache entry, if not it will first look for directory artwork files.
* If no directory artwork files are found, it looks for individual artwork (embedded images or images from spotify).
*
* @param persistentid persistent songalbumid or songartistid
* @param max_w maximum image width
* @param max_h maximum image height
* @param evbuf the event buffer that will contain the (scaled) image
*/
static int
artwork_get_group_persistentid(int64_t persistentid, int max_w, int max_h, struct evbuffer *evbuf)
{
struct query_params qp;
struct db_media_file_info dbmfi;
char *dir;
int got_art;
int cached;
int format;
char filename[PATH_MAX];
int ret;
int artwork;
int got_spotifyitem;
uint32_t data_kind;
DPRINTF(E_DBG, L_ART, "Artwork request for group %d\n", id);
DPRINTF(E_DBG, L_ART, "Artwork request for group %" PRIi64 "\n", persistentid);
/* Try directory artwork first */
ret = 0;
got_spotifyitem = 0;
/*
* First check if the artwork cache has a cached entry for the given persistent id and requested width/height
*/
ret = cache_artwork_get(persistentid, max_w, max_h, &cached, &format, evbuf);
if (ret == 0 && cached)
{
if (format > 0)
{
// Artwork found in cache "ret" contains the format of the image
DPRINTF(E_DBG, L_ART, "Artwork found in cache for group %" PRIi64 "\n", persistentid);
return format;
}
else if (format == 0)
{
// Entry found in cache but there is not artwork available
DPRINTF(E_DBG, L_ART, "Artwork found in cache but no image available for group %" PRIi64 "\n", persistentid);
return -1;
}
}
/* Image is not in the artwork cache. Try directory artwork first */
memset(&qp, 0, sizeof(struct query_params));
qp.type = Q_GROUP_DIRS;
qp.id = id;
qp.persistentid = persistentid;
ret = db_query_start(&qp);
if (ret < 0)
@ -1133,12 +1040,12 @@ artwork_get_group(int id, int max_w, int max_h, int format, struct evbuffer *evb
if (strncmp(dir, "http://", strlen("http://")) == 0)
continue;
/* If Spotify item don't look for artwork */
/* If Spotify item don't look for files artwork */
if (strncmp(dir, "spotify:", strlen("spotify:")) == 0)
continue;
got_art = (artwork_get_dir_image(dir, 1, max_w, max_h, format, evbuf) > 0)
|| (artwork_get_parentdir_image(dir, 1, max_w, max_h, format, evbuf) > 0);
format = artwork_get_dir_image(dir, max_w, max_h, filename, evbuf);
got_art = (format > 0);
}
db_query_end(&qp);
@ -1146,7 +1053,10 @@ artwork_get_group(int id, int max_w, int max_h, int format, struct evbuffer *evb
if (ret < 0)
DPRINTF(E_LOG, L_ART, "Error fetching Q_GROUP_DIRS results\n");
else if (got_art > 0)
return got_art;
{
cache_artwork_add(persistentid, max_w, max_h, format, filename, evbuf);
return format;
}
/* Then try individual files */
@ -1154,7 +1064,7 @@ artwork_get_group(int id, int max_w, int max_h, int format, struct evbuffer *evb
memset(&qp, 0, sizeof(struct query_params));
qp.type = Q_GROUP_ITEMS;
qp.id = id;
qp.persistentid = persistentid;
ret = db_query_start(&qp);
if (ret < 0)
@ -1170,7 +1080,14 @@ artwork_get_group(int id, int max_w, int max_h, int format, struct evbuffer *evb
if ((safe_atoi32(dbmfi.artwork, &artwork) != 0) && (safe_atou32(dbmfi.data_kind, &data_kind) != 0))
continue;
got_art = (artwork_get_item_path(dbmfi.path, artwork, data_kind, 1, max_w, max_h, format, evbuf) > 0);
format = artwork_get_item_path(dbmfi.path, artwork, max_w, max_h, evbuf);
got_art = (format > 0);
if (artwork == ARTWORK_SPOTIFY)
got_spotifyitem = 1;
if (got_art)
strcpy(filename, dbmfi.path);
}
db_query_end(&qp);
@ -1178,9 +1095,103 @@ artwork_get_group(int id, int max_w, int max_h, int format, struct evbuffer *evb
if (ret < 0)
DPRINTF(E_LOG, L_ART, "Error fetching Q_GROUP_ITEMS results\n");
else if (got_art > 0)
return got_art;
{
cache_artwork_add(persistentid, max_w, max_h, format, filename, evbuf);
return format;
}
DPRINTF(E_DBG, L_ART, "No artwork found for group %d\n", id);
/* Add cache entry for no artwork available */
if (!got_spotifyitem)
cache_artwork_add(persistentid, max_w, max_h, 0, "", evbuf);
DPRINTF(E_DBG, L_ART, "No artwork found for group %" PRIi64 "\n", persistentid);
return -1;
}
int
artwork_get_item(int id, int max_w, int max_h, struct evbuffer *evbuf)
{
struct media_file_info *mfi;
int ret;
DPRINTF(E_DBG, L_ART, "Artwork request for item %d\n", id);
mfi = db_file_fetch_byid(id);
if (!mfi)
return -1;
/*
* Load artwork image for the persistent id
*/
ret = artwork_get_group_persistentid(mfi->songalbumid, max_w, max_h, evbuf);
if (ret < 0)
DPRINTF(E_DBG, L_ART, "No artwork found for item id %d (%s)\n", id, mfi->fname);
free_mfi(mfi, 0);
return ret;
}
int
artwork_get_group(int id, int max_w, int max_h, struct evbuffer *evbuf)
{
int64_t persistentid;
int ret;
DPRINTF(E_DBG, L_ART, "Artwork request for group %d\n", id);
/*
* Get the persistent id for the given group id
*/
ret = db_group_persistentid_byid(id, &persistentid);
if (ret < 0) {
DPRINTF(E_LOG, L_ART, "Error fetching persistent id for group id %d\n", id);
return -1;
}
/*
* Load artwork image for the persistent id
*/
ret = artwork_get_group_persistentid(persistentid, max_w, max_h, evbuf);
if (ret < 0)
DPRINTF(E_DBG, L_ART, "No artwork found for group id %d\n", id);
return ret;
}
/* Checks if the file is an artwork file */
int
artwork_file_is_artwork(const char *filename)
{
cfg_t *lib;
int n;
int i;
int j;
int ret;
char artwork[PATH_MAX];
lib = cfg_getsec(cfg, "library");
n = cfg_size(lib, "artwork_basenames");
for (i = 0; i < n; i++)
{
for (j = 0; j < (sizeof(cover_extension) / sizeof(cover_extension[0])); j++)
{
ret = snprintf(artwork, sizeof(artwork), "%s.%s", cfg_getnstr(lib, "artwork_basenames", i), cover_extension[j]);
if ((ret < 0) || (ret >= sizeof(artwork)))
{
DPRINTF(E_INFO, L_ART, "Artwork path exceeds PATH_MAX (%s.%s)\n", cfg_getnstr(lib, "artwork_basenames", i), cover_extension[j]);
continue;
}
if (strcmp(artwork, filename) == 0)
return 1;
}
if (j < (sizeof(cover_extension) / sizeof(cover_extension[0])))
break;
}
return 0;
}

11
src/artwork.h
View File

@ -2,9 +2,6 @@
#ifndef __ARTWORK_H__
#define __ARTWORK_H__
#define ART_CAN_PNG (1 << 0)
#define ART_CAN_JPEG (1 << 1)
#define ART_FMT_PNG 1
#define ART_FMT_JPEG 2
@ -16,10 +13,14 @@
/* Get artwork for individual track */
int
artwork_get_item(int id, int max_w, int max_h, int format, struct evbuffer *evbuf);
artwork_get_item(int id, int max_w, int max_h, struct evbuffer *evbuf);
/* Get artwork for album or artist */
int
artwork_get_group(int id, int max_w, int max_h, int format, struct evbuffer *evbuf);
artwork_get_group(int id, int max_w, int max_h, struct evbuffer *evbuf);
/* Checks if the file is an artwork file */
int
artwork_file_is_artwork(const char *filename);
#endif /* !__ARTWORK_H__ */

1692
src/cache.c Normal file
View File

File diff suppressed because it is too large Load Diff

54
src/cache.h Normal file
View File

@ -0,0 +1,54 @@
#ifndef __CACHE_H__
#define __CACHE_H__
#ifdef HAVE_LIBEVENT2
# include <event2/event.h>
# include <event2/buffer.h>
#else
# include <event.h>
#endif
/* ---------------------------- DAAP cache API --------------------------- */
void
cache_daap_trigger(void);
int
cache_daap_get(const char *query, struct evbuffer *evbuf);
void
cache_daap_add(const char *query, const char *ua, int msec);
int
cache_daap_threshold(void);
/* ---------------------------- Artwork cache API --------------------------- */
int
cache_artwork_ping(char *path, time_t mtime);
int
cache_artwork_delete_by_path(char *path);
int
cache_artwork_purge_cruft(time_t ref);
int
cache_artwork_add(int64_t persistentid, int max_w, int max_h, int format, char *filename, struct evbuffer *evbuf);
int
cache_artwork_get(int64_t persistentid, int max_w, int max_h, int *cached, int *format, struct evbuffer *evbuf);
/* ---------------------------- Cache API --------------------------- */
int
cache_init(void);
void
cache_deinit(void);
#endif /* !__CACHE_H__ */

15
src/conffile.c
View File

@ -53,8 +53,8 @@ static cfg_opt_t sec_general[] =
CFG_INT("db_pragma_synchronous", -1, CFGF_NONE),
CFG_INT_CB("loglevel", E_LOG, CFGF_NONE, &cb_loglevel),
CFG_BOOL("ipv6", cfg_false, CFGF_NONE),
CFG_STR("daapcache_path", STATEDIR "/cache/" PACKAGE "/daapcache.db", CFGF_NONE),
CFG_INT("daapcache_threshold", 1000, CFGF_NONE),
CFG_STR("cache_path", STATEDIR "/cache/" PACKAGE "/cache.db", CFGF_NONE),
CFG_INT("cache_daap_threshold", 1000, CFGF_NONE),
CFG_END()
};
@ -114,6 +114,16 @@ static cfg_opt_t sec_spotify[] =
CFG_END()
};
/* SQLite section structure */
static cfg_opt_t sec_sqlite[] =
{
CFG_INT("pragma_cache_size_library", -1, CFGF_NONE),
CFG_INT("pragma_cache_size_cache", -1, CFGF_NONE),
CFG_STR("pragma_journal_mode", NULL, CFGF_NONE),
CFG_INT("pragma_synchronous", -1, CFGF_NONE),
CFG_END()
};
/* Config file structure */
static cfg_opt_t toplvl_cfg[] =
{
@ -122,6 +132,7 @@ static cfg_opt_t toplvl_cfg[] =
CFG_SEC("audio", sec_audio, CFGF_NONE),
CFG_SEC("airplay", sec_airplay, CFGF_MULTI | CFGF_TITLE),
CFG_SEC("spotify", sec_spotify, CFGF_NONE),
CFG_SEC("sqlite", sec_sqlite, CFGF_NONE),
CFG_END()
};

895
src/daap_cache.c
View File

@ -1,895 +0,0 @@
/*
* Copyright (C) 2014 Espen Jürgensen <espenjurgensen@gmail.com>
*
* 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 program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <stdio.h>
#include <inttypes.h>
#include <stdlib.h>
#include <stdint.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <time.h>
#include <string.h>
#include <pthread.h>
#include "conffile.h"
#include "logger.h"
#include "httpd_daap.h"
#include "db.h"
#include "daap_cache.h"
/* The DAAP cache will cache raw daap replies for queries added with
* daapcache_add(). Only some query types are supported.
* You can't add queries where the canonical reply is not HTTP_OK, because
* daap_request will use that as default for cache replies.
*
*/
struct daapcache_command;
typedef int (*cmd_func)(struct daapcache_command *cmd);
struct daapcache_command
{
pthread_mutex_t lck;
pthread_cond_t cond;
cmd_func func;
int nonblock;
struct {
char *query;
char *ua;
int msec;
struct evbuffer *evbuf;
} arg;
int ret;
};
/* --- Globals --- */
// daapcache thread
static pthread_t tid_daapcache;
// Event base, pipes and events
struct event_base *evbase_daapcache;
static int g_exit_pipe[2];
static int g_cmd_pipe[2];
static struct event *g_exitev;
static struct event *g_cmdev;
static struct event *g_cacheev;
static int g_initialized;
// Global cache database handle
static sqlite3 *g_db_hdl;
static char *g_db_path;
// After being triggered wait 60 seconds before rebuilding daapcache
static struct timeval g_wait = { 60, 0 };
// The user may configure a threshold (in msec), and queries slower than
// that will have their reply cached
static int g_cfg_threshold;
/* --------------------------------- HELPERS ------------------------------- */
/* The purpose of this function is to remove transient tags from a request
* url (query), eg remove session-id=xxx
*/
static void
remove_tag(char *in, const char *tag)
{
char *s;
char *e;
s = strstr(in, tag);
if (!s)
return;
e = strchr(s, '&');
if (e)
memmove(s, (e + 1), strlen(e + 1) + 1);
else if (s > in)
*(s - 1) = '\0';
}
/* ---------------------------- COMMAND EXECUTION -------------------------- */
static void
command_init(struct daapcache_command *cmd)
{
memset(cmd, 0, sizeof(struct daapcache_command));
pthread_mutex_init(&cmd->lck, NULL);
pthread_cond_init(&cmd->cond, NULL);
}
static void
command_deinit(struct daapcache_command *cmd)
{
pthread_cond_destroy(&cmd->cond);
pthread_mutex_destroy(&cmd->lck);
}
static int
send_command(struct daapcache_command *cmd)
{
int ret;
if (!cmd->func)
{
DPRINTF(E_LOG, L_DCACHE, "BUG: cmd->func is NULL!\n");
return -1;
}
ret = write(g_cmd_pipe[1], &cmd, sizeof(cmd));
if (ret != sizeof(cmd))
{
DPRINTF(E_LOG, L_DCACHE, "Could not send command: %s\n", strerror(errno));
return -1;
}
return 0;
}
static int
sync_command(struct daapcache_command *cmd)
{
int ret;
pthread_mutex_lock(&cmd->lck);
ret = send_command(cmd);
if (ret < 0)
{
pthread_mutex_unlock(&cmd->lck);
return -1;
}
pthread_cond_wait(&cmd->cond, &cmd->lck);
pthread_mutex_unlock(&cmd->lck);
ret = cmd->ret;
return ret;
}
static int
nonblock_command(struct daapcache_command *cmd)
{
int ret;
ret = send_command(cmd);
if (ret < 0)
return -1;
return 0;
}
static void
thread_exit(void)
{
int dummy = 42;
DPRINTF(E_DBG, L_DCACHE, "Killing daapcache thread\n");
if (write(g_exit_pipe[1], &dummy, sizeof(dummy)) != sizeof(dummy))
DPRINTF(E_LOG, L_DCACHE, "Could not write to exit fd: %s\n", strerror(errno));
}
/* --------------------------------- MAIN --------------------------------- */
/* Thread: daapcache */
static int
daapcache_create(void)
{
#define T_REPLIES \
"CREATE TABLE IF NOT EXISTS replies (" \
" id INTEGER PRIMARY KEY NOT NULL," \
" query VARCHAR(4096) NOT NULL," \
" reply BLOB" \
");"
#define T_QUERIES \
"CREATE TABLE IF NOT EXISTS queries (" \
" id INTEGER PRIMARY KEY NOT NULL," \
" query VARCHAR(4096) UNIQUE NOT NULL," \
" user_agent VARCHAR(1024)," \
" msec INTEGER DEFAULT 0," \
" timestamp INTEGER DEFAULT 0" \
");"
#define I_QUERY \
"CREATE INDEX IF NOT EXISTS idx_query ON replies (query);"
char *errmsg;
int ret;
// A fresh start
unlink(g_db_path);
// Create db
ret = sqlite3_open(g_db_path, &g_db_hdl);
if (ret != SQLITE_OK)
{
DPRINTF(E_FATAL, L_DCACHE, "Could not create database: %s\n", sqlite3_errmsg(g_db_hdl));
sqlite3_close(g_db_hdl);
return -1;
}
// Create reply cache table
ret = sqlite3_exec(g_db_hdl, T_REPLIES, NULL, NULL, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_FATAL, L_DCACHE, "Error creating reply cache table: %s\n", errmsg);
sqlite3_free(errmsg);
sqlite3_close(g_db_hdl);
return -1;
}
// Create query table (the queries for which we will generate and cache replies)
ret = sqlite3_exec(g_db_hdl, T_QUERIES, NULL, NULL, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_FATAL, L_DCACHE, "Error creating query table: %s\n", errmsg);
sqlite3_free(errmsg);
sqlite3_close(g_db_hdl);
return -1;
}
// Create index
ret = sqlite3_exec(g_db_hdl, I_QUERY, NULL, NULL, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_FATAL, L_DCACHE, "Error creating query index: %s\n", errmsg);
sqlite3_free(errmsg);
sqlite3_close(g_db_hdl);
return -1;
}
DPRINTF(E_DBG, L_DCACHE, "Cache created\n");
return 0;
#undef T_CACHE
#undef I_QUERY
}
static void
daapcache_destroy(void)
{
sqlite3_stmt *stmt;
if (!g_db_hdl)
return;
/* Tear down anything that's in flight */
while ((stmt = sqlite3_next_stmt(g_db_hdl, 0)))
sqlite3_finalize(stmt);
sqlite3_close(g_db_hdl);
unlink(g_db_path);
DPRINTF(E_DBG, L_DCACHE, "Cache destroyed\n");
}
/* Adds the reply (stored in evbuf) to the cache */
static int
daapcache_reply_add(const char *query, struct evbuffer *evbuf)
{
#define Q_TMPL "INSERT INTO replies (query, reply) VALUES (?, ?);"
sqlite3_stmt *stmt;
unsigned char *data;
size_t datlen;
int ret;
#ifdef HAVE_LIBEVENT2
datlen = evbuffer_get_length(evbuf);
data = evbuffer_pullup(evbuf, -1);
#else
datlen = EVBUFFER_LENGTH(evbuf);
data = EVBUFFER_DATA(evbuf);
#endif
ret = sqlite3_prepare_v2(g_db_hdl, Q_TMPL, -1, &stmt, 0);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DCACHE, "Error preparing query for cache update: %s\n", sqlite3_errmsg(g_db_hdl));
return -1;
}
sqlite3_bind_text(stmt, 1, query, -1, SQLITE_STATIC);
sqlite3_bind_blob(stmt, 2, data, datlen, SQLITE_STATIC);
ret = sqlite3_step(stmt);
if (ret != SQLITE_DONE)
{
DPRINTF(E_LOG, L_DCACHE, "Error stepping query for cache update: %s\n", sqlite3_errmsg(g_db_hdl));
sqlite3_finalize(stmt);
return -1;
}
ret = sqlite3_finalize(stmt);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DCACHE, "Error finalizing query for cache update: %s\n", sqlite3_errmsg(g_db_hdl));
return -1;
}
DPRINTF(E_DBG, L_DCACHE, "Wrote cache reply, size %d\n", datlen);
return 0;
#undef Q_TMPL
}
/* Adds the query to the list of queries for which we will build and cache a reply */
static int
daapcache_query_add(struct daapcache_command *cmd)
{
#define Q_TMPL "INSERT OR REPLACE INTO queries (user_agent, query, msec, timestamp) VALUES ('%q', '%q', %d, %" PRIi64 ");"
#define Q_CLEANUP "DELETE FROM queries WHERE id NOT IN (SELECT id FROM queries ORDER BY timestamp DESC LIMIT 20);"
char *query;
char *errmsg;
int ret;
if (!cmd->arg.ua)
{
DPRINTF(E_LOG, L_DCACHE, "Couldn't add slow query to cache, unknown user-agent\n");
goto error_add;
}
// Currently we are only able to pre-build and cache these reply types
if ( (strncmp(cmd->arg.query, "/databases/1/containers/", strlen("/databases/1/containers/")) != 0) &&
(strncmp(cmd->arg.query, "/databases/1/groups?", strlen("/databases/1/groups?")) != 0) &&
(strncmp(cmd->arg.query, "/databases/1/items?", strlen("/databases/1/items?")) != 0) &&
(strncmp(cmd->arg.query, "/databases/1/browse/", strlen("/databases/1/browse/")) != 0) )
goto error_add;
remove_tag(cmd->arg.query, "session-id");
remove_tag(cmd->arg.query, "revision-number");
query = sqlite3_mprintf(Q_TMPL, cmd->arg.ua, cmd->arg.query, cmd->arg.msec, (int64_t)time(NULL));
if (!query)
{
DPRINTF(E_LOG, L_DCACHE, "Out of memory making query string.\n");
goto error_add;
}
ret = sqlite3_exec(g_db_hdl, query, NULL, NULL, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DCACHE, "Error adding query to query list: %s\n", errmsg);
sqlite3_free(query);
sqlite3_free(errmsg);
goto error_add;
}
sqlite3_free(query);
DPRINTF(E_INFO, L_DCACHE, "Slow query (%d ms) added to cache: '%s' (user-agent: '%s')\n", cmd->arg.msec, cmd->arg.query, cmd->arg.ua);
free(cmd->arg.ua);
free(cmd->arg.query);
// Limits the size of the cache to only contain replies for 20 most recent queries
ret = sqlite3_exec(g_db_hdl, Q_CLEANUP, NULL, NULL, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DCACHE, "Error cleaning up query list before update: %s\n", errmsg);
sqlite3_free(errmsg);
return -1;
}
daapcache_trigger();
return 0;
error_add:
if (cmd->arg.ua)
free(cmd->arg.ua);
if (cmd->arg.query)
free(cmd->arg.query);
return -1;
#undef Q_CLEANUP
#undef Q_TMPL
}
/* Gets a reply from the cache */
static int
daapcache_query_get(struct daapcache_command *cmd)
{
#define Q_TMPL "SELECT reply FROM replies WHERE query = ?;"
sqlite3_stmt *stmt;
char *query;
int datlen;
int ret;
cmd->arg.evbuf = NULL;
query = cmd->arg.query;
remove_tag(query, "session-id");
remove_tag(query, "revision-number");
// Look in the DB
ret = sqlite3_prepare_v2(g_db_hdl, Q_TMPL, -1, &stmt, 0);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DCACHE, "Error preparing query for cache update: %s\n", sqlite3_errmsg(g_db_hdl));
free(query);
return -1;
}
sqlite3_bind_text(stmt, 1, query, -1, SQLITE_STATIC);
ret = sqlite3_step(stmt);
if (ret != SQLITE_ROW)
{
if (ret != SQLITE_DONE)
DPRINTF(E_LOG, L_DCACHE, "Error stepping query for cache update: %s\n", sqlite3_errmsg(g_db_hdl));
goto error_get;
}
datlen = sqlite3_column_bytes(stmt, 0);
cmd->arg.evbuf = evbuffer_new();
if (!cmd->arg.evbuf)
{
DPRINTF(E_LOG, L_DCACHE, "Could not create reply evbuffer\n");
goto error_get;
}
ret = evbuffer_add(cmd->arg.evbuf, sqlite3_column_blob(stmt, 0), datlen);
if (ret < 0)
{
DPRINTF(E_LOG, L_DCACHE, "Out of memory for reply evbuffer\n");
evbuffer_free(cmd->arg.evbuf);
cmd->arg.evbuf = NULL;
goto error_get;
}
ret = sqlite3_finalize(stmt);
if (ret != SQLITE_OK)
DPRINTF(E_LOG, L_DCACHE, "Error finalizing query for getting cache: %s\n", sqlite3_errmsg(g_db_hdl));
DPRINTF(E_INFO, L_DCACHE, "Cache hit: %s\n", query);
free(query);
return 0;
error_get:
sqlite3_finalize(stmt);
free(query);
return -1;
#undef Q_TMPL
}
/* Here we actually update the cache by asking httpd_daap for responses
* to the queries set for caching
*/
static void
daapcache_update_cb(int fd, short what, void *arg)
{
sqlite3_stmt *stmt;
struct evbuffer *evbuf;
char *errmsg;
char *query;
int ret;
DPRINTF(E_INFO, L_DCACHE, "Timeout reached, time to update DAAP cache\n");
ret = sqlite3_exec(g_db_hdl, "DELETE FROM replies;", NULL, NULL, &errmsg);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DCACHE, "Error clearing reply cache before update: %s\n", errmsg);
sqlite3_free(errmsg);
return;
}
ret = sqlite3_prepare_v2(g_db_hdl, "SELECT user_agent, query FROM queries;", -1, &stmt, 0);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DCACHE, "Error preparing for cache update: %s\n", sqlite3_errmsg(g_db_hdl));
return;
}
while ((ret = sqlite3_step(stmt)) == SQLITE_ROW)
{
query = strdup((char *)sqlite3_column_text(stmt, 1));
evbuf = daap_reply_build(query, (char *)sqlite3_column_text(stmt, 0));
if (!evbuf)
{
DPRINTF(E_LOG, L_DCACHE, "Error building DAAP reply for query: %s\n", query);
free(query);
continue;
}
daapcache_reply_add(query, evbuf);
free(query);
evbuffer_free(evbuf);
}
if (ret != SQLITE_DONE)
DPRINTF(E_LOG, L_DCACHE, "Could not step: %s\n", sqlite3_errmsg(g_db_hdl));
sqlite3_finalize(stmt);
DPRINTF(E_INFO, L_DCACHE, "DAAP cache updated\n");
}
/* This function will just set a timer, which when it times out will trigger
* the actual daapcache update. The purpose is to avoid avoid daapcache updates when
* the database is busy, eg during a library scan.
*/
static int
daapcache_update_timer(struct daapcache_command *cmd)
{
if (!g_cacheev)
return -1;
evtimer_add(g_cacheev, &g_wait);
return 0;
}
static void *
daapcache(void *arg)
{
int ret;
ret = daapcache_create();
if (ret < 0)
{
DPRINTF(E_LOG, L_DCACHE, "Error: Cache create failed\n");
pthread_exit(NULL);
}
ret = db_perthread_init();
if (ret < 0)
{
DPRINTF(E_LOG, L_DCACHE, "Error: DB init failed\n");
daapcache_destroy();
pthread_exit(NULL);
}
g_initialized = 1;
event_base_dispatch(evbase_daapcache);
if (g_initialized)
{
DPRINTF(E_LOG, L_DCACHE, "daapcache event loop terminated ahead of time!\n");
g_initialized = 0;
}
db_perthread_deinit();
daapcache_destroy();
pthread_exit(NULL);
}
static void
exit_cb(int fd, short what, void *arg)
{
int dummy;
int ret;
ret = read(g_exit_pipe[0], &dummy, sizeof(dummy));
if (ret != sizeof(dummy))
DPRINTF(E_LOG, L_DCACHE, "Error reading from exit pipe\n");
event_base_loopbreak(evbase_daapcache);
g_initialized = 0;
event_add(g_exitev, NULL);
}
static void
command_cb(int fd, short what, void *arg)
{
struct daapcache_command *cmd;
int ret;
ret = read(g_cmd_pipe[0], &cmd, sizeof(cmd));
if (ret != sizeof(cmd))
{
DPRINTF(E_LOG, L_DCACHE, "Could not read command! (read %d): %s\n", ret, (ret < 0) ? strerror(errno) : "-no error-");
goto readd;
}
if (cmd->nonblock)
{
cmd->func(cmd);
free(cmd);
goto readd;
}
pthread_mutex_lock(&cmd->lck);
ret = cmd->func(cmd);
cmd->ret = ret;
pthread_cond_signal(&cmd->cond);
pthread_mutex_unlock(&cmd->lck);
readd:
event_add(g_cmdev, NULL);
}
/* ---------------------------- Our daapcache API --------------------------- */
void
daapcache_trigger(void)
{
struct daapcache_command *cmd;
if (!g_initialized)
return;
cmd = (struct daapcache_command *)malloc(sizeof(struct daapcache_command));
if (!cmd)
{
DPRINTF(E_LOG, L_DCACHE, "Could not allocate daapcache_command\n");
return;
}
memset(cmd, 0, sizeof(struct daapcache_command));
cmd->nonblock = 1;
cmd->func = daapcache_update_timer;
nonblock_command(cmd);
}
struct evbuffer *
daapcache_get(const char *query)
{
struct daapcache_command cmd;
struct evbuffer *evbuf;
int ret;
if (!g_initialized)
return NULL;
command_init(&cmd);
cmd.func = daapcache_query_get;
cmd.arg.query = strdup(query);
ret = sync_command(&cmd);
evbuf = cmd.arg.evbuf;
command_deinit(&cmd);
return ((ret < 0) ? NULL : evbuf);
}
void
daapcache_add(const char *query, const char *ua, int msec)
{
struct daapcache_command *cmd;
if (!g_initialized)
return;
cmd = (struct daapcache_command *)malloc(sizeof(struct daapcache_command));
if (!cmd)
{
DPRINTF(E_LOG, L_DCACHE, "Could not allocate daapcache_command\n");
return;
}
memset(cmd, 0, sizeof(struct daapcache_command));
cmd->nonblock = 1;
cmd->func = daapcache_query_add;
cmd->arg.query = strdup(query);
cmd->arg.ua = strdup(ua);
cmd->arg.msec = msec;
nonblock_command(cmd);
}
int
daapcache_threshold(void)
{
return g_cfg_threshold;
}
int
daapcache_init(void)
{
int ret;
g_db_path = cfg_getstr(cfg_getsec(cfg, "general"), "daapcache_path");
if (!g_db_path || (strlen(g_db_path) == 0))
{
DPRINTF(E_LOG, L_DCACHE, "Cache path invalid, disabling cache\n");
g_initialized = 0;
return 0;
}
g_cfg_threshold = cfg_getint(cfg_getsec(cfg, "general"), "daapcache_threshold");
if (g_cfg_threshold == 0)
{
DPRINTF(E_LOG, L_DCACHE, "Cache threshold set to 0, disabling cache\n");
g_initialized = 0;
return 0;
}
# if defined(__linux__)
ret = pipe2(g_exit_pipe, O_CLOEXEC);
# else
ret = pipe(g_exit_pipe);
# endif
if (ret < 0)
{
DPRINTF(E_LOG, L_DCACHE, "Could not create pipe: %s\n", strerror(errno));
goto exit_fail;
}
# if defined(__linux__)
ret = pipe2(g_cmd_pipe, O_CLOEXEC);
# else
ret = pipe(g_cmd_pipe);
# endif
if (ret < 0)
{
DPRINTF(E_LOG, L_DCACHE, "Could not create command pipe: %s\n", strerror(errno));
goto cmd_fail;
}
evbase_daapcache = event_base_new();
if (!evbase_daapcache)
{
DPRINTF(E_LOG, L_DCACHE, "Could not create an event base\n");
goto evbase_fail;
}
#ifdef HAVE_LIBEVENT2
g_exitev = event_new(evbase_daapcache, g_exit_pipe[0], EV_READ, exit_cb, NULL);
if (!g_exitev)
{
DPRINTF(E_LOG, L_DCACHE, "Could not create exit event\n");
goto evnew_fail;
}
g_cmdev = event_new(evbase_daapcache, g_cmd_pipe[0], EV_READ, command_cb, NULL);
if (!g_cmdev)
{
DPRINTF(E_LOG, L_DCACHE, "Could not create cmd event\n");
goto evnew_fail;
}
g_cacheev = evtimer_new(evbase_daapcache, daapcache_update_cb, NULL);
if (!g_cmdev)
{
DPRINTF(E_LOG, L_DCACHE, "Could not create daapcache event\n");
goto evnew_fail;
}
#else
g_exitev = (struct event *)malloc(sizeof(struct event));
if (!g_exitev)
{
DPRINTF(E_LOG, L_DCACHE, "Could not create exit event\n");
goto evnew_fail;
}
event_set(g_exitev, g_exit_pipe[0], EV_READ, exit_cb, NULL);
event_base_set(evbase_daapcache, g_exitev);
g_cmdev = (struct event *)malloc(sizeof(struct event));
if (!g_cmdev)
{
DPRINTF(E_LOG, L_DCACHE, "Could not create cmd event\n");
goto evnew_fail;
}
event_set(g_cmdev, g_cmd_pipe[0], EV_READ, command_cb, NULL);
event_base_set(evbase_daapcache, g_cmdev);
g_cacheev = (struct event *)malloc(sizeof(struct event));
if (!g_cacheev)
{
DPRINTF(E_LOG, L_DCACHE, "Could not create daapcache event\n");
goto evnew_fail;
}
event_set(g_cacheev, -1, EV_TIMEOUT, daapcache_update_cb, NULL);
event_base_set(evbase_daapcache, g_cacheev);
#endif
event_add(g_exitev, NULL);
event_add(g_cmdev, NULL);
DPRINTF(E_INFO, L_DCACHE, "daapcache thread init\n");
ret = pthread_create(&tid_daapcache, NULL, daapcache, NULL);
if (ret < 0)
{
DPRINTF(E_LOG, L_DCACHE, "Could not spawn daapcache thread: %s\n", strerror(errno));
goto thread_fail;
}
return 0;
thread_fail:
evnew_fail:
event_base_free(evbase_daapcache);
evbase_daapcache = NULL;
evbase_fail:
close(g_cmd_pipe[0]);
close(g_cmd_pipe[1]);
cmd_fail:
close(g_exit_pipe[0]);
close(g_exit_pipe[1]);
exit_fail:
return -1;
}
void
daapcache_deinit(void)
{
int ret;
if (!g_initialized)
return;
thread_exit();
ret = pthread_join(tid_daapcache, NULL);
if (ret != 0)
{
DPRINTF(E_FATAL, L_DCACHE, "Could not join daapcache thread: %s\n", strerror(errno));
return;
}
// Free event base (should free events too)
event_base_free(evbase_daapcache);
// Close pipes
close(g_cmd_pipe[0]);
close(g_cmd_pipe[1]);
close(g_exit_pipe[0]);
close(g_exit_pipe[1]);
}

30
src/daap_cache.h
View File

@ -1,30 +0,0 @@
#ifndef __DAAP_CACHE_H__
#define __DAAP_CACHE_H__
#ifdef HAVE_LIBEVENT2
# include <event2/event.h>
# include <event2/buffer.h>
#else
# include <event.h>
#endif
void
daapcache_trigger(void);
struct evbuffer *
daapcache_get(const char *query);
void
daapcache_add(const char *query, const char *ua, int msec);
int
daapcache_threshold(void);
int
daapcache_init(void);
void
daapcache_deinit(void);
#endif /* !__DAAP_CACHE_H__ */

123
src/db.c
View File

@ -40,7 +40,7 @@
#include "conffile.h"
#include "logger.h"
#include "daap_cache.h"
#include "cache.h"
#include "misc.h"
#include "db.h"
@ -291,6 +291,9 @@ db_smartpl_count_items(const char *smartpl_query);
struct playlist_info *
db_pl_fetch_byid(int id);
static enum group_type
db_group_type_bypersistentid(int64_t persistentid);
char *
db_escape_string(const char *str)
@ -1259,22 +1262,22 @@ db_build_query_group_items(struct query_params *qp, char **q)
char *count;
enum group_type gt;
gt = db_group_type_byid(qp->id);
gt = db_group_type_bypersistentid(qp->persistentid);
switch (gt)
{
case G_ALBUMS:
count = sqlite3_mprintf("SELECT COUNT(*) FROM files f JOIN groups g ON f.songalbumid = g.persistentid"
" WHERE g.id = %d AND f.disabled = 0;", qp->id);
count = sqlite3_mprintf("SELECT COUNT(*) FROM files f"
" WHERE f.songalbumid = %" PRIi64 " AND f.disabled = 0;", qp->persistentid);
break;
case G_ARTISTS:
count = sqlite3_mprintf("SELECT COUNT(*) FROM files f JOIN groups g ON f.songartistid = g.persistentid"
" WHERE g.id = %d AND f.disabled = 0;", qp->id);
count = sqlite3_mprintf("SELECT COUNT(*) FROM files f"
" WHERE f.songartistid = %" PRIi64 " AND f.disabled = 0;", qp->persistentid);
break;
default:
DPRINTF(E_LOG, L_DB, "Unsupported group type %d for group id %d\n", gt, qp->id);
DPRINTF(E_LOG, L_DB, "Unsupported group type %d for group id %" PRIi64 "\n", gt, qp->persistentid);
return -1;
}
@ -1294,13 +1297,13 @@ db_build_query_group_items(struct query_params *qp, char **q)
switch (gt)
{
case G_ALBUMS:
query = sqlite3_mprintf("SELECT f.* FROM files f JOIN groups g ON f.songalbumid = g.persistentid"
" WHERE g.id = %d AND f.disabled = 0;", qp->id);
query = sqlite3_mprintf("SELECT f.* FROM files f"
" WHERE f.songalbumid = %" PRIi64 " AND f.disabled = 0;", qp->persistentid);
break;
case G_ARTISTS:
query = sqlite3_mprintf("SELECT f.* FROM files f JOIN groups g ON f.songartistid = g.persistentid"
" WHERE g.id = %d AND f.disabled = 0;", qp->id);
query = sqlite3_mprintf("SELECT f.* FROM files f"
" WHERE f.songartistid = %" PRIi64 " AND f.disabled = 0;", qp->persistentid);
break;
default:
@ -1325,24 +1328,24 @@ db_build_query_group_dirs(struct query_params *qp, char **q)
char *count;
enum group_type gt;
gt = db_group_type_byid(qp->id);
gt = db_group_type_bypersistentid(qp->persistentid);
switch (gt)
{
case G_ALBUMS:
count = sqlite3_mprintf("SELECT COUNT(DISTINCT(SUBSTR(f.path, 1, LENGTH(f.path) - LENGTH(f.fname) - 1)))"
" FROM files f JOIN groups g ON f.songalbumid = g.persistentid"
" WHERE g.id = %d AND f.disabled = 0;", qp->id);
" FROM files f"
" WHERE f.songalbumid = %" PRIi64 " AND f.disabled = 0;", qp->persistentid);
break;
case G_ARTISTS:
count = sqlite3_mprintf("SELECT COUNT(DISTINCT(SUBSTR(f.path, 1, LENGTH(f.path) - LENGTH(f.fname) - 1)))"
" FROM files f JOIN groups g ON f.songartistid = g.persistentid"
" WHERE g.id = %d AND f.disabled = 0;", qp->id);
" FROM files f"
" WHERE f.songartistid = %" PRIi64 " AND f.disabled = 0;", qp->persistentid);
break;
default:
DPRINTF(E_LOG, L_DB, "Unsupported group type %d for group id %d\n", gt, qp->id);
DPRINTF(E_LOG, L_DB, "Unsupported group type %d for group id %" PRIi64 "\n", gt, qp->persistentid);
return -1;
}
@ -1363,14 +1366,14 @@ db_build_query_group_dirs(struct query_params *qp, char **q)
{
case G_ALBUMS:
query = sqlite3_mprintf("SELECT DISTINCT(SUBSTR(f.path, 1, LENGTH(f.path) - LENGTH(f.fname) - 1))"
" FROM files f JOIN groups g ON f.songalbumid = g.persistentid"
" WHERE g.id = %d AND f.disabled = 0;", qp->id);
" FROM files f"
" WHERE f.songalbumid = %" PRIi64 " AND f.disabled = 0;", qp->persistentid);
break;
case G_ARTISTS:
query = sqlite3_mprintf("SELECT DISTINCT(SUBSTR(f.path, 1, LENGTH(f.path) - LENGTH(f.fname) - 1))"
" FROM files f JOIN groups g ON f.songartistid = g.persistentid"
" WHERE g.id = %d AND f.disabled = 0;", qp->id);
" FROM files f"
" WHERE f.songartistid = %" PRIi64 " AND f.disabled = 0;", qp->persistentid);
break;
default:
@ -1581,7 +1584,7 @@ db_query_run(char *query, int free, int cache_update)
sqlite3_free(query);
if (cache_update)
daapcache_trigger();
cache_daap_trigger();
return ((ret != SQLITE_OK) ? -1 : 0);
}
@ -2430,7 +2433,7 @@ db_file_add(struct media_file_info *mfi)
sqlite3_free(query);
daapcache_trigger();
cache_daap_trigger();
return 0;
@ -2506,7 +2509,7 @@ db_file_update(struct media_file_info *mfi)
sqlite3_free(query);
daapcache_trigger();
cache_daap_trigger();
return 0;
@ -3112,15 +3115,15 @@ db_groups_clear(void)
return db_query_run("DELETE FROM groups;", 0, 1);
}
enum group_type
db_group_type_byid(int id)
static enum group_type
db_group_type_bypersistentid(int64_t persistentid)
{
#define Q_TMPL "SELECT g.type FROM groups g WHERE g.id = '%d';"
#define Q_TMPL "SELECT g.type FROM groups g WHERE g.persistentid = '%" PRIi64 "';"
char *query;
sqlite3_stmt *stmt;
int ret;
query = sqlite3_mprintf(Q_TMPL, id);
query = sqlite3_mprintf(Q_TMPL, persistentid);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
@ -3167,6 +3170,62 @@ db_group_type_byid(int id)
#undef Q_TMPL
}
int
db_group_persistentid_byid(int id, int64_t *persistentid)
{
#define Q_TMPL "SELECT g.persistentid FROM groups g WHERE g.id = %d;"
char *query;
sqlite3_stmt *stmt;
int ret;
query = sqlite3_mprintf(Q_TMPL, id);
if (!query)
{
DPRINTF(E_LOG, L_DB, "Out of memory for query string\n");
return -1;
}
DPRINTF(E_DBG, L_DB, "Running query '%s'\n", query);
ret = db_blocking_prepare_v2(query, -1, &stmt, NULL);
if (ret != SQLITE_OK)
{
DPRINTF(E_LOG, L_DB, "Could not prepare statement: %s\n", sqlite3_errmsg(hdl));
sqlite3_free(query);
return -1;
}
ret = db_blocking_step(stmt);
if (ret != SQLITE_ROW)
{
if (ret == SQLITE_DONE)
DPRINTF(E_DBG, L_DB, "No results\n");
else
DPRINTF(E_LOG, L_DB, "Could not step: %s\n", sqlite3_errmsg(hdl));
sqlite3_finalize(stmt);
sqlite3_free(query);
return -1;
}
*persistentid = sqlite3_column_int64(stmt, 0);
#ifdef DB_PROFILE
while (db_blocking_step(stmt) == SQLITE_ROW)
; /* EMPTY */
#endif
sqlite3_finalize(stmt);
sqlite3_free(query);
return 0;
#undef Q_TMPL
}
/* Remotes */
static int
db_pairing_delete_byremote(char *remote_id)
@ -4052,6 +4111,8 @@ db_pragma_set_synchronous(int synchronous)
#undef Q_TMPL
}
int
db_perthread_init(void)
{
@ -4108,7 +4169,7 @@ db_perthread_init(void)
sqlite3_profile(hdl, db_xprofile, NULL);
#endif
cache_size = cfg_getint(cfg_getsec(cfg, "general"), "db_pragma_cache_size");
cache_size = cfg_getint(cfg_getsec(cfg, "sqlite"), "pragma_cache_size_library");
if (cache_size > -1)
{
db_pragma_set_cache_size(cache_size);
@ -4116,14 +4177,14 @@ db_perthread_init(void)
DPRINTF(E_DBG, L_DB, "Database cache size in pages: %d\n", cache_size);
}
journal_mode = cfg_getstr(cfg_getsec(cfg, "general"), "db_pragma_journal_mode");
journal_mode = cfg_getstr(cfg_getsec(cfg, "sqlite"), "pragma_journal_mode");
if (journal_mode)
{
journal_mode = db_pragma_set_journal_mode(journal_mode);
DPRINTF(E_DBG, L_DB, "Database journal mode: %s\n", journal_mode);
}
synchronous = cfg_getint(cfg_getsec(cfg, "general"), "db_pragma_synchronous");
synchronous = cfg_getint(cfg_getsec(cfg, "sqlite"), "pragma_synchronous");
if (synchronous > -1)
{
db_pragma_set_synchronous(synchronous);

5
src/db.h
View File

@ -54,6 +54,7 @@ struct query_params {
enum index_type idx_type;
enum sort_type sort;
int id;
int64_t persistentid;
int offset;
int limit;
@ -461,8 +462,8 @@ db_pl_enable_bycookie(uint32_t cookie, char *path);
int
db_groups_clear(void);
enum group_type
db_group_type_byid(int id);
int
db_group_persistentid_byid(int id, int64_t *persistentid);
/* Remotes */
int

21
src/filescanner.c
View File

@ -62,6 +62,8 @@
#include "misc.h"
#include "remote_pairing.h"
#include "player.h"
#include "cache.h"
#include "artwork.h"
#ifdef LASTFM
# include "lastfm.h"
@ -208,7 +210,7 @@ file_type_get(const char *path) {
if ((strcasecmp(ext, ".m3u") == 0) || (strcasecmp(ext, ".pls") == 0))
return FILE_PLAYLIST;
if ((strcasecmp(ext, ".png") == 0) || (strcasecmp(ext, ".jpg") == 0))
if (artwork_file_is_artwork(filename))
return FILE_ARTWORK;
#ifdef ITUNES
@ -712,6 +714,9 @@ process_file(char *file, time_t mtime, off_t size, int type, int flags)
case FILE_REGULAR:
filescanner_process_media(file, mtime, size, type, NULL);
cache_artwork_ping(file, mtime);
// TODO [artworkcache] If entry in artwork cache exists for no artwork available, delete the entry if media file has embedded artwork
counter++;
/* When in bulk mode, split transaction in pieces of 200 */
@ -731,6 +736,14 @@ process_file(char *file, time_t mtime, off_t size, int type, int flags)
process_playlist(file, mtime);
break;
case FILE_ARTWORK:
DPRINTF(E_DBG, L_SCAN, "Artwork file: %s\n", file);
cache_artwork_ping(file, mtime);
// TODO [artworkcache] If entry in artwork cache exists for no artwork available for a album with files in the same directory, delete the entry
break;
case FILE_CTRL_REMOTE:
remote_pairing_read_pin(file);
break;
@ -1066,6 +1079,7 @@ bulk_scan(int flags)
DPRINTF(E_DBG, L_SCAN, "Purging old database content\n");
db_purge_cruft(start);
cache_artwork_purge_cruft(start);
DPRINTF(E_LOG, L_SCAN, "Bulk library scan completed in %.f sec\n", difftime(end, start));
@ -1147,6 +1161,7 @@ filescanner(void *arg)
DPRINTF(E_FATAL, L_SCAN, "Scan event loop terminated ahead of time!\n");
db_perthread_deinit();
//artworkcache_perthread_deinit();
pthread_exit(NULL);
}
@ -1335,6 +1350,7 @@ process_inotify_file(struct watch_info *wi, char *path, struct inotify_event *ie
db_file_delete_bypath(path);
db_pl_delete_bypath(path);
cache_artwork_delete_by_path(path);
}
if (ie->mask & IN_MOVED_FROM)
@ -1357,7 +1373,8 @@ process_inotify_file(struct watch_info *wi, char *path, struct inotify_event *ie
{
DPRINTF(E_LOG, L_SCAN, "File access to '%s' failed: %s\n", path, strerror(errno));
db_file_delete_bypath(path);;
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
{

36
src/httpd_daap.c
View File

@ -52,7 +52,7 @@
#include "httpd_daap.h"
#include "daap_query.h"
#include "dmap_common.h"
#include "daap_cache.h"
#include "cache.h"
#ifdef HAVE_LIBEVENT2
# include <event2/http_struct.h>
@ -2255,9 +2255,9 @@ daap_reply_extra_data(struct evhttp_request *req, struct evbuffer *evbuf, char *
}
if (strcmp(uri[2], "groups") == 0)
ret = artwork_get_group(id, max_w, max_h, ART_CAN_PNG | ART_CAN_JPEG, evbuf);
ret = artwork_get_group(id, max_w, max_h, evbuf);
else if (strcmp(uri[2], "items") == 0)
ret = artwork_get_item(id, max_w, max_h, ART_CAN_PNG | ART_CAN_JPEG, evbuf);
ret = artwork_get_item(id, max_w, max_h, evbuf);
switch (ret)
{
@ -2668,19 +2668,6 @@ daap_request(struct evhttp_request *req)
*/
evhttp_add_header(headers, "Content-Type", "application/x-dmap-tagged");
// Try the cache
evbuf = daapcache_get(full_uri);
if (evbuf)
{
httpd_send_reply(req, HTTP_OK, "OK", evbuf); // TODO not all want this reply
evbuffer_free(evbuf);
free(uri);
free(full_uri);
return;
}
// No cache, so prepare handler arguments and send to the handler
evbuf = evbuffer_new();
if (!evbuf)
{
@ -2693,6 +2680,19 @@ daap_request(struct evhttp_request *req)
return;
}
// Try the cache
ret = cache_daap_get(full_uri, evbuf);
if (ret == 0)
{
httpd_send_reply(req, HTTP_OK, "OK", evbuf); // TODO not all want this reply
evbuffer_free(evbuf);
free(uri);
free(full_uri);
return;
}
// No cache, so prepare handler arguments and send to the handler
evhttp_parse_query(full_uri, &query);
clock_gettime(CLOCK_MONOTONIC, &start);
@ -2705,8 +2705,8 @@ daap_request(struct evhttp_request *req)
DPRINTF(E_DBG, L_DB, "DAAP request handled in %d milliseconds\n", msec);
if (msec > daapcache_threshold())
daapcache_add(full_uri, ua, msec);
if (msec > cache_daap_threshold())
cache_daap_add(full_uri, ua, msec);
evhttp_clear_headers(&query);
evbuffer_free(evbuf);

2
src/httpd_dacp.c
View File

@ -1802,7 +1802,7 @@ dacp_reply_nowplayingartwork(struct evhttp_request *req, struct evbuffer *evbuf,
if (ret < 0)
goto no_artwork;
ret = artwork_get_item(id, max_w, max_h, ART_CAN_PNG | ART_CAN_JPEG, evbuf);
ret = artwork_get_item(id, max_w, max_h, evbuf);
switch (ret)
{
case ART_FMT_PNG:

2
src/logger.c
View File

@ -43,7 +43,7 @@ static int threshold;
static int console;
static char *logfilename;
static FILE *logfile;
static char *labels[] = { "config", "daap", "db", "httpd", "main", "mdns", "misc", "rsp", "scan", "xcode", "event", "remote", "dacp", "ffmpeg", "artwork", "player", "raop", "laudio", "dmap", "dbperf", "spotify", "lastfm", "dcache" };
static char *labels[] = { "config", "daap", "db", "httpd", "main", "mdns", "misc", "rsp", "scan", "xcode", "event", "remote", "dacp", "ffmpeg", "artwork", "player", "raop", "laudio", "dmap", "dbperf", "spotify", "lastfm", "cache" };
static int

2
src/logger.h
View File

@ -28,7 +28,7 @@
#define L_DBPERF 19
#define L_SPOTIFY 20
#define L_LASTFM 21
#define L_DCACHE 22
#define L_CACHE 22
#define N_LOGDOMAINS 23

12
src/main.c
View File

@ -58,7 +58,7 @@ GCRY_THREAD_OPTION_PTHREAD_IMPL;
#include "db.h"
#include "logger.h"
#include "misc.h"
#include "daap_cache.h"
#include "cache.h"
#include "filescanner.h"
#include "httpd.h"
#include "mdns.h"
@ -675,11 +675,11 @@ main(int argc, char **argv)
goto db_fail;
}
/* Spawn DAAP cache thread */
ret = daapcache_init();
/* Spawn cache thread */
ret = cache_init();
if (ret != 0)
{
DPRINTF(E_FATAL, L_MAIN, "DAAP cache thread failed to start\n");
DPRINTF(E_FATAL, L_MAIN, "Cache thread failed to start\n");
ret = EXIT_FAILURE;
goto cache_fail;
@ -824,8 +824,8 @@ main(int argc, char **argv)
filescanner_deinit();
filescanner_fail:
DPRINTF(E_LOG, L_MAIN, "DAAP cache deinit\n");
daapcache_deinit();
DPRINTF(E_LOG, L_MAIN, "Cache deinit\n");
cache_deinit();
cache_fail:
DPRINTF(E_LOG, L_MAIN, "Database deinit\n");

2
src/raop.c
View File

@ -851,7 +851,7 @@ raop_metadata_prepare(int id, uint64_t rtptime)
goto skip_artwork;
}
ret = artwork_get_item(id, 600, 600, ART_CAN_PNG | ART_CAN_JPEG, rmd->artwork);
ret = artwork_get_item(id, 600, 600, rmd->artwork);
if (ret < 0)
{
DPRINTF(E_INFO, L_RAOP, "Failed to retrieve artwork for '%s' (%d); no artwork will be sent\n", dbmfi.title, id);