seal 0.1.0

data/mpg123/doc/examples/extract_frames.c

@@ -0,0 +1,92 @@
+/*
+	extract_frams: utlize the framebyframe API and mpg123_framedata to extract the MPEG frames out of a stream (strip off anything else).
+
+	copyright 2011 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
+*/
+
+#include <mpg123.h>
+
+/* unistd.h is not available under MSVC, 
+ io.h defines the read and write functions */
+#ifndef _MSC_VER
+#include <unistd.h>
+#else
+#include <io.h>
+#endif
+
+#include <stdio.h>
+
+int do_work(mpg123_handle *m);
+
+int main(int argc, char **argv)
+{
+	int ret = 0;
+	mpg123_handle *m;
+
+	mpg123_init();
+	m = mpg123_new(NULL, &ret);
+
+	if(m == NULL)
+	{
+		fprintf(stderr, "Cannot create handle: %s", mpg123_plain_strerror(ret));
+	}
+	else
+	{
+		fprintf(stderr, "I'll take your dirty MPEG audio from standard input and will write the extrated pure MPEG data to stadard output.\n");
+		if(argc > 1 && strcmp(argv[1], "--noinfo") == 0)
+		{
+			fprintf(stderr, "Enabling parsing/consuming of the Info frame so that it will not appear in output.\n");
+			ret = mpg123_param(m, MPG123_REMOVE_FLAGS, MPG123_IGNORE_INFOFRAME, 0.);
+		}
+		else
+		{
+			fprintf(stderr, "If you'd have given --noinfo as argument, I would omit a LAME/Xing info frame.\n");
+			ret = mpg123_param(m, MPG123_ADD_FLAGS, MPG123_IGNORE_INFOFRAME, 0.);
+		}
+		if(ret == 0) ret = do_work(m);
+
+		if(ret != 0) fprintf(stderr, "Some error occured: %s\n", mpg123_strerror(m));
+
+
+		mpg123_delete(m); /* Closes, too. */
+	}
+	mpg123_exit();
+
+	return ret;
+}
+
+int do_work(mpg123_handle *m)
+{
+	int ret;
+	size_t count = 0;
+	ret = mpg123_open_fd(m, STDIN_FILENO);
+	if(ret != MPG123_OK) return ret;
+
+	while( (ret = mpg123_framebyframe_next(m)) == MPG123_OK || ret == MPG123_NEW_FORMAT )
+	{
+		unsigned long header;
+		unsigned char *bodydata;
+		size_t bodybytes;
+		if(mpg123_framedata(m, &header, &bodydata, &bodybytes) == MPG123_OK)
+		{
+			/* Need to extract the 4 header bytes from the native storage in the correct order. */
+			unsigned char hbuf[4];
+			int i;
+			for(i=0; i<4; ++i) hbuf[i] = (unsigned char) ((header >> ((3-i)*8)) & 0xff);
+
+			/* Now write out both header and data, fire and forget. */
+			write(STDOUT_FILENO, hbuf, 4);
+			write(STDOUT_FILENO, bodydata, bodybytes);
+			fprintf(stderr, "%zu: header 0x%08x, %zu body bytes\n", ++count, header, bodybytes);
+		}
+	}
+
+	if(ret != MPG123_DONE)
+	fprintf(stderr, "Some error occured (non-fatal?): %s\n", mpg123_strerror(m));
+
+	fprintf(stderr, "Done with %zu MPEG frames.\n", count);
+
+	return 0;
+}

data/mpg123/doc/examples/feedseek.c

