seal 0.1.0

data/mpg123/src/tests/seek_whence.c

@@ -0,0 +1,56 @@
+#include "compat.h"
+#include <mpg123.h>
+#include "debug.h"
+
+int test_whence(const char* path, int scan_before)
+{
+	int err = MPG123_OK;
+	mpg123_handle* mh = NULL;
+	off_t length, pos;
+
+	mh = mpg123_new(NULL, &err );
+	if(mh == NULL) return -1;
+
+	err = mpg123_open(mh, path );
+	if(err != MPG123_OK) return -1;
+
+	if(scan_before) mpg123_scan(mh);
+
+	pos = mpg123_seek( mh, 0, SEEK_END);
+	if(pos < 0){ error1("seek failed: %s", mpg123_strerror(mh)); return -1; }
+
+	pos = mpg123_tell(mh);
+	length = mpg123_length(mh);
+
+	/* Later: Read samples and compare different whence values with identical seek positions. */
+
+	mpg123_close(mh);
+	mpg123_delete(mh);
+
+	fprintf(stdout, "length %"OFF_P" vs. pos %"OFF_P"\n", length, pos);
+
+	return (pos == length) ? 0 : -1;
+}
+
+
+int main(int argc, char **argv)
+{
+	int err = 0, errsum = 0;
+	if(argc < 2)
+	{
+		printf("Gimme a MPEG file name...\n");
+		return 0;
+	}
+	mpg123_init();
+	fprintf(stderr, "End seek without (explicit) scanning: ");
+	err = test_whence(argv[1], 0);
+	fprintf(stdout, "%s\n", err == 0 ? "PASS" : "FAIL");
+	errsum += err;
+	fprintf(stderr, "End seek with explicit scanning: ");
+	err = test_whence(argv[1], 1);
+	fprintf(stdout, "%s\n", err == 0 ? "PASS" : "FAIL");
+	errsum += err;
+	mpg123_exit();
+	printf("%s\n", errsum ? "FAIL" : "PASS");
+	return errsum;
+}

data/mpg123/src/tests/testtext.h

