oysteikt/mpd
0
0
Fork 0
Code Issues Pull Requests Releases Activity

Merge branch 'experimental' of git://git.musicpd.org/metyl/mpd

Browse Source 
Conflicts:

	configure.ac
	src/ls.h
	src/output/shout_plugin.c
This commit is contained in:
Max Kellermann 2008-12-27 13:34:51 +01:00
commit 9220e0edff
25 changed files with 1639 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
configure.ac
View File

@ -170,6 +170,52 @@ AC_ARG_ENABLE(mvp,
enable_mvp=no)
dnl
dnl archive plugins
dnl
AC_ARG_ENABLE(bz2,
AS_HELP_STRING([--enable-bz2],
[enable rar archive support (default: disabled)]),
enable_bz2=$enableval,
enable_bz2=no)
AM_CONDITIONAL(HAVE_BZ2, test x$enable_bz2 = xyes)
AC_ARG_ENABLE(zip,
AS_HELP_STRING([--enable-zip],
[enable zip archive support (default: disabled)]),
enable_zip=$enableval,
enable_zip=no)
AM_CONDITIONAL(HAVE_ZIP, test x$enable_zip = xyes)
AC_ARG_ENABLE(iso9660,
AS_HELP_STRING([--enable-iso9660],
[enable iso9660 archive support (default: disabled)]),
enable_iso=$enableval,
enable_iso=no)
AM_CONDITIONAL(HAVE_ISO, test x$enable_iso = xyes)
# archive plugin libraries
AC_CHECK_LIB(bz2, BZ2_bzDecompressInit,[MPD_LIBS="-lbz2";],enable_bz2=no)
if test x$enable_bz2 = xyes; then
AC_DEFINE(HAVE_BZ2, 1, [Define to have bz2 archive support])
fi
AC_CHECK_LIB(zzip, zzip_dir_open,[MPD_LIBS="-lzzip";],enable_zip=no)
if test x$enable_zip = xyes; then
AC_DEFINE(HAVE_ZIP, 1, [Define to have zip archive support])
fi
AC_CHECK_LIB(iso9660, iso9660_ifs_readdir ,,enable_iso=no)
if test x$enable_iso = xyes; then
MPD_LIBS="$MPD_LIBS -liso9660"
AC_DEFINE(HAVE_ISO, 1, [Define to have iso archive support])
fi
dnl
dnl decoder plugins
dnl
@ -1145,6 +1191,24 @@ else
echo " HTTP streaming (libcurl) ......disabled"
fi
if test x$enable_bz2 = xyes; then
echo " BZ2 archives support ..........enabled"
else
echo " BZ2 archives support ..........disabled"
fi
if test x$enable_zip = xyes; then
echo " ZIP archives support ..........enabled"
else
echo " ZIP archives support ..........disabled"
fi
if test x$enable_iso = xyes; then
echo " ISO 9660 archives support .....enabled"
else
echo " ISO 9660 archives support .....disabled"
fi
echo ""
echo "##########################################"
echo ""

23
src/Makefile.am
View File

@ -81,7 +81,10 @@ mpd_headers = \
zeroconf.h \
locate.h \
stored_playlist.h \
timer.h
timer.h \
archive_api.h \
archive_list.h \
input_archive.h
mpd_SOURCES = \
@ -155,7 +158,10 @@ mpd_SOURCES = \
volume.c \
locate.c \
stored_playlist.c \
timer.c
timer.c \
archive_api.c \
archive_list.c \
input_archive.c
if HAVE_LIBSAMPLERATE
mpd_SOURCES += pcm_resample_libsamplerate.c
@ -167,6 +173,19 @@ if HAVE_ID3TAG
mpd_SOURCES += tag_id3.c
endif
# archive plugins
if HAVE_BZ2
mpd_SOURCES += archive/bz2_plugin.c
endif
if HAVE_ZIP
mpd_SOURCES += archive/zip_plugin.c
endif
if HAVE_ISO
mpd_SOURCES += archive/iso_plugin.c
endif
# decoder plugins

303
src/archive/bz2_plugin.c Normal file
View File

