seal 0.1.0

data/mpg123/src/term.h

@@ -0,0 +1,81 @@
+/*
+	term: terminal control
+
+	copyright ?-2006 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 Michael Hipp
+*/
+
+#ifndef _MPG123_TERM_H_
+#define _MPG123_TERM_H_
+
+#include "mpg123app.h"
+
+#ifdef HAVE_TERMIOS
+
+#define LOOP_CYCLES	0.500000	/* Loop time in sec */
+
+/* 
+ * Defines the keybindings in term.c - change to your 
+ * own preferences.
+ */
+
+#define MPG123_HELP_KEY	'h'
+#define MPG123_BACK_KEY	'b'
+#define MPG123_NEXT_KEY	'f'
+#define MPG123_PAUSE_KEY	'p'
+#define MPG123_QUIT_KEY	'q'
+/* space bar is alias for that */
+#define MPG123_STOP_KEY	's'
+#define MPG123_REWIND_KEY	','
+#define MPG123_FORWARD_KEY	'.'
+/* This is convenient on QWERTZ-keyboards. */
+#define MPG123_FAST_REWIND_KEY ';'
+#define MPG123_FAST_FORWARD_KEY ':'
+#define MPG123_FINE_REWIND_KEY '<'
+#define MPG123_FINE_FORWARD_KEY '>'
+/* You probably want to use the following bindings instead
+ * on a standard QWERTY-keyboard:
+ */
+ 
+/* #define MPG123_FAST_REWIND_KEY '<' */
+/* #define MPG123_FAST_FORWARD_KEY '>' */
+/* #define MPG123_FINE_REWIND_KEY ';' */
+/* #define MPG123_FINE_FORWARD_KEY ':' */
+
+#define MPG123_VOL_UP_KEY '+'
+#define MPG123_VOL_DOWN_KEY '-'
+#define MPG123_VERBOSE_KEY 'v'
+#define MPG123_RVA_KEY 'r'
+#define MPG123_PLAYLIST_KEY 'l'
+#define MPG123_PREV_KEY 'd'
+#define MPG123_MPEG_KEY 'm'
+#define MPG123_TAG_KEY  't'
+#define MPG123_PITCH_UP_KEY    'c'
+#define MPG123_PITCH_BUP_KEY   'C'
+#define MPG123_PITCH_DOWN_KEY  'x'
+#define MPG123_PITCH_BDOWN_KEY 'X'
+#define MPG123_PITCH_ZERO_KEY  'w'
+/* This counts as "undocumented" and can disappear */
+#define MPG123_FRAME_INDEX_KEY 'i'
+#define MPG123_VARIOUS_INFO_KEY 'I'
+/* The normal and big pitch adjustment done on key presses. */
+#define MPG123_PITCH_VAL 0.001
+#define MPG123_PITCH_BVAL 0.01
+
+#define MPG123_PAUSED_STRING	"Paused. \b\b\b\b\b\b\b\b"
+#define MPG123_STOPPED_STRING	"Stopped.\b\b\b\b\b\b\b\b"
+#define MPG123_EMPTY_STRING	"        \b\b\b\b\b\b\b\b"
+
+/* Need it as string for the param struct, change according to the above. */
+#define MPG123_TERM_USR1 "s"
+#define MPG123_TERM_USR2 "f"
+
+void term_init(void);
+off_t term_control(mpg123_handle *mh, audio_output_t *ao);
+void term_restore(void);
+void term_hint(void); /* Print a message hinting at terminal usage. */
+
+#endif
+
+#endif

data/mpg123/src/tests/noise.c