@@ -0,0 +1,34 @@
+/* Test strings generated by testtext.sh, using data from test.txt */
+
+const unsigned char latin1[] = 
+{ 0x47, 0x72, 0x6f, 0xdf, 0x65, 0x72, 0x20, 0x4d, 0xe4, 0x7a, 0x65, 0x6e, 0x2c, 0x20, 0x7a, 0x65, 0x69, 0x67, 0x65, 0x20, 0x64, 0x65, 0x69, 0x6e, 0x65, 0x20, 0x46, 0x6c, 0xfc, 0x67, 0x65, 0x6c, 0x20, 0xf6, 0x66, 0x74, 0x65, 0x72, 0x20, 0x6d, 0x61, 0x6c, 0x21, 0x20, 0x46, 0x61, 0x6b, 0x74, 0x6f, 0x72, 0x20, 0xbc, 0x2c, 0x20, 0x62, 0x69, 0x74, 0x74, 0x65, 0x2e, 0x0a, 
+  0x00 };
+
+const unsigned char cp1252[] = 
+{ 0x47, 0x72, 0x6f, 0xdf, 0x65, 0x72, 0x20, 0x4d, 0xe4, 0x7a, 0x65, 0x6e, 0x2c, 0x20, 0x7a, 0x65, 0x69, 0x67, 0x65, 0x20, 0x64, 0x65, 0x69, 0x6e, 0x65, 0x20, 0x46, 0x6c, 0xfc, 0x67, 0x65, 0x6c, 0x20, 0xf6, 0x66, 0x74, 0x65, 0x72, 0x20, 0x6d, 0x61, 0x6c, 0x21, 0x20, 0x46, 0x61, 0x6b, 0x74, 0x6f, 0x72, 0x20, 0xbc, 0x2c, 0x20, 0x62, 0x69, 0x74, 0x74, 0x65, 0x2e, 0x0a, 
+  0x00 };
+
+const unsigned char utf8[] = 
+{ 0x47, 0x72, 0x6f, 0xc3, 0x9f, 0x65, 0x72, 0x20, 0x4d, 0xc3, 0xa4, 0x7a, 0x65, 0x6e, 0x2c, 0x20, 0x7a, 0x65, 0x69, 0x67, 0x65, 0x20, 0x64, 0x65, 0x69, 0x6e, 0x65, 0x20, 0x46, 0x6c, 0xc3, 0xbc, 0x67, 0x65, 0x6c, 0x20, 0xc3, 0xb6, 0x66, 0x74, 0x65, 0x72, 0x20, 0x6d, 0x61, 0x6c, 0x21, 0x20, 0x46, 0x61, 0x6b, 0x74, 0x6f, 0x72, 0x20, 0xc2, 0xbc, 0x2c, 0x20, 0x62, 0x69, 0x74, 0x74, 0x65, 0x2e, 0x0a, 
+  0x00 };
+
+const unsigned char utf16[] = 
+{ 0xff, 0xfe, 0x47, 0x00, 0x72, 0x00, 0x6f, 0x00, 0xdf, 0x00, 0x65, 0x00, 0x72, 0x00, 0x20, 0x00, 0x4d, 0x00, 0xe4, 0x00, 0x7a, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x2c, 0x00, 0x20, 0x00, 0x7a, 0x00, 0x65, 0x00, 0x69, 0x00, 0x67, 0x00, 0x65, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x20, 0x00, 0x46, 0x00, 0x6c, 0x00, 0xfc, 0x00, 0x67, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x20, 0x00, 0xf6, 0x00, 0x66, 0x00, 0x74, 0x00, 0x65, 0x00, 0x72, 0x00, 0x20, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x6c, 0x00, 0x21, 0x00, 0x20, 0x00, 0x46, 0x00, 0x61, 0x00, 0x6b, 0x00, 0x74, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x20, 0x00, 0xbc, 0x00, 0x2c, 0x00, 0x20, 0x00, 0x62, 0x00, 0x69, 0x00, 0x74, 0x00, 0x74, 0x00, 0x65, 0x00, 0x2e, 0x00, 0x0a, 0x00, 
+  0x00, 0x00 };
+
+const unsigned char utf16bom_le[] = 
+{ 0xff, 0xfe, 0x47, 0x00, 0x72, 0x00, 0x6f, 0x00, 0xdf, 0x00, 0x65, 0x00, 0x72, 0x00, 0x20, 0x00, 0x4d, 0x00, 0xe4, 0x00, 0x7a, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x2c, 0x00, 0x20, 0x00, 0x7a, 0x00, 0x65, 0x00, 0x69, 0x00, 0x67, 0x00, 0x65, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x20, 0x00, 0x46, 0x00, 0x6c, 0x00, 0xfc, 0x00, 0x67, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x20, 0x00, 0xf6, 0x00, 0x66, 0x00, 0x74, 0x00, 0x65, 0x00, 0x72, 0x00, 0x20, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x6c, 0x00, 0x21, 0x00, 0x20, 0x00, 0x46, 0x00, 0x61, 0x00, 0x6b, 0x00, 0x74, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x20, 0x00, 0xbc, 0x00, 0x2c, 0x00, 0x20, 0x00, 0x62, 0x00, 0x69, 0x00, 0x74, 0x00, 0x74, 0x00, 0x65, 0x00, 0x2e, 0x00, 0x0a, 0x00, 
+  0x00, 0x00 };
+
+const unsigned char utf16le[] = 
+{ 0x47, 0x00, 0x72, 0x00, 0x6f, 0x00, 0xdf, 0x00, 0x65, 0x00, 0x72, 0x00, 0x20, 0x00, 0x4d, 0x00, 0xe4, 0x00, 0x7a, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x2c, 0x00, 0x20, 0x00, 0x7a, 0x00, 0x65, 0x00, 0x69, 0x00, 0x67, 0x00, 0x65, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x20, 0x00, 0x46, 0x00, 0x6c, 0x00, 0xfc, 0x00, 0x67, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x20, 0x00, 0xf6, 0x00, 0x66, 0x00, 0x74, 0x00, 0x65, 0x00, 0x72, 0x00, 0x20, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x6c, 0x00, 0x21, 0x00, 0x20, 0x00, 0x46, 0x00, 0x61, 0x00, 0x6b, 0x00, 0x74, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x20, 0x00, 0xbc, 0x00, 0x2c, 0x00, 0x20, 0x00, 0x62, 0x00, 0x69, 0x00, 0x74, 0x00, 0x74, 0x00, 0x65, 0x00, 0x2e, 0x00, 0x0a, 0x00, 
+  0x00, 0x00 };
+
+const unsigned char utf16bom_be[] = 
+{ 0xfe, 0xff, 0x00, 0x47, 0x00, 0x72, 0x00, 0x6f, 0x00, 0xdf, 0x00, 0x65, 0x00, 0x72, 0x00, 0x20, 0x00, 0x4d, 0x00, 0xe4, 0x00, 0x7a, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x2c, 0x00, 0x20, 0x00, 0x7a, 0x00, 0x65, 0x00, 0x69, 0x00, 0x67, 0x00, 0x65, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x20, 0x00, 0x46, 0x00, 0x6c, 0x00, 0xfc, 0x00, 0x67, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x20, 0x00, 0xf6, 0x00, 0x66, 0x00, 0x74, 0x00, 0x65, 0x00, 0x72, 0x00, 0x20, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x6c, 0x00, 0x21, 0x00, 0x20, 0x00, 0x46, 0x00, 0x61, 0x00, 0x6b, 0x00, 0x74, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x20, 0x00, 0xbc, 0x00, 0x2c, 0x00, 0x20, 0x00, 0x62, 0x00, 0x69, 0x00, 0x74, 0x00, 0x74, 0x00, 0x65, 0x00, 0x2e, 0x00, 0x0a, 
+  0x00, 0x00 };
+
+const unsigned char utf16be[] = 
+{ 0x00, 0x47, 0x00, 0x72, 0x00, 0x6f, 0x00, 0xdf, 0x00, 0x65, 0x00, 0x72, 0x00, 0x20, 0x00, 0x4d, 0x00, 0xe4, 0x00, 0x7a, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x2c, 0x00, 0x20, 0x00, 0x7a, 0x00, 0x65, 0x00, 0x69, 0x00, 0x67, 0x00, 0x65, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x20, 0x00, 0x46, 0x00, 0x6c, 0x00, 0xfc, 0x00, 0x67, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x20, 0x00, 0xf6, 0x00, 0x66, 0x00, 0x74, 0x00, 0x65, 0x00, 0x72, 0x00, 0x20, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x6c, 0x00, 0x21, 0x00, 0x20, 0x00, 0x46, 0x00, 0x61, 0x00, 0x6b, 0x00, 0x74, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x20, 0x00, 0xbc, 0x00, 0x2c, 0x00, 0x20, 0x00, 0x62, 0x00, 0x69, 0x00, 0x74, 0x00, 0x74, 0x00, 0x65, 0x00, 0x2e, 0x00, 0x0a, 
+  0x00, 0x00 };
+