@ -0,0 +1,303 @@
/* the Music Player Daemon (MPD)
* Copyright (C) 2008 Viliam Mateicka <viliam.mateicka@gmail.com>
* This project's homepage is: http://www.musicpd.org
*
* 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
*/
/**
* single bz2 archive handling (requires libbz2)
*/
#include "archive_api.h"
#include "input_stream.h"
#include "utils.h"
#include <stdint.h>
#include <stddef.h>
#include <string.h>
#include <glib.h>
#include <bzlib.h>
#ifdef HAVE_OLDER_BZIP2
#define BZ2_bzDecompressInit bzDecompressInit
#define BZ2_bzDecompress bzDecompress
#endif
#define BZ_BUFSIZE 5000
typedef struct {
char *name;
bool reset;
struct input_stream istream;
int last_bz_result;
int last_parent_result;
bz_stream bzstream;
char *buffer;
} bz2_context;
static const struct input_plugin bz2_inputplugin;
/* single archive handling allocation helpers */
static bool
bz2_alloc(bz2_context *data)
{
data->bzstream.bzalloc = NULL;
data->bzstream.bzfree = NULL;
data->bzstream.opaque = NULL;
data->buffer = g_malloc(BZ_BUFSIZE);
data->bzstream.next_in = (void *) data->buffer;
data->bzstream.avail_in = 0;
if (BZ2_bzDecompressInit(&data->bzstream, 0, 0) != BZ_OK) {
g_free(data->buffer);
g_free(data);
return false;
}
data->last_bz_result = BZ_OK;
data->last_parent_result = 0;
return true;
}
static void
bz2_destroy(bz2_context *data)
{
BZ2_bzDecompressEnd(&data->bzstream);
g_free(data->buffer);
}
/* archive open && listing routine */
static struct archive_file *
bz2_open(char * pathname)
{
bz2_context *context;
char *name;
int len;
context = g_malloc(sizeof(bz2_context));
if (!context) {
return NULL;
}
//open archive
if (!input_stream_open(&context->istream, pathname)) {
g_warning("failed to open an bzip2 archive %s\n",pathname);
g_free(context);
return NULL;
}
//capture filename
name = strrchr(pathname, '/');
if (name == NULL) {
g_warning("failed to get bzip2 name from %s\n",pathname);
g_free(context);
return NULL;
}
context->name = g_strdup(name+1);
//remove suffix
len = strlen(context->name);
if (len > 4) {
context->name[len-4] = 0; //remove .bz2 suffix
}
return (struct archive_file *) context;
}
static void
bz2_scan_reset(struct archive_file *file)
{
bz2_context *context = (bz2_context *) file;
context->reset = true;
}
static char *
bz2_scan_next(struct archive_file *file)
{
bz2_context *context = (bz2_context *) file;
char *name = NULL;
if (context->reset) {
name = context->name;
context->reset = false;
}
return name;
}
static void
bz2_close(struct archive_file *file)
{
bz2_context *context = (bz2_context *) file;
if (context->name)
g_free(context->name);
input_stream_close(&context->istream);
g_free(context);
}
/* single archive handling */
static void
bz2_setup_stream(struct archive_file *file, struct input_stream *is)
{
bz2_context *context = (bz2_context *) file;
//setup file ops
is->plugin = &bz2_inputplugin;
//insert back reference
is->archive = context;
is->seekable = false;
}
static bool
bz2_is_open(struct input_stream *is, G_GNUC_UNUSED const char *url)
{
bz2_context *context = (bz2_context *) is->archive;
if (!bz2_alloc(context)) {
g_warning("alloc bz2 failed\n");
return false;
}
return true;
}
static void
bz2_is_close(struct input_stream *is)
{
bz2_context *context = (bz2_context *) is->archive;
bz2_destroy(context);
is->data = NULL;
}
static int
bz2_fillbuffer(bz2_context *context,
size_t numBytes)
{
size_t count;
bz_stream *bzstream;
bzstream = &context->bzstream;
if (bzstream->avail_in > 0)
return 0;
count = input_stream_read(&context->istream,
context->buffer, BZ_BUFSIZE);
if (count == 0) {
if (bzstream->avail_out == numBytes)
return -1;
if (!input_stream_eof(&context->istream))
context->last_parent_result = 1;
} else {
bzstream->next_in = context->buffer;
bzstream->avail_in = count;
}
return 0;
}
static size_t
bz2_is_read(struct input_stream *is, void *ptr, size_t size)
{
bz2_context *context = (bz2_context *) is->archive;
bz_stream *bzstream;
int bz_result;
size_t numBytes = size;
size_t bytesRead = 0;
if (context->last_bz_result != BZ_OK)
return 0;
if (context->last_parent_result != 0)
return 0;
bzstream = &context->bzstream;
bzstream->next_out = ptr;
bzstream->avail_out = numBytes;
while (bzstream->avail_out != 0) {
if (bz2_fillbuffer(context, numBytes) != 0)
break;
bz_result = BZ2_bzDecompress(bzstream);
if (context->last_bz_result != BZ_OK
&& bzstream->avail_out == numBytes) {
context->last_bz_result = bz_result;
break;
}
if (bz_result == BZ_STREAM_END) {
context->last_bz_result = bz_result;
break;
}
}
bytesRead = numBytes - bzstream->avail_out;
is->offset += bytesRead;
return bytesRead;
}
static bool
bz2_is_eof(struct input_stream *is)
{
bz2_context *context = (bz2_context *) is->archive;
if (context->last_bz_result == BZ_STREAM_END) {
return true;
}
return false;
}
static bool
bz2_is_seek(G_GNUC_UNUSED struct input_stream *is,
G_GNUC_UNUSED off_t offset, G_GNUC_UNUSED int whence)
{
return false;
}
static int
bz2_is_buffer(G_GNUC_UNUSED struct input_stream *is)
{
return 0;
}
/* exported structures */
static const char *const bz2_extensions[] = {
"bz2",
NULL
};
static const struct input_plugin bz2_inputplugin = {
.open = bz2_is_open,
.close = bz2_is_close,
.read = bz2_is_read,
.eof = bz2_is_eof,
.seek = bz2_is_seek,
.buffer = bz2_is_buffer
};
const struct archive_plugin bz2_plugin = {
.name = "bz2",
.open = bz2_open,
.scan_reset = bz2_scan_reset,
.scan_next = bz2_scan_next,
.setup_stream = bz2_setup_stream,
.close = bz2_close,
.suffixes = bz2_extensions
};

258
src/archive/iso_plugin.c Normal file
View File