@@ -0,0 +1,52 @@
+#include "config.h"
+#include "compat.h"
+#include "dither.h"
+#include "debug.h"
+
+const char *typenames[] = { "white", "tpdf", "highpass_tpdf" };
+enum mpg123_noise_type types[] = { mpg123_white_noise, mpg123_tpdf_noise, mpg123_highpass_tpdf_noise };
+
+int main(int argc, char **argv)
+{
+	size_t i;
+	size_t count = DITHERSIZE;
+	float *table;
+	enum mpg123_noise_type type = mpg123_highpass_tpdf_noise;
+
+	fprintf(stderr, "Note: You could give two optional arguments: noise type and table size (number count).\n");
+	if(argc > 1)
+	{
+		const char *typename = argv[1];
+		for(i=0; i<sizeof(typenames)/sizeof(char*); ++i)
+		if(strcmp(typename, typenames[i]) == 0)
+		{
+			type = types[i];
+			break;
+		}
+
+		if(i == sizeof(typenames)/sizeof(char*))
+		{
+			error("Unknown noise type!");
+			return -1;
+		}
+	}
+	if(argc > 2)
+	{
+		count = (size_t) atol(argv[2]);
+	}
+
+	table = malloc(sizeof(float)*count);
+	if(table == NULL)
+	{
+		error("Cannot allocate memory for noise table!");
+		return -2;
+	}
+
+	mpg123_noise(table, count, type);
+	for(i=0; i<count; ++i)
+	printf("%g\n", table[i]);
+
+	free(table);
+
+	return 0;
+}

data/mpg123/src/tests/plain_id3.c

@@ -0,0 +1,109 @@
+/* Just printing out ID3 tags with plain data from libmpg123 and explicitly called conversion routine. */
+
+#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;
+}
+
+void print_field(const char *name, mpg123_string *sb)
+{
+	const unsigned char *sbp = (unsigned char*)sb->p;
+	enum mpg123_text_encoding enc;
+	mpg123_string printer;
+	mpg123_init_string(&printer);
+	printf("\n=== %s ===\n", name);
+	if(sb->fill == 0)
+	{
+		printf("Oh, empty. Totally.\n");
+		return;
+	}
+
+	enc = mpg123_enc_from_id3(sbp[0]);
+
+	printf("From encoding: %i (in ID3: %i)\n", enc, (int)sbp[0]) ;
+	if(mpg123_store_utf8(&printer, enc, sbp+1, sb->fill-1))
+	{
+		/* Not caring for multiple strings separated via null bytes here. */
+		printf("Value: %s\n", printer.p);
+	}
+	else error("Conversion failed!");
+	mpg123_free_string(&printer);
+}
+
+
+int main(int argc, char **argv)
+{
+	int err;
+	int ret = 0;
+	mpg123_handle *mh;
+	mpg123_id3v2 *id3;
+
+	if(argc < 2)
+	{
+		printf("Gimme a MPEG file name...\n");
+		return 0;
+	}
+
+	mpg123_init();
+	mh = mpg123_new(NULL, &err);
+	if(err != MPG123_OK) goto badend;
+
+	mpg123_param(mh, MPG123_ADD_FLAGS, MPG123_PLAIN_ID3TEXT, 0.);
+
+	err = mpg123_open(mh, argv[1]);
+	if(err != MPG123_OK) goto badend;
+
+	err = mpg123_scan(mh);
+	if(err != MPG123_OK) goto badend;
+
+	err = mpg123_id3(mh, NULL, &id3);
+	if(err != MPG123_OK) goto badend;
+
+	if(id3 == NULL)
+	{
+		error("No ID3 data found.");
+		goto badend;
+	}
+
+	print_field("artist", id3->artist);
+	print_field("title", id3->title);
+	print_field("album", id3->album);
+	print_field("comment", id3->comment);
+
+	goto end;
+badend:
+	ret = -1;
+end:
+	mpg123_delete(mh);
+	mpg123_exit();
+	return ret;
+}

data/mpg123/src/tests/seek_accuracy.c