data/mpg123/src/tests/text.c

@@ -0,0 +1,80 @@
+/*
+	text: Test text transformations in libmpg123 (conversion to UTF-8).
+
+	copyright 2009 by the mpg123 project - free software under the terms of the LGPL 2.1
+	see COPYING and AUTHORS files in distribution or http://mpg123.org
+	initially written by Thomas Orgis
+
+	arguments: decoder testfile.mpeg
+*/
+
+#include <mpg123.h>
+#include <compat.h>
+
+#include "testtext.h"
+
+int string_good(mpg123_string *sb)
+{
+	/* Let's accept additional null bytes... */
+	if(sb->fill >= sizeof(utf8) && memcmp(utf8, sb->p, sizeof(utf8)) == 0
+	   && (sb->fill <= sizeof(utf8) || sb->p[sizeof(utf8)] == 0) )
+	return 1;
+	else
+	return 0;
+}
+
+int check_string(const char* name, enum mpg123_text_encoding enc, const unsigned char* source, size_t source_size)
+{
+	int ret = 0;
+	mpg123_string sb;
+	mpg123_init_string(&sb);
+	printf("Conversion of %s: ", name);
+	if(    mpg123_store_utf8(&sb, enc, source, source_size)
+	    && string_good(&sb) )
+	{
+		printf("PASS\n");
+		ret = 0;
+	}
+	else
+	{
+		printf("FAIL (%"SIZE_P" vs. %"SIZE_P")\n", (size_p)sb.fill, (size_p)sizeof(utf8));
+		ret = 1;
+	}
+
+	mpg123_free_string(&sb);
+	return ret;
+}
+
+/* We test: latin1, cp1252, utf8 and all of utf16be/le with and without BOM.
+   Everything should succeed -- except utf16le without BOM. */
+int main()
+{
+	int ret = 0;
+	mpg123_string trans_utf16le;
+
+	mpg123_init_string(&trans_utf16le);
+
+	/* First, all conversions that should work. */
+	ret += check_string("latin1", mpg123_text_latin1, latin1, sizeof(latin1));
+	ret += check_string("cp1252", mpg123_text_cp1252, cp1252, sizeof(cp1252));
+	ret += check_string("utf8",   mpg123_text_utf8,   utf8,   sizeof(utf8));
+	ret += check_string("utf16bom_be", mpg123_text_utf16bom, utf16bom_be, sizeof(utf16bom_be));
+	ret += check_string("utf16bom_le", mpg123_text_utf16,    utf16bom_le, sizeof(utf16bom_le));
+	ret += check_string("utf16be",     mpg123_text_utf16be,  utf16be,     sizeof(utf16be));
+
+	/* Now test the non-supported string. */
+	printf("Let's see what happens with a non-BOM little endian UTF-16 string: ");
+	mpg123_store_utf8(&trans_utf16le, mpg123_text_utf16, utf16le, sizeof(utf16le));
+	if(string_good(&trans_utf16le))
+	{
+		++ret;
+		printf("FAIL\n");
+	}
+	else printf("PASS\n");
+
+	mpg123_free_string(&trans_utf16le);
+
+	printf("\n%s\n", ret == 0 ? "PASS" : "FAIL");
+
+	return ret;
+}