@ -0,0 +1,258 @@
/* the Music Player Daemon (MPD)
* Copyright (C) 2008 Viliam Mateicka <viliam.mateicka@gmail.com>
* This project's homepage is: http://www.musicpd.org
*
* 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
*/
/**
* iso archive handling (requires cdio, and iso9660)
*/
#include "archive_api.h"
#include "input_stream.h"
#include "utils.h"
#include <cdio/cdio.h>
#include <cdio/iso9660.h>
#include <glib.h>
#include <string.h>
#define CEILING(x, y) ((x+(y-1))/y)
typedef struct {
iso9660_t *iso;
iso9660_stat_t *statbuf;
size_t cur_ofs;
size_t max_blocks;
GSList *list;
GSList *iter;
} iso_context;
static const struct input_plugin iso_inputplugin;
/* archive open && listing routine */
static void
listdir_recur(const char *psz_path, iso_context *context)
{
iso9660_t *iso = context->iso;
CdioList_t *entlist;
CdioListNode_t *entnode;
iso9660_stat_t *statbuf;
char pathname[4096];
entlist = iso9660_ifs_readdir (iso, psz_path);
if (!entlist) {
return;
}
/* Iterate over the list of nodes that iso9660_ifs_readdir gives */
_CDIO_LIST_FOREACH (entnode, entlist) {
statbuf = (iso9660_stat_t *) _cdio_list_node_data (entnode);
strcpy(pathname, psz_path);
strcat(pathname, statbuf->filename);
if (_STAT_DIR == statbuf->type ) {
if (strcmp(statbuf->filename, ".") && strcmp(statbuf->filename, "..")) {
strcat(pathname, "/");
listdir_recur(pathname, context);
}
} else {
//remove leading /
context->list = g_slist_prepend( context->list,
xstrdup(pathname+1));
}
}
_cdio_list_free (entlist, true);
}
static struct archive_file *
iso_open(char * pathname)
{
iso_context *context = g_malloc(sizeof(iso_context));
context->list = NULL;
/* open archive */
context->iso = iso9660_open (pathname);
if (context->iso == NULL) {
g_warning("iso %s open failed\n", pathname);
return NULL;
}
listdir_recur("/", context);
return (struct archive_file *)context;
}
static void
iso_scan_reset(struct archive_file *file)
{
iso_context *context = (iso_context *) file;
//reset iterator
context->iter = context->list;
}
static char *
iso_scan_next(struct archive_file *file)
{
iso_context *context = (iso_context *) file;
char *data = NULL;
if (context->iter != NULL) {
///fetch data and goto next
data = context->iter->data;
context->iter = g_slist_next(context->iter);
}
return data;
}
static void
iso_close(struct archive_file *file)
{
iso_context *context = (iso_context *) file;
GSList *tmp;
if (context->list) {
//free list
for (tmp = context->list; tmp != NULL; tmp = g_slist_next(tmp))
g_free(tmp->data);
g_slist_free(context->list);
}
//close archive
iso9660_close(context->iso);
context->iso = NULL;
}
/* single archive handling */
static void
iso_setup_stream(struct archive_file *file, struct input_stream *is)
{
iso_context *context = (iso_context *) file;
//setup file ops
is->plugin = &iso_inputplugin;
//insert back reference
is->archive = context;
//we are not seekable
is->seekable = false;
}
static bool
iso_is_open(struct input_stream *is, const char *pathname)
{
iso_context *context = (iso_context *) is->archive;
context->statbuf = iso9660_ifs_stat_translate (context->iso, pathname);
if (context->statbuf == NULL) {
g_warning("file %s not found in iso\n", pathname);
return false;
}
context->cur_ofs = 0;
context->max_blocks = CEILING(context->statbuf->size, ISO_BLOCKSIZE);
return true;
}
static void
iso_is_close(struct input_stream *is)
{
iso_context *context = (iso_context *) is->archive;
g_free(context->statbuf);
}
static size_t
iso_is_read(struct input_stream *is, void *ptr, size_t size)
{
iso_context *context = (iso_context *) is->archive;
int toread, readed = 0;
int no_blocks, cur_block;
size_t left_bytes = context->statbuf->size - context->cur_ofs;
size = (size * ISO_BLOCKSIZE) / ISO_BLOCKSIZE;
if (left_bytes < size) {
toread = left_bytes;
no_blocks = CEILING(left_bytes,ISO_BLOCKSIZE);
} else {
toread = size;
no_blocks = toread / ISO_BLOCKSIZE;
}
if (no_blocks > 0) {
cur_block = context->cur_ofs / ISO_BLOCKSIZE;
readed = iso9660_iso_seek_read (context->iso, ptr,
context->statbuf->lsn + cur_block, no_blocks);
if (readed != no_blocks * ISO_BLOCKSIZE) {
g_warning("error reading ISO file at lsn %lu\n",
(long unsigned int) cur_block );
return -1;
}
if (left_bytes < size) {
readed = left_bytes;
}
context->cur_ofs += readed;
}
return readed;
}
static bool
iso_is_eof(struct input_stream *is)
{
iso_context *context = (iso_context *) is->archive;
return (context->cur_ofs == context->statbuf->size);
}
static bool
iso_is_seek(G_GNUC_UNUSED struct input_stream *is,
G_GNUC_UNUSED off_t offset, G_GNUC_UNUSED int whence)
{
return false;
}
static int
iso_is_buffer(G_GNUC_UNUSED struct input_stream *is)
{
return 0;
}
/* exported structures */
static const char *const iso_extensions[] = {
"iso",
NULL
};
static const struct input_plugin iso_inputplugin = {
.open = iso_is_open,
.close = iso_is_close,
.read = iso_is_read,
.eof = iso_is_eof,
.seek = iso_is_seek,
.buffer = iso_is_buffer
};
const struct archive_plugin iso_plugin = {
.name = "iso",
.open = iso_open,
.scan_reset = iso_scan_reset,
.scan_next = iso_scan_next,
.setup_stream = iso_setup_stream,
.close = iso_close,
.suffixes = iso_extensions
};

196
src/archive/zip_plugin.c Normal file
View File

