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

configure.ac

@@ -171,6 +171,52 @@ AC_ARG_ENABLE(mvp,
 
 
 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 ""

src/Makefile.am

@@ -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
 

src/archive/bz2_plugin.c

+/* 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
+};
+

src/archive/iso_plugin.c

+/* 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
+};

src/archive/zip_plugin.c

+/* 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
+};

src/archive_api.c

+/* 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;
+}
+

src/archive_api.h

+/* 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
+

src/archive_internal.h

+/* 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

src/archive_list.c

+
+
+
+/* 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();
+	}
+}
+

src/archive_list.h

+/* 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

src/decoder/audiofile_plugin.c

@@ -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 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_decode(struct decoder *decoder, const char *path)
+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,
 };

src/decoder_list.c

@@ -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)
 {

src/directory.h

@@ -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;

src/input_archive.c

+/* 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,
+};

src/input_archive.h

+/* 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

src/input_stream.c

@@ -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

src/input_stream.h

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

src/ls.c

@@ -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;
+}

src/ls.h

@@ -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

src/main.c

@@ -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();

src/song.c

@@ -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)
 {

src/song.h

@@ -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

src/update.c

@@ -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);
 	}
 }
 

src/utils.c

@@ -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;
+}

src/utils.h

@@ -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