rtaglib 0.2.3 → 0.3.0

data/ext/taglib/taglib-mswin32/include/taglib/tbytevectorlist.h

@@ -0,0 +1,91 @@
+/***************************************************************************
+    copyright            : (C) 2002 - 2008 by Scott Wheeler
+    email                : wheeler@kde.org
+ ***************************************************************************/
+
+/***************************************************************************
+ *   This library is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU Lesser General Public License version   *
+ *   2.1 as published by the Free Software Foundation.                     *
+ *                                                                         *
+ *   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                                                                   *
+ *                                                                         *
+ *   Alternatively, this file is available under the Mozilla Public        *
+ *   License Version 1.1.  You may obtain a copy of the License at         *
+ *   http://www.mozilla.org/MPL/                                           *
+ ***************************************************************************/
+
+#ifndef TAGLIB_BYTEVECTORLIST_H
+#define TAGLIB_BYTEVECTORLIST_H
+
+#include "taglib_export.h"
+#include "tbytevector.h"
+#include "tlist.h"
+
+namespace TagLib {
+
+  //! A list of ByteVectors
+
+  /*!
+   * A List specialization with some handy features useful for ByteVectors.
+   */
+
+  class TAGLIB_EXPORT ByteVectorList : public List<ByteVector>
+  {
+  public:
+
+    /*!
+     * Construct an empty ByteVectorList.
+     */
+    ByteVectorList();
+
+    /*!
+     * Destroys this ByteVectorList instance.
+     */
+    virtual ~ByteVectorList();
+
+    /*!
+     * Make a shallow, implicitly shared, copy of \a l.  Because this is
+     * implicitly shared, this method is lightweight and suitable for
+     * pass-by-value usage.
+     */
+    ByteVectorList(const ByteVectorList &l);
+
+    /*!
+     * Convert the ByteVectorList to a ByteVector separated by \a separator.  By
+     * default a space is used.
+     */
+    ByteVector toByteVector(const ByteVector &separator = " ") const;
+
+    /*!
+     * Splits the ByteVector \a v into several strings at \a pattern.  This will
+     * not include the pattern in the returned ByteVectors.
+     */
+    static ByteVectorList split(const ByteVector &v, const ByteVector &pattern,
+                                int byteAlign = 1);
+    /*!
+     * Splits the ByteVector \a v into several strings at \a pattern.  This will
+     * not include the pattern in the returned ByteVectors.  \a max is the
+     * maximum number of entries that will be separated.  If \a max for instance
+     * is 2 then a maximum of 1 match will be found and the vector will be split
+     * on that match.
+     */
+    // BIC: merge with the function above
+    static ByteVectorList split(const ByteVector &v, const ByteVector &pattern,
+                                int byteAlign, int max);
+  private:
+    class ByteVectorListPrivate;
+    ByteVectorListPrivate *d;
+  };
+
+}
+
+#endif

data/ext/taglib/taglib-mswin32/include/taglib/textidentificationframe.h