@ -0,0 +1,196 @@
/* the Music Player Daemon (MPD)
* Copyright (C) 2008 Viliam Mateicka <viliam.mateicka@gmail.com>
* This project's homepage is: http://www.musicpd.org
*
* 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
*/
/**
* zip archive handling (requires zziplib)
*/
#include "archive_api.h"
#include "archive_api.h"
#include "input_stream.h"
#include "utils.h"
#include <zzip/zzip.h>
#include <glib.h>
#include <string.h>
typedef struct {
ZZIP_DIR *dir;
ZZIP_FILE *file;
size_t length;
GSList *list;
GSList *iter;
} zip_context;
static const struct input_plugin zip_inputplugin;
/* archive open && listing routine */
static struct archive_file *
zip_open(char * pathname)
{
zip_context *context = g_malloc(sizeof(zip_context));
ZZIP_DIRENT dirent;
// open archive
context->list = NULL;
context->dir = zzip_dir_open(pathname, 0);
if (context->dir == NULL) {
g_warning("zipfile %s open failed\n", pathname);
return NULL;
}
while (zzip_dir_read(context->dir, &dirent)) {
context->list = g_slist_prepend( context->list, xstrdup(dirent.d_name));
}
return (struct archive_file *)context;
}
static void
zip_scan_reset(struct archive_file *file)
{
zip_context *context = (zip_context *) file;
//reset iterator
context->iter = context->list;
}
static char *
zip_scan_next(struct archive_file *file)
{
zip_context *context = (zip_context *) file;
char *data = NULL;
if (context->iter != NULL) {
///fetch data and goto next
data = context->iter->data;
context->iter = g_slist_next(context->iter);
}
return data;
}
static void
zip_close(struct archive_file *file)
{
zip_context *context = (zip_context *) file;
if (context->list) {
//free list
for (GSList *tmp = context->list; tmp != NULL; tmp = g_slist_next(tmp))
g_free(tmp->data);
g_slist_free(context->list);
}
//close archive
zzip_dir_close (context->dir);
context->dir = NULL;
}
/* single archive handling */
static void
zip_setup_stream(struct archive_file *file, struct input_stream *is)
{
zip_context *context = (zip_context *) file;
//setup file ops
is->plugin = &zip_inputplugin;
//insert back reference
is->archive = context;
//we are not seekable
is->seekable = false;
}
static bool
zip_is_open(struct input_stream *is, const char *pathname)
{
zip_context *context = (zip_context *) is->archive;
ZZIP_STAT z_stat;
context->file = zzip_file_open(context->dir, pathname, 0);
if (!context->file) {
g_warning("file %s not found in the zipfile\n", pathname);
return false;
}
zzip_file_stat(context->file, &z_stat);
context->length = z_stat.st_size;
return true;
}
static void
zip_is_close(struct input_stream *is)
{
zip_context *context = (zip_context *) is->archive;
zzip_file_close (context->file);
}
static size_t
zip_is_read(struct input_stream *is, void *ptr, size_t size)
{
zip_context *context = (zip_context *) is->archive;
int ret;
ret = zzip_file_read(context->file, ptr, size);
if (ret < 0) {
g_warning("error %d reading zipfile\n", ret);
return 0;
}
return ret;
}
static bool
zip_is_eof(struct input_stream *is)
{
zip_context *context = (zip_context *) is->archive;
return ((size_t) zzip_tell(context->file) == context->length);
}
static bool
zip_is_seek(G_GNUC_UNUSED struct input_stream *is,
G_GNUC_UNUSED off_t offset, G_GNUC_UNUSED int whence)
{
return false;
}
static int
zip_is_buffer(G_GNUC_UNUSED struct input_stream *is)
{
return 0;
}
/* exported structures */
static const char *const zip_extensions[] = {
"zip",
NULL
};
static const struct input_plugin zip_inputplugin = {
.open = zip_is_open,
.close = zip_is_close,
.read = zip_is_read,
.eof = zip_is_eof,
.seek = zip_is_seek,
.buffer = zip_is_buffer
};
const struct archive_plugin zip_plugin = {
.name = "zip",
.open = zip_open,
.scan_reset = zip_scan_reset,
.scan_next = zip_scan_next,
.setup_stream = zip_setup_stream,
.close = zip_close,
.suffixes = zip_extensions
};

111
src/archive_api.c Normal file
View File

@ -0,0 +1,111 @@
/* the Music Player Daemon (MPD)
* Copyright (C) 2008 Viliam Mateicka <viliam.mateicka@gmail.com>
* This project's homepage is: http://www.musicpd.org
*
* 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
*/
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <glib.h>
#include "utils.h"
#include "archive_api.h"
/**
*
* archive_lookup is used to determine if part of pathname refers to an regular
* file (archive). If so then its also used to split pathname into archive file
* and path used to locate file in archive. It also returns suffix of the file.
* How it works:
* We do stat of the parent of input pathname as long as we find an regular file
* Normally this should never happen. When routine returns true pathname modified
* and split into archive, inpath and suffix. Otherwise nothing happens
*
* For example:
*
* /music/path/Talco.zip/Talco - Combat Circus/12 - A la pachenka.mp3
* is split into archive: /music/path/Talco.zip
* inarchive pathname: Talco - Combat Circus/12 - A la pachenka.mp3
* and suffix: zip
*/
bool archive_lookup(char *pathname, char **archive, char **inpath, char **suffix)
{
char *pathdupe;
int len, idx;
struct stat st_info;
bool ret = false;
*archive = NULL;
*inpath = NULL;
*suffix = NULL;
pathdupe = g_strdup(pathname);
len = idx = strlen(pathname);
while (idx > 0) {
//try to stat if its real directory
if (stat(pathdupe, &st_info) == -1) {
if (errno != ENOTDIR) {
g_warning("stat %s failed (errno=%d)\n", pathdupe, errno);
break;
}
} else {
//is something found ins original path (is not an archive)
if (idx == len) {
break;
}
//its a file ?
if (S_ISREG(st_info.st_mode)) {
//so the upper should be file
pathname[idx] = 0;
ret = true;
*archive = pathname;
*inpath = pathname + idx+1;
//try to get suffix
*suffix = NULL;
while (idx > 0) {
if (pathname[idx] == '.') {
*suffix = pathname + idx + 1;
break;
}
idx--;
}
break;
} else {
g_warning("not a regular file %s\n", pathdupe);
break;
}
}
//find one dir up
while (idx > 0) {
if (pathdupe[idx] == '/') {
pathdupe[idx] = 0;
break;
}
idx--;
}
}
g_free(pathdupe);
return ret;
}

