catori 0.2.5

data/ext/flac/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+$CFLAGS+=" -Wall"
+dir_config("flac")
+have_library("FLAC");
+create_makefile("flac");

data/ext/flac/flac.c

@@ -0,0 +1,75 @@
+#include "FLAC/metadata.h"
+#include "ruby.h"
+#include <ctype.h>
+#include <string.h>
+static VALUE    mFlac;
+static VALUE    cInfo;
+// static VALUE rb_cinfo_new(VALUE self);
+static VALUE    rb_flac_info(VALUE module, VALUE filename);
+static void     set_tag(FLAC__StreamMetadata_VorbisComment_Entry * tag,
+			VALUE info);
+void
+Init_flac()
+{
+    mFlac = rb_define_module("Flac");
+    cInfo = rb_define_class_under(mFlac, "Info", rb_cObject);
+    int             i = 0;
+#define NA 5
+    const char     *attr2[NA] =
+	{ "time", "sample_rate", "channels", "bits_per_sample", "comments"
+    };
+    for (i = 0; i < NA; i++) {
+	rb_define_attr(cInfo, attr2[i], 1, 0);
+    }
+
+    rb_define_module_function(mFlac, "info", rb_flac_info, 1);
+}
+
+VALUE
+rb_flac_info(VALUE self, VALUE filename)
+{
+    FLAC__StreamMetadata si;
+    FLAC__StreamMetadata *tags;
+    // char *tag;
+    char           *cfilename = STR2CSTR(filename);
+    FLAC__metadata_get_streaminfo(cfilename, &si);
+    int             i = 0;
+    VALUE           info = rb_class_new_instance(0, NULL, cInfo);
+    VALUE           comments = rb_hash_new();
+    double           time =
+	(double) si.data.stream_info.total_samples /
+	(double) si.data.stream_info.sample_rate;
+    rb_iv_set(info, "@sample_rate",
+	      INT2FIX(si.data.stream_info.sample_rate));
+    rb_iv_set(info, "@channels", INT2FIX(si.data.stream_info.channels));
+    rb_iv_set(info, "@bits_per_sample",
+	      INT2FIX(si.data.stream_info.bits_per_sample));
+    rb_iv_set(info, "@time", rb_float_new(time));
+    FLAC__metadata_get_tags(cfilename, &tags);
+    for (i = 0; i < tags->data.vorbis_comment.num_comments; i++) {
+	set_tag(&(tags->data.vorbis_comment.comments[i]), comments);
+    }
+    rb_iv_set(info, "@comments", comments);
+    FLAC__metadata_object_delete(tags);
+    return info;
+}
+
+static void
+set_tag(FLAC__StreamMetadata_VorbisComment_Entry * tag, VALUE comments)
+{
+    // printf("%s\n",tag->entry);
+    char           *s = tag->entry;
+    char           *equals_pos = strchr(s, '=');
+    VALUE           key,
+                    value;
+    if (0 != equals_pos) {
+	int             i = 0;
+
+	for (; i < equals_pos - s; i++) {
+	    s[i] = tolower(s[i]);
+	}
+	key = rb_str_new(s, equals_pos - s);
+	value = rb_str_new(equals_pos + 1, strlen(equals_pos + 1));
+	rb_hash_aset(comments, key, value);
+    }
+}

data/ext/flac/mkmf.log

@@ -0,0 +1,12 @@
+have_library: checking for main() in -lFLAC... -------------------- yes
+
+"i686-pc-linux-gnu-gcc -o conftest -I. -I/usr/lib/ruby/1.8/i686-linux -I.  -O2 -march=athlon-xp -m3dnow -msse -mfpmath=sse -mmmx -pipe -fno-strict-aliasing  -fPIC -Wall conftest.c  -L'.' -L'/usr/lib' -Wl,-R'/usr/lib' -L.  -rdynamic -Wl,-export-dynamic     -lruby18-static -lFLAC  -ldl -lcrypt -lm   -lc"
+checked program was:
+/* begin */
+1: /*top*/
+2: int main() { return 0; }
+3: int t() { void ((*volatile p)()); p = (void ((*)()))main; return 0; }
+/* end */
+
+--------------------
+

