Audio Codec: add tests for AAC, FLAC, MP3, and Tremolo codecs

- AAC encoder test: simple test program that accepts a PCM WAV file,
  encodes, and writes to an AAC file. Output format is fixed at 128000
  sample rate, stereo, ADTS format, AAC-LC
- FLAC encoder/decoder test: port of the libFLAC unit test from libFLAC
  1.2.1, with minor changes to support Android filesystem
- MP3 decoder test: Pulled from
  https://android-review.googlesource.com/#/c/94863/, with minor changes
  for verification of output file
- Tremolo decoder test: a simple test program based off of the
  ivorbisfile example from Tremolo v0.08, modified to output to a PCM
  WAV file. The test program accepts an OGG audio file, decodes it to
  PCM, and writes it to a WAV
- All tests are configured to be built as 32-bit static executables
- linaro-android-userspace-audio-codec-tests.sh: script for automated
  audio codec testing
- Media files for AAC, MP3, and Tremolo tests included

Change-Id: I8166267e732ec3fb41e9133bfca7677e9a8276e0

62 files changed, 14703 insertions, 0 deletions

diff --git a/audio-codec/aac/Android.mk b/audio-codec/aac/Android.mk
new file mode 100644
index 0000000..569e136
--- /dev/null
+++ b/audio-codec/aac/Android.mk
@@ -0,0 +1,20 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+	libaacenc_test.c
+
+LOCAL_C_INCLUDES += \
+	external/aac/libAACenc/include \
+	external/aac/libSYS/include
+
+LOCAL_STATIC_LIBRARIES := libc libFraunhoferAAC
+
+LOCAL_MODULE := libaacenc_test
+LOCAL_MODULE_TAGS := optional tests
+
+LOCAL_MULTILIB := 32
+
+LOCAL_FORCE_STATIC_EXECUTABLE := true
+
+include $(BUILD_EXECUTABLE)
diff --git a/audio-codec/aac/README b/audio-codec/aac/README
new file mode 100644
index 0000000..616e4d9
--- /dev/null
+++ b/audio-codec/aac/README
@@ -0,0 +1,8 @@
+The test media is derived from the song "Retribution" by Tanner Helland in PCM
+WAV format. The file was created by decoding the first 1000 frames of the
+MPEG-3 version of the song.
+
+The original song in MPEG-3 format was obtained from the following site:
+	http://www.tannerhelland.com/52/song-retribution/
+under the Create Commons Attribution-ShareAlike 3.0 License (for more info,
+please visit http://www.tannerhelland.com/52/song-retribution/)
diff --git a/audio-codec/aac/Retribution.wav b/audio-codec/aac/Retribution.wav
new file mode 100644
index 0000000..0c45d19
--- /dev/null
+++ b/audio-codec/aac/Retribution.wav
diff --git a/audio-codec/aac/libaacenc_test.c b/audio-codec/aac/libaacenc_test.c
new file mode 100644
index 0000000..7fd8727
--- /dev/null
+++ b/audio-codec/aac/libaacenc_test.c
@@ -0,0 +1,285 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* 
+ * function: simple AAC encoder
+ *
+ * Takes a PCM WAV file, encodes, and writes to AAC sound file. Output format
+ * is fixed at stereo, 128000 sample rate, AAC-LC, and ADTS foramt.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <aacenc_lib.h>
+#include <wav_file.h>
+
+INT_PCM wav_buf[4096];
+UCHAR aac_buf[2048];
+
+struct timespec timespec_diff(struct timespec *start, struct timespec *end)
+{
+	struct timespec diff;
+
+	if ((end->tv_nsec-start->tv_nsec) < 0) {
+		diff.tv_sec=end->tv_sec-start->tv_sec-1;
+		diff.tv_nsec=1000000000+end->tv_nsec-start->tv_nsec;
+	} else {
+		diff.tv_sec=end->tv_sec-start->tv_sec;
+		diff.tv_nsec=end->tv_nsec-start->tv_nsec;
+	}
+	return diff;
+}
+
+
+static int aac_enc_init(HANDLE_AACENCODER *encoder, WAV_HEADER *wav_header)
+{
+	if (AACENC_OK != aacEncOpen(encoder, 0, wav_header->numChannels)) {
+		fprintf(stderr, "Failed to open AAC encoder\n");
+		return -1;
+	}
+
+	if (AACENC_OK != aacEncoder_SetParam(*encoder, AACENC_AOT, AOT_AAC_LC)) {
+		fprintf(stderr, "Failed to set AAC encoder parameters\n");
+		goto close_encoder;
+	}
+	if (AACENC_OK != aacEncoder_SetParam(*encoder, AACENC_BITRATE, 128000)) {
+		fprintf(stderr, "Failed to set AAC encoder parameters\n");
+		goto close_encoder;
+	}
+	if (AACENC_OK != aacEncoder_SetParam(*encoder, AACENC_SAMPLERATE,
+						wav_header->sampleRate)) {
+		fprintf(stderr, "Failed to set AAC encoder parameters\n");
+		goto close_encoder;
+	}
+	if (AACENC_OK != aacEncoder_SetParam(*encoder, AACENC_CHANNELMODE,
+						MODE_2)) {
+		fprintf(stderr, "Failed to set AAC encoder parameters\n");
+		goto close_encoder;
+	}
+	if (AACENC_OK != aacEncoder_SetParam(*encoder, AACENC_TRANSMUX,
+						TT_MP4_ADTS)) {
+		fprintf(stderr, "Failed to set AAC encoder parameters\n");
+		goto close_encoder;
+	}
+	if (AACENC_OK != aacEncEncode(*encoder, NULL, NULL, NULL, NULL)) {
+		fprintf(stderr, "Failed to initalize AAC encoder parameters\n");
+		goto close_encoder;
+	}
+
+	return 0;
+
+close_encoder:
+	aacEncClose(encoder);
+	return -1;
+}
+
+static int aac_enc_encode(HANDLE_AACENCODER encoder, int samples)
+{
+	AACENC_InArgs inargs;
+	AACENC_OutArgs outargs;
+	memset(&inargs, 0, sizeof(inargs));
+	memset(&outargs, 0, sizeof(outargs));
+	inargs.numInSamples = samples;
+
+	void *inBuffer[]     = { wav_buf };
+	INT inBufferIds[]    = { IN_AUDIO_DATA };
+	INT inBufferSize[]   = { sizeof(wav_buf) };
+	INT inBufferElSize[] = { sizeof(INT_PCM) };
+
+	AACENC_BufDesc inBufDesc = { 0 };
+	inBufDesc.numBufs           = sizeof(inBuffer) / sizeof(void *);
+	inBufDesc.bufs              = (void **)&inBuffer;
+	inBufDesc.bufferIdentifiers = inBufferIds;
+	inBufDesc.bufSizes          = inBufferSize;
+	inBufDesc.bufElSizes        = inBufferElSize;
+
+	UCHAR *out_ptr = aac_buf;
+	INT out_avail = sizeof(aac_buf);
+
+	void* outBuffer[]       = { out_ptr };
+	INT   outBufferIds[]    = { OUT_BITSTREAM_DATA };
+	INT   outBufferSize[]   = { 0 };
+	INT   outBufferElSize[] = { sizeof(UCHAR) };
+
+	AACENC_BufDesc outBufDesc = { 0 };
+	outBufDesc.numBufs           = sizeof(outBuffer) / sizeof(void*);
+	outBufDesc.bufs              = (void**)&outBuffer;
+	outBufDesc.bufferIdentifiers = outBufferIds;
+	outBufDesc.bufSizes          = outBufferSize;
+	outBufDesc.bufElSizes        = outBufferElSize;
+
+	AACENC_ERROR err;
+	INT out_bytes = 0;
+	do {
+		memset(&outargs, 0, sizeof(outargs));
+		outBuffer[0] = out_ptr;
+		outBufferSize[0] = out_avail - out_bytes;
+
+		err = aacEncEncode(encoder, &inBufDesc, &outBufDesc, &inargs,
+					&outargs);
+		if (err == AACENC_OK) {
+			out_ptr += outargs.numOutBytes;
+			out_bytes += outargs.numOutBytes;
+
+			if (outargs.numInSamples > 0) {
+				int numRemainingSamples = inargs.numInSamples -
+							outargs.numInSamples;
+				if (numRemainingSamples > 0) {
+					memmove(wav_buf,
+						&wav_buf[outargs.numInSamples],
+						sizeof(INT_PCM) *
+						numRemainingSamples);
+				}
+				inargs.numInSamples -= outargs.numInSamples;
+			}
+		}
+	} while (err == AACENC_OK && inargs.numInSamples > 0);
+
+	return out_bytes;
+}
+
+/*
+ * aac_encode - Encode a PCM file into an AAC file
+ */
+static int aac_encode(HANDLE_WAV wav_file, FILE *aac_file)
+{
+	HANDLE_AACENCODER encoder;
+
+	if ((wav_file == NULL) || (aac_file == NULL))
+		return -1;
+
+	/* Initialize the encoder */
+	if (aac_enc_init(&encoder, &wav_file->header)) {
+		return -1;
+	}
+
+	/* Allocate AAC buffer here */
+	AACENC_InfoStruct enc_info;
+	if (AACENC_OK != aacEncInfo(encoder, &enc_info)) {
+		fprintf(stderr, "Failed to get encoder info\n");
+		aacEncClose(&encoder);
+		return -1;
+	} else {
+		printf("Encoder information:\n");
+		printf("\tmaxOutBufBytes: %u\n", enc_info.maxOutBufBytes);
+		printf("\tmaxAncBytes: %u\n", enc_info.maxAncBytes);
+		printf("\tinBufFillLevel: %u\n", enc_info.inBufFillLevel);
+		printf("\tinputChannels: %u\n", enc_info.inputChannels);
+		printf("\tframeLength: %u\n", enc_info.frameLength);
+		printf("\tencoderDelay: %u\n", enc_info.encoderDelay);
+	}
+
+	/* Main encoding loop */
+	while (1) {
+		static int total_bytes = 0;
+		/* Note: frame = sample (16 bit) * numChannels */
+		static int total_samples = 0;
+		int samples = WAV_InputRead(wav_file, wav_buf,
+					FDKmin(enc_info.inputChannels *
+						enc_info.frameLength,
+						sizeof(wav_buf) /
+						sizeof(INT_PCM)),
+					SAMPLE_BITS);
+		if (samples == 0) {
+			printf("Total samples extracted %d\n", total_samples);
+			printf("Total encoded bytes %d\n", total_bytes);
+			break;
+		}
+
+		int bytes = aac_enc_encode(encoder, samples);
+		fwrite(aac_buf, 1, bytes, aac_file);
+
+		total_samples += samples;
+		total_bytes += bytes;
+	}
+
+	aacEncClose(&encoder);
+
+	return 0;
+}
+
+int main(int argc, const char **argv)
+{
+	int ret = -1;
+	HANDLE_WAV wav_file;
+	FILE *aac_file;
+
+	if (argc != 3) {
+		fprintf(stderr, "Usage %s <input_pcm_wav_file> <output_raw_aac_file>\n",
+			argv[0]);
+		goto out;
+	}
+
+	/* Open the input file */
+	if (WAV_InputOpen(&wav_file, argv[1])){
+		fprintf(stderr, "Invalid input file %s\n", argv[1]);
+		goto out;
+	}
+
+	printf("Input file information:\n");
+	printf("\tsample rate: %d\n", wav_file->header.sampleRate);
+	printf("\tchannels: %d\n", wav_file->header.numChannels);
+	printf("\tbits per sample: %d\n", wav_file->header.bitsPerSample);
+	printf("\tdata size: %d\n", wav_file->header.dataSize);
+
+	/* Open the output file */
+	aac_file = fopen(argv[2], "wb");
+	if (!aac_file) {
+		fprintf(stderr, "Failed to open output file %s\n", argv[2]);
+		goto close_infile;
+	}
+
+	/* Track the total time it took to decode */
+	struct timespec start_time;
+	struct timespec end_time;
+	int track_time = 1;
+	if (clock_gettime(CLOCK_MONOTONIC, &start_time)) {
+		fprintf(stderr, "Failed to get start time for profiling\n");
+		track_time = 0;
+	}
+
+	ret = aac_encode(wav_file, aac_file);
+
+	if (!ret && track_time) {
+		if (clock_gettime(CLOCK_MONOTONIC,&end_time)) {
+			printf("Failed to get end time for profiling\n");
+		} else {
+			struct timespec diff=timespec_diff(&start_time,&end_time);
+			printf("Total encode time: %ld.%09ld seconds\n",
+				diff.tv_sec, diff.tv_nsec);
+		}
+	}
+
+	/* Clean up */
+	fclose(aac_file);
+close_infile:
+	WAV_InputClose(&wav_file);
+out:
+	return ret;
+}
diff --git a/audio-codec/common/Android.mk b/audio-codec/common/Android.mk
new file mode 100644
index 0000000..c0ed917
--- /dev/null
+++ b/audio-codec/common/Android.mk
@@ -0,0 +1,14 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libaudioprimitives
+LOCAL_MODULE_TAGS := optional tests
+
+LOCAL_SRC_FILES := \
+       ../../../../system/media/audio_utils/primitives.c
+
+LOCAL_C_INCLUDES += \
+       $(call include-path-for, audio-utils)
+
+include $(BUILD_STATIC_LIBRARY)
+
diff --git a/audio-codec/flac/Android.mk b/audio-codec/flac/Android.mk
new file mode 100644
index 0000000..14097f7
--- /dev/null
+++ b/audio-codec/flac/Android.mk
@@ -0,0 +1,39 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+	test_libFLAC/bitwriter.c \
+	test_libFLAC/decoders.c \
+	test_libFLAC/encoders.c \
+	test_libFLAC/format.c \
+	test_libFLAC/main.c
+
+LOCAL_SRC_FILES += \
+	test_libs_common/file_utils_flac.c \
+	test_libs_common/metadata_utils.c
+
+LOCAL_SRC_FILES += \
+	grabbag/file.c
+
+LOCAL_C_INCLUDES += \
+	$(LOCAL_PATH)/include \
+	external/flac \
+	external/flac/include \
+	external/flac/libFLAC/include
+
+LOCAL_CFLAGS += -DHAVE_CONFIG_H -DFLAC__NO_MD5 -DFLAC__INTEGER_ONLY_LIBRARY
+LOCAL_CFLAGS += -D_REENTRANT -DPIC -DU_COMMON_IMPLEMENTATION -fPIC
+LOCAL_CFLAGS += -O3 -funroll-loops -finline-functions -DFLAC__NO_METADATA
+
+LOCAL_STATIC_LIBRARIES := libc libFLAC
+
+LOCAL_ARM_MODE := arm
+
+LOCAL_MODULE := libFLAC_test
+LOCAL_MODULE_TAGS := optional tests
+
+LOCAL_MULTILIB := 32
+
+LOCAL_FORCE_STATIC_EXECUTABLE := true
+
+include $(BUILD_EXECUTABLE)
diff --git a/audio-codec/flac/grabbag/Makefile.am b/audio-codec/flac/grabbag/Makefile.am
new file mode 100644
index 0000000..879b155
--- /dev/null
+++ b/audio-codec/flac/grabbag/Makefile.am
@@ -0,0 +1,25 @@
+## Process this file with automake to produce Makefile.in
+
+AUTOMAKE_OPTIONS = foreign
+
+INCLUDES = -I$(top_srcdir)/include
+
+noinst_LTLIBRARIES = libgrabbag.la
+
+libgrabbag_la_SOURCES = \
+	cuesheet.c \
+	file.c \
+	picture.c \
+	replaygain.c \
+	seektable.c
+
+EXTRA_DIST = \
+	Makefile.lite \
+	grabbag_static.dsp \
+	grabbag_static.vcproj
+
+debug:
+	$(MAKE) all CFLAGS="@DEBUG@"
+
+profile:
+	$(MAKE) all CFLAGS="@PROFILE@"
diff --git a/audio-codec/flac/grabbag/Makefile.in b/audio-codec/flac/grabbag/Makefile.in
new file mode 100644
index 0000000..a7780a3
--- /dev/null
+++ b/audio-codec/flac/grabbag/Makefile.in
@@ -0,0 +1,512 @@
+# Makefile.in generated by automake 1.7.9 from Makefile.am.
+# @configure_input@
+
+# Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
+# Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+top_builddir = ../../..
+
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+INSTALL = @INSTALL@
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+host_triplet = @host@
+ACLOCAL = @ACLOCAL@
+ACLOCAL_AMFLAGS = @ACLOCAL_AMFLAGS@
+AMDEP_FALSE = @AMDEP_FALSE@
+AMDEP_TRUE = @AMDEP_TRUE@
+AMTAR = @AMTAR@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCAS = @CCAS@
+CCASFLAGS = @CCASFLAGS@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEBUG_FALSE = @DEBUG_FALSE@
+DEBUG_TRUE = @DEBUG_TRUE@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DOCBOOK_TO_MAN = @DOCBOOK_TO_MAN@
+DOXYGEN = @DOXYGEN@
+ECHO = @ECHO@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+F77 = @F77@
+FFLAGS = @FFLAGS@
+FLAC__TEST_LEVEL = @FLAC__TEST_LEVEL@
+FLAC__TEST_WITH_VALGRIND = @FLAC__TEST_WITH_VALGRIND@
+FLaC__CPU_IA32_FALSE = @FLaC__CPU_IA32_FALSE@
+FLaC__CPU_IA32_TRUE = @FLaC__CPU_IA32_TRUE@
+FLaC__CPU_PPC_FALSE = @FLaC__CPU_PPC_FALSE@
+FLaC__CPU_PPC_TRUE = @FLaC__CPU_PPC_TRUE@
+FLaC__CPU_SPARC_FALSE = @FLaC__CPU_SPARC_FALSE@
+FLaC__CPU_SPARC_TRUE = @FLaC__CPU_SPARC_TRUE@
+FLaC__HAS_AS_FALSE = @FLaC__HAS_AS_FALSE@
+FLaC__HAS_AS_TRUE = @FLaC__HAS_AS_TRUE@
+FLaC__HAS_AS__TEMPORARILY_DISABLED_FALSE = @FLaC__HAS_AS__TEMPORARILY_DISABLED_FALSE@
+FLaC__HAS_AS__TEMPORARILY_DISABLED_TRUE = @FLaC__HAS_AS__TEMPORARILY_DISABLED_TRUE@
+FLaC__HAS_DOCBOOK_TO_MAN_FALSE = @FLaC__HAS_DOCBOOK_TO_MAN_FALSE@
+FLaC__HAS_DOCBOOK_TO_MAN_TRUE = @FLaC__HAS_DOCBOOK_TO_MAN_TRUE@
+FLaC__HAS_DOXYGEN_FALSE = @FLaC__HAS_DOXYGEN_FALSE@
+FLaC__HAS_DOXYGEN_TRUE = @FLaC__HAS_DOXYGEN_TRUE@
+FLaC__HAS_GAS_FALSE = @FLaC__HAS_GAS_FALSE@
+FLaC__HAS_GAS_TRUE = @FLaC__HAS_GAS_TRUE@
+FLaC__HAS_GAS__TEMPORARILY_DISABLED_FALSE = @FLaC__HAS_GAS__TEMPORARILY_DISABLED_FALSE@
+FLaC__HAS_GAS__TEMPORARILY_DISABLED_TRUE = @FLaC__HAS_GAS__TEMPORARILY_DISABLED_TRUE@
+FLaC__HAS_NASM_FALSE = @FLaC__HAS_NASM_FALSE@
+FLaC__HAS_NASM_TRUE = @FLaC__HAS_NASM_TRUE@
+FLaC__HAS_OGG_FALSE = @FLaC__HAS_OGG_FALSE@
+FLaC__HAS_OGG_TRUE = @FLaC__HAS_OGG_TRUE@
+FLaC__HAS_XMMS_FALSE = @FLaC__HAS_XMMS_FALSE@
+FLaC__HAS_XMMS_TRUE = @FLaC__HAS_XMMS_TRUE@
+FLaC__INSTALL_XMMS_PLUGIN_LOCALLY_FALSE = @FLaC__INSTALL_XMMS_PLUGIN_LOCALLY_FALSE@
+FLaC__INSTALL_XMMS_PLUGIN_LOCALLY_TRUE = @FLaC__INSTALL_XMMS_PLUGIN_LOCALLY_TRUE@
+FLaC__NO_ASM_FALSE = @FLaC__NO_ASM_FALSE@
+FLaC__NO_ASM_TRUE = @FLaC__NO_ASM_TRUE@
+FLaC__SSE_OS_FALSE = @FLaC__SSE_OS_FALSE@
+FLaC__SSE_OS_TRUE = @FLaC__SSE_OS_TRUE@
+FLaC__SYS_DARWIN_FALSE = @FLaC__SYS_DARWIN_FALSE@
+FLaC__SYS_DARWIN_TRUE = @FLaC__SYS_DARWIN_TRUE@
+FLaC__SYS_LINUX_FALSE = @FLaC__SYS_LINUX_FALSE@
+FLaC__SYS_LINUX_TRUE = @FLaC__SYS_LINUX_TRUE@
+FLaC__USE_3DNOW_FALSE = @FLaC__USE_3DNOW_FALSE@
+FLaC__USE_3DNOW_TRUE = @FLaC__USE_3DNOW_TRUE@
+FLaC__USE_ALTIVEC_FALSE = @FLaC__USE_ALTIVEC_FALSE@
+FLaC__USE_ALTIVEC_TRUE = @FLaC__USE_ALTIVEC_TRUE@
+FLaC__WITH_CPPLIBS_FALSE = @FLaC__WITH_CPPLIBS_FALSE@
+FLaC__WITH_CPPLIBS_TRUE = @FLaC__WITH_CPPLIBS_TRUE@
+GAS = @GAS@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LDFLAGS = @LDFLAGS@
+LIBICONV = @LIBICONV@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LN_S = @LN_S@
+LTLIBICONV = @LTLIBICONV@
+LTLIBOBJS = @LTLIBOBJS@
+MAINT = @MAINT@
+MAINTAINER_MODE_FALSE = @MAINTAINER_MODE_FALSE@
+MAINTAINER_MODE_TRUE = @MAINTAINER_MODE_TRUE@
+MAKEINFO = @MAKEINFO@
+MINGW_WINSOCK_LIBS = @MINGW_WINSOCK_LIBS@
+NASM = @NASM@
+OBJEXT = @OBJEXT@
+OBJ_FORMAT = @OBJ_FORMAT@
+OGG_CFLAGS = @OGG_CFLAGS@
+OGG_LIBS = @OGG_LIBS@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+RANLIB = @RANLIB@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+XMMS_CFLAGS = @XMMS_CFLAGS@
+XMMS_CONFIG = @XMMS_CONFIG@
+XMMS_DATA_DIR = @XMMS_DATA_DIR@
+XMMS_EFFECT_PLUGIN_DIR = @XMMS_EFFECT_PLUGIN_DIR@
+XMMS_GENERAL_PLUGIN_DIR = @XMMS_GENERAL_PLUGIN_DIR@
+XMMS_INPUT_PLUGIN_DIR = @XMMS_INPUT_PLUGIN_DIR@
+XMMS_LIBS = @XMMS_LIBS@
+XMMS_OUTPUT_PLUGIN_DIR = @XMMS_OUTPUT_PLUGIN_DIR@
+XMMS_PLUGIN_DIR = @XMMS_PLUGIN_DIR@
+XMMS_VERSION = @XMMS_VERSION@
+XMMS_VISUALIZATION_PLUGIN_DIR = @XMMS_VISUALIZATION_PLUGIN_DIR@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_F77 = @ac_ct_F77@
+ac_ct_RANLIB = @ac_ct_RANLIB@
+ac_ct_STRIP = @ac_ct_STRIP@
+am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+am__fastdepCXX_FALSE = @am__fastdepCXX_FALSE@
+am__fastdepCXX_TRUE = @am__fastdepCXX_TRUE@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+datadir = @datadir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+oldincludedir = @oldincludedir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+
+AUTOMAKE_OPTIONS = foreign
+
+INCLUDES = -I$(top_srcdir)/include
+
+noinst_LTLIBRARIES = libgrabbag.la
+
+libgrabbag_la_SOURCES = \
+	cuesheet.c \
+	file.c \
+	picture.c \
+	replaygain.c \
+	seektable.c
+
+
+EXTRA_DIST = \
+	Makefile.lite \
+	grabbag_static.dsp \
+	grabbag_static.vcproj
+
+subdir = src/share/grabbag
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+LTLIBRARIES = $(noinst_LTLIBRARIES)
+
+libgrabbag_la_LDFLAGS =
+libgrabbag_la_LIBADD =
+am_libgrabbag_la_OBJECTS = cuesheet.lo file.lo picture.lo replaygain.lo \
+	seektable.lo
+libgrabbag_la_OBJECTS = $(am_libgrabbag_la_OBJECTS)
+
+DEFAULT_INCLUDES =  -I. -I$(srcdir) -I$(top_builddir)
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+@AMDEP_TRUE@DEP_FILES = ./$(DEPDIR)/cuesheet.Plo ./$(DEPDIR)/file.Plo \
+@AMDEP_TRUE@	./$(DEPDIR)/picture.Plo ./$(DEPDIR)/replaygain.Plo \
+@AMDEP_TRUE@	./$(DEPDIR)/seektable.Plo
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) \
+	$(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(LIBTOOL) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(AM_LDFLAGS) $(LDFLAGS) -o $@
+DIST_SOURCES = $(libgrabbag_la_SOURCES)
+DIST_COMMON = $(srcdir)/Makefile.in Makefile.am
+SOURCES = $(libgrabbag_la_SOURCES)
+
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ Makefile.am  $(top_srcdir)/configure.in $(ACLOCAL_M4)
+	cd $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign  src/share/grabbag/Makefile
+Makefile: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.in  $(top_builddir)/config.status
+	cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)
+
+clean-noinstLTLIBRARIES:
+	-test -z "$(noinst_LTLIBRARIES)" || rm -f $(noinst_LTLIBRARIES)
+	@list='$(noinst_LTLIBRARIES)'; for p in $$list; do \
+	  dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
+	  test "$$dir" = "$$p" && dir=.; \
+	  echo "rm -f \"$${dir}/so_locations\""; \
+	  rm -f "$${dir}/so_locations"; \
+	done
+libgrabbag.la: $(libgrabbag_la_OBJECTS) $(libgrabbag_la_DEPENDENCIES) 
+	$(LINK)  $(libgrabbag_la_LDFLAGS) $(libgrabbag_la_OBJECTS) $(libgrabbag_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT) core *.core
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cuesheet.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/file.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/picture.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/replaygain.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/seektable.Plo@am__quote@
+
+.c.o:
+@am__fastdepCC_TRUE@	if $(COMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" \
+@am__fastdepCC_TRUE@	  -c -o $@ `test -f '$<' || echo '$(srcdir)/'`$<; \
+@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; \
+@am__fastdepCC_TRUE@	else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; \
+@am__fastdepCC_TRUE@	fi
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c `test -f '$<' || echo '$(srcdir)/'`$<
+
+.c.obj:
+@am__fastdepCC_TRUE@	if $(COMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" \
+@am__fastdepCC_TRUE@	  -c -o $@ `if test -f '$<'; then $(CYGPATH_W) '$<'; else $(CYGPATH_W) '$(srcdir)/$<'; fi`; \
+@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; \
+@am__fastdepCC_TRUE@	else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; \
+@am__fastdepCC_TRUE@	fi
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c `if test -f '$<'; then $(CYGPATH_W) '$<'; else $(CYGPATH_W) '$(srcdir)/$<'; fi`
+
+.c.lo:
+@am__fastdepCC_TRUE@	if $(LTCOMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" \
+@am__fastdepCC_TRUE@	  -c -o $@ `test -f '$<' || echo '$(srcdir)/'`$<; \
+@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Plo"; \
+@am__fastdepCC_TRUE@	else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; \
+@am__fastdepCC_TRUE@	fi
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	depfile='$(DEPDIR)/$*.Plo' tmpdepfile='$(DEPDIR)/$*.TPlo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LTCOMPILE) -c -o $@ `test -f '$<' || echo '$(srcdir)/'`$<
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+distclean-libtool:
+	-rm -f libtool
+uninstall-info-am:
+
+ETAGS = etags
+ETAGSFLAGS =
+
+CTAGS = ctags
+CTAGSFLAGS =
+
+tags: TAGS
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	mkid -fID $$unique
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(ETAGS_ARGS)$$tags$$unique" \
+	  || $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	     $$tags $$unique
+
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(CTAGS_ARGS)$$tags$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$tags $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && cd $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) $$here
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+
+top_distdir = ../../..
+distdir = $(top_distdir)/$(PACKAGE)-$(VERSION)
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \
+	list='$(DISTFILES)'; for file in $$list; do \
+	  case $$file in \
+	    $(srcdir)/*) file=`echo "$$file" | sed "s|^$$srcdirstrip/||"`;; \
+	    $(top_srcdir)/*) file=`echo "$$file" | sed "s|^$$topsrcdirstrip/|$(top_builddir)/|"`;; \
+	  esac; \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \
+	  if test "$$dir" != "$$file" && test "$$dir" != "."; then \
+	    dir="/$$dir"; \
+	    $(mkinstalldirs) "$(distdir)$$dir"; \
+	  else \
+	    dir=''; \
+	  fi; \
+	  if test -d $$d/$$file; then \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
+	    fi; \
+	    cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
+	  else \
+	    test -f $(distdir)/$$file \
+	    || cp -p $$d/$$file $(distdir)/$$file \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES)
+
+installdirs:
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-rm -f $(CONFIG_CLEAN_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool clean-noinstLTLIBRARIES \
+	mostlyclean-am
+
+distclean: distclean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-libtool distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-exec-am:
+
+install-info: install-info-am
+
+install-man:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-info-am
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
+	clean-libtool clean-noinstLTLIBRARIES ctags distclean \
+	distclean-compile distclean-generic distclean-libtool \
+	distclean-tags distdir dvi dvi-am info info-am install \
+	install-am install-data install-data-am install-exec \
+	install-exec-am install-info install-info-am install-man \
+	install-strip installcheck installcheck-am installdirs \
+	maintainer-clean maintainer-clean-generic mostlyclean \
+	mostlyclean-compile mostlyclean-generic mostlyclean-libtool pdf \
+	pdf-am ps ps-am tags uninstall uninstall-am uninstall-info-am
+
+
+debug:
+	$(MAKE) all CFLAGS="@DEBUG@"
+
+profile:
+	$(MAKE) all CFLAGS="@PROFILE@"
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/audio-codec/flac/grabbag/Makefile.lite b/audio-codec/flac/grabbag/Makefile.lite
new file mode 100644
index 0000000..daf1975
--- /dev/null
+++ b/audio-codec/flac/grabbag/Makefile.lite
@@ -0,0 +1,19 @@
+#
+# GNU makefile
+#
+
+topdir = ../../..
+
+LIB_NAME = libgrabbag
+INCLUDES = -I$(topdir)/include
+
+SRCS_C = \
+	cuesheet.c \
+	file.c \
+	picture.c \
+	replaygain.c \
+	seektable.c
+
+include $(topdir)/build/lib.mk
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
diff --git a/audio-codec/flac/grabbag/cuesheet.c b/audio-codec/flac/grabbag/cuesheet.c
new file mode 100644
index 0000000..03f7cda
--- /dev/null
+++ b/audio-codec/flac/grabbag/cuesheet.c
@@ -0,0 +1,611 @@
+/* grabbag - Convenience lib for various routines common to several tools
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "share/grabbag.h"
+#include "FLAC/assert.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+unsigned grabbag__cuesheet_msf_to_frame(unsigned minutes, unsigned seconds, unsigned frames)
+{
+	return ((minutes * 60) + seconds) * 75 + frames;
+}
+
+void grabbag__cuesheet_frame_to_msf(unsigned frame, unsigned *minutes, unsigned *seconds, unsigned *frames)
+{
+	*frames = frame % 75;
+	frame /= 75;
+	*seconds = frame % 60;
+	frame /= 60;
+	*minutes = frame;
+}
+
+/* since we only care about values >= 0 or error, returns < 0 for any illegal string, else value */
+static int local__parse_int_(const char *s)
+{
+	int ret = 0;
+	char c;
+
+	if(*s == '\0')
+		return -1;
+
+	while('\0' != (c = *s++))
+		if(c >= '0' && c <= '9')
+			ret = ret * 10 + (c - '0');
+		else
+			return -1;
+
+	return ret;
+}
+
+/* since we only care about values >= 0 or error, returns < 0 for any illegal string, else value */
+static FLAC__int64 local__parse_int64_(const char *s)
+{
+	FLAC__int64 ret = 0;
+	char c;
+
+	if(*s == '\0')
+		return -1;
+
+	while('\0' != (c = *s++))
+		if(c >= '0' && c <= '9')
+			ret = ret * 10 + (c - '0');
+		else
+			return -1;
+
+	return ret;
+}
+
+/* accept '[0-9]+:[0-9][0-9]?:[0-9][0-9]?', but max second of 59 and max frame of 74, e.g. 0:0:0, 123:45:67
+ * return sample number or <0 for error
+ */
+static FLAC__int64 local__parse_msf_(const char *s)
+{
+	FLAC__int64 ret, field;
+	char c;
+
+	c = *s++;
+	if(c >= '0' && c <= '9')
+		field = (c - '0');
+	else
+		return -1;
+	while(':' != (c = *s++)) {
+		if(c >= '0' && c <= '9')
+			field = field * 10 + (c - '0');
+		else
+			return -1;
+	}
+
+	ret = field * 60 * 44100;
+
+	c = *s++;
+	if(c >= '0' && c <= '9')
+		field = (c - '0');
+	else
+		return -1;
+	if(':' != (c = *s++)) {
+		if(c >= '0' && c <= '9') {
+			field = field * 10 + (c - '0');
+			c = *s++;
+			if(c != ':')
+				return -1;
+		}
+		else
+			return -1;
+	}
+
+	if(field >= 60)
+		return -1;
+
+	ret += field * 44100;
+
+	c = *s++;
+	if(c >= '0' && c <= '9')
+		field = (c - '0');
+	else
+		return -1;
+	if('\0' != (c = *s++)) {
+		if(c >= '0' && c <= '9') {
+			field = field * 10 + (c - '0');
+			c = *s++;
+		}
+		else
+			return -1;
+	}
+
+	if(c != '\0')
+		return -1;
+
+	if(field >= 75)
+		return -1;
+
+	ret += field * (44100 / 75);
+
+	return ret;
+}
+
+static char *local__get_field_(char **s, FLAC__bool allow_quotes)
+{
+	FLAC__bool has_quote = false;
+	char *p;
+
+	FLAC__ASSERT(0 != s);
+
+	if(0 == *s)
+		return 0;
+
+	/* skip leading whitespace */
+	while(**s && 0 != strchr(" \t\r\n", **s))
+		(*s)++;
+
+	if(**s == 0) {
+		*s = 0;
+		return 0;
+	}
+
+	if(allow_quotes && (**s == '"')) {
+		has_quote = true;
+		(*s)++;
+		if(**s == 0) {
+			*s = 0;
+			return 0;
+		}
+	}
+
+	p = *s;
+
+	if(has_quote) {
+		*s = strchr(*s, '\"');
+		/* if there is no matching end quote, it's an error */
+		if(0 == *s)
+			p = *s = 0;
+		else {
+			**s = '\0';
+			(*s)++;
+		}
+	}
+	else {
+		while(**s && 0 == strchr(" \t\r\n", **s))
+			(*s)++;
+		if(**s) {
+			**s = '\0';
+			(*s)++;
+		}
+		else
+			*s = 0;
+	}
+
+	return p;
+}
+
+static FLAC__bool local__cuesheet_parse_(FILE *file, const char **error_message, unsigned *last_line_read, FLAC__StreamMetadata *cuesheet, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset)
+{
+#if defined _MSC_VER || defined __MINGW32__ || defined __EMX__
+#define FLAC__STRCASECMP stricmp
+#else
+#define FLAC__STRCASECMP strcasecmp
+#endif
+	char buffer[4096], *line, *field;
+	unsigned forced_leadout_track_num = 0;
+	FLAC__uint64 forced_leadout_track_offset = 0;
+	int in_track_num = -1, in_index_num = -1;
+	FLAC__bool disc_has_catalog = false, track_has_flags = false, track_has_isrc = false, has_forced_leadout = false;
+	FLAC__StreamMetadata_CueSheet *cs = &cuesheet->data.cue_sheet;
+
+	cs->lead_in = is_cdda? 2 * 44100 /* The default lead-in size for CD-DA */ : 0;
+	cs->is_cd = is_cdda;
+
+	while(0 != fgets(buffer, sizeof(buffer), file)) {
+		(*last_line_read)++;
+		line = buffer;
+
+		{
+			size_t linelen = strlen(line);
+			if((linelen == sizeof(buffer)-1) && line[linelen-1] != '\n') {
+				*error_message = "line too long";
+				return false;
+			}
+		}
+
+		if(0 != (field = local__get_field_(&line, /*allow_quotes=*/false))) {
+			if(0 == FLAC__STRCASECMP(field, "CATALOG")) {
+				if(disc_has_catalog) {
+					*error_message = "found multiple CATALOG commands";
+					return false;
+				}
+				if(0 == (field = local__get_field_(&line, /*allow_quotes=*/true))) {
+					*error_message = "CATALOG is missing catalog number";
+					return false;
+				}
+				if(strlen(field) >= sizeof(cs->media_catalog_number)) {
+					*error_message = "CATALOG number is too long";
+					return false;
+				}
+				if(is_cdda && (strlen(field) != 13 || strspn(field, "0123456789") != 13)) {
+					*error_message = "CD-DA CATALOG number must be 13 decimal digits";
+					return false;
+				}
+				strcpy(cs->media_catalog_number, field);
+				disc_has_catalog = true;
+			}
+			else if(0 == FLAC__STRCASECMP(field, "FLAGS")) {
+				if(track_has_flags) {
+					*error_message = "found multiple FLAGS commands";
+					return false;
+				}
+				if(in_track_num < 0 || in_index_num >= 0) {
+					*error_message = "FLAGS command must come after TRACK but before INDEX";
+					return false;
+				}
+				while(0 != (field = local__get_field_(&line, /*allow_quotes=*/false))) {
+					if(0 == FLAC__STRCASECMP(field, "PRE"))
+						cs->tracks[cs->num_tracks-1].pre_emphasis = 1;
+				}
+				track_has_flags = true;
+			}
+			else if(0 == FLAC__STRCASECMP(field, "INDEX")) {
+				FLAC__int64 xx;
+				FLAC__StreamMetadata_CueSheet_Track *track = &cs->tracks[cs->num_tracks-1];
+				if(in_track_num < 0) {
+					*error_message = "found INDEX before any TRACK";
+					return false;
+				}
+				if(0 == (field = local__get_field_(&line, /*allow_quotes=*/false))) {
+					*error_message = "INDEX is missing index number";
+					return false;
+				}
+				in_index_num = local__parse_int_(field);
+				if(in_index_num < 0) {
+					*error_message = "INDEX has invalid index number";
+					return false;
+				}
+				FLAC__ASSERT(cs->num_tracks > 0);
+				if(track->num_indices == 0) {
+					/* it's the first index point of the track */
+					if(in_index_num > 1) {
+						*error_message = "first INDEX number of a TRACK must be 0 or 1";
+						return false;
+					}
+				}
+				else {
+					if(in_index_num != track->indices[track->num_indices-1].number + 1) {
+						*error_message = "INDEX numbers must be sequential";
+						return false;
+					}
+				}
+				if(is_cdda && in_index_num > 99) {
+					*error_message = "CD-DA INDEX number must be between 0 and 99, inclusive";
+					return false;
+				}
+				/*@@@ search for duplicate track number? */
+				if(0 == (field = local__get_field_(&line, /*allow_quotes=*/false))) {
+					*error_message = "INDEX is missing an offset after the index number";
+					return false;
+				}
+				xx = local__parse_msf_(field);
+				if(xx < 0) {
+					if(is_cdda) {
+						*error_message = "illegal INDEX offset (not of the form MM:SS:FF)";
+						return false;
+					}
+					xx = local__parse_int64_(field);
+					if(xx < 0) {
+						*error_message = "illegal INDEX offset";
+						return false;
+					}
+				}
+				if(is_cdda && cs->num_tracks == 1 && cs->tracks[0].num_indices == 0 && xx != 0) {
+					*error_message = "first INDEX of first TRACK must have an offset of 00:00:00";
+					return false;
+				}
+				if(is_cdda && track->num_indices > 0 && (FLAC__uint64)xx <= track->indices[track->num_indices-1].offset) {
+					*error_message = "CD-DA INDEX offsets must increase in time";
+					return false;
+				}
+				/* fill in track offset if it's the first index of the track */
+				if(track->num_indices == 0)
+					track->offset = (FLAC__uint64)xx;
+				if(is_cdda && cs->num_tracks > 1) {
+					const FLAC__StreamMetadata_CueSheet_Track *prev = &cs->tracks[cs->num_tracks-2];
+					if((FLAC__uint64)xx <= prev->offset + prev->indices[prev->num_indices-1].offset) {
+						*error_message = "CD-DA INDEX offsets must increase in time";
+						return false;
+					}
+				}
+				if(!FLAC__metadata_object_cuesheet_track_insert_blank_index(cuesheet, cs->num_tracks-1, track->num_indices)) {
+					*error_message = "memory allocation error";
+					return false;
+				}
+				track->indices[track->num_indices-1].offset = (FLAC__uint64)xx - track->offset;
+				track->indices[track->num_indices-1].number = in_index_num;
+			}
+			else if(0 == FLAC__STRCASECMP(field, "ISRC")) {
+				char *l, *r;
+				if(track_has_isrc) {
+					*error_message = "found multiple ISRC commands";
+					return false;
+				}
+				if(in_track_num < 0 || in_index_num >= 0) {
+					*error_message = "ISRC command must come after TRACK but before INDEX";
+					return false;
+				}
+				if(0 == (field = local__get_field_(&line, /*allow_quotes=*/false))) {
+					*error_message = "ISRC is missing ISRC number";
+					return false;
+				}
+				/* strip out dashes */
+				for(l = r = field; *r; r++) {
+					if(*r != '-')
+						*l++ = *r;
+				}
+				*l = '\0';
+				if(strlen(field) != 12 || strspn(field, "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789") < 5 || strspn(field+5, "1234567890") != 7) {
+					*error_message = "invalid ISRC number";
+					return false;
+				}
+				strcpy(cs->tracks[cs->num_tracks-1].isrc, field);
+				track_has_isrc = true;
+			}
+			else if(0 == FLAC__STRCASECMP(field, "TRACK")) {
+				if(cs->num_tracks > 0) {
+					const FLAC__StreamMetadata_CueSheet_Track *prev = &cs->tracks[cs->num_tracks-1];
+					if(
+						prev->num_indices == 0 ||
+						(
+						 	is_cdda &&
+							(
+								(prev->num_indices == 1 && prev->indices[0].number != 1) ||
+								(prev->num_indices == 2 && prev->indices[0].number != 1 && prev->indices[1].number != 1)
+							)
+						)
+					) {
+						*error_message = is_cdda?
+							"previous TRACK must specify at least one INDEX 01" :
+							"previous TRACK must specify at least one INDEX";
+						return false;
+					}
+				}
+				if(0 == (field = local__get_field_(&line, /*allow_quotes=*/false))) {
+					*error_message = "TRACK is missing track number";
+					return false;
+				}
+				in_track_num = local__parse_int_(field);
+				if(in_track_num < 0) {
+					*error_message = "TRACK has invalid track number";
+					return false;
+				}
+				if(in_track_num == 0) {
+					*error_message = "TRACK number must be greater than 0";
+					return false;
+				}
+				if(is_cdda) {
+					if(in_track_num > 99) {
+						*error_message = "CD-DA TRACK number must be between 1 and 99, inclusive";
+						return false;
+					}
+				}
+				else {
+					if(in_track_num == 255) {
+						*error_message = "TRACK number 255 is reserved for the lead-out";
+						return false;
+					}
+					else if(in_track_num > 255) {
+						*error_message = "TRACK number must be between 1 and 254, inclusive";
+						return false;
+					}
+				}
+				if(is_cdda && cs->num_tracks > 0 && in_track_num != cs->tracks[cs->num_tracks-1].number + 1) {
+					*error_message = "CD-DA TRACK numbers must be sequential";
+					return false;
+				}
+				/*@@@ search for duplicate track number? */
+				if(0 == (field = local__get_field_(&line, /*allow_quotes=*/false))) {
+					*error_message = "TRACK is missing a track type after the track number";
+					return false;
+				}
+				if(!FLAC__metadata_object_cuesheet_insert_blank_track(cuesheet, cs->num_tracks)) {
+					*error_message = "memory allocation error";
+					return false;
+				}
+				cs->tracks[cs->num_tracks-1].number = in_track_num;
+				cs->tracks[cs->num_tracks-1].type = (0 == FLAC__STRCASECMP(field, "AUDIO"))? 0 : 1; /*@@@ should we be more strict with the value here? */
+				in_index_num = -1;
+				track_has_flags = false;
+				track_has_isrc = false;
+			}
+			else if(0 == FLAC__STRCASECMP(field, "REM")) {
+				if(0 != (field = local__get_field_(&line, /*allow_quotes=*/false))) {
+					if(0 == strcmp(field, "FLAC__lead-in")) {
+						FLAC__int64 xx;
+						if(0 == (field = local__get_field_(&line, /*allow_quotes=*/false))) {
+							*error_message = "FLAC__lead-in is missing offset";
+							return false;
+						}
+						xx = local__parse_int64_(field);
+						if(xx < 0) {
+							*error_message = "illegal FLAC__lead-in offset";
+							return false;
+						}
+						if(is_cdda && xx % 588 != 0) {
+							*error_message = "illegal CD-DA FLAC__lead-in offset, must be even multiple of 588 samples";
+							return false;
+						}
+						cs->lead_in = (FLAC__uint64)xx;
+					}
+					else if(0 == strcmp(field, "FLAC__lead-out")) {
+						int track_num;
+						FLAC__int64 offset;
+						if(has_forced_leadout) {
+							*error_message = "multiple FLAC__lead-out commands";
+							return false;
+						}
+						if(0 == (field = local__get_field_(&line, /*allow_quotes=*/false))) {
+							*error_message = "FLAC__lead-out is missing track number";
+							return false;
+						}
+						track_num = local__parse_int_(field);
+						if(track_num < 0) {
+							*error_message = "illegal FLAC__lead-out track number";
+							return false;
+						}
+						forced_leadout_track_num = (unsigned)track_num;
+						/*@@@ search for duplicate track number? */
+						if(0 == (field = local__get_field_(&line, /*allow_quotes=*/false))) {
+							*error_message = "FLAC__lead-out is missing offset";
+							return false;
+						}
+						offset = local__parse_int64_(field);
+						if(offset < 0) {
+							*error_message = "illegal FLAC__lead-out offset";
+							return false;
+						}
+						forced_leadout_track_offset = (FLAC__uint64)offset;
+						if(forced_leadout_track_offset != lead_out_offset) {
+							*error_message = "FLAC__lead-out offset does not match end-of-stream offset";
+							return false;
+						}
+						has_forced_leadout = true;
+					}
+				}
+			}
+		}
+	}
+
+	if(cs->num_tracks == 0) {
+		*error_message = "there must be at least one TRACK command";
+		return false;
+	}
+	else {
+		const FLAC__StreamMetadata_CueSheet_Track *prev = &cs->tracks[cs->num_tracks-1];
+		if(
+			prev->num_indices == 0 ||
+			(
+				is_cdda &&
+				(
+					(prev->num_indices == 1 && prev->indices[0].number != 1) ||
+					(prev->num_indices == 2 && prev->indices[0].number != 1 && prev->indices[1].number != 1)
+				)
+			)
+		) {
+			*error_message = is_cdda?
+				"previous TRACK must specify at least one INDEX 01" :
+				"previous TRACK must specify at least one INDEX";
+			return false;
+		}
+	}
+
+	if(!has_forced_leadout) {
+		forced_leadout_track_num = is_cdda? 170 : 255;
+		forced_leadout_track_offset = lead_out_offset;
+	}
+	if(!FLAC__metadata_object_cuesheet_insert_blank_track(cuesheet, cs->num_tracks)) {
+		*error_message = "memory allocation error";
+		return false;
+	}
+	cs->tracks[cs->num_tracks-1].number = forced_leadout_track_num;
+	cs->tracks[cs->num_tracks-1].offset = forced_leadout_track_offset;
+
+	if(!feof(file)) {
+		*error_message = "read error";
+		return false;
+	}
+	return true;
+#undef FLAC__STRCASECMP
+}
+
+FLAC__StreamMetadata *grabbag__cuesheet_parse(FILE *file, const char **error_message, unsigned *last_line_read, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset)
+{
+	FLAC__StreamMetadata *cuesheet;
+
+	FLAC__ASSERT(0 != file);
+	FLAC__ASSERT(0 != error_message);
+	FLAC__ASSERT(0 != last_line_read);
+
+	*last_line_read = 0;
+	cuesheet = FLAC__metadata_object_new(FLAC__METADATA_TYPE_CUESHEET);
+
+	if(0 == cuesheet) {
+		*error_message = "memory allocation error";
+		return 0;
+	}
+
+	if(!local__cuesheet_parse_(file, error_message, last_line_read, cuesheet, is_cdda, lead_out_offset)) {
+		FLAC__metadata_object_delete(cuesheet);
+		return 0;
+	}
+
+	return cuesheet;
+}
+
+void grabbag__cuesheet_emit(FILE *file, const FLAC__StreamMetadata *cuesheet, const char *file_reference)
+{
+	const FLAC__StreamMetadata_CueSheet *cs;
+	unsigned track_num, index_num;
+
+	FLAC__ASSERT(0 != file);
+	FLAC__ASSERT(0 != cuesheet);
+	FLAC__ASSERT(cuesheet->type == FLAC__METADATA_TYPE_CUESHEET);
+
+	cs = &cuesheet->data.cue_sheet;
+
+	if(*(cs->media_catalog_number))
+		fprintf(file, "CATALOG %s\n", cs->media_catalog_number);
+	fprintf(file, "FILE %s\n", file_reference);
+
+	for(track_num = 0; track_num < cs->num_tracks-1; track_num++) {
+		const FLAC__StreamMetadata_CueSheet_Track *track = cs->tracks + track_num;
+
+		fprintf(file, "  TRACK %02u %s\n", (unsigned)track->number, track->type == 0? "AUDIO" : "DATA");
+
+		if(track->pre_emphasis)
+			fprintf(file, "    FLAGS PRE\n");
+		if(*(track->isrc))
+			fprintf(file, "    ISRC %s\n", track->isrc);
+
+		for(index_num = 0; index_num < track->num_indices; index_num++) {
+			const FLAC__StreamMetadata_CueSheet_Index *index = track->indices + index_num;
+
+			fprintf(file, "    INDEX %02u ", (unsigned)index->number);
+			if(cs->is_cd) {
+				const unsigned logical_frame = (unsigned)((track->offset + index->offset) / (44100 / 75));
+				unsigned m, s, f;
+				grabbag__cuesheet_frame_to_msf(logical_frame, &m, &s, &f);
+				fprintf(file, "%02u:%02u:%02u\n", m, s, f);
+			}
+			else
+#ifdef _MSC_VER
+				fprintf(file, "%I64u\n", track->offset + index->offset);
+#else
+				fprintf(file, "%llu\n", (unsigned long long)(track->offset + index->offset));
+#endif
+		}
+	}
+
+#ifdef _MSC_VER
+	fprintf(file, "REM FLAC__lead-in %I64u\n", cs->lead_in);
+	fprintf(file, "REM FLAC__lead-out %u %I64u\n", (unsigned)cs->tracks[track_num].number, cs->tracks[track_num].offset);
+#else
+	fprintf(file, "REM FLAC__lead-in %llu\n", (unsigned long long)cs->lead_in);
+	fprintf(file, "REM FLAC__lead-out %u %llu\n", (unsigned)cs->tracks[track_num].number, (unsigned long long)cs->tracks[track_num].offset);
+#endif
+}
diff --git a/audio-codec/flac/grabbag/file.c b/audio-codec/flac/grabbag/file.c
new file mode 100644
index 0000000..d073c4b
--- /dev/null
+++ b/audio-codec/flac/grabbag/file.c
@@ -0,0 +1,192 @@
+/* grabbag - Convenience lib for various routines common to several tools
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#if defined _MSC_VER || defined __MINGW32__
+#include <sys/utime.h> /* for utime() */
+#include <io.h> /* for chmod(), _setmode(), unlink() */
+#include <fcntl.h> /* for _O_BINARY */
+#else
+#include <sys/types.h> /* some flavors of BSD (like OS X) require this to get time_t */
+#include <utime.h> /* for utime() */
+#endif
+#if defined __CYGWIN__ || defined __EMX__
+#include <io.h> /* for setmode(), O_BINARY */
+#include <fcntl.h> /* for _O_BINARY */
+#endif
+#include <sys/stat.h> /* for stat(), maybe chmod() */
+#if defined _WIN32 && !defined __CYGWIN__
+#else
+#include <unistd.h> /* for unlink() */
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h> /* for strrchr() */
+#if defined _WIN32 && !defined __CYGWIN__
+// for GetFileInformationByHandle() etc
+#include <windows.h>
+#include <winbase.h>
+#endif
+#include "share/grabbag.h"
+
+
+void grabbag__file_copy_metadata(const char *srcpath, const char *destpath)
+{
+	struct stat srcstat;
+	struct utimbuf srctime;
+
+	if(0 == stat(srcpath, &srcstat)) {
+		srctime.actime = srcstat.st_atime;
+		srctime.modtime = srcstat.st_mtime;
+		(void)chmod(destpath, srcstat.st_mode);
+		(void)utime(destpath, &srctime);
+	}
+}
+
+off_t grabbag__file_get_filesize(const char *srcpath)
+{
+	struct stat srcstat;
+
+	if(0 == stat(srcpath, &srcstat))
+		return srcstat.st_size;
+	else
+		return -1;
+}
+
+const char *grabbag__file_get_basename(const char *srcpath)
+{
+	const char *p;
+
+	p = strrchr(srcpath, '/');
+	if(0 == p) {
+		p = strrchr(srcpath, '\\');
+		if(0 == p)
+			return srcpath;
+	}
+	return ++p;
+}
+
+FLAC__bool grabbag__file_change_stats(const char *filename, FLAC__bool read_only)
+{
+	struct stat stats;
+
+	if(0 == stat(filename, &stats)) {
+#if !defined _MSC_VER && !defined __MINGW32__
+		if(read_only) {
+			stats.st_mode &= ~S_IWUSR;
+			stats.st_mode &= ~S_IWGRP;
+			stats.st_mode &= ~S_IWOTH;
+		}
+		else {
+			stats.st_mode |= S_IWUSR;
+		}
+#else
+		if(read_only)
+			stats.st_mode &= ~S_IWRITE;
+		else
+			stats.st_mode |= S_IWRITE;
+#endif
+		if(0 != chmod(filename, stats.st_mode))
+			return false;
+	}
+	else
+		return false;
+
+	return true;
+}
+
+FLAC__bool grabbag__file_are_same(const char *f1, const char *f2)
+{
+#if defined _MSC_VER || defined __MINGW32__
+	/* see
+	 * http://www.hydrogenaudio.org/forums/index.php?showtopic=49439&pid=444300&st=0
+	 *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/fileio/fs/getfileinformationbyhandle.asp
+	 *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/fileio/fs/by_handle_file_information_str.asp
+	 *  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/fileio/fs/createfile.asp
+	 * apparently both the files have to be open at the same time for the comparison to work
+	 */
+	FLAC__bool same = false;
+	BY_HANDLE_FILE_INFORMATION info1, info2;
+	HANDLE h1, h2;
+	BOOL ok = 1;
+	h1 = CreateFile(f1, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+	h2 = CreateFile(f2, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+	if(h1 == INVALID_HANDLE_VALUE || h2 == INVALID_HANDLE_VALUE)
+		ok = 0;
+	ok &= GetFileInformationByHandle(h1, &info1);
+	ok &= GetFileInformationByHandle(h2, &info2);
+	if(ok)
+		same =
+			info1.dwVolumeSerialNumber == info2.dwVolumeSerialNumber &&
+			info1.nFileIndexHigh == info2.nFileIndexHigh &&
+			info1.nFileIndexLow == info2.nFileIndexLow
+		;
+	if(h1 != INVALID_HANDLE_VALUE)
+		CloseHandle(h1);
+	if(h2 != INVALID_HANDLE_VALUE)
+		CloseHandle(h2);
+	return same;
+#else
+	struct stat s1, s2;
+	return f1 && f2 && stat(f1, &s1) == 0 && stat(f2, &s2) == 0 && s1.st_ino == s2.st_ino && s1.st_dev == s2.st_dev;
+#endif
+}
+
+FLAC__bool grabbag__file_remove_file(const char *filename)
+{
+	return grabbag__file_change_stats(filename, /*read_only=*/false) && 0 == unlink(filename);
+}
+
+FILE *grabbag__file_get_binary_stdin(void)
+{
+	/* if something breaks here it is probably due to the presence or
+	 * absence of an underscore before the identifiers 'setmode',
+	 * 'fileno', and/or 'O_BINARY'; check your system header files.
+	 */
+#if defined _MSC_VER || defined __MINGW32__
+	_setmode(_fileno(stdin), _O_BINARY);
+#elif defined __CYGWIN__
+	/* almost certainly not needed for any modern Cygwin, but let's be safe... */
+	setmode(_fileno(stdin), _O_BINARY);
+#elif defined __EMX__
+	setmode(fileno(stdin), O_BINARY);
+#endif
+
+	return stdin;
+}
+
+FILE *grabbag__file_get_binary_stdout(void)
+{
+	/* if something breaks here it is probably due to the presence or
+	 * absence of an underscore before the identifiers 'setmode',
+	 * 'fileno', and/or 'O_BINARY'; check your system header files.
+	 */
+#if defined _MSC_VER || defined __MINGW32__
+	_setmode(_fileno(stdout), _O_BINARY);
+#elif defined __CYGWIN__
+	/* almost certainly not needed for any modern Cygwin, but let's be safe... */
+	setmode(_fileno(stdout), _O_BINARY);
+#elif defined __EMX__
+	setmode(fileno(stdout), O_BINARY);
+#endif
+
+	return stdout;
+}
diff --git a/audio-codec/flac/grabbag/grabbag_static.dsp b/audio-codec/flac/grabbag/grabbag_static.dsp
new file mode 100644
index 0000000..11835bd
--- /dev/null
+++ b/audio-codec/flac/grabbag/grabbag_static.dsp
@@ -0,0 +1,144 @@
+# Microsoft Developer Studio Project File - Name="grabbag_static" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=grabbag_static - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "grabbag_static.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "grabbag_static.mak" CFG="grabbag_static - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "grabbag_static - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "grabbag_static - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName "grabbag"
+# PROP Scc_LocalPath "..\..\.."
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "grabbag_static - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "..\..\..\obj\release\lib"
+# PROP Intermediate_Dir "Release_static"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /Op /I ".\include" /I "..\..\..\include" /D "FLAC__NO_DLL" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /nodefaultlib
+
+!ELSEIF  "$(CFG)" == "grabbag_static - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "..\..\..\obj\debug\lib"
+# PROP Intermediate_Dir "Debug_static"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I ".\include" /I "..\..\..\include" /D "FLAC__NO_DLL" /D "WIN32" /D "_DEBUG" /D "DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /nodefaultlib
+
+!ENDIF 
+
+# Begin Target
+
+# Name "grabbag_static - Win32 Release"
+# Name "grabbag_static - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "c"
+# Begin Source File
+
+SOURCE=.\cuesheet.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\file.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\picture.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\replaygain.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\seektable.c
+# End Source File
+# End Group
+# Begin Group "Private Header Files"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\include\share\grabbag\cuesheet.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\include\share\grabbag\file.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\include\share\grabbag\picture.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\include\share\grabbag\replaygain.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\include\share\grabbag\seektable.h
+# End Source File
+# End Group
+# Begin Group "Protected Header Files"
+
+# PROP Default_Filter ""
+# End Group
+# Begin Group "Public Header Files"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\include\share\grabbag.h
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/audio-codec/flac/grabbag/grabbag_static.vcproj b/audio-codec/flac/grabbag/grabbag_static.vcproj
new file mode 100644
index 0000000..f548202
--- /dev/null
+++ b/audio-codec/flac/grabbag/grabbag_static.vcproj
@@ -0,0 +1,221 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="grabbag_static"
+	ProjectGUID="{4cefbc81-c215-11db-8314-0800200c9a66}"
+	RootNamespace="grabbag_static"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="..\..\..\obj\debug\lib"
+			IntermediateDirectory="Debug_static"
+			ConfigurationType="4"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories=".\include;..\..\..\include"
+				PreprocessorDefinitions="WIN32;_DEBUG;_LIB;FLAC__NO_DLL;DEBUG"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+				CompileAs="0"
+				DisableSpecificWarnings="4267;4996"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="..\..\..\obj\debug\lib\$(ProjectName).lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="..\..\..\obj\release\lib"
+			IntermediateDirectory="Release_static"
+			ConfigurationType="4"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				EnableIntrinsicFunctions="true"
+				FavorSizeOrSpeed="1"
+				OmitFramePointers="true"
+				WholeProgramOptimization="true"
+				AdditionalIncludeDirectories=".\include;..\..\..\include"
+				PreprocessorDefinitions="WIN32;NDEBUG;_LIB;FLAC__NO_DLL"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="false"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+				CompileAs="0"
+				DisableSpecificWarnings="4267;4996"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="..\..\..\obj\release\lib\$(ProjectName).lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath=".\cuesheet.c"
+				>
+			</File>
+			<File
+				RelativePath=".\file.c"
+				>
+			</File>
+			<File
+				RelativePath=".\picture.c"
+				>
+			</File>
+			<File
+				RelativePath=".\replaygain.c"
+				>
+			</File>
+			<File
+				RelativePath=".\seektable.c"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Public Header Files"
+			>
+			<File
+				RelativePath="..\..\..\include\share\grabbag.h"
+				>
+			</File>
+			<Filter
+				Name="grabbag"
+				>
+				<File
+					RelativePath="..\..\..\include\share\grabbag\cuesheet.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\include\share\grabbag\file.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\include\share\grabbag\picture.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\include\share\grabbag\replaygain.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\include\share\grabbag\seektable.h"
+					>
+				</File>
+			</Filter>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/audio-codec/flac/grabbag/picture.c b/audio-codec/flac/grabbag/picture.c
new file mode 100644
index 0000000..0e37273
--- /dev/null
+++ b/audio-codec/flac/grabbag/picture.c
@@ -0,0 +1,407 @@
+/* grabbag - Convenience lib for various routines common to several tools
+ * Copyright (C) 2006,2007  Josh Coalson
+ *
+ * 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.
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "share/alloc.h"
+#include "share/grabbag.h"
+#include "FLAC/assert.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* slightly different that strndup(): this always copies 'size' bytes starting from s into a NUL-terminated string. */
+static char *local__strndup_(const char *s, size_t size)
+{
+	char *x = (char*)safe_malloc_add_2op_(size, /*+*/1);
+	if(x) {
+		memcpy(x, s, size);
+		x[size] = '\0';
+	}
+	return x;
+}
+
+static FLAC__bool local__parse_type_(const char *s, size_t len, FLAC__StreamMetadata_Picture *picture)
+{
+	size_t i;
+	FLAC__uint32 val = 0;
+
+	picture->type = FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER;
+
+	if(len == 0)
+		return true; /* empty string implies default to 'front cover' */
+
+	for(i = 0; i < len; i++) {
+		if(s[i] >= '0' && s[i] <= '9')
+			val = 10*val + (FLAC__uint32)(s[i] - '0');
+		else
+			return false;
+	}
+
+	if(i == len)
+		picture->type = val;
+	else
+		return false;
+
+	return true;
+}
+
+static FLAC__bool local__parse_resolution_(const char *s, size_t len, FLAC__StreamMetadata_Picture *picture)
+{
+	int state = 0;
+	size_t i;
+	FLAC__uint32 val = 0;
+
+	picture->width = picture->height = picture->depth = picture->colors = 0;
+
+	if(len == 0)
+		return true; /* empty string implies client wants to get info from the file itself */
+
+	for(i = 0; i < len; i++) {
+		if(s[i] == 'x') {
+			if(state == 0)
+				picture->width = val;
+			else if(state == 1)
+				picture->height = val;
+			else
+				return false;
+			state++;
+			val = 0;
+		}
+		else if(s[i] == '/') {
+			if(state == 2)
+				picture->depth = val;
+			else
+				return false;
+			state++;
+			val = 0;
+		}
+		else if(s[i] >= '0' && s[i] <= '9')
+			val = 10*val + (FLAC__uint32)(s[i] - '0');
+		else
+			return false;
+	}
+
+	if(state < 2)
+		return false;
+	else if(state == 2)
+		picture->depth = val;
+	else if(state == 3)
+		picture->colors = val;
+	else
+		return false;
+	if(picture->depth < 32 && 1u<<picture->depth < picture->colors)
+		return false;
+
+	return true;
+}
+
+static FLAC__bool local__extract_mime_type_(FLAC__StreamMetadata *obj)
+{
+	if(obj->data.picture.data_length >= 8 && 0 == memcmp(obj->data.picture.data, "\x89PNG\x0d\x0a\x1a\x0a", 8))
+		return FLAC__metadata_object_picture_set_mime_type(obj, "image/png", /*copy=*/true);
+	else if(obj->data.picture.data_length >= 6 && (0 == memcmp(obj->data.picture.data, "GIF87a", 6) || 0 == memcmp(obj->data.picture.data, "GIF89a", 6)))
+		return FLAC__metadata_object_picture_set_mime_type(obj, "image/gif", /*copy=*/true);
+	else if(obj->data.picture.data_length >= 2 && 0 == memcmp(obj->data.picture.data, "\xff\xd8", 2))
+		return FLAC__metadata_object_picture_set_mime_type(obj, "image/jpeg", /*copy=*/true);
+	return false;
+}
+
+static FLAC__bool local__extract_resolution_color_info_(FLAC__StreamMetadata_Picture *picture)
+{
+	const FLAC__byte *data = picture->data;
+	FLAC__uint32 len = picture->data_length;
+
+	if(0 == strcmp(picture->mime_type, "image/png")) {
+		/* c.f. http://www.w3.org/TR/PNG/ */
+		FLAC__bool need_palette = false; /* if IHDR has color_type=3, we need to also read the PLTE chunk to get the #colors */
+		if(len < 8 || memcmp(data, "\x89PNG\x0d\x0a\x1a\x0a", 8))
+			return false;
+		/* try to find IHDR chunk */
+		data += 8;
+		len -= 8;
+		while(len > 12) { /* every PNG chunk must be at least 12 bytes long */
+			const FLAC__uint32 clen = (FLAC__uint32)data[0] << 24 | (FLAC__uint32)data[1] << 16 | (FLAC__uint32)data[2] << 8 | (FLAC__uint32)data[3];
+			if(0 == memcmp(data+4, "IHDR", 4) && clen == 13) {
+				unsigned color_type = data[17];
+				picture->width = (FLAC__uint32)data[8] << 24 | (FLAC__uint32)data[9] << 16 | (FLAC__uint32)data[10] << 8 | (FLAC__uint32)data[11];
+				picture->height = (FLAC__uint32)data[12] << 24 | (FLAC__uint32)data[13] << 16 | (FLAC__uint32)data[14] << 8 | (FLAC__uint32)data[15];
+				if(color_type == 3) {
+					/* even though the bit depth for color_type==3 can be 1,2,4,or 8,
+					 * the spec in 11.2.2 of http://www.w3.org/TR/PNG/ says that the
+					 * sample depth is always 8
+					 */
+					picture->depth = 8 * 3u;
+					need_palette = true;
+					data += 12 + clen;
+					len -= 12 + clen;
+				}
+				else {
+					if(color_type == 0) /* greyscale, 1 sample per pixel */
+						picture->depth = (FLAC__uint32)data[16];
+					if(color_type == 2) /* truecolor, 3 samples per pixel */
+						picture->depth = (FLAC__uint32)data[16] * 3u;
+					if(color_type == 4) /* greyscale+alpha, 2 samples per pixel */
+						picture->depth = (FLAC__uint32)data[16] * 2u;
+					if(color_type == 6) /* truecolor+alpha, 4 samples per pixel */
+						picture->depth = (FLAC__uint32)data[16] * 4u;
+					picture->colors = 0;
+					return true;
+				}
+			}
+			else if(need_palette && 0 == memcmp(data+4, "PLTE", 4)) {
+				picture->colors = clen / 3u;
+				return true;
+			}
+			else if(clen + 12 > len)
+				return false;
+			else {
+				data += 12 + clen;
+				len -= 12 + clen;
+			}
+		}
+	}
+	else if(0 == strcmp(picture->mime_type, "image/jpeg")) {
+		/* c.f. http://www.w3.org/Graphics/JPEG/itu-t81.pdf and Q22 of http://www.faqs.org/faqs/jpeg-faq/part1/ */
+		if(len < 2 || memcmp(data, "\xff\xd8", 2))
+			return false;
+		data += 2;
+		len -= 2;
+		while(1) {
+			/* look for sync FF byte */
+			for( ; len > 0; data++, len--) {
+				if(*data == 0xff)
+					break;
+			}
+			if(len == 0)
+				return false;
+			/* eat any extra pad FF bytes before marker */
+			for( ; len > 0; data++, len--) {
+				if(*data != 0xff)
+					break;
+			}
+			if(len == 0)
+				return false;
+			/* if we hit SOS or EOI, bail */
+			if(*data == 0xda || *data == 0xd9)
+				return false;
+			/* looking for some SOFn */
+			else if(memchr("\xc0\xc1\xc2\xc3\xc5\xc6\xc7\xc9\xca\xcb\xcd\xce\xcf", *data, 13)) {
+				data++; len--; /* skip marker byte */
+				if(len < 2)
+					return false;
+				else {
+					const FLAC__uint32 clen = (FLAC__uint32)data[0] << 8 | (FLAC__uint32)data[1];
+					if(clen < 8 || len < clen)
+						return false;
+					picture->width = (FLAC__uint32)data[5] << 8 | (FLAC__uint32)data[6];
+					picture->height = (FLAC__uint32)data[3] << 8 | (FLAC__uint32)data[4];
+					picture->depth = (FLAC__uint32)data[2] * (FLAC__uint32)data[7];
+					picture->colors = 0;
+					return true;
+				}
+			}
+			/* else skip it */
+			else {
+				data++; len--; /* skip marker byte */
+				if(len < 2)
+					return false;
+				else {
+					const FLAC__uint32 clen = (FLAC__uint32)data[0] << 8 | (FLAC__uint32)data[1];
+					if(clen < 2 || len < clen)
+						return false;
+					data += clen;
+					len -= clen;
+				}
+			}
+		}
+	}
+	else if(0 == strcmp(picture->mime_type, "image/gif")) {
+		/* c.f. http://www.w3.org/Graphics/GIF/spec-gif89a.txt */
+		if(len < 14)
+			return false;
+		if(memcmp(data, "GIF87a", 6) && memcmp(data, "GIF89a", 6))
+			return false;
+#if 0
+		/* according to the GIF spec, even if the GCTF is 0, the low 3 bits should still tell the total # colors used */
+		if(data[10] & 0x80 == 0)
+			return false;
+#endif
+		picture->width = (FLAC__uint32)data[6] | ((FLAC__uint32)data[7] << 8);
+		picture->height = (FLAC__uint32)data[8] | ((FLAC__uint32)data[9] << 8);
+#if 0
+		/* this value doesn't seem to be reliable... */
+		picture->depth = (((FLAC__uint32)(data[10] & 0x70) >> 4) + 1) * 3u;
+#else
+		/* ...just pessimistically assume it's 24-bit color without scanning all the color tables */
+		picture->depth = 8u * 3u;
+#endif
+		picture->colors = 1u << ((FLAC__uint32)(data[10] & 0x07) + 1u);
+		return true;
+	}
+	return false;
+}
+
+FLAC__StreamMetadata *grabbag__picture_parse_specification(const char *spec, const char **error_message)
+{
+	FLAC__StreamMetadata *obj;
+	int state = 0;
+	static const char *error_messages[] = {
+		"memory allocation error",
+		"invalid picture specification",
+		"invalid picture specification: can't parse resolution/color part",
+		"unable to extract resolution and color info from URL, user must set explicitly",
+		"unable to extract resolution and color info from file, user must set explicitly",
+		"error opening picture file",
+		"error reading picture file",
+		"invalid picture type",
+		"unable to guess MIME type from file, user must set explicitly",
+		"type 1 icon must be a 32x32 pixel PNG"
+	};
+
+	FLAC__ASSERT(0 != spec);
+	FLAC__ASSERT(0 != error_message);
+
+	/* double protection */
+	if(0 == spec)
+		return 0;
+	if(0 == error_message)
+		return 0;
+
+	*error_message = 0;
+
+	if(0 == (obj = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PICTURE)))
+		*error_message = error_messages[0];
+
+	if(strchr(spec, '|')) { /* full format */
+		const char *p;
+		char *q;
+		for(p = spec; *error_message==0 && *p; ) {
+			if(*p == '|') {
+				switch(state) {
+					case 0: /* type */
+						if(!local__parse_type_(spec, p-spec, &obj->data.picture))
+							*error_message = error_messages[7];
+						break;
+					case 1: /* mime type */
+						if(p-spec) { /* if blank, we'll try to guess later from the picture data */
+							if(0 == (q = local__strndup_(spec, p-spec)))
+								*error_message = error_messages[0];
+							else if(!FLAC__metadata_object_picture_set_mime_type(obj, q, /*copy=*/false))
+								*error_message = error_messages[0];
+						}
+						break;
+					case 2: /* description */
+						if(0 == (q = local__strndup_(spec, p-spec)))
+							*error_message = error_messages[0];
+						else if(!FLAC__metadata_object_picture_set_description(obj, (FLAC__byte*)q, /*copy=*/false))
+							*error_message = error_messages[0];
+						break;
+					case 3: /* resolution/color (e.g. [300x300x16[/1234]] */
+						if(!local__parse_resolution_(spec, p-spec, &obj->data.picture))
+							*error_message = error_messages[2];
+						break;
+					default:
+						*error_message = error_messages[1];
+						break;
+				}
+				p++;
+				spec = p;
+				state++;
+			}
+			else
+				p++;
+		}
+	}
+	else { /* simple format, filename only, everything else guessed */
+		if(!local__parse_type_("", 0, &obj->data.picture)) /* use default picture type */
+			*error_message = error_messages[7];
+		/* leave MIME type to be filled in later */
+		/* leave description empty */
+		/* leave the rest to be filled in later: */
+		else if(!local__parse_resolution_("", 0, &obj->data.picture))
+			*error_message = error_messages[2];
+		else
+			state = 4;
+	}
+
+	/* parse filename, read file, try to extract resolution/color info if needed */
+	if(*error_message == 0) {
+		if(state != 4)
+			*error_message = error_messages[1];
+		else { /* 'spec' points to filename/URL */
+			if(0 == strcmp(obj->data.picture.mime_type, "-->")) { /* magic MIME type means URL */
+				if(!FLAC__metadata_object_picture_set_data(obj, (FLAC__byte*)spec, strlen(spec), /*copy=*/true))
+					*error_message = error_messages[0];
+				else if(obj->data.picture.width == 0 || obj->data.picture.height == 0 || obj->data.picture.depth == 0)
+					*error_message = error_messages[3];
+			}
+			else { /* regular picture file */
+				const off_t size = grabbag__file_get_filesize(spec);
+				if(size < 0)
+					*error_message = error_messages[5];
+				else {
+					FLAC__byte *buffer = (FLAC__byte*)safe_malloc_(size);
+					if(0 == buffer)
+						*error_message = error_messages[0];
+					else {
+						FILE *f = fopen(spec, "rb");
+						if(0 == f)
+							*error_message = error_messages[5];
+						else {
+							if(fread(buffer, 1, size, f) != (size_t)size)
+								*error_message = error_messages[6];
+							fclose(f);
+							if(0 == *error_message) {
+								if(!FLAC__metadata_object_picture_set_data(obj, buffer, size, /*copy=*/false))
+									*error_message = error_messages[6];
+								/* try to extract MIME type if user left it blank */
+								else if(*obj->data.picture.mime_type == '\0' && !local__extract_mime_type_(obj))
+									*error_message = error_messages[8];
+								/* try to extract resolution/color info if user left it blank */
+								else if((obj->data.picture.width == 0 || obj->data.picture.height == 0 || obj->data.picture.depth == 0) && !local__extract_resolution_color_info_(&obj->data.picture))
+									*error_message = error_messages[4];
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	if(*error_message == 0) {
+		if(
+			obj->data.picture.type == FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD && 
+			(
+				(strcmp(obj->data.picture.mime_type, "image/png") && strcmp(obj->data.picture.mime_type, "-->")) ||
+				obj->data.picture.width != 32 ||
+				obj->data.picture.height != 32
+			)
+		)
+			*error_message = error_messages[9];
+	}
+
+	if(*error_message && obj) {
+		FLAC__metadata_object_delete(obj);
+		obj = 0;
+	}
+
+	return obj;
+}
diff --git a/audio-codec/flac/grabbag/replaygain.c b/audio-codec/flac/grabbag/replaygain.c
new file mode 100644
index 0000000..b3d3d21
--- /dev/null
+++ b/audio-codec/flac/grabbag/replaygain.c
@@ -0,0 +1,668 @@
+/* grabbag - Convenience lib for various routines common to several tools
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "share/grabbag.h"
+#include "share/replaygain_analysis.h"
+#include "FLAC/assert.h"
+#include "FLAC/metadata.h"
+#include "FLAC/stream_decoder.h"
+#include <locale.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#if defined _MSC_VER || defined __MINGW32__
+#include <io.h> /* for chmod() */
+#endif
+#include <sys/stat.h> /* for stat(), maybe chmod() */
+
+#ifdef local_min
+#undef local_min
+#endif
+#define local_min(a,b) ((a)<(b)?(a):(b))
+
+#ifdef local_max
+#undef local_max
+#endif
+#define local_max(a,b) ((a)>(b)?(a):(b))
+
+static const char *reference_format_ = "%s=%2.1f dB";
+static const char *gain_format_ = "%s=%+2.2f dB";
+static const char *peak_format_ = "%s=%1.8f";
+
+static double album_peak_, title_peak_;
+
+const unsigned GRABBAG__REPLAYGAIN_MAX_TAG_SPACE_REQUIRED = 190;
+/*
+	FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN/8 + 29 + 1 + 8 +
+	FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN/8 + 21 + 1 + 10 +
+	FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN/8 + 21 + 1 + 12 +
+	FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN/8 + 21 + 1 + 10 +
+	FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN/8 + 21 + 1 + 12
+*/
+
+const FLAC__byte * const GRABBAG__REPLAYGAIN_TAG_REFERENCE_LOUDNESS = (const FLAC__byte * const)"REPLAYGAIN_REFERENCE_LOUDNESS";
+const FLAC__byte * const GRABBAG__REPLAYGAIN_TAG_TITLE_GAIN = (const FLAC__byte * const)"REPLAYGAIN_TRACK_GAIN";
+const FLAC__byte * const GRABBAG__REPLAYGAIN_TAG_TITLE_PEAK = (const FLAC__byte * const)"REPLAYGAIN_TRACK_PEAK";
+const FLAC__byte * const GRABBAG__REPLAYGAIN_TAG_ALBUM_GAIN = (const FLAC__byte * const)"REPLAYGAIN_ALBUM_GAIN";
+const FLAC__byte * const GRABBAG__REPLAYGAIN_TAG_ALBUM_PEAK = (const FLAC__byte * const)"REPLAYGAIN_ALBUM_PEAK";
+
+
+static FLAC__bool get_file_stats_(const char *filename, struct stat *stats)
+{
+	FLAC__ASSERT(0 != filename);
+	FLAC__ASSERT(0 != stats);
+	return (0 == stat(filename, stats));
+}
+
+static void set_file_stats_(const char *filename, struct stat *stats)
+{
+	FLAC__ASSERT(0 != filename);
+	FLAC__ASSERT(0 != stats);
+
+	(void)chmod(filename, stats->st_mode);
+}
+
+static FLAC__bool append_tag_(FLAC__StreamMetadata *block, const char *format, const FLAC__byte *name, float value)
+{
+	char buffer[256];
+	char *saved_locale;
+	FLAC__StreamMetadata_VorbisComment_Entry entry;
+
+	FLAC__ASSERT(0 != block);
+	FLAC__ASSERT(block->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
+	FLAC__ASSERT(0 != format);
+	FLAC__ASSERT(0 != name);
+
+	buffer[sizeof(buffer)-1] = '\0';
+	/*
+	 * We need to save the old locale and switch to "C" because the locale
+	 * influences the formatting of %f and we want it a certain way.
+	 */
+	saved_locale = strdup(setlocale(LC_ALL, 0));
+	if (0 == saved_locale)
+		return false;
+	setlocale(LC_ALL, "C");
+#if defined _MSC_VER || defined __MINGW32__
+	_snprintf(buffer, sizeof(buffer)-1, format, name, value);
+#else
+	snprintf(buffer, sizeof(buffer)-1, format, name, value);
+#endif
+	setlocale(LC_ALL, saved_locale);
+	free(saved_locale);
+
+	entry.entry = (FLAC__byte *)buffer;
+	entry.length = strlen(buffer);
+
+	return FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true);
+}
+
+FLAC__bool grabbag__replaygain_is_valid_sample_frequency(unsigned sample_frequency)
+{
+	static const unsigned valid_sample_rates[] = {
+		8000,
+		11025,
+		12000,
+		16000,
+		22050,
+		24000,
+		32000,
+		44100,
+		48000
+	};
+	static const unsigned n_valid_sample_rates = sizeof(valid_sample_rates) / sizeof(valid_sample_rates[0]);
+
+	unsigned i;
+
+	for(i = 0; i < n_valid_sample_rates; i++)
+		if(sample_frequency == valid_sample_rates[i])
+			return true;
+	return false;
+}
+
+FLAC__bool grabbag__replaygain_init(unsigned sample_frequency)
+{
+	title_peak_ = album_peak_ = 0.0;
+	return InitGainAnalysis((long)sample_frequency) == INIT_GAIN_ANALYSIS_OK;
+}
+
+FLAC__bool grabbag__replaygain_analyze(const FLAC__int32 * const input[], FLAC__bool is_stereo, unsigned bps, unsigned samples)
+{
+	/* using a small buffer improves data locality; we'd like it to fit easily in the dcache */
+	static Float_t lbuffer[2048], rbuffer[2048];
+	static const unsigned nbuffer = sizeof(lbuffer) / sizeof(lbuffer[0]);
+	FLAC__int32 block_peak = 0, s;
+	unsigned i, j;
+
+	FLAC__ASSERT(bps >= 4 && bps <= FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE);
+	FLAC__ASSERT(FLAC__MIN_BITS_PER_SAMPLE == 4);
+	/*
+	 * We use abs() on a FLAC__int32 which is undefined for the most negative value.
+	 * If the reference codec ever handles 32bps we will have to write a special
+	 * case here.
+	 */
+	FLAC__ASSERT(FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE < 32);
+
+	if(bps == 16) {
+		if(is_stereo) {
+			j = 0;
+			while(samples > 0) {
+				const unsigned n = local_min(samples, nbuffer);
+				for(i = 0; i < n; i++, j++) {
+					s = input[0][j];
+					lbuffer[i] = (Float_t)s;
+					s = abs(s);
+					block_peak = local_max(block_peak, s);
+
+					s = input[1][j];
+					rbuffer[i] = (Float_t)s;
+					s = abs(s);
+					block_peak = local_max(block_peak, s);
+				}
+				samples -= n;
+				if(AnalyzeSamples(lbuffer, rbuffer, n, 2) != GAIN_ANALYSIS_OK)
+					return false;
+			}
+		}
+		else {
+			j = 0;
+			while(samples > 0) {
+				const unsigned n = local_min(samples, nbuffer);
+				for(i = 0; i < n; i++, j++) {
+					s = input[0][j];
+					lbuffer[i] = (Float_t)s;
+					s = abs(s);
+					block_peak = local_max(block_peak, s);
+				}
+				samples -= n;
+				if(AnalyzeSamples(lbuffer, 0, n, 1) != GAIN_ANALYSIS_OK)
+					return false;
+			}
+		}
+	}
+	else { /* bps must be < 32 according to above assertion */
+		const double scale = (
+			(bps > 16)?
+				(double)1. / (double)(1u << (bps - 16)) :
+				(double)(1u << (16 - bps))
+		);
+
+		if(is_stereo) {
+			j = 0;
+			while(samples > 0) {
+				const unsigned n = local_min(samples, nbuffer);
+				for(i = 0; i < n; i++, j++) {
+					s = input[0][j];
+					lbuffer[i] = (Float_t)(scale * (double)s);
+					s = abs(s);
+					block_peak = local_max(block_peak, s);
+
+					s = input[1][j];
+					rbuffer[i] = (Float_t)(scale * (double)s);
+					s = abs(s);
+					block_peak = local_max(block_peak, s);
+				}
+				samples -= n;
+				if(AnalyzeSamples(lbuffer, rbuffer, n, 2) != GAIN_ANALYSIS_OK)
+					return false;
+			}
+		}
+		else {
+			j = 0;
+			while(samples > 0) {
+				const unsigned n = local_min(samples, nbuffer);
+				for(i = 0; i < n; i++, j++) {
+					s = input[0][j];
+					lbuffer[i] = (Float_t)(scale * (double)s);
+					s = abs(s);
+					block_peak = local_max(block_peak, s);
+				}
+				samples -= n;
+				if(AnalyzeSamples(lbuffer, 0, n, 1) != GAIN_ANALYSIS_OK)
+					return false;
+			}
+		}
+	}
+
+	{
+		const double peak_scale = (double)(1u << (bps - 1));
+		double peak = (double)block_peak / peak_scale;
+		if(peak > title_peak_)
+			title_peak_ = peak;
+		if(peak > album_peak_)
+			album_peak_ = peak;
+	}
+
+	return true;
+}
+
+void grabbag__replaygain_get_album(float *gain, float *peak)
+{
+	*gain = (float)GetAlbumGain();
+	*peak = (float)album_peak_;
+	album_peak_ = 0.0;
+}
+
+void grabbag__replaygain_get_title(float *gain, float *peak)
+{
+	*gain = (float)GetTitleGain();
+	*peak = (float)title_peak_;
+	title_peak_ = 0.0;
+}
+
+
+typedef struct {
+	unsigned channels;
+	unsigned bits_per_sample;
+	unsigned sample_rate;
+	FLAC__bool error;
+} DecoderInstance;
+
+static FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
+{
+	DecoderInstance *instance = (DecoderInstance*)client_data;
+	const unsigned bits_per_sample = frame->header.bits_per_sample;
+	const unsigned channels = frame->header.channels;
+	const unsigned sample_rate = frame->header.sample_rate;
+	const unsigned samples = frame->header.blocksize;
+
+	(void)decoder;
+
+	if(
+		!instance->error &&
+		(channels == 2 || channels == 1) &&
+		bits_per_sample == instance->bits_per_sample &&
+		channels == instance->channels &&
+		sample_rate == instance->sample_rate
+	) {
+		instance->error = !grabbag__replaygain_analyze(buffer, channels==2, bits_per_sample, samples);
+	}
+	else {
+		instance->error = true;
+	}
+
+	if(!instance->error)
+		return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
+	else
+		return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
+}
+
+static void metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
+{
+	DecoderInstance *instance = (DecoderInstance*)client_data;
+
+	(void)decoder;
+
+	if(metadata->type == FLAC__METADATA_TYPE_STREAMINFO) {
+		instance->bits_per_sample = metadata->data.stream_info.bits_per_sample;
+		instance->channels = metadata->data.stream_info.channels;
+		instance->sample_rate = metadata->data.stream_info.sample_rate;
+
+		if(instance->channels != 1 && instance->channels != 2) {
+			instance->error = true;
+			return;
+		}
+
+		if(!grabbag__replaygain_is_valid_sample_frequency(instance->sample_rate)) {
+			instance->error = true;
+			return;
+		}
+	}
+}
+
+static void error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
+{
+	DecoderInstance *instance = (DecoderInstance*)client_data;
+
+	(void)decoder, (void)status;
+
+	instance->error = true;
+}
+
+const char *grabbag__replaygain_analyze_file(const char *filename, float *title_gain, float *title_peak)
+{
+	DecoderInstance instance;
+	FLAC__StreamDecoder *decoder = FLAC__stream_decoder_new();
+
+	if(0 == decoder)
+		return "memory allocation error";
+
+	instance.error = false;
+
+	/* It does these three by default but lets be explicit: */
+	FLAC__stream_decoder_set_md5_checking(decoder, false);
+	FLAC__stream_decoder_set_metadata_ignore_all(decoder);
+	FLAC__stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_STREAMINFO);
+
+	if(FLAC__stream_decoder_init_file(decoder, filename, write_callback_, metadata_callback_, error_callback_, &instance) != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
+		FLAC__stream_decoder_delete(decoder);
+		return "initializing decoder";
+	}
+
+	if(!FLAC__stream_decoder_process_until_end_of_stream(decoder) || instance.error) {
+		FLAC__stream_decoder_delete(decoder);
+		return "decoding file";
+	}
+
+	FLAC__stream_decoder_delete(decoder);
+
+	grabbag__replaygain_get_title(title_gain, title_peak);
+
+	return 0;
+}
+
+const char *grabbag__replaygain_store_to_vorbiscomment(FLAC__StreamMetadata *block, float album_gain, float album_peak, float title_gain, float title_peak)
+{
+	const char *error;
+
+	if(0 != (error = grabbag__replaygain_store_to_vorbiscomment_reference(block)))
+		return error;
+
+	if(0 != (error = grabbag__replaygain_store_to_vorbiscomment_title(block, title_gain, title_peak)))
+		return error;
+
+	if(0 != (error = grabbag__replaygain_store_to_vorbiscomment_album(block, album_gain, album_peak)))
+		return error;
+
+	return 0;
+}
+
+const char *grabbag__replaygain_store_to_vorbiscomment_reference(FLAC__StreamMetadata *block)
+{
+	FLAC__ASSERT(0 != block);
+	FLAC__ASSERT(block->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
+
+	if(FLAC__metadata_object_vorbiscomment_remove_entries_matching(block, (const char *)GRABBAG__REPLAYGAIN_TAG_REFERENCE_LOUDNESS) < 0)
+		return "memory allocation error";
+
+	if(!append_tag_(block, reference_format_, GRABBAG__REPLAYGAIN_TAG_REFERENCE_LOUDNESS, ReplayGainReferenceLoudness))
+		return "memory allocation error";
+
+	return 0;
+}
+
+const char *grabbag__replaygain_store_to_vorbiscomment_album(FLAC__StreamMetadata *block, float album_gain, float album_peak)
+{
+	FLAC__ASSERT(0 != block);
+	FLAC__ASSERT(block->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
+
+	if(
+		FLAC__metadata_object_vorbiscomment_remove_entries_matching(block, (const char *)GRABBAG__REPLAYGAIN_TAG_ALBUM_GAIN) < 0 ||
+		FLAC__metadata_object_vorbiscomment_remove_entries_matching(block, (const char *)GRABBAG__REPLAYGAIN_TAG_ALBUM_PEAK) < 0
+	)
+		return "memory allocation error";
+
+	if(
+		!append_tag_(block, gain_format_, GRABBAG__REPLAYGAIN_TAG_ALBUM_GAIN, album_gain) ||
+		!append_tag_(block, peak_format_, GRABBAG__REPLAYGAIN_TAG_ALBUM_PEAK, album_peak)
+	)
+		return "memory allocation error";
+
+	return 0;
+}
+
+const char *grabbag__replaygain_store_to_vorbiscomment_title(FLAC__StreamMetadata *block, float title_gain, float title_peak)
+{
+	FLAC__ASSERT(0 != block);
+	FLAC__ASSERT(block->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
+
+	if(
+		FLAC__metadata_object_vorbiscomment_remove_entries_matching(block, (const char *)GRABBAG__REPLAYGAIN_TAG_TITLE_GAIN) < 0 ||
+		FLAC__metadata_object_vorbiscomment_remove_entries_matching(block, (const char *)GRABBAG__REPLAYGAIN_TAG_TITLE_PEAK) < 0
+	)
+		return "memory allocation error";
+
+	if(
+		!append_tag_(block, gain_format_, GRABBAG__REPLAYGAIN_TAG_TITLE_GAIN, title_gain) ||
+		!append_tag_(block, peak_format_, GRABBAG__REPLAYGAIN_TAG_TITLE_PEAK, title_peak)
+	)
+		return "memory allocation error";
+
+	return 0;
+}
+
+static const char *store_to_file_pre_(const char *filename, FLAC__Metadata_Chain **chain, FLAC__StreamMetadata **block)
+{
+	FLAC__Metadata_Iterator *iterator;
+	const char *error;
+	FLAC__bool found_vc_block = false;
+
+	if(0 == (*chain = FLAC__metadata_chain_new()))
+		return "memory allocation error";
+
+	if(!FLAC__metadata_chain_read(*chain, filename)) {
+		error = FLAC__Metadata_ChainStatusString[FLAC__metadata_chain_status(*chain)];
+		FLAC__metadata_chain_delete(*chain);
+		return error;
+	}
+
+	if(0 == (iterator = FLAC__metadata_iterator_new())) {
+		FLAC__metadata_chain_delete(*chain);
+		return "memory allocation error";
+	}
+
+	FLAC__metadata_iterator_init(iterator, *chain);
+
+	do {
+		*block = FLAC__metadata_iterator_get_block(iterator);
+		if((*block)->type == FLAC__METADATA_TYPE_VORBIS_COMMENT)
+			found_vc_block = true;
+	} while(!found_vc_block && FLAC__metadata_iterator_next(iterator));
+
+	if(!found_vc_block) {
+		/* create a new block */
+		*block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
+		if(0 == *block) {
+			FLAC__metadata_chain_delete(*chain);
+			FLAC__metadata_iterator_delete(iterator);
+			return "memory allocation error";
+		}
+		while(FLAC__metadata_iterator_next(iterator))
+			;
+		if(!FLAC__metadata_iterator_insert_block_after(iterator, *block)) {
+			error = FLAC__Metadata_ChainStatusString[FLAC__metadata_chain_status(*chain)];
+			FLAC__metadata_chain_delete(*chain);
+			FLAC__metadata_iterator_delete(iterator);
+			return error;
+		}
+		/* iterator is left pointing to new block */
+		FLAC__ASSERT(FLAC__metadata_iterator_get_block(iterator) == *block);
+	}
+
+	FLAC__metadata_iterator_delete(iterator);
+
+	FLAC__ASSERT(0 != *block);
+	FLAC__ASSERT((*block)->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
+
+	return 0;
+}
+
+static const char *store_to_file_post_(const char *filename, FLAC__Metadata_Chain *chain, FLAC__bool preserve_modtime)
+{
+	struct stat stats;
+	const FLAC__bool have_stats = get_file_stats_(filename, &stats);
+
+	(void)grabbag__file_change_stats(filename, /*read_only=*/false);
+
+	FLAC__metadata_chain_sort_padding(chain);
+	if(!FLAC__metadata_chain_write(chain, /*use_padding=*/true, preserve_modtime)) {
+		FLAC__metadata_chain_delete(chain);
+		return FLAC__Metadata_ChainStatusString[FLAC__metadata_chain_status(chain)];
+	}
+
+	FLAC__metadata_chain_delete(chain);
+
+	if(have_stats)
+		set_file_stats_(filename, &stats);
+
+	return 0;
+}
+
+const char *grabbag__replaygain_store_to_file(const char *filename, float album_gain, float album_peak, float title_gain, float title_peak, FLAC__bool preserve_modtime)
+{
+	FLAC__Metadata_Chain *chain;
+	FLAC__StreamMetadata *block;
+	const char *error;
+
+	if(0 != (error = store_to_file_pre_(filename, &chain, &block)))
+		return error;
+
+	if(0 != (error = grabbag__replaygain_store_to_vorbiscomment(block, album_gain, album_peak, title_gain, title_peak))) {
+		FLAC__metadata_chain_delete(chain);
+		return error;
+	}
+
+	if(0 != (error = store_to_file_post_(filename, chain, preserve_modtime)))
+		return error;
+
+	return 0;
+}
+
+const char *grabbag__replaygain_store_to_file_reference(const char *filename, FLAC__bool preserve_modtime)
+{
+	FLAC__Metadata_Chain *chain;
+	FLAC__StreamMetadata *block;
+	const char *error;
+
+	if(0 != (error = store_to_file_pre_(filename, &chain, &block)))
+		return error;
+
+	if(0 != (error = grabbag__replaygain_store_to_vorbiscomment_reference(block))) {
+		FLAC__metadata_chain_delete(chain);
+		return error;
+	}
+
+	if(0 != (error = store_to_file_post_(filename, chain, preserve_modtime)))
+		return error;
+
+	return 0;
+}
+
+const char *grabbag__replaygain_store_to_file_album(const char *filename, float album_gain, float album_peak, FLAC__bool preserve_modtime)
+{
+	FLAC__Metadata_Chain *chain;
+	FLAC__StreamMetadata *block;
+	const char *error;
+
+	if(0 != (error = store_to_file_pre_(filename, &chain, &block)))
+		return error;
+
+	if(0 != (error = grabbag__replaygain_store_to_vorbiscomment_album(block, album_gain, album_peak))) {
+		FLAC__metadata_chain_delete(chain);
+		return error;
+	}
+
+	if(0 != (error = store_to_file_post_(filename, chain, preserve_modtime)))
+		return error;
+
+	return 0;
+}
+
+const char *grabbag__replaygain_store_to_file_title(const char *filename, float title_gain, float title_peak, FLAC__bool preserve_modtime)
+{
+	FLAC__Metadata_Chain *chain;
+	FLAC__StreamMetadata *block;
+	const char *error;
+
+	if(0 != (error = store_to_file_pre_(filename, &chain, &block)))
+		return error;
+
+	if(0 != (error = grabbag__replaygain_store_to_vorbiscomment_title(block, title_gain, title_peak))) {
+		FLAC__metadata_chain_delete(chain);
+		return error;
+	}
+
+	if(0 != (error = store_to_file_post_(filename, chain, preserve_modtime)))
+		return error;
+
+	return 0;
+}
+
+static FLAC__bool parse_double_(const FLAC__StreamMetadata_VorbisComment_Entry *entry, double *val)
+{
+	char s[32], *end;
+	const char *p, *q;
+	double v;
+
+	FLAC__ASSERT(0 != entry);
+	FLAC__ASSERT(0 != val);
+
+	p = (const char *)entry->entry;
+	q = strchr(p, '=');
+	if(0 == q)
+		return false;
+	q++;
+	memset(s, 0, sizeof(s)-1);
+	strncpy(s, q, local_min(sizeof(s)-1, entry->length - (q-p)));
+
+	v = strtod(s, &end);
+	if(end == s)
+		return false;
+
+	*val = v;
+	return true;
+}
+
+FLAC__bool grabbag__replaygain_load_from_vorbiscomment(const FLAC__StreamMetadata *block, FLAC__bool album_mode, FLAC__bool strict, double *reference, double *gain, double *peak)
+{
+	int reference_offset, gain_offset, peak_offset;
+
+	FLAC__ASSERT(0 != block);
+	FLAC__ASSERT(0 != reference);
+	FLAC__ASSERT(0 != gain);
+	FLAC__ASSERT(0 != peak);
+	FLAC__ASSERT(block->type == FLAC__METADATA_TYPE_VORBIS_COMMENT);
+
+	/* Default to current level until overridden by a detected tag; this
+	 * will always be true until we change replaygain_analysis.c
+	 */
+	*reference = ReplayGainReferenceLoudness;
+
+	if(0 <= (reference_offset = FLAC__metadata_object_vorbiscomment_find_entry_from(block, /*offset=*/0, (const char *)GRABBAG__REPLAYGAIN_TAG_REFERENCE_LOUDNESS)))
+		(void)parse_double_(block->data.vorbis_comment.comments + reference_offset, reference);
+
+	if(0 > (gain_offset = FLAC__metadata_object_vorbiscomment_find_entry_from(block, /*offset=*/0, (const char *)(album_mode? GRABBAG__REPLAYGAIN_TAG_ALBUM_GAIN : GRABBAG__REPLAYGAIN_TAG_TITLE_GAIN))))
+		return !strict && grabbag__replaygain_load_from_vorbiscomment(block, !album_mode, /*strict=*/true, reference, gain, peak);
+	if(0 > (peak_offset = FLAC__metadata_object_vorbiscomment_find_entry_from(block, /*offset=*/0, (const char *)(album_mode? GRABBAG__REPLAYGAIN_TAG_ALBUM_PEAK : GRABBAG__REPLAYGAIN_TAG_TITLE_PEAK))))
+		return !strict && grabbag__replaygain_load_from_vorbiscomment(block, !album_mode, /*strict=*/true, reference, gain, peak);
+
+	if(!parse_double_(block->data.vorbis_comment.comments + gain_offset, gain))
+		return !strict && grabbag__replaygain_load_from_vorbiscomment(block, !album_mode, /*strict=*/true, reference, gain, peak);
+	if(!parse_double_(block->data.vorbis_comment.comments + peak_offset, peak))
+		return !strict && grabbag__replaygain_load_from_vorbiscomment(block, !album_mode, /*strict=*/true, reference, gain, peak);
+
+	return true;
+}
+
+double grabbag__replaygain_compute_scale_factor(double peak, double gain, double preamp, FLAC__bool prevent_clipping)
+{
+	double scale;
+	FLAC__ASSERT(peak >= 0.0);
+ 	gain += preamp;
+	scale = (float) pow(10.0, gain * 0.05);
+	if(prevent_clipping && peak > 0.0) {
+		const double max_scale = (float)(1.0 / peak);
+		if(scale > max_scale)
+			scale = max_scale;
+	}
+	return scale;
+}
diff --git a/audio-codec/flac/grabbag/seektable.c b/audio-codec/flac/grabbag/seektable.c
new file mode 100644
index 0000000..55ac766
--- /dev/null
+++ b/audio-codec/flac/grabbag/seektable.c
@@ -0,0 +1,132 @@
+/* grabbag - Convenience lib for various routines common to several tools
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "share/grabbag.h"
+#include "FLAC/assert.h"
+#include <stdlib.h> /* for atoi() */
+#include <string.h>
+
+#ifdef _MSC_VER
+/* There's no strtoll() in MSVC6 so we just write a specialized one */
+static FLAC__int64 local__strtoll(const char *src, char **endptr)
+{
+	FLAC__bool neg = false;
+	FLAC__int64 ret = 0;
+	int c;
+	FLAC__ASSERT(0 != src);
+	if(*src == '-') {
+		neg = true;
+		src++;
+	}
+	while(0 != (c = *src)) {
+		c -= '0';
+		if(c >= 0 && c <= 9)
+			ret = (ret * 10) + c;
+		else
+			break;
+		src++;
+	}
+	if(endptr)
+		*endptr = (char*)src;
+	return neg? -ret : ret;
+}
+#endif
+
+FLAC__bool grabbag__seektable_convert_specification_to_template(const char *spec, FLAC__bool only_explicit_placeholders, FLAC__uint64 total_samples_to_encode, unsigned sample_rate, FLAC__StreamMetadata *seektable_template, FLAC__bool *spec_has_real_points)
+{
+	unsigned i;
+	const char *pt;
+
+	FLAC__ASSERT(0 != spec);
+	FLAC__ASSERT(0 != seektable_template);
+	FLAC__ASSERT(seektable_template->type = FLAC__METADATA_TYPE_SEEKTABLE);
+
+	if(0 != spec_has_real_points)
+		*spec_has_real_points = false;
+
+	for(pt = spec, i = 0; pt && *pt; i++) {
+		const char *q = strchr(pt, ';');
+		FLAC__ASSERT(0 != q);
+
+		if(q > pt) {
+			if(0 == strncmp(pt, "X;", 2)) { /* -S X */
+				if(!FLAC__metadata_object_seektable_template_append_placeholders(seektable_template, 1))
+					return false;
+			}
+			else if(q[-1] == 'x') { /* -S #x */
+				if(total_samples_to_encode > 0) { /* we can only do these if we know the number of samples to encode up front */
+					if(0 != spec_has_real_points)
+						*spec_has_real_points = true;
+					if(!only_explicit_placeholders) {
+						const int n = (unsigned)atoi(pt);
+						if(n > 0)
+							if(!FLAC__metadata_object_seektable_template_append_spaced_points(seektable_template, (unsigned)n, total_samples_to_encode))
+								return false;
+					}
+				}
+			}
+			else if(q[-1] == 's') { /* -S #s */
+				if(total_samples_to_encode > 0) { /* we can only do these if we know the number of samples to encode up front */
+					FLAC__ASSERT(sample_rate > 0);
+					if(0 != spec_has_real_points)
+						*spec_has_real_points = true;
+					if(!only_explicit_placeholders) {
+						const double sec = atof(pt);
+						if(sec > 0.0) {
+							unsigned samples = (unsigned)(sec * (double)sample_rate);
+							if(samples > 0) {
+								/* +1 for the initial point at sample 0 */
+								if(!FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(seektable_template, samples, total_samples_to_encode))
+									return false;
+							}
+						}
+					}
+				}
+			}
+			else { /* -S # */
+				if(0 != spec_has_real_points)
+					*spec_has_real_points = true;
+				if(!only_explicit_placeholders) {
+					char *endptr;
+#ifdef _MSC_VER
+					const FLAC__int64 n = local__strtoll(pt, &endptr);
+#else
+					const FLAC__int64 n = (FLAC__int64)strtoll(pt, &endptr, 10);
+#endif
+					if(
+						(n > 0 || (endptr > pt && *endptr == ';')) && /* is a valid number (extra check needed for "0") */
+						(total_samples_to_encode == 0 || (FLAC__uint64)n < total_samples_to_encode) /* number is not >= the known total_samples_to_encode */
+					)
+						if(!FLAC__metadata_object_seektable_template_append_point(seektable_template, (FLAC__uint64)n))
+							return false;
+				}
+			}
+		}
+
+		pt = ++q;
+	}
+
+	if(!FLAC__metadata_object_seektable_template_sort(seektable_template, /*compact=*/true))
+		return false;
+
+	return true;
+}
diff --git a/audio-codec/flac/include/share/grabbag.h b/audio-codec/flac/include/share/grabbag.h
new file mode 100644
index 0000000..42c6998
--- /dev/null
+++ b/audio-codec/flac/include/share/grabbag.h
@@ -0,0 +1,29 @@
+/* grabbag - Convenience lib for various routines common to several tools
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef SHARE__GRABBAG_H
+#define SHARE__GRABBAG_H
+
+/* These can't be included by themselves, only from within grabbag.h */
+#include "grabbag/cuesheet.h"
+#include "grabbag/file.h"
+#include "grabbag/picture.h"
+#include "grabbag/replaygain.h"
+#include "grabbag/seektable.h"
+
+#endif
diff --git a/audio-codec/flac/include/share/grabbag/cuesheet.h b/audio-codec/flac/include/share/grabbag/cuesheet.h
new file mode 100644
index 0000000..698d49b
--- /dev/null
+++ b/audio-codec/flac/include/share/grabbag/cuesheet.h
@@ -0,0 +1,42 @@
+/* grabbag - Convenience lib for various routines common to several tools
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+/* This .h cannot be included by itself; #include "share/grabbag.h" instead. */
+
+#ifndef GRABBAG__CUESHEET_H
+#define GRABBAG__CUESHEET_H
+
+#include <stdio.h>
+#include "FLAC/metadata.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+unsigned grabbag__cuesheet_msf_to_frame(unsigned minutes, unsigned seconds, unsigned frames);
+void grabbag__cuesheet_frame_to_msf(unsigned frame, unsigned *minutes, unsigned *seconds, unsigned *frames);
+
+FLAC__StreamMetadata *grabbag__cuesheet_parse(FILE *file, const char **error_message, unsigned *last_line_read, FLAC__bool is_cdda, FLAC__uint64 lead_out_offset);
+
+void grabbag__cuesheet_emit(FILE *file, const FLAC__StreamMetadata *cuesheet, const char *file_reference);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/audio-codec/flac/include/share/grabbag/file.h b/audio-codec/flac/include/share/grabbag/file.h
new file mode 100644
index 0000000..c8b149f
--- /dev/null
+++ b/audio-codec/flac/include/share/grabbag/file.h
@@ -0,0 +1,63 @@
+/* grabbag - Convenience lib for various routines common to several tools
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+/* Convenience routines for manipulating files */
+
+/* This .h cannot be included by itself; #include "share/grabbag.h" instead. */
+
+#ifndef GRABAG__FILE_H
+#define GRABAG__FILE_H
+
+/* needed because of off_t */
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <sys/types.h> /* for off_t */
+#include <stdio.h> /* for FILE */
+#include "FLAC/ordinals.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void grabbag__file_copy_metadata(const char *srcpath, const char *destpath);
+off_t grabbag__file_get_filesize(const char *srcpath);
+const char *grabbag__file_get_basename(const char *srcpath);
+
+/* read_only == false means "make file writable by user"
+ * read_only == true means "make file read-only for everyone"
+ */
+FLAC__bool grabbag__file_change_stats(const char *filename, FLAC__bool read_only);
+
+/* returns true iff stat() succeeds for both files and they have the same device and inode. */
+/* on windows, uses GetFileInformationByHandle() to compare */
+FLAC__bool grabbag__file_are_same(const char *f1, const char *f2);
+
+/* attempts to make writable before unlinking */
+FLAC__bool grabbag__file_remove_file(const char *filename);
+
+/* these will forcibly set stdin/stdout to binary mode (for OSes that require it) */
+FILE *grabbag__file_get_binary_stdin(void);
+FILE *grabbag__file_get_binary_stdout(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/audio-codec/flac/include/share/grabbag/picture.h b/audio-codec/flac/include/share/grabbag/picture.h
new file mode 100644
index 0000000..e7f4278
--- /dev/null
+++ b/audio-codec/flac/include/share/grabbag/picture.h
@@ -0,0 +1,46 @@
+/* grabbag - Convenience lib for various routines common to several tools
+ * Copyright (C) 2006,2007  Josh Coalson
+ *
+ * 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.
+ */
+
+/* This .h cannot be included by itself; #include "share/grabbag.h" instead. */
+
+#ifndef GRABBAG__PICTURE_H
+#define GRABBAG__PICTURE_H
+
+#include "FLAC/metadata.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* spec should be of the form "[TYPE]|MIME_TYPE|[DESCRIPTION]|[WIDTHxHEIGHTxDEPTH[/COLORS]]|FILE", e.g.
+ *   "|image/jpeg|||cover.jpg"
+ *   "4|image/jpeg||300x300x24|backcover.jpg"
+ *   "|image/png|description|300x300x24/71|cover.png"
+ *   "-->|image/gif||300x300x24/71|http://blah.blah.blah/cover.gif"
+ *
+ * empty type means default to FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER
+ * empty resolution spec means to get from the file (cannot get used with "-->" linked images)
+ * spec and error_message must not be NULL
+ */
+FLAC__StreamMetadata *grabbag__picture_parse_specification(const char *spec, const char **error_message);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/audio-codec/flac/include/share/grabbag/replaygain.h b/audio-codec/flac/include/share/grabbag/replaygain.h
new file mode 100644
index 0000000..ea8c935
--- /dev/null
+++ b/audio-codec/flac/include/share/grabbag/replaygain.h
@@ -0,0 +1,72 @@
+/* grabbag - Convenience lib for various routines common to several tools
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+/*
+ * This wraps the replaygain_analysis lib, which is LGPL.  This wrapper
+ * allows analysis of different input resolutions by automatically
+ * scaling the input signal
+ */
+
+/* This .h cannot be included by itself; #include "share/grabbag.h" instead. */
+
+#ifndef GRABBAG__REPLAYGAIN_H
+#define GRABBAG__REPLAYGAIN_H
+
+#include "FLAC/metadata.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern const unsigned GRABBAG__REPLAYGAIN_MAX_TAG_SPACE_REQUIRED;
+
+extern const FLAC__byte * const GRABBAG__REPLAYGAIN_TAG_REFERENCE_LOUDNESS; /* = "REPLAYGAIN_REFERENCE_LOUDNESS" */
+extern const FLAC__byte * const GRABBAG__REPLAYGAIN_TAG_TITLE_GAIN; /* = "REPLAYGAIN_TRACK_GAIN" */
+extern const FLAC__byte * const GRABBAG__REPLAYGAIN_TAG_TITLE_PEAK; /* = "REPLAYGAIN_TRACK_PEAK" */
+extern const FLAC__byte * const GRABBAG__REPLAYGAIN_TAG_ALBUM_GAIN; /* = "REPLAYGAIN_ALBUM_GAIN" */
+extern const FLAC__byte * const GRABBAG__REPLAYGAIN_TAG_ALBUM_PEAK; /* = "REPLAYGAIN_ALBUM_PEAK" */
+
+FLAC__bool grabbag__replaygain_is_valid_sample_frequency(unsigned sample_frequency);
+
+FLAC__bool grabbag__replaygain_init(unsigned sample_frequency);
+
+/* 'bps' must be valid for FLAC, i.e. >=4 and <= 32 */
+FLAC__bool grabbag__replaygain_analyze(const FLAC__int32 * const input[], FLAC__bool is_stereo, unsigned bps, unsigned samples);
+
+void grabbag__replaygain_get_album(float *gain, float *peak);
+void grabbag__replaygain_get_title(float *gain, float *peak);
+
+/* These three functions return an error string on error, or NULL if successful */
+const char *grabbag__replaygain_analyze_file(const char *filename, float *title_gain, float *title_peak);
+const char *grabbag__replaygain_store_to_vorbiscomment(FLAC__StreamMetadata *block, float album_gain, float album_peak, float title_gain, float title_peak);
+const char *grabbag__replaygain_store_to_vorbiscomment_reference(FLAC__StreamMetadata *block);
+const char *grabbag__replaygain_store_to_vorbiscomment_album(FLAC__StreamMetadata *block, float album_gain, float album_peak);
+const char *grabbag__replaygain_store_to_vorbiscomment_title(FLAC__StreamMetadata *block, float title_gain, float title_peak);
+const char *grabbag__replaygain_store_to_file(const char *filename, float album_gain, float album_peak, float title_gain, float title_peak, FLAC__bool preserve_modtime);
+const char *grabbag__replaygain_store_to_file_reference(const char *filename, FLAC__bool preserve_modtime);
+const char *grabbag__replaygain_store_to_file_album(const char *filename, float album_gain, float album_peak, FLAC__bool preserve_modtime);
+const char *grabbag__replaygain_store_to_file_title(const char *filename, float title_gain, float title_peak, FLAC__bool preserve_modtime);
+
+FLAC__bool grabbag__replaygain_load_from_vorbiscomment(const FLAC__StreamMetadata *block, FLAC__bool album_mode, FLAC__bool strict, double *reference, double *gain, double *peak);
+double grabbag__replaygain_compute_scale_factor(double peak, double gain, double preamp, FLAC__bool prevent_clipping);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/audio-codec/flac/include/share/grabbag/seektable.h b/audio-codec/flac/include/share/grabbag/seektable.h
new file mode 100644
index 0000000..8010fc9
--- /dev/null
+++ b/audio-codec/flac/include/share/grabbag/seektable.h
@@ -0,0 +1,38 @@
+/* grabbag - Convenience lib for various routines common to several tools
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+/* Convenience routines for working with seek tables */
+
+/* This .h cannot be included by itself; #include "share/grabbag.h" instead. */
+
+#ifndef GRABAG__SEEKTABLE_H
+#define GRABAG__SEEKTABLE_H
+
+#include "FLAC/format.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+FLAC__bool grabbag__seektable_convert_specification_to_template(const char *spec, FLAC__bool only_explicit_placeholders, FLAC__uint64 total_samples_to_encode, unsigned sample_rate, FLAC__StreamMetadata *seektable_template, FLAC__bool *spec_has_real_points);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/audio-codec/flac/include/test_libs_common/file_utils_flac.h b/audio-codec/flac/include/test_libs_common/file_utils_flac.h
new file mode 100644
index 0000000..27e3671
--- /dev/null
+++ b/audio-codec/flac/include/test_libs_common/file_utils_flac.h
@@ -0,0 +1,34 @@
+/* test_libFLAC - Unit tester for libFLAC
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * 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 FLAC__TEST_LIBFLAC_FILE_UTILS_H
+#define FLAC__TEST_LIBFLAC_FILE_UTILS_H
+
+/* needed because of off_t */
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "FLAC/format.h"
+#include <sys/types.h> /* for off_t */
+
+extern const long file_utils__ogg_serial_number;
+
+FLAC__bool file_utils__generate_flacfile(FLAC__bool is_ogg, const char *output_filename, off_t *output_filesize, unsigned length, const FLAC__StreamMetadata *streaminfo, FLAC__StreamMetadata **metadata, unsigned num_metadata);
+
+#endif
diff --git a/audio-codec/flac/include/test_libs_common/metadata_utils.h b/audio-codec/flac/include/test_libs_common/metadata_utils.h
new file mode 100644
index 0000000..2f0f3ee
--- /dev/null
+++ b/audio-codec/flac/include/test_libs_common/metadata_utils.h
@@ -0,0 +1,70 @@
+/* test_libFLAC - Unit tester for libFLAC
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * 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 FLAC__TEST_LIBS_COMMON_METADATA_UTILS_H
+#define FLAC__TEST_LIBS_COMMON_METADATA_UTILS_H
+
+/*
+ * These are not tests, just utility functions used by the metadata tests
+ */
+
+#include "FLAC/format.h"
+
+FLAC__bool mutils__compare_block_data_streaminfo(const FLAC__StreamMetadata_StreamInfo *block, const FLAC__StreamMetadata_StreamInfo *blockcopy);
+
+FLAC__bool mutils__compare_block_data_padding(const FLAC__StreamMetadata_Padding *block, const FLAC__StreamMetadata_Padding *blockcopy, unsigned block_length);
+
+FLAC__bool mutils__compare_block_data_application(const FLAC__StreamMetadata_Application *block, const FLAC__StreamMetadata_Application *blockcopy, unsigned block_length);
+
+FLAC__bool mutils__compare_block_data_seektable(const FLAC__StreamMetadata_SeekTable *block, const FLAC__StreamMetadata_SeekTable *blockcopy);
+
+FLAC__bool mutils__compare_block_data_vorbiscomment(const FLAC__StreamMetadata_VorbisComment *block, const FLAC__StreamMetadata_VorbisComment *blockcopy);
+
+FLAC__bool mutils__compare_block_data_cuesheet(const FLAC__StreamMetadata_CueSheet *block, const FLAC__StreamMetadata_CueSheet *blockcopy);
+
+FLAC__bool mutils__compare_block_data_picture(const FLAC__StreamMetadata_Picture *block, const FLAC__StreamMetadata_Picture *blockcopy);
+
+FLAC__bool mutils__compare_block_data_unknown(const FLAC__StreamMetadata_Unknown *block, const FLAC__StreamMetadata_Unknown *blockcopy, unsigned block_length);
+
+FLAC__bool mutils__compare_block(const FLAC__StreamMetadata *block, const FLAC__StreamMetadata *blockcopy);
+
+void mutils__init_metadata_blocks(
+	FLAC__StreamMetadata *streaminfo,
+	FLAC__StreamMetadata *padding,
+	FLAC__StreamMetadata *seektable,
+	FLAC__StreamMetadata *application1,
+	FLAC__StreamMetadata *application2,
+	FLAC__StreamMetadata *vorbiscomment,
+	FLAC__StreamMetadata *cuesheet,
+	FLAC__StreamMetadata *picture,
+	FLAC__StreamMetadata *unknown
+);
+
+void mutils__free_metadata_blocks(
+	FLAC__StreamMetadata *streaminfo,
+	FLAC__StreamMetadata *padding,
+	FLAC__StreamMetadata *seektable,
+	FLAC__StreamMetadata *application1,
+	FLAC__StreamMetadata *application2,
+	FLAC__StreamMetadata *vorbiscomment,
+	FLAC__StreamMetadata *cuesheet,
+	FLAC__StreamMetadata *picture,
+	FLAC__StreamMetadata *unknown
+);
+
+#endif
diff --git a/audio-codec/flac/test_libFLAC/Makefile.am b/audio-codec/flac/test_libFLAC/Makefile.am
new file mode 100644
index 0000000..d38f299
--- /dev/null
+++ b/audio-codec/flac/test_libFLAC/Makefile.am
@@ -0,0 +1,47 @@
+#  test_libFLAC - Unit tester for libFLAC
+#  Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007  Josh Coalson
+#
+#  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.
+
+EXTRA_DIST = \
+	Makefile.lite \
+	test_libFLAC.dsp \
+	test_libFLAC.vcproj
+
+INCLUDES = -I$(top_srcdir)/src/libFLAC/include
+
+noinst_PROGRAMS = test_libFLAC
+test_libFLAC_LDADD = \
+	$(top_builddir)/src/share/grabbag/libgrabbag.la \
+	$(top_builddir)/src/share/replaygain_analysis/libreplaygain_analysis.la \
+	$(top_builddir)/src/test_libs_common/libtest_libs_common.la \
+	$(top_builddir)/src/libFLAC/libFLAC.la \
+	@OGG_LIBS@ \
+	@MINGW_WINSOCK_LIBS@ \
+	-lm
+test_libFLAC_SOURCES = \
+	bitwriter.c \
+	decoders.c \
+	encoders.c \
+	format.c \
+	main.c \
+	metadata.c \
+	metadata_manip.c \
+	metadata_object.c \
+	bitwriter.h \
+	decoders.h \
+	encoders.h \
+	format.h \
+	metadata.h
diff --git a/audio-codec/flac/test_libFLAC/Makefile.in b/audio-codec/flac/test_libFLAC/Makefile.in
new file mode 100644
index 0000000..b43bc65
--- /dev/null
+++ b/audio-codec/flac/test_libFLAC/Makefile.in
@@ -0,0 +1,548 @@
+# Makefile.in generated by automake 1.7.9 from Makefile.am.
+# @configure_input@
+
+# Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
+# Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+#  test_libFLAC - Unit tester for libFLAC
+#  Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007  Josh Coalson
+#
+#  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.
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+top_builddir = ../..
+
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+INSTALL = @INSTALL@
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+host_triplet = @host@
+ACLOCAL = @ACLOCAL@
+ACLOCAL_AMFLAGS = @ACLOCAL_AMFLAGS@
+AMDEP_FALSE = @AMDEP_FALSE@
+AMDEP_TRUE = @AMDEP_TRUE@
+AMTAR = @AMTAR@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCAS = @CCAS@
+CCASFLAGS = @CCASFLAGS@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEBUG_FALSE = @DEBUG_FALSE@
+DEBUG_TRUE = @DEBUG_TRUE@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DOCBOOK_TO_MAN = @DOCBOOK_TO_MAN@
+DOXYGEN = @DOXYGEN@
+ECHO = @ECHO@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+F77 = @F77@
+FFLAGS = @FFLAGS@
+FLAC__TEST_LEVEL = @FLAC__TEST_LEVEL@
+FLAC__TEST_WITH_VALGRIND = @FLAC__TEST_WITH_VALGRIND@
+FLaC__CPU_IA32_FALSE = @FLaC__CPU_IA32_FALSE@
+FLaC__CPU_IA32_TRUE = @FLaC__CPU_IA32_TRUE@
+FLaC__CPU_PPC_FALSE = @FLaC__CPU_PPC_FALSE@
+FLaC__CPU_PPC_TRUE = @FLaC__CPU_PPC_TRUE@
+FLaC__CPU_SPARC_FALSE = @FLaC__CPU_SPARC_FALSE@
+FLaC__CPU_SPARC_TRUE = @FLaC__CPU_SPARC_TRUE@
+FLaC__HAS_AS_FALSE = @FLaC__HAS_AS_FALSE@
+FLaC__HAS_AS_TRUE = @FLaC__HAS_AS_TRUE@
+FLaC__HAS_AS__TEMPORARILY_DISABLED_FALSE = @FLaC__HAS_AS__TEMPORARILY_DISABLED_FALSE@
+FLaC__HAS_AS__TEMPORARILY_DISABLED_TRUE = @FLaC__HAS_AS__TEMPORARILY_DISABLED_TRUE@
+FLaC__HAS_DOCBOOK_TO_MAN_FALSE = @FLaC__HAS_DOCBOOK_TO_MAN_FALSE@
+FLaC__HAS_DOCBOOK_TO_MAN_TRUE = @FLaC__HAS_DOCBOOK_TO_MAN_TRUE@
+FLaC__HAS_DOXYGEN_FALSE = @FLaC__HAS_DOXYGEN_FALSE@
+FLaC__HAS_DOXYGEN_TRUE = @FLaC__HAS_DOXYGEN_TRUE@
+FLaC__HAS_GAS_FALSE = @FLaC__HAS_GAS_FALSE@
+FLaC__HAS_GAS_TRUE = @FLaC__HAS_GAS_TRUE@
+FLaC__HAS_GAS__TEMPORARILY_DISABLED_FALSE = @FLaC__HAS_GAS__TEMPORARILY_DISABLED_FALSE@
+FLaC__HAS_GAS__TEMPORARILY_DISABLED_TRUE = @FLaC__HAS_GAS__TEMPORARILY_DISABLED_TRUE@
+FLaC__HAS_NASM_FALSE = @FLaC__HAS_NASM_FALSE@
+FLaC__HAS_NASM_TRUE = @FLaC__HAS_NASM_TRUE@
+FLaC__HAS_OGG_FALSE = @FLaC__HAS_OGG_FALSE@
+FLaC__HAS_OGG_TRUE = @FLaC__HAS_OGG_TRUE@
+FLaC__HAS_XMMS_FALSE = @FLaC__HAS_XMMS_FALSE@
+FLaC__HAS_XMMS_TRUE = @FLaC__HAS_XMMS_TRUE@
+FLaC__INSTALL_XMMS_PLUGIN_LOCALLY_FALSE = @FLaC__INSTALL_XMMS_PLUGIN_LOCALLY_FALSE@
+FLaC__INSTALL_XMMS_PLUGIN_LOCALLY_TRUE = @FLaC__INSTALL_XMMS_PLUGIN_LOCALLY_TRUE@
+FLaC__NO_ASM_FALSE = @FLaC__NO_ASM_FALSE@
+FLaC__NO_ASM_TRUE = @FLaC__NO_ASM_TRUE@
+FLaC__SSE_OS_FALSE = @FLaC__SSE_OS_FALSE@
+FLaC__SSE_OS_TRUE = @FLaC__SSE_OS_TRUE@
+FLaC__SYS_DARWIN_FALSE = @FLaC__SYS_DARWIN_FALSE@
+FLaC__SYS_DARWIN_TRUE = @FLaC__SYS_DARWIN_TRUE@
+FLaC__SYS_LINUX_FALSE = @FLaC__SYS_LINUX_FALSE@
+FLaC__SYS_LINUX_TRUE = @FLaC__SYS_LINUX_TRUE@
+FLaC__USE_3DNOW_FALSE = @FLaC__USE_3DNOW_FALSE@
+FLaC__USE_3DNOW_TRUE = @FLaC__USE_3DNOW_TRUE@
+FLaC__USE_ALTIVEC_FALSE = @FLaC__USE_ALTIVEC_FALSE@
+FLaC__USE_ALTIVEC_TRUE = @FLaC__USE_ALTIVEC_TRUE@
+FLaC__WITH_CPPLIBS_FALSE = @FLaC__WITH_CPPLIBS_FALSE@
+FLaC__WITH_CPPLIBS_TRUE = @FLaC__WITH_CPPLIBS_TRUE@
+GAS = @GAS@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LDFLAGS = @LDFLAGS@
+LIBICONV = @LIBICONV@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LN_S = @LN_S@
+LTLIBICONV = @LTLIBICONV@
+LTLIBOBJS = @LTLIBOBJS@
+MAINT = @MAINT@
+MAINTAINER_MODE_FALSE = @MAINTAINER_MODE_FALSE@
+MAINTAINER_MODE_TRUE = @MAINTAINER_MODE_TRUE@
+MAKEINFO = @MAKEINFO@
+MINGW_WINSOCK_LIBS = @MINGW_WINSOCK_LIBS@
+NASM = @NASM@
+OBJEXT = @OBJEXT@
+OBJ_FORMAT = @OBJ_FORMAT@
+OGG_CFLAGS = @OGG_CFLAGS@
+OGG_LIBS = @OGG_LIBS@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+RANLIB = @RANLIB@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+XMMS_CFLAGS = @XMMS_CFLAGS@
+XMMS_CONFIG = @XMMS_CONFIG@
+XMMS_DATA_DIR = @XMMS_DATA_DIR@
+XMMS_EFFECT_PLUGIN_DIR = @XMMS_EFFECT_PLUGIN_DIR@
+XMMS_GENERAL_PLUGIN_DIR = @XMMS_GENERAL_PLUGIN_DIR@
+XMMS_INPUT_PLUGIN_DIR = @XMMS_INPUT_PLUGIN_DIR@
+XMMS_LIBS = @XMMS_LIBS@
+XMMS_OUTPUT_PLUGIN_DIR = @XMMS_OUTPUT_PLUGIN_DIR@
+XMMS_PLUGIN_DIR = @XMMS_PLUGIN_DIR@
+XMMS_VERSION = @XMMS_VERSION@
+XMMS_VISUALIZATION_PLUGIN_DIR = @XMMS_VISUALIZATION_PLUGIN_DIR@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_F77 = @ac_ct_F77@
+ac_ct_RANLIB = @ac_ct_RANLIB@
+ac_ct_STRIP = @ac_ct_STRIP@
+am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+am__fastdepCXX_FALSE = @am__fastdepCXX_FALSE@
+am__fastdepCXX_TRUE = @am__fastdepCXX_TRUE@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+datadir = @datadir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+oldincludedir = @oldincludedir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+
+EXTRA_DIST = \
+	Makefile.lite \
+	test_libFLAC.dsp \
+	test_libFLAC.vcproj
+
+
+INCLUDES = -I$(top_srcdir)/src/libFLAC/include
+
+noinst_PROGRAMS = test_libFLAC
+test_libFLAC_LDADD = \
+	$(top_builddir)/src/share/grabbag/libgrabbag.la \
+	$(top_builddir)/src/share/replaygain_analysis/libreplaygain_analysis.la \
+	$(top_builddir)/src/test_libs_common/libtest_libs_common.la \
+	$(top_builddir)/src/libFLAC/libFLAC.la \
+	@OGG_LIBS@ \
+	@MINGW_WINSOCK_LIBS@ \
+	-lm
+
+test_libFLAC_SOURCES = \
+	bitwriter.c \
+	decoders.c \
+	encoders.c \
+	format.c \
+	main.c \
+	metadata.c \
+	metadata_manip.c \
+	metadata_object.c \
+	bitwriter.h \
+	decoders.h \
+	encoders.h \
+	format.h \
+	metadata.h
+
+subdir = src/test_libFLAC
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+noinst_PROGRAMS = test_libFLAC$(EXEEXT)
+PROGRAMS = $(noinst_PROGRAMS)
+
+am_test_libFLAC_OBJECTS = bitwriter.$(OBJEXT) decoders.$(OBJEXT) \
+	encoders.$(OBJEXT) format.$(OBJEXT) main.$(OBJEXT) \
+	metadata.$(OBJEXT) metadata_manip.$(OBJEXT) \
+	metadata_object.$(OBJEXT)
+test_libFLAC_OBJECTS = $(am_test_libFLAC_OBJECTS)
+test_libFLAC_DEPENDENCIES = \
+	$(top_builddir)/src/share/grabbag/libgrabbag.la \
+	$(top_builddir)/src/share/replaygain_analysis/libreplaygain_analysis.la \
+	$(top_builddir)/src/test_libs_common/libtest_libs_common.la \
+	$(top_builddir)/src/libFLAC/libFLAC.la
+test_libFLAC_LDFLAGS =
+
+DEFAULT_INCLUDES =  -I. -I$(srcdir) -I$(top_builddir)
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+@AMDEP_TRUE@DEP_FILES = ./$(DEPDIR)/bitwriter.Po ./$(DEPDIR)/decoders.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/encoders.Po ./$(DEPDIR)/format.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/main.Po ./$(DEPDIR)/metadata.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/metadata_manip.Po \
+@AMDEP_TRUE@	./$(DEPDIR)/metadata_object.Po
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) \
+	$(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(LIBTOOL) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(AM_LDFLAGS) $(LDFLAGS) -o $@
+DIST_SOURCES = $(test_libFLAC_SOURCES)
+DIST_COMMON = $(srcdir)/Makefile.in Makefile.am
+SOURCES = $(test_libFLAC_SOURCES)
+
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ Makefile.am  $(top_srcdir)/configure.in $(ACLOCAL_M4)
+	cd $(top_srcdir) && \
+	  $(AUTOMAKE) --gnu  src/test_libFLAC/Makefile
+Makefile: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.in  $(top_builddir)/config.status
+	cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)
+
+clean-noinstPROGRAMS:
+	@list='$(noinst_PROGRAMS)'; for p in $$list; do \
+	  f=`echo $$p|sed 's/$(EXEEXT)$$//'`; \
+	  echo " rm -f $$p $$f"; \
+	  rm -f $$p $$f ; \
+	done
+test_libFLAC$(EXEEXT): $(test_libFLAC_OBJECTS) $(test_libFLAC_DEPENDENCIES) 
+	@rm -f test_libFLAC$(EXEEXT)
+	$(LINK) $(test_libFLAC_LDFLAGS) $(test_libFLAC_OBJECTS) $(test_libFLAC_LDADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT) core *.core
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bitwriter.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/decoders.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/encoders.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/format.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/main.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/metadata.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/metadata_manip.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/metadata_object.Po@am__quote@
+
+.c.o:
+@am__fastdepCC_TRUE@	if $(COMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" \
+@am__fastdepCC_TRUE@	  -c -o $@ `test -f '$<' || echo '$(srcdir)/'`$<; \
+@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; \
+@am__fastdepCC_TRUE@	else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; \
+@am__fastdepCC_TRUE@	fi
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c `test -f '$<' || echo '$(srcdir)/'`$<
+
+.c.obj:
+@am__fastdepCC_TRUE@	if $(COMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" \
+@am__fastdepCC_TRUE@	  -c -o $@ `if test -f '$<'; then $(CYGPATH_W) '$<'; else $(CYGPATH_W) '$(srcdir)/$<'; fi`; \
+@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; \
+@am__fastdepCC_TRUE@	else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; \
+@am__fastdepCC_TRUE@	fi
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c `if test -f '$<'; then $(CYGPATH_W) '$<'; else $(CYGPATH_W) '$(srcdir)/$<'; fi`
+
+.c.lo:
+@am__fastdepCC_TRUE@	if $(LTCOMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" \
+@am__fastdepCC_TRUE@	  -c -o $@ `test -f '$<' || echo '$(srcdir)/'`$<; \
+@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Plo"; \
+@am__fastdepCC_TRUE@	else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; \
+@am__fastdepCC_TRUE@	fi
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	depfile='$(DEPDIR)/$*.Plo' tmpdepfile='$(DEPDIR)/$*.TPlo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LTCOMPILE) -c -o $@ `test -f '$<' || echo '$(srcdir)/'`$<
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+distclean-libtool:
+	-rm -f libtool
+uninstall-info-am:
+
+ETAGS = etags
+ETAGSFLAGS =
+
+CTAGS = ctags
+CTAGSFLAGS =
+
+tags: TAGS
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	mkid -fID $$unique
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(ETAGS_ARGS)$$tags$$unique" \
+	  || $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	     $$tags $$unique
+
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(CTAGS_ARGS)$$tags$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$tags $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && cd $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) $$here
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+
+top_distdir = ../..
+distdir = $(top_distdir)/$(PACKAGE)-$(VERSION)
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \
+	list='$(DISTFILES)'; for file in $$list; do \
+	  case $$file in \
+	    $(srcdir)/*) file=`echo "$$file" | sed "s|^$$srcdirstrip/||"`;; \
+	    $(top_srcdir)/*) file=`echo "$$file" | sed "s|^$$topsrcdirstrip/|$(top_builddir)/|"`;; \
+	  esac; \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \
+	  if test "$$dir" != "$$file" && test "$$dir" != "."; then \
+	    dir="/$$dir"; \
+	    $(mkinstalldirs) "$(distdir)$$dir"; \
+	  else \
+	    dir=''; \
+	  fi; \
+	  if test -d $$d/$$file; then \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
+	    fi; \
+	    cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
+	  else \
+	    test -f $(distdir)/$$file \
+	    || cp -p $$d/$$file $(distdir)/$$file \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(PROGRAMS)
+
+installdirs:
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-rm -f $(CONFIG_CLEAN_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool clean-noinstPROGRAMS \
+	mostlyclean-am
+
+distclean: distclean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-libtool distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-exec-am:
+
+install-info: install-info-am
+
+install-man:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-info-am
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
+	clean-libtool clean-noinstPROGRAMS ctags distclean \
+	distclean-compile distclean-generic distclean-libtool \
+	distclean-tags distdir dvi dvi-am info info-am install \
+	install-am install-data install-data-am install-exec \
+	install-exec-am install-info install-info-am install-man \
+	install-strip installcheck installcheck-am installdirs \
+	maintainer-clean maintainer-clean-generic mostlyclean \
+	mostlyclean-compile mostlyclean-generic mostlyclean-libtool pdf \
+	pdf-am ps ps-am tags uninstall uninstall-am uninstall-info-am
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/audio-codec/flac/test_libFLAC/Makefile.lite b/audio-codec/flac/test_libFLAC/Makefile.lite
new file mode 100644
index 0000000..60d9920
--- /dev/null
+++ b/audio-codec/flac/test_libFLAC/Makefile.lite
@@ -0,0 +1,47 @@
+#  test_libFLAC - Unit tester for libFLAC
+#  Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007  Josh Coalson
+#
+#  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.
+
+#
+# GNU makefile
+#
+
+topdir = ../..
+libdir = $(topdir)/obj/$(BUILD)/lib
+
+PROGRAM_NAME = test_libFLAC
+
+INCLUDES = -I../libFLAC/include -I$(topdir)/include
+
+ifeq ($(DARWIN_BUILD),yes)
+EXPLICIT_LIBS = $(libdir)/libgrabbag.a $(libdir)/libreplaygain_analysis.a $(libdir)/libtest_libs_common.a $(libdir)/libFLAC.a $(OGG_LIB_DIR)/libogg.a -lm
+else
+LIBS = -lgrabbag -lreplaygain_analysis -ltest_libs_common -lFLAC -L$(OGG_LIB_DIR) -logg -lm
+endif
+
+SRCS_C = \
+	bitwriter.c \
+	decoders.c \
+	encoders.c \
+	format.c \
+	main.c \
+	metadata.c \
+	metadata_manip.c \
+	metadata_object.c
+
+include $(topdir)/build/exe.mk
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
diff --git a/audio-codec/flac/test_libFLAC/bitwriter.c b/audio-codec/flac/test_libFLAC/bitwriter.c
new file mode 100644
index 0000000..7bc23a8
--- /dev/null
+++ b/audio-codec/flac/test_libFLAC/bitwriter.c
@@ -0,0 +1,584 @@
+/* test_libFLAC - Unit tester for libFLAC
+ * Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * 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.
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "FLAC/assert.h"
+#include "private/bitwriter.h" /* from the libFLAC private include area */
+#include "bitwriter.h"
+#include <stdio.h>
+#include <string.h> /* for memcmp() */
+
+/* adjust for compilers that can't understand using LLU suffix for uint64_t literals */
+#ifdef _MSC_VER
+#define FLAC__U64L(x) x
+#else
+#define FLAC__U64L(x) x##LLU
+#endif
+
+/*
+ * WATCHOUT!  Since FLAC__BitWriter is a private structure, we use a copy of
+ * the definition here to get at the internals.  Make sure this is kept up
+ * to date with what is in ../libFLAC/bitwriter.c
+ */
+typedef FLAC__uint32 bwword;
+
+struct FLAC__BitWriter {
+	bwword *buffer;
+	bwword accum; /* accumulator; when full, accum is appended to buffer */
+	unsigned capacity; /* of buffer in words */
+	unsigned words; /* # of complete words in buffer */
+	unsigned bits; /* # of used bits in accum */
+};
+
+#define TOTAL_BITS(bw) ((bw)->words*sizeof(bwword)*8 + (bw)->bits)
+
+
+FLAC__bool test_bitwriter(void)
+{
+	FLAC__BitWriter *bw;
+	FLAC__bool ok;
+	unsigned i, j;
+#if WORDS_BIGENDIAN
+	static bwword test_pattern1[5] = { 0xaaf0aabe, 0xaaaaaaa8, 0x300aaaaa, 0xaaadeadb, 0x00eeface };
+#else
+	static bwword test_pattern1[5] = { 0xbeaaf0aa, 0xa8aaaaaa, 0xaaaa0a30, 0xdbeaadaa, 0x00eeface };
+#endif
+	unsigned words, bits; /* what we think bw->words and bw->bits should be */
+
+	printf("\n+++ libFLAC unit test: bitwriter\n\n");
+
+	/*
+	 * test new -> delete
+	 */
+	printf("testing new... ");
+	bw = FLAC__bitwriter_new();
+	if(0 == bw) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing delete... ");
+	FLAC__bitwriter_delete(bw);
+	printf("OK\n");
+
+	/*
+	 * test new -> init -> delete
+	 */
+	printf("testing new... ");
+	bw = FLAC__bitwriter_new();
+	if(0 == bw) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing init... ");
+	FLAC__bitwriter_init(bw);
+	if(0 == bw) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing delete... ");
+	FLAC__bitwriter_delete(bw);
+	printf("OK\n");
+
+	/*
+	 * test new -> init -> clear -> delete
+	 */
+	printf("testing new... ");
+	bw = FLAC__bitwriter_new();
+	if(0 == bw) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing init... ");
+	FLAC__bitwriter_init(bw);
+	if(0 == bw) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing clear... ");
+	FLAC__bitwriter_clear(bw);
+	if(0 == bw) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing delete... ");
+	FLAC__bitwriter_delete(bw);
+	printf("OK\n");
+
+	/*
+	 * test normal usage
+	 */
+	printf("testing new... ");
+	bw = FLAC__bitwriter_new();
+	if(0 == bw) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing init... ");
+	ok = FLAC__bitwriter_init(bw);
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok)
+		return false;
+
+	printf("testing clear... ");
+	FLAC__bitwriter_clear(bw);
+	printf("OK\n");
+
+	words = bits = 0;
+
+	printf("capacity = %u\n", bw->capacity);
+
+	printf("testing zeroes, raw_uint32*... ");
+	ok =
+		FLAC__bitwriter_write_raw_uint32(bw, 0x1, 1) &&
+		FLAC__bitwriter_write_raw_uint32(bw, 0x1, 2) &&
+		FLAC__bitwriter_write_raw_uint32(bw, 0xa, 5) &&
+		FLAC__bitwriter_write_raw_uint32(bw, 0xf0, 8) &&
+		FLAC__bitwriter_write_raw_uint32(bw, 0x2aa, 10) &&
+		FLAC__bitwriter_write_raw_uint32(bw, 0xf, 4) &&
+		FLAC__bitwriter_write_raw_uint32(bw, 0xaaaaaaaa, 32) &&
+		FLAC__bitwriter_write_zeroes(bw, 4) &&
+		FLAC__bitwriter_write_raw_uint32(bw, 0x3, 2) &&
+		FLAC__bitwriter_write_zeroes(bw, 8) &&
+		FLAC__bitwriter_write_raw_uint64(bw, FLAC__U64L(0xaaaaaaaadeadbeef), 64) &&
+		FLAC__bitwriter_write_raw_uint32(bw, 0xace, 12)
+	;
+	if(!ok) {
+		printf("FAILED\n");
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+	words = 4;
+	bits = 24;
+	if(bw->words != words) {
+		printf("FAILED byte count %u != %u\n", bw->words, words);
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+	if(bw->bits != bits) {
+		printf("FAILED bit count %u != %u\n", bw->bits, bits);
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+	if(memcmp(bw->buffer, test_pattern1, sizeof(bwword)*words) != 0) {
+		printf("FAILED pattern match (buffer)\n");
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+	if((bw->accum & 0x00ffffff) != test_pattern1[words]) {
+		printf("FAILED pattern match (bw->accum=%08X != %08X)\n", bw->accum&0x00ffffff, test_pattern1[words]);
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+	printf("OK\n");
+	FLAC__bitwriter_dump(bw, stdout);
+
+	printf("testing raw_uint32 some more... ");
+	ok = FLAC__bitwriter_write_raw_uint32(bw, 0x3d, 6);
+	if(!ok) {
+		printf("FAILED\n");
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+	bits += 6;
+	test_pattern1[words] <<= 6;
+	test_pattern1[words] |= 0x3d;
+	if(bw->words != words) {
+		printf("FAILED byte count %u != %u\n", bw->words, words);
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+	if(bw->bits != bits) {
+		printf("FAILED bit count %u != %u\n", bw->bits, bits);
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+	if(memcmp(bw->buffer, test_pattern1, sizeof(bwword)*words) != 0) {
+		printf("FAILED pattern match (buffer)\n");
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+	if((bw->accum & 0x3fffffff) != test_pattern1[words]) {
+		printf("FAILED pattern match (bw->accum=%08X != %08X)\n", bw->accum&0x3fffffff, test_pattern1[words]);
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+	printf("OK\n");
+	FLAC__bitwriter_dump(bw, stdout);
+
+	printf("testing utf8_uint32(0x00000000)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint32(bw, 0x00000000);
+	ok = TOTAL_BITS(bw) == 8 && (bw->accum & 0xff) == 0;
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint32(0x0000007F)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint32(bw, 0x0000007F);
+	ok = TOTAL_BITS(bw) == 8 && (bw->accum & 0xff) == 0x7F;
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint32(0x00000080)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint32(bw, 0x00000080);
+	ok = TOTAL_BITS(bw) == 16 && (bw->accum & 0xffff) == 0xC280;
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint32(0x000007FF)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint32(bw, 0x000007FF);
+	ok = TOTAL_BITS(bw) == 16 && (bw->accum & 0xffff) == 0xDFBF;
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint32(0x00000800)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint32(bw, 0x00000800);
+	ok = TOTAL_BITS(bw) == 24 && (bw->accum & 0xffffff) == 0xE0A080;
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint32(0x0000FFFF)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint32(bw, 0x0000FFFF);
+	ok = TOTAL_BITS(bw) == 24 && (bw->accum & 0xffffff) == 0xEFBFBF;
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint32(0x00010000)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint32(bw, 0x00010000);
+#if WORDS_BIGENDIAN
+	ok = TOTAL_BITS(bw) == 32 && bw->buffer[0] == 0xF0908080;
+#else
+	ok = TOTAL_BITS(bw) == 32 && bw->buffer[0] == 0x808090F0;
+#endif
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint32(0x001FFFFF)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint32(bw, 0x001FFFFF);
+#if WORDS_BIGENDIAN
+	ok = TOTAL_BITS(bw) == 32 && bw->buffer[0] == 0xF7BFBFBF;
+#else
+	ok = TOTAL_BITS(bw) == 32 && bw->buffer[0] == 0xBFBFBFF7;
+#endif
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint32(0x00200000)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint32(bw, 0x00200000);
+#if WORDS_BIGENDIAN
+	ok = TOTAL_BITS(bw) == 40 && bw->buffer[0] == 0xF8888080 && (bw->accum & 0xff) == 0x80;
+#else
+	ok = TOTAL_BITS(bw) == 40 && bw->buffer[0] == 0x808088F8 && (bw->accum & 0xff) == 0x80;
+#endif
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint32(0x03FFFFFF)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint32(bw, 0x03FFFFFF);
+#if WORDS_BIGENDIAN
+	ok = TOTAL_BITS(bw) == 40 && bw->buffer[0] == 0xFBBFBFBF && (bw->accum & 0xff) == 0xBF;
+#else
+	ok = TOTAL_BITS(bw) == 40 && bw->buffer[0] == 0xBFBFBFFB && (bw->accum & 0xff) == 0xBF;
+#endif
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint32(0x04000000)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint32(bw, 0x04000000);
+#if WORDS_BIGENDIAN
+	ok = TOTAL_BITS(bw) == 48 && bw->buffer[0] == 0xFC848080 && (bw->accum & 0xffff) == 0x8080;
+#else
+	ok = TOTAL_BITS(bw) == 48 && bw->buffer[0] == 0x808084FC && (bw->accum & 0xffff) == 0x8080;
+#endif
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint32(0x7FFFFFFF)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint32(bw, 0x7FFFFFFF);
+#if WORDS_BIGENDIAN
+	ok = TOTAL_BITS(bw) == 48 && bw->buffer[0] == 0xFDBFBFBF && (bw->accum & 0xffff) == 0xBFBF;
+#else
+	ok = TOTAL_BITS(bw) == 48 && bw->buffer[0] == 0xBFBFBFFD && (bw->accum & 0xffff) == 0xBFBF;
+#endif
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint64(0x0000000000000000)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint64(bw, 0x0000000000000000);
+	ok = TOTAL_BITS(bw) == 8 && (bw->accum & 0xff) == 0;
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint64(0x000000000000007F)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint64(bw, 0x000000000000007F);
+	ok = TOTAL_BITS(bw) == 8 && (bw->accum & 0xff) == 0x7F;
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint64(0x0000000000000080)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint64(bw, 0x0000000000000080);
+	ok = TOTAL_BITS(bw) == 16 && (bw->accum & 0xffff) == 0xC280;
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint64(0x00000000000007FF)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint64(bw, 0x00000000000007FF);
+	ok = TOTAL_BITS(bw) == 16 && (bw->accum & 0xffff) == 0xDFBF;
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint64(0x0000000000000800)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint64(bw, 0x0000000000000800);
+	ok = TOTAL_BITS(bw) == 24 && (bw->accum & 0xffffff) == 0xE0A080;
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint64(0x000000000000FFFF)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint64(bw, 0x000000000000FFFF);
+	ok = TOTAL_BITS(bw) == 24 && (bw->accum & 0xffffff) == 0xEFBFBF;
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint64(0x0000000000010000)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint64(bw, 0x0000000000010000);
+#if WORDS_BIGENDIAN
+	ok = TOTAL_BITS(bw) == 32 && bw->buffer[0] == 0xF0908080;
+#else
+	ok = TOTAL_BITS(bw) == 32 && bw->buffer[0] == 0x808090F0;
+#endif
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint64(0x00000000001FFFFF)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint64(bw, 0x00000000001FFFFF);
+#if WORDS_BIGENDIAN
+	ok = TOTAL_BITS(bw) == 32 && bw->buffer[0] == 0xF7BFBFBF;
+#else
+	ok = TOTAL_BITS(bw) == 32 && bw->buffer[0] == 0xBFBFBFF7;
+#endif
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint64(0x0000000000200000)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint64(bw, 0x0000000000200000);
+#if WORDS_BIGENDIAN
+	ok = TOTAL_BITS(bw) == 40 && bw->buffer[0] == 0xF8888080 && (bw->accum & 0xff) == 0x80;
+#else
+	ok = TOTAL_BITS(bw) == 40 && bw->buffer[0] == 0x808088F8 && (bw->accum & 0xff) == 0x80;
+#endif
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint64(0x0000000003FFFFFF)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint64(bw, 0x0000000003FFFFFF);
+#if WORDS_BIGENDIAN
+	ok = TOTAL_BITS(bw) == 40 && bw->buffer[0] == 0xFBBFBFBF && (bw->accum & 0xff) == 0xBF;
+#else
+	ok = TOTAL_BITS(bw) == 40 && bw->buffer[0] == 0xBFBFBFFB && (bw->accum & 0xff) == 0xBF;
+#endif
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint64(0x0000000004000000)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint64(bw, 0x0000000004000000);
+#if WORDS_BIGENDIAN
+	ok = TOTAL_BITS(bw) == 48 && bw->buffer[0] == 0xFC848080 && (bw->accum & 0xffff) == 0x8080;
+#else
+	ok = TOTAL_BITS(bw) == 48 && bw->buffer[0] == 0x808084FC && (bw->accum & 0xffff) == 0x8080;
+#endif
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint64(0x000000007FFFFFFF)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint64(bw, 0x000000007FFFFFFF);
+#if WORDS_BIGENDIAN
+	ok = TOTAL_BITS(bw) == 48 && bw->buffer[0] == 0xFDBFBFBF && (bw->accum & 0xffff) == 0xBFBF;
+#else
+	ok = TOTAL_BITS(bw) == 48 && bw->buffer[0] == 0xBFBFBFFD && (bw->accum & 0xffff) == 0xBFBF;
+#endif
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint64(0x0000000080000000)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint64(bw, 0x0000000080000000);
+#if WORDS_BIGENDIAN
+	ok = TOTAL_BITS(bw) == 56 && bw->buffer[0] == 0xFE828080 && (bw->accum & 0xffffff) == 0x808080;
+#else
+	ok = TOTAL_BITS(bw) == 56 && bw->buffer[0] == 0x808082FE && (bw->accum & 0xffffff) == 0x808080;
+#endif
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing utf8_uint64(0x0000000FFFFFFFFF)... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_utf8_uint64(bw, FLAC__U64L(0x0000000FFFFFFFFF));
+#if WORDS_BIGENDIAN
+	ok = TOTAL_BITS(bw) == 56 && bw->buffer[0] == 0xFEBFBFBF && (bw->accum & 0xffffff) == 0xBFBFBF;
+#else
+	ok = TOTAL_BITS(bw) == 56 && bw->buffer[0] == 0xBFBFBFFE && (bw->accum & 0xffffff) == 0xBFBFBF;
+#endif
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+
+	printf("testing grow... ");
+	FLAC__bitwriter_clear(bw);
+	FLAC__bitwriter_write_raw_uint32(bw, 0x5, 4);
+	j = bw->capacity;
+	for(i = 0; i < j; i++)
+		FLAC__bitwriter_write_raw_uint32(bw, 0xaaaaaaaa, 32);
+#if WORDS_BIGENDIAN
+	ok = TOTAL_BITS(bw) == i*32+4 && bw->buffer[0] == 0x5aaaaaaa && (bw->accum & 0xf) == 0xa;
+#else
+	ok = TOTAL_BITS(bw) == i*32+4 && bw->buffer[0] == 0xaaaaaa5a && (bw->accum & 0xf) == 0xa;
+#endif
+	printf("%s\n", ok?"OK":"FAILED");
+	if(!ok) {
+		FLAC__bitwriter_dump(bw, stdout);
+		return false;
+	}
+	printf("capacity = %u\n", bw->capacity);
+
+	printf("testing free... ");
+	FLAC__bitwriter_free(bw);
+	printf("OK\n");
+
+	printf("testing delete... ");
+	FLAC__bitwriter_delete(bw);
+	printf("OK\n");
+
+	printf("\nPASSED!\n");
+	return true;
+}
diff --git a/audio-codec/flac/test_libFLAC/bitwriter.h b/audio-codec/flac/test_libFLAC/bitwriter.h
new file mode 100644
index 0000000..44b6ade
--- /dev/null
+++ b/audio-codec/flac/test_libFLAC/bitwriter.h
@@ -0,0 +1,26 @@
+/* test_libFLAC - Unit tester for libFLAC
+ * Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * 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 FLAC__TEST_LIBFLAC_BITBUFFER_H
+#define FLAC__TEST_LIBFLAC_BITBUFFER_H
+
+#include "FLAC/ordinals.h"
+
+FLAC__bool test_bitwriter(void);
+
+#endif
diff --git a/audio-codec/flac/test_libFLAC/decoders.c b/audio-codec/flac/test_libFLAC/decoders.c
new file mode 100644
index 0000000..5941a2a
--- /dev/null
+++ b/audio-codec/flac/test_libFLAC/decoders.c
@@ -0,0 +1,1048 @@
+/* test_libFLAC - Unit tester for libFLAC
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * 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.
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#if defined _MSC_VER || defined __MINGW32__
+#if _MSC_VER <= 1600 /* @@@ [2G limit] */
+#define fseeko fseek
+#define ftello ftell
+#endif
+#endif
+#include "decoders.h"
+#include "FLAC/assert.h"
+#include "FLAC/stream_decoder.h"
+#include "share/grabbag.h"
+#include "test_libs_common/file_utils_flac.h"
+#include "test_libs_common/metadata_utils.h"
+
+typedef enum {
+	LAYER_STREAM = 0, /* FLAC__stream_decoder_init_[ogg_]stream() without seeking */
+	LAYER_SEEKABLE_STREAM, /* FLAC__stream_decoder_init_[ogg_]stream() with seeking */
+	LAYER_FILE, /* FLAC__stream_decoder_init_[ogg_]FILE() */
+	LAYER_FILENAME /* FLAC__stream_decoder_init_[ogg_]file() */
+} Layer;
+
+static const char * const LayerString[] = {
+	"Stream",
+	"Seekable Stream",
+	"FILE*",
+	"Filename"
+};
+
+typedef struct {
+	Layer layer;
+	FILE *file;
+	unsigned current_metadata_number;
+	FLAC__bool ignore_errors;
+	FLAC__bool error_occurred;
+} StreamDecoderClientData;
+
+static FLAC__StreamMetadata streaminfo_, padding_, seektable_, application1_, application2_, vorbiscomment_, cuesheet_, picture_, unknown_;
+static FLAC__StreamMetadata *expected_metadata_sequence_[9];
+static unsigned num_expected_;
+static off_t flacfilesize_;
+
+static const char *flacfilename(FLAC__bool is_ogg)
+{
+	return is_ogg? "/data/metadata.oga" : "/data/metadata.flac";
+}
+
+static FLAC__bool die_(const char *msg)
+{
+	printf("ERROR: %s\n", msg);
+	return false;
+}
+
+static FLAC__bool die_s_(const char *msg, const FLAC__StreamDecoder *decoder)
+{
+	FLAC__StreamDecoderState state = FLAC__stream_decoder_get_state(decoder);
+
+	if(msg)
+		printf("FAILED, %s", msg);
+	else
+		printf("FAILED");
+
+	printf(", state = %u (%s)\n", (unsigned)state, FLAC__StreamDecoderStateString[state]);
+
+	return false;
+}
+
+static void init_metadata_blocks_(void)
+{
+	mutils__init_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &picture_, &unknown_);
+}
+
+static void free_metadata_blocks_(void)
+{
+	mutils__free_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &picture_, &unknown_);
+}
+
+static FLAC__bool generate_file_(FLAC__bool is_ogg)
+{
+	printf("\n\ngenerating %sFLAC file for decoder tests...\n", is_ogg? "Ogg ":"");
+
+	num_expected_ = 0;
+	expected_metadata_sequence_[num_expected_++] = &padding_;
+	expected_metadata_sequence_[num_expected_++] = &seektable_;
+	expected_metadata_sequence_[num_expected_++] = &application1_;
+	expected_metadata_sequence_[num_expected_++] = &application2_;
+	expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
+	expected_metadata_sequence_[num_expected_++] = &cuesheet_;
+	expected_metadata_sequence_[num_expected_++] = &picture_;
+	expected_metadata_sequence_[num_expected_++] = &unknown_;
+	/* WATCHOUT: for Ogg FLAC the encoder should move the VORBIS_COMMENT block to the front, right after STREAMINFO */
+
+	if(!file_utils__generate_flacfile(is_ogg, flacfilename(is_ogg), &flacfilesize_, 512 * 1024, &streaminfo_, expected_metadata_sequence_, num_expected_))
+		return die_("creating the encoded file");
+
+	return true;
+}
+
+static FLAC__StreamDecoderReadStatus stream_decoder_read_callback_(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
+{
+	StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
+	const size_t requested_bytes = *bytes;
+
+	(void)decoder;
+
+	if(0 == dcd) {
+		printf("ERROR: client_data in read callback is NULL\n");
+		return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
+	}
+
+	if(dcd->error_occurred)
+		return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
+
+	if(feof(dcd->file)) {
+		*bytes = 0;
+		return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
+	}
+	else if(requested_bytes > 0) {
+		*bytes = fread(buffer, 1, requested_bytes, dcd->file);
+		if(*bytes == 0) {
+			if(feof(dcd->file))
+				return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
+			else
+				return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
+		}
+		else {
+			return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
+		}
+	}
+	else
+		return FLAC__STREAM_DECODER_READ_STATUS_ABORT; /* abort to avoid a deadlock */
+}
+
+static FLAC__StreamDecoderSeekStatus stream_decoder_seek_callback_(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
+{
+	StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
+
+	(void)decoder;
+
+	if(0 == dcd) {
+		printf("ERROR: client_data in seek callback is NULL\n");
+		return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
+	}
+
+	if(dcd->error_occurred)
+		return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
+
+	if(fseeko(dcd->file, (off_t)absolute_byte_offset, SEEK_SET) < 0) {
+		dcd->error_occurred = true;
+		return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
+	}
+
+	return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
+}
+
+static FLAC__StreamDecoderTellStatus stream_decoder_tell_callback_(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
+{
+	StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
+	off_t offset;
+
+	(void)decoder;
+
+	if(0 == dcd) {
+		printf("ERROR: client_data in tell callback is NULL\n");
+		return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
+	}
+
+	if(dcd->error_occurred)
+		return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
+
+	offset = ftello(dcd->file);
+	*absolute_byte_offset = (FLAC__uint64)offset;
+
+	if(offset < 0) {
+		dcd->error_occurred = true;
+		return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
+	}
+
+	return FLAC__STREAM_DECODER_TELL_STATUS_OK;
+}
+
+static FLAC__StreamDecoderLengthStatus stream_decoder_length_callback_(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
+{
+	StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
+
+	(void)decoder;
+
+	if(0 == dcd) {
+		printf("ERROR: client_data in length callback is NULL\n");
+		return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
+	}
+
+	if(dcd->error_occurred)
+		return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
+
+	*stream_length = (FLAC__uint64)flacfilesize_;
+	return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
+}
+
+static FLAC__bool stream_decoder_eof_callback_(const FLAC__StreamDecoder *decoder, void *client_data)
+{
+	StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
+
+	(void)decoder;
+
+	if(0 == dcd) {
+		printf("ERROR: client_data in eof callback is NULL\n");
+		return true;
+	}
+
+	if(dcd->error_occurred)
+		return true;
+
+	return feof(dcd->file);
+}
+
+static FLAC__StreamDecoderWriteStatus stream_decoder_write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
+{
+	StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
+
+	(void)decoder, (void)buffer;
+
+	if(0 == dcd) {
+		printf("ERROR: client_data in write callback is NULL\n");
+		return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
+	}
+
+	if(dcd->error_occurred)
+		return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
+
+	if(
+		(frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER && frame->header.number.frame_number == 0) ||
+		(frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER && frame->header.number.sample_number == 0)
+	) {
+		printf("content... ");
+		fflush(stdout);
+	}
+
+	return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
+}
+
+static void stream_decoder_metadata_callback_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
+{
+	StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
+
+	(void)decoder;
+
+	if(0 == dcd) {
+		printf("ERROR: client_data in metadata callback is NULL\n");
+		return;
+	}
+
+	if(dcd->error_occurred)
+		return;
+
+	printf("%d... ", dcd->current_metadata_number);
+	fflush(stdout);
+
+	if(dcd->current_metadata_number >= num_expected_) {
+		(void)die_("got more metadata blocks than expected");
+		dcd->error_occurred = true;
+	}
+	else {
+		if(!mutils__compare_block(expected_metadata_sequence_[dcd->current_metadata_number], metadata)) {
+			(void)die_("metadata block mismatch");
+			dcd->error_occurred = true;
+		}
+	}
+	dcd->current_metadata_number++;
+}
+
+static void stream_decoder_error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
+{
+	StreamDecoderClientData *dcd = (StreamDecoderClientData*)client_data;
+
+	(void)decoder;
+
+	if(0 == dcd) {
+		printf("ERROR: client_data in error callback is NULL\n");
+		return;
+	}
+
+	if(!dcd->ignore_errors) {
+		printf("ERROR: got error callback: err = %u (%s)\n", (unsigned)status, FLAC__StreamDecoderErrorStatusString[status]);
+		dcd->error_occurred = true;
+	}
+}
+
+static FLAC__bool stream_decoder_test_respond_(FLAC__StreamDecoder *decoder, StreamDecoderClientData *dcd, FLAC__bool is_ogg)
+{
+	FLAC__StreamDecoderInitStatus init_status;
+
+	if(!FLAC__stream_decoder_set_md5_checking(decoder, true))
+		return die_s_("at FLAC__stream_decoder_set_md5_checking(), returned false", decoder);
+
+	/* for FLAC__stream_encoder_init_FILE(), the FLAC__stream_encoder_finish() closes the file so we have to keep re-opening: */
+	if(dcd->layer == LAYER_FILE) {
+		printf("opening %sFLAC file... ", is_ogg? "Ogg ":"");
+		dcd->file = fopen(flacfilename(is_ogg), "rb");
+		if(0 == dcd->file) {
+			printf("ERROR (%s)\n", strerror(errno));
+			return false;
+		}
+		printf("OK\n");
+	}
+
+	switch(dcd->layer) {
+		case LAYER_STREAM:
+			printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":"");
+			init_status = is_ogg?
+				FLAC__stream_decoder_init_ogg_stream(decoder, stream_decoder_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd) :
+				FLAC__stream_decoder_init_stream(decoder, stream_decoder_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd)
+			;
+			break;
+		case LAYER_SEEKABLE_STREAM:
+			printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":"");
+			init_status = is_ogg?
+				FLAC__stream_decoder_init_ogg_stream(decoder, stream_decoder_read_callback_, stream_decoder_seek_callback_, stream_decoder_tell_callback_, stream_decoder_length_callback_, stream_decoder_eof_callback_, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd) :
+				FLAC__stream_decoder_init_stream(decoder, stream_decoder_read_callback_, stream_decoder_seek_callback_, stream_decoder_tell_callback_, stream_decoder_length_callback_, stream_decoder_eof_callback_, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd);
+			break;
+		case LAYER_FILE:
+			printf("testing FLAC__stream_decoder_init_%sFILE()... ", is_ogg? "ogg_":"");
+			init_status = is_ogg?
+				FLAC__stream_decoder_init_ogg_FILE(decoder, dcd->file, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd) :
+				FLAC__stream_decoder_init_FILE(decoder, dcd->file, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd);
+			break;
+		case LAYER_FILENAME:
+			printf("testing FLAC__stream_decoder_init_%sfile()... ", is_ogg? "ogg_":"");
+			init_status = is_ogg?
+				FLAC__stream_decoder_init_ogg_file(decoder, flacfilename(is_ogg), stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd) :
+				FLAC__stream_decoder_init_file(decoder, flacfilename(is_ogg), stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, dcd);
+			break;
+		default:
+			die_("internal error 000");
+			return false;
+	}
+	if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK)
+		return die_s_(0, decoder);
+	printf("OK\n");
+
+	dcd->current_metadata_number = 0;
+
+	if(dcd->layer < LAYER_FILE && fseeko(dcd->file, 0, SEEK_SET) < 0) {
+		printf("FAILED rewinding input, errno = %d\n", errno);
+		return false;
+	}
+
+	printf("testing FLAC__stream_decoder_process_until_end_of_stream()... ");
+	if(!FLAC__stream_decoder_process_until_end_of_stream(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_finish()... ");
+	if(!FLAC__stream_decoder_finish(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	return true;
+}
+
+static FLAC__bool test_stream_decoder(Layer layer, FLAC__bool is_ogg)
+{
+	FLAC__StreamDecoder *decoder;
+	FLAC__StreamDecoderInitStatus init_status;
+	FLAC__StreamDecoderState state;
+	StreamDecoderClientData decoder_client_data;
+	FLAC__bool expect;
+
+	decoder_client_data.layer = layer;
+
+	printf("\n+++ libFLAC unit test: FLAC__StreamDecoder (layer: %s, format: %s)\n\n", LayerString[layer], is_ogg? "Ogg FLAC" : "FLAC");
+
+	printf("testing FLAC__stream_decoder_new()... ");
+	decoder = FLAC__stream_decoder_new();
+	if(0 == decoder) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_delete()... ");
+	FLAC__stream_decoder_delete(decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_new()... ");
+	decoder = FLAC__stream_decoder_new();
+	if(0 == decoder) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	printf("OK\n");
+
+	switch(layer) {
+		case LAYER_STREAM:
+		case LAYER_SEEKABLE_STREAM:
+			printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":"");
+			init_status = is_ogg?
+				FLAC__stream_decoder_init_ogg_stream(decoder, 0, 0, 0, 0, 0, 0, 0, 0, 0) :
+				FLAC__stream_decoder_init_stream(decoder, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+			break;
+		case LAYER_FILE:
+			printf("testing FLAC__stream_decoder_init_%sFILE()... ", is_ogg? "ogg_":"");
+			init_status = is_ogg?
+				FLAC__stream_decoder_init_ogg_FILE(decoder, stdin, 0, 0, 0, 0) :
+				FLAC__stream_decoder_init_FILE(decoder, stdin, 0, 0, 0, 0);
+			break;
+		case LAYER_FILENAME:
+			printf("testing FLAC__stream_decoder_init_%sfile()... ", is_ogg? "ogg_":"");
+			init_status = is_ogg?
+				FLAC__stream_decoder_init_ogg_file(decoder, flacfilename(is_ogg), 0, 0, 0, 0) :
+				FLAC__stream_decoder_init_file(decoder, flacfilename(is_ogg), 0, 0, 0, 0);
+			break;
+		default:
+			die_("internal error 003");
+			return false;
+	}
+	if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS)
+		return die_s_(0, decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_delete()... ");
+	FLAC__stream_decoder_delete(decoder);
+	printf("OK\n");
+
+	num_expected_ = 0;
+	expected_metadata_sequence_[num_expected_++] = &streaminfo_;
+
+	printf("testing FLAC__stream_decoder_new()... ");
+	decoder = FLAC__stream_decoder_new();
+	if(0 == decoder) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	printf("OK\n");
+
+	if(is_ogg) {
+		printf("testing FLAC__stream_decoder_set_ogg_serial_number()... ");
+		if(!FLAC__stream_decoder_set_ogg_serial_number(decoder, file_utils__ogg_serial_number))
+			return die_s_("returned false", decoder);
+		printf("OK\n");
+	}
+
+	printf("testing FLAC__stream_decoder_set_md5_checking()... ");
+	if(!FLAC__stream_decoder_set_md5_checking(decoder, true))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	if(layer < LAYER_FILENAME) {
+		printf("opening %sFLAC file... ", is_ogg? "Ogg ":"");
+		decoder_client_data.file = fopen(flacfilename(is_ogg), "rb");
+		if(0 == decoder_client_data.file) {
+			printf("ERROR (%s)\n", strerror(errno));
+			return false;
+		}
+		printf("OK\n");
+	}
+
+	switch(layer) {
+		case LAYER_STREAM:
+			printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":"");
+			init_status = is_ogg?
+				FLAC__stream_decoder_init_ogg_stream(decoder, stream_decoder_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data) :
+				FLAC__stream_decoder_init_stream(decoder, stream_decoder_read_callback_, /*seek_callback=*/0, /*tell_callback=*/0, /*length_callback=*/0, /*eof_callback=*/0, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data);
+			break;
+		case LAYER_SEEKABLE_STREAM:
+			printf("testing FLAC__stream_decoder_init_%sstream()... ", is_ogg? "ogg_":"");
+			init_status = is_ogg?
+				FLAC__stream_decoder_init_ogg_stream(decoder, stream_decoder_read_callback_, stream_decoder_seek_callback_, stream_decoder_tell_callback_, stream_decoder_length_callback_, stream_decoder_eof_callback_, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data) :
+				FLAC__stream_decoder_init_stream(decoder, stream_decoder_read_callback_, stream_decoder_seek_callback_, stream_decoder_tell_callback_, stream_decoder_length_callback_, stream_decoder_eof_callback_, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data);
+			break;
+		case LAYER_FILE:
+			printf("testing FLAC__stream_decoder_init_%sFILE()... ", is_ogg? "ogg_":"");
+			init_status = is_ogg?
+				FLAC__stream_decoder_init_ogg_FILE(decoder, decoder_client_data.file, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data) :
+				FLAC__stream_decoder_init_FILE(decoder, decoder_client_data.file, stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data);
+			break;
+		case LAYER_FILENAME:
+			printf("testing FLAC__stream_decoder_init_%sfile()... ", is_ogg? "ogg_":"");
+			init_status = is_ogg?
+				FLAC__stream_decoder_init_ogg_file(decoder, flacfilename(is_ogg), stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data) :
+				FLAC__stream_decoder_init_file(decoder, flacfilename(is_ogg), stream_decoder_write_callback_, stream_decoder_metadata_callback_, stream_decoder_error_callback_, &decoder_client_data);
+			break;
+		default:
+			die_("internal error 009");
+			return false;
+	}
+	if(init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK)
+		return die_s_(0, decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_get_state()... ");
+	state = FLAC__stream_decoder_get_state(decoder);
+	printf("returned state = %u (%s)... OK\n", state, FLAC__StreamDecoderStateString[state]);
+
+	decoder_client_data.current_metadata_number = 0;
+	decoder_client_data.ignore_errors = false;
+	decoder_client_data.error_occurred = false;
+
+	printf("testing FLAC__stream_decoder_get_md5_checking()... ");
+	if(!FLAC__stream_decoder_get_md5_checking(decoder)) {
+		printf("FAILED, returned false, expected true\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_process_until_end_of_metadata()... ");
+	if(!FLAC__stream_decoder_process_until_end_of_metadata(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_process_single()... ");
+	if(!FLAC__stream_decoder_process_single(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_skip_single_frame()... ");
+	if(!FLAC__stream_decoder_skip_single_frame(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	if(layer < LAYER_FILE) {
+		printf("testing FLAC__stream_decoder_flush()... ");
+		if(!FLAC__stream_decoder_flush(decoder))
+			return die_s_("returned false", decoder);
+		printf("OK\n");
+
+		decoder_client_data.ignore_errors = true;
+		printf("testing FLAC__stream_decoder_process_single()... ");
+		if(!FLAC__stream_decoder_process_single(decoder))
+			return die_s_("returned false", decoder);
+		printf("OK\n");
+		decoder_client_data.ignore_errors = false;
+	}
+
+	expect = (layer != LAYER_STREAM);
+	printf("testing FLAC__stream_decoder_seek_absolute()... ");
+	if(FLAC__stream_decoder_seek_absolute(decoder, 0) != expect)
+		return die_s_(expect? "returned false" : "returned true", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_process_until_end_of_stream()... ");
+	if(!FLAC__stream_decoder_process_until_end_of_stream(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	expect = (layer != LAYER_STREAM);
+	printf("testing FLAC__stream_decoder_seek_absolute()... ");
+	if(FLAC__stream_decoder_seek_absolute(decoder, 0) != expect)
+		return die_s_(expect? "returned false" : "returned true", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_get_channels()... ");
+	{
+		unsigned channels = FLAC__stream_decoder_get_channels(decoder);
+		if(channels != streaminfo_.data.stream_info.channels) {
+			printf("FAILED, returned %u, expected %u\n", channels, streaminfo_.data.stream_info.channels);
+			return false;
+		}
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_get_bits_per_sample()... ");
+	{
+		unsigned bits_per_sample = FLAC__stream_decoder_get_bits_per_sample(decoder);
+		if(bits_per_sample != streaminfo_.data.stream_info.bits_per_sample) {
+			printf("FAILED, returned %u, expected %u\n", bits_per_sample, streaminfo_.data.stream_info.bits_per_sample);
+			return false;
+		}
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_get_sample_rate()... ");
+	{
+		unsigned sample_rate = FLAC__stream_decoder_get_sample_rate(decoder);
+		if(sample_rate != streaminfo_.data.stream_info.sample_rate) {
+			printf("FAILED, returned %u, expected %u\n", sample_rate, streaminfo_.data.stream_info.sample_rate);
+			return false;
+		}
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_get_blocksize()... ");
+	{
+		unsigned blocksize = FLAC__stream_decoder_get_blocksize(decoder);
+		/* value could be anything since we're at the last block, so accept any reasonable answer */
+		printf("returned %u... %s\n", blocksize, blocksize>0? "OK" : "FAILED");
+		if(blocksize == 0)
+			return false;
+	}
+
+	printf("testing FLAC__stream_decoder_get_channel_assignment()... ");
+	{
+		FLAC__ChannelAssignment ca = FLAC__stream_decoder_get_channel_assignment(decoder);
+		printf("returned %u (%s)... OK\n", (unsigned)ca, FLAC__ChannelAssignmentString[ca]);
+	}
+
+	if(layer < LAYER_FILE) {
+		printf("testing FLAC__stream_decoder_reset()... ");
+		if(!FLAC__stream_decoder_reset(decoder)) {
+			state = FLAC__stream_decoder_get_state(decoder);
+			printf("FAILED, returned false, state = %u (%s)\n", state, FLAC__StreamDecoderStateString[state]);
+			return false;
+		}
+		printf("OK\n");
+
+		if(layer == LAYER_STREAM) {
+			/* after a reset() we have to rewind the input ourselves */
+			printf("rewinding input... ");
+			if(fseeko(decoder_client_data.file, 0, SEEK_SET) < 0) {
+				printf("FAILED, errno = %d\n", errno);
+				return false;
+			}
+			printf("OK\n");
+		}
+
+		decoder_client_data.current_metadata_number = 0;
+
+		printf("testing FLAC__stream_decoder_process_until_end_of_stream()... ");
+		if(!FLAC__stream_decoder_process_until_end_of_stream(decoder))
+			return die_s_("returned false", decoder);
+		printf("OK\n");
+	}
+
+	printf("testing FLAC__stream_decoder_finish()... ");
+	if(!FLAC__stream_decoder_finish(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	/*
+	 * respond all
+	 */
+
+	printf("testing FLAC__stream_decoder_set_metadata_respond_all()... ");
+	if(!FLAC__stream_decoder_set_metadata_respond_all(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	num_expected_ = 0;
+	if(is_ogg) { /* encoder moves vorbis comment after streaminfo according to ogg mapping */
+		expected_metadata_sequence_[num_expected_++] = &streaminfo_;
+		expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
+		expected_metadata_sequence_[num_expected_++] = &padding_;
+		expected_metadata_sequence_[num_expected_++] = &seektable_;
+		expected_metadata_sequence_[num_expected_++] = &application1_;
+		expected_metadata_sequence_[num_expected_++] = &application2_;
+		expected_metadata_sequence_[num_expected_++] = &cuesheet_;
+		expected_metadata_sequence_[num_expected_++] = &picture_;
+		expected_metadata_sequence_[num_expected_++] = &unknown_;
+	}
+	else {
+		expected_metadata_sequence_[num_expected_++] = &streaminfo_;
+		expected_metadata_sequence_[num_expected_++] = &padding_;
+		expected_metadata_sequence_[num_expected_++] = &seektable_;
+		expected_metadata_sequence_[num_expected_++] = &application1_;
+		expected_metadata_sequence_[num_expected_++] = &application2_;
+		expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
+		expected_metadata_sequence_[num_expected_++] = &cuesheet_;
+		expected_metadata_sequence_[num_expected_++] = &picture_;
+		expected_metadata_sequence_[num_expected_++] = &unknown_;
+	}
+
+	if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
+		return false;
+
+	/*
+	 * ignore all
+	 */
+
+	printf("testing FLAC__stream_decoder_set_metadata_ignore_all()... ");
+	if(!FLAC__stream_decoder_set_metadata_ignore_all(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	num_expected_ = 0;
+
+	if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
+		return false;
+
+	/*
+	 * respond all, ignore VORBIS_COMMENT
+	 */
+
+	printf("testing FLAC__stream_decoder_set_metadata_respond_all()... ");
+	if(!FLAC__stream_decoder_set_metadata_respond_all(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_set_metadata_ignore(VORBIS_COMMENT)... ");
+	if(!FLAC__stream_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	num_expected_ = 0;
+	expected_metadata_sequence_[num_expected_++] = &streaminfo_;
+	expected_metadata_sequence_[num_expected_++] = &padding_;
+	expected_metadata_sequence_[num_expected_++] = &seektable_;
+	expected_metadata_sequence_[num_expected_++] = &application1_;
+	expected_metadata_sequence_[num_expected_++] = &application2_;
+	expected_metadata_sequence_[num_expected_++] = &cuesheet_;
+	expected_metadata_sequence_[num_expected_++] = &picture_;
+	expected_metadata_sequence_[num_expected_++] = &unknown_;
+
+	if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
+		return false;
+
+	/*
+	 * respond all, ignore APPLICATION
+	 */
+
+	printf("testing FLAC__stream_decoder_set_metadata_respond_all()... ");
+	if(!FLAC__stream_decoder_set_metadata_respond_all(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_set_metadata_ignore(APPLICATION)... ");
+	if(!FLAC__stream_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_APPLICATION))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	num_expected_ = 0;
+	if(is_ogg) { /* encoder moves vorbis comment after streaminfo according to ogg mapping */
+		expected_metadata_sequence_[num_expected_++] = &streaminfo_;
+		expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
+		expected_metadata_sequence_[num_expected_++] = &padding_;
+		expected_metadata_sequence_[num_expected_++] = &seektable_;
+		expected_metadata_sequence_[num_expected_++] = &cuesheet_;
+		expected_metadata_sequence_[num_expected_++] = &picture_;
+		expected_metadata_sequence_[num_expected_++] = &unknown_;
+	}
+	else {
+		expected_metadata_sequence_[num_expected_++] = &streaminfo_;
+		expected_metadata_sequence_[num_expected_++] = &padding_;
+		expected_metadata_sequence_[num_expected_++] = &seektable_;
+		expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
+		expected_metadata_sequence_[num_expected_++] = &cuesheet_;
+		expected_metadata_sequence_[num_expected_++] = &picture_;
+		expected_metadata_sequence_[num_expected_++] = &unknown_;
+	}
+
+	if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
+		return false;
+
+	/*
+	 * respond all, ignore APPLICATION id of app#1
+	 */
+
+	printf("testing FLAC__stream_decoder_set_metadata_respond_all()... ");
+	if(!FLAC__stream_decoder_set_metadata_respond_all(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_set_metadata_ignore_application(of app block #1)... ");
+	if(!FLAC__stream_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	num_expected_ = 0;
+	if(is_ogg) { /* encoder moves vorbis comment after streaminfo according to ogg mapping */
+		expected_metadata_sequence_[num_expected_++] = &streaminfo_;
+		expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
+		expected_metadata_sequence_[num_expected_++] = &padding_;
+		expected_metadata_sequence_[num_expected_++] = &seektable_;
+		expected_metadata_sequence_[num_expected_++] = &application2_;
+		expected_metadata_sequence_[num_expected_++] = &cuesheet_;
+		expected_metadata_sequence_[num_expected_++] = &picture_;
+		expected_metadata_sequence_[num_expected_++] = &unknown_;
+	}
+	else {
+		expected_metadata_sequence_[num_expected_++] = &streaminfo_;
+		expected_metadata_sequence_[num_expected_++] = &padding_;
+		expected_metadata_sequence_[num_expected_++] = &seektable_;
+		expected_metadata_sequence_[num_expected_++] = &application2_;
+		expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
+		expected_metadata_sequence_[num_expected_++] = &cuesheet_;
+		expected_metadata_sequence_[num_expected_++] = &picture_;
+		expected_metadata_sequence_[num_expected_++] = &unknown_;
+	}
+
+	if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
+		return false;
+
+	/*
+	 * respond all, ignore APPLICATION id of app#1 & app#2
+	 */
+
+	printf("testing FLAC__stream_decoder_set_metadata_respond_all()... ");
+	if(!FLAC__stream_decoder_set_metadata_respond_all(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_set_metadata_ignore_application(of app block #1)... ");
+	if(!FLAC__stream_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_set_metadata_ignore_application(of app block #2)... ");
+	if(!FLAC__stream_decoder_set_metadata_ignore_application(decoder, application2_.data.application.id))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	num_expected_ = 0;
+	if(is_ogg) { /* encoder moves vorbis comment after streaminfo according to ogg mapping */
+		expected_metadata_sequence_[num_expected_++] = &streaminfo_;
+		expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
+		expected_metadata_sequence_[num_expected_++] = &padding_;
+		expected_metadata_sequence_[num_expected_++] = &seektable_;
+		expected_metadata_sequence_[num_expected_++] = &cuesheet_;
+		expected_metadata_sequence_[num_expected_++] = &picture_;
+		expected_metadata_sequence_[num_expected_++] = &unknown_;
+	}
+	else {
+		expected_metadata_sequence_[num_expected_++] = &streaminfo_;
+		expected_metadata_sequence_[num_expected_++] = &padding_;
+		expected_metadata_sequence_[num_expected_++] = &seektable_;
+		expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
+		expected_metadata_sequence_[num_expected_++] = &cuesheet_;
+		expected_metadata_sequence_[num_expected_++] = &picture_;
+		expected_metadata_sequence_[num_expected_++] = &unknown_;
+	}
+
+	if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
+		return false;
+
+	/*
+	 * ignore all, respond VORBIS_COMMENT
+	 */
+
+	printf("testing FLAC__stream_decoder_set_metadata_ignore_all()... ");
+	if(!FLAC__stream_decoder_set_metadata_ignore_all(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_set_metadata_respond(VORBIS_COMMENT)... ");
+	if(!FLAC__stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	num_expected_ = 0;
+	expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
+
+	if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
+		return false;
+
+	/*
+	 * ignore all, respond APPLICATION
+	 */
+
+	printf("testing FLAC__stream_decoder_set_metadata_ignore_all()... ");
+	if(!FLAC__stream_decoder_set_metadata_ignore_all(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_set_metadata_respond(APPLICATION)... ");
+	if(!FLAC__stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_APPLICATION))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	num_expected_ = 0;
+	expected_metadata_sequence_[num_expected_++] = &application1_;
+	expected_metadata_sequence_[num_expected_++] = &application2_;
+
+	if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
+		return false;
+
+	/*
+	 * ignore all, respond APPLICATION id of app#1
+	 */
+
+	printf("testing FLAC__stream_decoder_set_metadata_ignore_all()... ");
+	if(!FLAC__stream_decoder_set_metadata_ignore_all(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_set_metadata_respond_application(of app block #1)... ");
+	if(!FLAC__stream_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	num_expected_ = 0;
+	expected_metadata_sequence_[num_expected_++] = &application1_;
+
+	if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
+		return false;
+
+	/*
+	 * ignore all, respond APPLICATION id of app#1 & app#2
+	 */
+
+	printf("testing FLAC__stream_decoder_set_metadata_ignore_all()... ");
+	if(!FLAC__stream_decoder_set_metadata_ignore_all(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_set_metadata_respond_application(of app block #1)... ");
+	if(!FLAC__stream_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_set_metadata_respond_application(of app block #2)... ");
+	if(!FLAC__stream_decoder_set_metadata_respond_application(decoder, application2_.data.application.id))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	num_expected_ = 0;
+	expected_metadata_sequence_[num_expected_++] = &application1_;
+	expected_metadata_sequence_[num_expected_++] = &application2_;
+
+	if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
+		return false;
+
+	/*
+	 * respond all, ignore APPLICATION, respond APPLICATION id of app#1
+	 */
+
+	printf("testing FLAC__stream_decoder_set_metadata_respond_all()... ");
+	if(!FLAC__stream_decoder_set_metadata_respond_all(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_set_metadata_ignore(APPLICATION)... ");
+	if(!FLAC__stream_decoder_set_metadata_ignore(decoder, FLAC__METADATA_TYPE_APPLICATION))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_set_metadata_respond_application(of app block #1)... ");
+	if(!FLAC__stream_decoder_set_metadata_respond_application(decoder, application1_.data.application.id))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	num_expected_ = 0;
+	if(is_ogg) { /* encoder moves vorbis comment after streaminfo according to ogg mapping */
+		expected_metadata_sequence_[num_expected_++] = &streaminfo_;
+		expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
+		expected_metadata_sequence_[num_expected_++] = &padding_;
+		expected_metadata_sequence_[num_expected_++] = &seektable_;
+		expected_metadata_sequence_[num_expected_++] = &application1_;
+		expected_metadata_sequence_[num_expected_++] = &cuesheet_;
+		expected_metadata_sequence_[num_expected_++] = &picture_;
+		expected_metadata_sequence_[num_expected_++] = &unknown_;
+	}
+	else {
+		expected_metadata_sequence_[num_expected_++] = &streaminfo_;
+		expected_metadata_sequence_[num_expected_++] = &padding_;
+		expected_metadata_sequence_[num_expected_++] = &seektable_;
+		expected_metadata_sequence_[num_expected_++] = &application1_;
+		expected_metadata_sequence_[num_expected_++] = &vorbiscomment_;
+		expected_metadata_sequence_[num_expected_++] = &cuesheet_;
+		expected_metadata_sequence_[num_expected_++] = &picture_;
+		expected_metadata_sequence_[num_expected_++] = &unknown_;
+	}
+
+	if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
+		return false;
+
+	/*
+	 * ignore all, respond APPLICATION, ignore APPLICATION id of app#1
+	 */
+
+	printf("testing FLAC__stream_decoder_set_metadata_ignore_all()... ");
+	if(!FLAC__stream_decoder_set_metadata_ignore_all(decoder))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_set_metadata_respond(APPLICATION)... ");
+	if(!FLAC__stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_APPLICATION))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_decoder_set_metadata_ignore_application(of app block #1)... ");
+	if(!FLAC__stream_decoder_set_metadata_ignore_application(decoder, application1_.data.application.id))
+		return die_s_("returned false", decoder);
+	printf("OK\n");
+
+	num_expected_ = 0;
+	expected_metadata_sequence_[num_expected_++] = &application2_;
+
+	if(!stream_decoder_test_respond_(decoder, &decoder_client_data, is_ogg))
+		return false;
+
+	if(layer < LAYER_FILE) /* for LAYER_FILE, FLAC__stream_decoder_finish() closes the file */
+		fclose(decoder_client_data.file);
+
+	printf("testing FLAC__stream_decoder_delete()... ");
+	FLAC__stream_decoder_delete(decoder);
+	printf("OK\n");
+
+	printf("\nPASSED!\n");
+
+	return true;
+}
+
+FLAC__bool test_decoders(void)
+{
+	FLAC__bool is_ogg = false;
+
+	while(1) {
+		init_metadata_blocks_();
+
+		if(!generate_file_(is_ogg))
+			return false;
+
+		if(!test_stream_decoder(LAYER_STREAM, is_ogg))
+			return false;
+
+		if(!test_stream_decoder(LAYER_SEEKABLE_STREAM, is_ogg))
+			return false;
+
+		if(!test_stream_decoder(LAYER_FILE, is_ogg))
+			return false;
+
+		if(!test_stream_decoder(LAYER_FILENAME, is_ogg))
+			return false;
+
+		(void) grabbag__file_remove_file(flacfilename(is_ogg));
+
+		free_metadata_blocks_();
+
+		if(!FLAC_API_SUPPORTS_OGG_FLAC || is_ogg)
+			break;
+		is_ogg = true;
+	}
+
+	return true;
+}
diff --git a/audio-codec/flac/test_libFLAC/decoders.h b/audio-codec/flac/test_libFLAC/decoders.h
new file mode 100644
index 0000000..11df106
--- /dev/null
+++ b/audio-codec/flac/test_libFLAC/decoders.h
@@ -0,0 +1,26 @@
+/* test_libFLAC - Unit tester for libFLAC
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * 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 FLAC__TEST_LIBFLAC_DECODERS_H
+#define FLAC__TEST_LIBFLAC_DECODERS_H
+
+#include "FLAC/ordinals.h"
+
+FLAC__bool test_decoders(void);
+
+#endif
diff --git a/audio-codec/flac/test_libFLAC/encoders.c b/audio-codec/flac/test_libFLAC/encoders.c
new file mode 100644
index 0000000..4410421
--- /dev/null
+++ b/audio-codec/flac/test_libFLAC/encoders.c
@@ -0,0 +1,521 @@
+/* test_libFLAC - Unit tester for libFLAC
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * 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.
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "encoders.h"
+#include "FLAC/assert.h"
+#include "FLAC/stream_encoder.h"
+#include "share/grabbag.h"
+#include "test_libs_common/file_utils_flac.h"
+#include "test_libs_common/metadata_utils.h"
+
+typedef enum {
+	LAYER_STREAM = 0, /* FLAC__stream_encoder_init_[ogg_]stream() without seeking */
+	LAYER_SEEKABLE_STREAM, /* FLAC__stream_encoder_init_[ogg_]stream() with seeking */
+	LAYER_FILE, /* FLAC__stream_encoder_init_[ogg_]FILE() */
+	LAYER_FILENAME /* FLAC__stream_encoder_init_[ogg_]file() */
+} Layer;
+
+static const char * const LayerString[] = {
+	"Stream",
+	"Seekable Stream",
+	"FILE*",
+	"Filename"
+};
+
+static FLAC__StreamMetadata streaminfo_, padding_, seektable_, application1_, application2_, vorbiscomment_, cuesheet_, picture_, unknown_;
+static FLAC__StreamMetadata *metadata_sequence_[] = { &vorbiscomment_, &padding_, &seektable_, &application1_, &application2_, &cuesheet_, &picture_, &unknown_ };
+static const unsigned num_metadata_ = sizeof(metadata_sequence_) / sizeof(metadata_sequence_[0]);
+
+static const char *flacfilename(FLAC__bool is_ogg)
+{
+	return is_ogg? "/data/metadata.oga" : "/data/metadata.flac";
+}
+
+static FLAC__bool die_(const char *msg)
+{
+	printf("ERROR: %s\n", msg);
+	return false;
+}
+
+static FLAC__bool die_s_(const char *msg, const FLAC__StreamEncoder *encoder)
+{
+	FLAC__StreamEncoderState state = FLAC__stream_encoder_get_state(encoder);
+
+	if(msg)
+		printf("FAILED, %s", msg);
+	else
+		printf("FAILED");
+
+	printf(", state = %u (%s)\n", (unsigned)state, FLAC__StreamEncoderStateString[state]);
+	if(state == FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR) {
+		FLAC__StreamDecoderState dstate = FLAC__stream_encoder_get_verify_decoder_state(encoder);
+		printf("      verify decoder state = %u (%s)\n", (unsigned)dstate, FLAC__StreamDecoderStateString[dstate]);
+	}
+
+	return false;
+}
+
+static void init_metadata_blocks_(void)
+{
+	mutils__init_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &picture_, &unknown_);
+}
+
+static void free_metadata_blocks_(void)
+{
+	mutils__free_metadata_blocks(&streaminfo_, &padding_, &seektable_, &application1_, &application2_, &vorbiscomment_, &cuesheet_, &picture_, &unknown_);
+}
+
+static FLAC__StreamEncoderReadStatus stream_encoder_read_callback_(const FLAC__StreamEncoder *encoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
+{
+	FILE *f = (FILE*)client_data;
+	(void)encoder;
+	if(*bytes > 0) {
+		*bytes = fread(buffer, sizeof(FLAC__byte), *bytes, f);
+		if(ferror(f))
+			return FLAC__STREAM_ENCODER_READ_STATUS_ABORT;
+		else if(*bytes == 0)
+			return FLAC__STREAM_ENCODER_READ_STATUS_END_OF_STREAM;
+		else
+			return FLAC__STREAM_ENCODER_READ_STATUS_CONTINUE;
+	}
+	else
+		return FLAC__STREAM_ENCODER_READ_STATUS_ABORT;
+}
+
+static FLAC__StreamEncoderWriteStatus stream_encoder_write_callback_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame, void *client_data)
+{
+	FILE *f = (FILE*)client_data;
+	(void)encoder, (void)samples, (void)current_frame;
+	if(fwrite(buffer, 1, bytes, f) != bytes)
+		return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
+	else
+		return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
+}
+
+static FLAC__StreamEncoderSeekStatus stream_encoder_seek_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data)
+{
+	FILE *f = (FILE*)client_data;
+	(void)encoder;
+	if(fseek(f, (long)absolute_byte_offset, SEEK_SET) < 0)
+		return FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR;
+	else
+		return FLAC__STREAM_ENCODER_SEEK_STATUS_OK;
+}
+
+static FLAC__StreamEncoderTellStatus stream_encoder_tell_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
+{
+	FILE *f = (FILE*)client_data;
+	long pos;
+	(void)encoder;
+	if((pos = ftell(f)) < 0)
+		return FLAC__STREAM_ENCODER_TELL_STATUS_ERROR;
+	else {
+		*absolute_byte_offset = (FLAC__uint64)pos;
+		return FLAC__STREAM_ENCODER_TELL_STATUS_OK;
+	}
+}
+
+static void stream_encoder_metadata_callback_(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data)
+{
+	(void)encoder, (void)metadata, (void)client_data;
+}
+
+static void stream_encoder_progress_callback_(const FLAC__StreamEncoder *encoder, FLAC__uint64 bytes_written, FLAC__uint64 samples_written, unsigned frames_written, unsigned total_frames_estimate, void *client_data)
+{
+	(void)encoder, (void)bytes_written, (void)samples_written, (void)frames_written, (void)total_frames_estimate, (void)client_data;
+}
+
+static FLAC__bool test_stream_encoder(Layer layer, FLAC__bool is_ogg)
+{
+	FLAC__StreamEncoder *encoder;
+	FLAC__StreamEncoderInitStatus init_status;
+	FLAC__StreamEncoderState state;
+	FLAC__StreamDecoderState dstate;
+	FILE *file = 0;
+	FLAC__int32 samples[1024];
+	FLAC__int32 *samples_array[1];
+	unsigned i;
+
+	samples_array[0] = samples;
+
+	printf("\n+++ libFLAC unit test: FLAC__StreamEncoder (layer: %s, format: %s)\n\n", LayerString[layer], is_ogg? "Ogg FLAC":"FLAC");
+
+	printf("testing FLAC__stream_encoder_new()... ");
+	encoder = FLAC__stream_encoder_new();
+	if(0 == encoder) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	printf("OK\n");
+
+	if(is_ogg) {
+		printf("testing FLAC__stream_encoder_set_ogg_serial_number()... ");
+		if(!FLAC__stream_encoder_set_ogg_serial_number(encoder, file_utils__ogg_serial_number))
+			return die_s_("returned false", encoder);
+		printf("OK\n");
+	}
+
+	printf("testing FLAC__stream_encoder_set_verify()... ");
+	if(!FLAC__stream_encoder_set_verify(encoder, true))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_streamable_subset()... ");
+	if(!FLAC__stream_encoder_set_streamable_subset(encoder, true))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_channels()... ");
+	if(!FLAC__stream_encoder_set_channels(encoder, streaminfo_.data.stream_info.channels))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_bits_per_sample()... ");
+	if(!FLAC__stream_encoder_set_bits_per_sample(encoder, streaminfo_.data.stream_info.bits_per_sample))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_sample_rate()... ");
+	if(!FLAC__stream_encoder_set_sample_rate(encoder, streaminfo_.data.stream_info.sample_rate))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_compression_level()... ");
+	if(!FLAC__stream_encoder_set_compression_level(encoder, (unsigned)(-1)))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_blocksize()... ");
+	if(!FLAC__stream_encoder_set_blocksize(encoder, streaminfo_.data.stream_info.min_blocksize))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_do_mid_side_stereo()... ");
+	if(!FLAC__stream_encoder_set_do_mid_side_stereo(encoder, false))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_loose_mid_side_stereo()... ");
+	if(!FLAC__stream_encoder_set_loose_mid_side_stereo(encoder, false))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_max_lpc_order()... ");
+	if(!FLAC__stream_encoder_set_max_lpc_order(encoder, 0))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_qlp_coeff_precision()... ");
+	if(!FLAC__stream_encoder_set_qlp_coeff_precision(encoder, 0))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_do_qlp_coeff_prec_search()... ");
+	if(!FLAC__stream_encoder_set_do_qlp_coeff_prec_search(encoder, false))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_do_escape_coding()... ");
+	if(!FLAC__stream_encoder_set_do_escape_coding(encoder, false))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_do_exhaustive_model_search()... ");
+	if(!FLAC__stream_encoder_set_do_exhaustive_model_search(encoder, false))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_min_residual_partition_order()... ");
+	if(!FLAC__stream_encoder_set_min_residual_partition_order(encoder, 0))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_max_residual_partition_order()... ");
+	if(!FLAC__stream_encoder_set_max_residual_partition_order(encoder, 0))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_rice_parameter_search_dist()... ");
+	if(!FLAC__stream_encoder_set_rice_parameter_search_dist(encoder, 0))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_total_samples_estimate()... ");
+	if(!FLAC__stream_encoder_set_total_samples_estimate(encoder, streaminfo_.data.stream_info.total_samples))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_set_metadata()... ");
+	if(!FLAC__stream_encoder_set_metadata(encoder, metadata_sequence_, num_metadata_))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	if(layer < LAYER_FILENAME) {
+		printf("opening file for FLAC output... ");
+		file = fopen(flacfilename(is_ogg), "w+b");
+		if(0 == file) {
+			printf("ERROR (%s)\n", strerror(errno));
+			return false;
+		}
+		printf("OK\n");
+	}
+
+	switch(layer) {
+		case LAYER_STREAM:
+			printf("testing FLAC__stream_encoder_init_%sstream()... ", is_ogg? "ogg_":"");
+			init_status = is_ogg?
+				FLAC__stream_encoder_init_ogg_stream(encoder, /*read_callback=*/0, stream_encoder_write_callback_, /*seek_callback=*/0, /*tell_callback=*/0, stream_encoder_metadata_callback_, /*client_data=*/file) :
+				FLAC__stream_encoder_init_stream(encoder, stream_encoder_write_callback_, /*seek_callback=*/0, /*tell_callback=*/0, stream_encoder_metadata_callback_, /*client_data=*/file);
+			break;
+		case LAYER_SEEKABLE_STREAM:
+			printf("testing FLAC__stream_encoder_init_%sstream()... ", is_ogg? "ogg_":"");
+			init_status = is_ogg?
+				FLAC__stream_encoder_init_ogg_stream(encoder, stream_encoder_read_callback_, stream_encoder_write_callback_, stream_encoder_seek_callback_, stream_encoder_tell_callback_, /*metadata_callback=*/0, /*client_data=*/file) :
+				FLAC__stream_encoder_init_stream(encoder, stream_encoder_write_callback_, stream_encoder_seek_callback_, stream_encoder_tell_callback_, /*metadata_callback=*/0, /*client_data=*/file);
+			break;
+		case LAYER_FILE:
+			printf("testing FLAC__stream_encoder_init_%sFILE()... ", is_ogg? "ogg_":"");
+			init_status = is_ogg?
+				FLAC__stream_encoder_init_ogg_FILE(encoder, file, stream_encoder_progress_callback_, /*client_data=*/0) :
+				FLAC__stream_encoder_init_FILE(encoder, file, stream_encoder_progress_callback_, /*client_data=*/0);
+			break;
+		case LAYER_FILENAME:
+			printf("testing FLAC__stream_encoder_init_%sfile()... ", is_ogg? "ogg_":"");
+			init_status = is_ogg?
+				FLAC__stream_encoder_init_ogg_file(encoder, flacfilename(is_ogg), stream_encoder_progress_callback_, /*client_data=*/0) :
+				FLAC__stream_encoder_init_file(encoder, flacfilename(is_ogg), stream_encoder_progress_callback_, /*client_data=*/0);
+			break;
+		default:
+			die_("internal error 001");
+			return false;
+	}
+	if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK)
+		return die_s_(0, encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_get_state()... ");
+	state = FLAC__stream_encoder_get_state(encoder);
+	printf("returned state = %u (%s)... OK\n", (unsigned)state, FLAC__StreamEncoderStateString[state]);
+
+	printf("testing FLAC__stream_encoder_get_verify_decoder_state()... ");
+	dstate = FLAC__stream_encoder_get_verify_decoder_state(encoder);
+	printf("returned state = %u (%s)... OK\n", (unsigned)dstate, FLAC__StreamDecoderStateString[dstate]);
+
+	{
+		FLAC__uint64 absolute_sample;
+		unsigned frame_number;
+		unsigned channel;
+		unsigned sample;
+		FLAC__int32 expected;
+		FLAC__int32 got;
+
+		printf("testing FLAC__stream_encoder_get_verify_decoder_error_stats()... ");
+		FLAC__stream_encoder_get_verify_decoder_error_stats(encoder, &absolute_sample, &frame_number, &channel, &sample, &expected, &got);
+		printf("OK\n");
+	}
+
+	printf("testing FLAC__stream_encoder_get_verify()... ");
+	if(FLAC__stream_encoder_get_verify(encoder) != true) {
+		printf("FAILED, expected true, got false\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_get_streamable_subset()... ");
+	if(FLAC__stream_encoder_get_streamable_subset(encoder) != true) {
+		printf("FAILED, expected true, got false\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_get_do_mid_side_stereo()... ");
+	if(FLAC__stream_encoder_get_do_mid_side_stereo(encoder) != false) {
+		printf("FAILED, expected false, got true\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_get_loose_mid_side_stereo()... ");
+	if(FLAC__stream_encoder_get_loose_mid_side_stereo(encoder) != false) {
+		printf("FAILED, expected false, got true\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_get_channels()... ");
+	if(FLAC__stream_encoder_get_channels(encoder) != streaminfo_.data.stream_info.channels) {
+		printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.channels, FLAC__stream_encoder_get_channels(encoder));
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_get_bits_per_sample()... ");
+	if(FLAC__stream_encoder_get_bits_per_sample(encoder) != streaminfo_.data.stream_info.bits_per_sample) {
+		printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.bits_per_sample, FLAC__stream_encoder_get_bits_per_sample(encoder));
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_get_sample_rate()... ");
+	if(FLAC__stream_encoder_get_sample_rate(encoder) != streaminfo_.data.stream_info.sample_rate) {
+		printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.sample_rate, FLAC__stream_encoder_get_sample_rate(encoder));
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_get_blocksize()... ");
+	if(FLAC__stream_encoder_get_blocksize(encoder) != streaminfo_.data.stream_info.min_blocksize) {
+		printf("FAILED, expected %u, got %u\n", streaminfo_.data.stream_info.min_blocksize, FLAC__stream_encoder_get_blocksize(encoder));
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_get_max_lpc_order()... ");
+	if(FLAC__stream_encoder_get_max_lpc_order(encoder) != 0) {
+		printf("FAILED, expected %u, got %u\n", 0, FLAC__stream_encoder_get_max_lpc_order(encoder));
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_get_qlp_coeff_precision()... ");
+	(void)FLAC__stream_encoder_get_qlp_coeff_precision(encoder);
+	/* we asked the encoder to auto select this so we accept anything */
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_get_do_qlp_coeff_prec_search()... ");
+	if(FLAC__stream_encoder_get_do_qlp_coeff_prec_search(encoder) != false) {
+		printf("FAILED, expected false, got true\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_get_do_escape_coding()... ");
+	if(FLAC__stream_encoder_get_do_escape_coding(encoder) != false) {
+		printf("FAILED, expected false, got true\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_get_do_exhaustive_model_search()... ");
+	if(FLAC__stream_encoder_get_do_exhaustive_model_search(encoder) != false) {
+		printf("FAILED, expected false, got true\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_get_min_residual_partition_order()... ");
+	if(FLAC__stream_encoder_get_min_residual_partition_order(encoder) != 0) {
+		printf("FAILED, expected %u, got %u\n", 0, FLAC__stream_encoder_get_min_residual_partition_order(encoder));
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_get_max_residual_partition_order()... ");
+	if(FLAC__stream_encoder_get_max_residual_partition_order(encoder) != 0) {
+		printf("FAILED, expected %u, got %u\n", 0, FLAC__stream_encoder_get_max_residual_partition_order(encoder));
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_get_rice_parameter_search_dist()... ");
+	if(FLAC__stream_encoder_get_rice_parameter_search_dist(encoder) != 0) {
+		printf("FAILED, expected %u, got %u\n", 0, FLAC__stream_encoder_get_rice_parameter_search_dist(encoder));
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_get_total_samples_estimate()... ");
+	if(FLAC__stream_encoder_get_total_samples_estimate(encoder) != streaminfo_.data.stream_info.total_samples) {
+#ifdef _MSC_VER
+		printf("FAILED, expected %I64u, got %I64u\n", streaminfo_.data.stream_info.total_samples, FLAC__stream_encoder_get_total_samples_estimate(encoder));
+#else
+		printf("FAILED, expected %llu, got %llu\n", (unsigned long long)streaminfo_.data.stream_info.total_samples, (unsigned long long)FLAC__stream_encoder_get_total_samples_estimate(encoder));
+#endif
+		return false;
+	}
+	printf("OK\n");
+
+	/* init the dummy sample buffer */
+	for(i = 0; i < sizeof(samples) / sizeof(FLAC__int32); i++)
+		samples[i] = i & 7;
+
+	printf("testing FLAC__stream_encoder_process()... ");
+	if(!FLAC__stream_encoder_process(encoder, (const FLAC__int32 * const *)samples_array, sizeof(samples) / sizeof(FLAC__int32)))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_process_interleaved()... ");
+	if(!FLAC__stream_encoder_process_interleaved(encoder, samples, sizeof(samples) / sizeof(FLAC__int32)))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	printf("testing FLAC__stream_encoder_finish()... ");
+	if(!FLAC__stream_encoder_finish(encoder))
+		return die_s_("returned false", encoder);
+	printf("OK\n");
+
+	if(layer < LAYER_FILE)
+		fclose(file);
+
+	printf("testing FLAC__stream_encoder_delete()... ");
+	FLAC__stream_encoder_delete(encoder);
+	printf("OK\n");
+
+	printf("\nPASSED!\n");
+
+	return true;
+}
+
+FLAC__bool test_encoders(void)
+{
+	FLAC__bool is_ogg = false;
+
+	while(1) {
+		init_metadata_blocks_();
+
+		if(!test_stream_encoder(LAYER_STREAM, is_ogg))
+			return false;
+
+		if(!test_stream_encoder(LAYER_SEEKABLE_STREAM, is_ogg))
+			return false;
+
+		if(!test_stream_encoder(LAYER_FILE, is_ogg))
+			return false;
+
+		if(!test_stream_encoder(LAYER_FILENAME, is_ogg))
+			return false;
+
+		(void) grabbag__file_remove_file(flacfilename(is_ogg));
+
+		free_metadata_blocks_();
+
+		if(!FLAC_API_SUPPORTS_OGG_FLAC || is_ogg)
+			break;
+		is_ogg = true;
+	}
+
+	return true;
+}
diff --git a/audio-codec/flac/test_libFLAC/encoders.h b/audio-codec/flac/test_libFLAC/encoders.h
new file mode 100644
index 0000000..86c3690
--- /dev/null
+++ b/audio-codec/flac/test_libFLAC/encoders.h
@@ -0,0 +1,26 @@
+/* test_libFLAC - Unit tester for libFLAC
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * 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 FLAC__TEST_LIBFLAC_ENCODERS_H
+#define FLAC__TEST_LIBFLAC_ENCODERS_H
+
+#include "FLAC/ordinals.h"
+
+FLAC__bool test_encoders(void);
+
+#endif
diff --git a/audio-codec/flac/test_libFLAC/format.c b/audio-codec/flac/test_libFLAC/format.c
new file mode 100644
index 0000000..7ac115d
--- /dev/null
+++ b/audio-codec/flac/test_libFLAC/format.c
@@ -0,0 +1,256 @@
+/* test_libFLAC - Unit tester for libFLAC
+ * Copyright (C) 2004,2005,2006,2007  Josh Coalson
+ *
+ * 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.
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "FLAC/assert.h"
+#include "FLAC/format.h"
+#include "format.h"
+#include <stdio.h>
+
+static const char *true_false_string_[2] = { "false", "true" };
+
+static struct {
+	unsigned rate;
+	FLAC__bool valid;
+	FLAC__bool subset;
+} SAMPLE_RATES[] = {
+	{ 0      , false, false },
+	{ 1      , true , true  },
+	{ 9      , true , true  },
+	{ 10     , true , true  },
+	{ 4000   , true , true  },
+	{ 8000   , true , true  },
+	{ 11025  , true , true  },
+	{ 12000  , true , true  },
+	{ 16000  , true , true  },
+	{ 22050  , true , true  },
+	{ 24000  , true , true  },
+	{ 32000  , true , true  },
+	{ 32768  , true , true  },
+	{ 44100  , true , true  },
+	{ 48000  , true , true  },
+	{ 65000  , true , true  },
+	{ 65535  , true , true  },
+	{ 65536  , true , false },
+	{ 65540  , true , true  },
+	{ 65550  , true , true  },
+	{ 65555  , true , false },
+	{ 66000  , true , true  },
+	{ 66001  , true , false },
+	{ 96000  , true , true  },
+	{ 100000 , true , true  },
+	{ 100001 , true , false },
+	{ 192000 , true , true  },
+	{ 500000 , true , true  },
+	{ 500001 , true , false },
+	{ 500010 , true , true  },
+	{ 655349 , true , false },
+	{ 655350 , true , true  },
+	{ 655351 , false, false },
+	{ 655360 , false, false },
+	{ 700000 , false, false },
+	{ 700010 , false, false },
+	{ 1000000, false, false },
+	{ 1100000, false, false }
+};
+
+static struct {
+	const char *string;
+	FLAC__bool valid;
+} VCENTRY_NAMES[] = {
+	{ ""    , true  },
+	{ "a"   , true  },
+	{ "="   , false },
+	{ "a="  , false },
+	{ "\x01", false },
+	{ "\x1f", false },
+	{ "\x7d", true  },
+	{ "\x7e", false },
+	{ "\xff", false }
+};
+
+static struct {
+	unsigned length;
+	const FLAC__byte *string;
+	FLAC__bool valid;
+} VCENTRY_VALUES[] = {
+	{ 0, (const FLAC__byte*)""            , true  },
+	{ 1, (const FLAC__byte*)""            , true  },
+	{ 1, (const FLAC__byte*)"\x01"        , true  },
+	{ 1, (const FLAC__byte*)"\x7f"        , true  },
+	{ 1, (const FLAC__byte*)"\x80"        , false },
+	{ 1, (const FLAC__byte*)"\x81"        , false },
+	{ 1, (const FLAC__byte*)"\xc0"        , false },
+	{ 1, (const FLAC__byte*)"\xe0"        , false },
+	{ 1, (const FLAC__byte*)"\xf0"        , false },
+	{ 2, (const FLAC__byte*)"\xc0\x41"    , false },
+	{ 2, (const FLAC__byte*)"\xc1\x41"    , false },
+	{ 2, (const FLAC__byte*)"\xc0\x85"    , false }, /* non-shortest form */
+	{ 2, (const FLAC__byte*)"\xc1\x85"    , false }, /* non-shortest form */
+	{ 2, (const FLAC__byte*)"\xc2\x85"    , true  },
+	{ 2, (const FLAC__byte*)"\xe0\x41"    , false },
+	{ 2, (const FLAC__byte*)"\xe1\x41"    , false },
+	{ 2, (const FLAC__byte*)"\xe0\x85"    , false },
+	{ 2, (const FLAC__byte*)"\xe1\x85"    , false },
+	{ 3, (const FLAC__byte*)"\xe0\x85\x41", false },
+	{ 3, (const FLAC__byte*)"\xe1\x85\x41", false },
+	{ 3, (const FLAC__byte*)"\xe0\x85\x80", false }, /* non-shortest form */
+	{ 3, (const FLAC__byte*)"\xe0\x95\x80", false }, /* non-shortest form */
+	{ 3, (const FLAC__byte*)"\xe0\xa5\x80", true  },
+	{ 3, (const FLAC__byte*)"\xe1\x85\x80", true  },
+	{ 3, (const FLAC__byte*)"\xe1\x95\x80", true  },
+	{ 3, (const FLAC__byte*)"\xe1\xa5\x80", true  }
+};
+
+static struct {
+	const FLAC__byte *string;
+	FLAC__bool valid;
+} VCENTRY_VALUES_NT[] = {
+	{ (const FLAC__byte*)""            , true  },
+	{ (const FLAC__byte*)"\x01"        , true  },
+	{ (const FLAC__byte*)"\x7f"        , true  },
+	{ (const FLAC__byte*)"\x80"        , false },
+	{ (const FLAC__byte*)"\x81"        , false },
+	{ (const FLAC__byte*)"\xc0"        , false },
+	{ (const FLAC__byte*)"\xe0"        , false },
+	{ (const FLAC__byte*)"\xf0"        , false },
+	{ (const FLAC__byte*)"\xc0\x41"    , false },
+	{ (const FLAC__byte*)"\xc1\x41"    , false },
+	{ (const FLAC__byte*)"\xc0\x85"    , false }, /* non-shortest form */
+	{ (const FLAC__byte*)"\xc1\x85"    , false }, /* non-shortest form */
+	{ (const FLAC__byte*)"\xc2\x85"    , true  },
+	{ (const FLAC__byte*)"\xe0\x41"    , false },
+	{ (const FLAC__byte*)"\xe1\x41"    , false },
+	{ (const FLAC__byte*)"\xe0\x85"    , false },
+	{ (const FLAC__byte*)"\xe1\x85"    , false },
+	{ (const FLAC__byte*)"\xe0\x85\x41", false },
+	{ (const FLAC__byte*)"\xe1\x85\x41", false },
+	{ (const FLAC__byte*)"\xe0\x85\x80", false }, /* non-shortest form */
+	{ (const FLAC__byte*)"\xe0\x95\x80", false }, /* non-shortest form */
+	{ (const FLAC__byte*)"\xe0\xa5\x80", true  },
+	{ (const FLAC__byte*)"\xe1\x85\x80", true  },
+	{ (const FLAC__byte*)"\xe1\x95\x80", true  },
+	{ (const FLAC__byte*)"\xe1\xa5\x80", true  }
+};
+
+static struct {
+	unsigned length;
+	const FLAC__byte *string;
+	FLAC__bool valid;
+} VCENTRIES[] = {
+	{ 0, (const FLAC__byte*)""              , false },
+	{ 1, (const FLAC__byte*)"a"             , false },
+	{ 1, (const FLAC__byte*)"="             , true  },
+	{ 2, (const FLAC__byte*)"a="            , true  },
+	{ 2, (const FLAC__byte*)"\x01="         , false },
+	{ 2, (const FLAC__byte*)"\x1f="         , false },
+	{ 2, (const FLAC__byte*)"\x7d="         , true  },
+	{ 2, (const FLAC__byte*)"\x7e="         , false },
+	{ 2, (const FLAC__byte*)"\xff="         , false },
+	{ 3, (const FLAC__byte*)"a=\x01"        , true  },
+	{ 3, (const FLAC__byte*)"a=\x7f"        , true  },
+	{ 3, (const FLAC__byte*)"a=\x80"        , false },
+	{ 3, (const FLAC__byte*)"a=\x81"        , false },
+	{ 3, (const FLAC__byte*)"a=\xc0"        , false },
+	{ 3, (const FLAC__byte*)"a=\xe0"        , false },
+	{ 3, (const FLAC__byte*)"a=\xf0"        , false },
+	{ 4, (const FLAC__byte*)"a=\xc0\x41"    , false },
+	{ 4, (const FLAC__byte*)"a=\xc1\x41"    , false },
+	{ 4, (const FLAC__byte*)"a=\xc0\x85"    , false }, /* non-shortest form */
+	{ 4, (const FLAC__byte*)"a=\xc1\x85"    , false }, /* non-shortest form */
+	{ 4, (const FLAC__byte*)"a=\xc2\x85"    , true  },
+	{ 4, (const FLAC__byte*)"a=\xe0\x41"    , false },
+	{ 4, (const FLAC__byte*)"a=\xe1\x41"    , false },
+	{ 4, (const FLAC__byte*)"a=\xe0\x85"    , false },
+	{ 4, (const FLAC__byte*)"a=\xe1\x85"    , false },
+	{ 5, (const FLAC__byte*)"a=\xe0\x85\x41", false },
+	{ 5, (const FLAC__byte*)"a=\xe1\x85\x41", false },
+	{ 5, (const FLAC__byte*)"a=\xe0\x85\x80", false }, /* non-shortest form */
+	{ 5, (const FLAC__byte*)"a=\xe0\x95\x80", false }, /* non-shortest form */
+	{ 5, (const FLAC__byte*)"a=\xe0\xa5\x80", true  },
+	{ 5, (const FLAC__byte*)"a=\xe1\x85\x80", true  },
+	{ 5, (const FLAC__byte*)"a=\xe1\x95\x80", true  },
+	{ 5, (const FLAC__byte*)"a=\xe1\xa5\x80", true  }
+};
+
+FLAC__bool test_format(void)
+{
+	unsigned i;
+
+	printf("\n+++ libFLAC unit test: format\n\n");
+
+	for(i = 0; i < sizeof(SAMPLE_RATES)/sizeof(SAMPLE_RATES[0]); i++) {
+		printf("testing FLAC__format_sample_rate_is_valid(%u)... ", SAMPLE_RATES[i].rate);
+		if(FLAC__format_sample_rate_is_valid(SAMPLE_RATES[i].rate) != SAMPLE_RATES[i].valid) {
+			printf("FAILED, expected %s, got %s\n", true_false_string_[SAMPLE_RATES[i].valid], true_false_string_[!SAMPLE_RATES[i].valid]);
+			return false;
+		}
+		printf("OK\n");
+	}
+
+	for(i = 0; i < sizeof(SAMPLE_RATES)/sizeof(SAMPLE_RATES[0]); i++) {
+		printf("testing FLAC__format_sample_rate_is_subset(%u)... ", SAMPLE_RATES[i].rate);
+		if(FLAC__format_sample_rate_is_subset(SAMPLE_RATES[i].rate) != SAMPLE_RATES[i].subset) {
+			printf("FAILED, expected %s, got %s\n", true_false_string_[SAMPLE_RATES[i].subset], true_false_string_[!SAMPLE_RATES[i].subset]);
+			return false;
+		}
+		printf("OK\n");
+	}
+
+	for(i = 0; i < sizeof(VCENTRY_NAMES)/sizeof(VCENTRY_NAMES[0]); i++) {
+		printf("testing FLAC__format_vorbiscomment_entry_name_is_legal(\"%s\")... ", VCENTRY_NAMES[i].string);
+		if(FLAC__format_vorbiscomment_entry_name_is_legal(VCENTRY_NAMES[i].string) != VCENTRY_NAMES[i].valid) {
+			printf("FAILED, expected %s, got %s\n", true_false_string_[VCENTRY_NAMES[i].valid], true_false_string_[!VCENTRY_NAMES[i].valid]);
+			return false;
+		}
+		printf("OK\n");
+	}
+
+	for(i = 0; i < sizeof(VCENTRY_VALUES)/sizeof(VCENTRY_VALUES[0]); i++) {
+		printf("testing FLAC__format_vorbiscomment_entry_value_is_legal(\"%s\", %u)... ", VCENTRY_VALUES[i].string, VCENTRY_VALUES[i].length);
+		if(FLAC__format_vorbiscomment_entry_value_is_legal(VCENTRY_VALUES[i].string, VCENTRY_VALUES[i].length) != VCENTRY_VALUES[i].valid) {
+			printf("FAILED, expected %s, got %s\n", true_false_string_[VCENTRY_VALUES[i].valid], true_false_string_[!VCENTRY_VALUES[i].valid]);
+			return false;
+		}
+		printf("OK\n");
+	}
+
+	for(i = 0; i < sizeof(VCENTRY_VALUES_NT)/sizeof(VCENTRY_VALUES_NT[0]); i++) {
+		printf("testing FLAC__format_vorbiscomment_entry_value_is_legal(\"%s\", -1)... ", VCENTRY_VALUES_NT[i].string);
+		if(FLAC__format_vorbiscomment_entry_value_is_legal(VCENTRY_VALUES_NT[i].string, (unsigned)(-1)) != VCENTRY_VALUES_NT[i].valid) {
+			printf("FAILED, expected %s, got %s\n", true_false_string_[VCENTRY_VALUES_NT[i].valid], true_false_string_[!VCENTRY_VALUES_NT[i].valid]);
+			return false;
+		}
+		printf("OK\n");
+	}
+
+	for(i = 0; i < sizeof(VCENTRIES)/sizeof(VCENTRIES[0]); i++) {
+		printf("testing FLAC__format_vorbiscomment_entry_is_legal(\"%s\", %u)... ", VCENTRIES[i].string, VCENTRIES[i].length);
+		if(FLAC__format_vorbiscomment_entry_is_legal(VCENTRIES[i].string, VCENTRIES[i].length) != VCENTRIES[i].valid) {
+			printf("FAILED, expected %s, got %s\n", true_false_string_[VCENTRIES[i].valid], true_false_string_[!VCENTRIES[i].valid]);
+			return false;
+		}
+		printf("OK\n");
+	}
+
+	printf("\nPASSED!\n");
+	return true;
+}
diff --git a/audio-codec/flac/test_libFLAC/format.h b/audio-codec/flac/test_libFLAC/format.h
new file mode 100644
index 0000000..e48a0e0
--- /dev/null
+++ b/audio-codec/flac/test_libFLAC/format.h
@@ -0,0 +1,26 @@
+/* test_libFLAC - Unit tester for libFLAC
+ * Copyright (C) 2004,2005,2006,2007  Josh Coalson
+ *
+ * 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 FLAC__TEST_LIBFLAC_FORMAT_H
+#define FLAC__TEST_LIBFLAC_FORMAT_H
+
+#include "FLAC/ordinals.h"
+
+FLAC__bool test_format(void);
+
+#endif
diff --git a/audio-codec/flac/test_libFLAC/main.c b/audio-codec/flac/test_libFLAC/main.c
new file mode 100644
index 0000000..aadd962
--- /dev/null
+++ b/audio-codec/flac/test_libFLAC/main.c
@@ -0,0 +1,50 @@
+/* test_libFLAC - Unit tester for libFLAC
+ * Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * 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.
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "bitwriter.h"
+#include "decoders.h"
+#include "encoders.h"
+#include "format.h"
+#include "metadata.h"
+
+int main(int argc, char *argv[])
+{
+	(void)argc, (void)argv;
+
+	if(!test_bitwriter())
+		return 1;
+
+	if(!test_format())
+		return 1;
+
+	if(!test_encoders())
+		return 1;
+
+	if(!test_decoders())
+		return 1;
+
+#ifndef FLAC__NO_METADATA
+	if(!test_metadata())
+		return 1;
+#endif
+	return 0;
+}
diff --git a/audio-codec/flac/test_libFLAC/metadata.c b/audio-codec/flac/test_libFLAC/metadata.c
new file mode 100644
index 0000000..aacb6bf
--- /dev/null
+++ b/audio-codec/flac/test_libFLAC/metadata.c
@@ -0,0 +1,40 @@
+/* test_libFLAC - Unit tester for libFLAC
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * 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.
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "metadata.h"
+#include <stdio.h>
+
+extern FLAC__bool test_metadata_object(void);
+extern FLAC__bool test_metadata_file_manipulation(void);
+
+FLAC__bool test_metadata(void)
+{
+	if(!test_metadata_object())
+		return false;
+
+	if(!test_metadata_file_manipulation())
+		return false;
+
+	printf("\nPASSED!\n");
+
+	return true;
+}
diff --git a/audio-codec/flac/test_libFLAC/metadata.h b/audio-codec/flac/test_libFLAC/metadata.h
new file mode 100644
index 0000000..0551564
--- /dev/null
+++ b/audio-codec/flac/test_libFLAC/metadata.h
@@ -0,0 +1,28 @@
+/* test_libFLAC - Unit tester for libFLAC
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * 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 FLAC__TEST_LIBFLAC_METADATA_H
+#define FLAC__TEST_LIBFLAC_METADATA_H
+
+#include "FLAC/ordinals.h"
+
+FLAC__bool test_metadata(void);
+FLAC__bool test_metadata_file_manipulation(void);
+FLAC__bool test_metadata_object(void);
+
+#endif
diff --git a/audio-codec/flac/test_libFLAC/metadata_manip.c b/audio-codec/flac/test_libFLAC/metadata_manip.c
new file mode 100644
index 0000000..b387531
--- /dev/null
+++ b/audio-codec/flac/test_libFLAC/metadata_manip.c
@@ -0,0 +1,2133 @@
+/* test_libFLAC - Unit tester for libFLAC
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * 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.
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h> /* for malloc() */
+#include <string.h> /* for memcpy()/memset() */
+#if defined _MSC_VER || defined __MINGW32__
+#include <sys/utime.h> /* for utime() */
+#include <io.h> /* for chmod() */
+#if _MSC_VER <= 1600 /* @@@ [2G limit] */
+#define fseeko fseek
+#define ftello ftell
+#endif
+#else
+#include <sys/types.h> /* some flavors of BSD (like OS X) require this to get time_t */
+#include <utime.h> /* for utime() */
+#include <unistd.h> /* for chown(), unlink() */
+#endif
+#include <sys/stat.h> /* for stat(), maybe chmod() */
+#include "FLAC/assert.h"
+#include "FLAC/stream_decoder.h"
+#include "FLAC/metadata.h"
+#include "share/grabbag.h"
+#include "test_libs_common/file_utils_flac.h"
+#include "test_libs_common/metadata_utils.h"
+#include "metadata.h"
+
+
+/******************************************************************************
+	The general strategy of these tests (for interface levels 1 and 2) is
+	to create a dummy FLAC file with a known set of initial metadata
+	blocks, then keep a mirror locally of what we expect the metadata to be
+	after each operation.  Then testing becomes a simple matter of running
+	a FLAC__StreamDecoder over the dummy file after each operation, comparing
+	the decoded metadata to what's in our local copy.  If there are any
+	differences in the metadata, or the actual audio data is corrupted, we
+	will catch it while decoding.
+******************************************************************************/
+
+typedef struct {
+	FLAC__bool error_occurred;
+} decoder_client_struct;
+
+typedef struct {
+	FLAC__StreamMetadata *blocks[64];
+	unsigned num_blocks;
+} our_metadata_struct;
+
+/* our copy of the metadata in flacfilename() */
+static our_metadata_struct our_metadata_;
+
+/* the current block number that corresponds to the position of the iterator we are testing */
+static unsigned mc_our_block_number_ = 0;
+
+static const char *flacfilename(FLAC__bool is_ogg)
+{
+	return is_ogg? "metadata.oga" : "metadata.flac";
+}
+
+static FLAC__bool die_(const char *msg)
+{
+	printf("ERROR: %s\n", msg);
+	return false;
+}
+
+static FLAC__bool die_c_(const char *msg, FLAC__Metadata_ChainStatus status)
+{
+	printf("ERROR: %s\n", msg);
+	printf("       status=%s\n", FLAC__Metadata_ChainStatusString[status]);
+	return false;
+}
+
+static FLAC__bool die_ss_(const char *msg, FLAC__Metadata_SimpleIterator *iterator)
+{
+	printf("ERROR: %s\n", msg);
+	printf("       status=%s\n", FLAC__Metadata_SimpleIteratorStatusString[FLAC__metadata_simple_iterator_status(iterator)]);
+	return false;
+}
+
+static void *malloc_or_die_(size_t size)
+{
+	void *x = malloc(size);
+	if(0 == x) {
+		fprintf(stderr, "ERROR: out of memory allocating %u bytes\n", (unsigned)size);
+		exit(1);
+	}
+	return x;
+}
+
+static char *strdup_or_die_(const char *s)
+{
+	char *x = strdup(s);
+	if(0 == x) {
+		fprintf(stderr, "ERROR: out of memory copying string \"%s\"\n", s);
+		exit(1);
+	}
+	return x;
+}
+
+/* functions for working with our metadata copy */
+
+static FLAC__bool replace_in_our_metadata_(FLAC__StreamMetadata *block, unsigned position, FLAC__bool copy)
+{
+	unsigned i;
+	FLAC__StreamMetadata *obj = block;
+	FLAC__ASSERT(position < our_metadata_.num_blocks);
+	if(copy) {
+		if(0 == (obj = FLAC__metadata_object_clone(block)))
+			return die_("during FLAC__metadata_object_clone()");
+	}
+	FLAC__metadata_object_delete(our_metadata_.blocks[position]);
+	our_metadata_.blocks[position] = obj;
+
+	/* set the is_last flags */
+	for(i = 0; i < our_metadata_.num_blocks - 1; i++)
+		our_metadata_.blocks[i]->is_last = false;
+	our_metadata_.blocks[i]->is_last = true;
+
+	return true;
+}
+
+static FLAC__bool insert_to_our_metadata_(FLAC__StreamMetadata *block, unsigned position, FLAC__bool copy)
+{
+	unsigned i;
+	FLAC__StreamMetadata *obj = block;
+	if(copy) {
+		if(0 == (obj = FLAC__metadata_object_clone(block)))
+			return die_("during FLAC__metadata_object_clone()");
+	}
+	if(position > our_metadata_.num_blocks) {
+		position = our_metadata_.num_blocks;
+	}
+	else {
+		for(i = our_metadata_.num_blocks; i > position; i--)
+			our_metadata_.blocks[i] = our_metadata_.blocks[i-1];
+	}
+	our_metadata_.blocks[position] = obj;
+	our_metadata_.num_blocks++;
+
+	/* set the is_last flags */
+	for(i = 0; i < our_metadata_.num_blocks - 1; i++)
+		our_metadata_.blocks[i]->is_last = false;
+	our_metadata_.blocks[i]->is_last = true;
+
+	return true;
+}
+
+static void delete_from_our_metadata_(unsigned position)
+{
+	unsigned i;
+	FLAC__ASSERT(position < our_metadata_.num_blocks);
+	FLAC__metadata_object_delete(our_metadata_.blocks[position]);
+	for(i = position; i < our_metadata_.num_blocks - 1; i++)
+		our_metadata_.blocks[i] = our_metadata_.blocks[i+1];
+	our_metadata_.num_blocks--;
+
+	/* set the is_last flags */
+	if(our_metadata_.num_blocks > 0) {
+		for(i = 0; i < our_metadata_.num_blocks - 1; i++)
+			our_metadata_.blocks[i]->is_last = false;
+		our_metadata_.blocks[i]->is_last = true;
+	}
+}
+
+/*
+ * This wad of functions supports filename- and callback-based chain reading/writing.
+ * Everything up to set_file_stats_() is copied from libFLAC/metadata_iterators.c
+ */
+static FLAC__bool open_tempfile_(const char *filename, FILE **tempfile, char **tempfilename)
+{
+	static const char *tempfile_suffix = ".metadata_edit";
+
+	if(0 == (*tempfilename = (char*)malloc(strlen(filename) + strlen(tempfile_suffix) + 1)))
+		return false;
+	strcpy(*tempfilename, filename);
+	strcat(*tempfilename, tempfile_suffix);
+
+	if(0 == (*tempfile = fopen(*tempfilename, "wb")))
+		return false;
+
+	return true;
+}
+
+static void cleanup_tempfile_(FILE **tempfile, char **tempfilename)
+{
+	if(0 != *tempfile) {
+		(void)fclose(*tempfile);
+		*tempfile = 0;
+	}
+
+	if(0 != *tempfilename) {
+		(void)unlink(*tempfilename);
+		free(*tempfilename);
+		*tempfilename = 0;
+	}
+}
+
+static FLAC__bool transport_tempfile_(const char *filename, FILE **tempfile, char **tempfilename)
+{
+	FLAC__ASSERT(0 != filename);
+	FLAC__ASSERT(0 != tempfile);
+	FLAC__ASSERT(0 != tempfilename);
+	FLAC__ASSERT(0 != *tempfilename);
+
+	if(0 != *tempfile) {
+		(void)fclose(*tempfile);
+		*tempfile = 0;
+	}
+
+#if defined _MSC_VER || defined __MINGW32__ || defined __EMX__
+	/* on some flavors of windows, rename() will fail if the destination already exists */
+	if(unlink(filename) < 0) {
+		cleanup_tempfile_(tempfile, tempfilename);
+		return false;
+	}
+#endif
+
+	if(0 != rename(*tempfilename, filename)) {
+		cleanup_tempfile_(tempfile, tempfilename);
+		return false;
+	}
+
+	cleanup_tempfile_(tempfile, tempfilename);
+
+	return true;
+}
+
+static FLAC__bool get_file_stats_(const char *filename, struct stat *stats)
+{
+	FLAC__ASSERT(0 != filename);
+	FLAC__ASSERT(0 != stats);
+	return (0 == stat(filename, stats));
+}
+
+static void set_file_stats_(const char *filename, struct stat *stats)
+{
+	struct utimbuf srctime;
+
+	FLAC__ASSERT(0 != filename);
+	FLAC__ASSERT(0 != stats);
+
+	srctime.actime = stats->st_atime;
+	srctime.modtime = stats->st_mtime;
+	(void)chmod(filename, stats->st_mode);
+	(void)utime(filename, &srctime);
+#if !defined _MSC_VER && !defined __MINGW32__ && !defined __EMX__
+	(void)chown(filename, stats->st_uid, -1);
+	(void)chown(filename, -1, stats->st_gid);
+#endif
+}
+
+#ifdef FLAC__VALGRIND_TESTING
+static size_t chain_write_cb_(const void *ptr, size_t size, size_t nmemb, FLAC__IOHandle handle)
+{
+	FILE *stream = (FILE*)handle;
+	size_t ret = fwrite(ptr, size, nmemb, stream);
+	if(!ferror(stream))
+		fflush(stream);
+	return ret;
+}
+#endif
+
+static int chain_seek_cb_(FLAC__IOHandle handle, FLAC__int64 offset, int whence)
+{
+	off_t o = (off_t)offset;
+	FLAC__ASSERT(offset == o);
+	return fseeko((FILE*)handle, o, whence);
+}
+
+static FLAC__int64 chain_tell_cb_(FLAC__IOHandle handle)
+{
+	return ftello((FILE*)handle);
+}
+
+static int chain_eof_cb_(FLAC__IOHandle handle)
+{
+	return feof((FILE*)handle);
+}
+
+static FLAC__bool write_chain_(FLAC__Metadata_Chain *chain, FLAC__bool use_padding, FLAC__bool preserve_file_stats, FLAC__bool filename_based, const char *filename)
+{
+	if(filename_based)
+		return FLAC__metadata_chain_write(chain, use_padding, preserve_file_stats);
+	else {
+		FLAC__IOCallbacks callbacks;
+
+		memset(&callbacks, 0, sizeof(callbacks));
+		callbacks.read = (FLAC__IOCallback_Read)fread;
+#ifdef FLAC__VALGRIND_TESTING
+		callbacks.write = chain_write_cb_;
+#else
+		callbacks.write = (FLAC__IOCallback_Write)fwrite;
+#endif
+		callbacks.seek = chain_seek_cb_;
+		callbacks.eof = chain_eof_cb_;
+
+		if(FLAC__metadata_chain_check_if_tempfile_needed(chain, use_padding)) {
+			struct stat stats;
+			FILE *file, *tempfile = 0;
+			char *tempfilename;
+			if(preserve_file_stats) {
+				if(!get_file_stats_(filename, &stats))
+					return false;
+			}
+			if(0 == (file = fopen(filename, "rb")))
+				return false; /*@@@@ chain status still says OK though */
+			if(!open_tempfile_(filename, &tempfile, &tempfilename)) {
+				fclose(file);
+				cleanup_tempfile_(&tempfile, &tempfilename);
+				return false; /*@@@@ chain status still says OK though */
+			}
+			if(!FLAC__metadata_chain_write_with_callbacks_and_tempfile(chain, use_padding, (FLAC__IOHandle)file, callbacks, (FLAC__IOHandle)tempfile, callbacks)) {
+				fclose(file);
+				fclose(tempfile);
+				return false;
+			}
+			fclose(file);
+			fclose(tempfile);
+			file = tempfile = 0;
+			if(!transport_tempfile_(filename, &tempfile, &tempfilename))
+				return false;
+			if(preserve_file_stats)
+				set_file_stats_(filename, &stats);
+		}
+		else {
+			FILE *file = fopen(filename, "r+b");
+			if(0 == file)
+				return false; /*@@@@ chain status still says OK though */
+			if(!FLAC__metadata_chain_write_with_callbacks(chain, use_padding, (FLAC__IOHandle)file, callbacks))
+				return false;
+			fclose(file);
+		}
+	}
+
+	return true;
+}
+
+static FLAC__bool read_chain_(FLAC__Metadata_Chain *chain, const char *filename, FLAC__bool filename_based, FLAC__bool is_ogg)
+{
+	if(filename_based)
+		return is_ogg?
+			FLAC__metadata_chain_read_ogg(chain, flacfilename(is_ogg)) :
+			FLAC__metadata_chain_read(chain, flacfilename(is_ogg))
+		;
+	else {
+		FLAC__IOCallbacks callbacks;
+
+		memset(&callbacks, 0, sizeof(callbacks));
+		callbacks.read = (FLAC__IOCallback_Read)fread;
+		callbacks.seek = chain_seek_cb_;
+		callbacks.tell = chain_tell_cb_;
+
+		{
+			FLAC__bool ret;
+			FILE *file = fopen(filename, "rb");
+			if(0 == file)
+				return false; /*@@@@ chain status still says OK though */
+			ret = is_ogg?
+				FLAC__metadata_chain_read_ogg_with_callbacks(chain, (FLAC__IOHandle)file, callbacks) :
+				FLAC__metadata_chain_read_with_callbacks(chain, (FLAC__IOHandle)file, callbacks)
+			;
+			fclose(file);
+			return ret;
+		}
+	}
+}
+
+/* function for comparing our metadata to a FLAC__Metadata_Chain */
+
+static FLAC__bool compare_chain_(FLAC__Metadata_Chain *chain, unsigned current_position, FLAC__StreamMetadata *current_block)
+{
+	unsigned i;
+	FLAC__Metadata_Iterator *iterator;
+	FLAC__StreamMetadata *block;
+	FLAC__bool next_ok = true;
+
+	FLAC__ASSERT(0 != chain);
+
+	printf("\tcomparing chain... ");
+	fflush(stdout);
+
+	if(0 == (iterator = FLAC__metadata_iterator_new()))
+		return die_("allocating memory for iterator");
+
+	FLAC__metadata_iterator_init(iterator, chain);
+
+	i = 0;
+	do {
+		printf("%u... ", i);
+		fflush(stdout);
+
+		if(0 == (block = FLAC__metadata_iterator_get_block(iterator))) {
+			FLAC__metadata_iterator_delete(iterator);
+			return die_("getting block from iterator");
+		}
+
+		if(!mutils__compare_block(our_metadata_.blocks[i], block)) {
+			FLAC__metadata_iterator_delete(iterator);
+			return die_("metadata block mismatch");
+		}
+
+		i++;
+		next_ok = FLAC__metadata_iterator_next(iterator);
+	} while(i < our_metadata_.num_blocks && next_ok);
+
+	FLAC__metadata_iterator_delete(iterator);
+
+	if(next_ok)
+		return die_("chain has more blocks than expected");
+
+	if(i < our_metadata_.num_blocks)
+		return die_("short block count in chain");
+
+	if(0 != current_block) {
+		printf("CURRENT_POSITION... ");
+		fflush(stdout);
+
+		if(!mutils__compare_block(our_metadata_.blocks[current_position], current_block))
+			return die_("metadata block mismatch");
+	}
+
+	printf("PASSED\n");
+
+	return true;
+}
+
+/* decoder callbacks for checking the file */
+
+static FLAC__StreamDecoderWriteStatus decoder_write_callback_(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
+{
+	(void)decoder, (void)buffer, (void)client_data;
+
+	if(
+		(frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER && frame->header.number.frame_number == 0) ||
+		(frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER && frame->header.number.sample_number == 0)
+	) {
+		printf("content... ");
+		fflush(stdout);
+	}
+
+	return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
+}
+
+/* this version pays no attention to the metadata */
+static void decoder_metadata_callback_null_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
+{
+	(void)decoder, (void)metadata, (void)client_data;
+
+	printf("%d... ", mc_our_block_number_);
+	fflush(stdout);
+
+	mc_our_block_number_++;
+}
+
+/* this version is used when we want to compare to our metadata copy */
+static void decoder_metadata_callback_compare_(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
+{
+	decoder_client_struct *dcd = (decoder_client_struct*)client_data;
+
+	(void)decoder;
+
+	/* don't bother checking if we've already hit an error */
+	if(dcd->error_occurred)
+		return;
+
+	printf("%d... ", mc_our_block_number_);
+	fflush(stdout);
+
+	if(mc_our_block_number_ >= our_metadata_.num_blocks) {
+		(void)die_("got more metadata blocks than expected");
+		dcd->error_occurred = true;
+	}
+	else {
+		if(!mutils__compare_block(our_metadata_.blocks[mc_our_block_number_], metadata)) {
+			(void)die_("metadata block mismatch");
+			dcd->error_occurred = true;
+		}
+	}
+	mc_our_block_number_++;
+}
+
+static void decoder_error_callback_(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
+{
+	decoder_client_struct *dcd = (decoder_client_struct*)client_data;
+	(void)decoder;
+
+	dcd->error_occurred = true;
+	printf("ERROR: got error callback, status = %s (%u)\n", FLAC__StreamDecoderErrorStatusString[status], (unsigned)status);
+}
+
+static FLAC__bool generate_file_(FLAC__bool include_extras, FLAC__bool is_ogg)
+{
+	FLAC__StreamMetadata streaminfo, vorbiscomment, *cuesheet, picture, padding;
+	FLAC__StreamMetadata *metadata[4];
+	unsigned i = 0, n = 0;
+
+	printf("generating %sFLAC file for test\n", is_ogg? "Ogg " : "");
+
+	while(our_metadata_.num_blocks > 0)
+		delete_from_our_metadata_(0);
+
+	streaminfo.is_last = false;
+	streaminfo.type = FLAC__METADATA_TYPE_STREAMINFO;
+	streaminfo.length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
+	streaminfo.data.stream_info.min_blocksize = 576;
+	streaminfo.data.stream_info.max_blocksize = 576;
+	streaminfo.data.stream_info.min_framesize = 0;
+	streaminfo.data.stream_info.max_framesize = 0;
+	streaminfo.data.stream_info.sample_rate = 44100;
+	streaminfo.data.stream_info.channels = 1;
+	streaminfo.data.stream_info.bits_per_sample = 8;
+	streaminfo.data.stream_info.total_samples = 0;
+	memset(streaminfo.data.stream_info.md5sum, 0, 16);
+
+	{
+		const unsigned vendor_string_length = (unsigned)strlen(FLAC__VENDOR_STRING);
+		vorbiscomment.is_last = false;
+		vorbiscomment.type = FLAC__METADATA_TYPE_VORBIS_COMMENT;
+		vorbiscomment.length = (4 + vendor_string_length) + 4;
+		vorbiscomment.data.vorbis_comment.vendor_string.length = vendor_string_length;
+		vorbiscomment.data.vorbis_comment.vendor_string.entry = malloc_or_die_(vendor_string_length+1);
+		memcpy(vorbiscomment.data.vorbis_comment.vendor_string.entry, FLAC__VENDOR_STRING, vendor_string_length+1);
+		vorbiscomment.data.vorbis_comment.num_comments = 0;
+		vorbiscomment.data.vorbis_comment.comments = 0;
+	}
+
+	{
+		if (0 == (cuesheet = FLAC__metadata_object_new(FLAC__METADATA_TYPE_CUESHEET)))
+			return die_("priming our metadata");
+		cuesheet->is_last = false;
+		strcpy(cuesheet->data.cue_sheet.media_catalog_number, "bogo-MCN");
+		cuesheet->data.cue_sheet.lead_in = 123;
+		cuesheet->data.cue_sheet.is_cd = false;
+		if (!FLAC__metadata_object_cuesheet_insert_blank_track(cuesheet, 0))
+			return die_("priming our metadata");
+		cuesheet->data.cue_sheet.tracks[0].number = 1;
+		if (!FLAC__metadata_object_cuesheet_track_insert_blank_index(cuesheet, 0, 0))
+			return die_("priming our metadata");
+	}
+
+	{
+		picture.is_last = false;
+		picture.type = FLAC__METADATA_TYPE_PICTURE;
+		picture.length =
+			(
+				FLAC__STREAM_METADATA_PICTURE_TYPE_LEN +
+				FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN + /* will add the length for the string later */
+				FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN + /* will add the length for the string later */
+				FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN +
+				FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN +
+				FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN +
+				FLAC__STREAM_METADATA_PICTURE_COLORS_LEN +
+				FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN /* will add the length for the data later */
+			) / 8
+		;
+		picture.data.picture.type = FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER;
+		picture.data.picture.mime_type = strdup_or_die_("image/jpeg");
+		picture.length += strlen(picture.data.picture.mime_type);
+		picture.data.picture.description = (FLAC__byte*)strdup_or_die_("desc");
+		picture.length += strlen((const char *)picture.data.picture.description);
+		picture.data.picture.width = 300;
+		picture.data.picture.height = 300;
+		picture.data.picture.depth = 24;
+		picture.data.picture.colors = 0;
+		picture.data.picture.data = (FLAC__byte*)strdup_or_die_("SOMEJPEGDATA");
+		picture.data.picture.data_length = strlen((const char *)picture.data.picture.data);
+		picture.length += picture.data.picture.data_length;
+	}
+
+	padding.is_last = true;
+	padding.type = FLAC__METADATA_TYPE_PADDING;
+	padding.length = 1234;
+
+	metadata[n++] = &vorbiscomment;
+	if(include_extras) {
+		metadata[n++] = cuesheet;
+		metadata[n++] = &picture;
+	}
+	metadata[n++] = &padding;
+
+	if(
+		!insert_to_our_metadata_(&streaminfo, i++, /*copy=*/true) ||
+		!insert_to_our_metadata_(&vorbiscomment, i++, /*copy=*/true) ||
+		(include_extras && !insert_to_our_metadata_(cuesheet, i++, /*copy=*/false)) ||
+		(include_extras && !insert_to_our_metadata_(&picture, i++, /*copy=*/true)) ||
+		!insert_to_our_metadata_(&padding, i++, /*copy=*/true)
+	)
+		return die_("priming our metadata");
+
+	if(!file_utils__generate_flacfile(is_ogg, flacfilename(is_ogg), 0, 512 * 1024, &streaminfo, metadata, n))
+		return die_("creating the encoded file");
+
+	free(vorbiscomment.data.vorbis_comment.vendor_string.entry);
+	free(picture.data.picture.mime_type);
+	free(picture.data.picture.description);
+	free(picture.data.picture.data);
+	if(!include_extras)
+		FLAC__metadata_object_delete(cuesheet);
+
+	return true;
+}
+
+static FLAC__bool test_file_(FLAC__bool is_ogg, FLAC__StreamDecoderMetadataCallback metadata_callback)
+{
+	const char *filename = flacfilename(is_ogg);
+	FLAC__StreamDecoder *decoder;
+	decoder_client_struct decoder_client_data;
+
+	FLAC__ASSERT(0 != metadata_callback);
+
+	mc_our_block_number_ = 0;
+	decoder_client_data.error_occurred = false;
+
+	printf("\ttesting '%s'... ", filename);
+	fflush(stdout);
+
+	if(0 == (decoder = FLAC__stream_decoder_new()))
+		return die_("couldn't allocate decoder instance");
+
+	FLAC__stream_decoder_set_md5_checking(decoder, true);
+	FLAC__stream_decoder_set_metadata_respond_all(decoder);
+	if(
+		(is_ogg?
+			FLAC__stream_decoder_init_ogg_file(decoder, filename, decoder_write_callback_, metadata_callback, decoder_error_callback_, &decoder_client_data) :
+			FLAC__stream_decoder_init_file(decoder, filename, decoder_write_callback_, metadata_callback, decoder_error_callback_, &decoder_client_data)
+		) != FLAC__STREAM_DECODER_INIT_STATUS_OK
+	) {
+		(void)FLAC__stream_decoder_finish(decoder);
+		FLAC__stream_decoder_delete(decoder);
+		return die_("initializing decoder\n");
+	}
+	if(!FLAC__stream_decoder_process_until_end_of_stream(decoder)) {
+		(void)FLAC__stream_decoder_finish(decoder);
+		FLAC__stream_decoder_delete(decoder);
+		return die_("decoding file\n");
+	}
+
+	(void)FLAC__stream_decoder_finish(decoder);
+	FLAC__stream_decoder_delete(decoder);
+
+	if(decoder_client_data.error_occurred)
+		return false;
+
+	if(mc_our_block_number_ != our_metadata_.num_blocks)
+		return die_("short metadata block count");
+
+	printf("PASSED\n");
+	return true;
+}
+
+static FLAC__bool change_stats_(const char *filename, FLAC__bool read_only)
+{
+	if(!grabbag__file_change_stats(filename, read_only))
+		return die_("during grabbag__file_change_stats()");
+
+	return true;
+}
+
+static FLAC__bool remove_file_(const char *filename)
+{
+	while(our_metadata_.num_blocks > 0)
+		delete_from_our_metadata_(0);
+
+	if(!grabbag__file_remove_file(filename))
+		return die_("removing file");
+
+	return true;
+}
+
+static FLAC__bool test_level_0_(void)
+{
+	FLAC__StreamMetadata streaminfo;
+	FLAC__StreamMetadata *tags = 0;
+	FLAC__StreamMetadata *cuesheet = 0;
+	FLAC__StreamMetadata *picture = 0;
+
+	printf("\n\n++++++ testing level 0 interface\n");
+
+	if(!generate_file_(/*include_extras=*/true, /*is_ogg=*/false))
+		return false;
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_null_))
+		return false;
+
+	printf("testing FLAC__metadata_get_streaminfo()... ");
+
+	if(!FLAC__metadata_get_streaminfo(flacfilename(/*is_ogg=*/false), &streaminfo))
+		return die_("during FLAC__metadata_get_streaminfo()");
+
+	/* check to see if some basic data matches (c.f. generate_file_()) */
+	if(streaminfo.data.stream_info.channels != 1)
+		return die_("mismatch in streaminfo.data.stream_info.channels");
+	if(streaminfo.data.stream_info.bits_per_sample != 8)
+		return die_("mismatch in streaminfo.data.stream_info.bits_per_sample");
+	if(streaminfo.data.stream_info.sample_rate != 44100)
+		return die_("mismatch in streaminfo.data.stream_info.sample_rate");
+	if(streaminfo.data.stream_info.min_blocksize != 576)
+		return die_("mismatch in streaminfo.data.stream_info.min_blocksize");
+	if(streaminfo.data.stream_info.max_blocksize != 576)
+		return die_("mismatch in streaminfo.data.stream_info.max_blocksize");
+
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_get_tags()... ");
+
+	if(!FLAC__metadata_get_tags(flacfilename(/*is_ogg=*/false), &tags))
+		return die_("during FLAC__metadata_get_tags()");
+
+	/* check to see if some basic data matches (c.f. generate_file_()) */
+	if(tags->data.vorbis_comment.num_comments != 0)
+		return die_("mismatch in tags->data.vorbis_comment.num_comments");
+
+	printf("OK\n");
+
+	FLAC__metadata_object_delete(tags);
+
+	printf("testing FLAC__metadata_get_cuesheet()... ");
+
+	if(!FLAC__metadata_get_cuesheet(flacfilename(/*is_ogg=*/false), &cuesheet))
+		return die_("during FLAC__metadata_get_cuesheet()");
+
+	/* check to see if some basic data matches (c.f. generate_file_()) */
+	if(cuesheet->data.cue_sheet.lead_in != 123)
+		return die_("mismatch in cuesheet->data.cue_sheet.lead_in");
+
+	printf("OK\n");
+
+	FLAC__metadata_object_delete(cuesheet);
+
+	printf("testing FLAC__metadata_get_picture()... ");
+
+	if(!FLAC__metadata_get_picture(flacfilename(/*is_ogg=*/false), &picture, /*type=*/(FLAC__StreamMetadata_Picture_Type)(-1), /*mime_type=*/0, /*description=*/0, /*max_width=*/(unsigned)(-1), /*max_height=*/(unsigned)(-1), /*max_depth=*/(unsigned)(-1), /*max_colors=*/(unsigned)(-1)))
+		return die_("during FLAC__metadata_get_picture()");
+
+	/* check to see if some basic data matches (c.f. generate_file_()) */
+	if(picture->data.picture.type != FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER)
+		return die_("mismatch in picture->data.picture.type");
+
+	printf("OK\n");
+
+	FLAC__metadata_object_delete(picture);
+
+	if(!remove_file_(flacfilename(/*is_ogg=*/false)))
+		return false;
+
+	return true;
+}
+
+static FLAC__bool test_level_1_(void)
+{
+	FLAC__Metadata_SimpleIterator *iterator;
+	FLAC__StreamMetadata *block, *app, *padding;
+	FLAC__byte data[1000];
+	unsigned our_current_position = 0;
+
+	/* initialize 'data' to avoid Valgrind errors */
+	memset(data, 0, sizeof(data));
+
+	printf("\n\n++++++ testing level 1 interface\n");
+
+	/************************************************************/
+
+	printf("simple iterator on read-only file\n");
+
+	if(!generate_file_(/*include_extras=*/false, /*is_ogg=*/false))
+		return false;
+
+	if(!change_stats_(flacfilename(/*is_ogg=*/false), /*read_only=*/true))
+		return false;
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_null_))
+		return false;
+
+	if(0 == (iterator = FLAC__metadata_simple_iterator_new()))
+		return die_("FLAC__metadata_simple_iterator_new()");
+
+	if(!FLAC__metadata_simple_iterator_init(iterator, flacfilename(/*is_ogg=*/false), /*read_only=*/false, /*preserve_file_stats=*/false))
+		return die_("FLAC__metadata_simple_iterator_init() returned false");
+
+	printf("is writable = %u\n", (unsigned)FLAC__metadata_simple_iterator_is_writable(iterator));
+	if(FLAC__metadata_simple_iterator_is_writable(iterator))
+		return die_("iterator claims file is writable when tester thinks it should not be; are you running as root?\n");
+
+	printf("iterate forwards\n");
+
+	if(FLAC__metadata_simple_iterator_get_block_type(iterator) != FLAC__METADATA_TYPE_STREAMINFO)
+		return die_("expected STREAMINFO type from FLAC__metadata_simple_iterator_get_block_type()");
+	if(0 == (block = FLAC__metadata_simple_iterator_get_block(iterator)))
+		return die_("getting block 0");
+	if(block->type != FLAC__METADATA_TYPE_STREAMINFO)
+		return die_("expected STREAMINFO type");
+	if(block->is_last)
+		return die_("expected is_last to be false");
+	if(block->length != FLAC__STREAM_METADATA_STREAMINFO_LENGTH)
+		return die_("bad STREAMINFO length");
+	/* check to see if some basic data matches (c.f. generate_file_()) */
+	if(block->data.stream_info.channels != 1)
+		return die_("mismatch in channels");
+	if(block->data.stream_info.bits_per_sample != 8)
+		return die_("mismatch in bits_per_sample");
+	if(block->data.stream_info.sample_rate != 44100)
+		return die_("mismatch in sample_rate");
+	if(block->data.stream_info.min_blocksize != 576)
+		return die_("mismatch in min_blocksize");
+	if(block->data.stream_info.max_blocksize != 576)
+		return die_("mismatch in max_blocksize");
+	FLAC__metadata_object_delete(block);
+
+	if(!FLAC__metadata_simple_iterator_next(iterator))
+		return die_("forward iterator ended early");
+	our_current_position++;
+
+	if(!FLAC__metadata_simple_iterator_next(iterator))
+		return die_("forward iterator ended early");
+	our_current_position++;
+
+	if(FLAC__metadata_simple_iterator_get_block_type(iterator) != FLAC__METADATA_TYPE_PADDING)
+		return die_("expected PADDING type from FLAC__metadata_simple_iterator_get_block_type()");
+	if(0 == (block = FLAC__metadata_simple_iterator_get_block(iterator)))
+		return die_("getting block 2");
+	if(block->type != FLAC__METADATA_TYPE_PADDING)
+		return die_("expected PADDING type");
+	if(!block->is_last)
+		return die_("expected is_last to be true");
+	/* check to see if some basic data matches (c.f. generate_file_()) */
+	if(block->length != 1234)
+		return die_("bad PADDING length");
+	FLAC__metadata_object_delete(block);
+
+	if(FLAC__metadata_simple_iterator_next(iterator))
+		return die_("forward iterator returned true but should have returned false");
+
+	printf("iterate backwards\n");
+	if(!FLAC__metadata_simple_iterator_prev(iterator))
+		return die_("reverse iterator ended early");
+	if(!FLAC__metadata_simple_iterator_prev(iterator))
+		return die_("reverse iterator ended early");
+	if(FLAC__metadata_simple_iterator_prev(iterator))
+		return die_("reverse iterator returned true but should have returned false");
+
+	printf("testing FLAC__metadata_simple_iterator_set_block() on read-only file...\n");
+
+	if(!FLAC__metadata_simple_iterator_set_block(iterator, (FLAC__StreamMetadata*)99, false))
+		printf("OK: FLAC__metadata_simple_iterator_set_block() returned false like it should\n");
+	else
+		return die_("FLAC__metadata_simple_iterator_set_block() returned true but shouldn't have");
+
+	FLAC__metadata_simple_iterator_delete(iterator);
+
+	/************************************************************/
+
+	printf("simple iterator on writable file\n");
+
+	if(!change_stats_(flacfilename(/*is_ogg=*/false), /*read-only=*/false))
+		return false;
+
+	printf("creating APPLICATION block\n");
+
+	if(0 == (app = FLAC__metadata_object_new(FLAC__METADATA_TYPE_APPLICATION)))
+		return die_("FLAC__metadata_object_new(FLAC__METADATA_TYPE_APPLICATION)");
+	memcpy(app->data.application.id, "duh", (FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8));
+
+	printf("creating PADDING block\n");
+
+	if(0 == (padding = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING)))
+		return die_("FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING)");
+	padding->length = 20;
+
+	if(0 == (iterator = FLAC__metadata_simple_iterator_new()))
+		return die_("FLAC__metadata_simple_iterator_new()");
+
+	if(!FLAC__metadata_simple_iterator_init(iterator, flacfilename(/*is_ogg=*/false), /*read_only=*/false, /*preserve_file_stats=*/false))
+		return die_("FLAC__metadata_simple_iterator_init() returned false");
+	our_current_position = 0;
+
+	printf("is writable = %u\n", (unsigned)FLAC__metadata_simple_iterator_is_writable(iterator));
+
+	printf("[S]VP\ttry to write over STREAMINFO block...\n");
+	if(!FLAC__metadata_simple_iterator_set_block(iterator, app, false))
+		printf("\tFLAC__metadata_simple_iterator_set_block() returned false like it should\n");
+	else
+		return die_("FLAC__metadata_simple_iterator_set_block() returned true but shouldn't have");
+
+	printf("[S]VP\tnext\n");
+	if(!FLAC__metadata_simple_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("S[V]P\tnext\n");
+	if(!FLAC__metadata_simple_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SV[P]\tinsert PADDING after, don't expand into padding\n");
+	padding->length = 25;
+	if(!FLAC__metadata_simple_iterator_insert_block_after(iterator, padding, false))
+		return die_ss_("FLAC__metadata_simple_iterator_insert_block_after(iterator, padding, false)", iterator);
+	if(!insert_to_our_metadata_(padding, ++our_current_position, /*copy=*/true))
+		return false;
+
+	printf("SVP[P]\tprev\n");
+	if(!FLAC__metadata_simple_iterator_prev(iterator))
+		return die_("iterator ended early\n");
+	our_current_position--;
+
+	printf("SV[P]P\tprev\n");
+	if(!FLAC__metadata_simple_iterator_prev(iterator))
+		return die_("iterator ended early\n");
+	our_current_position--;
+
+	printf("S[V]PP\tinsert PADDING after, don't expand into padding\n");
+	padding->length = 30;
+	if(!FLAC__metadata_simple_iterator_insert_block_after(iterator, padding, false))
+		return die_ss_("FLAC__metadata_simple_iterator_insert_block_after(iterator, padding, false)", iterator);
+	if(!insert_to_our_metadata_(padding, ++our_current_position, /*copy=*/true))
+		return false;
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[P]PP\tprev\n");
+	if(!FLAC__metadata_simple_iterator_prev(iterator))
+		return die_("iterator ended early\n");
+	our_current_position--;
+
+	printf("S[V]PPP\tprev\n");
+	if(!FLAC__metadata_simple_iterator_prev(iterator))
+		return die_("iterator ended early\n");
+	our_current_position--;
+
+	printf("[S]VPPP\tdelete (STREAMINFO block), must fail\n");
+	if(FLAC__metadata_simple_iterator_delete_block(iterator, false))
+		return die_ss_("FLAC__metadata_simple_iterator_delete_block(iterator, false) should have returned false", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("[S]VPPP\tnext\n");
+	if(!FLAC__metadata_simple_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("S[V]PPP\tnext\n");
+	if(!FLAC__metadata_simple_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SV[P]PP\tdelete (middle block), replace with padding\n");
+	if(!FLAC__metadata_simple_iterator_delete_block(iterator, true))
+		return die_ss_("FLAC__metadata_simple_iterator_delete_block(iterator, true)", iterator);
+	our_current_position--;
+
+	printf("S[V]PPP\tnext\n");
+	if(!FLAC__metadata_simple_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SV[P]PP\tdelete (middle block), don't replace with padding\n");
+	if(!FLAC__metadata_simple_iterator_delete_block(iterator, false))
+		return die_ss_("FLAC__metadata_simple_iterator_delete_block(iterator, false)", iterator);
+	delete_from_our_metadata_(our_current_position--);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("S[V]PP\tnext\n");
+	if(!FLAC__metadata_simple_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SV[P]P\tnext\n");
+	if(!FLAC__metadata_simple_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SVP[P]\tdelete (last block), replace with padding\n");
+	if(!FLAC__metadata_simple_iterator_delete_block(iterator, true))
+		return die_ss_("FLAC__metadata_simple_iterator_delete_block(iterator, false)", iterator);
+	our_current_position--;
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[P]P\tnext\n");
+	if(!FLAC__metadata_simple_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SVP[P]\tdelete (last block), don't replace with padding\n");
+	if(!FLAC__metadata_simple_iterator_delete_block(iterator, false))
+		return die_ss_("FLAC__metadata_simple_iterator_delete_block(iterator, false)", iterator);
+	delete_from_our_metadata_(our_current_position--);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[P]\tprev\n");
+	if(!FLAC__metadata_simple_iterator_prev(iterator))
+		return die_("iterator ended early\n");
+	our_current_position--;
+
+	printf("S[V]P\tprev\n");
+	if(!FLAC__metadata_simple_iterator_prev(iterator))
+		return die_("iterator ended early\n");
+	our_current_position--;
+
+	printf("[S]VP\tset STREAMINFO (change sample rate)\n");
+	FLAC__ASSERT(our_current_position == 0);
+	block = FLAC__metadata_simple_iterator_get_block(iterator);
+	block->data.stream_info.sample_rate = 32000;
+	if(!replace_in_our_metadata_(block, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	if(!FLAC__metadata_simple_iterator_set_block(iterator, block, false))
+		return die_ss_("FLAC__metadata_simple_iterator_set_block(iterator, block, false)", iterator);
+	FLAC__metadata_object_delete(block);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("[S]VP\tnext\n");
+	if(!FLAC__metadata_simple_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("S[V]P\tinsert APPLICATION after, expand into padding of exceeding size\n");
+	app->data.application.id[0] = 'e'; /* twiddle the id so that our comparison doesn't miss transposition */
+	if(!FLAC__metadata_simple_iterator_insert_block_after(iterator, app, true))
+		return die_ss_("FLAC__metadata_simple_iterator_insert_block_after(iterator, app, true)", iterator);
+	if(!insert_to_our_metadata_(app, ++our_current_position, /*copy=*/true))
+		return false;
+	our_metadata_.blocks[our_current_position+1]->length -= (FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8) + app->length;
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]P\tnext\n");
+	if(!FLAC__metadata_simple_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SVA[P]\tset APPLICATION, expand into padding of exceeding size\n");
+	app->data.application.id[0] = 'f'; /* twiddle the id */
+	if(!FLAC__metadata_simple_iterator_set_block(iterator, app, true))
+		return die_ss_("FLAC__metadata_simple_iterator_set_block(iterator, app, true)", iterator);
+	if(!insert_to_our_metadata_(app, our_current_position, /*copy=*/true))
+		return false;
+	our_metadata_.blocks[our_current_position+1]->length -= (FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8) + app->length;
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SVA[A]P\tset APPLICATION (grow), don't expand into padding\n");
+	app->data.application.id[0] = 'g'; /* twiddle the id */
+	if(!FLAC__metadata_object_application_set_data(app, data, sizeof(data), true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	if(!FLAC__metadata_simple_iterator_set_block(iterator, app, false))
+		return die_ss_("FLAC__metadata_simple_iterator_set_block(iterator, app, false)", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SVA[A]P\tset APPLICATION (shrink), don't fill in with padding\n");
+	app->data.application.id[0] = 'h'; /* twiddle the id */
+	if(!FLAC__metadata_object_application_set_data(app, data, 12, true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	if(!FLAC__metadata_simple_iterator_set_block(iterator, app, false))
+		return die_ss_("FLAC__metadata_simple_iterator_set_block(iterator, app, false)", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SVA[A]P\tset APPLICATION (grow), expand into padding of exceeding size\n");
+	app->data.application.id[0] = 'i'; /* twiddle the id */
+	if(!FLAC__metadata_object_application_set_data(app, data, sizeof(data), true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	our_metadata_.blocks[our_current_position+1]->length -= (sizeof(data) - 12);
+	if(!FLAC__metadata_simple_iterator_set_block(iterator, app, true))
+		return die_ss_("FLAC__metadata_simple_iterator_set_block(iterator, app, true)", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SVA[A]P\tset APPLICATION (shrink), fill in with padding\n");
+	app->data.application.id[0] = 'j'; /* twiddle the id */
+	if(!FLAC__metadata_object_application_set_data(app, data, 23, true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	if(!insert_to_our_metadata_(padding, our_current_position+1, /*copy=*/true))
+		return die_("copying object");
+	our_metadata_.blocks[our_current_position+1]->length = sizeof(data) - 23 - FLAC__STREAM_METADATA_HEADER_LENGTH;
+	if(!FLAC__metadata_simple_iterator_set_block(iterator, app, true))
+		return die_ss_("FLAC__metadata_simple_iterator_set_block(iterator, app, true)", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SVA[A]PP\tnext\n");
+	if(!FLAC__metadata_simple_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SVAA[P]P\tnext\n");
+	if(!FLAC__metadata_simple_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SVAAP[P]\tset PADDING (shrink), don't fill in with padding\n");
+	padding->length = 5;
+	if(!replace_in_our_metadata_(padding, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	if(!FLAC__metadata_simple_iterator_set_block(iterator, padding, false))
+		return die_ss_("FLAC__metadata_simple_iterator_set_block(iterator, padding, false)", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SVAAP[P]\tset APPLICATION (grow)\n");
+	app->data.application.id[0] = 'k'; /* twiddle the id */
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	if(!FLAC__metadata_simple_iterator_set_block(iterator, app, false))
+		return die_ss_("FLAC__metadata_simple_iterator_set_block(iterator, app, false)", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SVAAP[A]\tset PADDING (equal)\n");
+	padding->length = 27;
+	if(!replace_in_our_metadata_(padding, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	if(!FLAC__metadata_simple_iterator_set_block(iterator, padding, false))
+		return die_ss_("FLAC__metadata_simple_iterator_set_block(iterator, padding, false)", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SVAAP[P]\tprev\n");
+	if(!FLAC__metadata_simple_iterator_prev(iterator))
+		return die_("iterator ended early\n");
+	our_current_position--;
+
+	printf("SVAA[P]P\tdelete (middle block), don't replace with padding\n");
+	if(!FLAC__metadata_simple_iterator_delete_block(iterator, false))
+		return die_ss_("FLAC__metadata_simple_iterator_delete_block(iterator, false)", iterator);
+	delete_from_our_metadata_(our_current_position--);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SVA[A]P\tdelete (middle block), don't replace with padding\n");
+	if(!FLAC__metadata_simple_iterator_delete_block(iterator, false))
+		return die_ss_("FLAC__metadata_simple_iterator_delete_block(iterator, false)", iterator);
+	delete_from_our_metadata_(our_current_position--);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]P\tnext\n");
+	if(!FLAC__metadata_simple_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SVA[P]\tinsert PADDING after\n");
+	padding->length = 5;
+	if(!FLAC__metadata_simple_iterator_insert_block_after(iterator, padding, false))
+		return die_ss_("FLAC__metadata_simple_iterator_insert_block_after(iterator, padding, false)", iterator);
+	if(!insert_to_our_metadata_(padding, ++our_current_position, /*copy=*/true))
+		return false;
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SVAP[P]\tprev\n");
+	if(!FLAC__metadata_simple_iterator_prev(iterator))
+		return die_("iterator ended early\n");
+	our_current_position--;
+
+	printf("SVA[P]P\tprev\n");
+	if(!FLAC__metadata_simple_iterator_prev(iterator))
+		return die_("iterator ended early\n");
+	our_current_position--;
+
+	printf("SV[A]PP\tset APPLICATION (grow), try to expand into padding which is too small\n");
+	if(!FLAC__metadata_object_application_set_data(app, data, 32, true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	if(!FLAC__metadata_simple_iterator_set_block(iterator, app, true))
+		return die_ss_("FLAC__metadata_simple_iterator_set_block(iterator, app, true)", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]PP\tset APPLICATION (grow), try to expand into padding which is 'close' but still too small\n");
+	if(!FLAC__metadata_object_application_set_data(app, data, 60, true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	if(!FLAC__metadata_simple_iterator_set_block(iterator, app, true))
+		return die_ss_("FLAC__metadata_simple_iterator_set_block(iterator, app, true)", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]PP\tset APPLICATION (grow), expand into padding which will leave 0-length pad\n");
+	if(!FLAC__metadata_object_application_set_data(app, data, 87, true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	our_metadata_.blocks[our_current_position+1]->length = 0;
+	if(!FLAC__metadata_simple_iterator_set_block(iterator, app, true))
+		return die_ss_("FLAC__metadata_simple_iterator_set_block(iterator, app, true)", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]PP\tset APPLICATION (grow), expand into padding which is exactly consumed\n");
+	if(!FLAC__metadata_object_application_set_data(app, data, 91, true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	delete_from_our_metadata_(our_current_position+1);
+	if(!FLAC__metadata_simple_iterator_set_block(iterator, app, true))
+		return die_ss_("FLAC__metadata_simple_iterator_set_block(iterator, app, true)", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]P\tset APPLICATION (grow), expand into padding which is exactly consumed\n");
+	if(!FLAC__metadata_object_application_set_data(app, data, 100, true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	delete_from_our_metadata_(our_current_position+1);
+	our_metadata_.blocks[our_current_position]->is_last = true;
+	if(!FLAC__metadata_simple_iterator_set_block(iterator, app, true))
+		return die_ss_("FLAC__metadata_simple_iterator_set_block(iterator, app, true)", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]\tset PADDING (equal size)\n");
+	padding->length = app->length;
+	if(!replace_in_our_metadata_(padding, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	if(!FLAC__metadata_simple_iterator_set_block(iterator, padding, true))
+		return die_ss_("FLAC__metadata_simple_iterator_set_block(iterator, padding, true)", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[P]\tinsert PADDING after\n");
+	if(!FLAC__metadata_simple_iterator_insert_block_after(iterator, padding, false))
+		return die_ss_("FLAC__metadata_simple_iterator_insert_block_after(iterator, padding, false)", iterator);
+	if(!insert_to_our_metadata_(padding, ++our_current_position, /*copy=*/true))
+		return false;
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SVP[P]\tinsert PADDING after\n");
+	padding->length = 5;
+	if(!FLAC__metadata_simple_iterator_insert_block_after(iterator, padding, false))
+		return die_ss_("FLAC__metadata_simple_iterator_insert_block_after(iterator, padding, false)", iterator);
+	if(!insert_to_our_metadata_(padding, ++our_current_position, /*copy=*/true))
+		return false;
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SVPP[P]\tprev\n");
+	if(!FLAC__metadata_simple_iterator_prev(iterator))
+		return die_("iterator ended early\n");
+	our_current_position--;
+
+	printf("SVP[P]P\tprev\n");
+	if(!FLAC__metadata_simple_iterator_prev(iterator))
+		return die_("iterator ended early\n");
+	our_current_position--;
+
+	printf("SV[P]PP\tprev\n");
+	if(!FLAC__metadata_simple_iterator_prev(iterator))
+		return die_("iterator ended early\n");
+	our_current_position--;
+
+	printf("S[V]PPP\tinsert APPLICATION after, try to expand into padding which is too small\n");
+	if(!FLAC__metadata_object_application_set_data(app, data, 101, true))
+		return die_("setting APPLICATION data");
+	if(!insert_to_our_metadata_(app, ++our_current_position, /*copy=*/true))
+		return die_("copying object");
+	if(!FLAC__metadata_simple_iterator_insert_block_after(iterator, app, true))
+		return die_ss_("FLAC__metadata_simple_iterator_insert_block_after(iterator, app, true)", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]PPP\tdelete (middle block), don't replace with padding\n");
+	if(!FLAC__metadata_simple_iterator_delete_block(iterator, false))
+		return die_ss_("FLAC__metadata_simple_iterator_delete_block(iterator, false)", iterator);
+	delete_from_our_metadata_(our_current_position--);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("S[V]PPP\tinsert APPLICATION after, try to expand into padding which is 'close' but still too small\n");
+	if(!FLAC__metadata_object_application_set_data(app, data, 97, true))
+		return die_("setting APPLICATION data");
+	if(!insert_to_our_metadata_(app, ++our_current_position, /*copy=*/true))
+		return die_("copying object");
+	if(!FLAC__metadata_simple_iterator_insert_block_after(iterator, app, true))
+		return die_ss_("FLAC__metadata_simple_iterator_insert_block_after(iterator, app, true)", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]PPP\tdelete (middle block), don't replace with padding\n");
+	if(!FLAC__metadata_simple_iterator_delete_block(iterator, false))
+		return die_ss_("FLAC__metadata_simple_iterator_delete_block(iterator, false)", iterator);
+	delete_from_our_metadata_(our_current_position--);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("S[V]PPP\tinsert APPLICATION after, expand into padding which is exactly consumed\n");
+	if(!FLAC__metadata_object_application_set_data(app, data, 100, true))
+		return die_("setting APPLICATION data");
+	if(!insert_to_our_metadata_(app, ++our_current_position, /*copy=*/true))
+		return die_("copying object");
+	delete_from_our_metadata_(our_current_position+1);
+	if(!FLAC__metadata_simple_iterator_insert_block_after(iterator, app, true))
+		return die_ss_("FLAC__metadata_simple_iterator_insert_block_after(iterator, app, true)", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]PP\tdelete (middle block), don't replace with padding\n");
+	if(!FLAC__metadata_simple_iterator_delete_block(iterator, false))
+		return die_ss_("FLAC__metadata_simple_iterator_delete_block(iterator, false)", iterator);
+	delete_from_our_metadata_(our_current_position--);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("S[V]PP\tinsert APPLICATION after, expand into padding which will leave 0-length pad\n");
+	if(!FLAC__metadata_object_application_set_data(app, data, 96, true))
+		return die_("setting APPLICATION data");
+	if(!insert_to_our_metadata_(app, ++our_current_position, /*copy=*/true))
+		return die_("copying object");
+	our_metadata_.blocks[our_current_position+1]->length = 0;
+	if(!FLAC__metadata_simple_iterator_insert_block_after(iterator, app, true))
+		return die_ss_("FLAC__metadata_simple_iterator_insert_block_after(iterator, app, true)", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]PP\tdelete (middle block), don't replace with padding\n");
+	if(!FLAC__metadata_simple_iterator_delete_block(iterator, false))
+		return die_ss_("FLAC__metadata_simple_iterator_delete_block(iterator, false)", iterator);
+	delete_from_our_metadata_(our_current_position--);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("S[V]PP\tnext\n");
+	if(!FLAC__metadata_simple_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SV[P]P\tdelete (middle block), don't replace with padding\n");
+	if(!FLAC__metadata_simple_iterator_delete_block(iterator, false))
+		return die_ss_("FLAC__metadata_simple_iterator_delete_block(iterator, false)", iterator);
+	delete_from_our_metadata_(our_current_position--);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("S[V]P\tinsert APPLICATION after, expand into padding which is exactly consumed\n");
+	if(!FLAC__metadata_object_application_set_data(app, data, 1, true))
+		return die_("setting APPLICATION data");
+	if(!insert_to_our_metadata_(app, ++our_current_position, /*copy=*/true))
+		return die_("copying object");
+	delete_from_our_metadata_(our_current_position+1);
+	if(!FLAC__metadata_simple_iterator_insert_block_after(iterator, app, true))
+		return die_ss_("FLAC__metadata_simple_iterator_insert_block_after(iterator, app, true)", iterator);
+
+	if(!test_file_(/*is_ogg=*/false, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("delete simple iterator\n");
+
+	FLAC__metadata_simple_iterator_delete(iterator);
+
+	FLAC__metadata_object_delete(app);
+	FLAC__metadata_object_delete(padding);
+
+	if(!remove_file_(flacfilename(/*is_ogg=*/false)))
+		return false;
+
+	return true;
+}
+
+static FLAC__bool test_level_2_(FLAC__bool filename_based, FLAC__bool is_ogg)
+{
+	FLAC__Metadata_Iterator *iterator;
+	FLAC__Metadata_Chain *chain;
+	FLAC__StreamMetadata *block, *app, *padding;
+	FLAC__byte data[2000];
+	unsigned our_current_position;
+
+	/* initialize 'data' to avoid Valgrind errors */
+	memset(data, 0, sizeof(data));
+
+	printf("\n\n++++++ testing level 2 interface (%s-based, %s FLAC)\n", filename_based? "filename":"callback", is_ogg? "Ogg":"native");
+
+	printf("generate read-only file\n");
+
+	if(!generate_file_(/*include_extras=*/false, is_ogg))
+		return false;
+
+	if(!change_stats_(flacfilename(is_ogg), /*read_only=*/true))
+		return false;
+
+	printf("create chain\n");
+
+	if(0 == (chain = FLAC__metadata_chain_new()))
+		return die_("allocating chain");
+
+	printf("read chain\n");
+
+	if(!read_chain_(chain, flacfilename(is_ogg), filename_based, is_ogg))
+		return die_c_("reading chain", FLAC__metadata_chain_status(chain));
+
+	printf("[S]VP\ttest initial metadata\n");
+
+	if(!compare_chain_(chain, 0, 0))
+		return false;
+	if(!test_file_(is_ogg, decoder_metadata_callback_compare_))
+		return false;
+
+	if(is_ogg)
+		goto end;
+
+	printf("switch file to read-write\n");
+
+	if(!change_stats_(flacfilename(is_ogg), /*read-only=*/false))
+		return false;
+
+	printf("create iterator\n");
+	if(0 == (iterator = FLAC__metadata_iterator_new()))
+		return die_("allocating memory for iterator");
+
+	our_current_position = 0;
+
+	FLAC__metadata_iterator_init(iterator, chain);
+
+	if(0 == (block = FLAC__metadata_iterator_get_block(iterator)))
+		return die_("getting block from iterator");
+
+	FLAC__ASSERT(block->type == FLAC__METADATA_TYPE_STREAMINFO);
+
+	printf("[S]VP\tmodify STREAMINFO, write\n");
+
+	block->data.stream_info.sample_rate = 32000;
+	if(!replace_in_our_metadata_(block, our_current_position, /*copy=*/true))
+		return die_("copying object");
+
+	if(!write_chain_(chain, /*use_padding=*/false, /*preserve_file_stats=*/true, filename_based, flacfilename(is_ogg)))
+		return die_c_("during FLAC__metadata_chain_write(chain, false, true)", FLAC__metadata_chain_status(chain));
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+	if(!test_file_(is_ogg, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("[S]VP\tnext\n");
+	if(!FLAC__metadata_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("S[V]P\tnext\n");
+	if(!FLAC__metadata_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SV[P]\treplace PADDING with identical-size APPLICATION\n");
+	if(0 == (block = FLAC__metadata_iterator_get_block(iterator)))
+		return die_("getting block from iterator");
+	if(0 == (app = FLAC__metadata_object_new(FLAC__METADATA_TYPE_APPLICATION)))
+		return die_("FLAC__metadata_object_new(FLAC__METADATA_TYPE_APPLICATION)");
+	memcpy(app->data.application.id, "duh", (FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8));
+	if(!FLAC__metadata_object_application_set_data(app, data, block->length-(FLAC__STREAM_METADATA_APPLICATION_ID_LEN/8), true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	if(!FLAC__metadata_iterator_set_block(iterator, app))
+		return die_c_("FLAC__metadata_iterator_set_block(iterator, app)", FLAC__metadata_chain_status(chain));
+
+	if(!write_chain_(chain, /*use_padding=*/false, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
+		return die_c_("during FLAC__metadata_chain_write(chain, false, false)", FLAC__metadata_chain_status(chain));
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+	if(!test_file_(is_ogg, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]\tshrink APPLICATION, don't use padding\n");
+	if(0 == (app = FLAC__metadata_object_clone(our_metadata_.blocks[our_current_position])))
+		return die_("copying object");
+	if(!FLAC__metadata_object_application_set_data(app, data, 26, true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	if(!FLAC__metadata_iterator_set_block(iterator, app))
+		return die_c_("FLAC__metadata_iterator_set_block(iterator, app)", FLAC__metadata_chain_status(chain));
+
+	if(!write_chain_(chain, /*use_padding=*/false, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
+		return die_c_("during FLAC__metadata_chain_write(chain, false, false)", FLAC__metadata_chain_status(chain));
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+	if(!test_file_(is_ogg, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]\tgrow APPLICATION, don't use padding\n");
+	if(0 == (app = FLAC__metadata_object_clone(our_metadata_.blocks[our_current_position])))
+		return die_("copying object");
+	if(!FLAC__metadata_object_application_set_data(app, data, 28, true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	if(!FLAC__metadata_iterator_set_block(iterator, app))
+		return die_c_("FLAC__metadata_iterator_set_block(iterator, app)", FLAC__metadata_chain_status(chain));
+
+	if(!write_chain_(chain, /*use_padding=*/false, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
+		return die_c_("during FLAC__metadata_chain_write(chain, false, false)", FLAC__metadata_chain_status(chain));
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+	if(!test_file_(is_ogg, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]\tgrow APPLICATION, use padding, but last block is not padding\n");
+	if(0 == (app = FLAC__metadata_object_clone(our_metadata_.blocks[our_current_position])))
+		return die_("copying object");
+	if(!FLAC__metadata_object_application_set_data(app, data, 36, true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	if(!FLAC__metadata_iterator_set_block(iterator, app))
+		return die_c_("FLAC__metadata_iterator_set_block(iterator, app)", FLAC__metadata_chain_status(chain));
+
+	if(!write_chain_(chain, /*use_padding=*/false, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
+		return die_c_("during FLAC__metadata_chain_write(chain, false, false)", FLAC__metadata_chain_status(chain));
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+	if(!test_file_(is_ogg, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]\tshrink APPLICATION, use padding, last block is not padding, but delta is too small for new PADDING block\n");
+	if(0 == (app = FLAC__metadata_object_clone(our_metadata_.blocks[our_current_position])))
+		return die_("copying object");
+	if(!FLAC__metadata_object_application_set_data(app, data, 33, true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	if(!FLAC__metadata_iterator_set_block(iterator, app))
+		return die_c_("FLAC__metadata_iterator_set_block(iterator, app)", FLAC__metadata_chain_status(chain));
+
+	if(!write_chain_(chain, /*use_padding=*/true, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
+		return die_c_("during FLAC__metadata_chain_write(chain, true, false)", FLAC__metadata_chain_status(chain));
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+	if(!test_file_(is_ogg, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]\tshrink APPLICATION, use padding, last block is not padding, delta is enough for new PADDING block\n");
+	if(0 == (padding = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING)))
+		return die_("creating PADDING block");
+	if(0 == (app = FLAC__metadata_object_clone(our_metadata_.blocks[our_current_position])))
+		return die_("copying object");
+	if(!FLAC__metadata_object_application_set_data(app, data, 29, true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	padding->length = 0;
+	if(!insert_to_our_metadata_(padding, our_current_position+1, /*copy=*/false))
+		return die_("internal error");
+	if(!FLAC__metadata_iterator_set_block(iterator, app))
+		return die_c_("FLAC__metadata_iterator_set_block(iterator, app)", FLAC__metadata_chain_status(chain));
+
+	if(!write_chain_(chain, /*use_padding=*/true, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
+		return die_c_("during FLAC__metadata_chain_write(chain, true, false)", FLAC__metadata_chain_status(chain));
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+	if(!test_file_(is_ogg, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]P\tshrink APPLICATION, use padding, last block is padding\n");
+	if(0 == (app = FLAC__metadata_object_clone(our_metadata_.blocks[our_current_position])))
+		return die_("copying object");
+	if(!FLAC__metadata_object_application_set_data(app, data, 16, true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	our_metadata_.blocks[our_current_position+1]->length = 13;
+	if(!FLAC__metadata_iterator_set_block(iterator, app))
+		return die_c_("FLAC__metadata_iterator_set_block(iterator, app)", FLAC__metadata_chain_status(chain));
+
+	if(!write_chain_(chain, /*use_padding=*/true, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
+		return die_c_("during FLAC__metadata_chain_write(chain, true, false)", FLAC__metadata_chain_status(chain));
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+	if(!test_file_(is_ogg, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]P\tgrow APPLICATION, use padding, last block is padding, but delta is too small\n");
+	if(0 == (app = FLAC__metadata_object_clone(our_metadata_.blocks[our_current_position])))
+		return die_("copying object");
+	if(!FLAC__metadata_object_application_set_data(app, data, 50, true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	if(!FLAC__metadata_iterator_set_block(iterator, app))
+		return die_c_("FLAC__metadata_iterator_set_block(iterator, app)", FLAC__metadata_chain_status(chain));
+
+	if(!write_chain_(chain, /*use_padding=*/true, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
+		return die_c_("during FLAC__metadata_chain_write(chain, true, false)", FLAC__metadata_chain_status(chain));
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+	if(!test_file_(is_ogg, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]P\tgrow APPLICATION, use padding, last block is padding of exceeding size\n");
+	if(0 == (app = FLAC__metadata_object_clone(our_metadata_.blocks[our_current_position])))
+		return die_("copying object");
+	if(!FLAC__metadata_object_application_set_data(app, data, 56, true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	our_metadata_.blocks[our_current_position+1]->length -= (56 - 50);
+	if(!FLAC__metadata_iterator_set_block(iterator, app))
+		return die_c_("FLAC__metadata_iterator_set_block(iterator, app)", FLAC__metadata_chain_status(chain));
+
+	if(!write_chain_(chain, /*use_padding=*/true, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
+		return die_c_("during FLAC__metadata_chain_write(chain, true, false)", FLAC__metadata_chain_status(chain));
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+	if(!test_file_(is_ogg, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]P\tgrow APPLICATION, use padding, last block is padding of exact size\n");
+	if(0 == (app = FLAC__metadata_object_clone(our_metadata_.blocks[our_current_position])))
+		return die_("copying object");
+	if(!FLAC__metadata_object_application_set_data(app, data, 67, true))
+		return die_("setting APPLICATION data");
+	if(!replace_in_our_metadata_(app, our_current_position, /*copy=*/true))
+		return die_("copying object");
+	delete_from_our_metadata_(our_current_position+1);
+	if(!FLAC__metadata_iterator_set_block(iterator, app))
+		return die_c_("FLAC__metadata_iterator_set_block(iterator, app)", FLAC__metadata_chain_status(chain));
+
+	if(!write_chain_(chain, /*use_padding=*/true, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
+		return die_c_("during FLAC__metadata_chain_write(chain, true, false)", FLAC__metadata_chain_status(chain));
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+	if(!test_file_(is_ogg, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV[A]\tprev\n");
+	if(!FLAC__metadata_iterator_prev(iterator))
+		return die_("iterator ended early\n");
+	our_current_position--;
+
+	printf("S[V]A\tprev\n");
+	if(!FLAC__metadata_iterator_prev(iterator))
+		return die_("iterator ended early\n");
+	our_current_position--;
+
+	printf("[S]VA\tinsert PADDING before STREAMINFO (should fail)\n");
+	if(0 == (padding = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING)))
+		return die_("creating PADDING block");
+	padding->length = 30;
+	if(!FLAC__metadata_iterator_insert_block_before(iterator, padding))
+		printf("\tFLAC__metadata_iterator_insert_block_before() returned false like it should\n");
+	else
+		return die_("FLAC__metadata_iterator_insert_block_before() should have returned false");
+
+	printf("[S]VP\tnext\n");
+	if(!FLAC__metadata_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("S[V]A\tinsert PADDING after\n");
+	if(!insert_to_our_metadata_(padding, ++our_current_position, /*copy=*/true))
+		return die_("copying metadata");
+	if(!FLAC__metadata_iterator_insert_block_after(iterator, padding))
+		return die_("FLAC__metadata_iterator_insert_block_after(iterator, padding)");
+
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+
+	printf("SV[P]A\tinsert PADDING before\n");
+	if(0 == (padding = FLAC__metadata_object_clone(our_metadata_.blocks[our_current_position])))
+		return die_("creating PADDING block");
+	padding->length = 17;
+	if(!insert_to_our_metadata_(padding, our_current_position, /*copy=*/true))
+		return die_("copying metadata");
+	if(!FLAC__metadata_iterator_insert_block_before(iterator, padding))
+		return die_("FLAC__metadata_iterator_insert_block_before(iterator, padding)");
+
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+
+	printf("SV[P]PA\tinsert PADDING before\n");
+	if(0 == (padding = FLAC__metadata_object_clone(our_metadata_.blocks[our_current_position])))
+		return die_("creating PADDING block");
+	padding->length = 0;
+	if(!insert_to_our_metadata_(padding, our_current_position, /*copy=*/true))
+		return die_("copying metadata");
+	if(!FLAC__metadata_iterator_insert_block_before(iterator, padding))
+		return die_("FLAC__metadata_iterator_insert_block_before(iterator, padding)");
+
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+
+	printf("SV[P]PPA\tnext\n");
+	if(!FLAC__metadata_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SVP[P]PA\tnext\n");
+	if(!FLAC__metadata_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SVPP[P]A\tnext\n");
+	if(!FLAC__metadata_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SVPPP[A]\tinsert PADDING after\n");
+	if(0 == (padding = FLAC__metadata_object_clone(our_metadata_.blocks[2])))
+		return die_("creating PADDING block");
+	padding->length = 57;
+	if(!insert_to_our_metadata_(padding, ++our_current_position, /*copy=*/true))
+		return die_("copying metadata");
+	if(!FLAC__metadata_iterator_insert_block_after(iterator, padding))
+		return die_("FLAC__metadata_iterator_insert_block_after(iterator, padding)");
+
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+
+	printf("SVPPPA[P]\tinsert PADDING before\n");
+	if(0 == (padding = FLAC__metadata_object_clone(our_metadata_.blocks[2])))
+		return die_("creating PADDING block");
+	padding->length = 99;
+	if(!insert_to_our_metadata_(padding, our_current_position, /*copy=*/true))
+		return die_("copying metadata");
+	if(!FLAC__metadata_iterator_insert_block_before(iterator, padding))
+		return die_("FLAC__metadata_iterator_insert_block_before(iterator, padding)");
+
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+
+	printf("delete iterator\n");
+	FLAC__metadata_iterator_delete(iterator);
+	our_current_position = 0;
+
+	printf("SVPPPAPP\tmerge padding\n");
+	FLAC__metadata_chain_merge_padding(chain);
+	our_metadata_.blocks[2]->length += (FLAC__STREAM_METADATA_HEADER_LENGTH + our_metadata_.blocks[3]->length);
+	our_metadata_.blocks[2]->length += (FLAC__STREAM_METADATA_HEADER_LENGTH + our_metadata_.blocks[4]->length);
+	our_metadata_.blocks[6]->length += (FLAC__STREAM_METADATA_HEADER_LENGTH + our_metadata_.blocks[7]->length);
+	delete_from_our_metadata_(7);
+	delete_from_our_metadata_(4);
+	delete_from_our_metadata_(3);
+
+	if(!write_chain_(chain, /*use_padding=*/true, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
+		return die_c_("during FLAC__metadata_chain_write(chain, true, false)", FLAC__metadata_chain_status(chain));
+	if(!compare_chain_(chain, 0, 0))
+		return false;
+	if(!test_file_(is_ogg, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SVPAP\tsort padding\n");
+	FLAC__metadata_chain_sort_padding(chain);
+	our_metadata_.blocks[4]->length += (FLAC__STREAM_METADATA_HEADER_LENGTH + our_metadata_.blocks[2]->length);
+	delete_from_our_metadata_(2);
+
+	if(!write_chain_(chain, /*use_padding=*/true, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
+		return die_c_("during FLAC__metadata_chain_write(chain, true, false)", FLAC__metadata_chain_status(chain));
+	if(!compare_chain_(chain, 0, 0))
+		return false;
+	if(!test_file_(is_ogg, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("create iterator\n");
+	if(0 == (iterator = FLAC__metadata_iterator_new()))
+		return die_("allocating memory for iterator");
+
+	our_current_position = 0;
+
+	FLAC__metadata_iterator_init(iterator, chain);
+
+	printf("[S]VAP\tnext\n");
+	if(!FLAC__metadata_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("S[V]AP\tnext\n");
+	if(!FLAC__metadata_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SV[A]P\tdelete middle block, replace with padding\n");
+	if(0 == (padding = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING)))
+		return die_("creating PADDING block");
+	padding->length = 71;
+	if(!replace_in_our_metadata_(padding, our_current_position--, /*copy=*/false))
+		return die_("copying object");
+	if(!FLAC__metadata_iterator_delete_block(iterator, /*replace_with_padding=*/true))
+		return die_c_("FLAC__metadata_iterator_delete_block(iterator, true)", FLAC__metadata_chain_status(chain));
+
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+
+	printf("S[V]PP\tnext\n");
+	if(!FLAC__metadata_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SV[P]P\tdelete middle block, don't replace with padding\n");
+	delete_from_our_metadata_(our_current_position--);
+	if(!FLAC__metadata_iterator_delete_block(iterator, /*replace_with_padding=*/false))
+		return die_c_("FLAC__metadata_iterator_delete_block(iterator, false)", FLAC__metadata_chain_status(chain));
+
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+
+	printf("S[V]P\tnext\n");
+	if(!FLAC__metadata_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SV[P]\tdelete last block, replace with padding\n");
+	if(0 == (padding = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING)))
+		return die_("creating PADDING block");
+	padding->length = 219;
+	if(!replace_in_our_metadata_(padding, our_current_position--, /*copy=*/false))
+		return die_("copying object");
+	if(!FLAC__metadata_iterator_delete_block(iterator, /*replace_with_padding=*/true))
+		return die_c_("FLAC__metadata_iterator_delete_block(iterator, true)", FLAC__metadata_chain_status(chain));
+
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+
+	printf("S[V]P\tnext\n");
+	if(!FLAC__metadata_iterator_next(iterator))
+		return die_("iterator ended early\n");
+	our_current_position++;
+
+	printf("SV[P]\tdelete last block, don't replace with padding\n");
+	delete_from_our_metadata_(our_current_position--);
+	if(!FLAC__metadata_iterator_delete_block(iterator, /*replace_with_padding=*/false))
+		return die_c_("FLAC__metadata_iterator_delete_block(iterator, false)", FLAC__metadata_chain_status(chain));
+
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+
+	printf("S[V]\tprev\n");
+	if(!FLAC__metadata_iterator_prev(iterator))
+		return die_("iterator ended early\n");
+	our_current_position--;
+
+	printf("[S]V\tdelete STREAMINFO block, should fail\n");
+	if(FLAC__metadata_iterator_delete_block(iterator, /*replace_with_padding=*/false))
+		return die_("FLAC__metadata_iterator_delete_block() on STREAMINFO should have failed but didn't");
+
+	if(!compare_chain_(chain, our_current_position, FLAC__metadata_iterator_get_block(iterator)))
+		return false;
+
+	printf("delete iterator\n");
+	FLAC__metadata_iterator_delete(iterator);
+	our_current_position = 0;
+
+	printf("SV\tmerge padding\n");
+	FLAC__metadata_chain_merge_padding(chain);
+
+	if(!write_chain_(chain, /*use_padding=*/false, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
+		return die_c_("during FLAC__metadata_chain_write(chain, false, false)", FLAC__metadata_chain_status(chain));
+	if(!compare_chain_(chain, 0, 0))
+		return false;
+	if(!test_file_(is_ogg, decoder_metadata_callback_compare_))
+		return false;
+
+	printf("SV\tsort padding\n");
+	FLAC__metadata_chain_sort_padding(chain);
+
+	if(!write_chain_(chain, /*use_padding=*/false, /*preserve_file_stats=*/false, filename_based, flacfilename(is_ogg)))
+		return die_c_("during FLAC__metadata_chain_write(chain, false, false)", FLAC__metadata_chain_status(chain));
+	if(!compare_chain_(chain, 0, 0))
+		return false;
+	if(!test_file_(is_ogg, decoder_metadata_callback_compare_))
+		return false;
+
+end:
+	printf("delete chain\n");
+
+	FLAC__metadata_chain_delete(chain);
+
+	if(!remove_file_(flacfilename(is_ogg)))
+		return false;
+
+	return true;
+}
+
+static FLAC__bool test_level_2_misc_(FLAC__bool is_ogg)
+{
+	FLAC__Metadata_Iterator *iterator;
+	FLAC__Metadata_Chain *chain;
+	FLAC__IOCallbacks callbacks;
+
+	memset(&callbacks, 0, sizeof(callbacks));
+	callbacks.read = (FLAC__IOCallback_Read)fread;
+#ifdef FLAC__VALGRIND_TESTING
+	callbacks.write = chain_write_cb_;
+#else
+	callbacks.write = (FLAC__IOCallback_Write)fwrite;
+#endif
+	callbacks.seek = chain_seek_cb_;
+	callbacks.tell = chain_tell_cb_;
+	callbacks.eof = chain_eof_cb_;
+
+	printf("\n\n++++++ testing level 2 interface (mismatched read/write protections)\n");
+
+	printf("generate file\n");
+
+	if(!generate_file_(/*include_extras=*/false, is_ogg))
+		return false;
+
+	printf("create chain\n");
+
+	if(0 == (chain = FLAC__metadata_chain_new()))
+		return die_("allocating chain");
+
+	printf("read chain (filename-based)\n");
+
+	if(!FLAC__metadata_chain_read(chain, flacfilename(is_ogg)))
+		return die_c_("reading chain", FLAC__metadata_chain_status(chain));
+
+	printf("write chain with wrong method FLAC__metadata_chain_write_with_callbacks()\n");
+	{
+		if(FLAC__metadata_chain_write_with_callbacks(chain, /*use_padding=*/false, 0, callbacks))
+			return die_c_("mismatched write should have failed", FLAC__metadata_chain_status(chain));
+		if(FLAC__metadata_chain_status(chain) != FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH)
+			return die_c_("expected FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH", FLAC__metadata_chain_status(chain));
+		printf("  OK: FLAC__metadata_chain_write_with_callbacks() returned false,FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH like it should\n");
+	}
+
+	printf("read chain (filename-based)\n");
+
+	if(!FLAC__metadata_chain_read(chain, flacfilename(is_ogg)))
+		return die_c_("reading chain", FLAC__metadata_chain_status(chain));
+
+	printf("write chain with wrong method FLAC__metadata_chain_write_with_callbacks_and_tempfile()\n");
+	{
+		if(FLAC__metadata_chain_write_with_callbacks_and_tempfile(chain, /*use_padding=*/false, 0, callbacks, 0, callbacks))
+			return die_c_("mismatched write should have failed", FLAC__metadata_chain_status(chain));
+		if(FLAC__metadata_chain_status(chain) != FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH)
+			return die_c_("expected FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH", FLAC__metadata_chain_status(chain));
+		printf("  OK: FLAC__metadata_chain_write_with_callbacks_and_tempfile() returned false,FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH like it should\n");
+	}
+
+	printf("read chain (callback-based)\n");
+	{
+		FILE *file = fopen(flacfilename(is_ogg), "rb");
+		if(0 == file)
+			return die_("opening file");
+		if(!FLAC__metadata_chain_read_with_callbacks(chain, (FLAC__IOHandle)file, callbacks)) {
+			fclose(file);
+			return die_c_("reading chain", FLAC__metadata_chain_status(chain));
+		}
+		fclose(file);
+	}
+
+	printf("write chain with wrong method FLAC__metadata_chain_write()\n");
+	{
+		if(FLAC__metadata_chain_write(chain, /*use_padding=*/false, /*preserve_file_stats=*/false))
+			return die_c_("mismatched write should have failed", FLAC__metadata_chain_status(chain));
+		if(FLAC__metadata_chain_status(chain) != FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH)
+			return die_c_("expected FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH", FLAC__metadata_chain_status(chain));
+		printf("  OK: FLAC__metadata_chain_write() returned false,FLAC__METADATA_CHAIN_STATUS_READ_WRITE_MISMATCH like it should\n");
+	}
+
+	printf("read chain (callback-based)\n");
+	{
+		FILE *file = fopen(flacfilename(is_ogg), "rb");
+		if(0 == file)
+			return die_("opening file");
+		if(!FLAC__metadata_chain_read_with_callbacks(chain, (FLAC__IOHandle)file, callbacks)) {
+			fclose(file);
+			return die_c_("reading chain", FLAC__metadata_chain_status(chain));
+		}
+		fclose(file);
+	}
+
+	printf("testing FLAC__metadata_chain_check_if_tempfile_needed()... ");
+
+	if(!FLAC__metadata_chain_check_if_tempfile_needed(chain, /*use_padding=*/false))
+		printf("OK: FLAC__metadata_chain_check_if_tempfile_needed() returned false like it should\n");
+	else
+		return die_("FLAC__metadata_chain_check_if_tempfile_needed() returned true but shouldn't have");
+
+	printf("write chain with wrong method FLAC__metadata_chain_write_with_callbacks_and_tempfile()\n");
+	{
+		if(FLAC__metadata_chain_write_with_callbacks_and_tempfile(chain, /*use_padding=*/false, 0, callbacks, 0, callbacks))
+			return die_c_("mismatched write should have failed", FLAC__metadata_chain_status(chain));
+		if(FLAC__metadata_chain_status(chain) != FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL)
+			return die_c_("expected FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL", FLAC__metadata_chain_status(chain));
+		printf("  OK: FLAC__metadata_chain_write_with_callbacks_and_tempfile() returned false,FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL like it should\n");
+	}
+
+	printf("read chain (callback-based)\n");
+	{
+		FILE *file = fopen(flacfilename(is_ogg), "rb");
+		if(0 == file)
+			return die_("opening file");
+		if(!FLAC__metadata_chain_read_with_callbacks(chain, (FLAC__IOHandle)file, callbacks)) {
+			fclose(file);
+			return die_c_("reading chain", FLAC__metadata_chain_status(chain));
+		}
+		fclose(file);
+	}
+
+	printf("create iterator\n");
+	if(0 == (iterator = FLAC__metadata_iterator_new()))
+		return die_("allocating memory for iterator");
+
+	FLAC__metadata_iterator_init(iterator, chain);
+
+	printf("[S]VP\tnext\n");
+	if(!FLAC__metadata_iterator_next(iterator))
+		return die_("iterator ended early\n");
+
+	printf("S[V]P\tdelete VORBIS_COMMENT, write\n");
+	if(!FLAC__metadata_iterator_delete_block(iterator, /*replace_with_padding=*/false))
+		return die_c_("block delete failed\n", FLAC__metadata_chain_status(chain));
+
+	printf("testing FLAC__metadata_chain_check_if_tempfile_needed()... ");
+
+	if(FLAC__metadata_chain_check_if_tempfile_needed(chain, /*use_padding=*/false))
+		printf("OK: FLAC__metadata_chain_check_if_tempfile_needed() returned true like it should\n");
+	else
+		return die_("FLAC__metadata_chain_check_if_tempfile_needed() returned false but shouldn't have");
+
+	printf("write chain with wrong method FLAC__metadata_chain_write_with_callbacks()\n");
+	{
+		if(FLAC__metadata_chain_write_with_callbacks(chain, /*use_padding=*/false, 0, callbacks))
+			return die_c_("mismatched write should have failed", FLAC__metadata_chain_status(chain));
+		if(FLAC__metadata_chain_status(chain) != FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL)
+			return die_c_("expected FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL", FLAC__metadata_chain_status(chain));
+		printf("  OK: FLAC__metadata_chain_write_with_callbacks() returned false,FLAC__METADATA_CHAIN_STATUS_WRONG_WRITE_CALL like it should\n");
+	}
+
+	printf("delete iterator\n");
+
+	FLAC__metadata_iterator_delete(iterator);
+
+	printf("delete chain\n");
+
+	FLAC__metadata_chain_delete(chain);
+
+	if(!remove_file_(flacfilename(is_ogg)))
+		return false;
+
+	return true;
+}
+
+FLAC__bool test_metadata_file_manipulation(void)
+{
+	printf("\n+++ libFLAC unit test: metadata manipulation\n\n");
+
+	our_metadata_.num_blocks = 0;
+
+	if(!test_level_0_())
+		return false;
+
+	if(!test_level_1_())
+		return false;
+
+	if(!test_level_2_(/*filename_based=*/true, /*is_ogg=*/false)) /* filename-based */
+		return false;
+	if(!test_level_2_(/*filename_based=*/false, /*is_ogg=*/false)) /* callback-based */
+		return false;
+	if(!test_level_2_misc_(/*is_ogg=*/false))
+		return false;
+
+	if(FLAC_API_SUPPORTS_OGG_FLAC) {
+		if(!test_level_2_(/*filename_based=*/true, /*is_ogg=*/true)) /* filename-based */
+			return false;
+		if(!test_level_2_(/*filename_based=*/false, /*is_ogg=*/true)) /* callback-based */
+			return false;
+#if 0
+		/* when ogg flac write is supported, will have to add this: */
+		if(!test_level_2_misc_(/*is_ogg=*/true))
+			return false;
+#endif
+	}
+
+	return true;
+}
diff --git a/audio-codec/flac/test_libFLAC/metadata_object.c b/audio-codec/flac/test_libFLAC/metadata_object.c
new file mode 100644
index 0000000..617248f
--- /dev/null
+++ b/audio-codec/flac/test_libFLAC/metadata_object.c
@@ -0,0 +1,2299 @@
+/* test_libFLAC - Unit tester for libFLAC
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * 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.
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "FLAC/assert.h"
+#include "FLAC/metadata.h"
+#include "test_libs_common/metadata_utils.h"
+#include "metadata.h"
+#include <stdio.h>
+#include <stdlib.h> /* for malloc() */
+#include <string.h> /* for memcmp() */
+
+static FLAC__byte *make_dummydata_(FLAC__byte *dummydata, unsigned len)
+{
+	FLAC__byte *ret;
+
+	if(0 == (ret = (FLAC__byte*)malloc(len))) {
+		printf("FAILED, malloc error\n");
+		exit(1);
+	}
+	else
+		memcpy(ret, dummydata, len);
+
+	return ret;
+}
+
+static FLAC__bool compare_track_(const FLAC__StreamMetadata_CueSheet_Track *from, const FLAC__StreamMetadata_CueSheet_Track *to)
+{
+	unsigned i;
+
+	if(from->offset != to->offset) {
+#ifdef _MSC_VER
+		printf("FAILED, track offset mismatch, expected %I64u, got %I64u\n", to->offset, from->offset);
+#else
+		printf("FAILED, track offset mismatch, expected %llu, got %llu\n", (unsigned long long)to->offset, (unsigned long long)from->offset);
+#endif
+		return false;
+	}
+	if(from->number != to->number) {
+		printf("FAILED, track number mismatch, expected %u, got %u\n", (unsigned)to->number, (unsigned)from->number);
+		return false;
+	}
+	if(0 != strcmp(from->isrc, to->isrc)) {
+		printf("FAILED, track number mismatch, expected %s, got %s\n", to->isrc, from->isrc);
+		return false;
+	}
+	if(from->type != to->type) {
+		printf("FAILED, track type mismatch, expected %u, got %u\n", (unsigned)to->type, (unsigned)from->type);
+		return false;
+	}
+	if(from->pre_emphasis != to->pre_emphasis) {
+		printf("FAILED, track pre_emphasis mismatch, expected %u, got %u\n", (unsigned)to->pre_emphasis, (unsigned)from->pre_emphasis);
+		return false;
+	}
+	if(from->num_indices != to->num_indices) {
+		printf("FAILED, track num_indices mismatch, expected %u, got %u\n", (unsigned)to->num_indices, (unsigned)from->num_indices);
+		return false;
+	}
+	if(0 == to->indices || 0 == from->indices) {
+		if(to->indices != from->indices) {
+			printf("FAILED, track indices mismatch\n");
+			return false;
+		}
+	}
+	else {
+		for(i = 0; i < to->num_indices; i++) {
+			if(from->indices[i].offset != to->indices[i].offset) {
+#ifdef _MSC_VER
+				printf("FAILED, track indices[%u].offset mismatch, expected %I64u, got %I64u\n", i, to->indices[i].offset, from->indices[i].offset);
+#else
+				printf("FAILED, track indices[%u].offset mismatch, expected %llu, got %llu\n", i, (unsigned long long)to->indices[i].offset, (unsigned long long)from->indices[i].offset);
+#endif
+				return false;
+			}
+			if(from->indices[i].number != to->indices[i].number) {
+				printf("FAILED, track indices[%u].number mismatch, expected %u, got %u\n", i, (unsigned)to->indices[i].number, (unsigned)from->indices[i].number);
+				return false;
+			}
+		}
+	}
+
+	return true;
+}
+
+static FLAC__bool compare_seekpoint_array_(const FLAC__StreamMetadata_SeekPoint *from, const FLAC__StreamMetadata_SeekPoint *to, unsigned n)
+{
+	unsigned i;
+
+	FLAC__ASSERT(0 != from);
+	FLAC__ASSERT(0 != to);
+
+	for(i = 0; i < n; i++) {
+		if(from[i].sample_number != to[i].sample_number) {
+#ifdef _MSC_VER
+			printf("FAILED, point[%u].sample_number mismatch, expected %I64u, got %I64u\n", i, to[i].sample_number, from[i].sample_number);
+#else
+			printf("FAILED, point[%u].sample_number mismatch, expected %llu, got %llu\n", i, (unsigned long long)to[i].sample_number, (unsigned long long)from[i].sample_number);
+#endif
+			return false;
+		}
+		if(from[i].stream_offset != to[i].stream_offset) {
+#ifdef _MSC_VER
+			printf("FAILED, point[%u].stream_offset mismatch, expected %I64u, got %I64u\n", i, to[i].stream_offset, from[i].stream_offset);
+#else
+			printf("FAILED, point[%u].stream_offset mismatch, expected %llu, got %llu\n", i, (unsigned long long)to[i].stream_offset, (unsigned long long)from[i].stream_offset);
+#endif
+			return false;
+		}
+		if(from[i].frame_samples != to[i].frame_samples) {
+			printf("FAILED, point[%u].frame_samples mismatch, expected %u, got %u\n", i, to[i].frame_samples, from[i].frame_samples);
+			return false;
+		}
+	}
+
+	return true;
+}
+
+static FLAC__bool check_seektable_(const FLAC__StreamMetadata *block, unsigned num_points, const FLAC__StreamMetadata_SeekPoint *array)
+{
+	const unsigned expected_length = num_points * FLAC__STREAM_METADATA_SEEKPOINT_LENGTH;
+
+	if(block->length != expected_length) {
+		printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
+		return false;
+	}
+	if(block->data.seek_table.num_points != num_points) {
+		printf("FAILED, expected %u point, got %u\n", num_points, block->data.seek_table.num_points);
+		return false;
+	}
+	if(0 == array) {
+		if(0 != block->data.seek_table.points) {
+			printf("FAILED, 'points' pointer is not null\n");
+			return false;
+		}
+	}
+	else {
+		if(!compare_seekpoint_array_(block->data.seek_table.points, array, num_points))
+			return false;
+	}
+	printf("OK\n");
+
+	return true;
+}
+
+static void entry_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, const char *field)
+{
+	entry->length = strlen(field);
+	entry->entry = (FLAC__byte*)malloc(entry->length+1);
+	FLAC__ASSERT(0 != entry->entry);
+	memcpy(entry->entry, field, entry->length);
+	entry->entry[entry->length] = '\0';
+}
+
+static void entry_clone_(FLAC__StreamMetadata_VorbisComment_Entry *entry)
+{
+	FLAC__byte *x = (FLAC__byte*)malloc(entry->length+1);
+	FLAC__ASSERT(0 != x);
+	memcpy(x, entry->entry, entry->length);
+	x[entry->length] = '\0';
+	entry->entry = x;
+}
+
+static void vc_calc_len_(FLAC__StreamMetadata *block)
+{
+	const FLAC__StreamMetadata_VorbisComment *vc = &block->data.vorbis_comment;
+	unsigned i;
+
+	block->length = FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8;
+	block->length += vc->vendor_string.length;
+	block->length += FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN / 8;
+	for(i = 0; i < vc->num_comments; i++) {
+		block->length += FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN / 8;
+		block->length += vc->comments[i].length;
+	}
+}
+
+static void vc_resize_(FLAC__StreamMetadata *block, unsigned num)
+{
+	FLAC__StreamMetadata_VorbisComment *vc = &block->data.vorbis_comment;
+
+	if(vc->num_comments != 0) {
+		FLAC__ASSERT(0 != vc->comments);
+		if(num < vc->num_comments) {
+			unsigned i;
+			for(i = num; i < vc->num_comments; i++) {
+				if(0 != vc->comments[i].entry)
+					free(vc->comments[i].entry);
+			}
+		}
+	}
+	if(num == 0) {
+		if(0 != vc->comments) {
+			free(vc->comments);
+			vc->comments = 0;
+		}
+	}
+	else {
+		vc->comments = (FLAC__StreamMetadata_VorbisComment_Entry*)realloc(vc->comments, sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*num);
+		FLAC__ASSERT(0 != vc->comments);
+		if(num > vc->num_comments)
+			memset(vc->comments+vc->num_comments, 0, sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*(num-vc->num_comments));
+	}
+
+	vc->num_comments = num;
+	vc_calc_len_(block);
+}
+
+static int vc_find_from_(FLAC__StreamMetadata *block, const char *name, unsigned start)
+{
+	const unsigned n = strlen(name);
+	unsigned i;
+	for(i = start; i < block->data.vorbis_comment.num_comments; i++) {
+		const FLAC__StreamMetadata_VorbisComment_Entry *entry = &block->data.vorbis_comment.comments[i];
+		if(entry->length > n && 0 == strncmp((const char *)entry->entry, name, n) && entry->entry[n] == '=')
+			return (int)i;
+	}
+	return -1;
+}
+
+static void vc_set_vs_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, const char *field)
+{
+	if(0 != block->data.vorbis_comment.vendor_string.entry)
+		free(block->data.vorbis_comment.vendor_string.entry);
+	entry_new_(entry, field);
+	block->data.vorbis_comment.vendor_string = *entry;
+	vc_calc_len_(block);
+}
+
+static void vc_set_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, unsigned pos, const char *field)
+{
+	if(0 != block->data.vorbis_comment.comments[pos].entry)
+		free(block->data.vorbis_comment.comments[pos].entry);
+	entry_new_(entry, field);
+	block->data.vorbis_comment.comments[pos] = *entry;
+	vc_calc_len_(block);
+}
+
+static void vc_insert_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, unsigned pos, const char *field)
+{
+	vc_resize_(block, block->data.vorbis_comment.num_comments+1);
+	memmove(&block->data.vorbis_comment.comments[pos+1], &block->data.vorbis_comment.comments[pos], sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*(block->data.vorbis_comment.num_comments-1-pos));
+	memset(&block->data.vorbis_comment.comments[pos], 0, sizeof(FLAC__StreamMetadata_VorbisComment_Entry));
+	vc_set_new_(entry, block, pos, field);
+	vc_calc_len_(block);
+}
+
+static void vc_delete_(FLAC__StreamMetadata *block, unsigned pos)
+{
+	if(0 != block->data.vorbis_comment.comments[pos].entry)
+		free(block->data.vorbis_comment.comments[pos].entry);
+	memmove(&block->data.vorbis_comment.comments[pos], &block->data.vorbis_comment.comments[pos+1], sizeof(FLAC__StreamMetadata_VorbisComment_Entry)*(block->data.vorbis_comment.num_comments-pos-1));
+	block->data.vorbis_comment.comments[block->data.vorbis_comment.num_comments-1].entry = 0;
+	block->data.vorbis_comment.comments[block->data.vorbis_comment.num_comments-1].length = 0;
+	vc_resize_(block, block->data.vorbis_comment.num_comments-1);
+	vc_calc_len_(block);
+}
+
+static void vc_replace_new_(FLAC__StreamMetadata_VorbisComment_Entry *entry, FLAC__StreamMetadata *block, const char *field, FLAC__bool all)
+{
+	int index;
+	char field_name[256];
+	const char *eq = strchr(field, '=');
+	FLAC__ASSERT(eq>field && (unsigned)(eq-field) < sizeof(field_name));
+	memcpy(field_name, field, eq-field);
+	field_name[eq-field]='\0';
+
+	index = vc_find_from_(block, field_name, 0);
+	if(index < 0)
+		vc_insert_new_(entry, block, block->data.vorbis_comment.num_comments, field);
+	else {
+		vc_set_new_(entry, block, (unsigned)index, field);
+		if(all) {
+			for(index = index+1; index >= 0 && (unsigned)index < block->data.vorbis_comment.num_comments; )
+				if((index = vc_find_from_(block, field_name, (unsigned)index)) >= 0)
+					vc_delete_(block, (unsigned)index);
+		}
+	}
+
+	vc_calc_len_(block);
+}
+
+static void track_new_(FLAC__StreamMetadata_CueSheet_Track *track, FLAC__uint64 offset, FLAC__byte number, const char *isrc, FLAC__bool data, FLAC__bool pre_em)
+{
+	track->offset = offset;
+	track->number = number;
+	memcpy(track->isrc, isrc, sizeof(track->isrc));
+	track->type = data;
+	track->pre_emphasis = pre_em;
+	track->num_indices = 0;
+	track->indices = 0;
+}
+
+static void track_clone_(FLAC__StreamMetadata_CueSheet_Track *track)
+{
+	if(track->num_indices > 0) {
+		size_t bytes = sizeof(FLAC__StreamMetadata_CueSheet_Index) * track->num_indices;
+		FLAC__StreamMetadata_CueSheet_Index *x = (FLAC__StreamMetadata_CueSheet_Index*)malloc(bytes);
+		FLAC__ASSERT(0 != x);
+		memcpy(x, track->indices, bytes);
+		track->indices = x;
+	}
+}
+
+static void cs_calc_len_(FLAC__StreamMetadata *block)
+{
+	const FLAC__StreamMetadata_CueSheet *cs = &block->data.cue_sheet;
+	unsigned i;
+
+	block->length = (
+		FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN +
+		FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN +
+		FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN +
+		FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN +
+		FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN
+	) / 8;
+	block->length += cs->num_tracks * (
+		FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN +
+		FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN +
+		FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN +
+		FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN +
+		FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN +
+		FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN +
+		FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN
+	) / 8;
+	for(i = 0; i < cs->num_tracks; i++) {
+		block->length += cs->tracks[i].num_indices * (
+			FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN +
+			FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN +
+			FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN
+		) / 8;
+	}
+}
+
+static void tr_resize_(FLAC__StreamMetadata *block, unsigned track_num, unsigned num)
+{
+	FLAC__StreamMetadata_CueSheet_Track *tr;
+
+	FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks);
+
+	tr = &block->data.cue_sheet.tracks[track_num];
+
+	if(tr->num_indices != 0) {
+		FLAC__ASSERT(0 != tr->indices);
+	}
+	if(num == 0) {
+		if(0 != tr->indices) {
+			free(tr->indices);
+			tr->indices = 0;
+		}
+	}
+	else {
+		tr->indices = (FLAC__StreamMetadata_CueSheet_Index*)realloc(tr->indices, sizeof(FLAC__StreamMetadata_CueSheet_Index)*num);
+		FLAC__ASSERT(0 != tr->indices);
+		if(num > tr->num_indices)
+			memset(tr->indices+tr->num_indices, 0, sizeof(FLAC__StreamMetadata_CueSheet_Index)*(num-tr->num_indices));
+	}
+
+	tr->num_indices = num;
+	cs_calc_len_(block);
+}
+
+static void tr_set_new_(FLAC__StreamMetadata *block, unsigned track_num, unsigned pos, FLAC__StreamMetadata_CueSheet_Index index)
+{
+	FLAC__StreamMetadata_CueSheet_Track *tr;
+
+	FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks);
+
+	tr = &block->data.cue_sheet.tracks[track_num];
+
+	FLAC__ASSERT(pos < tr->num_indices);
+
+	tr->indices[pos] = index;
+
+	cs_calc_len_(block);
+}
+
+static void tr_insert_new_(FLAC__StreamMetadata *block, unsigned track_num, unsigned pos, FLAC__StreamMetadata_CueSheet_Index index)
+{
+	FLAC__StreamMetadata_CueSheet_Track *tr;
+
+	FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks);
+
+	tr = &block->data.cue_sheet.tracks[track_num];
+
+	FLAC__ASSERT(pos <= tr->num_indices);
+
+	tr_resize_(block, track_num, tr->num_indices+1);
+	memmove(&tr->indices[pos+1], &tr->indices[pos], sizeof(FLAC__StreamMetadata_CueSheet_Index)*(tr->num_indices-1-pos));
+	tr_set_new_(block, track_num, pos, index);
+	cs_calc_len_(block);
+}
+
+static void tr_delete_(FLAC__StreamMetadata *block, unsigned track_num, unsigned pos)
+{
+	FLAC__StreamMetadata_CueSheet_Track *tr;
+
+	FLAC__ASSERT(track_num < block->data.cue_sheet.num_tracks);
+
+	tr = &block->data.cue_sheet.tracks[track_num];
+
+	FLAC__ASSERT(pos <= tr->num_indices);
+
+	memmove(&tr->indices[pos], &tr->indices[pos+1], sizeof(FLAC__StreamMetadata_CueSheet_Index)*(tr->num_indices-pos-1));
+	tr_resize_(block, track_num, tr->num_indices-1);
+	cs_calc_len_(block);
+}
+
+static void cs_resize_(FLAC__StreamMetadata *block, unsigned num)
+{
+	FLAC__StreamMetadata_CueSheet *cs = &block->data.cue_sheet;
+
+	if(cs->num_tracks != 0) {
+		FLAC__ASSERT(0 != cs->tracks);
+		if(num < cs->num_tracks) {
+			unsigned i;
+			for(i = num; i < cs->num_tracks; i++) {
+				if(0 != cs->tracks[i].indices)
+					free(cs->tracks[i].indices);
+			}
+		}
+	}
+	if(num == 0) {
+		if(0 != cs->tracks) {
+			free(cs->tracks);
+			cs->tracks = 0;
+		}
+	}
+	else {
+		cs->tracks = (FLAC__StreamMetadata_CueSheet_Track*)realloc(cs->tracks, sizeof(FLAC__StreamMetadata_CueSheet_Track)*num);
+		FLAC__ASSERT(0 != cs->tracks);
+		if(num > cs->num_tracks)
+			memset(cs->tracks+cs->num_tracks, 0, sizeof(FLAC__StreamMetadata_CueSheet_Track)*(num-cs->num_tracks));
+	}
+
+	cs->num_tracks = num;
+	cs_calc_len_(block);
+}
+
+static void cs_set_new_(FLAC__StreamMetadata_CueSheet_Track *track, FLAC__StreamMetadata *block, unsigned pos, FLAC__uint64 offset, FLAC__byte number, const char *isrc, FLAC__bool data, FLAC__bool pre_em)
+{
+	track_new_(track, offset, number, isrc, data, pre_em);
+	block->data.cue_sheet.tracks[pos] = *track;
+	cs_calc_len_(block);
+}
+
+static void cs_insert_new_(FLAC__StreamMetadata_CueSheet_Track *track, FLAC__StreamMetadata *block, unsigned pos, FLAC__uint64 offset, FLAC__byte number, const char *isrc, FLAC__bool data, FLAC__bool pre_em)
+{
+	cs_resize_(block, block->data.cue_sheet.num_tracks+1);
+	memmove(&block->data.cue_sheet.tracks[pos+1], &block->data.cue_sheet.tracks[pos], sizeof(FLAC__StreamMetadata_CueSheet_Track)*(block->data.cue_sheet.num_tracks-1-pos));
+	cs_set_new_(track, block, pos, offset, number, isrc, data, pre_em);
+	cs_calc_len_(block);
+}
+
+static void cs_delete_(FLAC__StreamMetadata *block, unsigned pos)
+{
+	if(0 != block->data.cue_sheet.tracks[pos].indices)
+		free(block->data.cue_sheet.tracks[pos].indices);
+	memmove(&block->data.cue_sheet.tracks[pos], &block->data.cue_sheet.tracks[pos+1], sizeof(FLAC__StreamMetadata_CueSheet_Track)*(block->data.cue_sheet.num_tracks-pos-1));
+	block->data.cue_sheet.tracks[block->data.cue_sheet.num_tracks-1].indices = 0;
+	block->data.cue_sheet.tracks[block->data.cue_sheet.num_tracks-1].num_indices = 0;
+	cs_resize_(block, block->data.cue_sheet.num_tracks-1);
+	cs_calc_len_(block);
+}
+
+static void pi_set_mime_type(FLAC__StreamMetadata *block, const char *s)
+{
+	if(block->data.picture.mime_type) {
+		block->length -= strlen(block->data.picture.mime_type);
+		free(block->data.picture.mime_type);
+	}
+	block->data.picture.mime_type = strdup(s);
+	FLAC__ASSERT(block->data.picture.mime_type);
+	block->length += strlen(block->data.picture.mime_type);
+}
+
+static void pi_set_description(FLAC__StreamMetadata *block, const FLAC__byte *s)
+{
+	if(block->data.picture.description) {
+		block->length -= strlen((const char *)block->data.picture.description);
+		free(block->data.picture.description);
+	}
+	block->data.picture.description = (FLAC__byte*)strdup((const char *)s);
+	FLAC__ASSERT(block->data.picture.description);
+	block->length += strlen((const char *)block->data.picture.description);
+}
+
+static void pi_set_data(FLAC__StreamMetadata *block, const FLAC__byte *data, FLAC__uint32 len)
+{
+	if(block->data.picture.data) {
+		block->length -= block->data.picture.data_length;
+		free(block->data.picture.data);
+	}
+	block->data.picture.data = (FLAC__byte*)strdup((const char *)data);
+	FLAC__ASSERT(block->data.picture.data);
+	block->data.picture.data_length = len;
+	block->length += len;
+}
+
+FLAC__bool test_metadata_object(void)
+{
+	FLAC__StreamMetadata *block, *blockcopy, *vorbiscomment, *cuesheet, *picture;
+	FLAC__StreamMetadata_SeekPoint seekpoint_array[14];
+	FLAC__StreamMetadata_VorbisComment_Entry entry;
+	FLAC__StreamMetadata_CueSheet_Index index;
+	FLAC__StreamMetadata_CueSheet_Track track;
+	unsigned i, expected_length, seekpoints;
+	int j;
+	static FLAC__byte dummydata[4] = { 'a', 'b', 'c', 'd' };
+
+	printf("\n+++ libFLAC unit test: metadata objects\n\n");
+
+
+	printf("testing STREAMINFO\n");
+
+	printf("testing FLAC__metadata_object_new()... ");
+	block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_STREAMINFO);
+	if(0 == block) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	expected_length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
+	if(block->length != expected_length) {
+		printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_clone()... ");
+	blockcopy = FLAC__metadata_object_clone(block);
+	if(0 == blockcopy) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!mutils__compare_block(block, blockcopy))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(blockcopy);
+	FLAC__metadata_object_delete(block);
+	printf("OK\n");
+
+
+	printf("testing PADDING\n");
+
+	printf("testing FLAC__metadata_object_new()... ");
+	block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING);
+	if(0 == block) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	expected_length = 0;
+	if(block->length != expected_length) {
+		printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_clone()... ");
+	blockcopy = FLAC__metadata_object_clone(block);
+	if(0 == blockcopy) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!mutils__compare_block(block, blockcopy))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(blockcopy);
+	FLAC__metadata_object_delete(block);
+	printf("OK\n");
+
+
+	printf("testing APPLICATION\n");
+
+	printf("testing FLAC__metadata_object_new()... ");
+	block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_APPLICATION);
+	if(0 == block) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	expected_length = FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8;
+	if(block->length != expected_length) {
+		printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_clone()... ");
+	blockcopy = FLAC__metadata_object_clone(block);
+	if(0 == blockcopy) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!mutils__compare_block(block, blockcopy))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(blockcopy);
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_application_set_data(copy)... ");
+	if(!FLAC__metadata_object_application_set_data(block, dummydata, sizeof(dummydata), true/*copy*/)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	expected_length = (FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8) + sizeof(dummydata);
+	if(block->length != expected_length) {
+		printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
+		return false;
+	}
+	if(0 != memcmp(block->data.application.data, dummydata, sizeof(dummydata))) {
+		printf("FAILED, data mismatch\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_clone()... ");
+	blockcopy = FLAC__metadata_object_clone(block);
+	if(0 == blockcopy) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!mutils__compare_block(block, blockcopy))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(blockcopy);
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_application_set_data(own)... ");
+	if(!FLAC__metadata_object_application_set_data(block, make_dummydata_(dummydata, sizeof(dummydata)), sizeof(dummydata), false/*own*/)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	expected_length = (FLAC__STREAM_METADATA_APPLICATION_ID_LEN / 8) + sizeof(dummydata);
+	if(block->length != expected_length) {
+		printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
+		return false;
+	}
+	if(0 != memcmp(block->data.application.data, dummydata, sizeof(dummydata))) {
+		printf("FAILED, data mismatch\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_clone()... ");
+	blockcopy = FLAC__metadata_object_clone(block);
+	if(0 == blockcopy) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!mutils__compare_block(block, blockcopy))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(blockcopy);
+	FLAC__metadata_object_delete(block);
+	printf("OK\n");
+
+
+	printf("testing SEEKTABLE\n");
+
+	for(i = 0; i < sizeof(seekpoint_array) / sizeof(FLAC__StreamMetadata_SeekPoint); i++) {
+		seekpoint_array[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
+		seekpoint_array[i].stream_offset = 0;
+		seekpoint_array[i].frame_samples = 0;
+	}
+
+	seekpoints = 0;
+	printf("testing FLAC__metadata_object_new()... ");
+	block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE);
+	if(0 == block) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, 0))
+		return false;
+
+	printf("testing FLAC__metadata_object_clone()... ");
+	blockcopy = FLAC__metadata_object_clone(block);
+	if(0 == blockcopy) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!mutils__compare_block(block, blockcopy))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(blockcopy);
+	printf("OK\n");
+
+	seekpoints = 2;
+	printf("testing FLAC__metadata_object_seektable_resize_points(grow to %u)...", seekpoints);
+	if(!FLAC__metadata_object_seektable_resize_points(block, seekpoints)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, seekpoint_array))
+		return false;
+
+	seekpoints = 1;
+	printf("testing FLAC__metadata_object_seektable_resize_points(shrink to %u)...", seekpoints);
+	if(!FLAC__metadata_object_seektable_resize_points(block, seekpoints)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, seekpoint_array))
+		return false;
+
+	printf("testing FLAC__metadata_object_seektable_is_legal()...");
+	if(!FLAC__metadata_object_seektable_is_legal(block)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	printf("OK\n");
+
+	seekpoints = 0;
+	printf("testing FLAC__metadata_object_seektable_resize_points(shrink to %u)...", seekpoints);
+	if(!FLAC__metadata_object_seektable_resize_points(block, seekpoints)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, 0))
+		return false;
+
+	seekpoints++;
+	printf("testing FLAC__metadata_object_seektable_insert_point() on empty array...");
+	if(!FLAC__metadata_object_seektable_insert_point(block, 0, seekpoint_array[0])) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, seekpoint_array))
+		return false;
+
+	seekpoint_array[0].sample_number = 1;
+	seekpoints++;
+	printf("testing FLAC__metadata_object_seektable_insert_point() on beginning of non-empty array...");
+	if(!FLAC__metadata_object_seektable_insert_point(block, 0, seekpoint_array[0])) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, seekpoint_array))
+		return false;
+
+	seekpoint_array[1].sample_number = 2;
+	seekpoints++;
+	printf("testing FLAC__metadata_object_seektable_insert_point() on middle of non-empty array...");
+	if(!FLAC__metadata_object_seektable_insert_point(block, 1, seekpoint_array[1])) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, seekpoint_array))
+		return false;
+
+	seekpoint_array[3].sample_number = 3;
+	seekpoints++;
+	printf("testing FLAC__metadata_object_seektable_insert_point() on end of non-empty array...");
+	if(!FLAC__metadata_object_seektable_insert_point(block, 3, seekpoint_array[3])) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, seekpoint_array))
+		return false;
+
+	printf("testing FLAC__metadata_object_clone()... ");
+	blockcopy = FLAC__metadata_object_clone(block);
+	if(0 == blockcopy) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!mutils__compare_block(block, blockcopy))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(blockcopy);
+	printf("OK\n");
+
+	seekpoint_array[2].sample_number = seekpoint_array[3].sample_number;
+	seekpoints--;
+	printf("testing FLAC__metadata_object_seektable_delete_point() on middle of array...");
+	if(!FLAC__metadata_object_seektable_delete_point(block, 2)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, seekpoint_array))
+		return false;
+
+	seekpoints--;
+	printf("testing FLAC__metadata_object_seektable_delete_point() on end of array...");
+	if(!FLAC__metadata_object_seektable_delete_point(block, 2)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, seekpoint_array))
+		return false;
+
+	seekpoints--;
+	printf("testing FLAC__metadata_object_seektable_delete_point() on beginning of array...");
+	if(!FLAC__metadata_object_seektable_delete_point(block, 0)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, seekpoint_array+1))
+		return false;
+
+	printf("testing FLAC__metadata_object_seektable_set_point()...");
+	FLAC__metadata_object_seektable_set_point(block, 0, seekpoint_array[0]);
+	if(!check_seektable_(block, seekpoints, seekpoint_array))
+		return false;
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(block);
+	printf("OK\n");
+
+	/* seektable template functions */
+
+	for(i = 0; i < sizeof(seekpoint_array) / sizeof(FLAC__StreamMetadata_SeekPoint); i++) {
+		seekpoint_array[i].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
+		seekpoint_array[i].stream_offset = 0;
+		seekpoint_array[i].frame_samples = 0;
+	}
+
+	seekpoints = 0;
+	printf("testing FLAC__metadata_object_new()... ");
+	block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE);
+	if(0 == block) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, 0))
+		return false;
+
+	seekpoints += 2;
+	printf("testing FLAC__metadata_object_seekpoint_template_append_placeholders()... ");
+	if(!FLAC__metadata_object_seektable_template_append_placeholders(block, 2)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, seekpoint_array))
+		return false;
+
+	seekpoint_array[seekpoints++].sample_number = 7;
+	printf("testing FLAC__metadata_object_seekpoint_template_append_point()... ");
+	if(!FLAC__metadata_object_seektable_template_append_point(block, 7)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, seekpoint_array))
+		return false;
+
+	{
+		FLAC__uint64 nums[2] = { 3, 7 };
+		seekpoint_array[seekpoints++].sample_number = nums[0];
+		seekpoint_array[seekpoints++].sample_number = nums[1];
+		printf("testing FLAC__metadata_object_seekpoint_template_append_points()... ");
+		if(!FLAC__metadata_object_seektable_template_append_points(block, nums, sizeof(nums)/sizeof(FLAC__uint64))) {
+			printf("FAILED, returned false\n");
+			return false;
+		}
+		if(!check_seektable_(block, seekpoints, seekpoint_array))
+			return false;
+	}
+
+	seekpoint_array[seekpoints++].sample_number = 0;
+	seekpoint_array[seekpoints++].sample_number = 10;
+	seekpoint_array[seekpoints++].sample_number = 20;
+	printf("testing FLAC__metadata_object_seekpoint_template_append_spaced_points()... ");
+	if(!FLAC__metadata_object_seektable_template_append_spaced_points(block, 3, 30)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, seekpoint_array))
+		return false;
+
+	seekpoints--;
+	seekpoint_array[0].sample_number = 0;
+	seekpoint_array[1].sample_number = 3;
+	seekpoint_array[2].sample_number = 7;
+	seekpoint_array[3].sample_number = 10;
+	seekpoint_array[4].sample_number = 20;
+	seekpoint_array[5].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
+	seekpoint_array[6].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
+	printf("testing FLAC__metadata_object_seekpoint_template_sort(compact=true)... ");
+	if(!FLAC__metadata_object_seektable_template_sort(block, /*compact=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!FLAC__metadata_object_seektable_is_legal(block)) {
+		printf("FAILED, seek table is illegal\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, seekpoint_array))
+		return false;
+
+	printf("testing FLAC__metadata_object_seekpoint_template_sort(compact=false)... ");
+	if(!FLAC__metadata_object_seektable_template_sort(block, /*compact=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!FLAC__metadata_object_seektable_is_legal(block)) {
+		printf("FAILED, seek table is illegal\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, seekpoint_array))
+		return false;
+
+	seekpoint_array[seekpoints++].sample_number = 0;
+	seekpoint_array[seekpoints++].sample_number = 10;
+	seekpoint_array[seekpoints++].sample_number = 20;
+	printf("testing FLAC__metadata_object_seekpoint_template_append_spaced_points_by_samples()... ");
+	if(!FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(block, 10, 30)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, seekpoint_array))
+		return false;
+
+	seekpoint_array[seekpoints++].sample_number = 0;
+	seekpoint_array[seekpoints++].sample_number = 11;
+	seekpoint_array[seekpoints++].sample_number = 22;
+	printf("testing FLAC__metadata_object_seekpoint_template_append_spaced_points_by_samples()... ");
+	if(!FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(block, 11, 30)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!check_seektable_(block, seekpoints, seekpoint_array))
+		return false;
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(block);
+	printf("OK\n");
+
+
+	printf("testing VORBIS_COMMENT\n");
+
+	{
+		FLAC__StreamMetadata_VorbisComment_Entry entry_;
+		char *field_name, *field_value;
+
+		printf("testing FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair()... ");
+		if(!FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry_, "name", "value")) {
+			printf("FAILED, returned false\n");
+			return false;
+		}
+		if(strcmp((const char *)entry_.entry, "name=value")) {
+			printf("FAILED, field mismatch\n");
+			return false;
+		}
+		printf("OK\n");
+
+		printf("testing FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair()... ");
+		if(!FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair(entry_, &field_name, &field_value)) {
+			printf("FAILED, returned false\n");
+			return false;
+		}
+		if(strcmp(field_name, "name")) {
+			printf("FAILED, field name mismatch\n");
+			return false;
+		}
+		if(strcmp(field_value, "value")) {
+			printf("FAILED, field value mismatch\n");
+			return false;
+		}
+		printf("OK\n");
+
+		printf("testing FLAC__metadata_object_vorbiscomment_entry_matches()... ");
+		if(!FLAC__metadata_object_vorbiscomment_entry_matches(entry_, field_name, strlen(field_name))) {
+			printf("FAILED, expected true, returned false\n");
+			return false;
+		}
+		printf("OK\n");
+
+		printf("testing FLAC__metadata_object_vorbiscomment_entry_matches()... ");
+		if(FLAC__metadata_object_vorbiscomment_entry_matches(entry_, "blah", strlen("blah"))) {
+			printf("FAILED, expected false, returned true\n");
+			return false;
+		}
+		printf("OK\n");
+
+		free(entry_.entry);
+		free(field_name);
+		free(field_value);
+	}
+
+	printf("testing FLAC__metadata_object_new()... ");
+	block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
+	if(0 == block) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	expected_length = (FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN/8 + strlen(FLAC__VENDOR_STRING) + FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN/8);
+	if(block->length != expected_length) {
+		printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_clone()... ");
+	vorbiscomment = FLAC__metadata_object_clone(block);
+	if(0 == vorbiscomment) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	vc_resize_(vorbiscomment, 2);
+	printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(grow to %u)...", vorbiscomment->data.vorbis_comment.num_comments);
+	if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	vc_resize_(vorbiscomment, 1);
+	printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(shrink to %u)...", vorbiscomment->data.vorbis_comment.num_comments);
+	if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	vc_resize_(vorbiscomment, 0);
+	printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(shrink to %u)...", vorbiscomment->data.vorbis_comment.num_comments);
+	if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 0, "name1=field1");
+	if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on non-empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 1, "name2=field2");
+	if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	vc_resize_(vorbiscomment, 0);
+	printf("testing FLAC__metadata_object_vorbiscomment_resize_comments(shrink to %u)...", vorbiscomment->data.vorbis_comment.num_comments);
+	if(!FLAC__metadata_object_vorbiscomment_resize_comments(block, vorbiscomment->data.vorbis_comment.num_comments)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 0, "name1=field1");
+	if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on beginning of non-empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 0, "name2=field2");
+	if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on middle of non-empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 1, "name3=field3");
+	if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 1, entry, /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on end of non-empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 3, "name4=field4");
+	if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 3, entry, /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on end of non-empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 4, "name3=field3dup1");
+	if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 4, entry, /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(copy) on end of non-empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 5, "name3=field3dup1");
+	if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 5, entry, /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()...");
+	if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, 0, "name3")) != 1) {
+		printf("FAILED, expected 1, got %d\n", j);
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()...");
+	if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, j+1, "name3")) != 4) {
+		printf("FAILED, expected 4, got %d\n", j);
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()...");
+	if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, j+1, "name3")) != 5) {
+		printf("FAILED, expected 5, got %d\n", j);
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()...");
+	if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, 0, "name2")) != 0) {
+		printf("FAILED, expected 0, got %d\n", j);
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()...");
+	if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, j+1, "name2")) != -1) {
+		printf("FAILED, expected -1, got %d\n", j);
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_find_entry_from()...");
+	if((j = FLAC__metadata_object_vorbiscomment_find_entry_from(block, 0, "blah")) != -1) {
+		printf("FAILED, expected -1, got %d\n", j);
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_replace_comment(first, copy)...");
+	vc_replace_new_(&entry, vorbiscomment, "name3=field3new1", /*all=*/false);
+	if(!FLAC__metadata_object_vorbiscomment_replace_comment(block, entry, /*all=*/false, /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	if(block->data.vorbis_comment.num_comments != 6) {
+		printf("FAILED, expected 6 comments, got %u\n", block->data.vorbis_comment.num_comments);
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_replace_comment(all, copy)...");
+	vc_replace_new_(&entry, vorbiscomment, "name3=field3new2", /*all=*/true);
+	if(!FLAC__metadata_object_vorbiscomment_replace_comment(block, entry, /*all=*/true, /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	if(block->data.vorbis_comment.num_comments != 4) {
+		printf("FAILED, expected 4 comments, got %u\n", block->data.vorbis_comment.num_comments);
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_clone()... ");
+	blockcopy = FLAC__metadata_object_clone(block);
+	if(0 == blockcopy) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!mutils__compare_block(block, blockcopy))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(blockcopy);
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on middle of array...");
+	vc_delete_(vorbiscomment, 2);
+	if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on end of array...");
+	vc_delete_(vorbiscomment, 2);
+	if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on beginning of array...");
+	vc_delete_(vorbiscomment, 0);
+	if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 0)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on non-empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 1, "rem0=val0");
+	if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on non-empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 2, "rem0=val1");
+	if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_append_comment(copy) on non-empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 3, "rem0=val2");
+	if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_remove_entry_matching(\"blah\")...");
+	if((j = FLAC__metadata_object_vorbiscomment_remove_entry_matching(block, "blah")) != 0) {
+		printf("FAILED, expected 0, got %d\n", j);
+		return false;
+	}
+	if(block->data.vorbis_comment.num_comments != 4) {
+		printf("FAILED, expected 4 comments, got %u\n", block->data.vorbis_comment.num_comments);
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_remove_entry_matching(\"rem0\")...");
+	vc_delete_(vorbiscomment, 1);
+	if((j = FLAC__metadata_object_vorbiscomment_remove_entry_matching(block, "rem0")) != 1) {
+		printf("FAILED, expected 1, got %d\n", j);
+		return false;
+	}
+	if(block->data.vorbis_comment.num_comments != 3) {
+		printf("FAILED, expected 3 comments, got %u\n", block->data.vorbis_comment.num_comments);
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_remove_entries_matching(\"blah\")...");
+	if((j = FLAC__metadata_object_vorbiscomment_remove_entries_matching(block, "blah")) != 0) {
+		printf("FAILED, expected 0, got %d\n", j);
+		return false;
+	}
+	if(block->data.vorbis_comment.num_comments != 3) {
+		printf("FAILED, expected 3 comments, got %u\n", block->data.vorbis_comment.num_comments);
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_remove_entries_matching(\"rem0\")...");
+	vc_delete_(vorbiscomment, 1);
+	vc_delete_(vorbiscomment, 1);
+	if((j = FLAC__metadata_object_vorbiscomment_remove_entries_matching(block, "rem0")) != 2) {
+		printf("FAILED, expected 2, got %d\n", j);
+		return false;
+	}
+	if(block->data.vorbis_comment.num_comments != 1) {
+		printf("FAILED, expected 1 comments, got %u\n", block->data.vorbis_comment.num_comments);
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_set_comment(copy)...");
+	vc_set_new_(&entry, vorbiscomment, 0, "name5=field5");
+	FLAC__metadata_object_vorbiscomment_set_comment(block, 0, entry, /*copy=*/true);
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_set_vendor_string(copy)...");
+	vc_set_vs_new_(&entry, vorbiscomment, "name6=field6");
+	FLAC__metadata_object_vorbiscomment_set_vendor_string(block, entry, /*copy=*/true);
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(vorbiscomment);
+	FLAC__metadata_object_delete(block);
+	printf("OK\n");
+
+
+	printf("testing FLAC__metadata_object_new()... ");
+	block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
+	if(0 == block) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_clone()... ");
+	vorbiscomment = FLAC__metadata_object_clone(block);
+	if(0 == vorbiscomment) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_append_comment(own) on empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 0, "name1=field1");
+	entry_clone_(&entry);
+	if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_append_comment(own) on non-empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 1, "name2=field2");
+	entry_clone_(&entry);
+	if(!FLAC__metadata_object_vorbiscomment_append_comment(block, entry, /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(vorbiscomment);
+	FLAC__metadata_object_delete(block);
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_new()... ");
+	block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
+	if(0 == block) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_clone()... ");
+	vorbiscomment = FLAC__metadata_object_clone(block);
+	if(0 == vorbiscomment) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 0, "name1=field1");
+	entry_clone_(&entry);
+	if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on beginning of non-empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 0, "name2=field2");
+	entry_clone_(&entry);
+	if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 0, entry, /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on middle of non-empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 1, "name3=field3");
+	entry_clone_(&entry);
+	if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 1, entry, /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on end of non-empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 3, "name4=field4");
+	entry_clone_(&entry);
+	if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 3, entry, /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on end of non-empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 4, "name3=field3dup1");
+	entry_clone_(&entry);
+	if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 4, entry, /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_insert_comment(own) on end of non-empty array...");
+	vc_insert_new_(&entry, vorbiscomment, 5, "name3=field3dup1");
+	entry_clone_(&entry);
+	if(!FLAC__metadata_object_vorbiscomment_insert_comment(block, 5, entry, /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_replace_comment(first, own)...");
+	vc_replace_new_(&entry, vorbiscomment, "name3=field3new1", /*all=*/false);
+	entry_clone_(&entry);
+	if(!FLAC__metadata_object_vorbiscomment_replace_comment(block, entry, /*all=*/false, /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	if(block->data.vorbis_comment.num_comments != 6) {
+		printf("FAILED, expected 6 comments, got %u\n", block->data.vorbis_comment.num_comments);
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_replace_comment(all, own)...");
+	vc_replace_new_(&entry, vorbiscomment, "name3=field3new2", /*all=*/true);
+	entry_clone_(&entry);
+	if(!FLAC__metadata_object_vorbiscomment_replace_comment(block, entry, /*all=*/true, /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	if(block->data.vorbis_comment.num_comments != 4) {
+		printf("FAILED, expected 4 comments, got %u\n", block->data.vorbis_comment.num_comments);
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on middle of array...");
+	vc_delete_(vorbiscomment, 2);
+	if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on end of array...");
+	vc_delete_(vorbiscomment, 2);
+	if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 2)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_delete_comment() on beginning of array...");
+	vc_delete_(vorbiscomment, 0);
+	if(!FLAC__metadata_object_vorbiscomment_delete_comment(block, 0)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_set_comment(own)...");
+	vc_set_new_(&entry, vorbiscomment, 0, "name5=field5");
+	entry_clone_(&entry);
+	FLAC__metadata_object_vorbiscomment_set_comment(block, 0, entry, /*copy=*/false);
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_vorbiscomment_set_vendor_string(own)...");
+	vc_set_vs_new_(&entry, vorbiscomment, "name6=field6");
+	entry_clone_(&entry);
+	FLAC__metadata_object_vorbiscomment_set_vendor_string(block, entry, /*copy=*/false);
+	if(!mutils__compare_block(vorbiscomment, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(vorbiscomment);
+	FLAC__metadata_object_delete(block);
+	printf("OK\n");
+
+
+	printf("testing CUESHEET\n");
+
+	{
+		FLAC__StreamMetadata_CueSheet_Track *track_, *trackcopy_;
+
+		printf("testing FLAC__metadata_object_cuesheet_track_new()... ");
+		track_ = FLAC__metadata_object_cuesheet_track_new();
+		if(0 == track_) {
+			printf("FAILED, returned NULL\n");
+			return false;
+		}
+		printf("OK\n");
+
+		printf("testing FLAC__metadata_object_cuesheet_track_clone()... ");
+		trackcopy_ = FLAC__metadata_object_cuesheet_track_clone(track_);
+		if(0 == trackcopy_) {
+			printf("FAILED, returned NULL\n");
+			return false;
+		}
+		if(!compare_track_(trackcopy_, track_))
+			return false;
+		printf("OK\n");
+
+		printf("testing FLAC__metadata_object_cuesheet_track_delete()... ");
+		FLAC__metadata_object_cuesheet_track_delete(trackcopy_);
+		FLAC__metadata_object_cuesheet_track_delete(track_);
+		printf("OK\n");
+	}
+
+
+	printf("testing FLAC__metadata_object_new()... ");
+	block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_CUESHEET);
+	if(0 == block) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	expected_length = (
+		FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN +
+		FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN +
+		FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN +
+		FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN +
+		FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN
+	) / 8;
+	if(block->length != expected_length) {
+		printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_clone()... ");
+	cuesheet = FLAC__metadata_object_clone(block);
+	if(0 == cuesheet) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	cs_resize_(cuesheet, 2);
+	printf("testing FLAC__metadata_object_cuesheet_resize_tracks(grow to %u)...", cuesheet->data.cue_sheet.num_tracks);
+	if(!FLAC__metadata_object_cuesheet_resize_tracks(block, cuesheet->data.cue_sheet.num_tracks)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	cs_resize_(cuesheet, 1);
+	printf("testing FLAC__metadata_object_cuesheet_resize_tracks(shrink to %u)...", cuesheet->data.cue_sheet.num_tracks);
+	if(!FLAC__metadata_object_cuesheet_resize_tracks(block, cuesheet->data.cue_sheet.num_tracks)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	cs_resize_(cuesheet, 0);
+	printf("testing FLAC__metadata_object_cuesheet_resize_tracks(shrink to %u)...", cuesheet->data.cue_sheet.num_tracks);
+	if(!FLAC__metadata_object_cuesheet_resize_tracks(block, cuesheet->data.cue_sheet.num_tracks)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on empty array...");
+	cs_insert_new_(&track, cuesheet, 0, 0, 1, "ABCDE1234567", false, false);
+	if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on beginning of non-empty array...");
+	cs_insert_new_(&track, cuesheet, 0, 10, 2, "BBCDE1234567", false, false);
+	if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on middle of non-empty array...");
+	cs_insert_new_(&track, cuesheet, 1, 20, 3, "CBCDE1234567", false, false);
+	if(!FLAC__metadata_object_cuesheet_insert_track(block, 1, &track, /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_insert_track(copy) on end of non-empty array...");
+	cs_insert_new_(&track, cuesheet, 3, 30, 4, "DBCDE1234567", false, false);
+	if(!FLAC__metadata_object_cuesheet_insert_track(block, 3, &track, /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_insert_blank_track() on end of non-empty array...");
+	cs_insert_new_(&track, cuesheet, 4, 0, 0, "\0\0\0\0\0\0\0\0\0\0\0\0", false, false);
+	if(!FLAC__metadata_object_cuesheet_insert_blank_track(block, 4)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_clone()... ");
+	blockcopy = FLAC__metadata_object_clone(block);
+	if(0 == blockcopy) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!mutils__compare_block(block, blockcopy))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(blockcopy);
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_delete_track() on end of array...");
+	cs_delete_(cuesheet, 4);
+	if(!FLAC__metadata_object_cuesheet_delete_track(block, 4)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_delete_track() on middle of array...");
+	cs_delete_(cuesheet, 2);
+	if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_delete_track() on end of array...");
+	cs_delete_(cuesheet, 2);
+	if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_delete_track() on beginning of array...");
+	cs_delete_(cuesheet, 0);
+	if(!FLAC__metadata_object_cuesheet_delete_track(block, 0)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_set_track(copy)...");
+	cs_set_new_(&track, cuesheet, 0, 40, 5, "EBCDE1234567", false, false);
+	FLAC__metadata_object_cuesheet_set_track(block, 0, &track, /*copy=*/true);
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	tr_resize_(cuesheet, 0, 2);
+	printf("testing FLAC__metadata_object_cuesheet_track_resize_indices(grow to %u)...", cuesheet->data.cue_sheet.tracks[0].num_indices);
+	if(!FLAC__metadata_object_cuesheet_track_resize_indices(block, 0, cuesheet->data.cue_sheet.tracks[0].num_indices)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	tr_resize_(cuesheet, 0, 1);
+	printf("testing FLAC__metadata_object_cuesheet_track_resize_indices(shrink to %u)...", cuesheet->data.cue_sheet.tracks[0].num_indices);
+	if(!FLAC__metadata_object_cuesheet_track_resize_indices(block, 0, cuesheet->data.cue_sheet.tracks[0].num_indices)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	tr_resize_(cuesheet, 0, 0);
+	printf("testing FLAC__metadata_object_cuesheet_track_resize_indices(shrink to %u)...", cuesheet->data.cue_sheet.tracks[0].num_indices);
+	if(!FLAC__metadata_object_cuesheet_track_resize_indices(block, 0, cuesheet->data.cue_sheet.tracks[0].num_indices)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	index.offset = 0;
+	index.number = 1;
+	printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on empty array...");
+	tr_insert_new_(cuesheet, 0, 0, index);
+	if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 0, index)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	index.offset = 10;
+	index.number = 2;
+	printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on beginning of non-empty array...");
+	tr_insert_new_(cuesheet, 0, 0, index);
+	if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 0, index)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	index.offset = 20;
+	index.number = 3;
+	printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on middle of non-empty array...");
+	tr_insert_new_(cuesheet, 0, 1, index);
+	if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 1, index)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	index.offset = 30;
+	index.number = 4;
+	printf("testing FLAC__metadata_object_cuesheet_track_insert_index() on end of non-empty array...");
+	tr_insert_new_(cuesheet, 0, 3, index);
+	if(!FLAC__metadata_object_cuesheet_track_insert_index(block, 0, 3, index)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	index.offset = 0;
+	index.number = 0;
+	printf("testing FLAC__metadata_object_cuesheet_track_insert_blank_index() on end of non-empty array...");
+	tr_insert_new_(cuesheet, 0, 4, index);
+	if(!FLAC__metadata_object_cuesheet_track_insert_blank_index(block, 0, 4)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_clone()... ");
+	blockcopy = FLAC__metadata_object_clone(block);
+	if(0 == blockcopy) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!mutils__compare_block(block, blockcopy))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(blockcopy);
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on end of array...");
+	tr_delete_(cuesheet, 0, 4);
+	if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 4)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on middle of array...");
+	tr_delete_(cuesheet, 0, 2);
+	if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 2)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on end of array...");
+	tr_delete_(cuesheet, 0, 2);
+	if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 2)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_track_delete_index() on beginning of array...");
+	tr_delete_(cuesheet, 0, 0);
+	if(!FLAC__metadata_object_cuesheet_track_delete_index(block, 0, 0)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(cuesheet);
+	FLAC__metadata_object_delete(block);
+	printf("OK\n");
+
+
+	printf("testing FLAC__metadata_object_new()... ");
+	block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_CUESHEET);
+	if(0 == block) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_clone()... ");
+	cuesheet = FLAC__metadata_object_clone(block);
+	if(0 == cuesheet) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on empty array...");
+	cs_insert_new_(&track, cuesheet, 0, 60, 7, "GBCDE1234567", false, false);
+	track_clone_(&track);
+	if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on beginning of non-empty array...");
+	cs_insert_new_(&track, cuesheet, 0, 70, 8, "HBCDE1234567", false, false);
+	track_clone_(&track);
+	if(!FLAC__metadata_object_cuesheet_insert_track(block, 0, &track, /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on middle of non-empty array...");
+	cs_insert_new_(&track, cuesheet, 1, 80, 9, "IBCDE1234567", false, false);
+	track_clone_(&track);
+	if(!FLAC__metadata_object_cuesheet_insert_track(block, 1, &track, /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_insert_track(own) on end of non-empty array...");
+	cs_insert_new_(&track, cuesheet, 3, 90, 10, "JBCDE1234567", false, false);
+	track_clone_(&track);
+	if(!FLAC__metadata_object_cuesheet_insert_track(block, 3, &track, /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_delete_track() on middle of array...");
+	cs_delete_(cuesheet, 2);
+	if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_delete_track() on end of array...");
+	cs_delete_(cuesheet, 2);
+	if(!FLAC__metadata_object_cuesheet_delete_track(block, 2)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_delete_track() on beginning of array...");
+	cs_delete_(cuesheet, 0);
+	if(!FLAC__metadata_object_cuesheet_delete_track(block, 0)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_set_track(own)...");
+	cs_set_new_(&track, cuesheet, 0, 100, 11, "KBCDE1234567", false, false);
+	track_clone_(&track);
+	FLAC__metadata_object_cuesheet_set_track(block, 0, &track, /*copy=*/false);
+	if(!mutils__compare_block(cuesheet, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_cuesheet_is_legal()...");
+	{
+		const char *violation;
+		if(FLAC__metadata_object_cuesheet_is_legal(block, /*check_cd_da_subset=*/true, &violation)) {
+			printf("FAILED, returned true when expecting false\n");
+			return false;
+		}
+		printf("returned false as expected, violation=\"%s\" OK\n", violation);
+	}
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(cuesheet);
+	FLAC__metadata_object_delete(block);
+	printf("OK\n");
+
+
+	printf("testing PICTURE\n");
+
+	printf("testing FLAC__metadata_object_new()... ");
+	block = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PICTURE);
+	if(0 == block) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	expected_length = (
+		FLAC__STREAM_METADATA_PICTURE_TYPE_LEN +
+		FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN +
+		FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN +
+		FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN +
+		FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN +
+		FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN +
+		FLAC__STREAM_METADATA_PICTURE_COLORS_LEN +
+		FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN
+	) / 8;
+	if(block->length != expected_length) {
+		printf("FAILED, bad length, expected %u, got %u\n", expected_length, block->length);
+		return false;
+	}
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_clone()... ");
+	picture = FLAC__metadata_object_clone(block);
+	if(0 == picture) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!mutils__compare_block(picture, block))
+		return false;
+	printf("OK\n");
+
+	pi_set_mime_type(picture, "image/png\t");
+	printf("testing FLAC__metadata_object_picture_set_mime_type(copy)...");
+	if(!FLAC__metadata_object_picture_set_mime_type(block, "image/png\t", /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(picture, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_picture_is_legal()...");
+	{
+		const char *violation;
+		if(FLAC__metadata_object_picture_is_legal(block, &violation)) {
+			printf("FAILED, returned true when expecting false\n");
+			return false;
+		}
+		printf("returned false as expected, violation=\"%s\" OK\n", violation);
+	}
+
+	pi_set_mime_type(picture, "image/png");
+	printf("testing FLAC__metadata_object_picture_set_mime_type(copy)...");
+	if(!FLAC__metadata_object_picture_set_mime_type(block, "image/png", /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(picture, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_picture_is_legal()...");
+	{
+		const char *violation;
+		if(!FLAC__metadata_object_picture_is_legal(block, &violation)) {
+			printf("FAILED, returned false, violation=\"%s\"\n", violation);
+			return false;
+		}
+		printf("OK\n");
+	}
+
+	pi_set_description(picture, (const FLAC__byte *)"DESCRIPTION\xff");
+	printf("testing FLAC__metadata_object_picture_set_description(copy)...");
+	if(!FLAC__metadata_object_picture_set_description(block, (FLAC__byte *)"DESCRIPTION\xff", /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(picture, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_picture_is_legal()...");
+	{
+		const char *violation;
+		if(FLAC__metadata_object_picture_is_legal(block, &violation)) {
+			printf("FAILED, returned true when expecting false\n");
+			return false;
+		}
+		printf("returned false as expected, violation=\"%s\" OK\n", violation);
+	}
+
+	pi_set_description(picture, (const FLAC__byte *)"DESCRIPTION");
+	printf("testing FLAC__metadata_object_picture_set_description(copy)...");
+	if(!FLAC__metadata_object_picture_set_description(block, (FLAC__byte *)"DESCRIPTION", /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(picture, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_picture_is_legal()...");
+	{
+		const char *violation;
+		if(!FLAC__metadata_object_picture_is_legal(block, &violation)) {
+			printf("FAILED, returned false, violation=\"%s\"\n", violation);
+			return false;
+		}
+		printf("OK\n");
+	}
+
+
+	pi_set_data(picture, (const FLAC__byte*)"PNGDATA", strlen("PNGDATA"));
+	printf("testing FLAC__metadata_object_picture_set_data(copy)...");
+	if(!FLAC__metadata_object_picture_set_data(block, (FLAC__byte*)"PNGDATA", strlen("PNGDATA"), /*copy=*/true)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(picture, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_clone()... ");
+	blockcopy = FLAC__metadata_object_clone(block);
+	if(0 == blockcopy) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!mutils__compare_block(block, blockcopy))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(blockcopy);
+	printf("OK\n");
+
+	pi_set_mime_type(picture, "image/png\t");
+	printf("testing FLAC__metadata_object_picture_set_mime_type(own)...");
+	if(!FLAC__metadata_object_picture_set_mime_type(block, strdup("image/png\t"), /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(picture, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_picture_is_legal()...");
+	{
+		const char *violation;
+		if(FLAC__metadata_object_picture_is_legal(block, &violation)) {
+			printf("FAILED, returned true when expecting false\n");
+			return false;
+		}
+		printf("returned false as expected, violation=\"%s\" OK\n", violation);
+	}
+
+	pi_set_mime_type(picture, "image/png");
+	printf("testing FLAC__metadata_object_picture_set_mime_type(own)...");
+	if(!FLAC__metadata_object_picture_set_mime_type(block, strdup("image/png"), /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(picture, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_picture_is_legal()...");
+	{
+		const char *violation;
+		if(!FLAC__metadata_object_picture_is_legal(block, &violation)) {
+			printf("FAILED, returned false, violation=\"%s\"\n", violation);
+			return false;
+		}
+		printf("OK\n");
+	}
+
+	pi_set_description(picture, (const FLAC__byte *)"DESCRIPTION\xff");
+	printf("testing FLAC__metadata_object_picture_set_description(own)...");
+	if(!FLAC__metadata_object_picture_set_description(block, (FLAC__byte *)strdup("DESCRIPTION\xff"), /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(picture, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_picture_is_legal()...");
+	{
+		const char *violation;
+		if(FLAC__metadata_object_picture_is_legal(block, &violation)) {
+			printf("FAILED, returned true when expecting false\n");
+			return false;
+		}
+		printf("returned false as expected, violation=\"%s\" OK\n", violation);
+	}
+
+	pi_set_description(picture, (const FLAC__byte *)"DESCRIPTION");
+	printf("testing FLAC__metadata_object_picture_set_description(own)...");
+	if(!FLAC__metadata_object_picture_set_description(block, (FLAC__byte *)strdup("DESCRIPTION"), /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(picture, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_picture_is_legal()...");
+	{
+		const char *violation;
+		if(!FLAC__metadata_object_picture_is_legal(block, &violation)) {
+			printf("FAILED, returned false, violation=\"%s\"\n", violation);
+			return false;
+		}
+		printf("OK\n");
+	}
+
+	pi_set_data(picture, (const FLAC__byte*)"PNGDATA", strlen("PNGDATA"));
+	printf("testing FLAC__metadata_object_picture_set_data(own)...");
+	if(!FLAC__metadata_object_picture_set_data(block, (FLAC__byte*)strdup("PNGDATA"), strlen("PNGDATA"), /*copy=*/false)) {
+		printf("FAILED, returned false\n");
+		return false;
+	}
+	if(!mutils__compare_block(picture, block))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_clone()... ");
+	blockcopy = FLAC__metadata_object_clone(block);
+	if(0 == blockcopy) {
+		printf("FAILED, returned NULL\n");
+		return false;
+	}
+	if(!mutils__compare_block(block, blockcopy))
+		return false;
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(blockcopy);
+	printf("OK\n");
+
+	printf("testing FLAC__metadata_object_delete()... ");
+	FLAC__metadata_object_delete(picture);
+	FLAC__metadata_object_delete(block);
+	printf("OK\n");
+
+
+	return true;
+}
diff --git a/audio-codec/flac/test_libFLAC/test_libFLAC.dsp b/audio-codec/flac/test_libFLAC/test_libFLAC.dsp
new file mode 100644
index 0000000..bc351e3
--- /dev/null
+++ b/audio-codec/flac/test_libFLAC/test_libFLAC.dsp
@@ -0,0 +1,148 @@
+# Microsoft Developer Studio Project File - Name="test_libFLAC" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=test_libFLAC - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "test_libFLAC.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "test_libFLAC.mak" CFG="test_libFLAC - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "test_libFLAC - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "test_libFLAC - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "test_libFLAC - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "..\..\obj\release\bin"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\libFLAC\include" /I "..\..\include" /D "NDEBUG" /D "FLAC__NO_DLL" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX /Yc /Yu
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 ..\..\obj\release\lib\grabbag_static.lib ..\..\obj\release\lib\replaygain_analysis_static.lib ..\..\obj\release\lib\test_libs_common_static.lib ..\..\obj\release\lib\libFLAC_static.lib ..\..\obj\release\lib\ogg_static.lib /nologo /subsystem:console /machine:I386
+
+!ELSEIF  "$(CFG)" == "test_libFLAC - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "..\..\obj\debug\bin"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\libFLAC\include" /I "..\..\include" /D "_DEBUG" /D "DEBUG" /D "FLAC__NO_DLL" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c
+# SUBTRACT CPP /YX /Yc /Yu
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 ..\..\obj\debug\lib\grabbag_static.lib ..\..\obj\debug\lib\replaygain_analysis_static.lib ..\..\obj\debug\lib\test_libs_common_static.lib ..\..\obj\debug\lib\libFLAC_static.lib ..\..\obj\release\lib\ogg_static.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "test_libFLAC - Win32 Release"
+# Name "test_libFLAC - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\bitwriter.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\decoders.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\encoders.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\format.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\main.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\metadata.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\metadata_manip.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\metadata_object.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\bitwriter.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\decoders.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\encoders.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\format.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\metadata.h
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/audio-codec/flac/test_libFLAC/test_libFLAC.vcproj b/audio-codec/flac/test_libFLAC/test_libFLAC.vcproj
new file mode 100644
index 0000000..47988e7
--- /dev/null
+++ b/audio-codec/flac/test_libFLAC/test_libFLAC.vcproj
@@ -0,0 +1,252 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="test_libFLAC"
+	ProjectGUID="{4cefbc8c-c215-11db-8314-0800200c9a66}"
+	RootNamespace="test_libFLAC"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="..\..\obj\debug\bin"
+			IntermediateDirectory="Debug"
+			ConfigurationType="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories=".;..\libFLAC\include;..\..\include"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;FLAC__NO_DLL;DEBUG"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+				CompileAs="0"
+				DisableSpecificWarnings="4267;4996"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="..\..\obj\release\lib\ogg_static.lib"
+				LinkIncremental="2"
+				IgnoreDefaultLibraryNames="uuid.lib"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="..\..\obj\release\bin"
+			IntermediateDirectory="Release"
+			ConfigurationType="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				EnableIntrinsicFunctions="true"
+				FavorSizeOrSpeed="1"
+				OmitFramePointers="true"
+				WholeProgramOptimization="true"
+				AdditionalIncludeDirectories=".;..\libFLAC\include;..\..\include"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;FLAC__NO_DLL"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="false"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+				CompileAs="0"
+				DisableSpecificWarnings="4267;4996"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="..\..\obj\release\lib\ogg_static.lib"
+				LinkIncremental="1"
+				IgnoreDefaultLibraryNames="uuid.lib"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				LinkTimeCodeGeneration="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath=".\bitwriter.h"
+				>
+			</File>
+			<File
+				RelativePath=".\decoders.h"
+				>
+			</File>
+			<File
+				RelativePath=".\encoders.h"
+				>
+			</File>
+			<File
+				RelativePath=".\format.h"
+				>
+			</File>
+			<File
+				RelativePath=".\metadata.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath=".\bitwriter.c"
+				>
+			</File>
+			<File
+				RelativePath=".\decoders.c"
+				>
+			</File>
+			<File
+				RelativePath=".\encoders.c"
+				>
+			</File>
+			<File
+				RelativePath=".\format.c"
+				>
+			</File>
+			<File
+				RelativePath=".\main.c"
+				>
+			</File>
+			<File
+				RelativePath=".\metadata.c"
+				>
+			</File>
+			<File
+				RelativePath=".\metadata_manip.c"
+				>
+			</File>
+			<File
+				RelativePath=".\metadata_object.c"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/audio-codec/flac/test_libs_common/Makefile.am b/audio-codec/flac/test_libs_common/Makefile.am
new file mode 100644
index 0000000..f363f8b
--- /dev/null
+++ b/audio-codec/flac/test_libs_common/Makefile.am
@@ -0,0 +1,30 @@
+#  test_libs_common - Common code to library unit tests
+#  Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007  Josh Coalson
+#
+#  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.
+
+INCLUDES = -I$(top_srcdir)/include
+
+noinst_LTLIBRARIES = libtest_libs_common.la
+
+libtest_libs_common_la_SOURCES = \
+	file_utils_flac.c \
+	metadata_utils.c
+
+EXTRA_DIST = \
+	Makefile.lite \
+	README \
+	test_libs_common_static.dsp \
+	test_libs_common_static.vcproj
diff --git a/audio-codec/flac/test_libs_common/Makefile.in b/audio-codec/flac/test_libs_common/Makefile.in
new file mode 100644
index 0000000..424c04e
--- /dev/null
+++ b/audio-codec/flac/test_libs_common/Makefile.in
@@ -0,0 +1,514 @@
+# Makefile.in generated by automake 1.7.9 from Makefile.am.
+# @configure_input@
+
+# Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
+# Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+#  test_libs_common - Common code to library unit tests
+#  Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007  Josh Coalson
+#
+#  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.
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+top_builddir = ../..
+
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+INSTALL = @INSTALL@
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+host_triplet = @host@
+ACLOCAL = @ACLOCAL@
+ACLOCAL_AMFLAGS = @ACLOCAL_AMFLAGS@
+AMDEP_FALSE = @AMDEP_FALSE@
+AMDEP_TRUE = @AMDEP_TRUE@
+AMTAR = @AMTAR@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCAS = @CCAS@
+CCASFLAGS = @CCASFLAGS@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEBUG_FALSE = @DEBUG_FALSE@
+DEBUG_TRUE = @DEBUG_TRUE@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DOCBOOK_TO_MAN = @DOCBOOK_TO_MAN@
+DOXYGEN = @DOXYGEN@
+ECHO = @ECHO@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+F77 = @F77@
+FFLAGS = @FFLAGS@
+FLAC__TEST_LEVEL = @FLAC__TEST_LEVEL@
+FLAC__TEST_WITH_VALGRIND = @FLAC__TEST_WITH_VALGRIND@
+FLaC__CPU_IA32_FALSE = @FLaC__CPU_IA32_FALSE@
+FLaC__CPU_IA32_TRUE = @FLaC__CPU_IA32_TRUE@
+FLaC__CPU_PPC_FALSE = @FLaC__CPU_PPC_FALSE@
+FLaC__CPU_PPC_TRUE = @FLaC__CPU_PPC_TRUE@
+FLaC__CPU_SPARC_FALSE = @FLaC__CPU_SPARC_FALSE@
+FLaC__CPU_SPARC_TRUE = @FLaC__CPU_SPARC_TRUE@
+FLaC__HAS_AS_FALSE = @FLaC__HAS_AS_FALSE@
+FLaC__HAS_AS_TRUE = @FLaC__HAS_AS_TRUE@
+FLaC__HAS_AS__TEMPORARILY_DISABLED_FALSE = @FLaC__HAS_AS__TEMPORARILY_DISABLED_FALSE@
+FLaC__HAS_AS__TEMPORARILY_DISABLED_TRUE = @FLaC__HAS_AS__TEMPORARILY_DISABLED_TRUE@
+FLaC__HAS_DOCBOOK_TO_MAN_FALSE = @FLaC__HAS_DOCBOOK_TO_MAN_FALSE@
+FLaC__HAS_DOCBOOK_TO_MAN_TRUE = @FLaC__HAS_DOCBOOK_TO_MAN_TRUE@
+FLaC__HAS_DOXYGEN_FALSE = @FLaC__HAS_DOXYGEN_FALSE@
+FLaC__HAS_DOXYGEN_TRUE = @FLaC__HAS_DOXYGEN_TRUE@
+FLaC__HAS_GAS_FALSE = @FLaC__HAS_GAS_FALSE@
+FLaC__HAS_GAS_TRUE = @FLaC__HAS_GAS_TRUE@
+FLaC__HAS_GAS__TEMPORARILY_DISABLED_FALSE = @FLaC__HAS_GAS__TEMPORARILY_DISABLED_FALSE@
+FLaC__HAS_GAS__TEMPORARILY_DISABLED_TRUE = @FLaC__HAS_GAS__TEMPORARILY_DISABLED_TRUE@
+FLaC__HAS_NASM_FALSE = @FLaC__HAS_NASM_FALSE@
+FLaC__HAS_NASM_TRUE = @FLaC__HAS_NASM_TRUE@
+FLaC__HAS_OGG_FALSE = @FLaC__HAS_OGG_FALSE@
+FLaC__HAS_OGG_TRUE = @FLaC__HAS_OGG_TRUE@
+FLaC__HAS_XMMS_FALSE = @FLaC__HAS_XMMS_FALSE@
+FLaC__HAS_XMMS_TRUE = @FLaC__HAS_XMMS_TRUE@
+FLaC__INSTALL_XMMS_PLUGIN_LOCALLY_FALSE = @FLaC__INSTALL_XMMS_PLUGIN_LOCALLY_FALSE@
+FLaC__INSTALL_XMMS_PLUGIN_LOCALLY_TRUE = @FLaC__INSTALL_XMMS_PLUGIN_LOCALLY_TRUE@
+FLaC__NO_ASM_FALSE = @FLaC__NO_ASM_FALSE@
+FLaC__NO_ASM_TRUE = @FLaC__NO_ASM_TRUE@
+FLaC__SSE_OS_FALSE = @FLaC__SSE_OS_FALSE@
+FLaC__SSE_OS_TRUE = @FLaC__SSE_OS_TRUE@
+FLaC__SYS_DARWIN_FALSE = @FLaC__SYS_DARWIN_FALSE@
+FLaC__SYS_DARWIN_TRUE = @FLaC__SYS_DARWIN_TRUE@
+FLaC__SYS_LINUX_FALSE = @FLaC__SYS_LINUX_FALSE@
+FLaC__SYS_LINUX_TRUE = @FLaC__SYS_LINUX_TRUE@
+FLaC__USE_3DNOW_FALSE = @FLaC__USE_3DNOW_FALSE@
+FLaC__USE_3DNOW_TRUE = @FLaC__USE_3DNOW_TRUE@
+FLaC__USE_ALTIVEC_FALSE = @FLaC__USE_ALTIVEC_FALSE@
+FLaC__USE_ALTIVEC_TRUE = @FLaC__USE_ALTIVEC_TRUE@
+FLaC__WITH_CPPLIBS_FALSE = @FLaC__WITH_CPPLIBS_FALSE@
+FLaC__WITH_CPPLIBS_TRUE = @FLaC__WITH_CPPLIBS_TRUE@
+GAS = @GAS@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LDFLAGS = @LDFLAGS@
+LIBICONV = @LIBICONV@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LN_S = @LN_S@
+LTLIBICONV = @LTLIBICONV@
+LTLIBOBJS = @LTLIBOBJS@
+MAINT = @MAINT@
+MAINTAINER_MODE_FALSE = @MAINTAINER_MODE_FALSE@
+MAINTAINER_MODE_TRUE = @MAINTAINER_MODE_TRUE@
+MAKEINFO = @MAKEINFO@
+MINGW_WINSOCK_LIBS = @MINGW_WINSOCK_LIBS@
+NASM = @NASM@
+OBJEXT = @OBJEXT@
+OBJ_FORMAT = @OBJ_FORMAT@
+OGG_CFLAGS = @OGG_CFLAGS@
+OGG_LIBS = @OGG_LIBS@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+RANLIB = @RANLIB@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+XMMS_CFLAGS = @XMMS_CFLAGS@
+XMMS_CONFIG = @XMMS_CONFIG@
+XMMS_DATA_DIR = @XMMS_DATA_DIR@
+XMMS_EFFECT_PLUGIN_DIR = @XMMS_EFFECT_PLUGIN_DIR@
+XMMS_GENERAL_PLUGIN_DIR = @XMMS_GENERAL_PLUGIN_DIR@
+XMMS_INPUT_PLUGIN_DIR = @XMMS_INPUT_PLUGIN_DIR@
+XMMS_LIBS = @XMMS_LIBS@
+XMMS_OUTPUT_PLUGIN_DIR = @XMMS_OUTPUT_PLUGIN_DIR@
+XMMS_PLUGIN_DIR = @XMMS_PLUGIN_DIR@
+XMMS_VERSION = @XMMS_VERSION@
+XMMS_VISUALIZATION_PLUGIN_DIR = @XMMS_VISUALIZATION_PLUGIN_DIR@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_F77 = @ac_ct_F77@
+ac_ct_RANLIB = @ac_ct_RANLIB@
+ac_ct_STRIP = @ac_ct_STRIP@
+am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+am__fastdepCXX_FALSE = @am__fastdepCXX_FALSE@
+am__fastdepCXX_TRUE = @am__fastdepCXX_TRUE@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+datadir = @datadir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+oldincludedir = @oldincludedir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+
+INCLUDES = -I$(top_srcdir)/include
+
+noinst_LTLIBRARIES = libtest_libs_common.la
+
+libtest_libs_common_la_SOURCES = \
+	file_utils_flac.c \
+	metadata_utils.c
+
+
+EXTRA_DIST = \
+	Makefile.lite \
+	README \
+	test_libs_common_static.dsp \
+	test_libs_common_static.vcproj
+
+subdir = src/test_libs_common
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+LTLIBRARIES = $(noinst_LTLIBRARIES)
+
+libtest_libs_common_la_LDFLAGS =
+libtest_libs_common_la_LIBADD =
+am_libtest_libs_common_la_OBJECTS = file_utils_flac.lo metadata_utils.lo
+libtest_libs_common_la_OBJECTS = $(am_libtest_libs_common_la_OBJECTS)
+
+DEFAULT_INCLUDES =  -I. -I$(srcdir) -I$(top_builddir)
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+@AMDEP_TRUE@DEP_FILES = ./$(DEPDIR)/file_utils_flac.Plo \
+@AMDEP_TRUE@	./$(DEPDIR)/metadata_utils.Plo
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) \
+	$(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(LIBTOOL) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(AM_LDFLAGS) $(LDFLAGS) -o $@
+DIST_SOURCES = $(libtest_libs_common_la_SOURCES)
+DIST_COMMON = README $(srcdir)/Makefile.in Makefile.am
+SOURCES = $(libtest_libs_common_la_SOURCES)
+
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ Makefile.am  $(top_srcdir)/configure.in $(ACLOCAL_M4)
+	cd $(top_srcdir) && \
+	  $(AUTOMAKE) --gnu  src/test_libs_common/Makefile
+Makefile: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.in  $(top_builddir)/config.status
+	cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)
+
+clean-noinstLTLIBRARIES:
+	-test -z "$(noinst_LTLIBRARIES)" || rm -f $(noinst_LTLIBRARIES)
+	@list='$(noinst_LTLIBRARIES)'; for p in $$list; do \
+	  dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
+	  test "$$dir" = "$$p" && dir=.; \
+	  echo "rm -f \"$${dir}/so_locations\""; \
+	  rm -f "$${dir}/so_locations"; \
+	done
+libtest_libs_common.la: $(libtest_libs_common_la_OBJECTS) $(libtest_libs_common_la_DEPENDENCIES) 
+	$(LINK)  $(libtest_libs_common_la_LDFLAGS) $(libtest_libs_common_la_OBJECTS) $(libtest_libs_common_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT) core *.core
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/file_utils_flac.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/metadata_utils.Plo@am__quote@
+
+.c.o:
+@am__fastdepCC_TRUE@	if $(COMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" \
+@am__fastdepCC_TRUE@	  -c -o $@ `test -f '$<' || echo '$(srcdir)/'`$<; \
+@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; \
+@am__fastdepCC_TRUE@	else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; \
+@am__fastdepCC_TRUE@	fi
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c `test -f '$<' || echo '$(srcdir)/'`$<
+
+.c.obj:
+@am__fastdepCC_TRUE@	if $(COMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" \
+@am__fastdepCC_TRUE@	  -c -o $@ `if test -f '$<'; then $(CYGPATH_W) '$<'; else $(CYGPATH_W) '$(srcdir)/$<'; fi`; \
+@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Po"; \
+@am__fastdepCC_TRUE@	else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; \
+@am__fastdepCC_TRUE@	fi
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c `if test -f '$<'; then $(CYGPATH_W) '$<'; else $(CYGPATH_W) '$(srcdir)/$<'; fi`
+
+.c.lo:
+@am__fastdepCC_TRUE@	if $(LTCOMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" \
+@am__fastdepCC_TRUE@	  -c -o $@ `test -f '$<' || echo '$(srcdir)/'`$<; \
+@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/$*.Tpo" "$(DEPDIR)/$*.Plo"; \
+@am__fastdepCC_TRUE@	else rm -f "$(DEPDIR)/$*.Tpo"; exit 1; \
+@am__fastdepCC_TRUE@	fi
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	depfile='$(DEPDIR)/$*.Plo' tmpdepfile='$(DEPDIR)/$*.TPlo' @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	$(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LTCOMPILE) -c -o $@ `test -f '$<' || echo '$(srcdir)/'`$<
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+distclean-libtool:
+	-rm -f libtool
+uninstall-info-am:
+
+ETAGS = etags
+ETAGSFLAGS =
+
+CTAGS = ctags
+CTAGSFLAGS =
+
+tags: TAGS
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	mkid -fID $$unique
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(ETAGS_ARGS)$$tags$$unique" \
+	  || $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	     $$tags $$unique
+
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(CTAGS_ARGS)$$tags$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$tags $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && cd $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) $$here
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+
+top_distdir = ../..
+distdir = $(top_distdir)/$(PACKAGE)-$(VERSION)
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \
+	list='$(DISTFILES)'; for file in $$list; do \
+	  case $$file in \
+	    $(srcdir)/*) file=`echo "$$file" | sed "s|^$$srcdirstrip/||"`;; \
+	    $(top_srcdir)/*) file=`echo "$$file" | sed "s|^$$topsrcdirstrip/|$(top_builddir)/|"`;; \
+	  esac; \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \
+	  if test "$$dir" != "$$file" && test "$$dir" != "."; then \
+	    dir="/$$dir"; \
+	    $(mkinstalldirs) "$(distdir)$$dir"; \
+	  else \
+	    dir=''; \
+	  fi; \
+	  if test -d $$d/$$file; then \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
+	    fi; \
+	    cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
+	  else \
+	    test -f $(distdir)/$$file \
+	    || cp -p $$d/$$file $(distdir)/$$file \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES)
+
+installdirs:
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-rm -f $(CONFIG_CLEAN_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool clean-noinstLTLIBRARIES \
+	mostlyclean-am
+
+distclean: distclean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-libtool distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-exec-am:
+
+install-info: install-info-am
+
+install-man:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-info-am
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
+	clean-libtool clean-noinstLTLIBRARIES ctags distclean \
+	distclean-compile distclean-generic distclean-libtool \
+	distclean-tags distdir dvi dvi-am info info-am install \
+	install-am install-data install-data-am install-exec \
+	install-exec-am install-info install-info-am install-man \
+	install-strip installcheck installcheck-am installdirs \
+	maintainer-clean maintainer-clean-generic mostlyclean \
+	mostlyclean-compile mostlyclean-generic mostlyclean-libtool pdf \
+	pdf-am ps ps-am tags uninstall uninstall-am uninstall-info-am
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/audio-codec/flac/test_libs_common/Makefile.lite b/audio-codec/flac/test_libs_common/Makefile.lite
new file mode 100644
index 0000000..fe7c92f
--- /dev/null
+++ b/audio-codec/flac/test_libs_common/Makefile.lite
@@ -0,0 +1,35 @@
+#  test_libs_common - Common code to library unit tests
+#  Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007  Josh Coalson
+#
+#  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.
+
+#
+# GNU makefile
+#
+
+topdir = ../..
+libdir = $(topdir)/obj/$(BUILD)/lib
+
+LIB_NAME = libtest_libs_common
+
+INCLUDES = -I$(topdir)/include
+
+SRCS_C = \
+	file_utils_flac.c \
+	metadata_utils.c
+
+include $(topdir)/build/lib.mk
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
diff --git a/audio-codec/flac/test_libs_common/README b/audio-codec/flac/test_libs_common/README
new file mode 100644
index 0000000..6a704c2
--- /dev/null
+++ b/audio-codec/flac/test_libs_common/README
@@ -0,0 +1,2 @@
+This directory contains a convenience library of routines that are
+common to the library unit testers.
diff --git a/audio-codec/flac/test_libs_common/file_utils_flac.c b/audio-codec/flac/test_libs_common/file_utils_flac.c
new file mode 100644
index 0000000..a52fee0
--- /dev/null
+++ b/audio-codec/flac/test_libs_common/file_utils_flac.c
@@ -0,0 +1,153 @@
+/* test_libFLAC - Unit tester for libFLAC
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * 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.
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "FLAC/assert.h"
+#include "FLAC/stream_encoder.h"
+#include "test_libs_common/file_utils_flac.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h> /* for stat() */
+
+#ifdef min
+#undef min
+#endif
+#define min(a,b) ((a)<(b)?(a):(b))
+
+const long file_utils__ogg_serial_number = 12345;
+
+#ifdef FLAC__VALGRIND_TESTING
+static size_t local__fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
+{
+	size_t ret = fwrite(ptr, size, nmemb, stream);
+	if(!ferror(stream))
+		fflush(stream);
+	return ret;
+}
+#else
+#define local__fwrite fwrite
+#endif
+
+typedef struct {
+	FILE *file;
+} encoder_client_struct;
+
+static FLAC__StreamEncoderWriteStatus encoder_write_callback_(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame, void *client_data)
+{
+	encoder_client_struct *ecd = (encoder_client_struct*)client_data;
+
+	(void)encoder, (void)samples, (void)current_frame;
+
+	if(local__fwrite(buffer, 1, bytes, ecd->file) != bytes)
+		return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
+	else
+		return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
+}
+
+static void encoder_metadata_callback_(const FLAC__StreamEncoder *encoder, const FLAC__StreamMetadata *metadata, void *client_data)
+{
+	(void)encoder, (void)metadata, (void)client_data;
+}
+
+FLAC__bool file_utils__generate_flacfile(FLAC__bool is_ogg, const char *output_filename, off_t *output_filesize, unsigned length, const FLAC__StreamMetadata *streaminfo, FLAC__StreamMetadata **metadata, unsigned num_metadata)
+{
+	FLAC__int32 samples[1024];
+	FLAC__StreamEncoder *encoder;
+	FLAC__StreamEncoderInitStatus init_status;
+	encoder_client_struct encoder_client_data;
+	unsigned i, n;
+
+	FLAC__ASSERT(0 != output_filename);
+	FLAC__ASSERT(0 != streaminfo);
+	FLAC__ASSERT(streaminfo->type == FLAC__METADATA_TYPE_STREAMINFO);
+	FLAC__ASSERT((streaminfo->is_last && num_metadata == 0) || (!streaminfo->is_last && num_metadata > 0));
+
+	if(0 == (encoder_client_data.file = fopen(output_filename, "wb")))
+		return false;
+
+	encoder = FLAC__stream_encoder_new();
+	if(0 == encoder) {
+		fclose(encoder_client_data.file);
+		return false;
+	}
+
+	FLAC__stream_encoder_set_ogg_serial_number(encoder, file_utils__ogg_serial_number);
+	FLAC__stream_encoder_set_verify(encoder, true);
+	FLAC__stream_encoder_set_streamable_subset(encoder, true);
+	FLAC__stream_encoder_set_do_mid_side_stereo(encoder, false);
+	FLAC__stream_encoder_set_loose_mid_side_stereo(encoder, false);
+	FLAC__stream_encoder_set_channels(encoder, streaminfo->data.stream_info.channels);
+	FLAC__stream_encoder_set_bits_per_sample(encoder, streaminfo->data.stream_info.bits_per_sample);
+	FLAC__stream_encoder_set_sample_rate(encoder, streaminfo->data.stream_info.sample_rate);
+	FLAC__stream_encoder_set_blocksize(encoder, streaminfo->data.stream_info.min_blocksize);
+	FLAC__stream_encoder_set_max_lpc_order(encoder, 0);
+	FLAC__stream_encoder_set_qlp_coeff_precision(encoder, 0);
+	FLAC__stream_encoder_set_do_qlp_coeff_prec_search(encoder, false);
+	FLAC__stream_encoder_set_do_escape_coding(encoder, false);
+	FLAC__stream_encoder_set_do_exhaustive_model_search(encoder, false);
+	FLAC__stream_encoder_set_min_residual_partition_order(encoder, 0);
+	FLAC__stream_encoder_set_max_residual_partition_order(encoder, 0);
+	FLAC__stream_encoder_set_rice_parameter_search_dist(encoder, 0);
+	FLAC__stream_encoder_set_total_samples_estimate(encoder, streaminfo->data.stream_info.total_samples);
+	FLAC__stream_encoder_set_metadata(encoder, metadata, num_metadata);
+
+	if(is_ogg)
+		init_status = FLAC__stream_encoder_init_ogg_stream(encoder, /*read_callback=*/0, encoder_write_callback_, /*seek_callback=*/0, /*tell_callback=*/0, encoder_metadata_callback_, &encoder_client_data);
+	else
+		init_status = FLAC__stream_encoder_init_stream(encoder, encoder_write_callback_, /*seek_callback=*/0, /*tell_callback=*/0, encoder_metadata_callback_, &encoder_client_data);
+
+	if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
+		fclose(encoder_client_data.file);
+		return false;
+	}
+
+	/* init the dummy sample buffer */
+	for(i = 0; i < sizeof(samples) / sizeof(FLAC__int32); i++)
+		samples[i] = i & 7;
+
+	while(length > 0) {
+		n = min(length, sizeof(samples) / sizeof(FLAC__int32));
+
+		if(!FLAC__stream_encoder_process_interleaved(encoder, samples, n)) {
+			fclose(encoder_client_data.file);
+			return false;
+		}
+
+		length -= n;
+	}
+
+	(void)FLAC__stream_encoder_finish(encoder);
+
+	fclose(encoder_client_data.file);
+
+	FLAC__stream_encoder_delete(encoder);
+
+	if(0 != output_filesize) {
+		struct stat filestats;
+
+		if(stat(output_filename, &filestats) != 0)
+			return false;
+		else
+			*output_filesize = filestats.st_size;
+	}
+
+	return true;
+}
diff --git a/audio-codec/flac/test_libs_common/metadata_utils.c b/audio-codec/flac/test_libs_common/metadata_utils.c
new file mode 100644
index 0000000..fe192e7
--- /dev/null
+++ b/audio-codec/flac/test_libs_common/metadata_utils.c
@@ -0,0 +1,657 @@
+/* test_libFLAC - Unit tester for libFLAC
+ * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
+ *
+ * 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.
+ */
+
+/*
+ * These are not tests, just utility functions used by the metadata tests
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#include "FLAC/metadata.h"
+#include "test_libs_common/metadata_utils.h"
+#include <stdio.h>
+#include <stdlib.h> /* for malloc() */
+#include <string.h> /* for memcmp() */
+
+FLAC__bool mutils__compare_block_data_streaminfo(const FLAC__StreamMetadata_StreamInfo *block, const FLAC__StreamMetadata_StreamInfo *blockcopy)
+{
+	if(blockcopy->min_blocksize != block->min_blocksize) {
+		printf("FAILED, min_blocksize mismatch, expected %u, got %u\n", block->min_blocksize, blockcopy->min_blocksize);
+		return false;
+	}
+	if(blockcopy->max_blocksize != block->max_blocksize) {
+		printf("FAILED, max_blocksize mismatch, expected %u, got %u\n", block->max_blocksize, blockcopy->max_blocksize);
+		return false;
+	}
+	if(blockcopy->min_framesize != block->min_framesize) {
+		printf("FAILED, min_framesize mismatch, expected %u, got %u\n", block->min_framesize, blockcopy->min_framesize);
+		return false;
+	}
+	if(blockcopy->max_framesize != block->max_framesize) {
+		printf("FAILED, max_framesize mismatch, expected %u, got %u\n", block->max_framesize, blockcopy->max_framesize);
+		return false;
+	}
+	if(blockcopy->sample_rate != block->sample_rate) {
+		printf("FAILED, sample_rate mismatch, expected %u, got %u\n", block->sample_rate, blockcopy->sample_rate);
+		return false;
+	}
+	if(blockcopy->channels != block->channels) {
+		printf("FAILED, channels mismatch, expected %u, got %u\n", block->channels, blockcopy->channels);
+		return false;
+	}
+	if(blockcopy->bits_per_sample != block->bits_per_sample) {
+		printf("FAILED, bits_per_sample mismatch, expected %u, got %u\n", block->bits_per_sample, blockcopy->bits_per_sample);
+		return false;
+	}
+	if(blockcopy->total_samples != block->total_samples) {
+#ifdef _MSC_VER
+		printf("FAILED, total_samples mismatch, expected %I64u, got %I64u\n", block->total_samples, blockcopy->total_samples);
+#else
+		printf("FAILED, total_samples mismatch, expected %llu, got %llu\n", (unsigned long long)block->total_samples, (unsigned long long)blockcopy->total_samples);
+#endif
+		return false;
+	}
+	if(0 != memcmp(blockcopy->md5sum, block->md5sum, sizeof(block->md5sum))) {
+		printf("FAILED, md5sum mismatch, expected %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X, got %02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X\n",
+			(unsigned)block->md5sum[0],
+			(unsigned)block->md5sum[1],
+			(unsigned)block->md5sum[2],
+			(unsigned)block->md5sum[3],
+			(unsigned)block->md5sum[4],
+			(unsigned)block->md5sum[5],
+			(unsigned)block->md5sum[6],
+			(unsigned)block->md5sum[7],
+			(unsigned)block->md5sum[8],
+			(unsigned)block->md5sum[9],
+			(unsigned)block->md5sum[10],
+			(unsigned)block->md5sum[11],
+			(unsigned)block->md5sum[12],
+			(unsigned)block->md5sum[13],
+			(unsigned)block->md5sum[14],
+			(unsigned)block->md5sum[15],
+			(unsigned)blockcopy->md5sum[0],
+			(unsigned)blockcopy->md5sum[1],
+			(unsigned)blockcopy->md5sum[2],
+			(unsigned)blockcopy->md5sum[3],
+			(unsigned)blockcopy->md5sum[4],
+			(unsigned)blockcopy->md5sum[5],
+			(unsigned)blockcopy->md5sum[6],
+			(unsigned)blockcopy->md5sum[7],
+			(unsigned)blockcopy->md5sum[8],
+			(unsigned)blockcopy->md5sum[9],
+			(unsigned)blockcopy->md5sum[10],
+			(unsigned)blockcopy->md5sum[11],
+			(unsigned)blockcopy->md5sum[12],
+			(unsigned)blockcopy->md5sum[13],
+			(unsigned)blockcopy->md5sum[14],
+			(unsigned)blockcopy->md5sum[15]
+		);
+		return false;
+	}
+	return true;
+}
+
+FLAC__bool mutils__compare_block_data_padding(const FLAC__StreamMetadata_Padding *block, const FLAC__StreamMetadata_Padding *blockcopy, unsigned block_length)
+{
+	/* we don't compare the padding guts */
+	(void)block, (void)blockcopy, (void)block_length;
+	return true;
+}
+
+FLAC__bool mutils__compare_block_data_application(const FLAC__StreamMetadata_Application *block, const FLAC__StreamMetadata_Application *blockcopy, unsigned block_length)
+{
+	if(block_length < sizeof(block->id)) {
+		printf("FAILED, bad block length = %u\n", block_length);
+		return false;
+	}
+	if(0 != memcmp(blockcopy->id, block->id, sizeof(block->id))) {
+		printf("FAILED, id mismatch, expected %02X%02X%02X%02X, got %02X%02X%02X%02X\n",
+			(unsigned)block->id[0],
+			(unsigned)block->id[1],
+			(unsigned)block->id[2],
+			(unsigned)block->id[3],
+			(unsigned)blockcopy->id[0],
+			(unsigned)blockcopy->id[1],
+			(unsigned)blockcopy->id[2],
+			(unsigned)blockcopy->id[3]
+		);
+		return false;
+	}
+	if(0 == block->data || 0 == blockcopy->data) {
+		if(block->data != blockcopy->data) {
+			printf("FAILED, data mismatch (%s's data pointer is null)\n", 0==block->data?"original":"copy");
+			return false;
+		}
+		else if(block_length - sizeof(block->id) > 0) {
+			printf("FAILED, data pointer is null but block length is not 0\n");
+			return false;
+		}
+	}
+	else {
+		if(block_length - sizeof(block->id) == 0) {
+			printf("FAILED, data pointer is not null but block length is 0\n");
+			return false;
+		}
+		else if(0 != memcmp(blockcopy->data, block->data, block_length - sizeof(block->id))) {
+			printf("FAILED, data mismatch\n");
+			return false;
+		}
+	}
+	return true;
+}
+
+FLAC__bool mutils__compare_block_data_seektable(const FLAC__StreamMetadata_SeekTable *block, const FLAC__StreamMetadata_SeekTable *blockcopy)
+{
+	unsigned i;
+	if(blockcopy->num_points != block->num_points) {
+		printf("FAILED, num_points mismatch, expected %u, got %u\n", block->num_points, blockcopy->num_points);
+		return false;
+	}
+	for(i = 0; i < block->num_points; i++) {
+		if(blockcopy->points[i].sample_number != block->points[i].sample_number) {
+#ifdef _MSC_VER
+			printf("FAILED, points[%u].sample_number mismatch, expected %I64u, got %I64u\n", i, block->points[i].sample_number, blockcopy->points[i].sample_number);
+#else
+			printf("FAILED, points[%u].sample_number mismatch, expected %llu, got %llu\n", i, (unsigned long long)block->points[i].sample_number, (unsigned long long)blockcopy->points[i].sample_number);
+#endif
+			return false;
+		}
+		if(blockcopy->points[i].stream_offset != block->points[i].stream_offset) {
+#ifdef _MSC_VER
+			printf("FAILED, points[%u].stream_offset mismatch, expected %I64u, got %I64u\n", i, block->points[i].stream_offset, blockcopy->points[i].stream_offset);
+#else
+			printf("FAILED, points[%u].stream_offset mismatch, expected %llu, got %llu\n", i, (unsigned long long)block->points[i].stream_offset, (unsigned long long)blockcopy->points[i].stream_offset);
+#endif
+			return false;
+		}
+		if(blockcopy->points[i].frame_samples != block->points[i].frame_samples) {
+			printf("FAILED, points[%u].frame_samples mismatch, expected %u, got %u\n", i, block->points[i].frame_samples, blockcopy->points[i].frame_samples);
+			return false;
+		}
+	}
+	return true;
+}
+
+FLAC__bool mutils__compare_block_data_vorbiscomment(const FLAC__StreamMetadata_VorbisComment *block, const FLAC__StreamMetadata_VorbisComment *blockcopy)
+{
+	unsigned i;
+	if(blockcopy->vendor_string.length != block->vendor_string.length) {
+		printf("FAILED, vendor_string.length mismatch, expected %u, got %u\n", block->vendor_string.length, blockcopy->vendor_string.length);
+		return false;
+	}
+	if(0 == block->vendor_string.entry || 0 == blockcopy->vendor_string.entry) {
+		if(block->vendor_string.entry != blockcopy->vendor_string.entry) {
+			printf("FAILED, vendor_string.entry mismatch\n");
+			return false;
+		}
+	}
+	else if(0 != memcmp(blockcopy->vendor_string.entry, block->vendor_string.entry, block->vendor_string.length)) {
+		printf("FAILED, vendor_string.entry mismatch\n");
+		return false;
+	}
+	if(blockcopy->num_comments != block->num_comments) {
+		printf("FAILED, num_comments mismatch, expected %u, got %u\n", block->num_comments, blockcopy->num_comments);
+		return false;
+	}
+	for(i = 0; i < block->num_comments; i++) {
+		if(blockcopy->comments[i].length != block->comments[i].length) {
+			printf("FAILED, comments[%u].length mismatch, expected %u, got %u\n", i, block->comments[i].length, blockcopy->comments[i].length);
+			return false;
+		}
+		if(0 == block->comments[i].entry || 0 == blockcopy->comments[i].entry) {
+			if(block->comments[i].entry != blockcopy->comments[i].entry) {
+				printf("FAILED, comments[%u].entry mismatch\n", i);
+				return false;
+			}
+		}
+		else {
+			if(0 != memcmp(blockcopy->comments[i].entry, block->comments[i].entry, block->comments[i].length)) {
+				printf("FAILED, comments[%u].entry mismatch\n", i);
+				return false;
+			}
+		}
+	}
+	return true;
+}
+
+FLAC__bool mutils__compare_block_data_cuesheet(const FLAC__StreamMetadata_CueSheet *block, const FLAC__StreamMetadata_CueSheet *blockcopy)
+{
+	unsigned i, j;
+
+	if(0 != strcmp(blockcopy->media_catalog_number, block->media_catalog_number)) {
+		printf("FAILED, media_catalog_number mismatch, expected %s, got %s\n", block->media_catalog_number, blockcopy->media_catalog_number);
+		return false;
+	}
+	if(blockcopy->lead_in != block->lead_in) {
+#ifdef _MSC_VER
+		printf("FAILED, lead_in mismatch, expected %I64u, got %I64u\n", block->lead_in, blockcopy->lead_in);
+#else
+		printf("FAILED, lead_in mismatch, expected %llu, got %llu\n", (unsigned long long)block->lead_in, (unsigned long long)blockcopy->lead_in);
+#endif
+		return false;
+	}
+	if(blockcopy->is_cd != block->is_cd) {
+		printf("FAILED, is_cd mismatch, expected %u, got %u\n", (unsigned)block->is_cd, (unsigned)blockcopy->is_cd);
+		return false;
+	}
+	if(blockcopy->num_tracks != block->num_tracks) {
+		printf("FAILED, num_tracks mismatch, expected %u, got %u\n", block->num_tracks, blockcopy->num_tracks);
+		return false;
+	}
+	for(i = 0; i < block->num_tracks; i++) {
+		if(blockcopy->tracks[i].offset != block->tracks[i].offset) {
+#ifdef _MSC_VER
+			printf("FAILED, tracks[%u].offset mismatch, expected %I64u, got %I64u\n", i, block->tracks[i].offset, blockcopy->tracks[i].offset);
+#else
+			printf("FAILED, tracks[%u].offset mismatch, expected %llu, got %llu\n", i, (unsigned long long)block->tracks[i].offset, (unsigned long long)blockcopy->tracks[i].offset);
+#endif
+			return false;
+		}
+		if(blockcopy->tracks[i].number != block->tracks[i].number) {
+			printf("FAILED, tracks[%u].number mismatch, expected %u, got %u\n", i, (unsigned)block->tracks[i].number, (unsigned)blockcopy->tracks[i].number);
+			return false;
+		}
+		if(blockcopy->tracks[i].num_indices != block->tracks[i].num_indices) {
+			printf("FAILED, tracks[%u].num_indices mismatch, expected %u, got %u\n", i, (unsigned)block->tracks[i].num_indices, (unsigned)blockcopy->tracks[i].num_indices);
+			return false;
+		}
+		/* num_indices == 0 means lead-out track so only the track offset and number are valid */
+		if(block->tracks[i].num_indices > 0) {
+			if(0 != strcmp(blockcopy->tracks[i].isrc, block->tracks[i].isrc)) {
+				printf("FAILED, tracks[%u].isrc mismatch, expected %s, got %s\n", i, block->tracks[i].isrc, blockcopy->tracks[i].isrc);
+				return false;
+			}
+			if(blockcopy->tracks[i].type != block->tracks[i].type) {
+				printf("FAILED, tracks[%u].type mismatch, expected %u, got %u\n", i, (unsigned)block->tracks[i].type, (unsigned)blockcopy->tracks[i].type);
+				return false;
+			}
+			if(blockcopy->tracks[i].pre_emphasis != block->tracks[i].pre_emphasis) {
+				printf("FAILED, tracks[%u].pre_emphasis mismatch, expected %u, got %u\n", i, (unsigned)block->tracks[i].pre_emphasis, (unsigned)blockcopy->tracks[i].pre_emphasis);
+				return false;
+			}
+			if(0 == block->tracks[i].indices || 0 == blockcopy->tracks[i].indices) {
+				if(block->tracks[i].indices != blockcopy->tracks[i].indices) {
+					printf("FAILED, tracks[%u].indices mismatch\n", i);
+					return false;
+				}
+			}
+			else {
+				for(j = 0; j < block->tracks[i].num_indices; j++) {
+					if(blockcopy->tracks[i].indices[j].offset != block->tracks[i].indices[j].offset) {
+#ifdef _MSC_VER
+						printf("FAILED, tracks[%u].indices[%u].offset mismatch, expected %I64u, got %I64u\n", i, j, block->tracks[i].indices[j].offset, blockcopy->tracks[i].indices[j].offset);
+#else
+						printf("FAILED, tracks[%u].indices[%u].offset mismatch, expected %llu, got %llu\n", i, j, (unsigned long long)block->tracks[i].indices[j].offset, (unsigned long long)blockcopy->tracks[i].indices[j].offset);
+#endif
+						return false;
+					}
+					if(blockcopy->tracks[i].indices[j].number != block->tracks[i].indices[j].number) {
+						printf("FAILED, tracks[%u].indices[%u].number mismatch, expected %u, got %u\n", i, j, (unsigned)block->tracks[i].indices[j].number, (unsigned)blockcopy->tracks[i].indices[j].number);
+						return false;
+					}
+				}
+			}
+		}
+	}
+	return true;
+}
+
+FLAC__bool mutils__compare_block_data_picture(const FLAC__StreamMetadata_Picture *block, const FLAC__StreamMetadata_Picture *blockcopy)
+{
+	size_t len, lencopy;
+	if(blockcopy->type != block->type) {
+		printf("FAILED, type mismatch, expected %u, got %u\n", (unsigned)block->type, (unsigned)blockcopy->type);
+		return false;
+	}
+	len = strlen(block->mime_type);
+	lencopy = strlen(blockcopy->mime_type);
+	if(lencopy != len) {
+		printf("FAILED, mime_type length mismatch, expected %u, got %u\n", (unsigned)len, (unsigned)lencopy);
+		return false;
+	}
+	if(strcmp(blockcopy->mime_type, block->mime_type)) {
+		printf("FAILED, mime_type mismatch, expected %s, got %s\n", block->mime_type, blockcopy->mime_type);
+		return false;
+	}
+	len = strlen((const char *)block->description);
+	lencopy = strlen((const char *)blockcopy->description);
+	if(lencopy != len) {
+		printf("FAILED, description length mismatch, expected %u, got %u\n", (unsigned)len, (unsigned)lencopy);
+		return false;
+	}
+	if(strcmp((const char *)blockcopy->description, (const char *)block->description)) {
+		printf("FAILED, description mismatch, expected %s, got %s\n", block->description, blockcopy->description);
+		return false;
+	}
+	if(blockcopy->width != block->width) {
+		printf("FAILED, width mismatch, expected %u, got %u\n", block->width, blockcopy->width);
+		return false;
+	}
+	if(blockcopy->height != block->height) {
+		printf("FAILED, height mismatch, expected %u, got %u\n", block->height, blockcopy->height);
+		return false;
+	}
+	if(blockcopy->depth != block->depth) {
+		printf("FAILED, depth mismatch, expected %u, got %u\n", block->depth, blockcopy->depth);
+		return false;
+	}
+	if(blockcopy->colors != block->colors) {
+		printf("FAILED, colors mismatch, expected %u, got %u\n", block->colors, blockcopy->colors);
+		return false;
+	}
+	if(blockcopy->data_length != block->data_length) {
+		printf("FAILED, data_length mismatch, expected %u, got %u\n", block->data_length, blockcopy->data_length);
+		return false;
+	}
+	if(memcmp(blockcopy->data, block->data, block->data_length)) {
+		printf("FAILED, data mismatch\n");
+		return false;
+	}
+	return true;
+}
+
+FLAC__bool mutils__compare_block_data_unknown(const FLAC__StreamMetadata_Unknown *block, const FLAC__StreamMetadata_Unknown *blockcopy, unsigned block_length)
+{
+	if(0 == block->data || 0 == blockcopy->data) {
+		if(block->data != blockcopy->data) {
+			printf("FAILED, data mismatch (%s's data pointer is null)\n", 0==block->data?"original":"copy");
+			return false;
+		}
+		else if(block_length > 0) {
+			printf("FAILED, data pointer is null but block length is not 0\n");
+			return false;
+		}
+	}
+	else {
+		if(block_length == 0) {
+			printf("FAILED, data pointer is not null but block length is 0\n");
+			return false;
+		}
+		else if(0 != memcmp(blockcopy->data, block->data, block_length)) {
+			printf("FAILED, data mismatch\n");
+			return false;
+		}
+	}
+	return true;
+}
+
+FLAC__bool mutils__compare_block(const FLAC__StreamMetadata *block, const FLAC__StreamMetadata *blockcopy)
+{
+	if(blockcopy->type != block->type) {
+		printf("FAILED, type mismatch, expected %s, got %s\n", FLAC__MetadataTypeString[block->type], FLAC__MetadataTypeString[blockcopy->type]);
+		return false;
+	}
+	if(blockcopy->is_last != block->is_last) {
+		printf("FAILED, is_last mismatch, expected %u, got %u\n", (unsigned)block->is_last, (unsigned)blockcopy->is_last);
+		return false;
+	}
+	if(blockcopy->length != block->length) {
+		printf("FAILED, length mismatch, expected %u, got %u\n", block->length, blockcopy->length);
+		return false;
+	}
+	switch(block->type) {
+		case FLAC__METADATA_TYPE_STREAMINFO:
+			return mutils__compare_block_data_streaminfo(&block->data.stream_info, &blockcopy->data.stream_info);
+		case FLAC__METADATA_TYPE_PADDING:
+			return mutils__compare_block_data_padding(&block->data.padding, &blockcopy->data.padding, block->length);
+		case FLAC__METADATA_TYPE_APPLICATION:
+			return mutils__compare_block_data_application(&block->data.application, &blockcopy->data.application, block->length);
+		case FLAC__METADATA_TYPE_SEEKTABLE:
+			return mutils__compare_block_data_seektable(&block->data.seek_table, &blockcopy->data.seek_table);
+		case FLAC__METADATA_TYPE_VORBIS_COMMENT:
+			return mutils__compare_block_data_vorbiscomment(&block->data.vorbis_comment, &blockcopy->data.vorbis_comment);
+		case FLAC__METADATA_TYPE_CUESHEET:
+			return mutils__compare_block_data_cuesheet(&block->data.cue_sheet, &blockcopy->data.cue_sheet);
+		case FLAC__METADATA_TYPE_PICTURE:
+			return mutils__compare_block_data_picture(&block->data.picture, &blockcopy->data.picture);
+		default:
+			return mutils__compare_block_data_unknown(&block->data.unknown, &blockcopy->data.unknown, block->length);
+	}
+}
+
+static void *malloc_or_die_(size_t size)
+{
+	void *x = malloc(size);
+	if(0 == x) {
+		fprintf(stderr, "ERROR: out of memory allocating %u bytes\n", (unsigned)size);
+		exit(1);
+	}
+	return x;
+}
+
+static void *calloc_or_die_(size_t n, size_t size)
+{
+	void *x = calloc(n, size);
+	if(0 == x) {
+		fprintf(stderr, "ERROR: out of memory allocating %u bytes\n", (unsigned)n * (unsigned)size);
+		exit(1);
+	}
+	return x;
+}
+
+static char *strdup_or_die_(const char *s)
+{
+	char *x = strdup(s);
+	if(0 == x) {
+		fprintf(stderr, "ERROR: out of memory copying string \"%s\"\n", s);
+		exit(1);
+	}
+	return x;
+}
+
+void mutils__init_metadata_blocks(
+	FLAC__StreamMetadata *streaminfo,
+	FLAC__StreamMetadata *padding,
+	FLAC__StreamMetadata *seektable,
+	FLAC__StreamMetadata *application1,
+	FLAC__StreamMetadata *application2,
+	FLAC__StreamMetadata *vorbiscomment,
+	FLAC__StreamMetadata *cuesheet,
+	FLAC__StreamMetadata *picture,
+	FLAC__StreamMetadata *unknown
+)
+{
+	/*
+		most of the actual numbers and data in the blocks don't matter,
+		we just want to make sure the decoder parses them correctly
+
+		remember, the metadata interface gets tested after the decoders,
+		so we do all the metadata manipulation here without it.
+	*/
+
+	/* min/max_framesize and md5sum don't get written at first, so we have to leave them 0 */
+	streaminfo->is_last = false;
+	streaminfo->type = FLAC__METADATA_TYPE_STREAMINFO;
+	streaminfo->length = FLAC__STREAM_METADATA_STREAMINFO_LENGTH;
+	streaminfo->data.stream_info.min_blocksize = 576;
+	streaminfo->data.stream_info.max_blocksize = 576;
+	streaminfo->data.stream_info.min_framesize = 0;
+	streaminfo->data.stream_info.max_framesize = 0;
+	streaminfo->data.stream_info.sample_rate = 44100;
+	streaminfo->data.stream_info.channels = 1;
+	streaminfo->data.stream_info.bits_per_sample = 8;
+	streaminfo->data.stream_info.total_samples = 0;
+	memset(streaminfo->data.stream_info.md5sum, 0, 16);
+
+	padding->is_last = false;
+	padding->type = FLAC__METADATA_TYPE_PADDING;
+	padding->length = 1234;
+
+	seektable->is_last = false;
+	seektable->type = FLAC__METADATA_TYPE_SEEKTABLE;
+	seektable->data.seek_table.num_points = 2;
+	seektable->length = seektable->data.seek_table.num_points * FLAC__STREAM_METADATA_SEEKPOINT_LENGTH;
+	seektable->data.seek_table.points = (FLAC__StreamMetadata_SeekPoint*)malloc_or_die_(seektable->data.seek_table.num_points * sizeof(FLAC__StreamMetadata_SeekPoint));
+	seektable->data.seek_table.points[0].sample_number = 0;
+	seektable->data.seek_table.points[0].stream_offset = 0;
+	seektable->data.seek_table.points[0].frame_samples = streaminfo->data.stream_info.min_blocksize;
+	seektable->data.seek_table.points[1].sample_number = FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER;
+	seektable->data.seek_table.points[1].stream_offset = 1000;
+	seektable->data.seek_table.points[1].frame_samples = streaminfo->data.stream_info.min_blocksize;
+
+	application1->is_last = false;
+	application1->type = FLAC__METADATA_TYPE_APPLICATION;
+	application1->length = 8;
+	memcpy(application1->data.application.id, "\xfe\xdc\xba\x98", 4);
+	application1->data.application.data = (FLAC__byte*)malloc_or_die_(4);
+	memcpy(application1->data.application.data, "\xf0\xe1\xd2\xc3", 4);
+
+	application2->is_last = false;
+	application2->type = FLAC__METADATA_TYPE_APPLICATION;
+	application2->length = 4;
+	memcpy(application2->data.application.id, "\x76\x54\x32\x10", 4);
+	application2->data.application.data = 0;
+
+	{
+		const unsigned vendor_string_length = (unsigned)strlen(FLAC__VENDOR_STRING);
+		vorbiscomment->is_last = false;
+		vorbiscomment->type = FLAC__METADATA_TYPE_VORBIS_COMMENT;
+		vorbiscomment->length = (4 + vendor_string_length) + 4 + (4 + 5) + (4 + 0);
+		vorbiscomment->data.vorbis_comment.vendor_string.length = vendor_string_length;
+		vorbiscomment->data.vorbis_comment.vendor_string.entry = (FLAC__byte*)malloc_or_die_(vendor_string_length+1);
+		memcpy(vorbiscomment->data.vorbis_comment.vendor_string.entry, FLAC__VENDOR_STRING, vendor_string_length+1);
+		vorbiscomment->data.vorbis_comment.num_comments = 2;
+		vorbiscomment->data.vorbis_comment.comments = (FLAC__StreamMetadata_VorbisComment_Entry*)malloc_or_die_(vorbiscomment->data.vorbis_comment.num_comments * sizeof(FLAC__StreamMetadata_VorbisComment_Entry));
+		vorbiscomment->data.vorbis_comment.comments[0].length = 5;
+		vorbiscomment->data.vorbis_comment.comments[0].entry = (FLAC__byte*)malloc_or_die_(5+1);
+		memcpy(vorbiscomment->data.vorbis_comment.comments[0].entry, "ab=cd", 5+1);
+		vorbiscomment->data.vorbis_comment.comments[1].length = 0;
+		vorbiscomment->data.vorbis_comment.comments[1].entry = 0;
+	}
+
+	cuesheet->is_last = false;
+	cuesheet->type = FLAC__METADATA_TYPE_CUESHEET;
+	cuesheet->length =
+		/* cuesheet guts */
+		(
+			FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN +
+			FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN +
+			FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN +
+			FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN +
+			FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN
+		) / 8 +
+		/* 2 tracks */
+		3 * (
+			FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN +
+			FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN +
+			FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN +
+			FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN +
+			FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN +
+			FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN +
+			FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN
+		) / 8 +
+		/* 3 index points */
+		3 * (
+			FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN +
+			FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN +
+			FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN
+		) / 8
+	;
+	memset(cuesheet->data.cue_sheet.media_catalog_number, 0, sizeof(cuesheet->data.cue_sheet.media_catalog_number));
+	cuesheet->data.cue_sheet.media_catalog_number[0] = 'j';
+	cuesheet->data.cue_sheet.media_catalog_number[1] = 'C';
+	cuesheet->data.cue_sheet.lead_in = 2 * 44100;
+	cuesheet->data.cue_sheet.is_cd = true;
+	cuesheet->data.cue_sheet.num_tracks = 3;
+	cuesheet->data.cue_sheet.tracks = (FLAC__StreamMetadata_CueSheet_Track*)calloc_or_die_(cuesheet->data.cue_sheet.num_tracks, sizeof(FLAC__StreamMetadata_CueSheet_Track));
+	cuesheet->data.cue_sheet.tracks[0].offset = 0;
+	cuesheet->data.cue_sheet.tracks[0].number = 1;
+	memcpy(cuesheet->data.cue_sheet.tracks[0].isrc, "ACBDE1234567", sizeof(cuesheet->data.cue_sheet.tracks[0].isrc));
+	cuesheet->data.cue_sheet.tracks[0].type = 0;
+	cuesheet->data.cue_sheet.tracks[0].pre_emphasis = 1;
+	cuesheet->data.cue_sheet.tracks[0].num_indices = 2;
+	cuesheet->data.cue_sheet.tracks[0].indices = (FLAC__StreamMetadata_CueSheet_Index*)malloc_or_die_(cuesheet->data.cue_sheet.tracks[0].num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index));
+	cuesheet->data.cue_sheet.tracks[0].indices[0].offset = 0;
+	cuesheet->data.cue_sheet.tracks[0].indices[0].number = 0;
+	cuesheet->data.cue_sheet.tracks[0].indices[1].offset = 123 * 588;
+	cuesheet->data.cue_sheet.tracks[0].indices[1].number = 1;
+	cuesheet->data.cue_sheet.tracks[1].offset = 1234 * 588;
+	cuesheet->data.cue_sheet.tracks[1].number = 2;
+	memcpy(cuesheet->data.cue_sheet.tracks[1].isrc, "ACBDE7654321", sizeof(cuesheet->data.cue_sheet.tracks[1].isrc));
+	cuesheet->data.cue_sheet.tracks[1].type = 1;
+	cuesheet->data.cue_sheet.tracks[1].pre_emphasis = 0;
+	cuesheet->data.cue_sheet.tracks[1].num_indices = 1;
+	cuesheet->data.cue_sheet.tracks[1].indices = (FLAC__StreamMetadata_CueSheet_Index*)malloc_or_die_(cuesheet->data.cue_sheet.tracks[1].num_indices * sizeof(FLAC__StreamMetadata_CueSheet_Index));
+	cuesheet->data.cue_sheet.tracks[1].indices[0].offset = 0;
+	cuesheet->data.cue_sheet.tracks[1].indices[0].number = 1;
+	cuesheet->data.cue_sheet.tracks[2].offset = 12345 * 588;
+	cuesheet->data.cue_sheet.tracks[2].number = 170;
+	cuesheet->data.cue_sheet.tracks[2].num_indices = 0;
+
+	picture->is_last = false;
+	picture->type = FLAC__METADATA_TYPE_PICTURE;
+	picture->length =
+		(
+			FLAC__STREAM_METADATA_PICTURE_TYPE_LEN +
+			FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN + /* will add the length for the string later */
+			FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN + /* will add the length for the string later */
+			FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN +
+			FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN +
+			FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN +
+			FLAC__STREAM_METADATA_PICTURE_COLORS_LEN +
+			FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN /* will add the length for the data later */
+		) / 8
+	;
+	picture->data.picture.type = FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER;
+	picture->data.picture.mime_type = strdup_or_die_("image/jpeg");
+	picture->length += strlen(picture->data.picture.mime_type);
+	picture->data.picture.description = (FLAC__byte*)strdup_or_die_("desc");
+	picture->length += strlen((const char *)picture->data.picture.description);
+	picture->data.picture.width = 300;
+	picture->data.picture.height = 300;
+	picture->data.picture.depth = 24;
+	picture->data.picture.colors = 0;
+	picture->data.picture.data = (FLAC__byte*)strdup_or_die_("SOMEJPEGDATA");
+	picture->data.picture.data_length = strlen((const char *)picture->data.picture.data);
+	picture->length += picture->data.picture.data_length;
+
+	unknown->is_last = true;
+	unknown->type = 126;
+	unknown->length = 8;
+	unknown->data.unknown.data = (FLAC__byte*)malloc_or_die_(unknown->length);
+	memcpy(unknown->data.unknown.data, "\xfe\xdc\xba\x98\xf0\xe1\xd2\xc3", unknown->length);
+}
+
+void mutils__free_metadata_blocks(
+	FLAC__StreamMetadata *streaminfo,
+	FLAC__StreamMetadata *padding,
+	FLAC__StreamMetadata *seektable,
+	FLAC__StreamMetadata *application1,
+	FLAC__StreamMetadata *application2,
+	FLAC__StreamMetadata *vorbiscomment,
+	FLAC__StreamMetadata *cuesheet,
+	FLAC__StreamMetadata *picture,
+	FLAC__StreamMetadata *unknown
+)
+{
+	(void)streaminfo, (void)padding, (void)application2;
+	free(seektable->data.seek_table.points);
+	free(application1->data.application.data);
+	free(vorbiscomment->data.vorbis_comment.vendor_string.entry);
+	free(vorbiscomment->data.vorbis_comment.comments[0].entry);
+	free(vorbiscomment->data.vorbis_comment.comments);
+	free(cuesheet->data.cue_sheet.tracks[0].indices);
+	free(cuesheet->data.cue_sheet.tracks[1].indices);
+	free(cuesheet->data.cue_sheet.tracks);
+	free(picture->data.picture.mime_type);
+	free(picture->data.picture.description);
+	free(picture->data.picture.data);
+	free(unknown->data.unknown.data);
+}
diff --git a/audio-codec/flac/test_libs_common/test_libs_common_static.dsp b/audio-codec/flac/test_libs_common/test_libs_common_static.dsp
new file mode 100644
index 0000000..3989317
--- /dev/null
+++ b/audio-codec/flac/test_libs_common/test_libs_common_static.dsp
@@ -0,0 +1,108 @@
+# Microsoft Developer Studio Project File - Name="test_libs_common_static" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=test_libs_common_static - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "test_libs_common_static.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "test_libs_common_static.mak" CFG="test_libs_common_static - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "test_libs_common_static - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "test_libs_common_static - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName "test_libs_common"
+# PROP Scc_LocalPath "..\.."
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "test_libs_common_static - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "..\..\obj\release\lib"
+# PROP Intermediate_Dir "Release_static"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /Op /I ".\include" /I "..\..\include" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /nodefaultlib
+
+!ELSEIF  "$(CFG)" == "test_libs_common_static - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "..\..\obj\debug\lib"
+# PROP Intermediate_Dir "Debug_static"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I ".\include" /I "..\..\include" /D "WIN32" /D "_DEBUG" /D "DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /nodefaultlib
+
+!ENDIF 
+
+# Begin Target
+
+# Name "test_libs_common_static - Win32 Release"
+# Name "test_libs_common_static - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "c"
+# Begin Source File
+
+SOURCE=.\file_utils_flac.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\metadata_utils.c
+# End Source File
+# End Group
+# Begin Group "Public Header Files"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\include\test_libs_common\file_utils_flac.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\include\test_libs_common\metadata_utils.h
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/audio-codec/flac/test_libs_common/test_libs_common_static.vcproj b/audio-codec/flac/test_libs_common/test_libs_common_static.vcproj
new file mode 100644
index 0000000..b1c9074
--- /dev/null
+++ b/audio-codec/flac/test_libs_common/test_libs_common_static.vcproj
@@ -0,0 +1,177 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="test_libs_common_static"
+	ProjectGUID="{4cefbc8e-c215-11db-8314-0800200c9a66}"
+	RootNamespace="test_libs_common_static"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="..\..\obj\debug\lib"
+			IntermediateDirectory="Debug_static"
+			ConfigurationType="4"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories=".\include;..\..\include"
+				PreprocessorDefinitions="WIN32;_DEBUG;_LIB;FLAC__NO_DLL;DEBUG"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+				CompileAs="0"
+				DisableSpecificWarnings="4267;4996"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="..\..\obj\debug\lib\$(ProjectName).lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="..\..\obj\release\lib"
+			IntermediateDirectory="Release_static"
+			ConfigurationType="4"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				EnableIntrinsicFunctions="true"
+				FavorSizeOrSpeed="1"
+				OmitFramePointers="true"
+				WholeProgramOptimization="true"
+				AdditionalIncludeDirectories=".\include;..\..\include"
+				PreprocessorDefinitions="WIN32;NDEBUG;_LIB;FLAC__NO_DLL"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="false"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+				CompileAs="0"
+				DisableSpecificWarnings="4267;4996"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="..\..\..\obj\release\lib\$(ProjectName).lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath=".\file_utils_flac.c"
+				>
+			</File>
+			<File
+				RelativePath=".\metadata_utils.c"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/audio-codec/mp3dec/Android.mk b/audio-codec/mp3dec/Android.mk
new file mode 100644
index 0000000..f1c2e48
--- /dev/null
+++ b/audio-codec/mp3dec/Android.mk
@@ -0,0 +1,23 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+        mp3dec_test.cpp  \
+        mp3reader.cpp
+
+LOCAL_C_INCLUDES := \
+        frameworks/av/media/libstagefright/codecs/mp3dec/include \
+        frameworks/av/media/libstagefright/codecs/mp3dec/src \
+        $(call include-path-for, audio-utils)
+
+LOCAL_STATIC_LIBRARIES := \
+        libc libstagefright_mp3dec libsndfile libaudioprimitives
+
+LOCAL_MODULE := libstagefright_mp3dec_test
+LOCAL_MODULE_TAGS := optional tests
+
+LOCAL_MULTILIB := 32
+
+LOCAL_FORCE_STATIC_EXECUTABLE := true
+
+include $(BUILD_EXECUTABLE)
diff --git a/audio-codec/mp3dec/README b/audio-codec/mp3dec/README
new file mode 100644
index 0000000..028b584
--- /dev/null
+++ b/audio-codec/mp3dec/README
@@ -0,0 +1,6 @@
+The test media is the song "Retribution" by Tanner Helland in MPEG-3 format.
+
+The song was obtained from the following site:
+	http://www.tannerhelland.com/52/song-retribution/
+under the Create Commons Attribution-ShareAlike 3.0 License (for more info,
+please visit http://www.tannerhelland.com/52/song-retribution/)
diff --git a/audio-codec/mp3dec/Retribution.mp3 b/audio-codec/mp3dec/Retribution.mp3
new file mode 100644
index 0000000..c266ac2
--- /dev/null
+++ b/audio-codec/mp3dec/Retribution.mp3
diff --git a/audio-codec/mp3dec/mp3dec_test.cpp b/audio-codec/mp3dec/mp3dec_test.cpp
new file mode 100644
index 0000000..8cbbc97
--- /dev/null
+++ b/audio-codec/mp3dec/mp3dec_test.cpp
@@ -0,0 +1,203 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include <string.h>
+#include <time.h>
+
+#include "pvmp3decoder_api.h"
+#include "mp3reader.h"
+#include <audio_utils/sndfile.h>
+
+using namespace std;
+
+enum {
+        kInputBufferSize = 10 * 1024,
+        kOutputBufferSize = 4608 * 2,
+    };
+
+struct timespec timespec_diff(struct timespec *start, struct timespec *end){
+    struct timespec diff;
+    if((end->tv_nsec-start->tv_nsec) < 0){
+        diff.tv_sec=end->tv_sec-start->tv_sec-1;
+        diff.tv_nsec=1000000000+end->tv_nsec-start->tv_nsec;
+    } else {
+        diff.tv_sec=end->tv_sec-start->tv_sec;
+        diff.tv_nsec=end->tv_nsec-start->tv_nsec;
+    }
+    return diff;
+}
+
+int main(int argc, const char **argv) {
+
+    if(argc != 3) {
+        fprintf(stderr, "Usage %s <input file> <output file>\n", argv[0]);
+        return 1;
+    }
+
+    // Initialize the config
+    tPVMP3DecoderExternal config;
+    config.equalizerType = flat;
+    config.crcEnabled = false;
+
+    // Allocate the decoder memory
+    void *decoderBuf;
+    uint32_t memRequirements = pvmp3_decoderMemRequirements();
+    decoderBuf = malloc(memRequirements);
+    assert(decoderBuf != NULL);
+
+    // Initialize the decoder
+    pvmp3_InitDecoder(&config, decoderBuf);
+
+    // Open the input file
+    Mp3Reader mp3Reader;
+    bool success = mp3Reader.init(argv[1]);
+    if(!success) {
+        fprintf(stderr, "Encountered error reading %s \n", argv[1]);
+        return 1;
+    }
+
+    // Open the output file
+    SF_INFO sfInfo;
+    memset(&sfInfo, 0, sizeof(SF_INFO));
+    sfInfo.channels = mp3Reader.getNumChannels();
+    sfInfo.format = SF_FORMAT_WAV | SF_FORMAT_PCM_16;
+    sfInfo.samplerate = mp3Reader.getSampleRate();
+    SNDFILE *handle = sf_open(argv[2], SFM_WRITE, &sfInfo);
+    if(!handle) {
+        fprintf(stderr, "Encountered error writing %s \n", argv[2]);
+        return 1;
+    }
+
+    //Allocate input buffer
+    uint8_t *inputBuf = static_cast<uint8_t*>(malloc(kInputBufferSize));
+    assert(inputBuf != NULL);
+
+    //Allocate output buffer
+    int16_t *outputBuf = static_cast<int16_t*>(malloc(kOutputBufferSize));
+    assert(outputBuf != NULL);
+
+    // Track the total time it took to decode
+    struct timespec start_time;
+    struct timespec end_time;
+    if(clock_gettime(CLOCK_MONOTONIC, &start_time))
+        fprintf(stderr, "Failed to get start time for profiling\n");
+
+    //Decode loop
+    int retVal = 0;
+    while(1)
+    {
+        //Read input from the file
+        uint32_t bytesRead;
+        bool success = mp3Reader.getFrame(inputBuf, &bytesRead);
+        if(!success) break;
+
+        //Set the input config
+        config.inputBufferCurrentLength = bytesRead;
+        config.inputBufferMaxLength = 0;
+        config.inputBufferUsedLength = 0;
+        config.pInputBuffer  = inputBuf;
+        config.pOutputBuffer = outputBuf;
+        config.outputFrameSize = kOutputBufferSize / sizeof(int16_t);
+
+        ERROR_CODE decoderErr;
+        decoderErr = pvmp3_framedecoder(&config, decoderBuf);
+        if(decoderErr != NO_DECODING_ERROR) {
+            fprintf(stderr, "Decoder encountered error\n");
+            retVal = 1;
+            break;
+        }
+        sf_writef_short(handle, outputBuf,
+                        config.outputFrameSize / sfInfo.channels);
+    }
+
+    if(clock_gettime(CLOCK_MONOTONIC,&end_time)){
+        fprintf(stderr, "Failed to get end time for profiling\n");
+    }else{
+        struct timespec diff=timespec_diff(&start_time,&end_time);
+        fprintf(stderr, "Total decode time: %ld.%09ld seconds\n", diff.tv_sec,
+                diff.tv_nsec);
+    }
+
+    //Verify the output WAV file
+    sf_close(handle);
+    memset(&sfInfo, 0, sizeof(SF_INFO));
+    handle = sf_open(argv[2], SFM_READ, &sfInfo);
+
+    fprintf(stderr, "Decoded WAV file info:\n");
+    fprintf(stderr, "\tNumber of frames: %d\n", sfInfo.frames);
+    fprintf(stderr, "\tSample rate:      %d\n", sfInfo.samplerate);
+    fprintf(stderr, "\tChannels:         %d\n", sfInfo.channels);
+
+    int16_t *min = static_cast<int16_t*>(calloc(1, sfInfo.channels *
+                                                   sizeof(int16_t)));
+    assert(min != NULL);
+    int16_t *max = static_cast<int16_t*>(calloc(1, sfInfo.channels *
+                                                   sizeof(int16_t)));
+    assert(max != NULL);
+
+    while(1){
+        static int total_frames = 0;
+        sf_count_t frames;
+
+        frames = sf_readf_short(handle, outputBuf,
+                                sizeof(outputBuf) / sizeof(int16_t) /
+                                sfInfo.channels);
+        if(!frames){
+            fprintf(stderr, "Decoded %d frames\n", total_frames);
+            for(int j = 0; j < sfInfo.channels; j++)
+                fprintf(stderr, "Channel %d: min=%d max=%d\n", j, min[j], max[j]);
+            break;
+        }
+        total_frames += frames;
+
+        for(int i = 0; i < frames; i++){
+            for(int j = 0; j < sfInfo.channels; j++){
+                if ( outputBuf[i*j] > max[j])
+                    max[j] = outputBuf[i*j];
+                if ( outputBuf[i*j] < min[j])
+                    min[j] = outputBuf[i*j];
+            }
+        }
+    }
+    free(min);
+    free(max);
+
+    //Close input reader and output writer
+    mp3Reader.close();
+    sf_close(handle);
+
+    //Free allocated memory
+    free(inputBuf);
+    free(outputBuf);
+    free(decoderBuf);
+
+    return retVal;
+}
diff --git a/audio-codec/mp3dec/mp3reader.cpp b/audio-codec/mp3dec/mp3reader.cpp
new file mode 100644
index 0000000..db6d3a0
--- /dev/null
+++ b/audio-codec/mp3dec/mp3reader.cpp
@@ -0,0 +1,430 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include <string.h>
+#include <stdint.h>
+#include "mp3reader.h"
+
+static uint32_t U32_AT(const uint8_t *ptr) {
+    return ptr[0] << 24 | ptr[1] << 16 | ptr[2] << 8 | ptr[3];
+}
+
+static bool parseHeader(
+        uint32_t header, size_t *frame_size,
+        uint32_t *out_sampling_rate = NULL, uint32_t *out_channels = NULL ,
+        uint32_t *out_bitrate = NULL, uint32_t *out_num_samples = NULL) {
+    *frame_size = 0;
+
+    if (out_sampling_rate) {
+        *out_sampling_rate = 0;
+    }
+
+    if (out_channels) {
+        *out_channels = 0;
+    }
+
+    if (out_bitrate) {
+        *out_bitrate = 0;
+    }
+
+    if (out_num_samples) {
+        *out_num_samples = 1152;
+    }
+
+    if ((header & 0xffe00000) != 0xffe00000) {
+        return false;
+    }
+
+    unsigned version = (header >> 19) & 3;
+
+    if (version == 0x01) {
+        return false;
+    }
+
+    unsigned layer = (header >> 17) & 3;
+
+    if (layer == 0x00) {
+        return false;
+    }
+
+    unsigned bitrate_index = (header >> 12) & 0x0f;
+
+    if (bitrate_index == 0 || bitrate_index == 0x0f) {
+        // Disallow "free" bitrate.
+        return false;
+    }
+
+    unsigned sampling_rate_index = (header >> 10) & 3;
+
+    if (sampling_rate_index == 3) {
+        return false;
+    }
+
+    static const int kSamplingRateV1[] = { 44100, 48000, 32000 };
+    int sampling_rate = kSamplingRateV1[sampling_rate_index];
+    if (version == 2 /* V2 */) {
+        sampling_rate /= 2;
+    } else if (version == 0 /* V2.5 */) {
+        sampling_rate /= 4;
+    }
+
+    unsigned padding = (header >> 9) & 1;
+
+    if (layer == 3) {
+        // layer I
+
+        static const int kBitrateV1[] = {
+            32, 64, 96, 128, 160, 192, 224, 256,
+            288, 320, 352, 384, 416, 448
+        };
+
+        static const int kBitrateV2[] = {
+            32, 48, 56, 64, 80, 96, 112, 128,
+            144, 160, 176, 192, 224, 256
+        };
+
+        int bitrate =
+            (version == 3 /* V1 */)
+                ? kBitrateV1[bitrate_index - 1]
+                : kBitrateV2[bitrate_index - 1];
+
+        if (out_bitrate) {
+            *out_bitrate = bitrate;
+        }
+
+        *frame_size = (12000 * bitrate / sampling_rate + padding) * 4;
+
+        if (out_num_samples) {
+            *out_num_samples = 384;
+        }
+    } else {
+        // layer II or III
+
+        static const int kBitrateV1L2[] = {
+            32, 48, 56, 64, 80, 96, 112, 128,
+            160, 192, 224, 256, 320, 384
+        };
+
+        static const int kBitrateV1L3[] = {
+            32, 40, 48, 56, 64, 80, 96, 112,
+            128, 160, 192, 224, 256, 320
+        };
+
+        static const int kBitrateV2[] = {
+            8, 16, 24, 32, 40, 48, 56, 64,
+            80, 96, 112, 128, 144, 160
+        };
+
+        int bitrate;
+        if (version == 3 /* V1 */) {
+            bitrate = (layer == 2 /* L2 */)
+                ? kBitrateV1L2[bitrate_index - 1]
+                : kBitrateV1L3[bitrate_index - 1];
+
+            if (out_num_samples) {
+                *out_num_samples = 1152;
+            }
+        } else {
+            // V2 (or 2.5)
+
+            bitrate = kBitrateV2[bitrate_index - 1];
+            if (out_num_samples) {
+                *out_num_samples = (layer == 1 /* L3 */) ? 576 : 1152;
+            }
+        }
+
+        if (out_bitrate) {
+            *out_bitrate = bitrate;
+        }
+
+        if (version == 3 /* V1 */) {
+            *frame_size = 144000 * bitrate / sampling_rate + padding;
+        } else {
+            // V2 or V2.5
+            size_t tmp = (layer == 1 /* L3 */) ? 72000 : 144000;
+            *frame_size = tmp * bitrate / sampling_rate + padding;
+        }
+    }
+
+    if (out_sampling_rate) {
+        *out_sampling_rate = sampling_rate;
+    }
+
+    if (out_channels) {
+        int channel_mode = (header >> 6) & 3;
+
+        *out_channels = (channel_mode == 3) ? 1 : 2;
+    }
+
+    return true;
+}
+
+// Mask to extract MP3 header's part that should be same
+// for all MP3 frames
+static const uint32_t kMask = 0xfffe0c00;
+
+static ssize_t sourceReadAt(FILE *fp, off64_t offset, void *data, size_t size) {
+    fseek(fp, offset, SEEK_SET);
+    return fread(data, 1, size, fp);
+}
+
+// Resync to next valid MP3 frame in the file
+static bool resync(
+        FILE *fp, uint32_t match_header,
+        off64_t *inout_pos, uint32_t *out_header) {
+
+    if (*inout_pos == 0) {
+        // Skip an optional ID3 header if syncing at the very beginning
+        // of the datasource.
+
+        for (;;) {
+            uint8_t id3header[10];
+            fseek(fp, *inout_pos, SEEK_SET);
+            int retVal = fread(id3header, 1, sizeof(id3header), fp);
+            if (retVal < (ssize_t)sizeof(id3header)) {
+                // If we can't even read these 10 bytes, we might as well bail
+                // out, even if there _were_ 10 bytes of valid mp3 audio data...
+                return false;
+            }
+
+            if (memcmp("ID3", id3header, 3)) {
+                break;
+            }
+
+            // Skip the ID3v2 header.
+
+            size_t len =
+                ((id3header[6] & 0x7f) << 21)
+                | ((id3header[7] & 0x7f) << 14)
+                | ((id3header[8] & 0x7f) << 7)
+                | (id3header[9] & 0x7f);
+
+            len += 10;
+
+            *inout_pos += len;
+        }
+
+    }
+
+    off64_t pos = *inout_pos;
+    bool valid = false;
+
+    const int32_t kMaxReadBytes = 1024;
+    const int32_t kMaxBytesChecked = 128 * 1024;
+    uint8_t buf[kMaxReadBytes];
+    ssize_t bytesToRead = kMaxReadBytes;
+    ssize_t totalBytesRead = 0;
+    ssize_t remainingBytes = 0;
+    bool reachEOS = false;
+    uint8_t *tmp = buf;
+
+    do {
+        if (pos >= *inout_pos + kMaxBytesChecked) {
+            // Don't scan forever.
+            break;
+        }
+
+        if (remainingBytes < 4) {
+            if (reachEOS) {
+                break;
+            } else {
+                memcpy(buf, tmp, remainingBytes);
+                bytesToRead = kMaxReadBytes - remainingBytes;
+
+                /*
+                 * The next read position should start from the end of
+                 * the last buffer, and thus should include the remaining
+                 * bytes in the buffer.
+                 */
+                fseek(fp, pos + remainingBytes, SEEK_SET);
+                totalBytesRead = fread(buf + remainingBytes, 1, bytesToRead, fp);
+
+                if (totalBytesRead <= 0) {
+                    break;
+                }
+                reachEOS = (totalBytesRead != bytesToRead);
+                totalBytesRead += remainingBytes;
+                remainingBytes = totalBytesRead;
+                tmp = buf;
+                continue;
+            }
+        }
+
+        uint32_t header = U32_AT(tmp);
+
+        if (match_header != 0 && (header & kMask) != (match_header & kMask)) {
+            ++pos;
+            ++tmp;
+            --remainingBytes;
+            continue;
+        }
+
+        size_t frame_size;
+        uint32_t sample_rate, num_channels, bitrate;
+        if (!parseHeader(
+                    header, &frame_size,
+                    &sample_rate, &num_channels, &bitrate)) {
+            ++pos;
+            ++tmp;
+            --remainingBytes;
+            continue;
+        }
+
+        // We found what looks like a valid frame,
+        // now find its successors.
+
+        off64_t test_pos = pos + frame_size;
+
+        valid = true;
+        for (int j = 0; j < 3; ++j) {
+            uint8_t tmp[4];
+            fseek(fp, test_pos, SEEK_SET);
+            int retval = fread(tmp, 1, 4, fp);
+            if (retval < 4) {
+                valid = false;
+                break;
+            }
+
+            uint32_t test_header = U32_AT(tmp);
+
+            if ((test_header & kMask) != (header & kMask)) {
+                valid = false;
+                break;
+            }
+
+            size_t test_frame_size;
+            if (!parseHeader(
+                        test_header, &test_frame_size)) {
+                valid = false;
+                break;
+            }
+
+            test_pos += test_frame_size;
+        }
+
+        if (valid) {
+            *inout_pos = pos;
+
+            if (out_header != NULL) {
+                *out_header = header;
+            }
+        } else {
+        }
+
+        ++pos;
+        ++tmp;
+        --remainingBytes;
+    } while (!valid);
+
+    return valid;
+}
+
+Mp3Reader::Mp3Reader() {
+    mFp = NULL;
+    mFixedHeader = 0;
+    mCurrentPos = 0;
+}
+
+// Initialize the MP3 reader
+bool Mp3Reader::init(const char *file) {
+
+    // Open the file
+    mFp = fopen(file, "rb");
+    if(mFp == NULL) return false;
+
+    // Sync to the first valid frame
+    {
+        off64_t pos = 0;
+        uint32_t header;
+        bool success = resync(mFp, 0, &pos, &header);
+        if(success == false) return false;
+
+        mCurrentPos  = pos;
+        mFixedHeader = header;
+
+        size_t frame_size;
+        parseHeader(header, &frame_size, &mSampleRate, &mNumChannels, &mBitrate);
+    }
+    return true;
+
+}
+
+// Get the next valid MP3 frame
+bool Mp3Reader::getFrame(void* buffer, uint32_t* size){
+
+    size_t frame_size;
+    uint32_t bitrate;
+    uint32_t num_samples;
+    uint32_t sample_rate;
+    for (;;) {
+        ssize_t n = sourceReadAt(mFp, mCurrentPos, buffer, 4);
+        if (n < 4) {
+            return false;
+        }
+
+        uint32_t header = U32_AT((const uint8_t *)buffer);
+
+        if ((header & kMask) == (mFixedHeader & kMask)
+            && parseHeader(
+                header, &frame_size, &sample_rate, NULL,
+                &bitrate, &num_samples)) {
+            break;
+        }
+
+        // Lost sync.
+        off64_t pos = mCurrentPos;
+        if (!resync(mFp, mFixedHeader, &pos, NULL)) {
+            // Unable to resync. Signalling end of stream
+            return false;
+        }
+
+        mCurrentPos = pos;
+
+        // Try again with the new position.
+    }
+    ssize_t n = sourceReadAt(mFp, mCurrentPos, buffer, frame_size);
+    if (n < (ssize_t)frame_size) {
+        return false;
+    }
+
+    *size = frame_size;
+    mCurrentPos += frame_size;
+    return true;
+}
+
+// Close the MP3 reader
+void Mp3Reader::close(){
+    assert(mFp != NULL);
+    fclose(mFp);
+}
+
+Mp3Reader::~Mp3Reader(){
+}
diff --git a/audio-codec/mp3dec/mp3reader.h b/audio-codec/mp3dec/mp3reader.h
new file mode 100644
index 0000000..140b664
--- /dev/null
+++ b/audio-codec/mp3dec/mp3reader.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef MP3READER_H_
+#define MP3READER_H_
+
+class Mp3Reader {
+public:
+    Mp3Reader();
+    bool init(const char *file);
+    bool getFrame(void* buffer, uint32_t* size);
+    uint32_t getSampleRate() { return mSampleRate;}
+    uint32_t getNumChannels() { return mNumChannels;}
+    void close();
+    ~Mp3Reader();
+private:
+    FILE    *mFp;
+    uint32_t mFixedHeader;
+    off64_t  mCurrentPos;
+    uint32_t mSampleRate;
+    uint32_t mNumChannels;
+    uint32_t mBitrate;
+};
+
+
+#endif /* MP3READER_H_ */
diff --git a/audio-codec/tremolo/Android.mk b/audio-codec/tremolo/Android.mk
new file mode 100644
index 0000000..5717bd7
--- /dev/null
+++ b/audio-codec/tremolo/Android.mk
@@ -0,0 +1,66 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+PRIVATE_INC_DIR := external/tremolo
+PRIVATE_SRC_DIR := ../../../../external/tremolo
+
+LOCAL_SRC_FILES = \
+       $(PRIVATE_SRC_DIR)/Tremolo/bitwise.c \
+       $(PRIVATE_SRC_DIR)/Tremolo/codebook.c \
+       $(PRIVATE_SRC_DIR)/Tremolo/dsp.c \
+       $(PRIVATE_SRC_DIR)/Tremolo/floor0.c \
+       $(PRIVATE_SRC_DIR)/Tremolo/floor1.c \
+       $(PRIVATE_SRC_DIR)/Tremolo/floor_lookup.c \
+       $(PRIVATE_SRC_DIR)/Tremolo/framing.c \
+       $(PRIVATE_SRC_DIR)/Tremolo/mapping0.c \
+       $(PRIVATE_SRC_DIR)/Tremolo/mdct.c \
+       $(PRIVATE_SRC_DIR)/Tremolo/misc.c \
+       $(PRIVATE_SRC_DIR)/Tremolo/res012.c \
+       $(PRIVATE_SRC_DIR)/Tremolo/treminfo.c \
+       $(PRIVATE_SRC_DIR)/Tremolo/vorbisfile.c
+
+ifeq ($(TARGET_ARCH),arm)
+LOCAL_SRC_FILES += \
+       $(PRIVATE_SRC_DIR)/Tremolo/bitwiseARM.s \
+       $(PRIVATE_SRC_DIR)/Tremolo/dpen.s \
+       $(PRIVATE_SRC_DIR)/Tremolo/floor1ARM.s \
+       $(PRIVATE_SRC_DIR)/Tremolo/mdctARM.s
+LOCAL_CFLAGS += \
+    -D_ARM_ASSEM_
+else
+LOCAL_CFLAGS += \
+    -DONLY_C
+endif
+LOCAL_CFLAGS+= -O2
+
+LOCAL_C_INCLUDES:= \
+       $(PRIVATE_INC_DIR)/Tremolo
+
+LOCAL_ARM_MODE := arm
+
+LOCAL_MODULE := libvorbisidec
+
+include $(BUILD_STATIC_LIBRARY)
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+	ivorbisfile_example.c
+
+LOCAL_C_INCLUDES += \
+	external/tremolo/Tremolo \
+	$(call include-path-for, audio-utils)
+
+LOCAL_STATIC_LIBRARIES := \
+	libc libsndfile libvorbisidec libaudioprimitives
+
+LOCAL_ARM_MODE := arm
+
+LOCAL_MODULE := libvorbisidec_test
+LOCAL_MODULE_TAGS := optional tests
+
+LOCAL_MULTILIB := 32
+
+LOCAL_FORCE_STATIC_EXECUTABLE := true
+
+include $(BUILD_EXECUTABLE)
diff --git a/audio-codec/tremolo/README b/audio-codec/tremolo/README
new file mode 100644
index 0000000..c041b4b
--- /dev/null
+++ b/audio-codec/tremolo/README
@@ -0,0 +1,7 @@
+The test media is the song "Retribution" by Tanner Helland in Ogg Vorbis format.
+
+The song was obtained from the following site:
+	http://www.tannerhelland.com/52/song-retribution/
+under the Create Commons Attribution-ShareAlike 3.0 License (for more info,
+please visit http://www.tannerhelland.com/52/song-retribution/)
+
diff --git a/audio-codec/tremolo/Retribution.ogg b/audio-codec/tremolo/Retribution.ogg
new file mode 100644
index 0000000..6c70ce4
--- /dev/null
+++ b/audio-codec/tremolo/Retribution.ogg
diff --git a/audio-codec/tremolo/ivorbisfile_example.c b/audio-codec/tremolo/ivorbisfile_example.c
new file mode 100644
index 0000000..b5717ae
--- /dev/null
+++ b/audio-codec/tremolo/ivorbisfile_example.c
@@ -0,0 +1,181 @@
+/********************************************************************
+ *                                                                  *
+ * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE.   *
+ *                                                                  *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
+ *                                                                  *
+ * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002    *
+ * BY THE Xiph.Org FOUNDATION http://www.xiph.org/                  *
+ *                                                                  *
+ ********************************************************************
+
+ function: simple example decoder using vorbisidec
+
+ ********************************************************************/
+
+/* Takes a vorbis bitstream from stdin and writes stereo PCM to a WAV
+   file using vorbisfile and sndfile. Using vorbisfile is much
+   simpler than dealing with libvorbis. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <time.h>
+#include "ivorbiscodec.h"
+#include "ivorbisfile.h"
+#include <audio_utils/sndfile.h>
+
+#ifdef _WIN32 /* We need the following two to set stdin/stdout to binary */
+#include <io.h>
+#include <fcntl.h>
+#endif
+
+short pcmout[2048]; /* take 4k out of the data segment, not the stack */
+
+struct timespec timespec_diff(struct timespec *start, struct timespec *end){
+  struct timespec diff;
+  if((end->tv_nsec-start->tv_nsec) < 0){
+    diff.tv_sec=end->tv_sec-start->tv_sec-1;
+    diff.tv_nsec=1000000000+end->tv_nsec-start->tv_nsec;
+  } else {
+    diff.tv_sec=end->tv_sec-start->tv_sec;
+    diff.tv_nsec=end->tv_nsec-start->tv_nsec;
+  }
+  return diff;
+}
+
+int main(int argc, const char **argv){
+  FILE *input_file;
+  OggVorbis_File vf;
+  int eof=0;
+  int current_section;
+
+  if(argc != 3) {
+    fprintf(stderr, "Usage %s <input_ogg_file> <output_pcm_wav_file>\n", argv[0]);
+    exit(1);
+  }
+
+  /* Open the input file */
+  input_file = fopen(argv[1], "rb");
+  if(input_file == NULL){
+    fprintf(stderr,"Failed to open input file %s\n", argv[1]);
+    exit(1);
+  }
+
+  if(ov_open(input_file, &vf, NULL, 0) < 0){
+      fprintf(stderr,"Input does not appear to be an Ogg bitstream.\n");
+      exit(1);
+  }
+
+  /* Throw the comments plus a few lines about the bitstream we're
+     decoding */
+  {
+    char **ptr=ov_comment(&vf,-1)->user_comments;
+    vorbis_info *vi=ov_info(&vf,-1);
+    while(*ptr){
+      fprintf(stderr,"%s\n",*ptr);
+      ++ptr;
+    }
+    fprintf(stderr,"\nBitstream is %d channel, %ldHz\n",vi->channels,vi->rate);
+    fprintf(stderr,"\nDecoded length: %ld samples\n",
+	    (long)ov_pcm_total(&vf,-1));
+    fprintf(stderr,"Encoded by: %s\n\n",ov_comment(&vf,-1)->vendor);
+  }
+
+  /* Open the output file */
+  vorbis_info *vi=ov_info(&vf,-1);
+  SF_INFO sfInfo;
+  memset(&sfInfo, 0, sizeof(SF_INFO));
+  sfInfo.channels=vi->channels;
+  sfInfo.format=(SF_FORMAT_WAV | SF_FORMAT_PCM_16);
+  sfInfo.samplerate=vi->rate;
+  SNDFILE *output_file=sf_open(argv[2], SFM_WRITE, &sfInfo);
+  if(!output_file){
+    fprintf(stderr, "Encountered error writing %s\n", argv[2]);
+    fclose(input_file);
+    ov_clear(&vf);
+    exit(1);
+  }
+
+  /* Track the total time it took to decode */
+  struct timespec start_time;
+  struct timespec end_time;
+  if(clock_gettime(CLOCK_MONOTONIC, &start_time))
+     fprintf(stderr, "Failed to get start time for profiling\n");
+
+  while(!eof){
+    long ret=ov_read(&vf,pcmout,sizeof(pcmout),&current_section);
+    if (ret == 0) {
+      /* EOF */
+      eof=1;
+    } else if (ret < 0) {
+      /* error in the stream.  Not a problem, just reporting it in
+	 case we (the app) cares.  In this case, we don't. */
+    } else {
+      /* we don't bother dealing with sample rate changes, etc, but
+	 you'll have to*/
+      /* convert bytes read total to short (2 bytes) per channel */
+      sf_writef_short(output_file, pcmout, ret / 2 / sfInfo.channels);
+    }
+  }
+  if(clock_gettime(CLOCK_MONOTONIC,&end_time)){
+    fprintf(stderr, "Failed to get end time for profiling\n");
+  }else{
+    struct timespec diff=timespec_diff(&start_time,&end_time);
+    fprintf(stderr, "Total decode time: %ld.%09ld seconds\n", diff.tv_sec,
+            diff.tv_nsec);
+  }
+
+  /* verify the WAV file */
+  sf_close(output_file);
+  memset(&sfInfo, 0, sizeof(SF_INFO));
+  output_file = sf_open(argv[2], SFM_READ, &sfInfo);
+
+  fprintf(stderr, "Decoded WAV file info:\n");
+  fprintf(stderr, "\tNumber of frames: %d\n", sfInfo.frames);
+  fprintf(stderr, "\tSample rate:      %d\n", sfInfo.samplerate);
+  fprintf(stderr, "\tChannels:         %d\n", sfInfo.channels);
+
+  short *min = calloc(1, sfInfo.channels * sizeof(short));
+  assert(min != NULL);
+  short *max = calloc(1, sfInfo.channels * sizeof(short));
+  assert(max != NULL);
+
+  while(1){
+      static int total_frames = 0;
+      sf_count_t frames;
+      int i, j;
+
+      frames = sf_readf_short(output_file, pcmout,
+                              sizeof(pcmout) / sizeof(pcmout[0]) /
+                              sfInfo.channels);
+      if(!frames){
+          fprintf(stderr, "Decoded %d frames\n", total_frames);
+          for(j = 0; j < sfInfo.channels; j++)
+              fprintf(stderr, "Channel %d: min=%d max=%d\n", j, min[j], max[j]);
+          break;
+      }
+      total_frames += frames;
+
+      for(i = 0; i < frames; i++){
+          for(j = 0; j < sfInfo.channels; j++){
+              if(pcmout[i*j] > max[j])
+                  max[j] = pcmout[i*j];
+              if(pcmout[i*j] < min[j])
+                  min[j] = pcmout[i*j];
+          }
+      }
+  }
+  free(min);
+  free(max);
+
+  /* cleanup */
+  fclose(input_file);
+  sf_close(output_file);
+  ov_clear(&vf);
+    
+  fprintf(stderr,"Done.\n");
+  return(0);
+}
diff --git a/linaro-android-userspace-tests.sh b/linaro-android-userspace-tests.sh
new file mode 100755
index 0000000..4fe8374
--- /dev/null
+++ b/linaro-android-userspace-tests.sh
@@ -0,0 +1,239 @@
+#!/system/bin/sh
+#############################################################################
+# Copyright (c) 2014 Linaro
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+#     Linaro <linaro-dev@lists.linaro.org>
+#############################################################################
+
+usage() {
+	echo
+	echo "Usage: $0 [-h] [-t testnames]"
+	echo
+	echo "Runs all tests if no tests are specified"
+	echo
+	echo "-h prints this help message"
+	echo "-v turn on verbose output"
+	echo "-t testnames, run specified tests"
+	echo "   currently supported:"
+	echo "   audio_codec_aac"
+	echo "   audio_codec_flac"
+	echo "   audio_codec_mp3"
+	echo "   audio_codec_tremolo"
+	echo
+	echo "Example:"
+	echo "\t$0 -t \"audio_codec_aac audio_codec_mp3\""
+}
+
+run_audio_codec_aac()
+{
+	TEST_FILE="/data/linaro-android-userspace-test/audio-codec/Retribution.wav"
+	OUT_FILE="/data/local/tmp/audio-codec-test.out"
+	EXPECTED_MD5SUM="f35771514701eaf5055b1705a4c660b7"
+
+	echo
+	echo "Running AAC encoder test"
+
+	if [ ! -f ${TEST_FILE} ]; then
+		echo "ERROR: AAC test file ${TEST_FILE} does not exist"
+		echo "AAC encoder test: FAILED"
+		echo "[audio_codec_aac]: test failed"
+		return 1
+	fi
+	if [ "${VERBOSE}" -eq "1" ]; then
+		libaacenc_test ${TEST_FILE} ${OUT_FILE}
+	else
+		libaacenc_test ${TEST_FILE} ${OUT_FILE} &> /dev/null
+	fi
+	RET=$?
+	if [ "${RET}" -ne "0" ]; then
+		echo "ERROR: AAC encoder test returned error"
+		echo "AAC encoder test: FAILED"
+		echo "[audio_codec_aac]: test failed"
+		return 1
+	fi
+
+	echo "Checking MD5SUM of output file"
+	MD5SUM=`md5 ${OUT_FILE}`
+	MD5SUM=${MD5SUM%% *}
+	rm ${OUT_FILE}
+	if [[ "${MD5SUM}" == "${EXPECTED_MD5SUM}" ]]; then
+		echo "AAC encoder test: PASSED"
+		echo "[audio_codec_aac]: test passed"
+	else
+		echo "ERROR: incorrect MD5SUM '${MD5SUM}' (expected '${EXPECTED_MD5SUM}')"
+		echo "AAC encoder test: FAILED"
+		echo "[audio_codec_aac]: test failed"
+		return 1
+	fi
+}
+
+run_audio_codec_flac()
+{
+	echo
+	echo "Running FLAC encoder/decoder test"
+
+	if [ "${VERBOSE}" -eq "1" ]; then
+		libFLAC_test
+	else
+		libFLAC_test &> /dev/null
+	fi
+	RET=$?
+	if [ "${RET}" -eq "0" ]; then
+		echo "FLAC encoder/decoder test: PASSED"
+		echo "[audio_codec_flac]: test passed"
+	else
+		echo "ERROR: FLAC encoder/decoder test returned error"
+		echo "FLAC encoder/decoder test: FAILED"
+		echo "[audio_codec_flac]: test failed"
+		return 1
+	fi
+}
+
+run_audio_codec_mp3()
+{
+	TEST_FILE="/data/linaro-android-userspace-test/audio-codec/Retribution.mp3"
+	OUT_FILE="/data/local/tmp/audio-codec-test.out"
+	EXPECTED_MD5SUM="0d5fc8ef34911e814edc7ecfbdc04d87"
+
+	echo
+	echo "Running MP3 decoder test"
+
+	if [ ! -f ${TEST_FILE} ]; then
+		echo "ERROR: MP3 test file ${TEST_FILE} does not exist"
+		echo "MP3 decoder test: FAILED"
+		echo "[audio_codec_mp3]: test failed"
+		return 1
+	fi
+	if [ "${VERBOSE}" -eq "1" ]; then
+		libstagefright_mp3dec_test ${TEST_FILE} ${OUT_FILE}
+	else
+		libstagefright_mp3dec_test ${TEST_FILE} ${OUT_FILE} &> /dev/null
+	fi
+	RET=$?
+	if [ "${RET}" -ne "0" ]; then
+		echo "ERROR: MP3 decoder test returned error"
+		echo "MP3 decoder test: FAILED"
+		echo "[audio_codec_mp3]: test failed"
+		return 1
+	fi
+
+	echo "Checking MD5SUM of output file"
+	MD5SUM=`md5 ${OUT_FILE}`
+	MD5SUM=${MD5SUM%% *}
+	rm ${OUT_FILE}
+	if [[ "${MD5SUM}" == "${EXPECTED_MD5SUM}" ]]; then
+		echo "MP3 decoder test: PASSED"
+		echo "[audio_codec_mp3]: test passed"
+	else
+		echo "ERROR: incorrect MD5SUM '${MD5SUM}' (expected '${EXPECTED_MD5SUM}')"
+		echo "MP3 decoder test: FAILED"
+		echo "[audio_codec_mp3]: test failed"
+		return 1
+	fi
+}
+
+run_audio_codec_tremolo()
+{
+	TEST_FILE="/data/linaro-android-userspace-test/audio-codec/Retribution.ogg"
+	OUT_FILE="/data/local/tmp/audio-codec-test.out"
+	EXPECTED_MD5SUM="4169c09ca4bdcee5c38a770e6f7dc305"
+
+	echo
+	echo "Running Tremolo decoder test"
+	if [ ! -f ${TEST_FILE} ]; then
+		echo "ERROR: Tremolo test file ${TEST_FILE} does not exist"
+		echo "Tremolo decoder test: FAILED"
+		echo "[audio_codec_tremolo]: test failed"
+		return 1
+	fi
+	if [ "${VERBOSE}" -eq "1" ]; then
+		libvorbisidec_test ${TEST_FILE} ${OUT_FILE}
+	else
+		libvorbisidec_test ${TEST_FILE} ${OUT_FILE} &> /dev/null
+	fi
+	RET=$?
+	if [ "${RET}" -ne "0" ]; then
+		echo "ERROR: Tremolo decoder test returned error"
+		echo "Tremolo decoder test: FAILED"
+		echo "[audio_codec_tremolo]: test failed"
+		return 1
+	fi
+
+	echo "Checking MD5SUM of output file"
+	MD5SUM=`md5 ${OUT_FILE}`
+	MD5SUM=${MD5SUM%% *}
+	rm ${OUT_FILE}
+	if [[ "${MD5SUM}" == "${EXPECTED_MD5SUM}" ]]; then
+		echo "Tremolo decoder test: PASSED"
+		echo "[audio_codec_tremolo]: test passed"
+	else
+		echo "ERROR: incorrect MD5SUM '${MD5SUM}' (expected '${EXPECTED_MD5SUM}')"
+		echo "Tremolo decoder test: FAILED"
+		echo "[audio_codec_tremolo]: test failed"
+		return 1
+	fi
+}
+
+run_tests() {
+	for TEST in $TESTS;
+	do
+		case $TEST in
+		audio_codec_aac)
+			run_audio_codec_aac
+			;;
+		audio_codec_flac)
+			run_audio_codec_flac
+			;;
+		audio_codec_mp3)
+			run_audio_codec_mp3
+			;;
+		audio_codec_tremolo)
+			run_audio_codec_tremolo
+			;;
+		*)
+			echo
+			echo "Unrecognized test $TEST"
+			usage
+			exit
+			;;
+		esac
+	done
+}
+
+# Terse output by default
+VERBOSE=0
+
+TESTS=""
+
+while getopts "hvt:" OPT
+do
+	case $OPT in
+	h)
+		usage
+		exit 1
+		;;
+	t)
+		TESTS=$OPTARG
+		;;
+	v)
+		VERBOSE=1
+		;;
+	*)
+		usage
+		exit
+	esac
+done
+
+if [ -z "${TESTS}" ]; then
+	# Run all tests by default
+	TESTS="audio_codec_aac audio_codec_flac audio_codec_mp3 audio_codec_tremolo"
+	echo "Running all tests"
+fi
+
+run_tests
+echo
diff --git a/product.mk b/product.mk
new file mode 100644
index 0000000..566e0dd
--- /dev/null
+++ b/product.mk
@@ -0,0 +1,25 @@
+#############################################################################
+# Copyright (c) 2014 Linaro
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+#     Linaro <linaro-dev@lists.linaro.org>
+#############################################################################
+
+# pick up tests for inclusion in the system image
+PRODUCT_PACKAGES += \
+	libaacenc_test \
+	libFLAC_test \
+	libstagefright_mp3dec_test \
+	libvorbisidec_test
+
+# put audio codec test script and media files on the device filesystem
+PRODUCT_COPY_FILES += \
+	external/linaro-android-userspace-test/linaro-android-userspace-tests.sh:system/bin/linaro-android-userspace-tests.sh \
+	external/linaro-android-userspace-test/audio-codec/aac/Retribution.wav:data/linaro-android-userspace-test/audio-codec/Retribution.wav \
+	external/linaro-android-userspace-test/audio-codec/mp3dec/Retribution.mp3:data/linaro-android-userspace-test/audio-codec/Retribution.mp3 \
+	external/linaro-android-userspace-test/audio-codec/tremolo/Retribution.ogg:data/linaro-android-userspace-test/audio-codec/Retribution.ogg
+