94
src/archive_api.h Normal file
View File

@ -0,0 +1,94 @@
/* the Music Player Daemon (MPD)
* Copyright (C) 2008 Viliam Mateicka <viliam.mateicka@gmail.com>
* This project's homepage is: http://www.musicpd.org
*
* 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
*/
#ifndef MPD_ARCHIVE_API_H
#define MPD_ARCHIVE_API_H
/*
* This is the public API which is used by archive plugins to
* provide transparent archive decompression layer for mpd
*
*/
#include "archive_internal.h"
#include "input_stream.h"
#include <stdbool.h>
struct archive_file;
struct archive_plugin {
const char *name;
/**
* optional, set this to NULL if the archive plugin doesn't
* have/need one this must false if there is an error and
* true otherwise
*/
bool (*init)(void);
/**
* optional, set this to NULL if the archive plugin doesn't
* have/need one
*/
void (*finish)(void);
/**
* tryes to open archive file and associates handle with archive
* returns pointer to handle used is all operations with this archive
* or NULL when opening fails
*/
struct archive_file *(*open)(char * pathname);
/**
* reset routine will move current read index in archive to default
* position and then the filenames from archives can be read
* via scan_next routine
*/
void (*scan_reset)(struct archive_file *);
/**
* the read method will return corresponding files from archive
* (as pathnames) and move read index to next file. When there is no
* next file it return NULL.
*/
char *(*scan_next)(struct archive_file *);
/**
* this is used to setup input stream handle, to be able to read
* from archive. open method of inputstream can be the used to
* extract particular file
*/
void (*setup_stream)(struct archive_file *, struct input_stream *is);
/**
* closes archive file.
*/
void (*close)(struct archive_file *);
/**
* suffixes handled by this plugin.
* last element in these arrays must always be a NULL
*/
const char *const*suffixes;
};
bool archive_lookup(char *pathname, char **archive, char **inpath, char **suffix);
#endif

26
src/archive_internal.h Normal file
View File

@ -0,0 +1,26 @@
/* the Music Player Daemon (MPD)
* Copyright (C) 2008 Viliam Mateicka <viliam.mateicka@gmail.com>
* This project's homepage is: http://www.musicpd.org
*
* 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
*/
#ifndef MPD_ARCHIVE_INTERNAL_H
#define MPD_ARCHIVE_INTERNAL_H
struct archive_file {
int placeholder;
};
#endif

121
src/archive_list.c Normal file
View File

@ -0,0 +1,121 @@
/* the Music Player Daemon (MPD)
* Copyright (C) 2008 Viliam Mateicka <viliam.mateicka@gmail.com>
* This project's homepage is: http://www.musicpd.org
*
* 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
*/
#include "archive_list.h"
#include "archive_api.h"
#include "utils.h"
#include "../config.h"
#include <string.h>
#include <glib.h>
extern const struct archive_plugin bz2_plugin;
extern const struct archive_plugin zip_plugin;
extern const struct archive_plugin iso_plugin;
static const struct archive_plugin *const archive_plugins[] = {
#ifdef HAVE_BZ2
&bz2_plugin,
#endif
#ifdef HAVE_ZIP
&zip_plugin,
#endif
#ifdef HAVE_ISO
&iso_plugin,
#endif
NULL
};
enum {
num_archive_plugins = G_N_ELEMENTS(archive_plugins)-1,
};
/** which plugins have been initialized successfully? */
static bool archive_plugins_enabled[num_archive_plugins+1];
const struct archive_plugin *
archive_plugin_from_suffix(const char *suffix)
{
unsigned i;
if (suffix == NULL)
return NULL;
for (i=0; i < num_archive_plugins; ++i) {
const struct archive_plugin *plugin = archive_plugins[i];
if (archive_plugins_enabled[i] &&
stringFoundInStringArray(plugin->suffixes, suffix)) {
++i;
return plugin;
}
}
return NULL;
}
const struct archive_plugin *
archive_plugin_from_name(const char *name)
{
for (unsigned i = 0; i < num_archive_plugins; ++i) {
const struct archive_plugin *plugin = archive_plugins[i];
if (archive_plugins_enabled[i] &&
strcmp(plugin->name, name) == 0)
return plugin;
}
return NULL;
}
void archive_plugin_print_all_suffixes(FILE * fp)
{
const char *const*suffixes;
for (unsigned i = 0; i < num_archive_plugins; ++i) {
const struct archive_plugin *plugin = archive_plugins[i];
if (!archive_plugins_enabled[i])
continue;
suffixes = plugin->suffixes;
while (suffixes && *suffixes) {
fprintf(fp, "%s ", *suffixes);
suffixes++;
}
}
fprintf(fp, "\n");
fflush(fp);
}
void archive_plugin_init_all(void)
{
for (unsigned i = 0; i < num_archive_plugins; ++i) {
const struct archive_plugin *plugin = archive_plugins[i];
if (plugin->init == NULL || archive_plugins[i]->init())
archive_plugins_enabled[i] = true;
}
}
void archive_plugin_deinit_all(void)
{
for (unsigned i = 0; i < num_archive_plugins; ++i) {
const struct archive_plugin *plugin = archive_plugins[i];
if (archive_plugins_enabled[i] && plugin->finish != NULL)
archive_plugins[i]->finish();
}
}

44
src/archive_list.h Normal file
View File