data/mpg123/src/wav.c

@@ -0,0 +1,464 @@
+/*
+	wav.c: write wav files
+
+	copyright ?-2012 by the mpg123 project - free software under the terms of the LGPL 2.1
+	see COPYING and AUTHORS files in distribution or http://mpg123.org
+	initially written by Samuel Audet
+
+	Geez, why are WAV RIFF headers are so secret?  I got something together,
+	but wow...  anyway, I hope someone will find this useful.
+	- Samuel Audet
+
+	minor simplifications and ugly AU/CDR format stuff by MH
+
+	It's not a very clean code ... Fix this!
+
+	ThOr: The usage of stdio streams means we loose control over what data is actually written. On a full disk, fwrite() happily suceeds for ages, only a fflush fails.
+	Now: Do we want to fflush() after every write? That defeats the purpose of buffered I/O. So, switching to good old write() is an option (kernel doing disk buffering anyway).
+
+	TODO: convert fully to tab indent
+*/
+
+#include "mpg123app.h"
+#include <errno.h>
+#include "debug.h"
+
+/* Create the two WAV headers. */
+
+#define WAVE_FORMAT 1
+#define RIFF_NAME RIFF
+#include "wavhead.h"
+
+#undef WAVE_FORMAT
+#undef RIFF_NAME
+#define WAVE_FORMAT 3
+#define RIFF_NAME RIFF_FLOAT
+#define FLOATOUT
+#include "wavhead.h"
+
+/* AU header struct... */
+
+struct auhead {
+  byte magic[4];
+  byte headlen[4];
+  byte datalen[4];
+  byte encoding[4];
+  byte rate[4];
+  byte channels[4];
+  byte dummy[8];
+} auhead = { 
+  { 0x2e,0x73,0x6e,0x64 } , { 0x00,0x00,0x00,0x20 } , 
+  { 0xff,0xff,0xff,0xff } , { 0,0,0,0 } , { 0,0,0,0 } , { 0,0,0,0 } , 
+  { 0,0,0,0,0,0,0,0 }};
+
+
+static FILE *wavfp;
+static int header_written = 0; /* prevent writing multiple headers to stdout */
+static long datalen = 0;
+static int flipendian=0;
+int bytes_per_sample = -1;
+int floatwav = 0; /* If we write a floating point WAV file. */
+
+/* Convertfunctions: */
+/* always little endian */
+
+static void long2littleendian(long inval,byte *outval,int b)
+{
+  int i;
+  for(i=0;i<b;i++) {
+    outval[i] = (inval>>(i*8)) & 0xff;
+  } 
+}
+
+/* always big endian */
+static void long2bigendian(long inval,byte *outval,int b)
+{
+  int i;
+  for(i=0;i<b;i++) {
+    outval[i] = (inval>>((b-i-1)*8)) & 0xff;
+  }
+}
+
+static long from_little(byte *inval, int b)
+{
+	long ret = 0;
+	int i;
+	for(i=0;i<b;++i) ret += ((long)inval[i])<<(i*8);
+
+	return ret;
+}
+
+static int testEndian(void) 
+{
+  long i,a=0,b=0,c=0;
+  int ret = 0;
+
+  for(i=0;i<sizeof(long);i++) {
+    ((byte *)&a)[i] = i;
+    b<<=8;
+    b |= i;
+    c |= i << (i*8);
+  }
+  if(a == b)
+      ret = 1;
+  else if(a != c) {
+      error3("Strange endianness?? %08lx %08lx %08lx\n",a,b,c);
+      ret = -1;
+  }
+  return ret;
+}
+
+static int open_file(char *filename)
+{
+#if defined(HAVE_SETUID) && defined(HAVE_GETUID)
+   setuid(getuid()); /* dunno whether this helps. I'm not a security expert */
+#endif
+   if(!strcmp("-",filename))  {
+      wavfp = stdout;
+	return 0;
+   }
+   else {
+#ifdef WANT_WIN32_UNICODE
+     wchar_t *filenamew = NULL;
+     win32_utf8_wide(filename, &filenamew, NULL);
+     if(filenamew == NULL) {
+       wavfp = NULL;
+     } else {
+       wavfp = _wfopen(filenamew,L"wb");
+       free(filenamew);
+     }
+#else
+     wavfp = fopen(filename,"wb");
+#endif
+     if(!wavfp)
+       return -1;
+		else
+		{
+			/* Test if we actually can write at least a byte, only chance to catch a totally full disk early. */
+			char a = 'a';
+			if(fwrite(&a, 1, 1, wavfp) == 1 && !fflush(wavfp) && !fseek(wavfp, 0, SEEK_SET))
+			return 0;
+			else
+			{
+				error1("cannot even write a single byte: %s", strerror(errno));
+				fclose(wavfp);
+				return -1;
+			}
+		}
+   }
+}
+
+static int close_file()
+{
+	if(wavfp != NULL && wavfp != stdout)
+	{
+		if(fclose(wavfp))
+		{
+			error1("problem closing the audio file, probably because of flushing to disk: %s\n", strerror(errno));
+			return -1;
+		}
+		else return 0;
+	}
+
+	wavfp = NULL;
+	return 0;
+}
+
+/* Wrapper over header writing; ensure that stdout doesn't get multiple headers. */
+static int write_header(const void*ptr, size_t size)
+{
+	if(wavfp == stdout)
+	{
+		if(header_written) return 0;
+
+		header_written = 1;
+	}
+	if(fwrite(ptr, size, 1, wavfp) != 1 || fflush(wavfp))
+	{
+		error1("cannot write header: %s", strerror(errno));
+		return -1;
+	}
+	else return 0;
+}
+
+int au_open(audio_output_t *ao)
+{
+	if(ao->format < 0) ao->format = MPG123_ENC_SIGNED_16;
+
+	if(ao->format & MPG123_ENC_FLOAT)
+	{
+		error("AU file support for float values not there yet");
+		return -1;
+	}
+
+  flipendian = 0;
+
+	if(ao->rate < 0) ao->rate = 44100;
+	if(ao->channels < 0) ao->channels = 2;
+
+  switch(ao->format) {
+    case MPG123_ENC_SIGNED_16:
+      {
+        int endiantest = testEndian();
+        if(endiantest == -1) return -1;
+        flipendian = !endiantest; /* big end */
+        long2bigendian(3,auhead.encoding,sizeof(auhead.encoding));
+      }
+      break;
+    case MPG123_ENC_UNSIGNED_8:
+      ao->format = MPG123_ENC_ULAW_8; 
+    case MPG123_ENC_ULAW_8:
+      long2bigendian(1,auhead.encoding,sizeof(auhead.encoding));
+      break;
+    default:
+      error("AU output is only a hack. This audio mode isn't supported yet.");
+      return -1;
+  }
+
+  long2bigendian(0xffffffff,auhead.datalen,sizeof(auhead.datalen));
+  long2bigendian(ao->rate,auhead.rate,sizeof(auhead.rate));
+  long2bigendian(ao->channels,auhead.channels,sizeof(auhead.channels));
+
+  if(open_file(ao->device) < 0)
+    return -1;
+
+  datalen = 0;
+
+	return write_header(&auhead, sizeof(auhead));
+}
+
+int cdr_open(audio_output_t *ao)
+{
+	if(ao->format < 0 && ao->rate < 0 && ao->channels < 0)
+	{
+  /* param.force_stereo = 0; */
+  ao->format = MPG123_ENC_SIGNED_16;
+  ao->rate = 44100;
+  ao->channels = 2;
+	}
+  if(ao->format != MPG123_ENC_SIGNED_16 || ao->rate != 44100 || ao->channels != 2) {
+    fprintf(stderr,"Oops .. not forced to 16 bit, 44kHz?, stereo\n");
+    return -1;
+  }
+
+  flipendian = !testEndian(); /* big end */
+  
+
+  if(open_file(ao->device) < 0)
+    return -1;
+
+  return 0;
+}
+
+int wav_open(audio_output_t *ao)
+{
+	int bps;
+
+	if(ao->format < 0) ao->format = MPG123_ENC_SIGNED_16;
+
+	flipendian = 0;
+
+	/* standard MS PCM, and its format specific is BitsPerSample */
+	long2littleendian(1,RIFF.WAVE.fmt.FormatTag,sizeof(RIFF.WAVE.fmt.FormatTag));
+	floatwav = 0;
+	if(ao->format == MPG123_ENC_FLOAT_32)
+	{
+		floatwav = 1;
+		long2littleendian(3,RIFF_FLOAT.WAVE.fmt.FormatTag,sizeof(RIFF_FLOAT.WAVE.fmt.FormatTag));
+		long2littleendian(bps=32,RIFF_FLOAT.WAVE.fmt.BitsPerSample,sizeof(RIFF_FLOAT.WAVE.fmt.BitsPerSample));
+		flipendian = testEndian();
+	}
+	else if(ao->format == MPG123_ENC_SIGNED_32) {
+		long2littleendian(bps=32,RIFF.WAVE.fmt.BitsPerSample,sizeof(RIFF.WAVE.fmt.BitsPerSample));
+		flipendian = testEndian();
+	}
+	else if(ao->format == MPG123_ENC_SIGNED_24) {
+		long2littleendian(bps=24,RIFF.WAVE.fmt.BitsPerSample,sizeof(RIFF.WAVE.fmt.BitsPerSample));
+		flipendian = testEndian();
+	}
+	else if(ao->format == MPG123_ENC_SIGNED_16) {
+		long2littleendian(bps=16,RIFF.WAVE.fmt.BitsPerSample,sizeof(RIFF.WAVE.fmt.BitsPerSample));
+		flipendian = testEndian();
+	}
+	else if(ao->format == MPG123_ENC_UNSIGNED_8)
+	long2littleendian(bps=8,RIFF.WAVE.fmt.BitsPerSample,sizeof(RIFF.WAVE.fmt.BitsPerSample));
+	else
+	{
+		error("Format not supported.");
+		return -1;
+	}
+
+	if(ao->rate < 0) ao->rate = 44100;
+	if(ao->channels < 0) ao->channels = 2;
+
+	if(floatwav)
+	{
+		long2littleendian(ao->channels,RIFF_FLOAT.WAVE.fmt.Channels,sizeof(RIFF_FLOAT.WAVE.fmt.Channels));
+		long2littleendian(ao->rate,RIFF_FLOAT.WAVE.fmt.SamplesPerSec,sizeof(RIFF_FLOAT.WAVE.fmt.SamplesPerSec));
+		long2littleendian((int)(ao->channels * ao->rate * bps)>>3,
+			RIFF_FLOAT.WAVE.fmt.AvgBytesPerSec,sizeof(RIFF_FLOAT.WAVE.fmt.AvgBytesPerSec));
+		long2littleendian((int)(ao->channels * bps)>>3,
+			RIFF_FLOAT.WAVE.fmt.BlockAlign,sizeof(RIFF_FLOAT.WAVE.fmt.BlockAlign));
+	}
+	else
+	{
+		long2littleendian(ao->channels,RIFF.WAVE.fmt.Channels,sizeof(RIFF.WAVE.fmt.Channels));
+		long2littleendian(ao->rate,RIFF.WAVE.fmt.SamplesPerSec,sizeof(RIFF.WAVE.fmt.SamplesPerSec));
+		long2littleendian((int)(ao->channels * ao->rate * bps)>>3,
+			RIFF.WAVE.fmt.AvgBytesPerSec,sizeof(RIFF.WAVE.fmt.AvgBytesPerSec));
+		long2littleendian((int)(ao->channels * bps)>>3,
+			RIFF.WAVE.fmt.BlockAlign,sizeof(RIFF.WAVE.fmt.BlockAlign));
+	}
+
+	if(open_file(ao->device) < 0)
+	return -1;
+
+	if(floatwav)
+	{
+		long2littleendian(datalen,RIFF_FLOAT.WAVE.data.datalen,sizeof(RIFF_FLOAT.WAVE.data.datalen));
+		long2littleendian(datalen+sizeof(RIFF_FLOAT.WAVE),RIFF_FLOAT.WAVElen,sizeof(RIFF_FLOAT.WAVElen));
+	}
+	else
+	{
+		long2littleendian(datalen,RIFF.WAVE.data.datalen,sizeof(RIFF.WAVE.data.datalen));
+		long2littleendian(datalen+sizeof(RIFF.WAVE),RIFF.WAVElen,sizeof(RIFF.WAVElen));
+	}
+
+	if(!(    ( floatwav && !write_header(&RIFF_FLOAT, sizeof(RIFF_FLOAT)))
+	      || (!floatwav && !write_header(&RIFF,       sizeof(RIFF))) ))
+	{
+		return -1;
+	}
+
+	datalen = 0;
+	bytes_per_sample = bps>>3;
+
+	return 0;
+}
+
+int wav_write(unsigned char *buf,int len)
+{
+	int temp;
+	int i;
+
+	if(!wavfp)
+	return 0;
+
+	if(flipendian)
+	{
+		if(bytes_per_sample == 4) /* 32 bit */
+		{
+			if(len & 3)
+			{
+				error("Number of bytes no multiple of 4 (32bit)!");
+				return 0;
+			}
+			for(i=0;i<len;i+=4)
+			{
+				int j;
+				unsigned char tmp[4];
+				for(j = 0; j<=3; ++j) tmp[j] = buf[i+j];
+				for(j = 0; j<=3; ++j) buf[i+j] = tmp[3-j];
+			}
+		}
+		else /* 16 bit */
+		{
+			if(len & 1)
+			{
+				error("Odd number of bytes!");
+				return 0;
+			}
+			for(i=0;i<len;i+=2)
+			{
+				unsigned char tmp;
+				tmp = buf[i+0];
+				buf[i+0] = buf[i+1];
+				buf[i+1] = tmp;
+			}
+		}
+	}
+
+	temp = fwrite(buf, 1, len, wavfp);
+	if(temp <= 0)
+	return 0;
+/* That would kill it of early when running out of disk space. */
+#if 0
+if(fflush(wavfp))
+{
+	fprintf(stderr, "flushing failed: %s\n", strerror(errno));
+	return 0;
+}
+#endif
+	datalen += temp;
+
+	return temp;
+}
+
+int wav_close(void)
+{
+	if(!wavfp) return 0;
+
+	/* flush before seeking to catch out-of-disk explicitly at least at the end */
+	if(fflush(wavfp))
+	{
+		error1("cannot flush WAV stream: %s", strerror(errno));
+		fclose(wavfp);
+		return -1;
+	}
+	if(fseek(wavfp, 0L, SEEK_SET) >= 0)
+	{
+		if(floatwav)
+		{
+			long2littleendian(datalen,RIFF_FLOAT.WAVE.data.datalen,sizeof(RIFF_FLOAT.WAVE.data.datalen));
+			long2littleendian(datalen+sizeof(RIFF_FLOAT.WAVE),RIFF_FLOAT.WAVElen,sizeof(RIFF_FLOAT.WAVElen));
+			long2littleendian(datalen/(from_little(RIFF_FLOAT.WAVE.fmt.Channels,2)*from_little(RIFF_FLOAT.WAVE.fmt.BitsPerSample,2)/8),
+				RIFF_FLOAT.WAVE.fact.samplelen,sizeof(RIFF_FLOAT.WAVE.fact.samplelen));
+			/* Always (over)writing the header here; also for stdout, when fseek worked, this overwrite works. */
+			fwrite(&RIFF_FLOAT, sizeof(RIFF_FLOAT),1,wavfp);
+		}
+		else
+		{
+			long2littleendian(datalen,RIFF.WAVE.data.datalen,sizeof(RIFF.WAVE.data.datalen));
+			long2littleendian(datalen+sizeof(RIFF.WAVE),RIFF.WAVElen,sizeof(RIFF.WAVElen));
+			/* Always (over)writing the header here; also for stdout, when fseek worked, this overwrite works. */
+			fwrite(&RIFF, sizeof(RIFF),1,wavfp);
+		}
+	}
+	else
+	warning("Cannot rewind WAV file. File-format isn't fully conform now.");
+
+	return close_file();
+}
+
+int au_close(void)
+{
+   if(!wavfp)
+      return 0;
+
+	/* flush before seeking to catch out-of-disk explicitly at least at the end */
+	if(fflush(wavfp))
+	{
+		error1("cannot flush WAV stream: %s", strerror(errno));
+		fclose(wavfp);
+		return -1;
+	}
+   if(fseek(wavfp, 0L, SEEK_SET) >= 0) {
+     long2bigendian(datalen,auhead.datalen,sizeof(auhead.datalen));
+     /* Always (over)writing the header here; also for stdout, when fseek worked, this overwrite works. */
+     fwrite(&auhead, sizeof(auhead),1,wavfp); 
+   }
+   else
+   warning("Cannot rewind AU file. File-format isn't fully conform now.");
+
+	return close_file();
+}
+
+int cdr_close(void)
+{
+	if(!wavfp) return 0;
+
+	return close_file();
+}
+
+
+