@@ -0,0 +1,261 @@
+/*
+	seek-accuracy: Take some given mpeg file and validate that seeks are indeed accurate.
+
+	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 preframes testfile.mpeg
+*/
+
+#include <mpg123.h>
+#include <compat.h>
+
+#define SAMPLES 1000
+/* Cannot use the const value as fixed array size:-( */
+const size_t samples = SAMPLES;
+
+/* Use getlopt.c in future? But heck, don't bloat. */
+enum theargs
+{
+	 arg_binname = 0
+	,arg_decoder
+	,arg_preframes
+	,arg_file
+	,arg_total
+};
+
+const char* filename;
+int channels;
+mpg123_handle *m;
+size_t first_sample_errs = 0;
+
+
+int check_seeking(size_t *errs);
+
+int main(int argc, char **argv)
+{
+	int ret = 0;
+	size_t errs[2] = {0, 0};
+	size_t errs_ntom[2] = {0, 0};
+
+	if(argc < arg_total)
+	{
+		fprintf(stderr, "\nUsage: %s <decoder> <preframes> <mpeg audio file>\n\n", argv[0]);
+		return -1;
+	}
+	mpg123_init();
+	m = mpg123_new(argv[arg_decoder], NULL);
+	mpg123_param(m, MPG123_RESYNC_LIMIT, -1, 0);
+
+	if(mpg123_param(m, MPG123_PREFRAMES, atol(argv[arg_preframes]), 0) == MPG123_OK)
+	printf("Testing library with preframes set to %li\n", atol(argv[arg_preframes]));
+
+	filename = argv[arg_file];
+	ret = check_seeking(errs);
+
+	if(ret == 0)
+	{
+		printf("Now with NtoM resampling to 33333 Hz!");
+		mpg123_param(m, MPG123_FORCE_RATE, 33333, 0);
+		ret = check_seeking(errs_ntom);
+	}
+	else fprintf(stderr, "Some failure occured! Unable to test properly!");
+
+	printf("\n");
+	printf("1to1 indexed seek errors: %"SIZE_P" / %"SIZE_P"\n", (size_p)errs[0],(size_p)samples);
+	printf("1to1 non-indexed seek errors: %"SIZE_P" / %"SIZE_P"\n", (size_p)errs[1],(size_p)samples);
+	printf("NtoM indexed seek errors: %"SIZE_P" / %"SIZE_P"\n", (size_p)errs_ntom[0],(size_p)samples);
+	printf("NtoM non-indexed seek errors: %"SIZE_P" / %"SIZE_P"\n", (size_p)errs_ntom[1],(size_p)samples);
+	printf("Errors in getting first sample again: %"SIZE_P"\n", first_sample_errs);
+	printf("\n");
+
+	if(ret == 0)
+	{
+
+		if(first_sample_errs == 0 && errs[0] == 0 && errs[1] == 0 && errs_ntom[0] == 0 && errs_ntom[1] == 0)
+		{
+			printf("Congratulations, all seeks were accurate!\n");
+			printf("But be warned: Not _all_ sample offsets have been tested. This result just means that the basic mechanism of sample-accurate seeking seems to work.\n");
+		}
+		else
+		{
+			printf("There have been some errors. For layer 3 files, this may be due to too low MPG123_PREFRAMES.\n");
+			ret = -1;
+		}
+
+	}
+	else fprintf(stderr, "Some bad failure during checking!\n");
+
+	mpg123_delete(m);
+	mpg123_exit();
+
+	return ret;
+}
+
+int open_file()
+{
+	if( mpg123_open(m, filename) == MPG123_OK
+	     &&
+	    mpg123_getformat(m, NULL, &channels, NULL) == MPG123_OK )
+	{
+		printf("Channels: %i\n", channels);
+		return 0;
+	}
+	else
+	{
+		printf("Opening file failed: %s\n", mpg123_strerror(m));
+		return -1;
+	}
+}
+
+/* Operation:
+	Read through the whole file and remember selected samples and their position.
+	Then, seek to the positions selectively and compare.
+	Second mode: Check if this is identical to fresh decoding and seek (without frame index table)... less important now, focusing on the first one.
+*/
+
+struct seeko
+{
+	off_t position[SAMPLES];
+	short left[SAMPLES];
+	short right[SAMPLES];
+};
+
+/* select some positions to check seek accuracy on */
+void fix_positions(struct seeko *so, off_t length)
+{
+	off_t step = (length-1)/(samples-1);
+	size_t i;
+	/* simple fixed stepping, in order (one could shuffle this) */
+	for(i=0; i<samples-1; ++i)
+	so->position[i] = i*step;
+
+	/* plus the last one! */
+	so->position[samples-1] = length-1;
+}
+
+int collect(struct seeko *so)
+{
+	off_t pos_count = 0;
+	off_t length;
+	int err = MPG123_OK;
+	size_t posi = 0;
+	mpg123_scan(m);
+	length = mpg123_length(m);
+	printf("Estimated length: %"OFF_P"\n", (off_p)length);
+	/* Compute the interesting positions */
+	fix_positions(so, length);
+	/*
+		Default format is always 16bit int, rate does not matter.
+		Let's just get the channel count and not bother.
+	*/
+	while(err == MPG123_OK)
+	{
+		short buff[1024]; /* choosing a non-divider of mpeg frame size on purpose */
+		size_t got = 0;
+		off_t buffsamples;
+		err = mpg123_read(m, (unsigned char*)buff, 1024*sizeof(short), &got);
+		buffsamples = got/(channels*sizeof(short));
+		while(so->position[posi] < pos_count+buffsamples)
+		{
+			size_t i = (so->position[posi]-pos_count)*channels;
+			printf("got sample %"SIZE_P" (%"OFF_P")\n", (size_p)posi, (off_p)so->position[posi]);
+			so->left[posi] = buff[i];
+			if(channels == 2)
+			so->right[posi] = buff[i+1];
+
+			if(++posi >= samples) break;
+		}
+		if(posi >= samples) break;
+
+		pos_count += buffsamples;
+	}
+	if(posi < samples && (err != MPG123_DONE && err != MPG123_OK))
+	{
+		printf("An error occured (not done)?: %s\n", mpg123_strerror(m));
+		return -1;
+	}
+	return 0;
+}
+
+/* We allow some minimal difference ... for subtle floating point effects. */
+int same(short a, short b)
+{
+	return (abs(a-b) <= 2);
+}
+
+int check_sample(struct seeko *so, size_t i)
+{
+	short buf[2]; /* at max one left and right sample */
+	size_t got = 0;
+
+	if(mpg123_seek(m, so->position[i], SEEK_SET) != so->position[i])
+	{
+		printf("Error seeking to %"OFF_P": %s\n", (off_p)so->position[i],  mpg123_strerror(m));
+		return -1;
+	}
+
+	if( mpg123_read(m, (unsigned char*)buf, channels*sizeof(short), &got) != MPG123_OK
+		 ||
+		 got/sizeof(short) != channels )
+	{
+		printf("Error occured on reading sample %"SIZE_P"! (%s)\n", (size_p)i, mpg123_strerror(m));
+		return -1;
+	}
+	if(same(buf[0], so->left[i]) && (channels == 1 || same(buf[1], so->right[i])))
+	{
+		printf("sample %"SIZE_P" PASS\n", (size_p)i);
+	}
+	else
+	{
+		if(channels == 1) printf("sample %"SIZE_P" FAIL (%i != %i)\n", (size_p)i, buf[0], so->left[i]);
+		else printf("sample %"SIZE_P" FAIL (%i != %i || %i != %i)\n", (size_p)i, buf[0], so->left[i], buf[1], so->right[i]);
+		return -1;
+	}
+	return 0;
+}
+
+size_t check_positions(struct seeko *so)
+{
+	size_t i;
+	size_t errs = 0;
+	printf("Seeking and comparing...\n");
+	for(i=0; i<samples; ++i)
+	{
+		if(check_sample(so, i) != 0)
+		++errs;
+	}
+	printf("Check the first one again, seeking back from the end.\n");
+	if(check_sample(so, 0) != 0)
+	++first_sample_errs;
+
+	return errs;
+}
+
+int check_seeking(size_t *errs)
+{
+	struct seeko so;
+	int ret = 0;
+
+	/* First opening. */
+	if(open_file() != 0) return -1;
+
+	printf("Collecting samples...\n");
+	ret = collect(&so);
+	if(ret != 0) return ret;
+
+	errs[0] = check_positions(&so);
+
+	printf("With fresh opening (empty seek index):\n");
+	if(open_file() != 0) return -1;
+
+	errs[1] = check_positions(&so);
+
+	printf("Another fresh Opening to see if first sample works:\n");
+	if(open_file() != 0) return -1;
+	if(check_sample(&so, 0) != 0)
+	++first_sample_errs;
+
+	return ret;
+}