data/ext/flac/test.rb

@@ -0,0 +1,3 @@
+require 'flac'
+
+p Flac.info("test.flac")

data/ext/mahoro-0.1/INSTALL

@@ -0,0 +1,9 @@
+ INSTALL
+=========
+
+The installation is simple, install libmagic and type the following.
+
+> ruby extconf.rb --with-magic-include=/path/to/include \
+                  --with-magic-lib=/path/to/lib
+> make
+# make install

data/ext/mahoro-0.1/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+dir_config('magic')
+have_library('magic', 'magic_open')
+create_makefile('mahoro')
+
+# arch-tag: extconf

data/ext/mahoro-0.1/mahoro.c

@@ -0,0 +1,187 @@
+/*
+ * This file is Public Domain.
+ */
+
+#include <ruby.h>
+#include <magic.h>
+
+struct MagicCookie
+{
+	magic_t cookie;
+};
+
+static VALUE cMahoro;
+static VALUE eMahoroError;
+
+static void
+mahoro_free(ptr)
+	struct MagicCookie *ptr;
+{
+	magic_close(ptr->cookie);
+	free(ptr);
+}
+
+static VALUE
+mahoro_allocate(klass)
+	VALUE klass;
+{
+	return Data_Wrap_Struct(klass, 0, mahoro_free, 0);
+}
+
+static VALUE
+mahoro_initialize(argc, argv, self)
+	int argc;
+	VALUE *argv, self;
+{
+	int flags = MAGIC_NONE;
+	char *path = 0;
+	struct MagicCookie *ptr;
+	magic_t cookie;
+	VALUE vpath, vflags;
+
+	switch(rb_scan_args(argc, argv, "02", &vflags, &vpath)) {
+		case 2:
+			if(!NIL_P(vpath)) {
+				path = StringValuePtr(vpath);
+			}
+			/* fallthrough */
+		case 1:
+			flags = FIX2INT(vflags);
+			break;
+	}
+
+	if(!(cookie = magic_open(flags))) {
+		rb_raise(eMahoroError, "failed to initialize magic cookie");
+	}
+
+	if(magic_load(cookie, path)) {
+		rb_raise(eMahoroError, "failed to load database: %s",
+		                      magic_error(cookie));
+	}
+
+	ptr = ALLOC(struct MagicCookie);
+	ptr->cookie = cookie;
+	DATA_PTR(self) = ptr;
+
+	return self;
+}
+
+static VALUE
+mahoro_file(self, path)
+	VALUE self, path;
+{
+	const char *msg;
+	magic_t cookie = ((struct MagicCookie *) DATA_PTR(self))->cookie;
+
+	if(!(msg = magic_file(cookie, StringValuePtr(path)))) {
+		rb_raise(eMahoroError, "failed lookup: %s", magic_error(cookie));
+	}
+
+	return rb_str_new2(msg);
+}
+
+static VALUE
+mahoro_buffer(self, input)
+	VALUE self, input;
+{
+	const char *msg;
+	magic_t cookie = ((struct MagicCookie *) DATA_PTR(self))->cookie;
+
+	if(!(msg = magic_buffer(cookie, StringValuePtr(input),
+	                                RSTRING(StringValue(input))->len))) {
+		rb_raise(eMahoroError, "failed lookup: %s", magic_error(cookie));
+	}
+
+	return rb_str_new2(msg);
+}
+
+static VALUE
+mahoro_set_flags(self, flags)
+	VALUE self, flags;
+{
+	magic_t cookie = ((struct MagicCookie *) DATA_PTR(self))->cookie;
+
+	return INT2FIX(magic_setflags(cookie, FIX2INT(flags)));
+}
+
+static VALUE
+mahoro_check(argc, argv, self)
+	int argc;
+	VALUE *argv, self;
+{
+	char *path = 0;
+	VALUE vpath;
+	magic_t cookie = ((struct MagicCookie *) DATA_PTR(self))->cookie;
+
+	switch(rb_scan_args(argc, argv, "01", &vpath)) {
+		case 1:
+			if(!NIL_P(vpath)) { 
+				path = StringValuePtr(vpath);
+			}
+			break;
+	}
+
+	if(!magic_check(cookie, path)) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+static VALUE
+mahoro_compile(klass, path)
+	VALUE klass, path;
+{
+	magic_t cookie = magic_open(MAGIC_NONE);
+
+	if(magic_compile(cookie, StringValuePtr(path))) {
+		rb_raise(eMahoroError, "failed compile: %s", magic_error(cookie));
+	}
+
+	magic_close(cookie);
+
+	return Qtrue;
+}
+
+static VALUE
+mahoro_load(self, path)
+	VALUE self, path;
+{
+	magic_t cookie = ((struct MagicCookie *) DATA_PTR(self))->cookie;
+
+	if(magic_load(cookie, StringValuePtr(path))) {
+		rb_raise(eMahoroError, "failed load: %s", magic_error(cookie));
+	}
+
+	return self;
+}
+
+void Init_mahoro(void)
+{
+	cMahoro      = rb_define_class("Mahoro", rb_cObject);
+	eMahoroError = rb_define_class_under(cMahoro, "Error", rb_eStandardError);
+
+	rb_const_set(cMahoro, rb_intern("NONE"), INT2FIX(MAGIC_NONE));
+	rb_const_set(cMahoro, rb_intern("DEBUG"), INT2FIX(MAGIC_DEBUG));
+	rb_const_set(cMahoro, rb_intern("SYMLINK"), INT2FIX(MAGIC_SYMLINK));
+	rb_const_set(cMahoro, rb_intern("COMPRESS"), INT2FIX(MAGIC_COMPRESS));
+	rb_const_set(cMahoro, rb_intern("DEVICES"), INT2FIX(MAGIC_DEVICES));
+	rb_const_set(cMahoro, rb_intern("MIME"), INT2FIX(MAGIC_MIME));
+	rb_const_set(cMahoro, rb_intern("CONTINUE"), INT2FIX(MAGIC_CONTINUE));
+	rb_const_set(cMahoro, rb_intern("CHECK"), INT2FIX(MAGIC_CHECK));
+	rb_const_set(cMahoro, rb_intern("PRESERVE_ATIME"),
+	                      INT2FIX(MAGIC_PRESERVE_ATIME));
+	rb_const_set(cMahoro, rb_intern("RAW"), INT2FIX(MAGIC_RAW));
+	rb_const_set(cMahoro, rb_intern("ERROR"), INT2FIX(MAGIC_ERROR));
+
+	rb_define_alloc_func(cMahoro, mahoro_allocate);
+	rb_define_method(cMahoro, "initialize", mahoro_initialize, -1);
+	rb_define_method(cMahoro, "file", mahoro_file, 1);
+	rb_define_method(cMahoro, "buffer", mahoro_buffer, 1);
+	rb_define_method(cMahoro, "flags=", mahoro_set_flags, 1);
+	rb_define_method(cMahoro, "valid?", mahoro_check, -1);
+	rb_define_singleton_method(cMahoro, "compile", mahoro_compile, 1);
+	rb_define_method(cMahoro, "load", mahoro_load, 1);
+}
+
+/* arch-tag: mahoro */

data/ext/mahoro-0.1/mkmf.log

@@ -0,0 +1,24 @@
+have_library: checking for magic_open() in -lmagic... -------------------- yes
+
+"i686-pc-linux-gnu-gcc -o conftest -I. -I/usr/lib/ruby/1.8/i686-linux -I.  -O2 -march=athlon-xp -m3dnow -msse -mfpmath=sse -mmmx -pipe -fno-strict-aliasing  -fPIC conftest.c  -L'.' -L'/usr/lib' -Wl,-R'/usr/lib' -L.  -rdynamic -Wl,-export-dynamic     -lruby18-static -lmagic  -ldl -lcrypt -lm   -lc"
+conftest.c: En la función ‘t’:
+conftest.c:3: error: ‘magic_open’ no se declaró aquí (primer uso en esta función)
+conftest.c:3: error: (Cada identificador no declarado solamente se reporta una vez
+conftest.c:3: error: ara cada funcion en la que aparece.)
+checked program was:
+/* begin */
+1: /*top*/
+2: int main() { return 0; }
+3: int t() { void ((*volatile p)()); p = (void ((*)()))magic_open; return 0; }
+/* end */
+
+"i686-pc-linux-gnu-gcc -o conftest -I. -I/usr/lib/ruby/1.8/i686-linux -I.  -O2 -march=athlon-xp -m3dnow -msse -mfpmath=sse -mmmx -pipe -fno-strict-aliasing  -fPIC conftest.c  -L'.' -L'/usr/lib' -Wl,-R'/usr/lib' -L.  -rdynamic -Wl,-export-dynamic     -lruby18-static -lmagic  -ldl -lcrypt -lm   -lc"
+checked program was:
+/* begin */
+1: /*top*/
+2: int main() { return 0; }
+3: int t() { magic_open(); return 0; }
+/* end */
+
+--------------------
+

data/ext/mahoro-0.1/test.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'mahoro'
+
+class MahoroTestCase < Test::Unit::TestCase
+
+	def initialize(*args)
+		super
+		@m = Mahoro.new
+	end
+
+	def test_file
+		@m.flags = Mahoro::NONE
+		assert_equal('ASCII C program text', @m.file('mahoro.c'))
+	end
+
+	def test_mime_file
+		@m.flags = Mahoro::MIME
+		assert_equal('text/x-c; charset=us-ascii', @m.file('mahoro.c'))
+	end
+
+	def test_buffer
+		@m.flags = Mahoro::NONE
+		assert_equal('ASCII C program text',
+		             @m.buffer(File.read('mahoro.c')))
+	end
+
+	def test_mime_buffer
+		@m.flags = Mahoro::MIME
+		assert_equal('text/x-c; charset=us-ascii',
+		             @m.buffer(File.read('mahoro.c')))
+	end
+
+	def test_valid
+		assert(@m.valid?, 'Default database was not valid.')
+	end
+
+end
+
+# arch-tag: test

data/ext/mpc/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+$CFLAGS+=" -Wall"
+dir_config("mpcdec")
+have_library("mpcdec");
+create_makefile("mpc");

data/ext/mpc/id3tag.c

@@ -0,0 +1,245 @@
+/*
+ * Musepack audio compression
+ * Copyright (C) 1999-2004 Buschmann/Klemm/Piecha/Wolf
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <string.h>
+#include "mppdec.h"
+
+
+/*
+ *  List of known Genres. 256 genres are possible with version 1/1.1 tags,
+ *  but not yet used.
+ */
+
+static const char*  GenreList [] = {
+    "Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge",
+    "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies", "Other", "Pop", "R&B",
+    "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative", "Ska",
+    "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient",
+    "Trip-Hop", "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical",
+    "Instrumental", "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise",
+    "AlternRock", "Bass", "Soul", "Punk", "Space", "Meditative",
+    "Instrumental Pop", "Instrumental Rock", "Ethnic", "Gothic", "Darkwave",
+    "Techno-Industrial", "Electronic", "Pop-Folk", "Eurodance", "Dream",
+    "Southern Rock", "Comedy", "Cult", "Gangsta", "Top 40", "Christian Rap",
+    "Pop/Funk", "Jungle", "Native American", "Cabaret", "New Wave",
+    "Psychadelic", "Rave", "Showtunes", "Trailer", "Lo-Fi", "Tribal",
+    "Acid Punk", "Acid Jazz", "Polka", "Retro", "Musical", "Rock & Roll",
+    "Hard Rock", "Folk", "Folk/Rock", "National Folk", "Swing", "Fast-Fusion",
+    "Bebob", "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde",
+    "Gothic Rock", "Progressive Rock", "Psychedelic Rock", "Symphonic Rock",
+    "Slow Rock", "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour",
+    "Speech", "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony",
+    "Booty Bass", "Primus", "Porn Groove", "Satire", "Slow Jam", "Club",
+    "Tango", "Samba", "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul",
+    "Freestyle", "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House",
+    "Dance Hall", "Goa", "Drum & Bass", "Club House", "Hardcore", "Terror",
+    "Indie", "BritPop", "NegerPunk", "Polsk Punk", "Beat", "Christian Gangsta",
+    "Heavy Metal", "Black Metal", "Crossover", "Contemporary C",
+    "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "JPop",
+    "SynthPop"
+};
+
+
+/*
+ *  Copies src to dst. Copying is stopped at `\0' char is detected or if
+ *  len chars are copied.
+ *  Trailing blanks are removed and the string is `\0` terminated.
+ */
+
+static void
+memcpy_crop ( char* dst, const char* src, size_t len )
+{
+    size_t  i;
+
+    for ( i = 0; i < len; i++ )
+        if  ( src[i] != '\0' )
+            dst[i] = src[i];
+        else
+            break;
+
+    // dst[i] points behind the string contents
+
+    while ( i > 0  &&  dst [i-1] == ' ' )
+        i--;
+    dst [i] = '\0';
+}
+
+
+/*
+ *  Evaluate ID version 1/1.1 tags of a file given by 'fp' and fills out Tag
+ *  information in 'tip'. Tag information also contains the effective file
+ *  length (without the tags if tags are present). Return 1 if there is
+ *  usable information inside the file. Note there's also the case possible
+ *  that the file contains empty tags, the the file size is truncated by the
+ *  128 bytes but the function returns 0.
+ *
+ *  If there're no tags, all strings containing '\0', the Genre pointer is
+ *  NULL and GenreNo and TrackNo are -1.
+ */
+
+Int
+Read_ID3V1_Tags ( FILE_T fp, TagInfo_t* tip )
+{
+    Uint8_t  tmp [128];
+    OFF_T    file_pos;
+
+    memset ( tip, 0, sizeof(*tip) );
+    tip->GenreNo = -1;
+    tip->TrackNo = -1;
+
+    if ( -1 == (file_pos = FILEPOS (fp)) )
+        return 0;
+    if ( -1 == SEEK ( fp, -128L, SEEK_END ) )
+        return 0;          
+
+    tip->FileSize = FILEPOS (fp);
+    if ( 128 != READ ( fp, tmp, 128 ) )
+        return 0;
+    SEEK ( fp, file_pos, SEEK_SET );
+
+    if ( 0 != memcmp ( tmp, "TAG", 3 ) ) {
+        tip->FileSize += 128;
+        return 0;
+    }
+
+    if ( !tmp[3]  &&  !tmp[33]  &&  !tmp[63]  &&  !tmp[93]  &&  !tmp[97] )
+        return 0;
+
+    memcpy_crop  ( tip->Title  , tmp +  3, 30 );
+    memcpy_crop  ( tip->Artist , tmp + 33, 30 );
+    memcpy_crop  ( tip->Album  , tmp + 63, 30 );
+    memcpy_crop  ( tip->Year   , tmp + 93,  4 );
+    memcpy_crop  ( tip->Comment, tmp + 97, 30 );
+
+    strcpy ( tip->Genre, tmp[127] < sizeof(GenreList)/sizeof(*GenreList)  ?
+                         GenreList [tip->GenreNo = tmp[127]]  :  "???" );
+
+    // Index 0 may be true if file is very short
+    if ( tmp[125] == 0  &&  (tmp[126] != 0  ||  tip->FileSize < 66000 ) )
+        sprintf ( tip->Track, "[%02d]", tip->TrackNo = tmp[126] );
+    else
+        strcpy ( tip->Track, "    " );
+
+    return 1;
+}
+
+
+struct APETagFooterStruct {
+    Uint8_t   ID       [8];    // should equal 'APETAGEX'
+    Uint8_t   Version  [4];    // currently 1000 (version 1.000)
+    Uint8_t   Length   [4];    // the complete size of the tag, including this footer
+    Uint8_t   TagCount [4];    // the number of fields in the tag
+    Uint8_t   Flags    [4];    // the tag flags (none currently defined)
+    Uint8_t   Reserved [8];    // reserved for later use
+};
+
+
+static Uint32_t
+Read_LE_Uint32 ( const Uint8_t* p )
+{
+    return ((Uint32_t)p[0] <<  0) |
+           ((Uint32_t)p[1] <<  8) |
+           ((Uint32_t)p[2] << 16) |
+           ((Uint32_t)p[3] << 24);
+}
+
+
+#define TAG_ANALYZE(item,elem)                      \
+    if ( 0 == memcmp (p, #item, sizeof #item ) ) {  \
+        p += sizeof #item;                          \
+        memcpy ( tip->elem, p, len );               \
+        p += len;                                   \
+    } else
+
+
+Int
+Read_APE_Tags ( FILE_T fp, TagInfo_t* tip )
+{
+    OFF_T                      file_pos;
+    Uint32_t                   len;
+    Uint32_t                   flags;
+    unsigned char              buff [8192];
+    unsigned char*             p;
+    unsigned char*             end;
+    struct APETagFooterStruct  T;
+    Uint32_t                   TagLen;
+    Uint32_t                   TagCount;
+    Uint32_t                   tmp;
+
+    memset ( tip, 0, sizeof(*tip) );
+    tip->GenreNo = -1;
+    tip->TrackNo = -1;
+
+    if ( -1 == (file_pos = FILEPOS (fp)) )
+        goto notag;
+    if ( -1 == SEEK ( fp, 0L, SEEK_END ) )
+        goto notag;
+    tip->FileSize = FILEPOS (fp);
+    if ( -1 == SEEK ( fp, -(long)sizeof T, SEEK_END ) )
+        goto notag;
+    if ( sizeof(T) != READ ( fp, &T, sizeof T ) )
+        goto notag;
+    if ( memcmp ( T.ID, "APETAGEX", sizeof(T.ID) ) != 0 )
+        goto notag;
+    tmp = Read_LE_Uint32 (T.Version);
+    if (  tmp != 1000  &&  tmp != 2000 )
+        goto notag;
+    TagLen = Read_LE_Uint32 (T.Length);
+    if ( TagLen <= sizeof T )
+        goto notag;
+    if ( -1 == SEEK ( fp, -(long)TagLen, SEEK_END ) )
+        goto notag;
+    tip->FileSize = FILEPOS (fp);
+    memset ( buff, 0, sizeof(buff) );
+    if ( TagLen - sizeof T != READ ( fp, buff, TagLen - sizeof T ) )
+        goto notag;
+    SEEK ( fp, file_pos, SEEK_SET );
+
+    TagCount = Read_LE_Uint32 (T.TagCount);
+    end = buff + TagLen - sizeof T;
+    for ( p = buff; p < end  &&  TagCount--; ) {
+        len   = Read_LE_Uint32 ( p ); p += 4;
+        flags = Read_LE_Uint32 ( p ); p += 4;
+        TAG_ANALYZE ( Title  , Title   )
+        TAG_ANALYZE ( Album  , Album   )
+        TAG_ANALYZE ( Artist , Artist  )
+        TAG_ANALYZE ( Album  , Album   )
+        TAG_ANALYZE ( Comment, Comment )
+        TAG_ANALYZE ( Track  , Track   )
+        TAG_ANALYZE ( Year   , Year    )
+        TAG_ANALYZE ( Genre  , Genre   )
+        {
+            p += strlen(p) + 1 + len;
+        }
+    }
+
+    if ( tip->Track[0] != '\0' )
+        sprintf ( tip->Track, "[%02d]", tip->TrackNo = atoi (tip->Track) );
+    else
+        strcpy ( tip->Track, "    " );
+
+    /* genre is not yet entirely decoded */
+    return 1;
+
+notag:
+    SEEK ( fp, file_pos, SEEK_SET );
+    return 0;
+}
+
+/* end of id3tag.c */