@@ -0,0 +1,258 @@
+/***************************************************************************
+    copyright            : (C) 2002 - 2008 by Scott Wheeler
+    email                : wheeler@kde.org
+ ***************************************************************************/
+
+/***************************************************************************
+ *   This library is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU Lesser General Public License version   *
+ *   2.1 as published by the Free Software Foundation.                     *
+ *                                                                         *
+ *   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                                                                   *
+ *                                                                         *
+ *   Alternatively, this file is available under the Mozilla Public        *
+ *   License Version 1.1.  You may obtain a copy of the License at         *
+ *   http://www.mozilla.org/MPL/                                           *
+ ***************************************************************************/
+
+#ifndef TAGLIB_TEXTIDENTIFICATIONFRAME_H
+#define TAGLIB_TEXTIDENTIFICATIONFRAME_H
+
+#include <tstringlist.h>
+#include "taglib_export.h"
+
+#include <id3v2frame.h>
+
+namespace TagLib {
+
+  namespace ID3v2 {
+
+    class Tag;
+
+    //! An ID3v2 text identification frame implementation
+
+    /*!
+     * This is an implementation of the most common type of ID3v2 frame -- text
+     * identification frames.  There are a number of variations on this.  Those
+     * enumerated in the ID3v2.4 standard are:
+     *
+     * <ul>
+     *   <li><b>TALB</b> Album/Movie/Show title</li>
+     *   <li><b>TBPM</b> BPM (beats per minute)</li>
+     *   <li><b>TCOM</b> Composer</li>
+     *   <li><b>TCON</b> Content type</li>
+     *   <li><b>TCOP</b> Copyright message</li>
+     *   <li><b>TDEN</b> Encoding time</li>
+     *   <li><b>TDLY</b> Playlist delay</li>
+     *   <li><b>TDOR</b> Original release time</li>
+     *   <li><b>TDRC</b> Recording time</li>
+     *   <li><b>TDRL</b> Release time</li>
+     *   <li><b>TDTG</b> Tagging time</li>
+     *   <li><b>TENC</b> Encoded by</li>
+     *   <li><b>TEXT</b> Lyricist/Text writer</li>
+     *   <li><b>TFLT</b> File type</li>
+     *   <li><b>TIPL</b> Involved people list</li>
+     *   <li><b>TIT1</b> Content group description</li>
+     *   <li><b>TIT2</b> Title/songname/content description</li>
+     *   <li><b>TIT3</b> Subtitle/Description refinement</li>
+     *   <li><b>TKEY</b> Initial key</li>
+     *   <li><b>TLAN</b> Language(s)</li>
+     *   <li><b>TLEN</b> Length</li>
+     *   <li><b>TMCL</b> Musician credits list</li>
+     *   <li><b>TMED</b> Media type</li>
+     *   <li><b>TMOO</b> Mood</li>
+     *   <li><b>TOAL</b> Original album/movie/show title</li>
+     *   <li><b>TOFN</b> Original filename</li>
+     *   <li><b>TOLY</b> Original lyricist(s)/text writer(s)</li>
+     *   <li><b>TOPE</b> Original artist(s)/performer(s)</li>
+     *   <li><b>TOWN</b> File owner/licensee</li>
+     *   <li><b>TPE1</b> Lead performer(s)/Soloist(s)</li>
+     *   <li><b>TPE2</b> Band/orchestra/accompaniment</li>
+     *   <li><b>TPE3</b> Conductor/performer refinement</li>
+     *   <li><b>TPE4</b> Interpreted, remixed, or otherwise modified by</li>
+     *   <li><b>TPOS</b> Part of a set</li>
+     *   <li><b>TPRO</b> Produced notice</li>
+     *   <li><b>TPUB</b> Publisher</li>
+     *   <li><b>TRCK</b> Track number/Position in set</li>
+     *   <li><b>TRSN</b> Internet radio station name</li>
+     *   <li><b>TRSO</b> Internet radio station owner</li>
+     *   <li><b>TSOA</b> Album sort order</li>
+     *   <li><b>TSOP</b> Performer sort order</li>
+     *   <li><b>TSOT</b> Title sort order</li>
+     *   <li><b>TSRC</b> ISRC (international standard recording code)</li>
+     *   <li><b>TSSE</b> Software/Hardware and settings used for encoding</li>
+     *   <li><b>TSST</b> Set subtitle</li>
+     * </ul>
+     *
+     * The ID3v2 Frames document gives a description of each of these formats
+     * and the expected order of strings in each.  ID3v2::Header::frameID() can
+     * be used to determine the frame type.
+     *
+     * \note If non-Latin1 compatible strings are used with this class, even if
+     * the text encoding is set to Latin1, the frame will be written using UTF8
+     * (with the encoding flag appropriately set in the output).
+     */
+
+    class TAGLIB_EXPORT TextIdentificationFrame : public Frame
+    {
+      friend class FrameFactory;
+
+    public:
+      /*!
+       * Construct an empty frame of type \a type.  Uses \a encoding as the
+       * default text encoding.
+       *
+       * \note In this case you must specify the text encoding as it
+       * resolves the ambiguity between constructors.
+       *
+       * \note Please see the note in the class description regarding Latin1.
+       */
+      TextIdentificationFrame(const ByteVector &type, String::Type encoding);
+
+      /*!
+       * This is a dual purpose constructor.  \a data can either be binary data
+       * that should be parsed or (at a minimum) the frame ID.
+       */
+      explicit TextIdentificationFrame(const ByteVector &data);
+
+      /*!
+       * Destroys this TextIdentificationFrame instance.
+       */
+      virtual ~TextIdentificationFrame();
+
+      /*!
+       * Text identification frames are a list of string fields.
+       *
+       * This function will accept either a StringList or a String (using the
+       * StringList constructor that accepts a single String).
+       *
+       * \note This will not change the text encoding of the frame even if the
+       * strings passed in are not of the same encoding.  Please use
+       * setEncoding(s.type()) if you wish to change the encoding of the frame.
+       */
+      void setText(const StringList &l);
+
+      // Reimplementations.
+
+      virtual void setText(const String &s);
+      virtual String toString() const;
+
+      /*!
+       * Returns the text encoding that will be used in rendering this frame.
+       * This defaults to the type that was either specified in the constructor
+       * or read from the frame when parsed.
+       *
+       * \note Please see the note in the class description regarding Latin1.
+       *
+       * \see setTextEncoding()
+       * \see render()
+       */
+      String::Type textEncoding() const;
+
+      /*!
+       * Sets the text encoding to be used when rendering this frame to
+       * \a encoding.
+       *
+       * \note Please see the note in the class description regarding Latin1.
+       *
+       * \see textEncoding()
+       * \see render()
+       */
+      void setTextEncoding(String::Type encoding);
+
+      /*!
+       * Returns a list of the strings in this frame.
+       */
+      StringList fieldList() const;
+
+    protected:
+      // Reimplementations.
+
+      virtual void parseFields(const ByteVector &data);
+      virtual ByteVector renderFields() const;
+
+      /*!
+       * The constructor used by the FrameFactory.
+       */
+      TextIdentificationFrame(const ByteVector &data, Header *h);
+
+    private:
+      TextIdentificationFrame(const TextIdentificationFrame &);
+      TextIdentificationFrame &operator=(const TextIdentificationFrame &);
+
+      class TextIdentificationFramePrivate;
+      TextIdentificationFramePrivate *d;
+    };
+
+    /*!
+     * This is a specialization of text identification frames that allows for
+     * user defined entries.  Each entry has a description in addition to the
+     * normal list of fields that a text identification frame has.
+     *
+     * This description identifies the frame and must be unique.
+     */
+
+    //! An ID3v2 custom text identification frame implementationx
+
+    class TAGLIB_EXPORT UserTextIdentificationFrame : public TextIdentificationFrame
+    {
+      friend class FrameFactory;
+
+    public:
+      /*!
+       * Constructs an empty user defined text identification frame.  For this to be
+       * a useful frame both a description and text must be set.
+       */
+      explicit UserTextIdentificationFrame(String::Type encoding = String::Latin1);
+
+      /*!
+       * Creates a frame based on \a data.
+       */
+      explicit UserTextIdentificationFrame(const ByteVector &data);
+
+      virtual String toString() const;
+
+      /*!
+       * Returns the description for this frame.
+       */
+      String description() const;
+
+      /*!
+       * Sets the description of the frame to \a s.  \a s must be unique.  You can
+       * check for the presence of another user defined text frame of the same type
+       * using find() and testing for null.
+       */
+      void setDescription(const String &s);
+
+      StringList fieldList() const;
+      void setText(const String &text);
+      void setText(const StringList &fields);
+
+      /*!
+       * Searches for the user defined text frame with the description \a description
+       * in \a tag.  This returns null if no matching frames were found.
+       */
+      static UserTextIdentificationFrame *find(Tag *tag, const String &description);
+
+    private:
+      UserTextIdentificationFrame(const ByteVector &data, Header *h);
+      UserTextIdentificationFrame(const TextIdentificationFrame &);
+      UserTextIdentificationFrame &operator=(const UserTextIdentificationFrame &);
+
+      void checkFields();
+
+      class UserTextIdentificationFramePrivate;
+      UserTextIdentificationFramePrivate *d;
+    };
+
+  }
+}
+#endif