@ -0,0 +1,44 @@
/* the Music Player Daemon (MPD)
* Copyright (C) 2008 Viliam Mateicka <viliam.mateicka@gmail.com>
* This project's homepage is: http://www.musicpd.org
*
* 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
*/
#ifndef MPD_ARCHIVE_LIST_H
#define MPD_ARCHIVE_LIST_H
#include "archive_api.h"
#include <stdio.h>
struct archive_plugin;
/* interface for using plugins */
const struct archive_plugin *
archive_plugin_from_suffix(const char *suffix);
const struct archive_plugin *
archive_plugin_from_name(const char *name);
void archive_plugin_print_all_suffixes(FILE * fp);
/* this is where we "load" all the "plugins" ;-) */
void archive_plugin_init_all(void);
/* this is where we "unload" all the "plugins" */
void archive_plugin_deinit_all(void);
#endif

91
src/decoder/audiofile_plugin.c
View File

@ -20,8 +20,8 @@
#include "../decoder_api.h"
#include <sys/stat.h>
#include <audiofile.h>
#include <af_vfs.h>
#include <glib.h>
#undef G_LOG_DOMAIN
@ -44,27 +44,79 @@ static int getAudiofileTotalTime(const char *file)
return total_time;
}
static void
audiofile_decode(struct decoder *decoder, const char *path)
static ssize_t
audiofile_file_read(AFvirtualfile *vfile, void *data, size_t nbytes)
{
struct input_stream *is = (struct input_stream *) vfile->closure;
return input_stream_read(is, data, nbytes);
}
static long
audiofile_file_length(AFvirtualfile *vfile)
{
struct input_stream *is = (struct input_stream *) vfile->closure;
return is->size;
}
static long
audiofile_file_tell(AFvirtualfile *vfile)
{
struct input_stream *is = (struct input_stream *) vfile->closure;
return is->offset;
}
static void
audiofile_file_destroy(AFvirtualfile *vfile)
{
struct input_stream *is = (struct input_stream *) vfile->closure;
vfile->closure = NULL;
input_stream_close(is);
}
static long
audiofile_file_seek(AFvirtualfile *vfile, long offset, int is_relative)
{
struct input_stream *is = (struct input_stream *) vfile->closure;
int whence = (is_relative ? SEEK_CUR : SEEK_SET);
if (input_stream_seek(is, offset, whence)) {
return is->offset;
} else {
return -1;
}
}
static AFvirtualfile *
setup_virtual_fops(struct input_stream *stream)
{
AFvirtualfile *vf = g_malloc(sizeof(AFvirtualfile));
vf->closure = stream;
vf->write = NULL;
vf->read = audiofile_file_read;
vf->length = audiofile_file_length;
vf->destroy = audiofile_file_destroy;
vf->seek = audiofile_file_seek;
vf->tell = audiofile_file_tell;
return vf;
}
static void
audiofile_streamdecode(struct decoder * decoder, struct input_stream *inStream)
{
AFvirtualfile *vf;
int fs, frame_count;
AFfilehandle af_fp;
int bits;
struct audio_format audio_format;
float total_time;
uint16_t bitRate;
struct stat st;
int ret, current = 0;
char chunk[CHUNK_SIZE];
if (stat(path, &st) < 0) {
g_warning("failed to stat: %s\n", path);
return;
}
vf = setup_virtual_fops(inStream);
af_fp = afOpenFile(path, "r", NULL);
af_fp = afOpenVirtualFile(vf, "r", NULL);
if (af_fp == AF_NULL_FILEHANDLE) {
g_warning("failed to open: %s\n", path);
g_warning("failed to input stream\n");
return;
}
@ -89,7 +141,7 @@ audiofile_decode(struct decoder *decoder, const char *path)
total_time = ((float)frame_count / (float)audio_format.sample_rate);
bitRate = (uint16_t)(st.st_size * 8.0 / total_time / 1000.0 + 0.5);
bitRate = (uint16_t)(inStream->size * 8.0 / total_time / 1000.0 + 0.5);
fs = (int)afGetVirtualFrameSize(af_fp, AF_DEFAULT_TRACK, 1);
@ -118,7 +170,7 @@ audiofile_decode(struct decoder *decoder, const char *path)
afCloseFile(af_fp);
}
static struct tag *audiofileTagDup(const char *file)
static struct tag *audiofile_tag_dup(const char *file)
{
struct tag *ret = NULL;
int total_time = getAudiofileTotalTime(file);
@ -134,13 +186,20 @@ static struct tag *audiofileTagDup(const char *file)
return ret;
}
static const char *const audiofileSuffixes[] = {
static const char *const audiofile_suffixes[] = {
"wav", "au", "aiff", "aif", NULL
};
static const char *const audiofile_mime_types[] = {
"audio/x-wav",
"audio/x-aiff",
NULL
};
const struct decoder_plugin audiofilePlugin = {
.name = "audiofile",
.file_decode = audiofile_decode,
.tag_dup = audiofileTagDup,
.suffixes = audiofileSuffixes,
.stream_decode = audiofile_streamdecode,
.tag_dup = audiofile_tag_dup,
.suffixes = audiofile_suffixes,
.mime_types = audiofile_mime_types,
};

12
src/decoder_list.c
View File

@ -18,6 +18,7 @@
#include "decoder_list.h"
#include "decoder_api.h"
#include "utils.h"
#include <glib.h>
@ -76,17 +77,6 @@ enum {
/** which plugins have been initialized successfully? */
static bool decoder_plugins_enabled[num_decoder_plugins];
static int stringFoundInStringArray(const char *const*array, const char *suffix)
{
while (array && *array) {
if (strcasecmp(*array, suffix) == 0)
return 1;
array++;
}
return 0;
}
const struct decoder_plugin *
decoder_plugin_from_suffix(const char *suffix, unsigned int next)
{

2
src/directory.h
View File

@ -34,6 +34,8 @@
#define DIRECTORY_MPD_VERSION "mpd_version: "
#define DIRECTORY_FS_CHARSET "fs_charset: "
#define DEVICE_INARCHIVE (unsigned)(-1)
struct directory {
struct dirvec children;
struct songvec songs;

154
src/input_archive.c Normal file
View File

@ -0,0 +1,154 @@
/* the Music Player Daemon (MPD)
* Copyright (C) 2008 Viliam Mateicka <viliam.mateicka@gmail.com>
* This project's homepage is: http://www.musicpd.org
*
* 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
*/
#include "archive_api.h"
#include "archive_list.h"
#include "input_archive.h"
#include "input_stream.h"
#include "gcc.h"
#include "log.h"
#include "ls.h"
#include "utils.h"
#include <stdbool.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <assert.h>
#include <glib.h>
typedef struct {
const struct archive_plugin *aplugin;
const struct input_plugin *iplugin;
struct archive_file *file;
} archive_context;
/**
* select correct archive plugin to handle the input stream
* may allow stacking of archive plugins. for example for handling
* tar.gz a gzip handler opens file (through inputfile stream)
* then it opens a tar handler and sets gzip inputstream as
* parent_stream so tar plugin fetches file data from gzip
* plugin and gzip fetches file from disk
*/
static bool
input_archive_open(struct input_stream *is, const char *pathname)
{
archive_context *arch_ctx;
const struct archive_plugin *arplug;
char *archive, *filename, *suffix, *pname;
bool opened;
if (pathname[0] != '/')
return false;
pname = g_strdup(pathname);
// archive_lookup will modify pname when true is returned
if (!archive_lookup(pname, &archive, &filename, &suffix)) {
g_debug("not an archive, lookup %s failed\n", pname);
g_free(pname);
return false;
}
//check which archive plugin to use (by ext)
arplug = archive_plugin_from_suffix(suffix);
if (!arplug) {
g_warning("can't handle archive %s\n",archive);
g_free(pname);
return false;
}
arch_ctx = (archive_context *) g_malloc(sizeof(archive_context));
//setup archive plugin pointer
arch_ctx->aplugin = arplug;
//open archive file
arch_ctx->file = arplug->open(archive);
//setup fileops
arplug->setup_stream(arch_ctx->file, is);
//setup input plugin backup
arch_ctx->iplugin = is->plugin;
is->plugin = &input_plugin_archive;
//internal handle
is->data = arch_ctx;
//open archive
opened = arch_ctx->iplugin->open(is, filename);
if (!opened) {
g_warning("open inarchive file %s failed\n\n",filename);
} else {
is->ready = true;
}
g_free(pname);
return opened;
}
static void
input_archive_close(struct input_stream *is)
{
archive_context *arch_ctx = (archive_context *)is->data;
//close archive infile ops
arch_ctx->iplugin->close(is);
//close archive
arch_ctx->aplugin->close(arch_ctx->file);
//free private data
g_free(arch_ctx);
}
static bool
input_archive_seek(struct input_stream *is, off_t offset, int whence)
{
archive_context *arch_ctx = (archive_context *)is->data;
return arch_ctx->iplugin->seek(is, offset, whence);
}
static size_t
input_archive_read(struct input_stream *is, void *ptr, size_t size)
{
archive_context *arch_ctx = (archive_context *)is->data;
assert(ptr != NULL);
assert(size > 0);
return arch_ctx->iplugin->read(is, ptr, size);
}
static bool
input_archive_eof(struct input_stream *is)
{
archive_context *arch_ctx = (archive_context *)is->data;
return arch_ctx->iplugin->eof(is);
}
static int
input_archive_buffer(struct input_stream *is)
{
archive_context *arch_ctx = (archive_context *)is->data;
return arch_ctx->iplugin->buffer(is);
}
const struct input_plugin input_plugin_archive = {
.open = input_archive_open,
.close = input_archive_close,
.buffer = input_archive_buffer,
.read = input_archive_read,
.eof = input_archive_eof,
.seek = input_archive_seek,
};

24
src/input_archive.h Normal file
View File

@ -0,0 +1,24 @@
/* the Music Player Daemon (MPD)
* Copyright (C) 2008 Viliam Mateicka <viliam.mateicka@gmail.com>
* This project's homepage is: http://www.musicpd.org
*
* 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
*/
#ifndef MPD_INPUT_ARCHIVE_H
#define MPD_INPUT_ARCHIVE_H
extern const struct input_plugin input_plugin_archive;
#endif

2
src/input_stream.c
View File

@ -20,6 +20,7 @@
#include "config.h"
#include "input_file.h"
#include "input_archive.h"
#ifdef HAVE_CURL
#include "input_curl.h"
@ -30,6 +31,7 @@
static const struct input_plugin *const input_plugins[] = {
&input_plugin_file,
&input_plugin_archive,
#ifdef HAVE_CURL
&input_plugin_curl,
#endif

2
src/input_stream.h
View File

@ -48,6 +48,8 @@ struct input_stream {
void *data;
char *meta_name;
char *meta_title;
void *archive;
};
void input_stream_global_init(void);

15
src/ls.c
View File

@ -83,3 +83,18 @@ hasMusicSuffix(const char *utf8file, unsigned int next)
return ret;
}
const struct archive_plugin *
get_archive_by_suffix(const char *utf8file)
{
const struct archive_plugin *ret = NULL;
const char *s = getSuffix(utf8file);
if (s) {
ret = archive_plugin_from_suffix(s);
} else {
g_debug("get_archive_by_suffix: The file: %s has no valid suffix\n",
utf8file);
}
return ret;
}

4
src/ls.h
View File

@ -20,6 +20,7 @@
#define MPD_LS_H
#include "decoder_list.h"
#include "archive_list.h"
#include <stdbool.h>
@ -39,6 +40,9 @@ bool isRemoteUrl(const char *url);
const struct decoder_plugin *
hasMusicSuffix(const char *utf8file, unsigned int next);
const struct archive_plugin *
get_archive_by_suffix(const char *utf8file);
void printRemoteUrlHandlers(struct client *client);
#endif

8
src/main.c
View File

@ -40,6 +40,7 @@
#include "permission.h"
#include "replay_gain.h"
#include "decoder_list.h"
#include "archive_list.h"
#include "audioOutput.h"
#include "input_stream.h"
#include "state_file.h"
@ -145,6 +146,11 @@ static void version(void)
puts("\n"
"Supported outputs:\n");
printAllOutputPluginTypes(stdout);
puts("\n"
"Supported archives:\n");
archive_plugin_init_all();
archive_plugin_print_all_suffixes(stdout);
}
static void parseOptions(int argc, char **argv, Options * options)
@ -415,6 +421,7 @@ int main(int argc, char *argv[])
mapper_init();
initPermissions();
initPlaylist();
archive_plugin_init_all();
decoder_plugin_init_all();
update_global_init();
@ -500,6 +507,7 @@ int main(int argc, char *argv[])
command_finish();
update_global_finish();
decoder_plugin_deinit_all();
archive_plugin_deinit_all();
music_pipe_free();
cleanUpPidFile();
finishConf();

35
src/song.c
View File

@ -74,7 +74,12 @@ song_file_load(const char *path, struct directory *parent)
song = song_file_new(path, parent);
ret = song_file_update(song);
//in archive ?
if (parent->device == DEVICE_INARCHIVE) {
ret = song_file_update_inarchive(song);
} else {
ret = song_file_update(song);
}
if (!ret) {
song_free(song);
return NULL;
@ -123,6 +128,34 @@ song_file_update(struct song *song)
return song->tag != NULL;
}
bool
song_file_update_inarchive(struct song *song)
{
char buffer[MPD_PATH_MAX];
const char *path_fs;
const struct decoder_plugin *plugin;
assert(song_is_file(song));
path_fs = map_song_fs(song, buffer);
if (path_fs == NULL)
return false;
if (song->tag != NULL) {
tag_free(song->tag);
song->tag = NULL;
}
//accept every file that has music suffix
//because we dont support tag reading throught
//input streams
plugin = hasMusicSuffix(path_fs, 0);
if (plugin) {
song->tag = tag_new();
//tag_add_item(tag, TAG_ITEM_TITLE, f->title);
}
return song->tag != NULL;
}
char *
song_get_url(const struct song *song, char *path_max_tmp)
{

3
src/song.h
View File

@ -58,6 +58,9 @@ song_free(struct song *song);
bool
song_file_update(struct song *song);
bool
song_file_update_inarchive(struct song *song);
/*
* song_get_url - Returns a path of a song in UTF8-encoded form
* path_max_tmp is the argument that the URL is written to, this

65
src/update.c
View File

@ -276,6 +276,39 @@ make_subdir(struct directory *parent, const char *name)
return directory;
}
static void
update_archive_tree(struct directory *directory, char *name)
{
struct directory *subdir;
struct song *song;
char *tmp;
tmp = strchr(name, '/');
if (tmp) {
*tmp = 0;
//add dir is not there already
if ((subdir = dirvec_find(&directory->children, name)) == NULL) {
//create new directory
subdir = make_subdir(directory, name);
subdir->device = DEVICE_INARCHIVE;
}
//create directories first
update_archive_tree(subdir, tmp+1);
} else {
//add file
song = songvec_find(&directory->songs, name);
if (song == NULL) {
song = song_file_load(name, directory);
if (song != NULL) {
songvec_add(&directory->songs, song);
modified = true;
LOG("added %s/%s\n",
directory_get_path(directory), name);
}
}
}
}
static bool
updateDirectory(struct directory *directory, const struct stat *st);
@ -283,6 +316,7 @@ static void
updateInDirectory(struct directory *directory,
const char *name, const struct stat *st)
{
const struct archive_plugin *archive;
assert(strchr(name, '/') == NULL);
if (S_ISREG(st->st_mode) && hasMusicSuffix(name, 0)) {
@ -317,8 +351,37 @@ updateInDirectory(struct directory *directory,
ret = updateDirectory(subdir, st);
if (!ret)
delete_directory(subdir);
} else if (S_ISREG(st->st_mode) && (archive = get_archive_by_suffix(name))) {
struct archive_file *archfile;
char pathname[MPD_PATH_MAX];
map_directory_child_fs(directory, name, pathname);
//open archive
archfile = archive->open(pathname);
if (archfile) {
char *filepath;
struct directory *archdir;
g_debug("archive %s opened\n",pathname);
archdir = dirvec_find(&directory->children, name);
if (archdir == NULL) {
g_debug("creating archive directory (%s)\n", name);
archdir = make_subdir(directory, name);
//mark this directory as archive (we use device for this)
archdir->device = DEVICE_INARCHIVE;
}
archive->scan_reset(archfile);
while ((filepath = archive->scan_next(archfile)) != NULL) {
//split name into directory and file
g_debug("adding archive file: %s\n", filepath);
update_archive_tree(archdir, filepath);
}
archive->close(archfile);
} else {
g_warning("unable to open archive %s\n", pathname);
}
} else {
DEBUG("update: %s is not a directory or music\n", name);
g_debug("update: %s is not a directory, archive or music\n", name);
}
}

11
src/utils.c
View File

@ -235,3 +235,14 @@ void xpthread_cond_destroy(pthread_cond_t *cond)
if ((err = pthread_cond_destroy(cond)))
FATAL("failed to destroy cond: %s\n", strerror(err));
}
int stringFoundInStringArray(const char *const*array, const char *suffix)
{
while (array && *array) {
if (strcasecmp(*array, suffix) == 0)
return 1;
array++;
}
return 0;
}

2
src/utils.h
View File

@ -108,4 +108,6 @@ void xpthread_mutex_destroy(pthread_mutex_t *mutex);
void xpthread_cond_destroy(pthread_cond_t *cond);
int stringFoundInStringArray(const char *const*array, const char *suffix);
#endif