@@ -0,0 +1,238 @@
+/*
+	feedseek: test program for libmpg123, showing how to use fuzzy seeking in feeder mode
+	copyright 2008 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	
+*/
+
+#include <mpg123.h>
+#include <stdio.h>
+
+#define INBUFF  16384 * 2 * 2
+#define WAVE_FORMAT_PCM 0x0001
+#define WAVE_FORMAT_IEEE_FLOAT 0x0003
+
+FILE *out;
+size_t totaloffset, dataoffset;
+long rate;
+int channels, enc;
+unsigned short bitspersample, wavformat;
+
+// write wav header
+void initwav()
+{
+	unsigned int tmp32 = 0;
+	unsigned short tmp16 = 0;
+
+	fwrite("RIFF", 1, 4, out);
+	totaloffset = ftell(out);
+
+	fwrite(&tmp32, 1, 4, out); // total size
+	fwrite("WAVE", 1, 4, out);
+	fwrite("fmt ", 1, 4, out);
+	tmp32 = 16;
+	fwrite(&tmp32, 1, 4, out); // format length
+	tmp16 = wavformat;
+	fwrite(&tmp16, 1, 2, out); // format
+	tmp16 = channels;
+	fwrite(&tmp16, 1, 2, out); // channels
+	tmp32 = rate;
+	fwrite(&tmp32, 1, 4, out); // sample rate
+	tmp32 = rate * bitspersample/8 * channels;
+	fwrite(&tmp32, 1, 4, out); // bytes / second
+	tmp16 = bitspersample/8 * channels; // float 16 or signed int 16
+	fwrite(&tmp16, 1, 2, out); // block align
+	tmp16 = bitspersample;
+	fwrite(&tmp16, 1, 2, out); // bits per sample
+	fwrite("data ", 1, 4, out);
+	tmp32 = 0;
+	dataoffset = ftell(out);
+	fwrite(&tmp32, 1, 4, out); // data length
+}
+
+// rewrite wav header with final length infos
+void closewav()
+{
+	unsigned int tmp32 = 0;
+	unsigned short tmp16 = 0;
+
+	long total = ftell(out);
+	fseek(out, totaloffset, SEEK_SET);
+	tmp32 = total - (totaloffset + 4);
+	fwrite(&tmp32, 1, 4, out);
+	fseek(out, dataoffset, SEEK_SET);
+	tmp32 = total - (dataoffset + 4);
+
+	fwrite(&tmp32, 1, 4, out);
+}
+
+// determine correct wav format and bits per sample
+// from mpg123 enc value
+void initwavformat()
+{
+	if(enc & MPG123_ENC_FLOAT_64)
+	{
+		bitspersample = 64;
+		wavformat = WAVE_FORMAT_IEEE_FLOAT;
+	}
+	else if(enc & MPG123_ENC_FLOAT_32)
+	{
+		bitspersample = 32;
+		wavformat = WAVE_FORMAT_IEEE_FLOAT;
+	}
+	else if(enc & MPG123_ENC_16)
+	{
+		bitspersample = 16;
+		wavformat = WAVE_FORMAT_PCM;
+	}
+	else
+	{
+		bitspersample = 8;
+		wavformat = WAVE_FORMAT_PCM;
+	}
+}
+
+int main(int argc, char **argv)
+{
+	unsigned char buf[INBUFF];
+	unsigned char *audio;
+	FILE *in;
+	mpg123_handle *m;
+	int ret, state;
+	size_t inc, outc;
+	off_t len, num;
+	size_t bytes;
+	off_t inoffset;
+	inc = outc = 0;
+
+	if(argc < 3)
+	{
+		fprintf(stderr,"Please supply in and out filenames\n");
+		return -1;
+	}
+
+	mpg123_init();
+
+	m = mpg123_new(NULL, &ret);
+	if(m == NULL)
+	{
+		fprintf(stderr,"Unable to create mpg123 handle: %s\n", mpg123_plain_strerror(ret));
+		return -1;
+	}
+
+	mpg123_param(m, MPG123_VERBOSE, 2, 0);
+
+	ret = mpg123_param(m, MPG123_FLAGS, MPG123_FUZZY | MPG123_SEEKBUFFER | MPG123_GAPLESS, 0);
+	if(ret != MPG123_OK)
+	{
+		fprintf(stderr,"Unable to set library options: %s\n", mpg123_plain_strerror(ret));
+		return -1;
+	}
+
+	// Let the seek index auto-grow and contain an entry for every frame
+	ret = mpg123_param(m, MPG123_INDEX_SIZE, -1, 0);
+	if(ret != MPG123_OK)
+	{
+		fprintf(stderr,"Unable to set index size: %s\n", mpg123_plain_strerror(ret));
+		return -1;
+	}
+
+	ret = mpg123_format_none(m);
+	if(ret != MPG123_OK)
+	{
+		fprintf(stderr,"Unable to disable all output formats: %s\n", mpg123_plain_strerror(ret));
+		return -1;
+	}
+	
+	// Use float output
+	ret = mpg123_format(m, 44100, MPG123_MONO | MPG123_STEREO,  MPG123_ENC_FLOAT_32);
+	if(ret != MPG123_OK)
+	{
+		fprintf(stderr,"Unable to set float output formats: %s\n", mpg123_plain_strerror(ret));
+		return -1;
+	}
+
+	ret = mpg123_open_feed(m);
+	if(ret != MPG123_OK)
+	{
+		fprintf(stderr,"Unable open feed: %s\n", mpg123_plain_strerror(ret));
+		return -1;
+	}
+
+	in = fopen(argv[1], "rb");
+	if(in == NULL)
+	{
+		fprintf(stderr,"Unable to open input file %s\n", argv[1]);
+		return -1;
+	}
+	
+	out = fopen(argv[2], "wb");
+	if(out == NULL)
+	{
+		fclose(in);
+		fprintf(stderr,"Unable to open output file %s\n", argv[2]);
+		return -1;
+	}
+
+	fprintf(stderr, "Seeking...\n");
+	/* That condition is tricky... parentheses are crucial... */
+	while((ret = mpg123_feedseek(m, 95000, SEEK_SET, &inoffset)) == MPG123_NEED_MORE)
+	{
+		len = fread(buf, sizeof(unsigned char), INBUFF, in);
+		if(len <= 0)
+			break;
+		inc += len;
+
+		state = mpg123_feed(m, buf, len);
+		if(state == MPG123_ERR)
+		{
+			fprintf(stderr, "Error: %s", mpg123_strerror(m));
+			return -1; 
+		}
+	}
+	if(ret == MPG123_ERR)
+	{
+		fprintf(stderr, "Feedseek failed: %s\n", mpg123_strerror(m));
+		return -1;
+	}
+
+	fseek(in, inoffset, SEEK_SET);	
+	
+	fprintf(stderr, "Starting decode...\n");
+	while(1)
+	{
+		len = fread(buf, sizeof(unsigned char), INBUFF, in);
+		if(len <= 0)
+			break;
+		inc += len;
+		ret = mpg123_feed(m, buf, len);
+
+		while(ret != MPG123_ERR && ret != MPG123_NEED_MORE)
+		{
+			ret = mpg123_decode_frame(m, &num, &audio, &bytes);
+			if(ret == MPG123_NEW_FORMAT)
+			{
+				mpg123_getformat(m, &rate, &channels, &enc);
+				initwavformat();
+				initwav();
+				fprintf(stderr, "New format: %li Hz, %i channels, encoding value %i\n", rate, channels, enc);
+			}
+			fwrite(audio, sizeof(unsigned char), bytes, out);
+			outc += bytes;
+		}
+
+		if(ret == MPG123_ERR)
+		{
+			fprintf(stderr, "Error: %s", mpg123_strerror(m));
+			break; 
+		}
+	}
+
+	fprintf(stderr, "Finished\n", (unsigned long)inc, (unsigned long)outc);
+
+	closewav();
+	fclose(out);
+	fclose(in);
+	mpg123_delete(m);
+	mpg123_exit();
+	return 0;
+}