data/ext/taglib/taglib-mswin32/include/taglib/tfile.h

@@ -0,0 +1,271 @@
+/***************************************************************************
+    copyright            : (C) 2002 - 2008 by Scott Wheeler
+    email                : wheeler@kde.org
+ ***************************************************************************/
+
+/***************************************************************************
+ *   This library is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU Lesser General Public License version   *
+ *   2.1 as published by the Free Software Foundation.                     *
+ *                                                                         *
+ *   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                                                                   *
+ *                                                                         *
+ *   Alternatively, this file is available under the Mozilla Public        *
+ *   License Version 1.1.  You may obtain a copy of the License at         *
+ *   http://www.mozilla.org/MPL/                                           *
+ ***************************************************************************/
+
+#ifndef TAGLIB_FILE_H
+#define TAGLIB_FILE_H
+
+#include "taglib_export.h"
+#include "taglib.h"
+#include "tbytevector.h"
+
+namespace TagLib {
+
+  class String;
+  class Tag;
+  class AudioProperties;
+
+#ifdef _WIN32
+  class TAGLIB_EXPORT FileName
+  {
+  public:
+    FileName(const wchar_t *name) : m_wname(name) {}
+    FileName(const char *name) : m_name(name) {}
+    operator const wchar_t *() const { return m_wname.c_str(); }
+    operator const char *() const { return m_name.c_str(); }
+  private:
+    std::string m_name;
+    std::wstring m_wname;
+  };
+#else
+  typedef const char *FileName;
+#endif
+
+  //! A file class with some useful methods for tag manipulation
+
+  /*!
+   * This class is a basic file class with some methods that are particularly
+   * useful for tag editors.  It has methods to take advantage of
+   * ByteVector and a binary search method for finding patterns in a file.
+   */
+
+  class TAGLIB_EXPORT File
+  {
+  public:
+    /*!
+     * Position in the file used for seeking.
+     */
+    enum Position {
+      //! Seek from the beginning of the file.
+      Beginning,
+      //! Seek from the current position in the file.
+      Current,
+      //! Seek from the end of the file.
+      End
+    };
+
+    /*!
+     * Destroys this File instance.
+     */
+    virtual ~File();
+
+    /*!
+     * Returns the file name in the local file system encoding.
+     */
+    FileName name() const;
+
+    /*!
+     * Returns a pointer to this file's tag.  This should be reimplemented in
+     * the concrete subclasses.
+     */
+    virtual Tag *tag() const = 0;
+
+    /*!
+     * Returns a pointer to this file's audio properties.  This should be
+     * reimplemented in the concrete subclasses.  If no audio properties were
+     * read then this will return a null pointer.
+     */
+    virtual AudioProperties *audioProperties() const = 0;
+
+    /*!
+     * Save the file and its associated tags.  This should be reimplemented in
+     * the concrete subclasses.  Returns true if the save succeeds.
+     *
+     * \warning On UNIX multiple processes are able to write to the same file at
+     * the same time.  This can result in serious file corruption.  If you are
+     * developing a program that makes use of TagLib from multiple processes you
+     * must insure that you are only doing writes to a particular file from one
+     * of them.
+     */
+    virtual bool save() = 0;
+
+    /*!
+     * Reads a block of size \a length at the current get pointer.
+     */
+    ByteVector readBlock(ulong length);
+
+    /*!
+     * Attempts to write the block \a data at the current get pointer.  If the
+     * file is currently only opened read only -- i.e. readOnly() returns true --
+     * this attempts to reopen the file in read/write mode.
+     *
+     * \note This should be used instead of using the streaming output operator
+     * for a ByteVector.  And even this function is significantly slower than
+     * doing output with a char[].
+     */
+    void writeBlock(const ByteVector &data);
+
+    /*!
+     * Returns the offset in the file that \a pattern occurs at or -1 if it can
+     * not be found.  If \a before is set, the search will only continue until the
+     * pattern \a before is found.  This is useful for tagging purposes to search
+     * for a tag before the synch frame.
+     *
+     * Searching starts at \a fromOffset, which defaults to the beginning of the
+     * file.
+     *
+     * \note This has the practial limitation that \a pattern can not be longer
+     * than the buffer size used by readBlock().  Currently this is 1024 bytes.
+     */
+    long find(const ByteVector &pattern,
+              long fromOffset = 0,
+              const ByteVector &before = ByteVector::null);
+
+    /*!
+     * Returns the offset in the file that \a pattern occurs at or -1 if it can
+     * not be found.  If \a before is set, the search will only continue until the
+     * pattern \a before is found.  This is useful for tagging purposes to search
+     * for a tag before the synch frame.
+     *
+     * Searching starts at \a fromOffset and proceeds from the that point to the
+     * beginning of the file and defaults to the end of the file.
+     *
+     * \note This has the practial limitation that \a pattern can not be longer
+     * than the buffer size used by readBlock().  Currently this is 1024 bytes.
+     */
+    long rfind(const ByteVector &pattern,
+               long fromOffset = 0,
+               const ByteVector &before = ByteVector::null);
+
+    /*!
+     * Insert \a data at position \a start in the file overwriting \a replace
+     * bytes of the original content.
+     *
+     * \note This method is slow since it requires rewriting all of the file
+     * after the insertion point.
+     */
+    void insert(const ByteVector &data, ulong start = 0, ulong replace = 0);
+
+    /*!
+     * Removes a block of the file starting a \a start and continuing for
+     * \a length bytes.
+     *
+     * \note This method is slow since it involves rewriting all of the file
+     * after the removed portion.
+     */
+    void removeBlock(ulong start = 0, ulong length = 0);
+
+    /*!
+     * Returns true if the file is read only (or if the file can not be opened).
+     */
+    bool readOnly() const;
+
+    /*!
+     * Since the file can currently only be opened as an argument to the
+     * constructor (sort-of by design), this returns if that open succeeded.
+     */
+    bool isOpen() const;
+
+    /*!
+     * Returns true if the file is open and readble and valid information for
+     * the Tag and / or AudioProperties was found.
+     */
+    bool isValid() const;
+
+    /*!
+     * Move the I/O pointer to \a offset in the file from position \a p.  This
+     * defaults to seeking from the beginning of the file.
+     *
+     * \see Position
+     */
+    void seek(long offset, Position p = Beginning);
+
+    /*!
+     * Reset the end-of-file and error flags on the file.
+     */
+    void clear();
+
+    /*!
+     * Returns the current offset withing the file.
+     */
+    long tell() const;
+
+    /*!
+     * Returns the length of the file.
+     */
+    long length();
+
+    /*!
+     * Returns true if \a file can be opened for reading.  If the file does not
+     * exist, this will return false.
+     *
+     * \deprecated
+     */
+    static bool isReadable(const char *file);
+
+    /*!
+     * Returns true if \a file can be opened for writing.
+     *
+     * \deprecated
+     */
+    static bool isWritable(const char *name);
+
+  protected:
+    /*!
+     * Construct a File object and opens the \a file.  \a file should be a
+     * be a C-string in the local file system encoding.
+     *
+     * \note Constructor is protected since this class should only be
+     * instantiated through subclasses.
+     */
+    File(FileName file);
+
+    /*!
+     * Marks the file as valid or invalid.
+     *
+     * \see isValid()
+     */
+    void setValid(bool valid);
+
+    /*!
+     * Truncates the file to a \a length.
+     */
+    void truncate(long length);
+
+    /*!
+     * Returns the buffer size that is used for internal buffering.
+     */
+    static uint bufferSize();
+
+  private:
+    File(const File &);
+    File &operator=(const File &);
+
+    class FilePrivate;
+    FilePrivate *d;
+  };
+
+}
+
+#endif