rtaglib 0.1.2 → 0.2.0

data/swig/Rakefile

@@ -0,0 +1,33 @@
+#!/usr/bin/ruby
+
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+
+task :default => [:compile,:test,:copy]
+
+task :compile => ["taglib.so"]
+
+task :test => ["taglib.so"] do |t|
+    system %(ruby "test.rb")
+end
+task :copy => [:test] do |t|
+    system %(cp extconf.rb taglib.cxx ../ext/taglib/)
+    system %(cp test.rb ../test/test_taglib.rb)
+end
+file "taglib.so" => ["taglib.cxx","Makefile"] do |t|
+	system %(make)
+end
+
+file "taglib.cxx" => ["taglib.i"] do |t|
+    puts "Actualizando swig"
+    if
+	!system %(swig -fvirtual -Wall -c++ -o taglib.cxx -ruby taglib.i)
+    system %(rm *.o *.so *.cxx)
+    end
+end
+
+file "Makefile" => ["extconf.rb"] do |t|
+    system %(ruby "extconf.rb")
+end
+

data/swig/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+$libs = append_library($libs, "supc++")
+$CFLAGS= " -I/usr/include/taglib"
+if have_library("tag")
+    create_makefile("taglib")
+end

data/swig/taglib.i

@@ -0,0 +1,817 @@
+%module taglib
+%{
+#include "taglib/tlist.h"
+#include "taglib/fileref.h"
+#include "taglib/id3v1tag.h"
+#include "taglib/id3v1genres.h"
+
+
+#include "taglib/id3v2tag.h"
+#include "taglib/attachedpictureframe.h"
+#include "taglib/commentsframe.h"
+#include <taglib/xingheader.h>
+
+#include "taglib/apefooter.h"
+#include "taglib/apetag.h"
+#include "taglib/apeitem.h"
+
+#include "taglib/mpcfile.h"
+#include "taglib/mpcproperties.h"
+
+
+
+#include "taglib/flacfile.h"
+#include "taglib/flacproperties.h"
+
+#include <taglib/oggpage.h>
+#include <taglib/oggpageheader.h>
+#include <taglib/oggflacfile.h>
+#include <taglib/speexfile.h>
+#include <taglib/speexproperties.h>
+
+
+
+#include "taglib/vorbisfile.h"
+#include "taglib/vorbisproperties.h"
+
+#include "taglib/xiphcomment.h"
+#include "taglib/mpegfile.h"
+
+
+#include "taglib/trueaudiofile.h"
+#include "taglib/trueaudioproperties.h"
+
+
+#include "taglib/wavpackfile.h"
+#include "taglib/wavpackproperties.h"
+
+%}
+
+%inline %{
+typedef wchar_t 	wchar;
+typedef unsigned char 	uchar;
+typedef unsigned int 	uint;
+typedef unsigned long 	ulong;
+typedef std::basic_string< wchar > 	wstring;
+typedef const char * 	FileName;
+%}
+
+%{
+    VALUE StringList2Ruby(TagLib::StringList st) {
+        VALUE ary=Qnil;
+        if(st.size()>0) {
+            ary=rb_ary_new2(st.size());
+            for(uint i=0;i<(st.size());i++) {
+            TagLib::String &rst=st.operator[](i);
+            const char* ch=rst.toCString(true);
+            rb_ary_push(ary, rb_tainted_str_new2(ch));
+            }
+        }
+        return ary;
+    }
+%}
+
+
+%define MAP_HELPERS(TYPE,FUNC) 
+%extend Map<TagLib::String, TYPE> {
+    VALUE __getitem__(TagLib::String &item) {
+        if($self->contains(item)) {
+            return FUNC($self->operator[](item));
+        } else {
+            return Qnil;
+        }
+    }
+    VALUE __hash__() {
+        uint i;
+        VALUE hash=rb_hash_new();
+        for(std::map<TagLib::String,TYPE>::const_iterator it=$self->begin(); it!=$self->end();it++) {
+            VALUE key=rb_tainted_str_new2(it->first.toCString(true));
+            VALUE ary=FUNC(it->second);
+            rb_hash_aset(hash,key,ary);
+        }
+        return hash;
+    }
+}
+%enddef
+
+%define FILE_VIRTUALS()
+virtual ~File();
+virtual Tag * 	tag () const;
+virtual Properties * 	audioProperties () const;
+virtual bool 	save ();
+%enddef
+
+%define PROPERTIES_VIRTUALS()
+virtual int 	length () const;
+virtual int 	bitrate () const;
+virtual int 	sampleRate () const;
+virtual int 	channels () const;
+%enddef
+
+%define TAG_VIRTUALS()
+%alias setTitle "title="
+%alias setArtist "artist="
+%alias setAlbum "album="
+%alias setComment "comment="
+%alias setGenre "genre="
+%alias setYear "year="
+%alias setTrack "track="
+%alias isEmpty "empty?"
+virtual ~Tag();
+virtual String title() const;
+virtual String artist() const;
+virtual String album() const;
+virtual String comment() const;
+virtual String genre() const;
+virtual uint year() const;
+virtual uint track() ;
+virtual void setTitle(const String & s);
+virtual void setArtist(const String & s);
+virtual void setAlbum(const String & s);
+virtual void setComment(const String & s);
+virtual void setGenre(const String & s);
+virtual void setYear(uint i);
+virtual void setTrack(uint i);
+virtual bool isEmpty();
+%enddef
+
+
+
+namespace TagLib {
+
+//rename(TagLib_File) File;
+
+
+%typemap(in) TagLib::StringList & {
+    TagLib::StringList *sl=new TagLib::StringList();
+    for(long i=0;i<RARRAY_LEN($input);i++) {
+        SafeStringValue(RARRAY_PTR($input)[i]);
+        TagLib::String ntl=TagLib::String(StringValuePtr(RARRAY_PTR($input)[i]));
+        sl->append(ntl);
+    }
+    $1=sl;
+};
+
+
+%typemap(out) TagLib::StringList &{
+    $result=StringList2Ruby($1);
+}
+
+%typemap(out) TagLib::StringList {
+    $result=StringList2Ruby($1);
+}
+
+%apply  TagLib::StringList & {TagLib::StringList const &};
+
+
+%typemap(out) String {
+    $result = rb_tainted_str_new2($1.toCString(true));
+};
+
+%typemap(in) String {
+    $1=new TagLib::String(StringValuePtr($input));
+};
+
+
+%apply String {String &, const String &};
+
+%typemap(in) ByteVector {
+    $1=new TagLib::ByteVector(StringValuePtr($input), RSTRING_LEN($input));
+};
+
+%typemap(out) ByteVector {
+    $result = rb_tainted_str_new($1.data(),$1.size());
+};
+
+%apply ByteVector {ByteVector &, const ByteVector &};
+
+class AudioProperties {
+    AudioProperties(ReadStyle style);
+    virtual ~AudioProperties();
+
+    public:
+    enum ReadStyle {
+    Fast,Average,Accurate};
+    PROPERTIES_VIRTUALS()
+};
+class String {
+    
+    enum  	Type {
+    Latin1 = 0, UTF16 = 1, UTF16BE = 2, UTF8 = 3,
+    UTF16LE = 4
+    };
+    public:
+    String();
+    String(const char *s, Type t=Latin1);
+    ~String();
+    const char* toCString();
+    
+    };
+class Tag {
+    protected:
+    Tag();
+    public:
+    TAG_VIRTUALS()
+};
+class ByteVector {
+    public:
+    ByteVector(const char *data, uint length);
+    ByteVector(const char *data);
+    ~ByteVector();
+    uint size();
+    const char * 	data () const;
+    %extend {
+        const char * __str__() {
+            return $self->data();
+        }
+    }
+};
+
+class File {
+    protected:
+    File(FileName file);
+    void 	setValid (bool valid);
+    void 	truncate (long length);
+    public:
+    %alias readOnly "read_only?"
+    %alias isWritable "writable?"
+    %alias isOpen "open?"
+    %alias isValid "valid?"
+    
+    enum  	Position { Beginning, Current, End  };
+    FileName 	name() const;
+    virtual 	~File ();
+    virtual Tag * 	tag () const;
+    virtual AudioProperties * 	audioProperties () const;
+    virtual bool 	save ();
+    ByteVector 	readBlock (ulong length);
+    void 	writeBlock (const ByteVector &data);
+   
+   
+    %rename(find3) find(const ByteVector &pattern, long fromOffset, const ByteVector &before);
+    %rename(find2) find(const ByteVector &pattern, long fromOffset);
+    %rename(find1) find(const ByteVector &pattern);
+
+   long find(const ByteVector &pattern);
+   long find(const ByteVector &pattern, long fromOffset = 0);
+   long find(const ByteVector &pattern, long fromOffset=0, const ByteVector &before=ByteVector::null);
+
+   long 	rfind (const ByteVector &pattern, long fromOffset=0, const ByteVector &before=ByteVector::null);
+    void 	insert (const ByteVector &data, ulong start=0, ulong replace=0);
+    void 	removeBlock (ulong start=0, ulong length=0);
+    bool 	readOnly () const;
+    bool 	isOpen () const;
+    bool 	isValid () const;
+    void 	seek (long offset, Position p=Beginning);
+    void 	clear ();
+    long 	tell () const;
+    long 	length ();
+    %extend {
+        bool isWritable() {
+            return !$self->readOnly();
+        }
+    }
+};
+
+    
+    
+    
+    template<class T> class List {
+        public:
+         	List ();
+            List (const List< T > &l);
+            virtual 	~List ();
+            uint 	size () const;
+            bool 	isEmpty () const;
+            bool 	contains (const T &value) const ;
+    };
+    
+    
+    
+    
+    
+    template<class Key, class T> class Map {
+        public:
+        %alias isEmpty "empty?"
+        Map();
+        template <class Key,class T> Map(const Map< Key, T > &m);
+        ~Map();
+        Map<Key,T>& insert( const Key&, const T &);
+        Map<Key,T>& clear();
+        uint size();
+        %predicate Map::isEmpty();
+        bool isEmpty();
+        %predicate Map::contains();
+        bool 	contains (const Key &key);
+        %extend {
+             uint __len__() {
+                 return $self->size();
+             }
+        }
+        
+    };
+    // Helpers for FieldListMap
+    MAP_HELPERS(TagLib::StringList,StringList2Ruby)
+    // Helpers for GenreMap
+    MAP_HELPERS(int,INT2FIX)
+    
+    
+    %template (FieldListMap) Map<TagLib::String, TagLib::StringList>;
+    %template (ItemListMap) Map<TagLib::String, TagLib::APE::Item>;
+    %template (GenreMap) Map<TagLib::String, int>;
+    %template (FrameListMap) Map < TagLib::ByteVector, TagLib::ID3v2::FrameList >;
+    
+    %template (StringList) List< TagLib::String >; 
+    %template (ByteVectorList) List<TagLib::ByteVector>;
+    %template (FrameList) List< TagLib::ID3v2::Frame * >; 
+
+    typedef List<TagLib::ByteVector> ByteVectorList;
+    typedef List<TagLib::String> StringList;
+
+    class FileRef {
+        public:
+        static StringList 	defaultFileExtensions ();
+        %alias isNull "null?"
+        FileRef(FileName fileName, bool readAudioProperties = true,  	AudioProperties::ReadStyle   	 audioPropertiesStyle = AudioProperties::Average);
+        ~FileRef();
+        Tag* tag();
+        AudioProperties* audioProperties();
+        File* file();
+        bool save();
+        bool isNull();
+        
+    };
+    
+    
+    namespace APE {
+        typedef Map<TagLib::String,TagLib::APE::Item> ItemListMap;
+            
+        %rename(TagLib_APE_Tag) Tag;
+        %rename(TagLib_APE_Footer) Footer;
+        
+        class Footer {
+            public:
+            Footer ();
+            Footer (const ByteVector &data);
+            virtual 	~Footer ();
+            uint 	version () const;
+            bool 	headerPresent () const;
+            bool 	footerPresent () const;
+            bool 	isHeader () const;
+            void 	setHeaderPresent (bool b) const;
+            uint 	itemCount () const;
+            void 	setItemCount (uint s);
+            uint 	tagSize () const;
+            uint 	completeTagSize () const;
+            void 	setTagSize (uint s);
+            void 	setData (const ByteVector &data);
+            ByteVector 	renderFooter () const;
+            ByteVector 	renderHeader () const ;
+        };
+        
+        class Item {
+            public:
+            enum  	ItemTypes { Text = 0, Binary = 1, Locator = 2 };            
+            Item ();
+            Item (const String &key, const String &value);
+            Item (const String &key, const StringList &values);
+            Item (const Item &item);
+            virtual 	~Item ();
+            //Item & 	operator= (const Item &item);
+            String 	key () const;
+            ByteVector 	value () const;
+            void 	setKey (const String &key);
+            void 	setValue (const String &value);
+            void 	setValues (const StringList &values);
+            void 	appendValue (const String &value);
+            void 	appendValues (const StringList &values);
+            int 	size () const;
+            String 	toString () const;
+            StringList 	toStringList () const;
+            StringList 	values () const;
+            ByteVector 	render () const;
+            void 	parse (const ByteVector &data);
+            void 	setReadOnly (bool readOnly);
+            bool 	isReadOnly () const;
+            void 	setType (ItemTypes type);
+            ItemTypes 	type () const;
+            bool 	isEmpty () const;             
+        };
+        
+        class Tag : public TagLib::Tag {
+            public:
+            Tag();
+            Tag (File *file, long footerLocation);
+            
+            ByteVector render();
+            TAG_VIRTUALS()
+            Footer * 	footer () const;
+            const ItemListMap & 	itemListMap () const;
+            void 	removeItem (const String &key);
+            void 	addValue (const String &key, const String &value, bool replace=true);
+            void 	setItem (const String &key, const Item &item);
+
+
+        };
+    };
+    
+    
+    
+    
+    
+            
+    namespace Ogg {
+        
+        typedef Map<TagLib::String,TagLib::StringList> FieldListMap;
+
+        %rename(Ogg_XiphComment) XiphComment;
+        %rename(Ogg_Page) Page;
+        %rename(Ogg_PageHeader) PageHeader;
+        %rename(Ogg_File) File;
+            
+        class PageHeader {
+            public:
+            PageHeader (TagLib::Ogg::File *file=0, long pageOffset=-1);
+            virtual 	~PageHeader ();
+            bool 	isValid () const;
+            List< int > 	packetSizes () const;
+            void 	setPacketSizes (const List< int > &sizes);
+            bool 	firstPacketContinued () const;
+            void 	setFirstPacketContinued (bool continued);
+            bool 	lastPacketCompleted () const;
+            void 	setLastPacketCompleted (bool completed);
+            bool 	firstPageOfStream () const;
+            void 	setFirstPageOfStream (bool first);
+            bool 	lastPageOfStream () const;
+            void 	setLastPageOfStream (bool last);
+            long long 	absoluteGranularPosition () const;
+            void 	setAbsoluteGranularPosition (long long agp);
+            uint 	streamSerialNumber () const;
+            void 	setStreamSerialNumber (uint n);
+            int 	pageSequenceNumber () const;
+            void 	setPageSequenceNumber (int sequenceNumber);
+            int 	size () const;
+            int 	dataSize () const;
+            ByteVector 	render () const;
+        };
+        class Page {
+            public:
+                enum  	ContainsPacketFlags { DoesNotContainPacket = 0x0000, CompletePacket = 0x0001, BeginsWithPacket = 0x0002, EndsWithPacket = 0x0004 };
+                enum  	PaginationStrategy { SinglePagePerGroup, Repaginate };
+                Page (TagLib::Ogg::File *file, long pageOffset);
+                virtual 	~Page ();
+                long 	fileOffset () const;
+                const PageHeader * 	header () const;
+                int 	firstPacketIndex () const;
+                void 	setFirstPacketIndex (int index);
+                ContainsPacketFlags 	containsPacket (int index) const;
+                uint 	packetCount () const;
+                ByteVectorList 	packets () const;
+                int 	size () const;
+                ByteVector 	render () const;
+
+        };
+        class File : public TagLib::File {
+            protected:
+            File (FileName file);
+            public:
+            virtual 	~File ();
+            ByteVector 	packet (uint i);
+            void 	setPacket (uint i, const ByteVector &p);
+            const PageHeader * 	firstPageHeader ();
+            const PageHeader * 	lastPageHeader ();
+            virtual bool 	save ();
+        };
+        class XiphComment : public TagLib::Tag{
+        public:
+         	XiphComment ();
+            XiphComment (const ByteVector &data);
+            TAG_VIRTUALS()
+            uint 	fieldCount ();
+            const FieldListMap & 	fieldListMap();
+            String 	vendorID ();
+            %ignore addField(const String &key, const String &value);
+            void 	addField (const String &key, const String &value, bool replace=true);
+            %ignore removeField(const String &key, const String &value);
+            void removeField(const String &key);
+            //void removeField(const String &key, const String &value);
+            
+            bool 	contains (const String &key);
+            ByteVector 	render ();
+            ByteVector 	render (bool addFramingBit);
+        };
+        namespace FLAC {
+            %rename (Ogg_Flac_File) File;
+            class File : public TagLib::Ogg::File {
+                public:
+                File (FileName file, bool readProperties=true, TagLib::AudioProperties::ReadStyle propertiesStyle=Properties::Average);
+                virtual 	~File ();
+                virtual XiphComment * 	tag () const;
+                virtual TagLib::FLAC::Properties * 	audioProperties () const;
+                virtual bool 	save ();
+                long 	streamLength ();
+            };
+        };
+        namespace Speex {
+            %rename (Ogg_Speex_File) File;
+            %rename (Ogg_Speex_Properties) Properties;
+            class Properties : public TagLib::AudioProperties {
+                public:
+                 	Properties (TagLib::Ogg::Speex::File *file, ReadStyle style=Average);
+                    PROPERTIES_VIRTUALS()
+                    int 	speexVersion () const ;
+            };
+            class File : public TagLib::Ogg::File {
+                public:
+                File (FileName file, bool readProperties=true, Properties::ReadStyle propertiesStyle=Properties::Average);
+                virtual 	~File ();
+                virtual Ogg::XiphComment * 	tag () const;
+                virtual Properties * 	audioProperties () const;
+                virtual bool 	save ();
+            };
+        };
+       ;        
+    }; // end namespace Ogg
+ namespace Vorbis {
+            %rename(Vorbis_File) File;
+            %rename(Vorbis_Properties) Properties;
+                class Properties : public TagLib::AudioProperties {
+                    public:
+                    Properties(TagLib::Vorbis::File *file, ReadStyle style=Average);
+                    PROPERTIES_VIRTUALS()
+                    int 	vorbisVersion () const;
+                    int 	bitrateMaximum () const;
+                    int 	bitrateNominal () const;
+                    int 	bitrateMinimum () const; 
+                };
+            
+            class File : public TagLib::Ogg::File {
+            File (FileName file, bool readProperties=true, Properties::ReadStyle propertiesStyle=Properties::Average);
+            virtual 	~File ();
+            virtual Ogg::XiphComment * 	tag () const;
+            virtual Properties * 	audioProperties () const;
+            virtual bool 	save ();
+                };
+            }    
+ namespace ID3v1 {
+     typedef Map<TagLib::String,int> 	GenreMap;
+     String genre(int index);
+     int genreIndex(const String &name);
+     StringList genreList();
+     GenreMap genreMap();
+        %rename(ID3v1_Tag) Tag;
+        class Tag : public TagLib::Tag {
+            public:
+            Tag();
+            Tag(File *file, long tagOffset);            
+            TAG_VIRTUALS()
+            ByteVector render() const;
+            
+        };
+    };
+    namespace ID3v2 {
+        %rename(ID3v2_Tag) Tag;
+        %rename(ID3v2_Header) Header;
+        %rename(ID3v2_CommentsFrame) CommentsFrame;
+        %rename(ID3v2_FrameFactory) FrameFactory;
+        
+        typedef List< Frame * >FrameList;
+        typedef Map < ByteVector, FrameList > 	FrameListMap;
+        class AttachedPictureFrame {
+            public: 
+            enum  	Type {
+              Other = 0x00, FileIcon = 0x01, OtherFileIcon = 0x02, FrontCover = 0x03,
+              BackCover = 0x04, LeafletPage = 0x05, Media = 0x06, LeadArtist = 0x07,
+              Artist = 0x08, Conductor = 0x09, Band = 0x0A, Composer = 0x0B,
+              Lyricist = 0x0C, RecordingLocation = 0x0D, DuringRecording = 0x0E, DuringPerformance = 0x0F,
+              MovieScreenCapture = 0x10, ColouredFish = 0x11, Illustration = 0x12, BandLogo = 0x13,
+              PublisherLogo = 0x14
+            };              
+            AttachedPictureFrame ();
+            AttachedPictureFrame (const ByteVector &data);
+            virtual 	~AttachedPictureFrame ();
+            virtual String 	toString () const;
+            String::Type 	textEncoding () const;
+            void 	setTextEncoding (String::Type t);
+            String 	mimeType () const;
+            void 	setMimeType (const String &m);
+            Type 	type () const;
+            void 	setType (Type t);
+            String 	description () const;
+            void 	setDescription (const String &desc);
+            ByteVector 	picture () const;
+            void 	setPicture (const ByteVector &p);
+        };
+        
+        class CommentsFrame {
+            static CommentsFrame* TagLib::ID3v2::CommentsFrame::findByDescription  	(  	const Tag * tag, const String &  	d);
+            CommentsFrame (String::Type encoding=String::Latin1);
+            CommentsFrame (const ByteVector &data);
+            virtual 	~CommentsFrame ();
+            virtual String 	toString () const;
+            ByteVector 	language () const;
+            String 	description () const;
+            String 	text () const;
+            void 	setLanguage (const ByteVector &languageCode);
+            void 	setDescription (const String &s);
+            virtual void 	setText (const String &s);
+            String::Type 	textEncoding () const;
+            void 	setTextEncoding (String::Type encoding);
+        };
+        class FrameFactory {
+            FrameFactory();
+            ~FrameFactory();
+        };
+        class Header {
+            Header();
+            
+        };
+        class Tag : public TagLib::Tag {
+            public:
+            Tag();
+            Tag(File *file, long tagOffset, const FrameFactory* factory);            
+            TAG_VIRTUALS()
+            Header *header();
+        };
+    };
+    
+    namespace FLAC {
+        %rename(FLAC_Properties) Properties;
+        %rename(FLAC_File) File;
+        class Properties : public TagLib::AudioProperties {
+            public: 
+            //Properties(TagLib::ByteVector  data, long streamLength, TagLib::AudioProperties::ReadStyle style=Average);
+            Properties(TagLib::FLAC::File * file, ReadStyle style = Average);
+            virtual ~Properties();
+            PROPERTIES_VIRTUALS()
+            int sampleWidth();
+        };
+
+        class File : public TagLib::File {
+            public:
+            File(FileName file, bool readProperties=true, Properties::ReadStyle propertiesStyle=Properties::Average);
+            File(FileName file, ID3v2::FrameFactory *frameFactory, bool readProperties=true, Properties::ReadStyle propertiesStyle=Properties::Average);
+            FILE_VIRTUALS()
+            ID3v2::Tag * 	ID3v2Tag (bool create=false);
+            ID3v1::Tag * 	ID3v1Tag (bool create=false);
+            Ogg::XiphComment * 	xiphComment (bool create=false);
+            void 	setID3v2FrameFactory (const ID3v2::FrameFactory *factory);
+            ByteVector 	streamInfoData ();
+            long 	streamLength ();
+            
+        };
+        
+    };
+
+    
+        namespace MPC {
+        %rename(MPC_File) File;
+        %rename(MPC_Properties) Properties;
+        class Properties : public TagLib::AudioProperties {
+            public:
+            Properties(const ByteVector &data, long streamLength, ReadStyle style=Average);
+            PROPERTIES_VIRTUALS()
+            int mpcVersion() const;
+        };
+        
+        class File : public TagLib::File {
+            public:
+            
+            enum  	TagTypes {
+                NoTags = 0x0000, ID3v1 = 0x0001, ID3v2 = 0x0002, APE = 0x0004, AllTags = 0xffff
+            };
+            
+            
+            
+            File (FileName file, bool readProperties=true, Properties::ReadStyle propertiesStyle=Properties::Average);
+            FILE_VIRTUALS()
+            ID3v1::Tag * 	ID3v1Tag (bool create=false);
+            APE::Tag * 	APETag (bool create=false);
+            void 	strip (int tags=AllTags);
+            void 	remove (int tags=AllTags);
+        };
+    };
+    
+    namespace TrueAudio {
+        %rename(TrueAudio_File) File;
+        %rename(TrueAudio_Properties) Properties;
+        class Properties : public TagLib::AudioProperties {
+            public:
+            Properties(const ByteVector &data, long streamLength, ReadStyle style=Average);
+            PROPERTIES_VIRTUALS()
+           int 	bitsPerSample () const;
+           int 	ttaVersion () const;
+        };
+        
+        class File : public TagLib::File {
+            public:
+            enum  	TagTypes { NoTags = 0x0000, ID3v1 = 0x0001, ID3v2 = 0x0002, AllTags = 0xffff };
+            File (FileName file, bool readProperties=true, Properties::ReadStyle propertiesStyle=Properties::Average);
+            File (FileName file, ID3v2::FrameFactory *frameFactory, bool readProperties=true, Properties::ReadStyle propertiesStyle=Properties::Average);
+            FILE_VIRTUALS()
+            void 	setID3v2FrameFactory (const ID3v2::FrameFactory *factory);
+            ID3v1::Tag * 	ID3v1Tag (bool create=false);
+ID3v2::Tag * 	ID3v2Tag (bool create=false);
+void 	strip (int tags=AllTags);
+        };
+    };
+    
+    namespace WavPack {
+        %rename(WavPack_File) File;
+        %rename(WavPack_Properties) Properties;
+        class Properties : public TagLib::AudioProperties {
+            public:
+            Properties(const ByteVector &data, long streamLength, ReadStyle style=Average);
+            PROPERTIES_VIRTUALS()
+           int 	bitsPerSample () const;
+           int 	version () const;
+        };
+        
+        class File : public TagLib::File {
+            public:
+            enum  	TagTypes { NoTags = 0x0000, ID3v1 = 0x0001, APE = 0x0002, AllTags = 0xffff };
+            File (FileName file, bool readProperties=true, Properties::ReadStyle propertiesStyle=Properties::Average);
+            FILE_VIRTUALS()
+
+            ID3v1::Tag * 	ID3v1Tag (bool create=false);
+            APE::Tag * 	APETag (bool create=false);
+            void 	strip (int tags=AllTags);
+        };
+    };
+    
+    namespace MPEG {
+        %rename(MPEG_File) File;
+        %rename(MPEG_Properties) Properties;
+        %rename(MPEG_Header) Header;
+        
+        class Header {
+            public:
+            enum  	Version { Version1 = 0, Version2 = 1, Version2_5 = 2 };
+            enum  	ChannelMode { Stereo = 0, JointStereo = 1, DualChannel = 2, SingleChannel = 3 };
+            Header(const ByteVector &data);
+            Header(const Header &h);
+            virtual 	~Header ();
+            bool 	isValid () const;
+            Version 	version () const;
+            int 	layer () const;
+            bool 	protectionEnabled () const;
+            int 	bitrate () const;
+            int 	sampleRate () const;
+            bool 	isPadded() const;
+            ChannelMode 	channelMode () const;
+            bool 	isCopyrighted () const;
+            bool 	isOriginal () const;
+            int 	frameLength () const;
+            int 	samplesPerFrame () const;
+//            Header & 	operator= (const Header &h);
+        };
+        class XingHeader {
+            public:
+            XingHeader (const ByteVector &data);
+            virtual 	~XingHeader ();
+            bool 	isValid () const;
+            uint 	totalFrames () const;
+            uint 	totalSize () const;          
+        };
+        class Properties : public TagLib::AudioProperties {
+            public:
+            Properties(TagLib::MPEG::File *file, ReadStyle style=Average);
+            PROPERTIES_VIRTUALS()
+            const XingHeader * 	xingHeader () const;
+            Header::Version 	version () const;
+            int 	layer () const;
+            bool 	protectionEnabled () const;
+            Header::ChannelMode 	channelMode () const;
+            bool 	isCopyrighted () const;
+            bool 	isOriginal () const ;
+        };        
+        class File : public TagLib::File {
+            public:
+            enum  	TagTypes {
+            NoTags = 0x0000, ID3v1 = 0x0001, ID3v2 = 0x0002, APE = 0x0004,
+            AllTags = 0xffff};
+            File (FileName file, bool readProperties=true, Properties::ReadStyle propertiesStyle=Properties::Average);
+            File (FileName file, ID3v2::FrameFactory *frameFactory, bool readProperties=true, Properties::ReadStyle propertiesStyle=Properties::Average);
+            FILE_VIRTUALS();
+            bool 	save (int tags);
+            bool 	save (int tags, bool stripOthers);
+            ID3v2::Tag * 	ID3v2Tag (bool create=false);
+            ID3v1::Tag * 	ID3v1Tag (bool create=false);
+            APE::Tag * 	APETag (bool create=false);
+            bool 	strip (int tags=AllTags);
+            bool 	strip (int tags, bool freeMemory);
+            void 	setID3v2FrameFactory (const ID3v2::FrameFactory *factory);
+            long 	firstFrameOffset ();
+            long 	nextFrameOffset (long position);
+            long 	previousFrameOffset (long position);
+            long 	lastFrameOffset ();;
+        };
+    };
+
+};
+
+
+
+
+     
+