data/mpg123/doc/examples/id3dump.c

@@ -0,0 +1,178 @@
+/*
+	id3dump: Print ID3 tags of files, scanned using libmpg123.
+
+	copyright 2007 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
+*/
+
+#include "mpg123.h"
+#include <string.h>
+#include "stdio.h"
+#include "sys/types.h"
+
+/* Helper for v1 printing, get these strings their zero byte. */
+void safe_print(char* name, char *data, size_t size)
+{
+	char safe[31];
+	if(size>30) return;
+
+	memcpy(safe, data, size);
+	safe[size] = 0;
+	printf("%s: %s\n", name, safe);
+}
+
+/* Print out ID3v1 info. */
+void print_v1(mpg123_id3v1 *v1)
+{
+	safe_print("Title",   v1->title,   sizeof(v1->title));
+	safe_print("Artist",  v1->artist,  sizeof(v1->artist));
+	safe_print("Album",   v1->album,   sizeof(v1->album));
+	safe_print("Year",    v1->year,    sizeof(v1->year));
+	safe_print("Comment", v1->comment, sizeof(v1->comment));
+	printf("Genre: %i", v1->genre);
+}
+
+/* Split up a number of lines separated by \n, \r, both or just zero byte
+   and print out each line with specified prefix. */
+void print_lines(const char* prefix, mpg123_string *inlines)
+{
+	size_t i;
+	int hadcr = 0, hadlf = 0;
+	char *lines = NULL;
+	char *line  = NULL;
+	size_t len = 0;
+
+	if(inlines != NULL && inlines->fill)
+	{
+		lines = inlines->p;
+		len   = inlines->fill;
+	}
+	else return;
+
+	line = lines;
+	for(i=0; i<len; ++i)
+	{
+		if(lines[i] == '\n' || lines[i] == '\r' || lines[i] == 0)
+		{
+			char save = lines[i]; /* saving, changing, restoring a byte in the data */
+			if(save == '\n') ++hadlf;
+			if(save == '\r') ++hadcr;
+			if((hadcr || hadlf) && hadlf % 2 == 0 && hadcr % 2 == 0) line = "";
+
+			if(line)
+			{
+				lines[i] = 0;
+				printf("%s%s\n", prefix, line);
+				line = NULL;
+				lines[i] = save;
+			}
+		}
+		else
+		{
+			hadlf = hadcr = 0;
+			if(line == NULL) line = lines+i;
+		}
+	}
+}
+
+/* Print out the named ID3v2  fields. */
+void print_v2(mpg123_id3v2 *v2)
+{
+	print_lines("Title: ",   v2->title);
+	print_lines("Artist: ",  v2->artist);
+	print_lines("Album: ",   v2->album);
+	print_lines("Year: ",    v2->year);
+	print_lines("Comment: ", v2->comment);
+	print_lines("Genre: ",   v2->genre);
+}
+
+/* Print out all stored ID3v2 fields with their 4-character IDs. */
+void print_raw_v2(mpg123_id3v2 *v2)
+{
+	size_t i;
+	for(i=0; i<v2->texts; ++i)
+	{
+		char id[5];
+		char lang[4];
+		memcpy(id, v2->text[i].id, 4);
+		id[4] = 0;
+		memcpy(lang, v2->text[i].lang, 3);
+		lang[3] = 0;
+		if(v2->text[i].description.fill)
+		printf("%s language(%s) description(%s)\n", id, lang, v2->text[i].description.p);
+		else printf("%s language(%s)\n", id, lang);
+
+		print_lines(" ", &v2->text[i].text);
+	}
+	for(i=0; i<v2->extras; ++i)
+	{
+		char id[5];
+		memcpy(id, v2->extra[i].id, 4);
+		id[4] = 0;
+		printf( "%s description(%s)\n",
+		        id,
+		        v2->extra[i].description.fill ? v2->extra[i].description.p : "" );
+		print_lines(" ", &v2->extra[i].text);
+	}
+	for(i=0; i<v2->comments; ++i)
+	{
+		char id[5];
+		char lang[4];
+		memcpy(id, v2->comment_list[i].id, 4);
+		id[4] = 0;
+		memcpy(lang, v2->comment_list[i].lang, 3);
+		lang[3] = 0;
+		printf( "%s description(%s) language(%s): \n",
+		        id,
+		        v2->comment_list[i].description.fill ? v2->comment_list[i].description.p : "",
+		        lang );
+		print_lines(" ", &v2->comment_list[i].text);
+	}
+}
+
+int main(int argc, char **argv)
+{
+	int i;
+	mpg123_handle* m;
+	if(argc < 2)
+	{
+		fprintf(stderr, "\nI will print some ID3 tag fields of MPEG audio files.\n");
+		fprintf(stderr, "\nUsage: %s <mpeg audio file list>\n\n", argv[0]);
+		return -1;
+	}
+	mpg123_init();
+	m = mpg123_new(NULL, NULL);
+
+	for(i=1; i < argc; ++i)
+	{
+		mpg123_id3v1 *v1;
+		mpg123_id3v2 *v2;
+		int meta;
+		if(mpg123_open(m, argv[i]) != MPG123_OK)
+		{
+			fprintf(stderr, "Cannot open %s: %s\n", argv[i], mpg123_strerror(m));
+			continue;
+		}
+		mpg123_scan(m);
+		meta = mpg123_meta_check(m);
+		if(meta & MPG123_ID3 && mpg123_id3(m, &v1, &v2) == MPG123_OK)
+		{
+			printf("Tag data on %s:\n", argv[i]);
+			printf("\n====      ID3v1       ====\n");
+			if(v1 != NULL) print_v1(v1);
+
+			printf("\n====      ID3v2       ====\n");
+			if(v2 != NULL) print_v2(v2);
+
+			printf("\n==== ID3v2 Raw frames ====\n");
+			if(v2 != NULL) print_raw_v2(v2);
+		}
+		else printf("Nothing found for %s.\n", argv[i]);
+
+		mpg123_close(m);
+	}
+	mpg123_delete(m);
+	mpg123_exit();
+	return 0;
+}