Minor fix for mp4 media header v0 minimum size check (#894)

Mp4 media header (mdhd) v0 atoms are a minimum of 8 bytes for size & type information, plus 24 bytes for remaining entries (`24 +8`) bytes in total, rather than (`24 + 4`).

See https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-25615

.astylerc

@@ -0,0 +1,18 @@
+--suffix=none
+--style=kr
+--indent=spaces=2
+--indent-col1-comments
+--min-conditional-indent=0
+--attach-extern-c
+--attach-namespaces
+--indent-namespaces
+--pad-oper
+--unpad-paren
+--align-pointer=name
+--align-reference=name
+--max-instatement-indent=40
+--break-closing-brackets
+--remove-brackets
+--convert-tabs
+--max-code-length=100
+--break-after-logical

.editorconfig

@@ -0,0 +1,21 @@
+# EditorConfig is awesome: http://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+# Non-specified newlines with a newline ending every file
+[*]
+insert_final_newline = true
+
+# 2 space indentation
+[*.{h,cpp,tcc,cmake,yml}]
+indent_style = space
+indent_size = 2
+
+# Trim traling whitespaces
+[*.{h,cpp,tcc,cmake,yml}]
+trim_trailing_whitespace = true
+
+# UTF-8 without BOM
+[*]
+charset = utf-8

.gitignore

@@ -19,8 +19,10 @@ CMakeFiles/
 /taglib.pc
 /tests/test_runner
 /tests/Testing
+/taglib/libtag.a
 /taglib_config.h
 /taglib-config
+/bindings/c/libtag_c.a
 /bindings/c/taglib_c.pc
 /bindings/c/Debug
 /bindings/c/MinSizeRel
@@ -42,3 +44,6 @@ CMakeFiles/
 /taglib/tag.dir/Release
 /ALL_BUILD.dir
 /ZERO_CHECK.dir
+taglib.h.stamp
+taglib.xcodeproj
+CMakeScripts

.travis.yml

@@ -0,0 +1,30 @@
+language: cpp
+
+sudo: false
+
+os:
+  - linux
+  - osx
+
+dist: trusty
+
+compiler:
+  - gcc
+  - clang
+
+addons:
+  apt:
+    packages:
+      - libcppunit-dev
+      - zlib1g-dev
+      - libboost-dev
+
+matrix:
+  exclude:
+    - os: osx
+      compiler: gcc
+
+install:
+  - if [ "$TRAVIS_OS_NAME" = "osx" ]; then brew install cppunit; fi
+
+script: cmake -DBUILD_TESTS=ON -DBUILD_EXAMPLES=ON -DBUILD_BINDINGS=ON -DCMAKE_CXX_FLAGS="-std=c++11" . && make && make check

3rdparty/utf8-cpp/checked.h

@@ -0,0 +1,327 @@
+// Copyright 2006-2016 Nemanja Trifunovic
+
+/*
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+
+#ifndef UTF8_FOR_CPP_CHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
+#define UTF8_FOR_CPP_CHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
+
+#include "core.h"
+#include <stdexcept>
+
+namespace utf8
+{
+    // Base for the exceptions that may be thrown from the library
+    class exception : public ::std::exception {
+    };
+
+    // Exceptions that may be thrown from the library functions.
+    class invalid_code_point : public exception {
+        uint32_t cp;
+    public:
+        invalid_code_point(uint32_t codepoint) : cp(codepoint) {}
+        virtual const char* what() const throw() { return "Invalid code point"; }
+        uint32_t code_point() const {return cp;}
+    };
+
+    class invalid_utf8 : public exception {
+        uint8_t u8;
+    public:
+        invalid_utf8 (uint8_t u) : u8(u) {}
+        virtual const char* what() const throw() { return "Invalid UTF-8"; }
+        uint8_t utf8_octet() const {return u8;}
+    };
+
+    class invalid_utf16 : public exception {
+        uint16_t u16;
+    public:
+        invalid_utf16 (uint16_t u) : u16(u) {}
+        virtual const char* what() const throw() { return "Invalid UTF-16"; }
+        uint16_t utf16_word() const {return u16;}
+    };
+
+    class not_enough_room : public exception {
+    public:
+        virtual const char* what() const throw() { return "Not enough space"; }
+    };
+
+    /// The library API - functions intended to be called by the users
+
+    template <typename octet_iterator>
+    octet_iterator append(uint32_t cp, octet_iterator result)
+    {
+        if (!utf8::internal::is_code_point_valid(cp))
+            throw invalid_code_point(cp);
+
+        if (cp < 0x80)                        // one octet
+            *(result++) = static_cast<uint8_t>(cp);
+        else if (cp < 0x800) {                // two octets
+            *(result++) = static_cast<uint8_t>((cp >> 6)            | 0xc0);
+            *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
+        }
+        else if (cp < 0x10000) {              // three octets
+            *(result++) = static_cast<uint8_t>((cp >> 12)           | 0xe0);
+            *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f)   | 0x80);
+            *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
+        }
+        else {                                // four octets
+            *(result++) = static_cast<uint8_t>((cp >> 18)           | 0xf0);
+            *(result++) = static_cast<uint8_t>(((cp >> 12) & 0x3f)  | 0x80);
+            *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f)   | 0x80);
+            *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
+        }
+        return result;
+    }
+
+    template <typename octet_iterator, typename output_iterator>
+    output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out, uint32_t replacement)
+    {
+        while (start != end) {
+            octet_iterator sequence_start = start;
+            internal::utf_error err_code = utf8::internal::validate_next(start, end);
+            switch (err_code) {
+                case internal::UTF8_OK :
+                    for (octet_iterator it = sequence_start; it != start; ++it)
+                        *out++ = *it;
+                    break;
+                case internal::NOT_ENOUGH_ROOM:
+                    throw not_enough_room();
+                case internal::INVALID_LEAD:
+                    out = utf8::append (replacement, out);
+                    ++start;
+                    break;
+                case internal::INCOMPLETE_SEQUENCE:
+                case internal::OVERLONG_SEQUENCE:
+                case internal::INVALID_CODE_POINT:
+                    out = utf8::append (replacement, out);
+                    ++start;
+                    // just one replacement mark for the sequence
+                    while (start != end && utf8::internal::is_trail(*start))
+                        ++start;
+                    break;
+            }
+        }
+        return out;
+    }
+
+    template <typename octet_iterator, typename output_iterator>
+    inline output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out)
+    {
+        static const uint32_t replacement_marker = utf8::internal::mask16(0xfffd);
+        return utf8::replace_invalid(start, end, out, replacement_marker);
+    }
+
+    template <typename octet_iterator>
+    uint32_t next(octet_iterator& it, octet_iterator end)
+    {
+        uint32_t cp = 0;
+        internal::utf_error err_code = utf8::internal::validate_next(it, end, cp);
+        switch (err_code) {
+            case internal::UTF8_OK :
+                break;
+            case internal::NOT_ENOUGH_ROOM :
+                throw not_enough_room();
+            case internal::INVALID_LEAD :
+            case internal::INCOMPLETE_SEQUENCE :
+            case internal::OVERLONG_SEQUENCE :
+                throw invalid_utf8(*it);
+            case internal::INVALID_CODE_POINT :
+                throw invalid_code_point(cp);
+        }
+        return cp;
+    }
+
+    template <typename octet_iterator>
+    uint32_t peek_next(octet_iterator it, octet_iterator end)
+    {
+        return utf8::next(it, end);
+    }
+
+    template <typename octet_iterator>
+    uint32_t prior(octet_iterator& it, octet_iterator start)
+    {
+        // can't do much if it == start
+        if (it == start)
+            throw not_enough_room();
+
+        octet_iterator end = it;
+        // Go back until we hit either a lead octet or start
+        while (utf8::internal::is_trail(*(--it)))
+            if (it == start)
+                throw invalid_utf8(*it); // error - no lead byte in the sequence
+        return utf8::peek_next(it, end);
+    }
+
+    /// Deprecated in versions that include "prior"
+    template <typename octet_iterator>
+    uint32_t previous(octet_iterator& it, octet_iterator pass_start)
+    {
+        octet_iterator end = it;
+        while (utf8::internal::is_trail(*(--it)))
+            if (it == pass_start)
+                throw invalid_utf8(*it); // error - no lead byte in the sequence
+        octet_iterator temp = it;
+        return utf8::next(temp, end);
+    }
+
+    template <typename octet_iterator, typename distance_type>
+    void advance (octet_iterator& it, distance_type n, octet_iterator end)
+    {
+        for (distance_type i = 0; i < n; ++i)
+            utf8::next(it, end);
+    }
+
+    template <typename octet_iterator>
+    typename std::iterator_traits<octet_iterator>::difference_type
+    distance (octet_iterator first, octet_iterator last)
+    {
+        typename std::iterator_traits<octet_iterator>::difference_type dist;
+        for (dist = 0; first < last; ++dist)
+            utf8::next(first, last);
+        return dist;
+    }
+
+    template <typename u16bit_iterator, typename octet_iterator>
+    octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_iterator result)
+    {
+        while (start != end) {
+            uint32_t cp = utf8::internal::mask16(*start++);
+            // Take care of surrogate pairs first
+            if (utf8::internal::is_lead_surrogate(cp)) {
+                if (start != end) {
+                    uint32_t trail_surrogate = utf8::internal::mask16(*start++);
+                    if (utf8::internal::is_trail_surrogate(trail_surrogate))
+                        cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET;
+                    else
+                        throw invalid_utf16(static_cast<uint16_t>(trail_surrogate));
+                }
+                else
+                    throw invalid_utf16(static_cast<uint16_t>(cp));
+
+            }
+            // Lone trail surrogate
+            else if (utf8::internal::is_trail_surrogate(cp))
+                throw invalid_utf16(static_cast<uint16_t>(cp));
+
+            result = utf8::append(cp, result);
+        }
+        return result;
+    }
+
+    template <typename u16bit_iterator, typename octet_iterator>
+    u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result)
+    {
+        while (start < end) {
+            uint32_t cp = utf8::next(start, end);
+            if (cp > 0xffff) { //make a surrogate pair
+                *result++ = static_cast<uint16_t>((cp >> 10)   + internal::LEAD_OFFSET);
+                *result++ = static_cast<uint16_t>((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN);
+            }
+            else
+                *result++ = static_cast<uint16_t>(cp);
+        }
+        return result;
+    }
+
+    template <typename octet_iterator, typename u32bit_iterator>
+    octet_iterator utf32to8 (u32bit_iterator start, u32bit_iterator end, octet_iterator result)
+    {
+        while (start != end)
+            result = utf8::append(*(start++), result);
+
+        return result;
+    }
+
+    template <typename octet_iterator, typename u32bit_iterator>
+    u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_iterator result)
+    {
+        while (start < end)
+            (*result++) = utf8::next(start, end);
+
+        return result;
+    }
+
+    // The iterator class
+    template <typename octet_iterator>
+    class iterator : public std::iterator <std::bidirectional_iterator_tag, uint32_t> {
+      octet_iterator it;
+      octet_iterator range_start;
+      octet_iterator range_end;
+      public:
+      iterator () {}
+      explicit iterator (const octet_iterator& octet_it,
+                         const octet_iterator& rangestart,
+                         const octet_iterator& rangeend) :
+               it(octet_it), range_start(rangestart), range_end(rangeend)
+      {
+          if (it < range_start || it > range_end)
+              throw std::out_of_range("Invalid utf-8 iterator position");
+      }
+      // the default "big three" are OK
+      octet_iterator base () const { return it; }
+      uint32_t operator * () const
+      {
+          octet_iterator temp = it;
+          return utf8::next(temp, range_end);
+      }
+      bool operator == (const iterator& rhs) const
+      {
+          if (range_start != rhs.range_start || range_end != rhs.range_end)
+              throw std::logic_error("Comparing utf-8 iterators defined with different ranges");
+          return (it == rhs.it);
+      }
+      bool operator != (const iterator& rhs) const
+      {
+          return !(operator == (rhs));
+      }
+      iterator& operator ++ ()
+      {
+          utf8::next(it, range_end);
+          return *this;
+      }
+      iterator operator ++ (int)
+      {
+          iterator temp = *this;
+          utf8::next(it, range_end);
+          return temp;
+      }
+      iterator& operator -- ()
+      {
+          utf8::prior(it, range_start);
+          return *this;
+      }
+      iterator operator -- (int)
+      {
+          iterator temp = *this;
+          utf8::prior(it, range_start);
+          return temp;
+      }
+    }; // class iterator
+
+} // namespace utf8
+
+#endif //header guard
+
+

3rdparty/utf8-cpp/core.h

@@ -0,0 +1,332 @@
+// Copyright 2006 Nemanja Trifunovic
+
+/*
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+
+#ifndef UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
+#define UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
+
+#include <iterator>
+
+namespace utf8
+{
+    // The typedefs for 8-bit, 16-bit and 32-bit unsigned integers
+    // You may need to change them to match your system.
+    // These typedefs have the same names as ones from cstdint, or boost/cstdint
+    typedef unsigned char   uint8_t;
+    typedef unsigned short  uint16_t;
+    typedef unsigned int    uint32_t;
+
+// Helper code - not intended to be directly called by the library users. May be changed at any time
+namespace internal
+{
+    // Unicode constants
+    // Leading (high) surrogates: 0xd800 - 0xdbff
+    // Trailing (low) surrogates: 0xdc00 - 0xdfff
+    const uint16_t LEAD_SURROGATE_MIN  = 0xd800u;
+    const uint16_t LEAD_SURROGATE_MAX  = 0xdbffu;
+    const uint16_t TRAIL_SURROGATE_MIN = 0xdc00u;
+    const uint16_t TRAIL_SURROGATE_MAX = 0xdfffu;
+    const uint16_t LEAD_OFFSET         = LEAD_SURROGATE_MIN - (0x10000 >> 10);
+    const uint32_t SURROGATE_OFFSET    = 0x10000u - (LEAD_SURROGATE_MIN << 10) - TRAIL_SURROGATE_MIN;
+
+    // Maximum valid value for a Unicode code point
+    const uint32_t CODE_POINT_MAX      = 0x0010ffffu;
+
+    template<typename octet_type>
+    inline uint8_t mask8(octet_type oc)
+    {
+        return static_cast<uint8_t>(0xff & oc);
+    }
+    template<typename u16_type>
+    inline uint16_t mask16(u16_type oc)
+    {
+        return static_cast<uint16_t>(0xffff & oc);
+    }
+    template<typename octet_type>
+    inline bool is_trail(octet_type oc)
+    {
+        return ((utf8::internal::mask8(oc) >> 6) == 0x2);
+    }
+
+    template <typename u16>
+    inline bool is_lead_surrogate(u16 cp)
+    {
+        return (cp >= LEAD_SURROGATE_MIN && cp <= LEAD_SURROGATE_MAX);
+    }
+
+    template <typename u16>
+    inline bool is_trail_surrogate(u16 cp)
+    {
+        return (cp >= TRAIL_SURROGATE_MIN && cp <= TRAIL_SURROGATE_MAX);
+    }
+
+    template <typename u16>
+    inline bool is_surrogate(u16 cp)
+    {
+        return (cp >= LEAD_SURROGATE_MIN && cp <= TRAIL_SURROGATE_MAX);
+    }
+
+    template <typename u32>
+    inline bool is_code_point_valid(u32 cp)
+    {
+        return (cp <= CODE_POINT_MAX && !utf8::internal::is_surrogate(cp));
+    }
+
+    template <typename octet_iterator>
+    inline typename std::iterator_traits<octet_iterator>::difference_type
+    sequence_length(octet_iterator lead_it)
+    {
+        uint8_t lead = utf8::internal::mask8(*lead_it);
+        if (lead < 0x80)
+            return 1;
+        else if ((lead >> 5) == 0x6)
+            return 2;
+        else if ((lead >> 4) == 0xe)
+            return 3;
+        else if ((lead >> 3) == 0x1e)
+            return 4;
+        else
+            return 0;
+    }
+
+    template <typename octet_difference_type>
+    inline bool is_overlong_sequence(uint32_t cp, octet_difference_type length)
+    {
+        if (cp < 0x80) {
+            if (length != 1) 
+                return true;
+        }
+        else if (cp < 0x800) {
+            if (length != 2) 
+                return true;
+        }
+        else if (cp < 0x10000) {
+            if (length != 3) 
+                return true;
+        }
+
+        return false;
+    }
+
+    enum utf_error {UTF8_OK, NOT_ENOUGH_ROOM, INVALID_LEAD, INCOMPLETE_SEQUENCE, OVERLONG_SEQUENCE, INVALID_CODE_POINT};
+
+    /// Helper for get_sequence_x
+    template <typename octet_iterator>
+    utf_error increase_safely(octet_iterator& it, octet_iterator end)
+    {
+        if (++it == end)
+            return NOT_ENOUGH_ROOM;
+
+        if (!utf8::internal::is_trail(*it))
+            return INCOMPLETE_SEQUENCE;
+        
+        return UTF8_OK;
+    }
+
+    #define UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(IT, END) {utf_error ret = increase_safely(IT, END); if (ret != UTF8_OK) return ret;}    
+
+    /// get_sequence_x functions decode utf-8 sequences of the length x
+    template <typename octet_iterator>
+    utf_error get_sequence_1(octet_iterator& it, octet_iterator end, uint32_t& code_point)
+    {
+        if (it == end)
+            return NOT_ENOUGH_ROOM;
+
+        code_point = utf8::internal::mask8(*it);
+
+        return UTF8_OK;
+    }
+
+    template <typename octet_iterator>
+    utf_error get_sequence_2(octet_iterator& it, octet_iterator end, uint32_t& code_point)
+    {
+        if (it == end) 
+            return NOT_ENOUGH_ROOM;
+        
+        code_point = utf8::internal::mask8(*it);
+
+        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
+
+        code_point = ((code_point << 6) & 0x7ff) + ((*it) & 0x3f);
+
+        return UTF8_OK;
+    }
+
+    template <typename octet_iterator>
+    utf_error get_sequence_3(octet_iterator& it, octet_iterator end, uint32_t& code_point)
+    {
+        if (it == end)
+            return NOT_ENOUGH_ROOM;
+            
+        code_point = utf8::internal::mask8(*it);
+
+        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
+
+        code_point = ((code_point << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff);
+
+        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
+
+        code_point += (*it) & 0x3f;
+
+        return UTF8_OK;
+    }
+
+    template <typename octet_iterator>
+    utf_error get_sequence_4(octet_iterator& it, octet_iterator end, uint32_t& code_point)
+    {
+        if (it == end)
+           return NOT_ENOUGH_ROOM;
+
+        code_point = utf8::internal::mask8(*it);
+
+        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
+
+        code_point = ((code_point << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff);
+
+        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
+
+        code_point += (utf8::internal::mask8(*it) << 6) & 0xfff;
+
+        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
+
+        code_point += (*it) & 0x3f;
+
+        return UTF8_OK;
+    }
+
+    #undef UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR
+
+    template <typename octet_iterator>
+    utf_error validate_next(octet_iterator& it, octet_iterator end, uint32_t& code_point)
+    {
+	if (it == end)
+            return NOT_ENOUGH_ROOM;
+
+        // Save the original value of it so we can go back in case of failure
+        // Of course, it does not make much sense with i.e. stream iterators
+        octet_iterator original_it = it;
+
+        uint32_t cp = 0;
+        // Determine the sequence length based on the lead octet
+        typedef typename std::iterator_traits<octet_iterator>::difference_type octet_difference_type;
+        const octet_difference_type length = utf8::internal::sequence_length(it);
+
+        // Get trail octets and calculate the code point
+        utf_error err = UTF8_OK;
+        switch (length) {
+            case 0: 
+                return INVALID_LEAD;
+            case 1:
+                err = utf8::internal::get_sequence_1(it, end, cp);
+                break;
+            case 2:
+                err = utf8::internal::get_sequence_2(it, end, cp);
+            break;
+            case 3:
+                err = utf8::internal::get_sequence_3(it, end, cp);
+            break;
+            case 4:
+                err = utf8::internal::get_sequence_4(it, end, cp);
+            break;
+        }
+
+        if (err == UTF8_OK) {
+            // Decoding succeeded. Now, security checks...
+            if (utf8::internal::is_code_point_valid(cp)) {
+                if (!utf8::internal::is_overlong_sequence(cp, length)){
+                    // Passed! Return here.
+                    code_point = cp;
+                    ++it;
+                    return UTF8_OK;
+                }
+                else
+                    err = OVERLONG_SEQUENCE;
+            }
+            else 
+                err = INVALID_CODE_POINT;
+        }
+
+        // Failure branch - restore the original value of the iterator
+        it = original_it;
+        return err;
+    }
+
+    template <typename octet_iterator>
+    inline utf_error validate_next(octet_iterator& it, octet_iterator end) {
+        uint32_t ignored;
+        return utf8::internal::validate_next(it, end, ignored);
+    }
+
+} // namespace internal
+
+    /// The library API - functions intended to be called by the users
+
+    // Byte order mark
+    const uint8_t bom[] = {0xef, 0xbb, 0xbf};
+
+    template <typename octet_iterator>
+    octet_iterator find_invalid(octet_iterator start, octet_iterator end)
+    {
+        octet_iterator result = start;
+        while (result != end) {
+            utf8::internal::utf_error err_code = utf8::internal::validate_next(result, end);
+            if (err_code != internal::UTF8_OK)
+                return result;
+        }
+        return result;
+    }
+
+    template <typename octet_iterator>
+    inline bool is_valid(octet_iterator start, octet_iterator end)
+    {
+        return (utf8::find_invalid(start, end) == end);
+    }
+
+    template <typename octet_iterator>
+    inline bool starts_with_bom (octet_iterator it, octet_iterator end)
+    {
+        return (
+            ((it != end) && (utf8::internal::mask8(*it++)) == bom[0]) &&
+            ((it != end) && (utf8::internal::mask8(*it++)) == bom[1]) &&
+            ((it != end) && (utf8::internal::mask8(*it))   == bom[2])
+           );
+    }
+	
+    //Deprecated in release 2.3 
+    template <typename octet_iterator>
+    inline bool is_bom (octet_iterator it)
+    {
+        return (
+            (utf8::internal::mask8(*it++)) == bom[0] &&
+            (utf8::internal::mask8(*it++)) == bom[1] &&
+            (utf8::internal::mask8(*it))   == bom[2]
+           );
+    }
+} // namespace utf8
+
+#endif // header guard
+
+

AUTHORS

@@ -2,6 +2,10 @@ Scott Wheeler <wheeler@kde.org>
  Author, maintainer
 Lukas Lalinsky <lalinsky@gmail.com>
  Implementation of multiple new file formats, many bug fixes, maintainer
+Tsuda Kageyu <tsuda.kageyu@gmail.com>
+ A lot of bug fixes and performance improvements, maintainer.
+Stephen F. Booth <me@sbooth.org>
+ DSF metadata implementation, bug fixes, maintainer.
 Ismael Orenstein <orenstein@kde.org>
  Xing header implementation
 Allan Sandfeld Jensen <kde@carewolf.org>
@@ -10,6 +14,8 @@ Teemu Tervo <teemu.tervo@gmx.net>
  Numerous bug reports and fixes
 Mathias Panzenböck <grosser.meister.morti@gmx.net>
  Mod, S3M, IT and XM metadata implementations
+Damien Plisson <damien78@audirvana.com>
+ DSDIFF metadata implementation
 
 Please send all patches and questions to taglib-devel@kde.org rather than to
 individual developers!

CMakeLists.txt

@@ -1,64 +1,102 @@
+cmake_minimum_required(VERSION 2.8.0 FATAL_ERROR)
+
 project(taglib)
 
-cmake_minimum_required(VERSION 2.6.0 FATAL_ERROR)
+if(NOT ${CMAKE_VERSION} VERSION_LESS 2.8.12)
+  cmake_policy(SET CMP0022 OLD)
+endif()
 
-option(ENABLE_STATIC "Make static version of libtag"  OFF)
-if(ENABLE_STATIC)
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
+
+if(DEFINED ENABLE_STATIC)
+  message(FATAL_ERROR "This option is no longer available, use BUILD_SHARED_LIBS instead")
+endif()
+
+option(BUILD_SHARED_LIBS "Build shared libraries" OFF)
+if(APPLE)
+  option(BUILD_FRAMEWORK "Build an OS X framework" OFF)
+  if(BUILD_FRAMEWORK)
+    set(BUILD_SHARED_LIBS ON)
+    #set(CMAKE_MACOSX_RPATH 1)
+    set(FRAMEWORK_INSTALL_DIR "/Library/Frameworks" CACHE STRING "Directory to install frameworks to.")
+  endif()
+endif()
+if(NOT BUILD_SHARED_LIBS)
   add_definitions(-DTAGLIB_STATIC)
-  set(BUILD_SHARED_LIBS OFF)
-else()
-  set(BUILD_SHARED_LIBS ON)
 endif()
-OPTION(ENABLE_STATIC_RUNTIME "Visual Studio, link with runtime statically"  OFF)
+option(ENABLE_STATIC_RUNTIME "Visual Studio, link with runtime statically" OFF)
 
-option(VISIBILITY_HIDDEN "Build with -fvisibility=hidden"  OFF)
-if(VISIBILITY_HIDDEN)
-  add_definitions (-fvisibility=hidden)
+option(ENABLE_CCACHE "Use ccache when building libtag" OFF)
+if(ENABLE_CCACHE)
+  find_program(CCACHE_FOUND ccache)
+  if(CCACHE_FOUND)
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
+    set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
+  endif()
 endif()
 
-option(BUILD_TESTS "Build the test suite"  OFF)
-option(BUILD_EXAMPLES "Build the examples"  OFF)
+option(VISIBILITY_HIDDEN "Build with -fvisibility=hidden" OFF)
+option(BUILD_TESTS "Build the test suite" OFF)
+option(BUILD_EXAMPLES "Build the examples" OFF)
+option(BUILD_BINDINGS "Build the bindings" ON)
 
-option(NO_ITUNES_HACKS "Disable workarounds for iTunes bugs"  OFF)
+option(NO_ITUNES_HACKS "Disable workarounds for iTunes bugs" OFF)
+
+option(PLATFORM_WINRT "Enable WinRT support" OFF)
+if(PLATFORM_WINRT)
+  add_definitions(-DPLATFORM_WINRT)
+endif()
 
 add_definitions(-DHAVE_CONFIG_H)
 set(TESTS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/tests/")
 
 ## the following are directories where stuff will be installed to
 set(LIB_SUFFIX "" CACHE STRING "Define suffix of directory name (32/64)")
-set(EXEC_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}" CACHE PATH "Base directory for executables and libraries" FORCE)
-set(BIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/bin" CACHE PATH "The subdirectory to the binaries prefix (default prefix/bin)" FORCE)
-set(LIB_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX}" CACHE PATH "The subdirectory relative to the install prefix where libraries will be installed (default is /lib${LIB_SUFFIX})" FORCE)
-set(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE PATH "The subdirectory to the header prefix" FORCE)
-
-if(APPLE)
-	option(BUILD_FRAMEWORK "Build an OS X framework" OFF)
-	set(FRAMEWORK_INSTALL_DIR "/Library/Frameworks" CACHE STRING "Directory to install frameworks to.")
-endif()
+set(EXEC_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}" CACHE PATH "Base directory for executables and libraries")
+set(BIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/bin" CACHE PATH "The subdirectory to the binaries prefix (default prefix/bin)")
+set(LIB_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/lib${LIB_SUFFIX}" CACHE PATH "The subdirectory relative to the install prefix where libraries will be installed (default is /lib${LIB_SUFFIX})")
+set(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE PATH "The subdirectory to the header prefix")
 
 if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
 endif()
-if (MSVC AND ENABLE_STATIC_RUNTIME)
+
+if(MSVC AND ENABLE_STATIC_RUNTIME)
   foreach(flag_var CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
     string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
   endforeach(flag_var)
 endif()
 
-set(TAGLIB_LIB_MAJOR_VERSION "1")
-set(TAGLIB_LIB_MINOR_VERSION "8")
-set(TAGLIB_LIB_PATCH_VERSION "0")
+# Read version information from file taglib/toolkit/taglib.h into variables
+# TAGLIB_LIB_MAJOR_VERSION, TAGLIB_LIB_MINOR_VERSION, TAGLIB_LIB_PATCH_VERSION.
+foreach(version_part MAJOR MINOR PATCH)
+  set(version_var_name "TAGLIB_${version_part}_VERSION")
+  file(STRINGS taglib/toolkit/taglib.h version_line
+       REGEX "^#define +${version_var_name}")
+  if(NOT version_line)
+    message(FATAL_ERROR "${version_var_name} not found in taglib.h")
+  endif()
+  string(REGEX MATCH "${version_var_name} +([^ ]+)" result ${version_line})
+  set(TAGLIB_LIB_${version_part}_VERSION ${CMAKE_MATCH_1})
+endforeach(version_part)
 
-set(TAGLIB_LIB_VERSION_STRING "${TAGLIB_LIB_MAJOR_VERSION}.${TAGLIB_LIB_MINOR_VERSION}.${TAGLIB_LIB_PATCH_VERSION}")
+# Only used to force cmake rerun when taglib.h changes.
+configure_file(taglib/toolkit/taglib.h ${CMAKE_CURRENT_BINARY_DIR}/taglib.h.stamp)
+
+if("${TAGLIB_LIB_PATCH_VERSION}" EQUAL "0")
+  set(TAGLIB_LIB_VERSION_STRING "${TAGLIB_LIB_MAJOR_VERSION}.${TAGLIB_LIB_MINOR_VERSION}")
+else()
+  set(TAGLIB_LIB_VERSION_STRING "${TAGLIB_LIB_MAJOR_VERSION}.${TAGLIB_LIB_MINOR_VERSION}.${TAGLIB_LIB_PATCH_VERSION}")
+endif()
 
 # 1. If the library source code has changed at all since the last update, then increment revision.
 # 2. If any interfaces have been added, removed, or changed since the last update, increment current, and set revision to 0.
 # 3. If any interfaces have been added since the last public release, then increment age.
-# 4. If any interfaces have been removed since the last public release, then set age to 0. 
-set(TAGLIB_SOVERSION_CURRENT  13)
+# 4. If any interfaces have been removed since the last public release, then set age to 0.
+set(TAGLIB_SOVERSION_CURRENT  18)
 set(TAGLIB_SOVERSION_REVISION 0)
-set(TAGLIB_SOVERSION_AGE      12)
+set(TAGLIB_SOVERSION_AGE      17)
 
 math(EXPR TAGLIB_SOVERSION_MAJOR "${TAGLIB_SOVERSION_CURRENT} - ${TAGLIB_SOVERSION_AGE}")
 math(EXPR TAGLIB_SOVERSION_MINOR "${TAGLIB_SOVERSION_AGE}")
@@ -66,43 +104,56 @@ math(EXPR TAGLIB_SOVERSION_PATCH "${TAGLIB_SOVERSION_REVISION}")
 
 include(ConfigureChecks.cmake)
 
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/taglib-config.cmake ${CMAKE_CURRENT_BINARY_DIR}/taglib-config )
-install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/taglib-config DESTINATION ${BIN_INSTALL_DIR})
+if(NOT WIN32)
+  configure_file("${CMAKE_CURRENT_SOURCE_DIR}/taglib-config.cmake" "${CMAKE_CURRENT_BINARY_DIR}/taglib-config")
+  install(PROGRAMS "${CMAKE_CURRENT_BINARY_DIR}/taglib-config" DESTINATION "${BIN_INSTALL_DIR}")
+endif()
 
-if(NOT WIN32 AND NOT BUILD_FRAMEWORK)
-  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/taglib.pc.cmake ${CMAKE_CURRENT_BINARY_DIR}/taglib.pc )
-  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/taglib.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig)
+if(WIN32)
+  configure_file("${CMAKE_CURRENT_SOURCE_DIR}/taglib-config.cmd.cmake" "${CMAKE_CURRENT_BINARY_DIR}/taglib-config.cmd")
+  install(PROGRAMS "${CMAKE_CURRENT_BINARY_DIR}/taglib-config.cmd" DESTINATION "${BIN_INSTALL_DIR}")
+endif()
+
+if(NOT BUILD_FRAMEWORK)
+  configure_file("${CMAKE_CURRENT_SOURCE_DIR}/taglib.pc.cmake" "${CMAKE_CURRENT_BINARY_DIR}/taglib.pc" @ONLY)
+  install(FILES "${CMAKE_CURRENT_BINARY_DIR}/taglib.pc" DESTINATION "${LIB_INSTALL_DIR}/pkgconfig")
+endif()
+
+if(NOT HAVE_ZLIB AND ZLIB_SOURCE)
+  set(HAVE_ZLIB 1)
+  set(HAVE_ZLIB_SOURCE 1)
 endif()
 
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
-configure_file(config-taglib.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config.h)
+configure_file(config.h.cmake "${CMAKE_CURRENT_BINARY_DIR}/config.h")
 
-if(WITH_ASF)
-    set(TAGLIB_WITH_ASF TRUE)
-endif()
-if(WITH_MP4)
-    set(TAGLIB_WITH_MP4 TRUE)
+option(TRACE_IN_RELEASE "Output debug messages even in release mode"  OFF)
+if(TRACE_IN_RELEASE)
+  set(TRACE_IN_RELEASE TRUE)
 endif()
 
-configure_file(taglib/taglib_config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/taglib_config.h)
+add_subdirectory(taglib)
 
-add_subdirectory(taglib) 
-add_subdirectory(bindings)
-if(BUILD_TESTS)
-    enable_testing()
-    add_subdirectory(tests)
-endif(BUILD_TESTS)
-add_subdirectory(examples)
+if(BUILD_BINDINGS)
+  add_subdirectory(bindings)
+endif()
 
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.cmake ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)
+if(BUILD_TESTS AND NOT BUILD_SHARED_LIBS)
+  enable_testing()
+  add_subdirectory(tests)
+endif()
+
+if(BUILD_EXAMPLES)
+  add_subdirectory(examples)
+endif()
+
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.cmake" "${CMAKE_CURRENT_BINARY_DIR}/Doxyfile")
 file(COPY doc/taglib.png DESTINATION doc)
 add_custom_target(docs doxygen)
 
 # uninstall target
-configure_file(
-  "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
-  "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
-  IMMEDIATE @ONLY)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" IMMEDIATE @ONLY)
 
-add_custom_target(uninstall
-  COMMAND ${CMAKE_COMMAND} -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
+if(NOT TARGET uninstall)
+  add_custom_target(uninstall COMMAND "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
+endif()

ConfigureChecks.cmake

@@ -1,23 +1,244 @@
-include(CheckIncludeFile)
-include(CheckIncludeFiles)
-include(CheckSymbolExists)
-include(CheckFunctionExists)
 include(CheckLibraryExists)
 include(CheckTypeSize)
+include(CheckCXXCompilerFlag)
 include(CheckCXXSourceCompiles)
+include(TestLargeFiles)
 
-# check for libz using the cmake supplied FindZLIB.cmake
-find_package(ZLIB)
-if(ZLIB_FOUND)
-	set(HAVE_ZLIB 1)
-else()
-	set(HAVE_ZLIB 0)
+# Check if the size of numeric types are suitable.
+
+check_type_size("short" SIZEOF_SHORT)
+if(NOT ${SIZEOF_SHORT} EQUAL 2)
+  message(FATAL_ERROR "TagLib requires that short is 16-bit wide.")
 endif()
 
-set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
-find_package(CppUnit)
-if(NOT CppUnit_FOUND AND BUILD_TESTS)
-	message(STATUS "CppUnit not found, disabling tests.")
-	set(BUILD_TESTS OFF)
+check_type_size("int" SIZEOF_INT)
+if(NOT ${SIZEOF_INT} EQUAL 4)
+  message(FATAL_ERROR "TagLib requires that int is 32-bit wide.")
 endif()
 
+check_type_size("long long" SIZEOF_LONGLONG)
+if(NOT ${SIZEOF_LONGLONG} EQUAL 8)
+  message(FATAL_ERROR "TagLib requires that long long is 64-bit wide.")
+endif()
+
+check_type_size("wchar_t" SIZEOF_WCHAR_T)
+if(${SIZEOF_WCHAR_T} LESS 2)
+  message(FATAL_ERROR "TagLib requires that wchar_t is sufficient to store a UTF-16 char.")
+endif()
+
+check_type_size("float" SIZEOF_FLOAT)
+if(NOT ${SIZEOF_FLOAT} EQUAL 4)
+  message(FATAL_ERROR "TagLib requires that float is 32-bit wide.")
+endif()
+
+check_type_size("double" SIZEOF_DOUBLE)
+if(NOT ${SIZEOF_DOUBLE} EQUAL 8)
+  message(FATAL_ERROR "TagLib requires that double is 64-bit wide.")
+endif()
+
+# Determine whether your compiler supports large files.
+
+if(NOT WIN32)
+  test_large_files(SUPPORT_LARGE_FILES)
+  if(NOT SUPPORT_LARGE_FILES)
+    MESSAGE(FATAL_ERROR "TagLib requires large files support.")
+  endif()
+endif()
+
+# Enable check_cxx_source_compiles() to work with Boost "header-only" libraries.
+
+find_package(Boost)
+if(Boost_FOUND)
+  set(CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES};${Boost_INCLUDE_DIRS}")
+endif()
+
+# Determine which kind of atomic operations your compiler supports.
+
+check_cxx_source_compiles("
+  #include <atomic>
+  int main() {
+    std::atomic_int x(1);
+    ++x;
+    --x;
+    return 0;
+  }
+" HAVE_STD_ATOMIC)
+
+if(NOT HAVE_STD_ATOMIC)
+  check_cxx_source_compiles("
+    int main() {
+      volatile int x;
+      __sync_add_and_fetch(&x, 1);
+      int y = __sync_sub_and_fetch(&x, 1);
+      return 0;
+    }
+  " HAVE_GCC_ATOMIC)
+
+  if(NOT HAVE_GCC_ATOMIC)
+    check_cxx_source_compiles("
+      #include <libkern/OSAtomic.h>
+      int main() {
+        volatile int32_t x;
+        OSAtomicIncrement32Barrier(&x);
+        int32_t y = OSAtomicDecrement32Barrier(&x);
+        return 0;
+      }
+    " HAVE_MAC_ATOMIC)
+
+    if(NOT HAVE_MAC_ATOMIC)
+      check_cxx_source_compiles("
+        #include <windows.h>
+        int main() {
+          volatile LONG x;
+          InterlockedIncrement(&x);
+          LONG y = InterlockedDecrement(&x);
+          return 0;
+        }
+      " HAVE_WIN_ATOMIC)
+
+      if(NOT HAVE_WIN_ATOMIC)
+        check_cxx_source_compiles("
+          #include <ia64intrin.h>
+          int main() {
+            volatile int x;
+            __sync_add_and_fetch(&x, 1);
+            int y = __sync_sub_and_fetch(&x, 1);
+            return 0;
+          }
+        " HAVE_IA64_ATOMIC)
+      endif()
+    endif()
+  endif()
+endif()
+
+# Determine which kind of smart pointers your compiler supports.
+
+check_cxx_source_compiles("
+  #include <memory>
+  int main() {
+    std::shared_ptr<int> x;
+    std::unique_ptr<int> y;
+    return 0;
+  }
+" HAVE_STD_SMART_PTR)
+
+# Determine which kind of byte swap functions your compiler supports.
+
+check_cxx_source_compiles("
+  int main() {
+    __builtin_bswap16(0);
+    __builtin_bswap32(0);
+    __builtin_bswap64(0);
+    return 0;
+  }
+" HAVE_GCC_BYTESWAP)
+
+if(NOT HAVE_GCC_BYTESWAP)
+  check_cxx_source_compiles("
+    #include <byteswap.h>
+    int main() {
+      __bswap_16(0);
+      __bswap_32(0);
+      __bswap_64(0);
+      return 0;
+    }
+  " HAVE_GLIBC_BYTESWAP)
+
+  if(NOT HAVE_GLIBC_BYTESWAP)
+    check_cxx_source_compiles("
+      #include <stdlib.h>
+      int main() {
+        _byteswap_ushort(0);
+        _byteswap_ulong(0);
+        _byteswap_uint64(0);
+        return 0;
+      }
+    " HAVE_MSC_BYTESWAP)
+
+    if(NOT HAVE_MSC_BYTESWAP)
+      check_cxx_source_compiles("
+        #include <libkern/OSByteOrder.h>
+        int main() {
+          OSSwapInt16(0);
+          OSSwapInt32(0);
+          OSSwapInt64(0);
+          return 0;
+        }
+      " HAVE_MAC_BYTESWAP)
+
+      if(NOT HAVE_MAC_BYTESWAP)
+        check_cxx_source_compiles("
+          #include <sys/endian.h>
+          int main() {
+            swap16(0);
+            swap32(0);
+            swap64(0);
+            return 0;
+          }
+        " HAVE_OPENBSD_BYTESWAP)
+      endif()
+    endif()
+  endif()
+endif()
+
+# Determine whether your compiler supports some safer version of vsprintf.
+
+check_cxx_source_compiles("
+  #include <cstdio>
+  #include <cstdarg>
+  int main() {
+    char buf[20];
+    va_list args;
+    vsnprintf(buf, 20, \"%d\", args);
+    return 0;
+  }
+" HAVE_VSNPRINTF)
+
+if(NOT HAVE_VSNPRINTF)
+  check_cxx_source_compiles("
+    #include <cstdio>
+    #include <cstdarg>
+    int main() {
+      char buf[20];
+      va_list args;
+      vsprintf_s(buf, \"%d\", args);
+      return 0;
+    }
+  " HAVE_VSPRINTF_S)
+endif()
+
+# Determine whether your compiler supports ISO _strdup.
+
+check_cxx_source_compiles("
+  #include <cstring>
+  int main() {
+    _strdup(0);
+    return 0;
+  }
+" HAVE_ISO_STRDUP)
+
+# Determine whether zlib is installed.
+
+if(NOT ZLIB_SOURCE)
+  find_package(ZLIB)
+  if(ZLIB_FOUND)
+    set(HAVE_ZLIB 1)
+  else()
+    set(HAVE_ZLIB 0)
+  endif()
+endif()
+
+# Determine whether CppUnit is installed.
+
+if(BUILD_TESTS AND NOT BUILD_SHARED_LIBS)
+  find_package(CppUnit)
+  if(NOT CppUnit_FOUND)
+    message(STATUS "CppUnit not found, disabling tests.")
+    set(BUILD_TESTS OFF)
+  endif()
+endif()
+
+# Detect WinRT mode
+if(CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
+	set(PLATFORM_WINRT 1)
+endif()

INSTALL

@@ -1,70 +0,0 @@
-TagLib Installation
-===================
-
-TagLib uses the CMake build system. As a user, you will most likely want to
-build TagLib in release mode and install it into a system-wide location.
-This can be done using the following commands:
-
-  cmake -DCMAKE_INSTALL_PREFIX=/usr/local -DCMAKE_RELEASE_TYPE=Release .
-  make
-  sudo make install
-
-In order to build the included examples, use the BUILD_EXAMPLES option:
-
-  cmake -DBUILD_EXAMPLES=ON [...]
-
-See http://www.cmake.org/cmake/help/runningcmake.html for generic help on
-running CMake.
-
-Mac OS X
---------
-
-On Mac OS X, you might want to build a framework that can be easily integrated
-into your application. If you set the BUILD_FRAMEWORK option on, it will compile
-TagLib as a framework. For example, the following command can be used to build
-an Universal Binary framework with Mac OS X 10.4 as the deployment target:
-
-  cmake -DCMAKE_BUILD_TYPE=Release \
-    -DBUILD_FRAMEWORK=ON \
-    -DCMAKE_C_COMPILER=/usr/bin/gcc-4.0 \
-    -DCMAKE_CXX_COMPILER=/usr/bin/c++-4.0 \
-    -DCMAKE_OSX_SYSROOT=/Developer/SDKs/MacOSX10.4u.sdk/ \
-    -DCMAKE_OSX_DEPLOYMENT_TARGET=10.4 \
-    -DCMAKE_OSX_ARCHITECTURES="ppc;i386;x86_64"
-
-For a 10.6 Snow Leopard static library with both 32-bit and 64-bit code, use:
-
-  cmake -DCMAKE_BUILD_TYPE=Release \
-    -DCMAKE_OSX_DEPLOYMENT_TARGET=10.6 \
-    -DCMAKE_OSX_ARCHITECTURES="i386;x86_64" \
-    -DENABLE_STATIC=ON \
-    -DCMAKE_INSTALL_PREFIX="<folder you want to build to>"
-
-After 'make', and 'make install', add libtag.a to your XCode project, and add
-the include folder to the project's User Header Search Paths.
-
-Windows
--------
-
-For building a static library on Windows with Visual Studio 2010, cd to
-the TagLib folder then:
-
-  cmake -DENABLE_STATIC=ON -DENABLE_STATIC_RUNTIME=ON -G "Visual Studio 10" ...
-  
-Including ENABLE_STATIC_RUNTIME=ON indicates you want TagLib built using the
-static runtime library, rather than the DLL form of the runtime.
-CMake will create a Visual Studio solution, taglib.sln that you can open and
-build as normal.  
-
-Unit Tests
-----------
-
-If you want to run the test suite to make sure TagLib works properly on your
-system, you need to have cppunit installed. To build the tests, include
-the option -DBUILD_TESTS=on when running cmake.
-
-The test suite has a custom target in the build system, so you can run
-the tests using make:
-
-  make check
-

INSTALL.md

@@ -0,0 +1,175 @@
+TagLib Installation
+===================
+
+TagLib uses the CMake build system. As a user, you will most likely want to
+build TagLib in release mode and install it into a system-wide location.
+This can be done using the following commands:
+
+    cmake -DCMAKE_INSTALL_PREFIX=/usr/local -DCMAKE_BUILD_TYPE=Release .
+    make
+    sudo make install
+
+In order to build the included examples, use the `BUILD_EXAMPLES` option:
+
+    cmake -DBUILD_EXAMPLES=ON [...]
+
+See http://www.cmake.org/cmake/help/runningcmake.html for generic help on
+running CMake.
+
+Mac OS X
+--------
+
+On Mac OS X, you might want to build a framework that can be easily integrated
+into your application. If you set the BUILD_FRAMEWORK option on, it will compile
+TagLib as a framework. For example, the following command can be used to build
+an Universal Binary framework with Mac OS X 10.4 as the deployment target:
+
+    cmake -DCMAKE_BUILD_TYPE=Release \
+      -DBUILD_FRAMEWORK=ON \
+      -DCMAKE_C_COMPILER=/usr/bin/gcc-4.0 \
+      -DCMAKE_CXX_COMPILER=/usr/bin/c++-4.0 \
+      -DCMAKE_OSX_SYSROOT=/Developer/SDKs/MacOSX10.4u.sdk/ \
+      -DCMAKE_OSX_DEPLOYMENT_TARGET=10.4 \
+      -DCMAKE_OSX_ARCHITECTURES="ppc;i386;x86_64"
+
+For a 10.6 Snow Leopard static library with both 32-bit and 64-bit code, use:
+
+    cmake -DCMAKE_BUILD_TYPE=Release \
+      -DCMAKE_OSX_DEPLOYMENT_TARGET=10.6 \
+      -DCMAKE_OSX_ARCHITECTURES="i386;x86_64" \
+      -DBUILD_SHARED_LIBS=OFF \
+      -DCMAKE_INSTALL_PREFIX="<folder you want to build to>"
+
+After `make`, and `make install`, add `libtag.` to your XCode project, and add
+the include folder to the project's User Header Search Paths.
+
+Windows
+-------
+
+It's Windows ... Systems vary!
+This means you need to adjust things to suit your system, especially paths.
+
+Tested with:
+* Microsoft Visual Studio 2010, 2015, 2017
+* Microsoft C++ Build Tools 2015, 2017 (standalone packages not requiring Visual Studio)
+* Gcc by mingw-w64.sf.net v4.6.3 (Strawberry Perl 32b)
+* MinGW32-4.8.0
+
+Requirements:
+* Tool chain, build environment, whatever ya want to call it ...
+     Installed and working.
+* CMake program. (Available at: www.cmake.org)
+     Installed and working.
+
+Optional:
+*  Zlib library.
+     Available in some tool chains, not all.
+     Search the web, take your choice.
+
+Useful configuration options used with CMake (GUI and/or command line):
+  Any of the `ZLIB_` variables may be used at the command line, `ZLIB_ROOT` is only
+  available on the command line.
+  
+  | option               | description |
+   ---------------------| ------------|
+  `ZLIB_ROOT=`         | Where to find ZLib's root directory. Assumes parent of: `\include` and `\lib.`|
+   `ZLIB_INCLUDE_DIR=`  | Where to find ZLib's Include directory.|
+   `ZLIB_LIBRARY=`      | Where to find ZLib's Library.
+   `ZLIB_SOURCE=`       | Where to find ZLib's Source Code. Alternative to `ZLIB_INCLUDE_DIR` and `ZLIB_LIBRARY`.
+   `CMAKE_INSTALL_PREFIX=` | Where to install Taglib. |
+   `CMAKE_BUILD_TYPE=`  | Release, Debug, etc ... (Not available in MSVC) |
+
+The easiest way is at the command prompt (Visual C++ command prompt for MSVS users – batch file and/or shortcuts are your friends).
+
+1.  **Build the Makefiles:**
+
+    Replace "GENERATOR" with your needs.
+    * For MSVS: `Visual Studio XX YYYY`, e.g. `Visual Studio 14 2015`.
+    
+      **Note**: As Visual Studio 2017 supports CMake, you can skip this step and open the taglib
+      folder in VS instead.
+    * For MinGW: `MinGW Makefiles`
+       
+          C:\GitRoot\taglib> cmake -G "GENERATOR"  -DCMAKE_INSTALL_PREFIX=C:\Libraries\taglib
+
+    Or use the CMake GUI:
+    1. Open CMake GUI.
+    2. Set paths: *Where is the source code* and *Where to build the binaries*.
+
+       In the example, both would be: `C:\GitRoot\taglib`
+    3. Tick: Advanced
+    4. Select: Configure
+    5. Select: Generator
+    6. Tick: Use default native compilers
+    7. Select: Finish
+      Wait until done.
+    8. If using ZLib, Scroll down.
+    (to the bottom of the list of options ... should go over them all)
+       1. Edit: `ZLIB_INCLUDE_DIR`
+       2. Edit: `ZLIB_LIBRARY`
+    9. Select: Generate
+
+2.  **Build the project**
+    * MSVS:
+
+          C:\GitRoot\taglib> msbuild all_build.vcxproj /p:Configuration=Release
+      OR (Depending on MSVS version or personal choice)
+
+          C:\GitRoot\taglib> devenv all_build.vcxproj /build Release
+      OR in the MSVS GUI:
+      1. Open MSVS.
+      2. Open taglib solution.
+      3. Set build type to: Release (look in the tool bars)
+      2. Hit F7 to build the solution. (project)
+    * MinGW:
+
+          C:\GitRoot\taglib> gmake
+
+      OR (Depending on MinGW install)
+      
+          C:\GitRoot\taglib> mingw32-make
+
+
+
+3.  **Install the project**
+  
+    (Change `install` to `uninstall` to uninstall the project)
+    * MSVS:
+
+          C:\GitRoot\taglib> msbuild install.vcxproj
+      OR (Depending on MSVC version or personal choice)
+
+          C:\GitRoot\taglib> devenv install.vcxproj
+      
+      Or in the MSVS GUI:
+        1. Open project.
+        2. Open Solution Explorer.
+        3. Right Click: INSTALL
+        4. Select: Project Only
+        5. Select: Build Only INSTALL
+    * MinGW:
+
+          C:\GitRoot\taglib> gmake install
+      OR (Depending on MinGW install)
+          
+          C:\GitRoot\taglib> mingw32-make install
+
+
+To build a static library, set the following two options with CMake:
+
+    -DBUILD_SHARED_LIBS=OFF -DENABLE_STATIC_RUNTIME=ON
+
+Including `ENABLE_STATIC_RUNTIME=ON` indicates you want TagLib built using the
+static runtime library, rather than the DLL form of the runtime.
+
+Unit Tests
+----------
+
+If you want to run the test suite to make sure TagLib works properly on your
+system, you need to have cppunit installed. To build the tests, include
+the option `-DBUILD_TESTS=on` when running cmake.
+
+The test suite has a custom target in the build system, so you can run
+the tests using make:
+
+    make check

NEWS

@@ -1,5 +1,170 @@
+============================
+
+ * Added support for DSF and DSDIFF files.
+ * Added support for WinRT.
+ * Added support for classical music tags of iTunes 12.5.
+ * Added support for file descriptor to FileStream.
+ * Added support for 'cmID', 'purl', 'egid' MP4 atoms.
+ * Enabled FileRef to detect file types based on the stream content.
+ * Dropped support for Windows 9x and NT 4.0 or older.
+ * Check for mandatory header objects in ASF files.
+ * Fixed OOB read on invalid Ogg FLAC files (CVE-2018-11439).
+ * Fixed handling of empty MPEG files.
+ * Fixed reading MP4 atoms with zero length.
+ * Fixed reading FLAC files with zero-sized seektables.
+ * Fixed handling of lowercase field names in Vorbis Comments.
+ * Fixed handling of 'rate' atoms in MP4 files.
+ * Fixed handling of invalid UTF-8 sequences.
+ * Fixed possible file corruptions when saving Ogg files.
+ * TableOfContentsFrame::toString() improved.
+ * UserTextIdentificationFrame::toString() improved.
+ * Marked FileRef::create() deprecated.
+ * Several smaller bug fixes and performance improvements.
+
+TagLib 1.11.1 (Oct 24, 2016)
+============================
+
+ * Fixed binary incompatible change in TagLib::String.
+ * Fixed reading ID3v2 CTOC frames with a lot of entries.
+ * Fixed seeking ByteVectorStream from the end.
+
+TagLib 1.11 (Apr 29, 2016)
+==========================
+
+1.11:
+
+ * Fixed reading APE items with long keys.
+ * Fixed reading ID3v2 SYLT frames when description is empty.
+
+1.11 BETA 2:
+
+ * Better handling of PCM WAV files with a 'fact' chunk.
+ * Better handling of corrupted APE tags.
+ * Efficient decoding of unsynchronized ID3v2 frames.
+ * Fixed text encoding when saving certain frames in ID3v2.3 tags.
+ * Fixed updating the size of RIFF files when removing chunks.
+ * Several smaller bug fixes and performance improvements.
+
+1.11 BETA:
+
+ * New API for creating FileRef from IOStream.
+ * Added support for ID3v2 PCST and WFED frames.
+ * Added support for pictures in XiphComment.
+ * Added String::clear().
+ * Added FLAC::File::strip() for removing non-standard tags.
+ * Added alternative functions to XiphComment::removeField().
+ * Added BUILD_BINDINGS build option.
+ * Added ENABLE_CCACHE build option.
+ * Replaced ENABLE_STATIC build option with BUILD_SHARED_LIBS.
+ * Better handling of duplicate ID3v2 tags in all kinds of files.
+ * Better handling of duplicate tag chunks in WAV files.
+ * Better handling of duplicate tag chunks in AIFF files.
+ * Better handling of duplicate Vorbis comment blocks in FLAC files.
+ * Better handling of broken MPEG audio frames.
+ * Fixed crash when calling File::properties() after strip().
+ * Fixed crash when parsing certain MPEG files.
+ * Fixed crash when saving Ogg files.
+ * Fixed possible file corruptions when saving ASF files.
+ * Fixed possible file corruptions when saving FLAC files.
+ * Fixed possible file corruptions when saving MP4 files.
+ * Fixed possible file corruptions when saving MPEG files.
+ * Fixed possible file corruptions when saving APE files.
+ * Fixed possible file corruptions when saving Musepack files.
+ * Fixed possible file corruptions when saving WavPack files.
+ * Fixed updating the comment field of Vorbis comments.
+ * Fixed reading date and time in ID3v2.3 tags.
+ * Marked ByteVector::null and ByteVector::isNull() deprecated.
+ * Marked String::null and String::isNull() deprecated.
+ * Marked XiphComment::removeField() deprecated.
+ * Marked Ogg::Page::getCopyWithNewPageSequenceNumber() deprecated. It returns null.
+ * Marked custom integer types deprecated.
+ * Many smaller bug fixes and performance improvements.
+
+TagLib 1.10 (Nov 11, 2015)
+==========================
+
+1.10:
+
+ * Added new options to the tagwriter example.
+ * Fixed self-assignment operator in some types.
+ * Fixed extraction of MP4 tag keys with an empty list.
+
+1.10 BETA:
+
+ * New API for the audio length in milliseconds.
+ * Added support for ID3v2 ETCO and SYLT frames.
+ * Added support for album artist in PropertyMap API of MP4 files.
+ * Added support for embedded frames in ID3v2 CHAP and CTOC frames.
+ * Added support for AIFF-C files.
+ * Better handling of duplicate ID3v2 tags in MPEG files.
+ * Allowed generating taglib.pc on Windows.
+ * Added ZLIB_SOURCE build option.
+ * Fixed backwards-incompatible change in TagLib::String when constructing UTF16 strings.
+ * Fixed crash when parsing certain FLAC files.
+ * Fixed crash when encoding empty strings.
+ * Fixed saving of certain XM files on OS X.
+ * Changed Xiph and APE generic getters to return space-concatenated values.
+ * Fixed possible file corruptions when removing tags from WAV files.
+ * Added support for MP4 files with 64-bit atoms in certain 64-bit environments.
+ * Prevented ID3v2 padding from being too large.
+ * Fixed crash when parsing corrupted APE files.
+ * Fixed crash when parsing corrupted WAV files.
+ * Fixed crash when parsing corrupted Ogg FLAC files.
+ * Fixed crash when parsing corrupted MPEG files.
+ * Fixed saving empty tags in WAV files.
+ * Fixed crash when parsing corrupted Musepack files.
+ * Fixed possible memory leaks when parsing AIFF and WAV files.
+ * Fixed crash when parsing corrupted MP4 files.
+ * Stopped writing empty ID3v2 frames.
+ * Fixed possible file corruptions when saving WMA files.
+ * Added TagLib::MP4::Tag::isEmpty().
+ * Added accessors to manipulate MP4 tags.
+ * Fixed crash when parsing corrupted WavPack files.
+ * Fixed seeking MPEG frames.
+ * Fixed reading FLAC files with zero-sized padding blocks.
+ * Added support for reading the encoder information of WMA files.
+ * Added support for reading the codec of WAV files.
+ * Added support for multi channel WavPack files.
+ * Added support for reading the nominal bitrate of Ogg Speex files.
+ * Added support for VBR headers in MPEG files.
+ * Marked FLAC::File::streamInfoData() deprecated. It returns an empty ByteVector.
+ * Marked FLAC::File::streamLength() deprecated. It returns zero.
+ * Fixed possible file corruptions when adding an ID3v1 tag to FLAC files.
+ * Many smaller bug fixes and performance improvements.
+
+TagLib 1.9.1 (Oct 8, 2013)
+==========================
+
+ * Fixed binary incompatible change in TagLib::Map and TagLib::List.
+ * Fixed constructing String from ByteVector.
+ * Fixed compilation on MSVC with the /Zc:wchar_t- option.
+ * Fixed detecting of RIFF files with invalid chunk sizes.
+ * Added TagLib::MP4::Properties::codec().
+
+TagLib 1.9 (Oct 6, 2013)
+========================
+
+ * Added support for the Ogg Opus file format.
+ * Added support for INFO tags in WAV files.
+ * Changed FileStream to use Windows file API.
+ * Included taglib-config.cmd script for Windows.
+ * New ID3v1::Tag methods for working directly with genre numbers.
+ * New MPEG::File methods for checking which tags are saved in the file.
+ * Added support for the PropertyMap API to ASF and MP4 files.
+ * Added MusicBrainz identifiers to the PropertyMap API.
+ * Allowed reading of MP4 cover art without an explicitly specified format.
+ * Better parsing of corrupted FLAC files.
+ * Fixed saving of PropertyMap comments without description into ID3v2 tags.
+ * Fixed crash when parsing certain XM files.
+ * Fixed compilation of unit test with clang.
+ * Better handling of files that can't be open or have read-only permissions.
+ * Improved atomic reference counting.
+ * New hookable API for debug messages.
+ * More complete Windows install instructions.
+ * Many smaller bug fixes and performance improvements.
+
 TagLib 1.8 (Sep 6, 2012)
-==============================
+========================
 
 1.8:
 

README.md

@@ -0,0 +1,26 @@
+# TagLib
+
+[![Build Status](https://travis-ci.org/taglib/taglib.svg?branch=master)](https://travis-ci.org/taglib/taglib)
+
+### TagLib Audio Metadata Library
+
+http://taglib.org/
+
+TagLib is a library for reading and editing the metadata of several
+popular audio formats. Currently it supports both ID3v1 and [ID3v2][]
+for MP3 files, [Ogg Vorbis][] comments and ID3 tags 
+in [FLAC][], MPC, Speex, WavPack, TrueAudio, WAV, AIFF, MP4, APE,
+DSF, DFF, and ASF files.
+
+TagLib is distributed under the [GNU Lesser General Public License][]
+(LGPL) and [Mozilla Public License][] (MPL). Essentially that means that
+it may be used in proprietary applications, but if changes are made to
+TagLib they must be contributed back to the project. Please review the
+licenses if you are considering using TagLib in your project.
+
+  [ID3v2]: http://www.id3.org 
+  [Ogg Vorbis]: http://vorbis.com/
+  [FLAC]: https://xiph.org/flac/
+  [GNU Lesser General Public License]: http://www.gnu.org/licenses/lgpl.html
+  [Mozilla Public License]: http://www.mozilla.org/MPL/MPL-1.1.html
+

bindings/c/CMakeLists.txt

@@ -21,7 +21,14 @@ set(tag_c_HDRS tag_c.h)
 add_library(tag_c tag_c.cpp ${tag_c_HDRS})
 
 target_link_libraries(tag_c tag)
-set_target_properties(tag_c PROPERTIES PUBLIC_HEADER "${tag_c_HDRS}")
+set_target_properties(tag_c PROPERTIES
+  PUBLIC_HEADER "${tag_c_HDRS}"
+  DEFINE_SYMBOL MAKE_TAGLIB_LIB
+)
+if(VISIBILITY_HIDDEN)
+	set_target_properties(tag_c PROPERTIES C_VISIBILITY_PRESET hidden
+	)
+endif()
 if(BUILD_FRAMEWORK)
   set_target_properties(tag_c PROPERTIES FRAMEWORK TRUE)
 endif()
@@ -61,7 +68,7 @@ install(TARGETS tag_c
 	PUBLIC_HEADER DESTINATION ${INCLUDE_INSTALL_DIR}/taglib
 )
 
-if(NOT WIN32 AND NOT BUILD_FRAMEWORK)
+if(NOT BUILD_FRAMEWORK)
 	configure_file(${CMAKE_CURRENT_SOURCE_DIR}/taglib_c.pc.cmake ${CMAKE_CURRENT_BINARY_DIR}/taglib_c.pc)
 	install(FILES ${CMAKE_CURRENT_BINARY_DIR}/taglib_c.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig)
 endif()

bindings/c/tag_c.cpp

@@ -20,7 +20,7 @@
  ***************************************************************************/
 
 #ifdef HAVE_CONFIG_H
-#include "config.h"
+# include <config.h>
 #endif
 
 #include <stdlib.h>
@@ -44,18 +44,41 @@
 
 using namespace TagLib;
 
-static List<char *> strings;
-static bool unicodeStrings = true;
-static bool stringManagementEnabled = true;
+namespace
+{
+  List<char *> strings;
+  bool unicodeStrings = true;
+  bool stringManagementEnabled = true;
+
+  char *stringToCharArray(const String &s)
+  {
+    const std::string str = s.to8Bit(unicodeStrings);
+
+#ifdef HAVE_ISO_STRDUP
+
+    return ::_strdup(str.c_str());
+
+#else
+
+    return ::strdup(str.c_str());
+
+#endif
+  }
+
+  String charArrayToString(const char *s)
+  {
+    return String(s, unicodeStrings ? String::UTF8 : String::Latin1);
+  }
+}
 
 void taglib_set_strings_unicode(BOOL unicode)
 {
-  unicodeStrings = bool(unicode);
+  unicodeStrings = (unicode != 0);
 }
 
 void taglib_set_string_management_enabled(BOOL management)
 {
-  stringManagementEnabled = bool(management);
+  stringManagementEnabled = (management != 0);
 }
 
 void taglib_free(void* pointer)
@@ -69,64 +92,62 @@ void taglib_free(void* pointer)
 
 TagLib_File *taglib_file_new(const char *filename)
 {
-  return reinterpret_cast<TagLib_File *>(FileRef::create(filename));
+  return reinterpret_cast<TagLib_File *>(new FileRef(filename));
 }
 
 TagLib_File *taglib_file_new_type(const char *filename, TagLib_File_Type type)
 {
   switch(type) {
   case TagLib_File_MPEG:
-    return reinterpret_cast<TagLib_File *>(new MPEG::File(filename));
+    return reinterpret_cast<TagLib_File *>(new FileRef(new MPEG::File(filename)));
   case TagLib_File_OggVorbis:
-    return reinterpret_cast<TagLib_File *>(new Ogg::Vorbis::File(filename));
+    return reinterpret_cast<TagLib_File *>(new FileRef(new Ogg::Vorbis::File(filename)));
   case TagLib_File_FLAC:
-    return reinterpret_cast<TagLib_File *>(new FLAC::File(filename));
+    return reinterpret_cast<TagLib_File *>(new FileRef(new FLAC::File(filename)));
   case TagLib_File_MPC:
-    return reinterpret_cast<TagLib_File *>(new MPC::File(filename));
+    return reinterpret_cast<TagLib_File *>(new FileRef(new MPC::File(filename)));
   case TagLib_File_OggFlac:
-    return reinterpret_cast<TagLib_File *>(new Ogg::FLAC::File(filename));
+    return reinterpret_cast<TagLib_File *>(new FileRef(new Ogg::FLAC::File(filename)));
   case TagLib_File_WavPack:
-    return reinterpret_cast<TagLib_File *>(new WavPack::File(filename));
+    return reinterpret_cast<TagLib_File *>(new FileRef(new WavPack::File(filename)));
   case TagLib_File_Speex:
-    return reinterpret_cast<TagLib_File *>(new Ogg::Speex::File(filename));
+    return reinterpret_cast<TagLib_File *>(new FileRef(new Ogg::Speex::File(filename)));
   case TagLib_File_TrueAudio:
-    return reinterpret_cast<TagLib_File *>(new TrueAudio::File(filename));
+    return reinterpret_cast<TagLib_File *>(new FileRef(new TrueAudio::File(filename)));
   case TagLib_File_MP4:
-    return reinterpret_cast<TagLib_File *>(new MP4::File(filename));
+    return reinterpret_cast<TagLib_File *>(new FileRef(new MP4::File(filename)));
   case TagLib_File_ASF:
-    return reinterpret_cast<TagLib_File *>(new ASF::File(filename));
+    return reinterpret_cast<TagLib_File *>(new FileRef(new ASF::File(filename)));
   default:
     return 0;
   }
-
-  return 0;
 }
 
 void taglib_file_free(TagLib_File *file)
 {
-  delete reinterpret_cast<File *>(file);
+  delete reinterpret_cast<FileRef *>(file);
 }
 
 BOOL taglib_file_is_valid(const TagLib_File *file)
 {
-  return reinterpret_cast<const File *>(file)->isValid();
+  return reinterpret_cast<const FileRef *>(file)->isValid();
 }
 
 TagLib_Tag *taglib_file_tag(const TagLib_File *file)
 {
-  const File *f = reinterpret_cast<const File *>(file);
+  const FileRef *f = reinterpret_cast<const FileRef *>(file);
   return reinterpret_cast<TagLib_Tag *>(f->tag());
 }
 
 const TagLib_AudioProperties *taglib_file_audioproperties(const TagLib_File *file)
 {
-  const File *f = reinterpret_cast<const File *>(file);
+  const FileRef *f = reinterpret_cast<const FileRef *>(file);
   return reinterpret_cast<const TagLib_AudioProperties *>(f->audioProperties());
 }
 
 BOOL taglib_file_save(TagLib_File *file)
 {
-  return reinterpret_cast<File *>(file)->save();
+  return reinterpret_cast<FileRef *>(file)->save();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -136,7 +157,7 @@ BOOL taglib_file_save(TagLib_File *file)
 char *taglib_tag_title(const TagLib_Tag *tag)
 {
   const Tag *t = reinterpret_cast<const Tag *>(tag);
-  char *s = ::strdup(t->title().toCString(unicodeStrings));
+  char *s = stringToCharArray(t->title());
   if(stringManagementEnabled)
     strings.append(s);
   return s;
@@ -145,7 +166,7 @@ char *taglib_tag_title(const TagLib_Tag *tag)
 char *taglib_tag_artist(const TagLib_Tag *tag)
 {
   const Tag *t = reinterpret_cast<const Tag *>(tag);
-  char *s = ::strdup(t->artist().toCString(unicodeStrings));
+  char *s = stringToCharArray(t->artist());
   if(stringManagementEnabled)
     strings.append(s);
   return s;
@@ -154,7 +175,7 @@ char *taglib_tag_artist(const TagLib_Tag *tag)
 char *taglib_tag_album(const TagLib_Tag *tag)
 {
   const Tag *t = reinterpret_cast<const Tag *>(tag);
-  char *s = ::strdup(t->album().toCString(unicodeStrings));
+  char *s = stringToCharArray(t->album());
   if(stringManagementEnabled)
     strings.append(s);
   return s;
@@ -163,7 +184,7 @@ char *taglib_tag_album(const TagLib_Tag *tag)
 char *taglib_tag_comment(const TagLib_Tag *tag)
 {
   const Tag *t = reinterpret_cast<const Tag *>(tag);
-  char *s = ::strdup(t->comment().toCString(unicodeStrings));
+  char *s = stringToCharArray(t->comment());
   if(stringManagementEnabled)
     strings.append(s);
   return s;
@@ -172,7 +193,7 @@ char *taglib_tag_comment(const TagLib_Tag *tag)
 char *taglib_tag_genre(const TagLib_Tag *tag)
 {
   const Tag *t = reinterpret_cast<const Tag *>(tag);
-  char *s = ::strdup(t->genre().toCString(unicodeStrings));
+  char *s = stringToCharArray(t->genre());
   if(stringManagementEnabled)
     strings.append(s);
   return s;
@@ -193,31 +214,31 @@ unsigned int taglib_tag_track(const TagLib_Tag *tag)
 void taglib_tag_set_title(TagLib_Tag *tag, const char *title)
 {
   Tag *t = reinterpret_cast<Tag *>(tag);
-  t->setTitle(String(title, unicodeStrings ? String::UTF8 : String::Latin1));
+  t->setTitle(charArrayToString(title));
 }
 
 void taglib_tag_set_artist(TagLib_Tag *tag, const char *artist)
 {
   Tag *t = reinterpret_cast<Tag *>(tag);
-  t->setArtist(String(artist, unicodeStrings ? String::UTF8 : String::Latin1));
+  t->setArtist(charArrayToString(artist));
 }
 
 void taglib_tag_set_album(TagLib_Tag *tag, const char *album)
 {
   Tag *t = reinterpret_cast<Tag *>(tag);
-  t->setAlbum(String(album, unicodeStrings ? String::UTF8 : String::Latin1));
+  t->setAlbum(charArrayToString(album));
 }
 
 void taglib_tag_set_comment(TagLib_Tag *tag, const char *comment)
 {
   Tag *t = reinterpret_cast<Tag *>(tag);
-  t->setComment(String(comment, unicodeStrings ? String::UTF8 : String::Latin1));
+  t->setComment(charArrayToString(comment));
 }
 
 void taglib_tag_set_genre(TagLib_Tag *tag, const char *genre)
 {
   Tag *t = reinterpret_cast<Tag *>(tag);
-  t->setGenre(String(genre, unicodeStrings ? String::UTF8 : String::Latin1));
+  t->setGenre(charArrayToString(genre));
 }
 
 void taglib_tag_set_year(TagLib_Tag *tag, unsigned int year)
@@ -237,7 +258,7 @@ void taglib_tag_free_strings()
   if(!stringManagementEnabled)
     return;
 
-  for(List<char *>::Iterator it = strings.begin(); it != strings.end(); ++it)
+  for(List<char *>::ConstIterator it = strings.begin(); it != strings.end(); ++it)
     free(*it);
   strings.clear();
 }

bindings/c/tag_c.h

@@ -29,7 +29,9 @@
 extern "C" {
 #endif
 
-#if defined(_WIN32) || defined(_WIN64)
+#if defined(TAGLIB_STATIC)
+#define TAGLIB_C_EXPORT
+#elif defined(_WIN32) || defined(_WIN64)
 #ifdef MAKE_TAGLIB_C_LIB
 #define TAGLIB_C_EXPORT __declspec(dllexport)
 #else
@@ -122,7 +124,7 @@ TAGLIB_C_EXPORT TagLib_File *taglib_file_new_type(const char *filename, TagLib_F
 TAGLIB_C_EXPORT void taglib_file_free(TagLib_File *file);
 
 /*!
- * Returns true if the file is open and readble and valid information for
+ * Returns true if the file is open and readable and valid information for
  * the Tag and / or AudioProperties was found.
  */
 
@@ -135,7 +137,7 @@ TAGLIB_C_EXPORT BOOL taglib_file_is_valid(const TagLib_File *file);
 TAGLIB_C_EXPORT TagLib_Tag *taglib_file_tag(const TagLib_File *file);
 
 /*!
- * Returns a pointer to the the audio properties associated with this file.  This
+ * Returns a pointer to the audio properties associated with this file.  This
  * will be freed automatically when the file is freed.
  */
 TAGLIB_C_EXPORT const TagLib_AudioProperties *taglib_file_audioproperties(const TagLib_File *file);

bindings/c/taglib_c.pc.cmake

@@ -7,6 +7,6 @@ includedir=${INCLUDE_INSTALL_DIR}
 Name: TagLib C Bindings
 Description: Audio meta-data library (C bindings)
 Requires: taglib
-Version: ${TAGLIB_LIB_MAJOR_VERSION}.${TAGLIB_LIB_MINOR_VERSION}.${TAGLIB_LIB_PATCH_VERSION}
+Version: ${TAGLIB_LIB_VERSION_STRING}
 Libs: -L${LIB_INSTALL_DIR} -ltag_c
 Cflags: -I${INCLUDE_INSTALL_DIR}/taglib 

cmake/TestFileOffsetBits.c

@@ -0,0 +1,9 @@
+#include <sys/types.h>
+
+int main(int argc, char **argv)
+{
+  /* Cause a compile-time error if off_t is smaller than 64 bits */
+#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
+  int off_t_is_large[ (LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1 ];  
+  return 0;
+}

cmake/TestLargeFiles.c.cmakein

@@ -0,0 +1,23 @@
+#cmakedefine _LARGEFILE_SOURCE
+#cmakedefine _LARGEFILE64_SOURCE
+#cmakedefine _LARGE_FILES
+#cmakedefine _FILE_OFFSET_BITS ${_FILE_OFFSET_BITS}
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char **argv)
+{
+  /* Cause a compile-time error if off_t is smaller than 64 bits,
+   * and make sure we have ftello / fseeko.
+   */
+#define LARGE_OFF_T (((off_t) 1 << 62) - 1 + ((off_t) 1 << 62))
+  int off_t_is_large[ (LARGE_OFF_T % 2147483629 == 721 && LARGE_OFF_T % 2147483647 == 1) ? 1 : -1 ];  
+  FILE *fp = fopen(argv[0],"r");
+  off_t offset = ftello( fp );
+
+  fseeko( fp, offset, SEEK_CUR );
+  fclose(fp);
+  return 0;
+}

cmake/modules/TestLargeFiles.cmake

@@ -0,0 +1,104 @@
+# - Define macro to check large file support
+#
+#  TEST_LARGE_FILES(VARIABLE)
+#
+#  VARIABLE will be set to true if off_t is 64 bits, and fseeko/ftello present.
+#  This macro will also set defines necessary enable large file support, for instance
+#  _LARGE_FILES
+#  _LARGEFILE_SOURCE
+#  _FILE_OFFSET_BITS 64
+#  HAVE_FSEEKO
+#
+#  However, it is YOUR job to make sure these defines are set in a cmakedefine so they
+#  end up in a config.h file that is included in your source if necessary!
+
+#  This macro skips the Windows specific checks. Because TagLib uses Win32 API.
+
+MACRO(TEST_LARGE_FILES VARIABLE)
+  IF(NOT DEFINED ${VARIABLE})
+
+    # On most platforms it is probably overkill to first test the flags for 64-bit off_t,
+    # and then separately fseeko. However, in the future we might have 128-bit filesystems
+    # (ZFS), so it might be dangerous to indiscriminately set e.g. _FILE_OFFSET_BITS=64.
+
+    MESSAGE(STATUS "Checking for 64-bit off_t")
+
+    # First check without any special flags
+    TRY_COMPILE(FILE64_OK "${PROJECT_BINARY_DIR}"
+      "${CMAKE_SOURCE_DIR}/cmake/TestFileOffsetBits.c")
+    if(FILE64_OK)
+      MESSAGE(STATUS "Checking for 64-bit off_t - present")
+    endif(FILE64_OK)
+
+    if(NOT FILE64_OK)
+      # Test with _FILE_OFFSET_BITS=64
+      TRY_COMPILE(FILE64_OK "${PROJECT_BINARY_DIR}"
+        "${CMAKE_SOURCE_DIR}/cmake/TestFileOffsetBits.c"
+        COMPILE_DEFINITIONS "-D_FILE_OFFSET_BITS=64" )
+      if(FILE64_OK)
+        MESSAGE(STATUS "Checking for 64-bit off_t - present with _FILE_OFFSET_BITS=64")
+        set(_FILE_OFFSET_BITS 64)
+      endif(FILE64_OK)
+    endif(NOT FILE64_OK)
+
+    if(NOT FILE64_OK)
+      # Test with _LARGE_FILES
+      TRY_COMPILE(FILE64_OK "${PROJECT_BINARY_DIR}"
+        "${CMAKE_SOURCE_DIR}/cmake/TestFileOffsetBits.c"
+        COMPILE_DEFINITIONS "-D_LARGE_FILES" )
+      if(FILE64_OK)
+        MESSAGE(STATUS "Checking for 64-bit off_t - present with _LARGE_FILES")
+        set(_LARGE_FILES 1)
+      endif(FILE64_OK)
+    endif(NOT FILE64_OK)
+
+    if(NOT FILE64_OK)
+      # Test with _LARGEFILE_SOURCE
+      TRY_COMPILE(FILE64_OK "${PROJECT_BINARY_DIR}"
+        "${CMAKE_SOURCE_DIR}/cmake/TestFileOffsetBits.c"
+        COMPILE_DEFINITIONS "-D_LARGEFILE_SOURCE" )
+      if(FILE64_OK)
+        MESSAGE(STATUS "Checking for 64-bit off_t - present with _LARGEFILE_SOURCE")
+        set(_LARGEFILE_SOURCE 1)
+      endif(FILE64_OK)
+    endif(NOT FILE64_OK)
+
+    if(NOT FILE64_OK)
+      MESSAGE(STATUS "Checking for 64-bit off_t - not present")
+    else(NOT FILE64_OK)
+
+      # Set the flags we might have determined to be required above
+      configure_file("${CMAKE_SOURCE_DIR}/cmake/TestLargeFiles.c.cmakein"
+                     "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/TestLargeFiles.c")
+
+      MESSAGE(STATUS "Checking for fseeko/ftello")
+      # Test if ftello/fseeko are available
+      TRY_COMPILE(FSEEKO_COMPILE_OK "${PROJECT_BINARY_DIR}"
+        "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/TestLargeFiles.c")
+      if(FSEEKO_COMPILE_OK)
+        MESSAGE(STATUS "Checking for fseeko/ftello - present")
+      endif(FSEEKO_COMPILE_OK)
+
+      if(NOT FSEEKO_COMPILE_OK)
+        # glibc 2.2 neds _LARGEFILE_SOURCE for fseeko (but not 64-bit off_t...)
+        TRY_COMPILE(FSEEKO_COMPILE_OK "${PROJECT_BINARY_DIR}"
+          "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/TestLargeFiles.c"
+          COMPILE_DEFINITIONS "-D_LARGEFILE_SOURCE" )
+        if(FSEEKO_COMPILE_OK)
+          MESSAGE(STATUS "Checking for fseeko/ftello - present with _LARGEFILE_SOURCE")
+          set(_LARGEFILE_SOURCE 1)
+        endif(FSEEKO_COMPILE_OK)
+      endif(NOT FSEEKO_COMPILE_OK)
+
+    endif(NOT FILE64_OK)
+
+    if(FSEEKO_COMPILE_OK)
+      SET(${VARIABLE} 1 CACHE INTERNAL "Result of test for large file support" FORCE)
+      set(HAVE_FSEEKO 1)
+    else(FSEEKO_COMPILE_OK)
+      MESSAGE(STATUS "Checking for fseeko/ftello - not found")
+      SET(${VARIABLE} 0 CACHE INTERNAL "Result of test for large file support" FORCE)
+    endif(FSEEKO_COMPILE_OK)
+
+  ENDIF(NOT DEFINED ${VARIABLE})
+ENDMACRO(TEST_LARGE_FILES VARIABLE)

config-taglib.h.cmake

@@ -1,11 +0,0 @@
-/* config-taglib.h. Generated by cmake from config-taglib.h.cmake */
-
-/* Define if you have libz */
-#cmakedefine   HAVE_ZLIB 1
-
-#cmakedefine   NO_ITUNES_HACKS 1
-#cmakedefine   WITH_ASF 1
-#cmakedefine   WITH_MP4 1
-
-#cmakedefine TESTS_DIR "@TESTS_DIR@"
-

config.h.cmake

@@ -0,0 +1,43 @@
+/* config.h. Generated by cmake from config.h.cmake */
+
+#ifndef TAGLIB_CONFIG_H
+#define TAGLIB_CONFIG_H
+
+/* Defined if required for large files support */
+#cmakedefine   _LARGE_FILES      ${_LARGE_FILES}
+#cmakedefine   _LARGEFILE_SOURCE ${_LARGEFILE_SOURCE}
+#cmakedefine   _FILE_OFFSET_BITS ${_FILE_OFFSET_BITS}
+
+/* Defined if your compiler supports some byte swap functions */
+#cmakedefine   HAVE_GCC_BYTESWAP 1
+#cmakedefine   HAVE_GLIBC_BYTESWAP 1
+#cmakedefine   HAVE_MSC_BYTESWAP 1
+#cmakedefine   HAVE_MAC_BYTESWAP 1
+#cmakedefine   HAVE_OPENBSD_BYTESWAP 1
+
+/* Defined if your compiler supports some atomic operations */
+#cmakedefine   HAVE_STD_ATOMIC 1
+#cmakedefine   HAVE_GCC_ATOMIC 1
+#cmakedefine   HAVE_MAC_ATOMIC 1
+#cmakedefine   HAVE_WIN_ATOMIC 1
+#cmakedefine   HAVE_IA64_ATOMIC 1
+
+/* Defined if your compiler supports shared_ptr */
+#cmakedefine   HAVE_STD_SMART_PTR 1
+
+/* Defined if your compiler supports some safer version of vsprintf */
+#cmakedefine   HAVE_VSNPRINTF 1
+#cmakedefine   HAVE_VSPRINTF_S 1
+
+/* Defined if your compiler supports ISO _strdup */
+#cmakedefine   HAVE_ISO_STRDUP 1
+
+/* Defined if zlib is installed */
+#cmakedefine   HAVE_ZLIB 1
+
+/* Indicates whether debug messages are shown even in release mode */
+#cmakedefine   TRACE_IN_RELEASE 1
+
+#cmakedefine TESTS_DIR "@TESTS_DIR@"
+
+#endif

examples/CMakeLists.txt

@@ -1,50 +1,43 @@
-if(BUILD_EXAMPLES)
-INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_SOURCE_DIR}/../taglib
-		     ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/toolkit
-		     ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/ape
-		     ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/mpeg
-		     ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/mpeg/id3v1
-		     ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/mpeg/id3v2
-		     ${CMAKE_CURRENT_SOURCE_DIR}/../bindings/c/  )
+include_directories(
+  ${CMAKE_CURRENT_SOURCE_DIR}/../taglib
+  ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/toolkit
+  ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/ape
+  ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/mpeg
+  ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/mpeg/id3v1
+  ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/mpeg/id3v2
+  ${CMAKE_CURRENT_SOURCE_DIR}/../bindings/c/
+)
 
-if(ENABLE_STATIC)
-    add_definitions(-DTAGLIB_STATIC)
-endif(ENABLE_STATIC)
+if(NOT BUILD_SHARED_LIBS)
+  add_definitions(-DTAGLIB_STATIC)
+endif()
 
 ########### next target ###############
 
-ADD_EXECUTABLE(tagreader tagreader.cpp)
-
-TARGET_LINK_LIBRARIES(tagreader  tag )
-
+add_executable(tagreader tagreader.cpp)
+target_link_libraries(tagreader tag)
 
 ########### next target ###############
 
-ADD_EXECUTABLE(tagreader_c tagreader_c.c)
-
-TARGET_LINK_LIBRARIES(tagreader_c  tag_c )
-
+add_executable(tagreader_c tagreader_c.c)
+target_link_libraries(tagreader_c tag_c)
 
 ########### next target ###############
 
-ADD_EXECUTABLE(tagwriter tagwriter.cpp)
-
-TARGET_LINK_LIBRARIES(tagwriter  tag )
-
+add_executable(tagwriter tagwriter.cpp)
+target_link_libraries(tagwriter tag)
 
 ########### next target ###############
 
-ADD_EXECUTABLE(framelist framelist.cpp)
-
-TARGET_LINK_LIBRARIES(framelist  tag )
-
+add_executable(framelist framelist.cpp)
+target_link_libraries(framelist tag)
 
 ########### next target ###############
 
-ADD_EXECUTABLE(strip-id3v1 strip-id3v1.cpp)
+add_executable(strip-id3v1 strip-id3v1.cpp)
+target_link_libraries(strip-id3v1 tag)
 
-TARGET_LINK_LIBRARIES(strip-id3v1  tag )
-
-
-endif(BUILD_EXAMPLES)
+########### next target ###############
 
+add_executable(inspect inspect.cpp)
+target_link_libraries(inspect tag)

examples/framelist.cpp

@@ -95,7 +95,10 @@ int main(int argc, char *argv[])
       for(APE::ItemListMap::ConstIterator it = ape->itemListMap().begin();
           it != ape->itemListMap().end(); ++it)
       {
-        cout << (*it).first << " - \"" << (*it).second.toString() << "\"" << endl;
+        if((*it).second.type() != APE::Item::Binary)
+          cout << (*it).first << " - \"" << (*it).second.toString() << "\"" << endl;
+        else
+          cout << (*it).first << " - Binary data (" << (*it).second.binaryData().size() << " bytes)" << endl;
       }
     }
     else

examples/inspect.cpp

@@ -0,0 +1,48 @@
+/* Copyright (C) 2012 Lukas Lalinsky <lalinsky@gmail.com>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <iostream>
+#include <stdlib.h>
+
+#include <fileref.h>
+#include <tfile.h>
+
+using namespace std;
+using namespace TagLib;
+
+int main(int argc, char *argv[])
+{
+  // process the command line args
+
+  for(int i = 1; i < argc; i++) {
+
+    cout << "******************** \"" << argv[i] << "\"********************" << endl;
+
+    FileRef f(argv[i]);
+    if(!f.isNull() && f.file()) {
+      cout << f.file()->toString().to8Bit(true) << endl;
+    }
+
+  }
+}

examples/tagreader.cpp

@@ -23,20 +23,16 @@
  */
 
 #include <iostream>
+#include <iomanip>
 #include <stdio.h>
 
 #include <fileref.h>
 #include <tag.h>
+#include <tpicturemap.h>
+#include <tpropertymap.h>
 
 using namespace std;
 
-TagLib::String formatSeconds(int seconds)
-{
-  char secondsString[3];
-  sprintf(secondsString, "%02i", seconds);
-  return secondsString;
-}
-
 int main(int argc, char *argv[])
 {
   for(int i = 1; i < argc; i++) {
@@ -49,14 +45,33 @@ int main(int argc, char *argv[])
 
       TagLib::Tag *tag = f.tag();
 
-      cout << "-- TAG --" << endl;
-      cout << "title   - \"" << tag->title()   << "\"" << endl;
-      cout << "artist  - \"" << tag->artist()  << "\"" << endl;
-      cout << "album   - \"" << tag->album()   << "\"" << endl;
-      cout << "year    - \"" << tag->year()    << "\"" << endl;
-      cout << "comment - \"" << tag->comment() << "\"" << endl;
-      cout << "track   - \"" << tag->track()   << "\"" << endl;
-      cout << "genre   - \"" << tag->genre()   << "\"" << endl;
+      cout << "-- TAG (basic) --" << endl;
+      cout << "title    - \"" << tag->title()    << "\"" << endl;
+      cout << "artist   - \"" << tag->artist()   << "\"" << endl;
+      cout << "album    - \"" << tag->album()    << "\"" << endl;
+      cout << "year     - \"" << tag->year()     << "\"" << endl;
+      cout << "comment  - \"" << tag->comment()  << "\"" << endl;
+      cout << "track    - \"" << tag->track()    << "\"" << endl;
+      cout << "genre    - \"" << tag->genre()    << "\"" << endl;
+      if(!tag->pictures().isEmpty())
+        cout << "pictures -"    << tag->pictures() << endl;
+
+      TagLib::PropertyMap tags = f.file()->properties();
+
+      unsigned int longest = 0;
+      for(TagLib::PropertyMap::ConstIterator i = tags.begin(); i != tags.end(); ++i) {
+        if (i->first.size() > longest) {
+          longest = i->first.size();
+        }
+      }
+
+      cout << "-- TAG (properties) --" << endl;
+      for(TagLib::PropertyMap::ConstIterator i = tags.begin(); i != tags.end(); ++i) {
+        for(TagLib::StringList::ConstIterator j = i->second.begin(); j != i->second.end(); ++j) {
+          cout << left << std::setw(longest) << i->first << " - " << '"' << *j << '"' << endl;
+        }
+      }
+
     }
 
     if(!f.isNull() && f.audioProperties()) {
@@ -70,7 +85,7 @@ int main(int argc, char *argv[])
       cout << "bitrate     - " << properties->bitrate() << endl;
       cout << "sample rate - " << properties->sampleRate() << endl;
       cout << "channels    - " << properties->channels() << endl;
-      cout << "length      - " << minutes << ":" << formatSeconds(seconds) << endl;
+      cout << "length      - " << minutes << ":" << setfill('0') << setw(2) << seconds << endl;
     }
   }
   return 0;

examples/tagwriter.cpp

@@ -22,7 +22,10 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <fstream>
 #include <iostream>
+#include <iomanip>
+#include <sstream>
 #include <string.h>
 
 #include <stdio.h>
@@ -33,7 +36,10 @@
 #include <tlist.h>
 #include <fileref.h>
 #include <tfile.h>
+#include <tpicturemap.h>
+
 #include <tag.h>
+#include <tpropertymap.h>
 
 using namespace std;
 
@@ -65,11 +71,33 @@ void usage()
   cout << "  -g <genre>"   << endl;
   cout << "  -y <year>"    << endl;
   cout << "  -T <track>"   << endl;
+  cout << "  -R <tagname> <tagvalue>"   << endl;
+  cout << "  -I <tagname> <tagvalue>"   << endl;
+  cout << "  -D <tagname>"   << endl;
+  cout << "  -p <picture(jpg only, file between double quotes)>" << endl;
   cout << endl;
 
   exit(1);
 }
 
+void checkForRejectedProperties(const TagLib::PropertyMap &tags)
+{ // stolen from tagreader.cpp
+  if(tags.size() > 0) {
+    unsigned int longest = 0;
+    for(TagLib::PropertyMap::ConstIterator i = tags.begin(); i != tags.end(); ++i) {
+      if(i->first.size() > longest) {
+        longest = i->first.size();
+      }
+    }
+    cout << "-- rejected TAGs (properties) --" << endl;
+    for(TagLib::PropertyMap::ConstIterator i = tags.begin(); i != tags.end(); ++i) {
+      for(TagLib::StringList::ConstIterator j = i->second.begin(); j != i->second.end(); ++j) {
+        cout << left << std::setw(longest) << i->first << " - " << '"' << *j << '"' << endl;
+      }
+    }
+  }
+}
+
 int main(int argc, char *argv[])
 {
   TagLib::List<TagLib::FileRef> fileList;
@@ -87,13 +115,15 @@ int main(int argc, char *argv[])
   if(fileList.isEmpty())
     usage();
 
+  if(argv[argc-1][1] == 'p')
+    argc++;
+
   for(int i = 1; i < argc - 1; i += 2) {
 
     if(isArgument(argv[i]) && i + 1 < argc && !isArgument(argv[i + 1])) {
 
       char field = argv[i][1];
       TagLib::String value = argv[i + 1];
-
       TagLib::List<TagLib::FileRef>::Iterator it;
       for(it = fileList.begin(); it != fileList.end(); ++it) {
 
@@ -121,6 +151,54 @@ int main(int argc, char *argv[])
         case 'T':
           t->setTrack(value.toInt());
           break;
+        case 'R':
+        case 'I':
+          if(i + 2 < argc) {
+            TagLib::PropertyMap map = (*it).file()->properties ();
+            if(field == 'R') {
+              map.replace(value, TagLib::String(argv[i + 2]));
+            }
+            else {
+              map.insert(value, TagLib::String(argv[i + 2]));
+            }
+            ++i;
+            checkForRejectedProperties((*it).file()->setProperties(map));
+          }
+          else {
+            usage();
+          }
+          break;
+        case 'D': {
+          TagLib::PropertyMap map = (*it).file()->properties();
+          map.erase(value);
+          checkForRejectedProperties((*it).file()->setProperties(map));
+          break;
+        }
+        case 'p':
+          {
+            if(!isFile(value.toCString())) {
+              cout << value.toCString() << " not found." << endl;
+              return 1;
+            }
+            ifstream picture;
+            picture.open(value.toCString());
+            stringstream buffer;
+            buffer << picture.rdbuf();
+            picture.close();
+            TagLib::String buf(buffer.str());
+            TagLib::ByteVector data(buf.data(TagLib::String::Latin1));
+            if(!data.find("JFIF")) {
+              cout << value.toCString() << " is not a JPEG." << endl;
+              return 1;
+            }
+            TagLib::Picture pic(data,
+              TagLib::Picture::FrontCover,
+              "image/jpeg",
+              "Added with taglib");
+            TagLib::PictureMap picMap(pic);
+            t->setPictures(picMap);
+          }
+          break;
         default:
           usage();
           break;
@@ -131,7 +209,7 @@ int main(int argc, char *argv[])
       usage();
   }
 
-  TagLib::List<TagLib::FileRef>::Iterator it;
+  TagLib::List<TagLib::FileRef>::ConstIterator it;
   for(it = fileList.begin(); it != fileList.end(); ++it)
     (*it).file()->save();
 

taglib-config.cmake

@@ -35,7 +35,7 @@ do
 	  flags="$flags -I$includedir/taglib"
 	  ;;
     --version)
-	  echo ${TAGLIB_LIB_MAJOR_VERSION}.${TAGLIB_LIB_MINOR_VERSION}.${TAGLIB_LIB_PATCH_VERSION} 
+	  echo ${TAGLIB_LIB_VERSION_STRING}
 	  ;;
     --prefix)
 	  echo $prefix

taglib-config.cmd.cmake

@@ -0,0 +1,35 @@
+@echo off
+goto beginning
+  *
+  * It is what it is, you can do with it as you please.
+  *
+  * Just don't blame me if it teaches your computer to smoke!
+  *
+  *  -Enjoy
+  *  fh :)_~
+  *
+:beginning
+if /i "%1#" == "--libs#"    goto doit
+if /i "%1#" == "--cflags#"  goto doit
+if /i "%1#" == "--version#" goto doit
+if /i "%1#" == "--prefix#"  goto doit
+
+echo "usage: %0 [OPTIONS]"
+echo	[--libs]
+echo	[--cflags]
+echo	[--version]
+echo	[--prefix]
+goto theend
+
+  *
+  * NOTE: Windows does not assume libraries are prefixed with 'lib'.
+  * NOTE: If '-llibtag' is the last element, it is easily appended in the users installation/makefile process
+  *       to allow for static, shared or debug builds.
+  * It would be preferable if the top level CMakeLists.txt provided the library name during config. ??
+:doit
+if /i "%1#" == "--libs#"    echo -L${LIB_INSTALL_DIR} -llibtag
+if /i "%1#" == "--cflags#"  echo -I${INCLUDE_INSTALL_DIR}/taglib
+if /i "%1#" == "--version#" echo ${TAGLIB_LIB_VERSION_STRING}
+if /i "%1#" == "--prefix#"  echo ${CMAKE_INSTALL_PREFIX}
+
+:theend

taglib.pc.cmake

@@ -1,11 +1,11 @@
-prefix=${CMAKE_INSTALL_PREFIX}
-exec_prefix=${CMAKE_INSTALL_PREFIX}
-libdir=${LIB_INSTALL_DIR}
-includedir=${INCLUDE_INSTALL_DIR}
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@LIB_INSTALL_DIR@
+includedir=@INCLUDE_INSTALL_DIR@
 
 Name: TagLib
 Description: Audio meta-data library
 Requires: 
-Version: ${TAGLIB_LIB_MAJOR_VERSION}.${TAGLIB_LIB_MINOR_VERSION}.${TAGLIB_LIB_PATCH_VERSION}
-Libs: -L${LIB_INSTALL_DIR} -ltag
-Cflags: -I${INCLUDE_INSTALL_DIR}/taglib 
+Version: @TAGLIB_LIB_VERSION_STRING@
+Libs: -L${libdir} -ltag
+Cflags: -I${includedir}/taglib

taglib/CMakeLists.txt

@@ -10,6 +10,7 @@ include_directories(
   ${CMAKE_CURRENT_SOURCE_DIR}/mp4
   ${CMAKE_CURRENT_SOURCE_DIR}/ogg/vorbis
   ${CMAKE_CURRENT_SOURCE_DIR}/ogg/speex
+  ${CMAKE_CURRENT_SOURCE_DIR}/ogg/opus
   ${CMAKE_CURRENT_SOURCE_DIR}/mpeg/id3v2
   ${CMAKE_CURRENT_SOURCE_DIR}/mpeg/id3v2/frames
   ${CMAKE_CURRENT_SOURCE_DIR}/mpeg/id3v1
@@ -23,10 +24,17 @@ include_directories(
   ${CMAKE_CURRENT_SOURCE_DIR}/s3m
   ${CMAKE_CURRENT_SOURCE_DIR}/it
   ${CMAKE_CURRENT_SOURCE_DIR}/xm
+  ${CMAKE_CURRENT_SOURCE_DIR}/ebml
+  ${CMAKE_CURRENT_SOURCE_DIR}/ebml/matroska
+  ${CMAKE_CURRENT_SOURCE_DIR}/dsf
+  ${CMAKE_CURRENT_SOURCE_DIR}/dsdiff
+  ${CMAKE_SOURCE_DIR}/3rdparty
 )
 
 if(ZLIB_FOUND)
   include_directories(${ZLIB_INCLUDE_DIR})
+elseif(HAVE_ZLIB_SOURCE)
+  include_directories(${ZLIB_SOURCE})
 endif()
 
 set(tag_HDRS
@@ -34,12 +42,12 @@ set(tag_HDRS
   fileref.h
   audioproperties.h
   taglib_export.h
-  ${CMAKE_BINARY_DIR}/taglib_config.h
   toolkit/taglib.h
   toolkit/tstring.h
   toolkit/tlist.h
   toolkit/tlist.tcc
   toolkit/tstringlist.h
+  toolkit/tstringhandler.h
   toolkit/tbytevector.h
   toolkit/tbytevectorlist.h
   toolkit/tbytevectorstream.h
@@ -48,7 +56,11 @@ set(tag_HDRS
   toolkit/tfilestream.h
   toolkit/tmap.h
   toolkit/tmap.tcc
+  toolkit/tpicture.h
+  toolkit/tpicturemap.h
   toolkit/tpropertymap.h
+  toolkit/trefcounter.h
+  toolkit/tdebuglistener.h
   mpeg/mpegfile.h
   mpeg/mpegproperties.h
   mpeg/mpegheader.h
@@ -64,16 +76,21 @@ set(tag_HDRS
   mpeg/id3v2/id3v2tag.h
   mpeg/id3v2/frames/attachedpictureframe.h
   mpeg/id3v2/frames/commentsframe.h
+  mpeg/id3v2/frames/eventtimingcodesframe.h
   mpeg/id3v2/frames/generalencapsulatedobjectframe.h
   mpeg/id3v2/frames/ownershipframe.h
   mpeg/id3v2/frames/popularimeterframe.h
   mpeg/id3v2/frames/privateframe.h
   mpeg/id3v2/frames/relativevolumeframe.h
+  mpeg/id3v2/frames/synchronizedlyricsframe.h
   mpeg/id3v2/frames/textidentificationframe.h
   mpeg/id3v2/frames/uniquefileidentifierframe.h
   mpeg/id3v2/frames/unknownframe.h
   mpeg/id3v2/frames/unsynchronizedlyricsframe.h
   mpeg/id3v2/frames/urllinkframe.h
+  mpeg/id3v2/frames/chapterframe.h
+  mpeg/id3v2/frames/tableofcontentsframe.h
+  mpeg/id3v2/frames/podcastframe.h
   ogg/oggfile.h
   ogg/oggpage.h
   ogg/oggpageheader.h
@@ -83,6 +100,8 @@ set(tag_HDRS
   ogg/flac/oggflacfile.h
   ogg/speex/speexfile.h
   ogg/speex/speexproperties.h
+  ogg/opus/opusfile.h
+  ogg/opus/opusproperties.h
   flac/flacfile.h
   flac/flacpicture.h
   flac/flacproperties.h
@@ -103,6 +122,7 @@ set(tag_HDRS
   riff/aiff/aiffproperties.h
   riff/wav/wavfile.h
   riff/wav/wavproperties.h
+  riff/wav/infotag.h
   asf/asffile.h
   asf/asfproperties.h
   asf/asftag.h
@@ -124,6 +144,17 @@ set(tag_HDRS
   s3m/s3mproperties.h
   xm/xmfile.h
   xm/xmproperties.h
+  ebml/ebmlfile.h
+  ebml/ebmlelement.h
+  ebml/ebmlconstants.h
+  ebml/matroska/ebmlmatroskafile.h
+  ebml/matroska/ebmlmatroskaconstants.h
+  ebml/matroska/ebmlmatroskaaudio.h
+  dsf/dsffile.h
+  dsf/dsfproperties.h
+  dsdiff/dsdifffile.h
+  dsdiff/dsdiffproperties.h
+  dsdiff/dsdiffdiintag.h
 )
 
 set(mpeg_SRCS
@@ -151,16 +182,21 @@ set(id3v2_SRCS
 set(frames_SRCS
   mpeg/id3v2/frames/attachedpictureframe.cpp
   mpeg/id3v2/frames/commentsframe.cpp
+  mpeg/id3v2/frames/eventtimingcodesframe.cpp
   mpeg/id3v2/frames/generalencapsulatedobjectframe.cpp
   mpeg/id3v2/frames/ownershipframe.cpp
   mpeg/id3v2/frames/popularimeterframe.cpp
   mpeg/id3v2/frames/privateframe.cpp
   mpeg/id3v2/frames/relativevolumeframe.cpp
+  mpeg/id3v2/frames/synchronizedlyricsframe.cpp
   mpeg/id3v2/frames/textidentificationframe.cpp
   mpeg/id3v2/frames/uniquefileidentifierframe.cpp
   mpeg/id3v2/frames/unknownframe.cpp
   mpeg/id3v2/frames/unsynchronizedlyricsframe.cpp
   mpeg/id3v2/frames/urllinkframe.cpp
+  mpeg/id3v2/frames/chapterframe.cpp
+  mpeg/id3v2/frames/tableofcontentsframe.cpp
+  mpeg/id3v2/frames/podcastframe.cpp
 )
 
 set(ogg_SRCS
@@ -219,6 +255,11 @@ set(speex_SRCS
   ogg/speex/speexproperties.cpp
 )
 
+set(opus_SRCS
+  ogg/opus/opusfile.cpp
+  ogg/opus/opusproperties.cpp
+)
+
 set(trueaudio_SRCS
   trueaudio/trueaudiofile.cpp
   trueaudio/trueaudioproperties.cpp
@@ -244,6 +285,7 @@ set(aiff_SRCS
 set(wav_SRCS
   riff/wav/wavfile.cpp
   riff/wav/wavproperties.cpp
+  riff/wav/infotag.cpp
 )
 
 set(mod_SRCS
@@ -268,9 +310,32 @@ set(xm_SRCS
   xm/xmproperties.cpp
 )
 
+set(dsf_SRCS
+  dsf/dsffile.cpp
+  dsf/dsfproperties.cpp
+)
+
+set(ebml_SRCS
+  ebml/ebmlfile.cpp
+  ebml/ebmlelement.cpp
+)
+
+set(matroska_SRCS
+  ebml/matroska/ebmlmatroskafile.cpp
+  ebml/matroska/ebmlmatroskaaudio.cpp
+)
+
+set(dsdiff_SRCS
+  dsdiff/dsdifffile.cpp
+  dsdiff/dsdiffproperties.cpp
+  dsdiff/dsdiffdiintag.cpp
+)
+
 set(toolkit_SRCS
+  toolkit/taglib.cpp
   toolkit/tstring.cpp
   toolkit/tstringlist.cpp
+  toolkit/tstringhandler.cpp
   toolkit/tbytevector.cpp
   toolkit/tbytevectorlist.cpp
   toolkit/tbytevectorstream.cpp
@@ -278,25 +343,43 @@ set(toolkit_SRCS
   toolkit/tfile.cpp
   toolkit/tfilestream.cpp
   toolkit/tdebug.cpp
+  toolkit/tpicture.cpp
+  toolkit/tpicturemap.cpp
   toolkit/tpropertymap.cpp
-  toolkit/unicode.cpp
+  toolkit/trefcounter.cpp
+  toolkit/tdebuglistener.cpp
+  toolkit/tzlib.cpp
 )
 
+if(HAVE_ZLIB_SOURCE)
+  set(zlib_SRCS
+    ${ZLIB_SOURCE}/adler32.c
+    ${ZLIB_SOURCE}/crc32.c
+    ${ZLIB_SOURCE}/inffast.c
+    ${ZLIB_SOURCE}/inflate.c
+    ${ZLIB_SOURCE}/inftrees.c
+    ${ZLIB_SOURCE}/zutil.c
+  )
+endif()
+
 set(tag_LIB_SRCS
   ${mpeg_SRCS} ${id3v1_SRCS} ${id3v2_SRCS} ${frames_SRCS} ${ogg_SRCS}
   ${vorbis_SRCS} ${oggflacs_SRCS} ${mpc_SRCS} ${ape_SRCS} ${toolkit_SRCS} ${flacs_SRCS}
   ${wavpack_SRCS} ${speex_SRCS} ${trueaudio_SRCS} ${riff_SRCS} ${aiff_SRCS} ${wav_SRCS}
-  ${asf_SRCS} ${mp4_SRCS} ${mod_SRCS} ${s3m_SRCS} ${it_SRCS} ${xm_SRCS}
+  ${asf_SRCS} ${mp4_SRCS} ${mod_SRCS} ${s3m_SRCS} ${it_SRCS} ${xm_SRCS} ${opus_SRCS}
+  ${ebml_SRCS} ${matroska_SRCS} ${dsf_SRCS} ${dsdiff_SRCS}
+  ${zlib_SRCS}
   tag.cpp
   tagunion.cpp
   fileref.cpp
   audioproperties.cpp
+  tagutils.cpp
 )
 
 add_library(tag ${tag_LIB_SRCS} ${tag_HDRS})
 
-if(ZLIB_FOUND)
-	target_link_libraries(tag ${ZLIB_LIBRARIES})
+if(HAVE_ZLIB AND NOT HAVE_ZLIB_SOURCE)
+  target_link_libraries(tag ${ZLIB_LIBRARIES})
 endif()
 
 set_target_properties(tag PROPERTIES
@@ -307,15 +390,25 @@ set_target_properties(tag PROPERTIES
   LINK_INTERFACE_LIBRARIES ""
   PUBLIC_HEADER "${tag_HDRS}"
 )
+if(VISIBILITY_HIDDEN)
+	set_target_properties(tag PROPERTIES C_VISIBILITY_PRESET hidden
+	)
+endif()
+
 if(BUILD_FRAMEWORK)
-  set_target_properties(tag PROPERTIES FRAMEWORK TRUE)
+  unset(INSTALL_NAME_DIR)
+  set_target_properties(tag PROPERTIES 
+      FRAMEWORK TRUE
+      MACOSX_RPATH 1
+      VERSION "A"
+      SOVERSION "A"
+      )
 endif()
 
 install(TARGETS tag
-	FRAMEWORK DESTINATION ${FRAMEWORK_INSTALL_DIR}
-	LIBRARY DESTINATION ${LIB_INSTALL_DIR}
-	RUNTIME DESTINATION ${BIN_INSTALL_DIR}
-	ARCHIVE DESTINATION ${LIB_INSTALL_DIR}
-	PUBLIC_HEADER DESTINATION ${INCLUDE_INSTALL_DIR}/taglib
+  FRAMEWORK DESTINATION ${FRAMEWORK_INSTALL_DIR}
+  LIBRARY DESTINATION ${LIB_INSTALL_DIR}
+  RUNTIME DESTINATION ${BIN_INSTALL_DIR}
+  ARCHIVE DESTINATION ${LIB_INSTALL_DIR}
+  PUBLIC_HEADER DESTINATION ${INCLUDE_INSTALL_DIR}/taglib
 )
-

taglib/ape/apefile.cpp

@@ -36,10 +36,12 @@
 #include <tdebug.h>
 #include <tagunion.h>
 #include <id3v1tag.h>
+#include <id3v2header.h>
 #include <tpropertymap.h>
+#include <tagutils.h>
+#include <tsmartptr.h>
 
 #include "apefile.h"
-
 #include "apetag.h"
 #include "apefooter.h"
 
@@ -47,7 +49,7 @@ using namespace TagLib;
 
 namespace
 {
-  enum { ApeAPEIndex, ApeID3v1Index };
+  enum { ApeAPEIndex = 0, ApeID3v1Index = 1 };
 }
 
 class APE::File::FilePrivate
@@ -57,47 +59,53 @@ public:
     APELocation(-1),
     APESize(0),
     ID3v1Location(-1),
-    properties(0),
-    hasAPE(false),
-    hasID3v1(false) {}
+    ID3v2Location(-1),
+    ID3v2Size(0) {}
 
-  ~FilePrivate()
-  {
-    delete properties;
-  }
+  long long APELocation;
+  long long APESize;
 
-  long APELocation;
-  uint APESize;
+  long long ID3v1Location;
 
-  long ID3v1Location;
+  SCOPED_PTR<ID3v2::Header> ID3v2Header;
+  long long ID3v2Location;
+  long long ID3v2Size;
 
-  TagUnion tag;
+  DoubleTagUnion tag;
 
-  Properties *properties;
-
-  // These indicate whether the file *on disk* has these tags, not if
-  // this data structure does.  This is used in computing offsets.
-
-  bool hasAPE;
-  bool hasID3v1;
+  SCOPED_PTR<AudioProperties> properties;
 };
 
+////////////////////////////////////////////////////////////////////////////////
+// static members
+////////////////////////////////////////////////////////////////////////////////
+
+bool APE::File::isSupported(IOStream *stream)
+{
+  // An APE file has an ID "MAC " somewhere. An ID3v2 tag may precede.
+
+  const ByteVector buffer = Utils::readHeader(stream, bufferSize(), true);
+  return (buffer.find("MAC ") != ByteVector::npos());
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-APE::File::File(FileName file, bool readProperties,
-                Properties::ReadStyle propertiesStyle) : TagLib::File(file)
+APE::File::File(FileName file, bool readProperties, AudioProperties::ReadStyle) :
+  TagLib::File(file),
+  d(new FilePrivate())
 {
-  d = new FilePrivate;
-  read(readProperties, propertiesStyle);
+  if(isOpen())
+    read(readProperties);
 }
 
-APE::File::File(IOStream *stream, bool readProperties,
-                Properties::ReadStyle propertiesStyle) : TagLib::File(stream)
+APE::File::File(IOStream *stream, bool readProperties, AudioProperties::ReadStyle) :
+  TagLib::File(stream),
+  d(new FilePrivate())
 {
-  d = new FilePrivate;
-  read(readProperties, propertiesStyle);
+  if(isOpen())
+    read(readProperties);
 }
 
 APE::File::~File()
@@ -110,36 +118,17 @@ TagLib::Tag *APE::File::tag() const
   return &d->tag;
 }
 
-PropertyMap APE::File::properties() const
-{
-  if(d->hasAPE)
-    return d->tag.access<APE::Tag>(ApeAPEIndex, false)->properties();
-  if(d->hasID3v1)
-    return d->tag.access<ID3v1::Tag>(ApeID3v1Index, false)->properties();
-  return PropertyMap();
-}
-
-void APE::File::removeUnsupportedProperties(const StringList &properties)
-{
-  if(d->hasAPE)
-    d->tag.access<APE::Tag>(ApeAPEIndex, false)->removeUnsupportedProperties(properties);
-  if(d->hasID3v1)
-    d->tag.access<ID3v1::Tag>(ApeID3v1Index, false)->removeUnsupportedProperties(properties);
-}
-
 PropertyMap APE::File::setProperties(const PropertyMap &properties)
 {
-  if(d->hasAPE)
-    return d->tag.access<APE::Tag>(ApeAPEIndex, false)->setProperties(properties);
-  else if(d->hasID3v1)
-    return d->tag.access<ID3v1::Tag>(ApeID3v1Index, false)->setProperties(properties);
-  else
-    return d->tag.access<APE::Tag>(ApeAPEIndex, true)->setProperties(properties);
+  if(ID3v1Tag())
+    ID3v1Tag()->setProperties(properties);
+
+  return APETag(true)->setProperties(properties);
 }
 
-APE::Properties *APE::File::audioProperties() const
+APE::AudioProperties *APE::File::audioProperties() const
 {
-  return d->properties;
+  return d->properties.get();
 }
 
 bool APE::File::save()
@@ -151,64 +140,67 @@ bool APE::File::save()
 
   // Update ID3v1 tag
 
-  if(ID3v1Tag()) {
-    if(d->hasID3v1) {
+  if(ID3v1Tag() && !ID3v1Tag()->isEmpty()) {
+
+    // ID3v1 tag is not empty. Update the old one or create a new one.
+
+    if(d->ID3v1Location >= 0) {
       seek(d->ID3v1Location);
-      writeBlock(ID3v1Tag()->render());
     }
     else {
       seek(0, End);
       d->ID3v1Location = tell();
-      writeBlock(ID3v1Tag()->render());
-      d->hasID3v1 = true;
     }
+
+    writeBlock(ID3v1Tag()->render());
   }
   else {
-    if(d->hasID3v1) {
-      removeBlock(d->ID3v1Location, 128);
-      d->hasID3v1 = false;
-      if(d->hasAPE) {
-        if(d->APELocation > d->ID3v1Location)
-          d->APELocation -= 128;
-      }
+
+    // ID3v1 tag is empty. Remove the old one.
+
+    if(d->ID3v1Location >= 0) {
+      truncate(d->ID3v1Location);
+      d->ID3v1Location = -1;
     }
   }
 
   // Update APE tag
 
-  if(APETag()) {
-    if(d->hasAPE)
-      insert(APETag()->render(), d->APELocation, d->APESize);
-    else {
-      if(d->hasID3v1)  {
-        insert(APETag()->render(), d->ID3v1Location, 0);
-        d->APESize = APETag()->footer()->completeTagSize();
-        d->hasAPE = true;
+  if(APETag() && !APETag()->isEmpty()) {
+
+    // APE tag is not empty. Update the old one or create a new one.
+
+    if(d->APELocation < 0) {
+      if(d->ID3v1Location >= 0)
         d->APELocation = d->ID3v1Location;
-        d->ID3v1Location += d->APESize;
-      }
-      else {
-        seek(0, End);
-        d->APELocation = tell();
-        writeBlock(APETag()->render());
-        d->APESize = APETag()->footer()->completeTagSize();
-        d->hasAPE = true;
-      }
+      else
+        d->APELocation = length();
     }
+
+    const ByteVector data = APETag()->render();
+    insert(data, d->APELocation, static_cast<size_t>(d->APESize));
+
+    if(d->ID3v1Location >= 0)
+      d->ID3v1Location += (static_cast<long>(data.size()) - d->APESize);
+
+    d->APESize = data.size();
   }
   else {
-    if(d->hasAPE) {
-      removeBlock(d->APELocation, d->APESize);
-      d->hasAPE = false;
-      if(d->hasID3v1) {
-        if(d->ID3v1Location > d->APELocation) {
-          d->ID3v1Location -= d->APESize;
-        }
-      }
+
+    // APE tag is empty. Remove the old one.
+
+    if(d->APELocation >= 0) {
+      removeBlock(d->APELocation, static_cast<size_t>(d->APESize));
+
+      if(d->ID3v1Location >= 0)
+        d->ID3v1Location -= d->APESize;
+
+      d->APELocation = -1;
+      d->APESize = 0;
     }
   }
 
-   return true;
+  return true;
 }
 
 ID3v1::Tag *APE::File::ID3v1Tag(bool create)
@@ -223,83 +215,83 @@ APE::Tag *APE::File::APETag(bool create)
 
 void APE::File::strip(int tags)
 {
-  if(tags & ID3v1) {
+  if(tags & ID3v1)
     d->tag.set(ApeID3v1Index, 0);
-    APETag(true);
-  }
 
-  if(tags & APE) {
+  if(tags & APE)
     d->tag.set(ApeAPEIndex, 0);
 
-    if(!ID3v1Tag())
-      APETag(true);
-  }
+  if(!ID3v1Tag())
+    APETag(true);
+}
+
+bool APE::File::hasAPETag() const
+{
+  return (d->APELocation >= 0);
+}
+
+bool APE::File::hasID3v1Tag() const
+{
+  return (d->ID3v1Location >= 0);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
-void APE::File::read(bool readProperties, Properties::ReadStyle /* propertiesStyle */)
+void APE::File::read(bool readProperties)
 {
+  // Look for an ID3v2 tag
+
+  d->ID3v2Location = Utils::findID3v2(this);
+
+  if(d->ID3v2Location >= 0) {
+    seek(d->ID3v2Location);
+    d->ID3v2Header.reset(new ID3v2::Header(readBlock(ID3v2::Header::size())));
+    d->ID3v2Size = d->ID3v2Header->completeTagSize();
+  }
+
   // Look for an ID3v1 tag
 
-  d->ID3v1Location = findID3v1();
+  d->ID3v1Location = Utils::findID3v1(this);
 
-  if(d->ID3v1Location >= 0) {
+  if(d->ID3v1Location >= 0)
     d->tag.set(ApeID3v1Index, new ID3v1::Tag(this, d->ID3v1Location));
-    d->hasID3v1 = true;
-  }
 
   // Look for an APE tag
 
-  d->APELocation = findAPE();
+  d->APELocation = Utils::findAPE(this, d->ID3v1Location);
 
   if(d->APELocation >= 0) {
     d->tag.set(ApeAPEIndex, new APE::Tag(this, d->APELocation));
     d->APESize = APETag()->footer()->completeTagSize();
-    d->APELocation = d->APELocation + APETag()->footer()->size() - d->APESize;
-    d->hasAPE = true;
+    d->APELocation = d->APELocation + APE::Footer::size() - d->APESize;
   }
 
-  if(!d->hasID3v1)
+  if(d->ID3v1Location < 0)
     APETag(true);
 
   // Look for APE audio properties
 
   if(readProperties) {
-    d->properties = new Properties(this);
+
+    long long streamLength;
+
+    if(d->APELocation >= 0)
+      streamLength = d->APELocation;
+    else if(d->ID3v1Location >= 0)
+      streamLength = d->ID3v1Location;
+    else
+      streamLength = length();
+
+    if(d->ID3v2Location >= 0) {
+      seek(d->ID3v2Location + d->ID3v2Size);
+      streamLength -= (d->ID3v2Location + d->ID3v2Size);
+    }
+    else {
+      seek(0);
+    }
+
+    d->properties.reset(new AudioProperties(this, streamLength));
   }
 }
-
-long APE::File::findAPE()
-{
-  if(!isValid())
-    return -1;
-
-  if(d->hasID3v1)
-    seek(-160, End);
-  else
-    seek(-32, End);
-
-  long p = tell();
-
-  if(readBlock(8) == APE::Tag::fileIdentifier())
-    return p;
-
-  return -1;
-}
-
-long APE::File::findID3v1()
-{
-  if(!isValid())
-    return -1;
-
-  seek(-128, End);
-  long p = tell();
-
-  if(readBlock(3) == ID3v1::Tag::fileIdentifier())
-    return p;
-
-  return -1;
-}

taglib/ape/apefile.h

@@ -59,7 +59,7 @@ namespace TagLib {
     //! An implementation of TagLib::File with APE specific methods
 
     /*!
-     * This implements and provides an interface APE WavPack files to the
+     * This implements and provides an interface for APE files to the
      * TagLib::Tag and TagLib::AudioProperties interfaces by way of implementing
      * the abstract TagLib::File API as well as providing some additional
      * information specific to APE files.
@@ -84,23 +84,25 @@ namespace TagLib {
       };
 
       /*!
-       * Contructs an WavPack file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
+       * Constructs an APE file from \a file.  If \a readProperties is true the
+       * file's audio properties will also be read.
+       *
+       * \note In the current implementation, \a propertiesStyle is ignored.
        */
       File(FileName file, bool readProperties = true,
-           Properties::ReadStyle propertiesStyle = Properties::Average);
+           AudioProperties::ReadStyle propertiesStyle = AudioProperties::Average);
 
       /*!
-       * Contructs an WavPack file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
+       * Constructs an APE file from \a stream.  If \a readProperties is true the
+       * file's audio properties will also be read.
        *
        * \note TagLib will *not* take ownership of the stream, the caller is
        * responsible for deleting it after the File object.
+       *
+       * \note In the current implementation, \a propertiesStyle is ignored.
        */
       File(IOStream *stream, bool readProperties = true,
-           Properties::ReadStyle propertiesStyle = Properties::Average);
+           AudioProperties::ReadStyle propertiesStyle = AudioProperties::Average);
 
       /*!
        * Destroys this instance of the File.
@@ -113,30 +115,18 @@ namespace TagLib {
        */
       virtual TagLib::Tag *tag() const;
 
-      /*!
-       * Implements the unified property interface -- export function.
-       * If the file contains both an APE and an ID3v1 tag, only APE
-       * will be converted to the PropertyMap.
-       */
-      PropertyMap properties() const;
-
-      /*!
-       * Removes unsupported properties. Forwards to the actual Tag's
-       * removeUnsupportedProperties() function.
-       */
-      void removeUnsupportedProperties(const StringList &properties);
-
       /*!
        * Implements the unified property interface -- import function.
-       * As for the export, only one tag is taken into account. If the file
-       * has no tag at all, APE will be created.
+       * Creates an APEv2 tag if necessary. A potentially existing ID3v1
+       * tag will be updated as well.
        */
-      PropertyMap setProperties(const PropertyMap &);
+      virtual PropertyMap setProperties(const PropertyMap &);
+
       /*!
        * Returns the APE::Properties for this file.  If no audio properties
        * were read then this will return a null pointer.
        */
-      virtual Properties *audioProperties() const;
+      virtual AudioProperties *audioProperties() const;
 
       /*!
        * Saves the file.
@@ -149,27 +139,38 @@ namespace TagLib {
       /*!
        * Returns a pointer to the ID3v1 tag of the file.
        *
-       * If \a create is false (the default) this will return a null pointer
+       * If \a create is false (the default) this may return a null pointer
        * if there is no valid ID3v1 tag.  If \a create is true it will create
-       * an ID3v1 tag if one does not exist. If there is already an APE tag, the
-       * new ID3v1 tag will be placed after it.
+       * an ID3v1 tag if one does not exist and returns a valid pointer.
        *
-       * \note The Tag <b>is still</b> owned by the APE::File and should not be
+       * \note This may return a valid pointer regardless of whether or not the
+       * file on disk has an ID3v1 tag.  Use hasID3v1Tag() to check if the file
+       * on disk actually has an ID3v1 tag.
+       *
+       * \note The Tag <b>is still</b> owned by the MPEG::File and should not be
        * deleted by the user.  It will be deleted when the file (object) is
        * destroyed.
+       *
+       * \see hasID3v1Tag()
        */
       ID3v1::Tag *ID3v1Tag(bool create = false);
 
       /*!
        * Returns a pointer to the APE tag of the file.
        *
-       * If \a create is false (the default) this will return a null pointer
+       * If \a create is false (the default) this may return a null pointer
        * if there is no valid APE tag.  If \a create is true it will create
-       * a APE tag if one does not exist.
+       * an APE tag if one does not exist and returns a valid pointer.
        *
-       * \note The Tag <b>is still</b> owned by the APE::File and should not be
+       * \note This may return a valid pointer regardless of whether or not the
+       * file on disk has an APE tag.  Use hasAPETag() to check if the file
+       * on disk actually has an APE tag.
+       *
+       * \note The Tag <b>is still</b> owned by the MPEG::File and should not be
        * deleted by the user.  It will be deleted when the file (object) is
        * destroyed.
+       *
+       * \see hasAPETag()
        */
       APE::Tag *APETag(bool create = false);
 
@@ -183,14 +184,34 @@ namespace TagLib {
        */
       void strip(int tags = AllTags);
 
+      /*!
+       * Returns whether or not the file on disk actually has an APE tag.
+       *
+       * \see APETag()
+       */
+      bool hasAPETag() const;
+
+      /*!
+       * Returns whether or not the file on disk actually has an ID3v1 tag.
+       *
+       * \see ID3v1Tag()
+       */
+      bool hasID3v1Tag() const;
+
+      /*!
+       * Returns whether or not the given \a stream can be opened as an APE
+       * file.
+       *
+       * \note This method is designed to do a quick check.  The result may
+       * not necessarily be correct.
+       */
+      static bool isSupported(IOStream *stream);
+
     private:
       File(const File &);
       File &operator=(const File &);
 
-      void read(bool readProperties, Properties::ReadStyle propertiesStyle);
-      void scan();
-      long findID3v1();
-      long findAPE();
+      void read(bool readProperties);
 
       class FilePrivate;
       FilePrivate *d;

taglib/ape/apefooter.cpp

@@ -38,54 +38,51 @@ using namespace APE;
 class APE::Footer::FooterPrivate
 {
 public:
-  FooterPrivate() : version(0),
-                    footerPresent(true),
-                    headerPresent(false),
-                    isHeader(false),
-                    itemCount(0),
-                    tagSize(0) {}
+  FooterPrivate() :
+    version(0),
+    footerPresent(true),
+    headerPresent(false),
+    isHeader(false),
+    itemCount(0),
+    tagSize(0) {}
 
-  ~FooterPrivate() {}
-
-  uint version;
+  unsigned int version;
 
   bool footerPresent;
   bool headerPresent;
 
   bool isHeader;
 
-  uint itemCount;
-  uint tagSize;
-
-  static const uint size = 32;
+  unsigned int itemCount;
+  unsigned int tagSize;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // static members
 ////////////////////////////////////////////////////////////////////////////////
 
-TagLib::uint APE::Footer::size()
+unsigned int APE::Footer::size()
 {
-  return FooterPrivate::size;
+  return 32;
 }
 
 ByteVector APE::Footer::fileIdentifier()
 {
-  return ByteVector::fromCString("APETAGEX");
+  return ByteVector("APETAGEX");
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-APE::Footer::Footer()
+APE::Footer::Footer() :
+  d(new FooterPrivate())
 {
-  d = new FooterPrivate;
 }
 
-APE::Footer::Footer(const ByteVector &data)
+APE::Footer::Footer(const ByteVector &data) :
+  d(new FooterPrivate())
 {
-  d = new FooterPrivate;
   parse(data);
 }
 
@@ -94,7 +91,7 @@ APE::Footer::~Footer()
   delete d;
 }
 
-TagLib::uint APE::Footer::version() const
+unsigned int APE::Footer::version() const
 {
   return d->version;
 }
@@ -119,30 +116,30 @@ void APE::Footer::setHeaderPresent(bool b) const
   d->headerPresent = b;
 }
 
-TagLib::uint APE::Footer::itemCount() const
+unsigned int APE::Footer::itemCount() const
 {
   return d->itemCount;
 }
 
-void APE::Footer::setItemCount(uint s)
+void APE::Footer::setItemCount(unsigned int s)
 {
   d->itemCount = s;
 }
 
-TagLib::uint APE::Footer::tagSize() const
+unsigned int APE::Footer::tagSize() const
 {
   return d->tagSize;
 }
 
-TagLib::uint APE::Footer::completeTagSize() const
+unsigned int APE::Footer::completeTagSize() const
 {
   if(d->headerPresent)
-    return d->tagSize + d->size;
+    return d->tagSize + size();
   else
     return d->tagSize;
 }
 
-void APE::Footer::setTagSize(uint s)
+void APE::Footer::setTagSize(unsigned int s)
 {
   d->tagSize = s;
 }
@@ -154,13 +151,14 @@ void APE::Footer::setData(const ByteVector &data)
 
 ByteVector APE::Footer::renderFooter() const
 {
-    return render(false);
+  return render(false);
 }
 
 ByteVector APE::Footer::renderHeader() const
 {
-    if (!d->headerPresent) return ByteVector();
-
+  if(!d->headerPresent)
+    return ByteVector();
+  else
     return render(true);
 }
 
@@ -177,19 +175,19 @@ void APE::Footer::parse(const ByteVector &data)
 
   // Read the version number
 
-  d->version = data.mid(8, 4).toUInt(false);
+  d->version = data.toUInt32LE(8);
 
   // Read the tag size
 
-  d->tagSize = data.mid(12, 4).toUInt(false);
+  d->tagSize = data.toUInt32LE(12);
 
   // Read the item count
 
-  d->itemCount = data.mid(16, 4).toUInt(false);
+  d->itemCount = data.toUInt32LE(16);
 
   // Read the flags
 
-  std::bitset<32> flags(TAGLIB_CONSTRUCT_BITSET(data.mid(20, 4).toUInt(false)));
+  std::bitset<32> flags(TAGLIB_CONSTRUCT_BITSET(data.toUInt32LE(20)));
 
   d->headerPresent = flags[31];
   d->footerPresent = !flags[30];
@@ -208,15 +206,15 @@ ByteVector APE::Footer::render(bool isHeader) const
   // add the version number -- we always render a 2.000 tag regardless of what
   // the tag originally was.
 
-  v.append(ByteVector::fromUInt(2000, false));
+  v.append(ByteVector::fromUInt32LE(2000));
 
   // add the tag size
 
-  v.append(ByteVector::fromUInt(d->tagSize, false));
+  v.append(ByteVector::fromUInt32LE(d->tagSize));
 
   // add the item count
 
-  v.append(ByteVector::fromUInt(d->itemCount, false));
+  v.append(ByteVector::fromUInt32LE(d->itemCount));
 
   // render and add the flags
 
@@ -226,11 +224,11 @@ ByteVector APE::Footer::render(bool isHeader) const
   flags[30] = false; // footer is always present
   flags[29] = isHeader;
 
-  v.append(ByteVector::fromUInt(flags.to_ulong(), false));
+  v.append(ByteVector::fromUInt32LE(flags.to_ulong()));
 
   // add the reserved 64bit
 
-  v.append(ByteVector::fromLongLong(0));
+  v.append(ByteVector::fromUInt64BE(0));
 
   return v;
 }

taglib/ape/apefooter.h

@@ -37,7 +37,7 @@ namespace TagLib {
 
     /*!
      * This class implements APE footers (and headers). It attempts to follow, both
-     * semantically and programatically, the structure specified in
+     * semantically and programmatically, the structure specified in
      * the APE v2.0 standard.  The API is based on the properties of APE footer and
      * headers specified there.
      */
@@ -54,7 +54,7 @@ namespace TagLib {
        * Constructs an APE footer based on \a data.  parse() is called
        * immediately.
        */
-      Footer(const ByteVector &data);
+      explicit Footer(const ByteVector &data);
 
       /*!
        * Destroys the footer.
@@ -64,7 +64,7 @@ namespace TagLib {
       /*!
        * Returns the version number.  (Note: This is the 1000 or 2000.)
        */
-      uint version() const;
+      unsigned int version() const;
 
       /*!
        * Returns true if a header is present in the tag.
@@ -89,13 +89,13 @@ namespace TagLib {
       /*!
        * Returns the number of items in the tag.
        */
-      uint itemCount() const;
+      unsigned int itemCount() const;
 
       /*!
        * Set the item count to \a s.
        * \see itemCount()
        */
-      void setItemCount(uint s);
+      void setItemCount(unsigned int s);
 
       /*!
        * Returns the tag size in bytes.  This is the size of the frame content and footer.
@@ -103,7 +103,7 @@ namespace TagLib {
        *
        * \see completeTagSize()
        */
-      uint tagSize() const;
+      unsigned int tagSize() const;
 
       /*!
        * Returns the tag size, including if present, the header
@@ -111,18 +111,18 @@ namespace TagLib {
        *
        * \see tagSize()
        */
-      uint completeTagSize() const;
+      unsigned int completeTagSize() const;
 
       /*!
        * Set the tag size to \a s.
        * \see tagSize()
        */
-      void setTagSize(uint s);
+      void setTagSize(unsigned int s);
 
       /*!
        * Returns the size of the footer.  Presently this is always 32 bytes.
        */
-      static uint size();
+      static unsigned int size();
 
       /*!
        * Returns the string used to identify an APE tag inside of a file.

taglib/ape/apeitem.cpp

@@ -25,16 +25,18 @@
 
 #include <tbytevectorlist.h>
 #include <tdebug.h>
+#include <tsmartptr.h>
 
 #include "apeitem.h"
 
 using namespace TagLib;
 using namespace APE;
 
-class APE::Item::ItemPrivate
+struct ItemData
 {
-public:
-  ItemPrivate() : type(Text), readOnly(false) {}
+  ItemData() :
+    type(Item::Text),
+    readOnly(false) {}
 
   Item::ItemTypes type;
   String key;
@@ -43,40 +45,54 @@ public:
   bool readOnly;
 };
 
-APE::Item::Item()
+class APE::Item::ItemPrivate
+{
+public:
+  ItemPrivate() :
+    data(new ItemData()) {}
+
+  SHARED_PTR<ItemData> data;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// public members
+////////////////////////////////////////////////////////////////////////////////
+
+APE::Item::Item() :
+  d(new ItemPrivate())
 {
-  d = new ItemPrivate;
 }
 
-APE::Item::Item(const String &key, const String &value)
+APE::Item::Item(const String &key, const String &value) :
+  d(new ItemPrivate())
 {
-  d = new ItemPrivate;
-  d->key = key;
-  d->text.append(value);
+  d->data->key = key;
+  d->data->text.append(value);
 }
 
-APE::Item::Item(const String &key, const StringList &values)
+APE::Item::Item(const String &key, const StringList &values) :
+  d(new ItemPrivate())
 {
-  d = new ItemPrivate;
-  d->key = key;
-  d->text = values;
+  d->data->key = key;
+  d->data->text = values;
 }
 
-APE::Item::Item(const String &key, const ByteVector &value, bool binary)
+APE::Item::Item(const String &key, const ByteVector &value, bool binary) :
+  d(new ItemPrivate())
 {
-  d = new ItemPrivate;
-  d->key = key;
+  d->data->key = key;
   if(binary) {
-    d->type = Binary;
-    d->value = value;
+    d->data->type = Binary;
+    d->data->value = value;
+  }
+  else {
+    d->data->text.append(value);
   }
-  else
-    d->text.append(value);
 }
 
-APE::Item::Item(const Item &item)
+APE::Item::Item(const Item &item) :
+  d(new ItemPrivate(*item.d))
 {
-  d = new ItemPrivate(*item.d);
 }
 
 APE::Item::~Item()
@@ -86,135 +102,135 @@ APE::Item::~Item()
 
 Item &APE::Item::operator=(const Item &item)
 {
-  delete d;
-  d = new ItemPrivate(*item.d);
+  Item(item).swap(*this);
   return *this;
 }
 
+void APE::Item::swap(Item &item)
+{
+  using std::swap;
+
+  swap(d, item.d);
+}
+
 void APE::Item::setReadOnly(bool readOnly)
 {
-  d->readOnly = readOnly;
+  d->data->readOnly = readOnly;
 }
 
 bool APE::Item::isReadOnly() const
 {
-  return d->readOnly;
+  return d->data->readOnly;
 }
 
 void APE::Item::setType(APE::Item::ItemTypes val)
 {
-  d->type = val;
+  d->data->type = val;
 }
 
 APE::Item::ItemTypes APE::Item::type() const
 {
-  return d->type;
+  return d->data->type;
 }
 
 String APE::Item::key() const
 {
-  return d->key;
+  return d->data->key;
 }
 
 ByteVector APE::Item::binaryData() const
 {
-  return d->value;
+  return d->data->value;
 }
 
 void APE::Item::setBinaryData(const ByteVector &value)
 {
-  d->type = Binary;
-  d->value = value;
-}
-
-ByteVector APE::Item::value() const
-{
-  // This seems incorrect as it won't be actually rendering the value to keep it
-  // up to date.
-
-  return d->value;
+  d->data->type = Binary;
+  d->data->value = value;
+  d->data->text.clear();
 }
 
 void APE::Item::setKey(const String &key)
 {
-    d->key = key;
+  d->data->key = key;
 }
 
 void APE::Item::setValue(const String &value)
 {
-    d->type = Text;
-    d->text = value;
+  d->data->type = Text;
+  d->data->text = value;
+  d->data->value.clear();
 }
 
 void APE::Item::setValues(const StringList &value)
 {
-    d->type = Text;
-    d->text = value;
+  d->data->type = Text;
+  d->data->text = value;
+  d->data->value.clear();
 }
 
 void APE::Item::appendValue(const String &value)
 {
-    d->type = Text;
-    d->text.append(value);
+  d->data->type = Text;
+  d->data->text.append(value);
+  d->data->value.clear();
 }
 
 void APE::Item::appendValues(const StringList &values)
 {
-    d->type = Text;
-    d->text.append(values);
+  d->data->type = Text;
+  d->data->text.append(values);
+  d->data->value.clear();
 }
 
 int APE::Item::size() const
 {
-  // SFB: Why is d->key.size() used when size() returns the length in UniChars and not UTF-8?
-  int result = 8 + d->key.size() /* d->key.data(String::UTF8).size() */ + 1;
-  switch (d->type) {
+  size_t result = 8 + d->data->key.size() + 1;
+  switch(d->data->type) {
     case Text:
-      if(d->text.size()) {
-        StringList::ConstIterator it = d->text.begin();
+      if(!d->data->text.isEmpty()) {
+        StringList::ConstIterator it = d->data->text.begin();
 
         result += it->data(String::UTF8).size();
         it++;
-        for(; it != d->text.end(); ++it)
+        for(; it != d->data->text.end(); ++it)
           result += 1 + it->data(String::UTF8).size();
       }
       break;
 
     case Binary:
     case Locator:
-      result += d->value.size();
+      result += d->data->value.size();
       break;
   }
-  return result;
-}
-
-StringList APE::Item::toStringList() const
-{
-  return d->text;
+  return static_cast<int>(result);
 }
 
 StringList APE::Item::values() const
 {
-  return d->text;
+  return d->data->text;
 }
 
 String APE::Item::toString() const
 {
-  return isEmpty() ? String::null : d->text.front();
+  if(d->data->type == Text && !isEmpty())
+    return d->data->text.front();
+  else
+    return String();
 }
 
 bool APE::Item::isEmpty() const
 {
-  switch(d->type) {
+  switch(d->data->type) {
     case Text:
-      if(d->text.isEmpty())
+      if(d->data->text.isEmpty())
         return true;
-      if(d->text.size() == 1 && d->text.front().isEmpty())
+      if(d->data->text.size() == 1 && d->data->text.front().isEmpty())
         return true;
       return false;
     case Binary:
     case Locator:
-      return d->value.isEmpty();
+      return d->data->value.isEmpty();
     default:
       return false;
   }
@@ -229,46 +245,51 @@ void APE::Item::parse(const ByteVector &data)
     return;
   }
 
-  uint valueLength  = data.mid(0, 4).toUInt(false);
-  uint flags        = data.mid(4, 4).toUInt(false);
+  const unsigned int valueLength  = data.toUInt32LE(0);
+  const unsigned int flags        = data.toUInt32LE(4);
 
-  d->key = String(data.mid(8), String::UTF8);
+  // An item key can contain ASCII characters from 0x20 up to 0x7E, not UTF-8.
+  // We assume that the validity of the given key has been checked.
 
-  d->value = data.mid(8 + d->key.size() + 1, valueLength);
+  d->data->key = String(&data[8], String::Latin1);
+
+  const ByteVector value = data.mid(8 + d->data->key.size() + 1, valueLength);
 
   setReadOnly(flags & 1);
   setType(ItemTypes((flags >> 1) & 3));
 
-  if(Text == d->type)
-    d->text = StringList(ByteVectorList::split(d->value, '\0'), String::UTF8);
+  if(Text == d->data->type)
+    d->data->text = StringList(ByteVectorList::split(value, '\0'), String::UTF8);
+  else
+    d->data->value = value;
 }
 
 ByteVector APE::Item::render() const
 {
   ByteVector data;
-  TagLib::uint flags = ((d->readOnly) ? 1 : 0) | (d->type << 1);
+  unsigned int flags = ((d->data->readOnly) ? 1 : 0) | (d->data->type << 1);
   ByteVector value;
 
   if(isEmpty())
     return data;
 
-  if(d->type == Text) {
-    StringList::ConstIterator it = d->text.begin();
+  if(d->data->type == Text) {
+    StringList::ConstIterator it = d->data->text.begin();
 
     value.append(it->data(String::UTF8));
     it++;
-    for(; it != d->text.end(); ++it) {
+    for(; it != d->data->text.end(); ++it) {
       value.append('\0');
       value.append(it->data(String::UTF8));
     }
-    d->value = value;
+    d->data->value = value;
   }
   else
-    value.append(d->value);
+    value.append(d->data->value);
 
-  data.append(ByteVector::fromUInt(value.size(), false));
-  data.append(ByteVector::fromUInt(flags, false));
-  data.append(d->key.data(String::UTF8));
+  data.append(ByteVector::fromUInt32LE(value.size()));
+  data.append(ByteVector::fromUInt32LE(flags));
+  data.append(d->data->key.data(String::Latin1));
   data.append(ByteVector('\0'));
   data.append(value);
 

taglib/ape/apeitem.h

@@ -61,7 +61,6 @@ namespace TagLib {
       /*!
        * Constructs a text item with \a key and \a value.
        */
-      // BIC: Remove this, StringList has a constructor from a single string
       Item(const String &key, const String &value);
 
       /*!
@@ -90,6 +89,11 @@ namespace TagLib {
        */
       Item &operator=(const Item &item);
 
+      /*!
+       * Exchanges the content of this item by the content of \a item.
+       */
+      void swap(Item &item);
+
       /*!
        * Returns the key.
        */
@@ -97,7 +101,7 @@ namespace TagLib {
 
       /*!
        * Returns the binary value.
-       * If the item type is not \a Binary, the returned contents are undefined
+       * If the item type is not \a Binary, always returns an empty ByteVector.
        */
       ByteVector binaryData() const;
 
@@ -107,11 +111,6 @@ namespace TagLib {
       */
       void setBinaryData(const ByteVector &value);
 
-#ifndef DO_NOT_DOCUMENT
-      /* Remove in next binary incompatible release */
-      ByteVector value() const;
-#endif
-
       /*!
        * Sets the key for the item to \a key.
        */
@@ -152,18 +151,15 @@ namespace TagLib {
       int size() const;
 
       /*!
-       * Returns the value as a single string. In case of multiple strings,
-       * the first is returned.
+       * Returns the value as a single string.  In case of multiple strings,
+       * the first is returned.  If the data type is not \a Text, always returns
+       * an empty String.
        */
       String toString() const;
 
-#ifndef DO_NOT_DOCUMENT
-      /* Remove in next binary incompatible release */
-      StringList toStringList() const;
-#endif
-
       /*!
-       * Returns the list of text values.
+       * Returns the list of text values.  If the data type is not \a Text, always
+       * returns an empty StringList.
        */
       StringList values() const;
 

taglib/ape/apeproperties.cpp

@@ -29,26 +29,26 @@
 
 #include <tstring.h>
 #include <tdebug.h>
-#include <bitset>
+
 #include "id3v2tag.h"
 #include "apeproperties.h"
 #include "apefile.h"
+#include "apetag.h"
+#include "apefooter.h"
 
 using namespace TagLib;
 
-class APE::Properties::PropertiesPrivate
+class APE::AudioProperties::PropertiesPrivate
 {
 public:
-  PropertiesPrivate(File *file, long streamLength) :
+  PropertiesPrivate() :
     length(0),
     bitrate(0),
     sampleRate(0),
     channels(0),
     version(0),
     bitsPerSample(0),
-    sampleFrames(0),
-    file(file),
-    streamLength(streamLength) {}
+    sampleFrames(0) {}
 
   int length;
   int bitrate;
@@ -56,57 +56,66 @@ public:
   int channels;
   int version;
   int bitsPerSample;
-  uint sampleFrames;
-  File *file;
-  long streamLength;
+  unsigned int sampleFrames;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-APE::Properties::Properties(File *file, ReadStyle style) : AudioProperties(style)
+APE::AudioProperties::AudioProperties(File *file, long long streamLength, ReadStyle) :
+  TagLib::AudioProperties(),
+  d(new PropertiesPrivate())
 {
-  d = new PropertiesPrivate(file, file->length());
-  read();
+  read(file, streamLength);
 }
 
-APE::Properties::~Properties()
+APE::AudioProperties::~AudioProperties()
 {
   delete d;
 }
 
-int APE::Properties::length() const
+int APE::AudioProperties::length() const
+{
+  return lengthInSeconds();
+}
+
+int APE::AudioProperties::lengthInSeconds() const
+{
+  return d->length / 1000;
+}
+
+int APE::AudioProperties::lengthInMilliseconds() const
 {
   return d->length;
 }
 
-int APE::Properties::bitrate() const
+int APE::AudioProperties::bitrate() const
 {
   return d->bitrate;
 }
 
-int APE::Properties::sampleRate() const
+int APE::AudioProperties::sampleRate() const
 {
   return d->sampleRate;
 }
 
-int APE::Properties::channels() const
+int APE::AudioProperties::channels() const
 {
   return d->channels;
 }
 
-int APE::Properties::version() const
+int APE::AudioProperties::version() const
 {
   return d->version;
 }
 
-int APE::Properties::bitsPerSample() const
+int APE::AudioProperties::bitsPerSample() const
 {
   return d->bitsPerSample;
 }
 
-TagLib::uint APE::Properties::sampleFrames() const
+unsigned int APE::AudioProperties::sampleFrames() const
 {
   return d->sampleFrames;
 }
@@ -115,117 +124,122 @@ TagLib::uint APE::Properties::sampleFrames() const
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
-
-void APE::Properties::read()
+namespace
 {
-  // First we are searching the descriptor
-  long offset = findDescriptor();
-  if(offset < 0)
-    return;
+  int headerVersion(const ByteVector &header)
+  {
+    if(header.size() < 6 || !header.startsWith("MAC "))
+      return -1;
 
-  // Then we read the header common for all versions of APE
-  d->file->seek(offset);
-  ByteVector commonHeader=d->file->readBlock(6);
-  if(!commonHeader.startsWith("MAC "))
-    return;
-  d->version = commonHeader.mid(4).toUInt(false);
-
-  if(d->version >= 3980) {
-    analyzeCurrent();
-  }
-  else {
-    analyzeOld();
+    return header.toUInt16LE(4);
   }
 }
 
-long APE::Properties::findDescriptor()
+void APE::AudioProperties::read(File *file, long long streamLength)
 {
-  long ID3v2Location = findID3v2();
-  long ID3v2OriginalSize = 0;
-  bool hasID3v2 = false;
-  if(ID3v2Location >= 0) {
-    ID3v2::Tag tag(d->file, ID3v2Location);
-    ID3v2OriginalSize = tag.header()->completeTagSize();
-    if(tag.header()->tagSize() > 0)
-      hasID3v2 = true;
+  // First, we assume that the file pointer is set at the first descriptor.
+  long long offset = file->tell();
+  int version = headerVersion(file->readBlock(6));
+
+  // Next, we look for the descriptor.
+  if(version < 0) {
+    offset = file->find("MAC ", offset);
+    file->seek(offset);
+    version = headerVersion(file->readBlock(6));
   }
 
-  long offset = 0;
-  if(hasID3v2)
-    offset = d->file->find("MAC ", ID3v2Location + ID3v2OriginalSize);
+  if(version < 0) {
+    debug("APE::AudioProperties::read() -- APE descriptor not found");
+    return;
+  }
+
+  d->version = version;
+
+  if(d->version >= 3980)
+    analyzeCurrent(file);
   else
-    offset = d->file->find("MAC ");
+    analyzeOld(file);
 
-  if(offset < 0) {
-    debug("APE::Properties::findDescriptor() -- APE descriptor not found");
-    return -1;
+  if(d->sampleFrames > 0 && d->sampleRate > 0) {
+    const double length = d->sampleFrames * 1000.0 / d->sampleRate;
+    d->length  = static_cast<int>(length + 0.5);
+    d->bitrate = static_cast<int>(streamLength * 8.0 / length + 0.5);
   }
-
-  return offset;
 }
 
-long APE::Properties::findID3v2()
-{
-  if(!d->file->isValid())
-    return -1;
-
-  d->file->seek(0);
-
-  if(d->file->readBlock(3) == ID3v2::Header::fileIdentifier())
-    return 0;
-
-  return -1;
-}
-
-void APE::Properties::analyzeCurrent()
+void APE::AudioProperties::analyzeCurrent(File *file)
 {
   // Read the descriptor
-  d->file->seek(2, File::Current);
-  ByteVector descriptor = d->file->readBlock(44);
-  uint descriptorBytes = descriptor.mid(0,4).toUInt(false);
+  file->seek(2, File::Current);
+  const ByteVector descriptor = file->readBlock(44);
+  if(descriptor.size() < 44) {
+    debug("APE::AudioProperties::analyzeCurrent() -- descriptor is too short.");
+    return;
+  }
 
-  if ((descriptorBytes - 52) > 0)
-    d->file->seek(descriptorBytes - 52, File::Current);
+  const unsigned int descriptorBytes = descriptor.toUInt32LE(0);
+
+  if((descriptorBytes - 52) > 0)
+    file->seek(descriptorBytes - 52, File::Current);
 
   // Read the header
-  ByteVector header = d->file->readBlock(24);
+  const ByteVector header = file->readBlock(24);
+  if(header.size() < 24) {
+    debug("APE::AudioProperties::analyzeCurrent() -- MAC header is too short.");
+    return;
+  }
 
   // Get the APE info
-  d->channels = header.mid(18, 2).toShort(false);
-  d->sampleRate = header.mid(20, 4).toUInt(false);
-  d->bitsPerSample = header.mid(16, 2).toShort(false);
-  //d->compressionLevel =
+  d->channels      = header.toUInt16LE(18);
+  d->sampleRate    = header.toUInt32LE(20);
+  d->bitsPerSample = header.toUInt16LE(16);
 
-  uint totalFrames = header.mid(12, 4).toUInt(false);
-  uint blocksPerFrame = header.mid(4, 4).toUInt(false);
-  uint finalFrameBlocks = header.mid(8, 4).toUInt(false);
-  d->sampleFrames = totalFrames > 0 ? (totalFrames -  1) * blocksPerFrame + finalFrameBlocks : 0;
-  d->length = d->sampleRate > 0 ? d->sampleFrames / d->sampleRate : 0;
-  d->bitrate = d->length > 0 ? ((d->streamLength * 8L) / d->length) / 1000 : 0;
+  const unsigned int totalFrames = header.toUInt32LE(12);
+  if(totalFrames == 0)
+    return;
+
+  const unsigned int blocksPerFrame   = header.toUInt32LE(4);
+  const unsigned int finalFrameBlocks = header.toUInt32LE(8);
+  d->sampleFrames = (totalFrames - 1) * blocksPerFrame + finalFrameBlocks;
 }
 
-void APE::Properties::analyzeOld()
+void APE::AudioProperties::analyzeOld(File *file)
 {
-  ByteVector header = d->file->readBlock(26);
-  uint totalFrames = header.mid(18, 4).toUInt(false);
+  const ByteVector header = file->readBlock(26);
+  if(header.size() < 26) {
+    debug("APE::AudioProperties::analyzeOld() -- MAC header is too short.");
+    return;
+  }
+
+  const unsigned int totalFrames = header.toUInt32LE(18);
 
   // Fail on 0 length APE files (catches non-finalized APE files)
   if(totalFrames == 0)
     return;
 
-  short compressionLevel = header.mid(0, 2).toShort(false);
-  uint blocksPerFrame;
+  const short compressionLevel = header.toUInt32LE(0);
+  unsigned int blocksPerFrame;
   if(d->version >= 3950)
     blocksPerFrame = 73728 * 4;
   else if(d->version >= 3900 || (d->version >= 3800 && compressionLevel == 4000))
     blocksPerFrame = 73728;
   else
     blocksPerFrame = 9216;
-  d->channels = header.mid(4, 2).toShort(false);
-  d->sampleRate = header.mid(6, 4).toUInt(false);
-  uint finalFrameBlocks = header.mid(22, 4).toUInt(false);
-  uint totalBlocks = totalFrames > 0 ? (totalFrames - 1) * blocksPerFrame + finalFrameBlocks : 0;
-  d->length = totalBlocks / d->sampleRate;
-  d->bitrate = d->length > 0 ? ((d->streamLength * 8L) / d->length) / 1000 : 0;
-}
 
+  // Get the APE info
+  d->channels   = header.toUInt16LE(4);
+  d->sampleRate = header.toUInt32LE(6);
+
+  const unsigned int finalFrameBlocks = header.toUInt32LE(22);
+  d->sampleFrames = (totalFrames - 1) * blocksPerFrame + finalFrameBlocks;
+
+  // Get the bit depth from the RIFF-fmt chunk.
+  file->seek(16, File::Current);
+  const ByteVector fmt = file->readBlock(28);
+  if(fmt.size() < 28 || !fmt.startsWith("WAVEfmt ")) {
+    debug("APE::AudioProperties::analyzeOld() -- fmt header is too short.");
+    return;
+  }
+
+  d->bitsPerSample = fmt.toUInt16LE(26);
+}

taglib/ape/apeproperties.h

@@ -46,32 +46,69 @@ namespace TagLib {
      * API.
      */
 
-    class TAGLIB_EXPORT Properties : public AudioProperties
+    class TAGLIB_EXPORT AudioProperties : public TagLib::AudioProperties
     {
     public:
       /*!
        * Create an instance of APE::Properties with the data read from the
-       * ByteVector \a data.
+       * APE::File \a file.
        */
-      Properties(File *f, ReadStyle style = Average);
+      AudioProperties(File *file, long long streamLength, ReadStyle style = Average);
 
       /*!
-       * Destroys this APE::Properties instance.
+       * Destroys this APE::AudioProperties instance.
        */
-      virtual ~Properties();
-
-      // Reimplementations.
+      virtual ~AudioProperties();
 
+      /*!
+       * Returns the length of the file in seconds.  The length is rounded down to
+       * the nearest whole second.
+       *
+       * \note This method is just an alias of lengthInSeconds().
+       *
+       * \deprecated
+       */
       virtual int length() const;
+
+      /*!
+       * Returns the length of the file in seconds.  The length is rounded down to
+       * the nearest whole second.
+       *
+       * \see lengthInMilliseconds()
+       */
+      virtual int lengthInSeconds() const;
+
+      /*!
+       * Returns the length of the file in milliseconds.
+       *
+       * \see lengthInSeconds()
+       */
+      virtual int lengthInMilliseconds() const;
+
+      /*!
+       * Returns the average bit rate of the file in kb/s.
+       */
       virtual int bitrate() const;
+
+      /*!
+       * Returns the sample rate in Hz.
+       */
       virtual int sampleRate() const;
+
+      /*!
+       * Returns the number of audio channels.
+       */
       virtual int channels() const;
 
       /*!
-       * Returns number of bits per sample.
+       * Returns the number of bits per audio sample.
        */
       int bitsPerSample() const;
-      uint sampleFrames() const;
+
+      /*!
+       * Returns the total number of audio samples in file.
+       */
+      unsigned int sampleFrames() const;
 
       /*!
        * Returns APE version.
@@ -79,16 +116,9 @@ namespace TagLib {
       int version() const;
 
     private:
-      Properties(const Properties &);
-      Properties &operator=(const Properties &);
-
-      void read();
-
-      long findDescriptor();
-      long findID3v2();
-
-      void analyzeCurrent();
-      void analyzeOld();
+      void read(File *file, long long streamLength);
+      void analyzeCurrent(File *file);
+      void analyzeOld(File *file);
 
       class PropertiesPrivate;
       PropertiesPrivate *d;

taglib/ape/apetag.cpp

@@ -23,7 +23,7 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef __SUNPRO_CC
+#if defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x5130)
 // Sun Studio finds multiple specializations of Map because
 // it considers specializations with and without class types
 // to be different; this define forces Map to use only the
@@ -34,7 +34,10 @@
 #include <tfile.h>
 #include <tstring.h>
 #include <tmap.h>
+#include <tpicturemap.h>
 #include <tpropertymap.h>
+#include <tdebug.h>
+#include <tutils.h>
 
 #include "apetag.h"
 #include "apefooter.h"
@@ -43,17 +46,44 @@
 using namespace TagLib;
 using namespace APE;
 
+namespace
+{
+  const unsigned int MinKeyLength = 2;
+  const unsigned int MaxKeyLength = 255;
+
+  bool isKeyValid(const ByteVector &key)
+  {
+    const char *invalidKeys[] = { "ID3", "TAG", "OGGS", "MP+", 0 };
+
+    // only allow printable ASCII including space (32..126)
+
+    for(ByteVector::ConstIterator it = key.begin(); it != key.end(); ++it) {
+      const int c = static_cast<unsigned char>(*it);
+      if(c < 32 || c > 126)
+        return false;
+    }
+
+    const String upperKey = String(key).upper();
+    for(size_t i = 0; invalidKeys[i] != 0; ++i) {
+      if(upperKey == invalidKeys[i])
+        return false;
+    }
+
+    return true;
+  }
+}
+
 class APE::Tag::TagPrivate
 {
 public:
-  TagPrivate() : file(0), footerLocation(-1), tagLength(0) {}
+  TagPrivate() :
+    file(0),
+    footerLocation(0) {}
 
-  TagLib::File *file;
-  long footerLocation;
-  long tagLength;
+  File *file;
+  long long footerLocation;
 
   Footer footer;
-
   ItemListMap itemListMap;
 };
 
@@ -61,14 +91,16 @@ public:
 // public methods
 ////////////////////////////////////////////////////////////////////////////////
 
-APE::Tag::Tag() : TagLib::Tag()
+APE::Tag::Tag() :
+  TagLib::Tag(),
+  d(new TagPrivate())
 {
-  d = new TagPrivate;
 }
 
-APE::Tag::Tag(TagLib::File *file, long footerLocation) : TagLib::Tag()
+APE::Tag::Tag(TagLib::File *file, long long footerLocation) :
+  TagLib::Tag(),
+  d(new TagPrivate())
 {
-  d = new TagPrivate;
   d->file = file;
   d->footerLocation = footerLocation;
 
@@ -88,52 +120,88 @@ ByteVector APE::Tag::fileIdentifier()
 String APE::Tag::title() const
 {
   if(d->itemListMap["TITLE"].isEmpty())
-    return String::null;
-  return d->itemListMap["TITLE"].toString();
+    return String();
+  return d->itemListMap["TITLE"].values().toString();
 }
 
 String APE::Tag::artist() const
 {
   if(d->itemListMap["ARTIST"].isEmpty())
-    return String::null;
-  return d->itemListMap["ARTIST"].toString();
+    return String();
+  return d->itemListMap["ARTIST"].values().toString();
 }
 
 String APE::Tag::album() const
 {
   if(d->itemListMap["ALBUM"].isEmpty())
-    return String::null;
-  return d->itemListMap["ALBUM"].toString();
+    return String();
+  return d->itemListMap["ALBUM"].values().toString();
 }
 
 String APE::Tag::comment() const
 {
   if(d->itemListMap["COMMENT"].isEmpty())
-    return String::null;
-  return d->itemListMap["COMMENT"].toString();
+    return String();
+  return d->itemListMap["COMMENT"].values().toString();
 }
 
 String APE::Tag::genre() const
 {
   if(d->itemListMap["GENRE"].isEmpty())
-    return String::null;
-  return d->itemListMap["GENRE"].toString();
+    return String();
+  return d->itemListMap["GENRE"].values().toString();
 }
 
-TagLib::uint APE::Tag::year() const
+unsigned int APE::Tag::year() const
 {
   if(d->itemListMap["YEAR"].isEmpty())
     return 0;
   return d->itemListMap["YEAR"].toString().toInt();
 }
 
-TagLib::uint APE::Tag::track() const
+unsigned int APE::Tag::track() const
 {
   if(d->itemListMap["TRACK"].isEmpty())
     return 0;
   return d->itemListMap["TRACK"].toString().toInt();
 }
 
+TagLib::PictureMap APE::Tag::pictures() const
+{
+  PictureMap map;
+  if(d->itemListMap.contains(FRONT_COVER)) {
+    Item front = d->itemListMap[FRONT_COVER];
+    if(Item::Binary == front.type()) {
+      ByteVector picture = front.binaryData();
+      const size_t index = picture.find('\0');
+      if(index < picture.size()) {
+        ByteVector desc = picture.mid(0, index + 1);
+        String mime = "image/jpeg";
+        ByteVector data = picture.mid(index + 1);
+        Picture p(data, Picture::FrontCover, mime, desc);
+        map.insert(p);
+      }
+    }
+  }
+
+  if(d->itemListMap.contains(BACK_COVER)) {
+    Item back = d->itemListMap[BACK_COVER];
+    if(Item::Binary == back.type()) {
+      ByteVector picture = back.binaryData();
+      const size_t index = picture.find('\0');
+      if(index < picture.size()) {
+        ByteVector desc = picture.mid(0, index + 1);
+        String mime = "image/jpeg";
+        ByteVector data = picture.mid(index + 1);
+        Picture p(data, Picture::BackCover, mime, desc);
+        map.insert(p);
+      }
+    }
+  }
+
+  return PictureMap(map);
+}
+
 void APE::Tag::setTitle(const String &s)
 {
   addValue("TITLE", s, true);
@@ -159,30 +227,91 @@ void APE::Tag::setGenre(const String &s)
   addValue("GENRE", s, true);
 }
 
-void APE::Tag::setYear(uint i)
+void APE::Tag::setYear(unsigned int i)
 {
-  if(i <= 0)
+  if(i == 0)
     removeItem("YEAR");
   else
     addValue("YEAR", String::number(i), true);
 }
 
-void APE::Tag::setTrack(uint i)
+void APE::Tag::setTrack(unsigned int i)
 {
-  if(i <= 0)
+  if(i == 0)
     removeItem("TRACK");
   else
     addValue("TRACK", String::number(i), true);
 }
 
-// conversions of tag keys between what we use in PropertyMap and what's usual
-// for APE tags
-static const TagLib::uint keyConversionsSize = 5; //usual,         APE
-static const char *keyConversions[][2] =  {{"TRACKNUMBER", "TRACK"       },
-                                           {"DATE",        "YEAR"        },
-                                           {"ALBUMARTIST", "ALBUM ARTIST"},
-                                           {"DISCNUMBER",  "DISC"        },
-                                           {"REMIXER",     "MIXARTIST"   }};
+void APE::Tag::setPictures(const PictureMap &l)
+{
+  removeItem(FRONT_COVER);
+  removeItem(BACK_COVER);
+  for(PictureMap::ConstIterator pictureMapIt = l.begin();
+      pictureMapIt != l.end();
+      ++pictureMapIt) {
+    Picture::Type type = pictureMapIt->first;
+    if(Picture::FrontCover != type && Picture::BackCover != type) {
+      std::cout << "APE: Trying to add a picture with wrong type"
+                << std::endl;
+      continue;
+    }
+
+    const char *id;
+    switch(type) {
+    case Picture::FrontCover:
+      id = FRONT_COVER;
+      break;
+    case Picture::BackCover:
+      id = BACK_COVER;
+      break;
+    default:
+      id = FRONT_COVER;
+      break;
+    }
+
+    PictureList list = pictureMapIt->second;
+    for(PictureList::ConstIterator pictureListIt = list.begin();
+        pictureListIt != list.end();
+        ++pictureListIt) {
+      Picture picture = *pictureListIt;
+      if(d->itemListMap.contains(id)) {
+        std::cout << "APE: Already added a picture of type "
+                  << id
+                  << " '"
+                  << picture.description()
+                  << "' "
+                  << "and next are being ignored"
+                  << std::endl;
+        break;
+      }
+
+      ByteVector data = picture.description().data(String::Latin1)
+                        .append('\0')
+                        .append(picture.data());
+
+      Item item;
+      item.setKey(id);
+      item.setType(Item::Binary);
+      item.setBinaryData(data);
+      setItem(item.key(), item);
+    }
+  }
+
+}
+
+namespace
+{
+  // conversions of tag keys between what we use in PropertyMap and what's usual
+  // for APE tags
+  //                                    usual,         APE
+  const char *keyConversions[][2] =  {{"TRACKNUMBER", "TRACK"       },
+                                      {"DATE",        "YEAR"        },
+                                      {"ALBUMARTIST", "ALBUM ARTIST"},
+                                      {"DISCNUMBER",  "DISC"        },
+                                      {"REMIXER",     "MIXARTIST"   }};
+  const size_t keyConversionsSize = sizeof(keyConversions) / sizeof(keyConversions[0]);
+}
 
 PropertyMap APE::Tag::properties() const
 {
@@ -192,14 +321,16 @@ PropertyMap APE::Tag::properties() const
     String tagName = it->first.upper();
     // if the item is Binary or Locator, or if the key is an invalid string,
     // add to unsupportedData
-    if(it->second.type() != Item::Text || tagName.isNull())
+    if(it->second.type() != Item::Text || tagName.isEmpty()) {
       properties.unsupportedData().append(it->first);
+    }
     else {
       // Some tags need to be handled specially
-      for(uint i = 0; i < keyConversionsSize; ++i)
+      for(size_t i = 0; i < keyConversionsSize; ++i) {
         if(tagName == keyConversions[i][1])
           tagName = keyConversions[i][0];
-        properties[tagName].append(it->second.toStringList());
+      }
+      properties[tagName].append(it->second.values());
     }
   }
   return properties;
@@ -217,7 +348,7 @@ PropertyMap APE::Tag::setProperties(const PropertyMap &origProps)
   PropertyMap properties(origProps); // make a local copy that can be modified
 
   // see comment in properties()
-  for(uint i = 0; i < keyConversionsSize; ++i)
+  for(size_t i = 0; i < keyConversionsSize; ++i)
     if(properties.contains(keyConversions[i][0])) {
       properties.insert(keyConversions[i][1], properties[keyConversions[i][0]]);
       properties.erase(keyConversions[i][0]);
@@ -229,11 +360,11 @@ PropertyMap APE::Tag::setProperties(const PropertyMap &origProps)
   for(; remIt != itemListMap().end(); ++remIt) {
     String key = remIt->first.upper();
     // only remove if a) key is valid, b) type is text, c) key not contained in new properties
-    if(!key.isNull() && remIt->second.type() == APE::Item::Text && !properties.contains(key))
+    if(!key.isEmpty() && remIt->second.type() == APE::Item::Text && !properties.contains(key))
       toRemove.append(remIt->first);
   }
 
-  for (StringList::Iterator removeIt = toRemove.begin(); removeIt != toRemove.end(); removeIt++)
+  for(StringList::ConstIterator removeIt = toRemove.begin(); removeIt != toRemove.end(); removeIt++)
     removeItem(*removeIt);
 
   // now sync in the "forward direction"
@@ -244,7 +375,7 @@ PropertyMap APE::Tag::setProperties(const PropertyMap &origProps)
     if(!checkKey(tagName))
       invalid.insert(it->first, it->second);
     else if(!(itemListMap().contains(tagName)) || !(itemListMap()[tagName].values() == it->second)) {
-      if(it->second.size() == 0)
+      if(it->second.isEmpty())
         removeItem(tagName);
       else {
         StringList::ConstIterator valueIt = it->second.begin();
@@ -260,16 +391,10 @@ PropertyMap APE::Tag::setProperties(const PropertyMap &origProps)
 
 bool APE::Tag::checkKey(const String &key)
 {
-  if(key.size() < 2 || key.size() > 16)
-      return false;
-    for(String::ConstIterator it = key.begin(); it != key.end(); it++)
-        // only allow printable ASCII including space (32..127)
-        if (*it < 32 || *it >= 128)
-          return false;
-    String upperKey = key.upper();
-    if (upperKey=="ID3" || upperKey=="TAG" || upperKey=="OGGS" || upperKey=="MP+")
-      return false;
-    return true;
+  if(key.size() < MinKeyLength || key.size() > MaxKeyLength)
+    return false;
+
+  return isKeyValid(key.data(String::UTF8));
 }
 
 APE::Footer *APE::Tag::footer() const
@@ -284,40 +409,46 @@ const APE::ItemListMap& APE::Tag::itemListMap() const
 
 void APE::Tag::removeItem(const String &key)
 {
-  Map<const String, Item>::Iterator it = d->itemListMap.find(key.upper());
-  if(it != d->itemListMap.end())
-    d->itemListMap.erase(it);
+  d->itemListMap.erase(key.upper());
 }
 
 void APE::Tag::addValue(const String &key, const String &value, bool replace)
 {
   if(replace)
     removeItem(key);
-  if(!key.isEmpty() && !value.isEmpty()) {
-    if(!replace && d->itemListMap.contains(key)) {
-      // Text items may contain more than one value
-      if(APE::Item::Text == d->itemListMap.begin()->second.type())
-        d->itemListMap[key.upper()].appendValue(value);
-      // Binary or locator items may have only one value
-      else
-        setItem(key, Item(key, value));
-    }
-    else
-      setItem(key, Item(key, value));
-  }
+
+  if(value.isEmpty())
+    return;
+
+  // Text items may contain more than one value.
+  // Binary or locator items may have only one value, hence always replaced.
+
+  ItemListMap::Iterator it = d->itemListMap.find(key.upper());
+
+  if(it != d->itemListMap.end() && it->second.type() == Item::Text)
+    it->second.appendValue(value);
+  else
+    setItem(key, Item(key, value));
 }
 
 void APE::Tag::setData(const String &key, const ByteVector &value)
 {
   removeItem(key);
-  if(!key.isEmpty() && !value.isEmpty())
-    setItem(key, Item(key, value, true));
+
+  if(value.isEmpty())
+    return;
+
+  setItem(key, Item(key, value, true));
 }
 
 void APE::Tag::setItem(const String &key, const Item &item)
 {
-  if(!key.isEmpty())
-    d->itemListMap.insert(key.upper(), item);
+  if(!checkKey(key)) {
+    debug("APE::Tag::setItem() - Couldn't set an item due to an invalid key.");
+    return;
+  }
+
+  d->itemListMap[key.upper()] = item;
 }
 
 bool APE::Tag::isEmpty() const
@@ -337,7 +468,7 @@ void APE::Tag::read()
     d->footer.setData(d->file->readBlock(Footer::size()));
 
     if(d->footer.tagSize() <= Footer::size() ||
-       d->footer.tagSize() > uint(d->file->length()))
+       d->footer.tagSize() > static_cast<unsigned long>(d->file->length()))
       return;
 
     d->file->seek(d->footerLocation + Footer::size() - d->footer.tagSize());
@@ -348,19 +479,15 @@ void APE::Tag::read()
 ByteVector APE::Tag::render() const
 {
   ByteVector data;
-  uint itemCount = 0;
+  unsigned int itemCount = 0;
 
-  {
-    for(Map<const String, Item>::ConstIterator it = d->itemListMap.begin();
-        it != d->itemListMap.end(); ++it)
-    {
-      data.append(it->second.render());
-      itemCount++;
-    }
+  for(ItemListMap::ConstIterator it = d->itemListMap.begin(); it != d->itemListMap.end(); ++it) {
+    data.append(it->second.render());
+    itemCount++;
   }
 
   d->footer.setItemCount(itemCount);
-  d->footer.setTagSize(data.size() + Footer::size());
+  d->footer.setTagSize(static_cast<unsigned int>(data.size() + Footer::size()));
   d->footer.setHeaderPresent(true);
 
   return d->footer.renderHeader() + data + d->footer.renderFooter();
@@ -368,16 +495,37 @@ ByteVector APE::Tag::render() const
 
 void APE::Tag::parse(const ByteVector &data)
 {
-  uint pos = 0;
-
   // 11 bytes is the minimum size for an APE item
 
-  for(uint i = 0; i < d->footer.itemCount() && pos <= data.size() - 11; i++) {
-    APE::Item item;
-    item.parse(data.mid(pos));
+  if(data.size() < 11)
+    return;
 
-    d->itemListMap.insert(item.key().upper(), item);
+  size_t pos = 0;
 
-    pos += item.size();
+  for(unsigned int i = 0; i < d->footer.itemCount() && pos <= data.size() - 11; i++) {
+
+    const size_t nullPos = data.find('\0', pos + 8);
+    if(nullPos == ByteVector::npos()) {
+      debug("APE::Tag::parse() - Couldn't find a key/value separator. Stopped parsing.");
+      return;
+    }
+
+    const size_t keyLength = nullPos - pos - 8;
+    const size_t valLegnth = data.toUInt32LE(pos);
+
+    if(keyLength >= MinKeyLength
+      && keyLength <= MaxKeyLength
+      && isKeyValid(data.mid(pos + 8, keyLength)))
+    {
+      APE::Item item;
+      item.parse(data.mid(pos));
+
+      d->itemListMap.insert(item.key().upper(), item);
+    }
+    else {
+      debug("APE::Tag::parse() - Skipped an item due to an invalid key.");
+    }
+
+    pos += keyLength + valLegnth + 9;
   }
 }

taglib/ape/apetag.h

@@ -34,6 +34,9 @@
 
 #include "apeitem.h"
 
+#define FRONT_COVER "COVER ART (FRONT)"
+#define BACK_COVER "COVER ART (BACK)"
+
 namespace TagLib {
 
   class File;
@@ -49,7 +52,7 @@ namespace TagLib {
      *
      * \see APE::Tag::itemListMap()
      */
-    typedef Map<const String, Item> ItemListMap;
+    typedef Map<String, Item> ItemListMap;
 
 
     //! An APE tag implementation
@@ -66,7 +69,7 @@ namespace TagLib {
        * Create an APE tag and parse the data in \a file with APE footer at
        * \a tagOffset.
        */
-      Tag(TagLib::File *file, long footerLocation);
+      Tag(TagLib::File *file, long long footerLocation);
 
       /*!
        * Destroys this Tag instance.
@@ -92,16 +95,26 @@ namespace TagLib {
       virtual String album() const;
       virtual String comment() const;
       virtual String genre() const;
-      virtual uint year() const;
-      virtual uint track() const;
+      virtual unsigned int year() const;
+      virtual unsigned int track() const;
+
+      /**
+       * @brief pictures
+       * According to :
+       * http://www.hydrogenaud.io/forums/index.php?showtopic=40603&st=50&p=504669&#entry504669
+       * http://git.videolan.org/?p=vlc.git;a=blob;f=modules/meta_engine/taglib.cpp
+       * @return
+       */
+      virtual PictureMap pictures() const;
 
       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 void setYear(unsigned int i);
+      virtual void setTrack(unsigned int i);
+      virtual void setPictures(const PictureMap &l);
 
       /*!
        * Implements the unified tag dictionary interface -- export function.
@@ -143,7 +156,7 @@ namespace TagLib {
        * Returns a reference to the item list map.  This is an ItemListMap of
        * all of the items in the tag.
        *
-       * This is the most powerfull structure for accessing the items of the tag.
+       * This is the most powerful structure for accessing the items of the tag.
        *
        * APE tags are case-insensitive, all keys in this map have been converted
        * to upper case.

taglib/asf/asfattribute.cpp

@@ -1,4 +1,4 @@
-/**************************************************************************
+/**************************************************************************
     copyright            : (C) 2005-2007 by Lukáš Lalinský
     email                : lalinsky@gmail.com
  **************************************************************************/
@@ -23,226 +23,238 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <taglib.h>
 #include <tdebug.h>
+#include <tsmartptr.h>
+
 #include "asfattribute.h"
 #include "asffile.h"
+#include "asfutils.h"
 
 using namespace TagLib;
 
-class ASF::Attribute::AttributePrivate : public RefCounter
+namespace
 {
-public:
-  AttributePrivate()
-    : pictureValue(ASF::Picture::fromInvalid()),
+  struct AttributeData
+  {
+    AttributeData() :
+      numericValue(0),
       stream(0),
       language(0) {}
-  AttributeTypes type;
-  String stringValue;
-  ByteVector byteVectorValue;
-  ASF::Picture pictureValue;
-  union {
-    unsigned int intValue;
-    unsigned short shortValue;
-    unsigned long long longLongValue;
-    bool boolValue;
+
+    ASF::Attribute::AttributeTypes type;
+    String stringValue;
+    ByteVector byteVectorValue;
+    ASF::Picture pictureValue;
+    unsigned long long numericValue;
+    int stream;
+    int language;
   };
-  int stream;
-  int language;
+}
+
+class ASF::Attribute::AttributePrivate
+{
+public:
+  AttributePrivate() :
+    data(new AttributeData())
+  {
+    data->pictureValue = ASF::Picture::fromInvalid();
+  }
+
+  SHARED_PTR<AttributeData> data;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-ASF::Attribute::Attribute()
+ASF::Attribute::Attribute() :
+  d(new AttributePrivate())
 {
-  d = new AttributePrivate;
-  d->type = UnicodeType;
+  d->data->type = UnicodeType;
 }
 
-ASF::Attribute::Attribute(const ASF::Attribute &other)
-  : d(other.d)
+ASF::Attribute::Attribute(const ASF::Attribute &other) :
+  d(new AttributePrivate(*other.d))
 {
-  d->ref();
+}
+
+ASF::Attribute::Attribute(const String &value) :
+  d(new AttributePrivate())
+{
+  d->data->type = UnicodeType;
+  d->data->stringValue = value;
+}
+
+ASF::Attribute::Attribute(const ByteVector &value) :
+  d(new AttributePrivate())
+{
+  d->data->type = BytesType;
+  d->data->byteVectorValue = value;
+}
+
+ASF::Attribute::Attribute(const ASF::Picture &value) :
+  d(new AttributePrivate())
+{
+  d->data->type = BytesType;
+  d->data->pictureValue = value;
+}
+
+ASF::Attribute::Attribute(unsigned int value) :
+  d(new AttributePrivate())
+{
+  d->data->type = DWordType;
+  d->data->numericValue = value;
+}
+
+ASF::Attribute::Attribute(unsigned long long value) :
+  d(new AttributePrivate())
+{
+  d->data->type = QWordType;
+  d->data->numericValue = value;
+}
+
+ASF::Attribute::Attribute(unsigned short value) :
+  d(new AttributePrivate())
+{
+  d->data->type = WordType;
+  d->data->numericValue = value;
+}
+
+ASF::Attribute::Attribute(bool value) :
+  d(new AttributePrivate())
+{
+  d->data->type = BoolType;
+  d->data->numericValue = value;
 }
 
 ASF::Attribute &ASF::Attribute::operator=(const ASF::Attribute &other)
 {
-  if(d->deref())
-    delete d;
-  d = other.d;
-  d->ref();
+  Attribute(other).swap(*this);
   return *this;
 }
 
+void ASF::Attribute::swap(Attribute &other)
+{
+  using std::swap;
+
+  swap(d, other.d);
+}
+
 ASF::Attribute::~Attribute()
 {
-  if(d->deref())
-    delete d;
-}
-
-ASF::Attribute::Attribute(const String &value)
-{
-  d = new AttributePrivate;
-  d->type = UnicodeType;
-  d->stringValue = value;
-}
-
-ASF::Attribute::Attribute(const ByteVector &value)
-{
-  d = new AttributePrivate;
-  d->type = BytesType;
-  d->byteVectorValue = value;
-}
-
-ASF::Attribute::Attribute(const ASF::Picture &value)
-{
-  d = new AttributePrivate;
-  d->type = BytesType;
-  d->pictureValue = value;
-}
-
-ASF::Attribute::Attribute(unsigned int value)
-{
-  d = new AttributePrivate;
-  d->type = DWordType;
-  d->intValue = value;
-}
-
-ASF::Attribute::Attribute(unsigned long long value)
-{
-  d = new AttributePrivate;
-  d->type = QWordType;
-  d->longLongValue = value;
-}
-
-ASF::Attribute::Attribute(unsigned short value)
-{
-  d = new AttributePrivate;
-  d->type = WordType;
-  d->shortValue = value;
-}
-
-ASF::Attribute::Attribute(bool value)
-{
-  d = new AttributePrivate;
-  d->type = BoolType;
-  d->boolValue = value;
+  delete d;
 }
 
 ASF::Attribute::AttributeTypes ASF::Attribute::type() const
 {
-  return d->type;
+  return d->data->type;
 }
 
 String ASF::Attribute::toString() const
 {
-  return d->stringValue;
+  return d->data->stringValue;
 }
 
 ByteVector ASF::Attribute::toByteVector() const
 {
-  if(d->pictureValue.isValid())
-    return d->pictureValue.render();
-  return d->byteVectorValue;
+  if(d->data->pictureValue.isValid())
+    return d->data->pictureValue.render();
+
+  return d->data->byteVectorValue;
 }
 
 unsigned short ASF::Attribute::toBool() const
 {
-  return d->shortValue;
+  return d->data->numericValue ? 1 : 0;
 }
 
 unsigned short ASF::Attribute::toUShort() const
 {
-  return d->shortValue;
+  return static_cast<unsigned short>(d->data->numericValue);
 }
 
 unsigned int ASF::Attribute::toUInt() const
 {
-  return d->intValue;
+  return static_cast<unsigned int>(d->data->numericValue);
 }
 
 unsigned long long ASF::Attribute::toULongLong() const
 {
-  return d->longLongValue;
+  return static_cast<unsigned long long>(d->data->numericValue);
 }
 
 ASF::Picture ASF::Attribute::toPicture() const
 {
-  return d->pictureValue;
+  return d->data->pictureValue;
 }
 
 String ASF::Attribute::parse(ASF::File &f, int kind)
 {
-  uint size, nameLength;
+  unsigned int size, nameLength;
   String name;
-  d->pictureValue = Picture::fromInvalid();
+  d->data->pictureValue = Picture::fromInvalid();
   // extended content descriptor
   if(kind == 0) {
-    nameLength = f.readWORD();
-    name = f.readString(nameLength);
-    d->type = ASF::Attribute::AttributeTypes(f.readWORD());
-    size = f.readWORD();
+    nameLength = readWORD(&f);
+    name = readString(&f, nameLength);
+    d->data->type = ASF::Attribute::AttributeTypes(readWORD(&f));
+    size = readWORD(&f);
   }
   // metadata & metadata library
   else {
-    int temp = f.readWORD();
+    int temp = readWORD(&f);
     // metadata library
     if(kind == 2) {
-      d->language = temp;
+      d->data->language = temp;
     }
-    d->stream = f.readWORD();
-    nameLength = f.readWORD();
-    d->type = ASF::Attribute::AttributeTypes(f.readWORD());
-    size = f.readDWORD();
-    name = f.readString(nameLength);
+    d->data->stream = readWORD(&f);
+    nameLength = readWORD(&f);
+    d->data->type = ASF::Attribute::AttributeTypes(readWORD(&f));
+    size = readDWORD(&f);
+    name = readString(&f, nameLength);
   }
 
   if(kind != 2 && size > 65535) {
     debug("ASF::Attribute::parse() -- Value larger than 64kB");
   }
 
-  switch(d->type) {
+  switch(d->data->type) {
   case WordType:
-    d->shortValue = f.readWORD();
+    d->data->numericValue = readWORD(&f);
     break;
 
   case BoolType:
     if(kind == 0) {
-      d->boolValue = f.readDWORD() == 1;
+      d->data->numericValue = (readDWORD(&f) != 0);
     }
     else {
-      d->boolValue = f.readWORD() == 1;
+      d->data->numericValue = (readWORD(&f) != 0);
     }
     break;
 
   case DWordType:
-    d->intValue = f.readDWORD();
+    d->data->numericValue = readDWORD(&f);
     break;
 
   case QWordType:
-    d->longLongValue = f.readQWORD();
+    d->data->numericValue = readQWORD(&f);
     break;
 
   case UnicodeType:
-    d->stringValue = f.readString(size);
+    d->data->stringValue = readString(&f, size);
     break;
 
   case BytesType:
   case GuidType:
-    d->byteVectorValue = f.readBlock(size);
+    d->data->byteVectorValue = f.readBlock(size);
     break;
   }
 
-  if(d->type == BytesType && name == "WM/Picture") {
-    d->pictureValue.parse(d->byteVectorValue);
-    if(d->pictureValue.isValid()) {
-      d->byteVectorValue.clear();
+  if(d->data->type == BytesType && name == "WM/Picture") {
+    d->data->pictureValue.parse(d->data->byteVectorValue);
+    if(d->data->pictureValue.isValid()) {
+      d->data->byteVectorValue.clear();
     }
   }
 
@@ -251,7 +263,7 @@ String ASF::Attribute::parse(ASF::File &f, int kind)
 
 int ASF::Attribute::dataSize() const
 {
-  switch (d->type) {
+  switch (d->data->type) {
   case WordType:
     return 2;
   case BoolType:
@@ -261,12 +273,12 @@ int ASF::Attribute::dataSize() const
   case QWordType:
     return 5;
   case UnicodeType:
-    return d->stringValue.size() * 2 + 2;
+    return static_cast<int>(d->data->stringValue.size() * 2 + 2);
   case BytesType:
-    if(d->pictureValue.isValid())
-      return d->pictureValue.dataSize();
+    if(d->data->pictureValue.isValid())
+      return d->data->pictureValue.dataSize();
   case GuidType:
-    return d->byteVectorValue.size();
+    return static_cast<int>(d->data->byteVectorValue.size());
   }
   return 0;
 }
@@ -275,55 +287,55 @@ ByteVector ASF::Attribute::render(const String &name, int kind) const
 {
   ByteVector data;
 
-  switch (d->type) {
+  switch (d->data->type) {
   case WordType:
-    data.append(ByteVector::fromShort(d->shortValue, false));
+    data.append(ByteVector::fromUInt16LE(toUShort()));
     break;
 
   case BoolType:
     if(kind == 0) {
-      data.append(ByteVector::fromUInt(d->boolValue ? 1 : 0, false));
+      data.append(ByteVector::fromUInt32LE(toBool()));
     }
     else {
-      data.append(ByteVector::fromShort(d->boolValue ? 1 : 0, false));
+      data.append(ByteVector::fromUInt16LE(toBool()));
     }
     break;
 
   case DWordType:
-    data.append(ByteVector::fromUInt(d->intValue, false));
+    data.append(ByteVector::fromUInt32LE(toUInt()));
     break;
 
   case QWordType:
-    data.append(ByteVector::fromLongLong(d->longLongValue, false));
+    data.append(ByteVector::fromUInt64LE(toULongLong()));
     break;
 
   case UnicodeType:
-    data.append(File::renderString(d->stringValue));
+    data.append(renderString(d->data->stringValue));
     break;
 
   case BytesType:
-    if(d->pictureValue.isValid()) {
-      data.append(d->pictureValue.render());
+    if(d->data->pictureValue.isValid()) {
+      data.append(d->data->pictureValue.render());
       break;
     }
   case GuidType:
-    data.append(d->byteVectorValue);
+    data.append(d->data->byteVectorValue);
     break;
   }
 
   if(kind == 0) {
-    data = File::renderString(name, true) +
-           ByteVector::fromShort((int)d->type, false) +
-           ByteVector::fromShort(data.size(), false) +
+    data = renderString(name, true) +
+           ByteVector::fromUInt16LE((int)d->data->type) +
+           ByteVector::fromUInt16LE(data.size()) +
            data;
   }
   else {
-    ByteVector nameData = File::renderString(name);
-    data = ByteVector::fromShort(kind == 2 ? d->language : 0, false) +
-           ByteVector::fromShort(d->stream, false) +
-           ByteVector::fromShort(nameData.size(), false) +
-           ByteVector::fromShort((int)d->type, false) +
-           ByteVector::fromUInt(data.size(), false) +
+    ByteVector nameData = renderString(name);
+    data = ByteVector::fromUInt16LE(kind == 2 ? d->data->language : 0) +
+           ByteVector::fromUInt16LE(d->data->stream) +
+           ByteVector::fromUInt16LE(nameData.size()) +
+           ByteVector::fromUInt16LE((int)d->data->type) +
+           ByteVector::fromUInt32LE(data.size()) +
            nameData +
            data;
   }
@@ -333,21 +345,20 @@ ByteVector ASF::Attribute::render(const String &name, int kind) const
 
 int ASF::Attribute::language() const
 {
-  return d->language;
+  return d->data->language;
 }
 
 void ASF::Attribute::setLanguage(int value)
 {
-  d->language = value;
+  d->data->language = value;
 }
 
 int ASF::Attribute::stream() const
 {
-  return d->stream;
+  return d->data->stream;
 }
 
 void ASF::Attribute::setStream(int value)
 {
-  d->stream = value;
+  d->data->stream = value;
 }
-

taglib/asf/asfattribute.h

@@ -36,7 +36,6 @@ namespace TagLib
 
   namespace ASF
   {
-
     class File;
     class Picture;
 
@@ -113,7 +112,12 @@ namespace TagLib
       /*!
        * Copies the contents of \a other into this item.
        */
-      ASF::Attribute &operator=(const Attribute &other);
+      Attribute &operator=(const Attribute &other);
+
+      /*!
+       * Exchanges the content of the Attribute by the content of \a other.
+       */
+      void swap(Attribute &other);
 
       /*!
        * Destroys the attribute.
@@ -180,17 +184,13 @@ namespace TagLib
        */
       void setStream(int value);
 
-#ifndef DO_NOT_DOCUMENT
-      /* THIS IS PRIVATE, DON'T TOUCH IT! */
-      String parse(ASF::File &file, int kind = 0);
-#endif
-
       //! Returns the size of the stored data
       int dataSize() const;
 
     private:
       friend class File;
 
+      String parse(ASF::File &file, int kind = 0);
       ByteVector render(const String &name, int kind = 0) const;
 
       class AttributePrivate;

taglib/asf/asffile.cpp

@@ -23,218 +23,255 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <tdebug.h>
 #include <tbytevectorlist.h>
+#include <tpropertymap.h>
 #include <tstring.h>
+#include <tagutils.h>
+#include <tsmartptr.h>
+
 #include "asffile.h"
 #include "asftag.h"
 #include "asfproperties.h"
+#include "asfutils.h"
 
 using namespace TagLib;
 
 class ASF::File::FilePrivate
 {
 public:
+  class BaseObject;
+  class UnknownObject;
+  class FilePropertiesObject;
+  class StreamPropertiesObject;
+  class ContentDescriptionObject;
+  class ExtendedContentDescriptionObject;
+  class HeaderExtensionObject;
+  class CodecListObject;
+  class MetadataObject;
+  class MetadataLibraryObject;
+
+  typedef List<SHARED_PTR<BaseObject> > ObjectList;
+  typedef ObjectList::ConstIterator     ObjectConstIterator;
+
   FilePrivate():
-    size(0),
-    tag(0),
-    properties(0),
-    contentDescriptionObject(0),
-    extendedContentDescriptionObject(0),
-    headerExtensionObject(0),
-    metadataObject(0),
-    metadataLibraryObject(0) {}
-  unsigned long long size;
-  ASF::Tag *tag;
-  ASF::Properties *properties;
-  List<ASF::File::BaseObject *> objects;
-  ASF::File::ContentDescriptionObject *contentDescriptionObject;
-  ASF::File::ExtendedContentDescriptionObject *extendedContentDescriptionObject;
-  ASF::File::HeaderExtensionObject *headerExtensionObject;
-  ASF::File::MetadataObject *metadataObject;
-  ASF::File::MetadataLibraryObject *metadataLibraryObject;
+    headerSize(0) {}
+
+  unsigned long long headerSize;
+
+  SCOPED_PTR<ASF::Tag> tag;
+  SCOPED_PTR<ASF::AudioProperties> properties;
+
+  ObjectList objects;
+
+  SHARED_PTR<ContentDescriptionObject>         contentDescriptionObject;
+  SHARED_PTR<ExtendedContentDescriptionObject> extendedContentDescriptionObject;
+  SHARED_PTR<HeaderExtensionObject>            headerExtensionObject;
+  SHARED_PTR<MetadataObject>                   metadataObject;
+  SHARED_PTR<MetadataLibraryObject>            metadataLibraryObject;
 };
 
-static ByteVector headerGuid("\x30\x26\xB2\x75\x8E\x66\xCF\x11\xA6\xD9\x00\xAA\x00\x62\xCE\x6C", 16);
-static ByteVector filePropertiesGuid("\xA1\xDC\xAB\x8C\x47\xA9\xCF\x11\x8E\xE4\x00\xC0\x0C\x20\x53\x65", 16);
-static ByteVector streamPropertiesGuid("\x91\x07\xDC\xB7\xB7\xA9\xCF\x11\x8E\xE6\x00\xC0\x0C\x20\x53\x65", 16);
-static ByteVector contentDescriptionGuid("\x33\x26\xB2\x75\x8E\x66\xCF\x11\xA6\xD9\x00\xAA\x00\x62\xCE\x6C", 16);
-static ByteVector extendedContentDescriptionGuid("\x40\xA4\xD0\xD2\x07\xE3\xD2\x11\x97\xF0\x00\xA0\xC9\x5E\xA8\x50", 16);
-static ByteVector headerExtensionGuid("\xb5\x03\xbf_.\xa9\xcf\x11\x8e\xe3\x00\xc0\x0c Se", 16);
-static ByteVector metadataGuid("\xEA\xCB\xF8\xC5\xAF[wH\204g\xAA\214D\xFAL\xCA", 16);
-static ByteVector metadataLibraryGuid("\224\034#D\230\224\321I\241A\x1d\x13NEpT", 16);
-static ByteVector contentEncryptionGuid("\xFB\xB3\x11\x22\x23\xBD\xD2\x11\xB4\xB7\x00\xA0\xC9\x55\xFC\x6E", 16);
-static ByteVector extendedContentEncryptionGuid("\x14\xE6\x8A\x29\x22\x26 \x17\x4C\xB9\x35\xDA\xE0\x7E\xE9\x28\x9C", 16);
-static ByteVector advancedContentEncryptionGuid("\xB6\x9B\x07\x7A\xA4\xDA\x12\x4E\xA5\xCA\x91\xD3\x8D\xC1\x1A\x8D", 16);
+namespace
+{
+  const ByteVector headerGuid("\x30\x26\xB2\x75\x8E\x66\xCF\x11\xA6\xD9\x00\xAA\x00\x62\xCE\x6C", 16);
+  const ByteVector filePropertiesGuid("\xA1\xDC\xAB\x8C\x47\xA9\xCF\x11\x8E\xE4\x00\xC0\x0C\x20\x53\x65", 16);
+  const ByteVector streamPropertiesGuid("\x91\x07\xDC\xB7\xB7\xA9\xCF\x11\x8E\xE6\x00\xC0\x0C\x20\x53\x65", 16);
+  const ByteVector contentDescriptionGuid("\x33\x26\xB2\x75\x8E\x66\xCF\x11\xA6\xD9\x00\xAA\x00\x62\xCE\x6C", 16);
+  const ByteVector extendedContentDescriptionGuid("\x40\xA4\xD0\xD2\x07\xE3\xD2\x11\x97\xF0\x00\xA0\xC9\x5E\xA8\x50", 16);
+  const ByteVector headerExtensionGuid("\xb5\x03\xbf_.\xa9\xcf\x11\x8e\xe3\x00\xc0\x0c Se", 16);
+  const ByteVector metadataGuid("\xEA\xCB\xF8\xC5\xAF[wH\204g\xAA\214D\xFAL\xCA", 16);
+  const ByteVector metadataLibraryGuid("\224\034#D\230\224\321I\241A\x1d\x13NEpT", 16);
+  const ByteVector codecListGuid("\x40\x52\xd1\x86\x1d\x31\xd0\x11\xa3\xa4\x00\xa0\xc9\x03\x48\xf6", 16);
+  const ByteVector contentEncryptionGuid("\xFB\xB3\x11\x22\x23\xBD\xD2\x11\xB4\xB7\x00\xA0\xC9\x55\xFC\x6E", 16);
+  const ByteVector extendedContentEncryptionGuid("\x14\xE6\x8A\x29\x22\x26 \x17\x4C\xB9\x35\xDA\xE0\x7E\xE9\x28\x9C", 16);
+  const ByteVector advancedContentEncryptionGuid("\xB6\x9B\x07\x7A\xA4\xDA\x12\x4E\xA5\xCA\x91\xD3\x8D\xC1\x1A\x8D", 16);
+}
 
-class ASF::File::BaseObject
+class ASF::File::FilePrivate::BaseObject
 {
 public:
   ByteVector data;
   virtual ~BaseObject() {}
-  virtual ByteVector guid() = 0;
+  virtual ByteVector guid() const = 0;
   virtual void parse(ASF::File *file, unsigned int size);
   virtual ByteVector render(ASF::File *file);
 };
 
-class ASF::File::UnknownObject : public ASF::File::BaseObject
+class ASF::File::FilePrivate::UnknownObject : public ASF::File::FilePrivate::BaseObject
 {
   ByteVector myGuid;
 public:
-  UnknownObject(const ByteVector &guid);
-  ByteVector guid();
+  explicit UnknownObject(const ByteVector &guid);
+  ByteVector guid() const;
 };
 
-class ASF::File::FilePropertiesObject : public ASF::File::BaseObject
+class ASF::File::FilePrivate::FilePropertiesObject : public ASF::File::FilePrivate::BaseObject
 {
 public:
-  ByteVector guid();
-  void parse(ASF::File *file, uint size);
+  ByteVector guid() const;
+  void parse(ASF::File *file, unsigned int size);
 };
 
-class ASF::File::StreamPropertiesObject : public ASF::File::BaseObject
+class ASF::File::FilePrivate::StreamPropertiesObject : public ASF::File::FilePrivate::BaseObject
 {
 public:
-  ByteVector guid();
-  void parse(ASF::File *file, uint size);
+  ByteVector guid() const;
+  void parse(ASF::File *file, unsigned int size);
 };
 
-class ASF::File::ContentDescriptionObject : public ASF::File::BaseObject
+class ASF::File::FilePrivate::ContentDescriptionObject : public ASF::File::FilePrivate::BaseObject
 {
 public:
-  ByteVector guid();
-  void parse(ASF::File *file, uint size);
+  ByteVector guid() const;
+  void parse(ASF::File *file, unsigned int size);
   ByteVector render(ASF::File *file);
 };
 
-class ASF::File::ExtendedContentDescriptionObject : public ASF::File::BaseObject
+class ASF::File::FilePrivate::ExtendedContentDescriptionObject : public ASF::File::FilePrivate::BaseObject
 {
 public:
   ByteVectorList attributeData;
-  ByteVector guid();
-  void parse(ASF::File *file, uint size);
+  ByteVector guid() const;
+  void parse(ASF::File *file, unsigned int size);
   ByteVector render(ASF::File *file);
 };
 
-class ASF::File::MetadataObject : public ASF::File::BaseObject
+class ASF::File::FilePrivate::MetadataObject : public ASF::File::FilePrivate::BaseObject
 {
 public:
   ByteVectorList attributeData;
-  ByteVector guid();
-  void parse(ASF::File *file, uint size);
+  ByteVector guid() const;
+  void parse(ASF::File *file, unsigned int size);
   ByteVector render(ASF::File *file);
 };
 
-class ASF::File::MetadataLibraryObject : public ASF::File::BaseObject
+class ASF::File::FilePrivate::MetadataLibraryObject : public ASF::File::FilePrivate::BaseObject
 {
 public:
   ByteVectorList attributeData;
-  ByteVector guid();
-  void parse(ASF::File *file, uint size);
+  ByteVector guid() const;
+  void parse(ASF::File *file, unsigned int size);
   ByteVector render(ASF::File *file);
 };
 
-class ASF::File::HeaderExtensionObject : public ASF::File::BaseObject
+class ASF::File::FilePrivate::HeaderExtensionObject : public ASF::File::FilePrivate::BaseObject
 {
 public:
-  List<ASF::File::BaseObject *> objects;
-  ~HeaderExtensionObject();
-  ByteVector guid();
-  void parse(ASF::File *file, uint size);
+  ObjectList objects;
+  HeaderExtensionObject();
+  ByteVector guid() const;
+  void parse(ASF::File *file, unsigned int size);
   ByteVector render(ASF::File *file);
 };
 
-ASF::File::HeaderExtensionObject::~HeaderExtensionObject()
+class ASF::File::FilePrivate::CodecListObject : public ASF::File::FilePrivate::BaseObject
 {
-  for(unsigned int i = 0; i < objects.size(); i++) {
-    delete objects[i];
-  }
-}
+public:
+  ByteVector guid() const;
+  void parse(ASF::File *file, unsigned int size);
 
-void ASF::File::BaseObject::parse(ASF::File *file, unsigned int size)
+private:
+  enum CodecType
+  {
+    Video   = 0x0001,
+    Audio   = 0x0002,
+    Unknown = 0xFFFF
+  };
+};
+
+void ASF::File::FilePrivate::BaseObject::parse(ASF::File *file, unsigned int size)
 {
   data.clear();
-  if (size > 24 && size <= (unsigned int)(file->length()))
+  if(size > 24 && static_cast<long long>(size) <= file->length())
     data = file->readBlock(size - 24);
   else
-    data = ByteVector::null;
+    data = ByteVector();
 }
 
-ByteVector ASF::File::BaseObject::render(ASF::File * /*file*/)
+ByteVector ASF::File::FilePrivate::BaseObject::render(ASF::File * /*file*/)
 {
-  return guid() + ByteVector::fromLongLong(data.size() + 24, false) + data;
+  return guid() + ByteVector::fromUInt64LE(data.size() + 24) + data;
 }
 
-ASF::File::UnknownObject::UnknownObject(const ByteVector &guid) : myGuid(guid)
+ASF::File::FilePrivate::UnknownObject::UnknownObject(const ByteVector &guid) : myGuid(guid)
 {
 }
 
-ByteVector ASF::File::UnknownObject::guid()
+ByteVector ASF::File::FilePrivate::UnknownObject::guid() const
 {
   return myGuid;
 }
 
-ByteVector ASF::File::FilePropertiesObject::guid()
+ByteVector ASF::File::FilePrivate::FilePropertiesObject::guid() const
 {
   return filePropertiesGuid;
 }
 
-void ASF::File::FilePropertiesObject::parse(ASF::File *file, uint size)
+void ASF::File::FilePrivate::FilePropertiesObject::parse(ASF::File *file, unsigned int size)
 {
   BaseObject::parse(file, size);
-  file->d->properties->setLength((int)(data.mid(40, 8).toLongLong(false) / 10000000L - data.mid(56, 8).toLongLong(false) / 1000L));
+  if(data.size() < 64) {
+    debug("ASF::File::FilePrivate::FilePropertiesObject::parse() -- data is too short.");
+    return;
+  }
+
+  const long long duration = data.toInt64LE(40);
+  const long long preroll  = data.toInt64LE(56);
+  file->d->properties->setLengthInMilliseconds(static_cast<int>(duration / 10000.0 - preroll + 0.5));
 }
 
-ByteVector ASF::File::StreamPropertiesObject::guid()
+ByteVector ASF::File::FilePrivate::StreamPropertiesObject::guid() const
 {
   return streamPropertiesGuid;
 }
 
-void ASF::File::StreamPropertiesObject::parse(ASF::File *file, uint size)
+void ASF::File::FilePrivate::StreamPropertiesObject::parse(ASF::File *file, unsigned int size)
 {
   BaseObject::parse(file, size);
-  file->d->properties->setChannels(data.mid(56, 2).toShort(false));
-  file->d->properties->setSampleRate(data.mid(58, 4).toUInt(false));
-  file->d->properties->setBitrate(data.mid(62, 4).toUInt(false) * 8 / 1000);
+  if(data.size() < 70) {
+    debug("ASF::File::FilePrivate::StreamPropertiesObject::parse() -- data is too short.");
+    return;
+  }
+
+  file->d->properties->setCodec(data.toUInt16LE(54));
+  file->d->properties->setChannels(data.toUInt16LE(56));
+  file->d->properties->setSampleRate(data.toUInt32LE(58));
+  file->d->properties->setBitrate(static_cast<int>(data.toUInt32LE(62) * 8.0 / 1000.0 + 0.5));
+  file->d->properties->setBitsPerSample(data.toUInt16LE(68));
 }
 
-ByteVector ASF::File::ContentDescriptionObject::guid()
+ByteVector ASF::File::FilePrivate::ContentDescriptionObject::guid() const
 {
   return contentDescriptionGuid;
 }
 
-void ASF::File::ContentDescriptionObject::parse(ASF::File *file, uint /*size*/)
+void ASF::File::FilePrivate::ContentDescriptionObject::parse(ASF::File *file, unsigned int /*size*/)
 {
-  file->d->contentDescriptionObject = this;
-  int titleLength = file->readWORD();
-  int artistLength = file->readWORD();
-  int copyrightLength = file->readWORD();
-  int commentLength = file->readWORD();
-  int ratingLength = file->readWORD();
-  file->d->tag->setTitle(file->readString(titleLength));
-  file->d->tag->setArtist(file->readString(artistLength));
-  file->d->tag->setCopyright(file->readString(copyrightLength));
-  file->d->tag->setComment(file->readString(commentLength));
-  file->d->tag->setRating(file->readString(ratingLength));
+  const int titleLength     = readWORD(file);
+  const int artistLength    = readWORD(file);
+  const int copyrightLength = readWORD(file);
+  const int commentLength   = readWORD(file);
+  const int ratingLength    = readWORD(file);
+  file->d->tag->setTitle(readString(file,titleLength));
+  file->d->tag->setArtist(readString(file,artistLength));
+  file->d->tag->setCopyright(readString(file,copyrightLength));
+  file->d->tag->setComment(readString(file,commentLength));
+  file->d->tag->setRating(readString(file,ratingLength));
 }
 
-ByteVector ASF::File::ContentDescriptionObject::render(ASF::File *file)
+ByteVector ASF::File::FilePrivate::ContentDescriptionObject::render(ASF::File *file)
 {
-  ByteVector v1 = file->renderString(file->d->tag->title());
-  ByteVector v2 = file->renderString(file->d->tag->artist());
-  ByteVector v3 = file->renderString(file->d->tag->copyright());
-  ByteVector v4 = file->renderString(file->d->tag->comment());
-  ByteVector v5 = file->renderString(file->d->tag->rating());
+  const ByteVector v1 = renderString(file->d->tag->title());
+  const ByteVector v2 = renderString(file->d->tag->artist());
+  const ByteVector v3 = renderString(file->d->tag->copyright());
+  const ByteVector v4 = renderString(file->d->tag->comment());
+  const ByteVector v5 = renderString(file->d->tag->rating());
   data.clear();
-  data.append(ByteVector::fromShort(v1.size(), false));
-  data.append(ByteVector::fromShort(v2.size(), false));
-  data.append(ByteVector::fromShort(v3.size(), false));
-  data.append(ByteVector::fromShort(v4.size(), false));
-  data.append(ByteVector::fromShort(v5.size(), false));
+  data.append(ByteVector::fromUInt16LE(v1.size()));
+  data.append(ByteVector::fromUInt16LE(v2.size()));
+  data.append(ByteVector::fromUInt16LE(v3.size()));
+  data.append(ByteVector::fromUInt16LE(v4.size()));
+  data.append(ByteVector::fromUInt16LE(v5.size()));
   data.append(v1);
   data.append(v2);
   data.append(v3);
@@ -243,15 +280,14 @@ ByteVector ASF::File::ContentDescriptionObject::render(ASF::File *file)
   return BaseObject::render(file);
 }
 
-ByteVector ASF::File::ExtendedContentDescriptionObject::guid()
+ByteVector ASF::File::FilePrivate::ExtendedContentDescriptionObject::guid() const
 {
   return extendedContentDescriptionGuid;
 }
 
-void ASF::File::ExtendedContentDescriptionObject::parse(ASF::File *file, uint /*size*/)
+void ASF::File::FilePrivate::ExtendedContentDescriptionObject::parse(ASF::File *file, unsigned int /*size*/)
 {
-  file->d->extendedContentDescriptionObject = this;
-  int count = file->readWORD();
+  int count = readWORD(file);
   while(count--) {
     ASF::Attribute attribute;
     String name = attribute.parse(*file);
@@ -259,23 +295,22 @@ void ASF::File::ExtendedContentDescriptionObject::parse(ASF::File *file, uint /*
   }
 }
 
-ByteVector ASF::File::ExtendedContentDescriptionObject::render(ASF::File *file)
+ByteVector ASF::File::FilePrivate::ExtendedContentDescriptionObject::render(ASF::File *file)
 {
   data.clear();
-  data.append(ByteVector::fromShort(attributeData.size(), false));
-  data.append(attributeData.toByteVector(ByteVector::null));
+  data.append(ByteVector::fromUInt16LE(attributeData.size()));
+  data.append(attributeData.toByteVector(""));
   return BaseObject::render(file);
 }
 
-ByteVector ASF::File::MetadataObject::guid()
+ByteVector ASF::File::FilePrivate::MetadataObject::guid() const
 {
   return metadataGuid;
 }
 
-void ASF::File::MetadataObject::parse(ASF::File *file, uint /*size*/)
+void ASF::File::FilePrivate::MetadataObject::parse(ASF::File *file, unsigned int /*size*/)
 {
-  file->d->metadataObject = this;
-  int count = file->readWORD();
+  int count = readWORD(file);
   while(count--) {
     ASF::Attribute attribute;
     String name = attribute.parse(*file, 1);
@@ -283,23 +318,22 @@ void ASF::File::MetadataObject::parse(ASF::File *file, uint /*size*/)
   }
 }
 
-ByteVector ASF::File::MetadataObject::render(ASF::File *file)
+ByteVector ASF::File::FilePrivate::MetadataObject::render(ASF::File *file)
 {
   data.clear();
-  data.append(ByteVector::fromShort(attributeData.size(), false));
-  data.append(attributeData.toByteVector(ByteVector::null));
+  data.append(ByteVector::fromUInt16LE(attributeData.size()));
+  data.append(attributeData.toByteVector(""));
   return BaseObject::render(file);
 }
 
-ByteVector ASF::File::MetadataLibraryObject::guid()
+ByteVector ASF::File::FilePrivate::MetadataLibraryObject::guid() const
 {
   return metadataLibraryGuid;
 }
 
-void ASF::File::MetadataLibraryObject::parse(ASF::File *file, uint /*size*/)
+void ASF::File::FilePrivate::MetadataLibraryObject::parse(ASF::File *file, unsigned int /*size*/)
 {
-  file->d->metadataLibraryObject = this;
-  int count = file->readWORD();
+  int count = readWORD(file);
   while(count--) {
     ASF::Attribute attribute;
     String name = attribute.parse(*file, 2);
@@ -307,24 +341,27 @@ void ASF::File::MetadataLibraryObject::parse(ASF::File *file, uint /*size*/)
   }
 }
 
-ByteVector ASF::File::MetadataLibraryObject::render(ASF::File *file)
+ByteVector ASF::File::FilePrivate::MetadataLibraryObject::render(ASF::File *file)
 {
   data.clear();
-  data.append(ByteVector::fromShort(attributeData.size(), false));
-  data.append(attributeData.toByteVector(ByteVector::null));
+  data.append(ByteVector::fromUInt16LE(attributeData.size()));
+  data.append(attributeData.toByteVector(""));
   return BaseObject::render(file);
 }
 
-ByteVector ASF::File::HeaderExtensionObject::guid()
+ASF::File::FilePrivate::HeaderExtensionObject::HeaderExtensionObject()
+{
+}
+
+ByteVector ASF::File::FilePrivate::HeaderExtensionObject::guid() const
 {
   return headerExtensionGuid;
 }
 
-void ASF::File::HeaderExtensionObject::parse(ASF::File *file, uint /*size*/)
+void ASF::File::FilePrivate::HeaderExtensionObject::parse(ASF::File *file, unsigned int /*size*/)
 {
-  file->d->headerExtensionObject = this;
   file->seek(18, File::Current);
-  long long dataSize = file->readDWORD();
+  long long dataSize = readDWORD(file);
   long long dataPos = 0;
   while(dataPos < dataSize) {
     ByteVector guid = file->readBlock(16);
@@ -333,20 +370,22 @@ void ASF::File::HeaderExtensionObject::parse(ASF::File *file, uint /*size*/)
       break;
     }
     bool ok;
-    long long size = file->readQWORD(&ok);
+    long long size = readQWORD(file, &ok);
     if(!ok) {
       file->setValid(false);
       break;
     }
-    BaseObject *obj;
+    SHARED_PTR<BaseObject> obj;
     if(guid == metadataGuid) {
-      obj = new MetadataObject();
+      file->d->metadataObject.reset(new MetadataObject());
+      obj = file->d->metadataObject;
     }
     else if(guid == metadataLibraryGuid) {
-      obj = new MetadataLibraryObject();
+      file->d->metadataLibraryObject.reset(new MetadataLibraryObject());
+      obj = file->d->metadataLibraryObject;
     }
     else {
-      obj = new UnknownObject(guid);
+      obj.reset(new UnknownObject(guid));
     }
     obj->parse(file, (unsigned int)size);
     objects.append(obj);
@@ -354,124 +393,116 @@ void ASF::File::HeaderExtensionObject::parse(ASF::File *file, uint /*size*/)
   }
 }
 
-ByteVector ASF::File::HeaderExtensionObject::render(ASF::File *file)
+ByteVector ASF::File::FilePrivate::HeaderExtensionObject::render(ASF::File *file)
 {
   data.clear();
-  for(unsigned int i = 0; i < objects.size(); i++) {
-    data.append(objects[i]->render(file));
+  for(ObjectConstIterator it = objects.begin(); it != objects.end(); ++it) {
+    data.append((*it)->render(file));
   }
-  data = ByteVector("\x11\xD2\xD3\xAB\xBA\xA9\xcf\x11\x8E\xE6\x00\xC0\x0C\x20\x53\x65\x06\x00", 18) + ByteVector::fromUInt(data.size(), false) + data;
+  data = ByteVector("\x11\xD2\xD3\xAB\xBA\xA9\xcf\x11\x8E\xE6\x00\xC0\x0C\x20\x53\x65\x06\x00", 18) + ByteVector::fromUInt32LE(data.size()) + data;
   return BaseObject::render(file);
 }
 
+ByteVector ASF::File::FilePrivate::CodecListObject::guid() const
+{
+  return codecListGuid;
+}
+
+void ASF::File::FilePrivate::CodecListObject::parse(ASF::File *file, unsigned int size)
+{
+  BaseObject::parse(file, size);
+  if(data.size() <= 20) {
+    debug("ASF::File::FilePrivate::CodecListObject::parse() -- data is too short.");
+    return;
+  }
+
+  unsigned int pos = 16;
+
+  const int count = data.toUInt32LE(pos);
+  pos += 4;
+
+  for(int i = 0; i < count; ++i) {
+
+    if(pos >= data.size())
+      break;
+
+    const CodecType type = static_cast<CodecType>(data.toUInt16LE(pos));
+    pos += 2;
+
+    int nameLength = data.toUInt16LE(pos);
+    pos += 2;
+
+    const unsigned int namePos = pos;
+    pos += nameLength * 2;
+
+    const int descLength = data.toUInt16LE(pos);
+    pos += 2;
+
+    const unsigned int descPos = pos;
+    pos += descLength * 2;
+
+    const int infoLength = data.toUInt16LE(pos);
+    pos += 2 + infoLength * 2;
+
+    if(type == CodecListObject::Audio) {
+      // First audio codec found.
+
+      const String name(data.mid(namePos, nameLength * 2), String::UTF16LE);
+      file->d->properties->setCodecName(name.stripWhiteSpace());
+
+      const String desc(data.mid(descPos, descLength * 2), String::UTF16LE);
+      file->d->properties->setCodecDescription(desc.stripWhiteSpace());
+
+      break;
+    }
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// static members
+////////////////////////////////////////////////////////////////////////////////
+
+bool ASF::File::isSupported(IOStream *stream)
+{
+  // An ASF file has to start with the designated GUID.
+
+  const ByteVector id = Utils::readHeader(stream, 16, false);
+  return (id == headerGuid);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-ASF::File::File(FileName file, bool readProperties, Properties::ReadStyle propertiesStyle)
-  : TagLib::File(file)
+ASF::File::File(FileName file, bool, AudioProperties::ReadStyle) :
+  TagLib::File(file),
+  d(new FilePrivate())
 {
-  d = new FilePrivate;
-  read(readProperties, propertiesStyle);
+  if(isOpen())
+    read();
 }
 
-ASF::File::File(IOStream *stream, bool readProperties, Properties::ReadStyle propertiesStyle)
-  : TagLib::File(stream)
+ASF::File::File(IOStream *stream, bool, AudioProperties::ReadStyle) :
+  TagLib::File(stream),
+  d(new FilePrivate())
 {
-  d = new FilePrivate;
-  read(readProperties, propertiesStyle);
+  if(isOpen())
+    read();
 }
 
 ASF::File::~File()
 {
-  for(unsigned int i = 0; i < d->objects.size(); i++) {
-    delete d->objects[i];
-  }
-  if(d->tag) {
-    delete d->tag;
-  }
-  if(d->properties) {
-    delete d->properties;
-  }
   delete d;
 }
 
 ASF::Tag *ASF::File::tag() const
 {
-  return d->tag;
+  return d->tag.get();
 }
 
-ASF::Properties *ASF::File::audioProperties() const
+ASF::AudioProperties *ASF::File::audioProperties() const
 {
-  return d->properties;
-}
-
-void ASF::File::read(bool /*readProperties*/, Properties::ReadStyle /*propertiesStyle*/)
-{
-  if(!isValid())
-    return;
-
-  ByteVector guid = readBlock(16);
-  if(guid != headerGuid) {
-    debug("ASF: Not an ASF file.");
-    setValid(false);
-    return;
-  }
-
-  d->tag = new ASF::Tag();
-  d->properties = new ASF::Properties();
-
-  bool ok;
-  d->size = readQWORD(&ok);
-  if(!ok) {
-    setValid(false);
-    return;
-  }
-  int numObjects = readDWORD(&ok);
-  if(!ok) {
-    setValid(false);
-    return;
-  }
-  seek(2, Current);
-
-  for(int i = 0; i < numObjects; i++) {
-    ByteVector guid = readBlock(16);
-    if(guid.size() != 16) {
-      setValid(false);
-      break;
-    }
-    long size = (long)readQWORD(&ok);
-    if(!ok) {
-      setValid(false);
-      break;
-    }
-    BaseObject *obj;
-    if(guid == filePropertiesGuid) {
-      obj = new FilePropertiesObject();
-    }
-    else if(guid == streamPropertiesGuid) {
-      obj = new StreamPropertiesObject();
-    }
-    else if(guid == contentDescriptionGuid) {
-      obj = new ContentDescriptionObject();
-    }
-    else if(guid == extendedContentDescriptionGuid) {
-      obj = new ExtendedContentDescriptionObject();
-    }
-    else if(guid == headerExtensionGuid) {
-      obj = new HeaderExtensionObject();
-    }
-    else {
-      if(guid == contentEncryptionGuid ||
-         guid == extendedContentEncryptionGuid ||
-         guid == advancedContentEncryptionGuid) {
-        d->properties->setEncrypted(true);
-      }
-      obj = new UnknownObject(guid);
-    }
-    obj->parse(this, size);
-    d->objects.append(obj);
-  }
+  return d->properties.get();
 }
 
 bool ASF::File::save()
@@ -487,40 +518,51 @@ bool ASF::File::save()
   }
 
   if(!d->contentDescriptionObject) {
-    d->contentDescriptionObject = new ContentDescriptionObject();
+    d->contentDescriptionObject.reset(new FilePrivate::ContentDescriptionObject());
     d->objects.append(d->contentDescriptionObject);
   }
   if(!d->extendedContentDescriptionObject) {
-    d->extendedContentDescriptionObject = new ExtendedContentDescriptionObject();
+    d->extendedContentDescriptionObject.reset(new FilePrivate::ExtendedContentDescriptionObject());
     d->objects.append(d->extendedContentDescriptionObject);
   }
   if(!d->headerExtensionObject) {
-    d->headerExtensionObject = new HeaderExtensionObject();
+    d->headerExtensionObject.reset(new FilePrivate::HeaderExtensionObject());
     d->objects.append(d->headerExtensionObject);
   }
   if(!d->metadataObject) {
-    d->metadataObject = new MetadataObject();
+    d->metadataObject.reset(new FilePrivate::MetadataObject());
     d->headerExtensionObject->objects.append(d->metadataObject);
   }
   if(!d->metadataLibraryObject) {
-    d->metadataLibraryObject = new MetadataLibraryObject();
+    d->metadataLibraryObject.reset(new FilePrivate::MetadataLibraryObject());
     d->headerExtensionObject->objects.append(d->metadataLibraryObject);
   }
 
-  ASF::AttributeListMap::ConstIterator it = d->tag->attributeListMap().begin();
-  for(; it != d->tag->attributeListMap().end(); it++) {
+  d->extendedContentDescriptionObject->attributeData.clear();
+  d->metadataObject->attributeData.clear();
+  d->metadataLibraryObject->attributeData.clear();
+
+  const AttributeListMap allAttributes = d->tag->attributeListMap();
+
+  for(AttributeListMap::ConstIterator it = allAttributes.begin(); it != allAttributes.end(); ++it) {
+
     const String &name = it->first;
     const AttributeList &attributes = it->second;
+
     bool inExtendedContentDescriptionObject = false;
     bool inMetadataObject = false;
-    for(unsigned int j = 0; j < attributes.size(); j++) {
-      const Attribute &attribute = attributes[j];
-      bool largeValue = attribute.dataSize() > 65535;
-      if(!inExtendedContentDescriptionObject && !largeValue && attribute.language() == 0 && attribute.stream() == 0) {
+
+    for(AttributeList::ConstIterator jt = attributes.begin(); jt != attributes.end(); ++jt) {
+
+      const Attribute &attribute = *jt;
+      const bool largeValue = (attribute.dataSize() > 65535);
+      const bool guid       = (attribute.type() == Attribute::GuidType);
+
+      if(!inExtendedContentDescriptionObject && !guid && !largeValue && attribute.language() == 0 && attribute.stream() == 0) {
         d->extendedContentDescriptionObject->attributeData.append(attribute.render(name));
         inExtendedContentDescriptionObject = true;
       }
-      else if(!inMetadataObject && !largeValue && attribute.language() == 0 && attribute.stream() != 0) {
+      else if(!inMetadataObject && !guid && !largeValue && attribute.language() == 0 && attribute.stream() != 0) {
         d->metadataObject->attributeData.append(attribute.render(name, 1));
         inMetadataObject = true;
       }
@@ -531,85 +573,105 @@ bool ASF::File::save()
   }
 
   ByteVector data;
-  for(unsigned int i = 0; i < d->objects.size(); i++) {
-    data.append(d->objects[i]->render(this));
+  for(FilePrivate::ObjectConstIterator it = d->objects.begin(); it != d->objects.end(); ++it) {
+    data.append((*it)->render(this));
   }
-  data = headerGuid + ByteVector::fromLongLong(data.size() + 30, false) + ByteVector::fromUInt(d->objects.size(), false) + ByteVector("\x01\x02", 2) + data;
-  insert(data, 0, (TagLib::ulong)d->size);
+
+  seek(16);
+  writeBlock(ByteVector::fromUInt64LE(data.size() + 30));
+  writeBlock(ByteVector::fromUInt32LE(d->objects.size()));
+  writeBlock(ByteVector("\x01\x02", 2));
+
+  insert(data, 30, static_cast<size_t>(d->headerSize - 30));
+
+  d->headerSize = data.size() + 30;
 
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// protected members
+// private members
 ////////////////////////////////////////////////////////////////////////////////
 
-int ASF::File::readBYTE(bool *ok)
+void ASF::File::read()
 {
-  ByteVector v = readBlock(1);
-  if(v.size() != 1) {
-    if(ok) *ok = false;
-    return 0;
-  }
-  if(ok) *ok = true;
-  return v[0];
-}
+  if(!isValid())
+    return;
 
-int ASF::File::readWORD(bool *ok)
-{
-  ByteVector v = readBlock(2);
-  if(v.size() != 2) {
-    if(ok) *ok = false;
-    return 0;
+  if(readBlock(16) != headerGuid) {
+    debug("ASF::File::read(): Not an ASF file.");
+    setValid(false);
+    return;
   }
-  if(ok) *ok = true;
-  return v.toUShort(false);
-}
 
-unsigned int ASF::File::readDWORD(bool *ok)
-{
-  ByteVector v = readBlock(4);
-  if(v.size() != 4) {
-    if(ok) *ok = false;
-    return 0;
+  d->tag.reset(new ASF::Tag());
+  d->properties.reset(new ASF::AudioProperties());
+
+  bool ok;
+  d->headerSize = readQWORD(this, &ok);
+  if(!ok) {
+    setValid(false);
+    return;
   }
-  if(ok) *ok = true;
-  return v.toUInt(false);
-}
-
-long long ASF::File::readQWORD(bool *ok)
-{
-  ByteVector v = readBlock(8);
-  if(v.size() != 8) {
-    if(ok) *ok = false;
-    return 0;
+  int numObjects = readDWORD(this, &ok);
+  if(!ok) {
+    setValid(false);
+    return;
   }
-  if(ok) *ok = true;
-  return v.toLongLong(false);
-}
+  seek(2, Current);
 
-String ASF::File::readString(int length)
-{
-  ByteVector data = readBlock(length);
-  unsigned int size = data.size();
-  while (size >= 2) {
-    if(data[size - 1] != '\0' || data[size - 2] != '\0') {
+  SHARED_PTR<FilePrivate::FilePropertiesObject>   filePropertiesObject;
+  SHARED_PTR<FilePrivate::StreamPropertiesObject> streamPropertiesObject;
+  for(int i = 0; i < numObjects; i++) {
+    const ByteVector guid = readBlock(16);
+    if(guid.size() != 16) {
+      setValid(false);
       break;
     }
-    size -= 2;
+    long size = (long)readQWORD(this, &ok);
+    if(!ok) {
+      setValid(false);
+      break;
+    }
+    SHARED_PTR<FilePrivate::BaseObject> obj;
+    if(guid == filePropertiesGuid) {
+      filePropertiesObject.reset(new FilePrivate::FilePropertiesObject());
+      obj = filePropertiesObject;
+    }
+    else if(guid == streamPropertiesGuid) {
+      streamPropertiesObject.reset(new FilePrivate::StreamPropertiesObject());
+      obj = streamPropertiesObject;
+    }
+    else if(guid == contentDescriptionGuid) {
+      d->contentDescriptionObject.reset(new FilePrivate::ContentDescriptionObject());
+      obj = d->contentDescriptionObject;
+    }
+    else if(guid == extendedContentDescriptionGuid) {
+      d->extendedContentDescriptionObject.reset(new FilePrivate::ExtendedContentDescriptionObject());
+      obj = d->extendedContentDescriptionObject;
+    }
+    else if(guid == headerExtensionGuid) {
+      d->headerExtensionObject.reset(new FilePrivate::HeaderExtensionObject());
+      obj = d->headerExtensionObject;
+    }
+    else if(guid == codecListGuid) {
+      obj.reset(new FilePrivate::CodecListObject());
+    }
+    else {
+      if(guid == contentEncryptionGuid ||
+         guid == extendedContentEncryptionGuid ||
+         guid == advancedContentEncryptionGuid) {
+        d->properties->setEncrypted(true);
+      }
+      obj.reset(new FilePrivate::UnknownObject(guid));
+    }
+    obj->parse(this, size);
+    d->objects.append(obj);
   }
-  if(size != data.size()) {
-    data.resize(size);
-  }
-  return String(data, String::UTF16LE);
-}
 
-ByteVector ASF::File::renderString(const String &str, bool includeLength)
-{
-  ByteVector data = str.data(String::UTF16LE) + ByteVector::fromShort(0, false);
-  if(includeLength) {
-    data = ByteVector::fromShort(data.size(), false) + data;
+  if(!filePropertiesObject || !streamPropertiesObject) {
+    debug("ASF::File::read(): Missing mandatory header objects.");
+    setValid(false);
+    return;
   }
-  return data;
 }
-

taglib/asf/asffile.h

@@ -53,12 +53,11 @@ namespace TagLib {
        * false, \a propertiesStyle is ignored.
        *
        * \note In the current implementation, both \a readProperties and
-       * \a propertiesStyle are ignored.
-       *
-       * \note TagLib will *not* take ownership of the stream, the caller is
-       * responsible for deleting it after the File object.
+       * \a propertiesStyle are ignored.  The audio properties are always
+       * read.
        */
-      File(FileName file, bool readProperties = true, Properties::ReadStyle propertiesStyle = Properties::Average);
+      File(FileName file, bool readProperties = true,
+           AudioProperties::ReadStyle propertiesStyle = AudioProperties::Average);
 
       /*!
        * Contructs an ASF file from \a file.  If \a readProperties is true the
@@ -66,12 +65,14 @@ namespace TagLib {
        * false, \a propertiesStyle is ignored.
        *
        * \note In the current implementation, both \a readProperties and
-       * \a propertiesStyle are ignored.
+       * \a propertiesStyle are ignored.  The audio properties are always
+       * read.
        *
        * \note TagLib will *not* take ownership of the stream, the caller is
        * responsible for deleting it after the File object.
        */
-      File(IOStream *stream, bool readProperties = true, Properties::ReadStyle propertiesStyle = Properties::Average);
+      File(IOStream *stream, bool readProperties = true,
+           AudioProperties::ReadStyle propertiesStyle = AudioProperties::Average);
 
       /*!
        * Destroys this instance of the File.
@@ -93,7 +94,7 @@ namespace TagLib {
       /*!
        * Returns the ASF audio properties for this file.
        */
-      virtual Properties *audioProperties() const;
+      virtual AudioProperties *audioProperties() const;
 
       /*!
        * Save the file.
@@ -102,28 +103,17 @@ namespace TagLib {
        */
       virtual bool save();
 
+      /*!
+       * Returns whether or not the given \a stream can be opened as an ASF
+       * file.
+       *
+       * \note This method is designed to do a quick check.  The result may
+       * not necessarily be correct.
+       */
+      static bool isSupported(IOStream *stream);
+
     private:
-
-      int readBYTE(bool *ok = 0);
-      int readWORD(bool *ok = 0);
-      unsigned int readDWORD(bool *ok = 0);
-      long long readQWORD(bool *ok = 0);
-      static ByteVector renderString(const String &str, bool includeLength = false);
-      String readString(int len);
-      void read(bool readProperties, Properties::ReadStyle propertiesStyle);
-
-      friend class Attribute;
-      friend class Picture;
-
-      class BaseObject;
-      class UnknownObject;
-      class FilePropertiesObject;
-      class StreamPropertiesObject;
-      class ContentDescriptionObject;
-      class ExtendedContentDescriptionObject;
-      class HeaderExtensionObject;
-      class MetadataObject;
-      class MetadataLibraryObject;
+      void read();
 
       class FilePrivate;
       FilePrivate *d;

taglib/asf/asfpicture.cpp

@@ -23,160 +23,170 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <taglib.h>
 #include <tdebug.h>
+#include <tsmartptr.h>
+
 #include "asfattribute.h"
 #include "asffile.h"
 #include "asfpicture.h"
+#include "asfutils.h"
 
 using namespace TagLib;
 
-class ASF::Picture::PicturePrivate : public RefCounter
+namespace
+{
+  struct PictureData
+  {
+    bool valid;
+    ASF::Picture::Type type;
+    String mimeType;
+    String description;
+    ByteVector picture;
+  };
+}
+
+class ASF::Picture::PicturePrivate
 {
 public:
-  bool valid;
-  Type type;
-  String mimeType;
-  String description;
-  ByteVector picture;
+  PicturePrivate() :
+    data(new PictureData()) {}
+
+  SHARED_PTR<PictureData> data;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // Picture class members
 ////////////////////////////////////////////////////////////////////////////////
 
-ASF::Picture::Picture()
+ASF::Picture::Picture() :
+  d(new PicturePrivate())
 {
-  d = new PicturePrivate();
-  d->valid = true;
+  d->data->valid = true;
 }
 
-ASF::Picture::Picture(const Picture& other)
-  : d(other.d)
+ASF::Picture::Picture(const Picture& other) :
+  d(new PicturePrivate(*other.d))
 {
-  d->ref();
 }
 
 ASF::Picture::~Picture()
 {
-  if(d->deref())
-    delete d;
+  delete d;
 }
 
 bool ASF::Picture::isValid() const
 {
-  return d->valid;
+  return d->data->valid;
 }
 
 String ASF::Picture::mimeType() const
 {
-  return d->mimeType;
+  return d->data->mimeType;
 }
 
 void ASF::Picture::setMimeType(const String &value)
 {
-  d->mimeType = value;
+  d->data->mimeType = value;
 }
 
 ASF::Picture::Type ASF::Picture::type() const
 {
-  return d->type;
+  return d->data->type;
 }
 
 void ASF::Picture::setType(const ASF::Picture::Type& t)
 {
-  d->type = t;
+  d->data->type = t;
 }
 
 String ASF::Picture::description() const
 {
-  return d->description;
+  return d->data->description;
 }
 
 void ASF::Picture::setDescription(const String &desc)
 {
-  d->description = desc;
+  d->data->description = desc;
 }
 
 ByteVector ASF::Picture::picture() const
 {
-  return d->picture;
+  return d->data->picture;
 }
 
 void ASF::Picture::setPicture(const ByteVector &p)
 {
-  d->picture = p;
+  d->data->picture = p;
 }
 
 int ASF::Picture::dataSize() const
 {
-  return
-    9 + (d->mimeType.length() + d->description.length()) * 2 +
-    d->picture.size();
+  return static_cast<int>(
+    9 + (d->data->mimeType.length() + d->data->description.length()) * 2 +
+    d->data->picture.size());
 }
 
 ASF::Picture& ASF::Picture::operator=(const ASF::Picture& other)
 {
-  if(other.d != d) {
-    if(d->deref())
-      delete d;
-    d = other.d;
-    d->ref();
-  }
+  Picture(other).swap(*this);
   return *this;
 }
 
+void ASF::Picture::swap(Picture &other)
+{
+  using std::swap;
+
+  swap(d, other.d);
+}
+
 ByteVector ASF::Picture::render() const
 {
   if(!isValid())
-    return ByteVector::null;
+    return ByteVector();
+
   return
-    ByteVector((char)d->type) +
-    ByteVector::fromUInt(d->picture.size(), false) +
-    ASF::File::renderString(d->mimeType) +
-    ASF::File::renderString(d->description) +
-    d->picture;
+    ByteVector((char)d->data->type) +
+    ByteVector::fromUInt32LE(d->data->picture.size()) +
+    renderString(d->data->mimeType) +
+    renderString(d->data->description) +
+    d->data->picture;
 }
 
 void ASF::Picture::parse(const ByteVector& bytes)
 {
-  d->valid = false;
+  d->data->valid = false;
   if(bytes.size() < 9)
     return;
-  int pos = 0;
-  d->type = (Type)bytes[0]; ++pos;
-  uint dataLen = bytes.mid(pos, 4).toUInt(false); pos+=4;
+  size_t pos = 0;
+  d->data->type = (Type)bytes[0]; ++pos;
+  const unsigned int dataLen = bytes.toUInt32LE(pos); pos+=4;
 
   const ByteVector nullStringTerminator(2, 0);
 
-  int endPos = bytes.find(nullStringTerminator, pos, 2);
-  if(endPos < 0)
+  size_t endPos = bytes.find(nullStringTerminator, pos, 2);
+  if(endPos == ByteVector::npos())
     return;
-  d->mimeType = String(bytes.mid(pos, endPos - pos), String::UTF16LE);
+  d->data->mimeType = String(bytes.mid(pos, endPos - pos), String::UTF16LE);
   pos = endPos+2;
 
   endPos = bytes.find(nullStringTerminator, pos, 2);
-  if(endPos < 0)
+  if(endPos == ByteVector::npos())
     return;
-  d->description = String(bytes.mid(pos, endPos - pos), String::UTF16LE);
+  d->data->description = String(bytes.mid(pos, endPos - pos), String::UTF16LE);
   pos = endPos+2;
 
   if(dataLen + pos != bytes.size())
     return;
 
-  d->picture = bytes.mid(pos, dataLen);
-  d->valid = true;
+  d->data->picture = bytes.mid(pos, dataLen);
+  d->data->valid = true;
   return;
 }
 
 ASF::Picture ASF::Picture::fromInvalid()
 {
   Picture ret;
-  ret.d->valid = false;
+  ret.d->data->valid = false;
   return ret;
 }
-

taglib/asf/asfpicture.h

@@ -35,6 +35,7 @@ namespace TagLib
 {
   namespace ASF
   {
+    class Attribute;
 
     //! An ASF attached picture interface implementation
 
@@ -46,7 +47,8 @@ namespace TagLib
      * \see Attribute::toPicture()
      * \see Attribute::Attribute(const Picture& picture)
      */
-    class TAGLIB_EXPORT Picture {
+    class TAGLIB_EXPORT Picture
+    {
     public:
 
       /*!
@@ -103,7 +105,7 @@ namespace TagLib
       Picture();
 
       /*!
-       * Construct an picture as a copy of \a other.
+       * Constructs an picture as a copy of \a other.
        */
       Picture(const Picture& other);
 
@@ -117,6 +119,11 @@ namespace TagLib
        */
       Picture& operator=(const Picture& other);
 
+      /*!
+       * Exchanges the content of the Picture by the content of \a other.
+       */
+      void swap(Picture &other);
+
       /*!
        * Returns true if Picture stores valid picture
        */
@@ -201,16 +208,15 @@ namespace TagLib
        */
       int dataSize() const;
 
-#ifndef DO_NOT_DOCUMENT
-      /* THIS IS PRIVATE, DON'T TOUCH IT! */
-      void parse(const ByteVector& );
-      static Picture fromInvalid();
+    private:
       friend class Attribute;
-#endif
-      private:
-        class PicturePrivate;
-        PicturePrivate *d;
-      };
+
+      void parse(const ByteVector &);
+      static Picture fromInvalid();
+
+      class PicturePrivate;
+      PicturePrivate *d;
+    };
   }
 }
 

taglib/asf/asfproperties.cpp

@@ -23,24 +23,32 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <tdebug.h>
 #include <tstring.h>
 #include "asfproperties.h"
 
 using namespace TagLib;
 
-class ASF::Properties::PropertiesPrivate
+class ASF::AudioProperties::PropertiesPrivate
 {
 public:
-  PropertiesPrivate(): length(0), bitrate(0), sampleRate(0), channels(0), encrypted(false) {}
+  PropertiesPrivate() :
+    length(0),
+    bitrate(0),
+    sampleRate(0),
+    channels(0),
+    bitsPerSample(0),
+    codec(ASF::AudioProperties::Unknown),
+    encrypted(false) {}
+
   int length;
   int bitrate;
   int sampleRate;
   int channels;
+  int bitsPerSample;
+  ASF::AudioProperties::Codec codec;
+  String codecName;
+  String codecDescription;
   bool encrypted;
 };
 
@@ -48,38 +56,68 @@ public:
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-ASF::Properties::Properties() : AudioProperties(AudioProperties::Average)
+ASF::AudioProperties::AudioProperties() :
+  TagLib::AudioProperties(),
+  d(new PropertiesPrivate())
 {
-  d = new PropertiesPrivate;
 }
 
-ASF::Properties::~Properties()
+ASF::AudioProperties::~AudioProperties()
 {
-  if(d)
-    delete d;
+  delete d;
 }
 
-int ASF::Properties::length() const
+int ASF::AudioProperties::length() const
+{
+  return lengthInSeconds();
+}
+
+int ASF::AudioProperties::lengthInSeconds() const
+{
+  return d->length / 1000;
+}
+
+int ASF::AudioProperties::lengthInMilliseconds() const
 {
   return d->length;
 }
 
-int ASF::Properties::bitrate() const
+int ASF::AudioProperties::bitrate() const
 {
   return d->bitrate;
 }
 
-int ASF::Properties::sampleRate() const
+int ASF::AudioProperties::sampleRate() const
 {
   return d->sampleRate;
 }
 
-int ASF::Properties::channels() const
+int ASF::AudioProperties::channels() const
 {
   return d->channels;
 }
 
-bool ASF::Properties::isEncrypted() const
+int ASF::AudioProperties::bitsPerSample() const
+{
+  return d->bitsPerSample;
+}
+
+ASF::AudioProperties::Codec ASF::AudioProperties::codec() const
+{
+  return d->codec;
+}
+
+String ASF::AudioProperties::codecName() const
+{
+  return d->codecName;
+}
+
+String ASF::AudioProperties::codecDescription() const
+{
+  return d->codecDescription;
+}
+
+bool ASF::AudioProperties::isEncrypted() const
 {
   return d->encrypted;
 }
@@ -88,28 +126,64 @@ bool ASF::Properties::isEncrypted() const
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
-void ASF::Properties::setLength(int length)
+void ASF::AudioProperties::setLengthInMilliseconds(int value)
 {
-  d->length = length;
+  d->length = value;
 }
 
-void ASF::Properties::setBitrate(int length)
+void ASF::AudioProperties::setBitrate(int value)
 {
-  d->bitrate = length;
+  d->bitrate = value;
 }
 
-void ASF::Properties::setSampleRate(int length)
+void ASF::AudioProperties::setSampleRate(int value)
 {
-  d->sampleRate = length;
+  d->sampleRate = value;
 }
 
-void ASF::Properties::setChannels(int length)
+void ASF::AudioProperties::setChannels(int value)
 {
-  d->channels = length;
+  d->channels = value;
 }
 
-void ASF::Properties::setEncrypted(bool encrypted)
+void ASF::AudioProperties::setBitsPerSample(int value)
 {
-  d->encrypted = encrypted;
+  d->bitsPerSample = value;
 }
 
+void ASF::AudioProperties::setCodec(int value)
+{
+  switch(value)
+  {
+  case 0x0160:
+    d->codec = WMA1;
+    break;
+  case 0x0161:
+    d->codec = WMA2;
+    break;
+  case 0x0162:
+    d->codec = WMA9Pro;
+    break;
+  case 0x0163:
+    d->codec = WMA9Lossless;
+    break;
+  default:
+    d->codec = Unknown;
+    break;
+  }
+}
+
+void ASF::AudioProperties::setCodecName(const String &value)
+{
+  d->codecName = value;
+}
+
+void ASF::AudioProperties::setCodecDescription(const String &value)
+{
+  d->codecDescription = value;
+}
+
+void ASF::AudioProperties::setEncrypted(bool value)
+{
+  d->encrypted = value;
+}

taglib/asf/asfproperties.h

@@ -34,37 +34,143 @@ namespace TagLib {
 
   namespace ASF {
 
+    class File;
+
     //! An implementation of ASF audio properties
-    class TAGLIB_EXPORT Properties : public AudioProperties
+    class TAGLIB_EXPORT AudioProperties : public TagLib::AudioProperties
     {
+      friend class File;
+
     public:
+      /*!
+       * Audio codec types can be used in ASF file.
+       */
+      enum Codec
+      {
+        /*!
+         * Couldn't detect the codec.
+         */
+        Unknown = 0,
+
+        /*!
+         * Windows Media Audio 1
+         */
+        WMA1,
+
+        /*!
+         * Windows Media Audio 2 or above
+         */
+        WMA2,
+
+        /*!
+         * Windows Media Audio 9 Professional
+         */
+        WMA9Pro,
+
+        /*!
+         * Windows Media Audio 9 Lossless
+         */
+        WMA9Lossless,
+      };
 
       /*!
-       * Create an instance of ASF::Properties.
+       * Creates an instance of ASF::AudioProperties.
        */
-      Properties();
+      AudioProperties();
 
       /*!
-       * Destroys this ASF::Properties instance.
+       * Destroys this ASF::AudioProperties instance.
        */
-      virtual ~Properties();
+      virtual ~AudioProperties();
 
-      // Reimplementations.
+      /*!
+       * Returns the length of the file in seconds.  The length is rounded down to
+       * the nearest whole second.
+       *
+       * \note This method is just an alias of lengthInSeconds().
+       *
+       * \deprecated
+       */
       virtual int length() const;
+
+      /*!
+       * Returns the length of the file in seconds.  The length is rounded down to
+       * the nearest whole second.
+       *
+       * \see lengthInMilliseconds()
+       */
+      virtual int lengthInSeconds() const;
+
+      /*!
+       * Returns the length of the file in milliseconds.
+       *
+       * \see lengthInSeconds()
+       */
+      virtual int lengthInMilliseconds() const;
+
+      /*!
+       * Returns the average bit rate of the file in kb/s.
+       */
       virtual int bitrate() const;
+
+      /*!
+       * Returns the sample rate in Hz.
+       */
       virtual int sampleRate() const;
+
+      /*!
+       * Returns the number of audio channels.
+       */
       virtual int channels() const;
+
+      /*!
+       * Returns the number of bits per audio sample.
+       */
+      int bitsPerSample() const;
+
+      /*!
+       * Returns the codec used in the file.
+       *
+       * \see codecName()
+       * \see codecDescription()
+       */
+      Codec codec() const;
+
+      /*!
+       * Returns the concrete codec name, for example "Windows Media Audio 9.1"
+       * used in the file if available, otherwise an empty string.
+       *
+       * \see codec()
+       * \see codecDescription()
+       */
+      String codecName() const;
+
+      /*!
+       * Returns the codec description, typically contains the encoder settings,
+       * for example "VBR Quality 50, 44kHz, stereo 1-pass VBR" if available,
+       * otherwise an empty string.
+       *
+       * \see codec()
+       * \see codecName()
+       */
+      String codecDescription() const;
+
+      /*!
+       * Returns whether or not the file is encrypted.
+       */
       bool isEncrypted() const;
 
-#ifndef DO_NOT_DOCUMENT
-      void setLength(int value);
+    private:
+      void setLengthInMilliseconds(int value);
       void setBitrate(int value);
       void setSampleRate(int value);
       void setChannels(int value);
+      void setBitsPerSample(int value);
+      void setCodec(int value);
+      void setCodecName(const String &value);
+      void setCodecDescription(const String &value);
       void setEncrypted(bool value);
-#endif
 
-    private:
       class PropertiesPrivate;
       PropertiesPrivate *d;
     };

taglib/asf/asftag.cpp

@@ -23,10 +23,8 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
+#include <tpicturemap.h>
+#include <tpropertymap.h>
 #include "asftag.h"
 
 using namespace TagLib;
@@ -42,16 +40,15 @@ public:
   AttributeListMap attributeListMap;
 };
 
-ASF::Tag::Tag()
-: TagLib::Tag()
+ASF::Tag::Tag() :
+  TagLib::Tag(),
+  d(new TagPrivate())
 {
-  d = new TagPrivate;
 }
 
 ASF::Tag::~Tag()
 {
-  if(d)
-    delete d;
+  delete d;
 }
 
 String ASF::Tag::title() const
@@ -68,7 +65,7 @@ String ASF::Tag::album() const
 {
   if(d->attributeListMap.contains("WM/AlbumTitle"))
     return d->attributeListMap["WM/AlbumTitle"][0].toString();
-  return String::null;
+  return String();
 }
 
 String ASF::Tag::copyright() const
@@ -111,7 +108,92 @@ String ASF::Tag::genre() const
 {
   if(d->attributeListMap.contains("WM/Genre"))
     return d->attributeListMap["WM/Genre"][0].toString();
-  return String::null;
+  return String();
+}
+
+PictureMap ASF::Tag::pictures() const
+{
+  PictureMap map;
+  if(d->attributeListMap.contains("WM/Picture")) {
+    AttributeList list = d->attributeListMap["WM/Picture"];
+    for(AttributeList::ConstIterator it = list.begin();
+        it != list.end();
+        ++it) {
+      ASF::Picture asfPicture = (*it).toPicture();
+      TagLib::Picture::Type type;
+      switch(asfPicture.type()) {
+      case ASF::Picture::FileIcon:
+        type = TagLib::Picture::FileIcon;
+        break;
+      case ASF::Picture::OtherFileIcon:
+        type = TagLib::Picture::OtherFileIcon;
+        break;
+      case ASF::Picture::FrontCover:
+        type = TagLib::Picture::FrontCover;
+        break;
+      case ASF::Picture::BackCover:
+        type = TagLib::Picture::BackCover;
+        break;
+      case ASF::Picture::LeafletPage:
+        type = TagLib::Picture::LeafletPage;
+        break;
+      case ASF::Picture::Media:
+        type = TagLib::Picture::Media;
+        break;
+      case ASF::Picture::LeadArtist:
+        type = TagLib::Picture::LeadArtist;
+        break;
+      case ASF::Picture::Artist:
+        type = TagLib::Picture::Artist;
+        break;
+      case ASF::Picture::Conductor:
+        type = TagLib::Picture::Conductor;
+        break;
+      case ASF::Picture::Band:
+        type = TagLib::Picture::Band;
+        break;
+      case ASF::Picture::Composer:
+        type = TagLib::Picture::Composer;
+        break;
+      case ASF::Picture::Lyricist:
+        type = TagLib::Picture::Lyricist;
+        break;
+      case ASF::Picture::RecordingLocation:
+        type = TagLib::Picture::RecordingLocation;
+        break;
+      case ASF::Picture::DuringRecording:
+        type = TagLib::Picture::DuringRecording;
+        break;
+      case ASF::Picture::DuringPerformance:
+        type = TagLib::Picture::DuringPerformance;
+        break;
+      case ASF::Picture::MovieScreenCapture:
+        type = TagLib::Picture::MovieScreenCapture;
+        break;
+      case ASF::Picture::ColouredFish:
+        type = TagLib::Picture::ColouredFish;
+        break;
+      case ASF::Picture::Illustration:
+        type = TagLib::Picture::Illustration;
+        break;
+      case ASF::Picture::BandLogo:
+        type = TagLib::Picture::BandLogo;
+        break;
+      case ASF::Picture::PublisherLogo:
+        type = TagLib::Picture::PublisherLogo;
+        break;
+      default:
+        type = TagLib::Picture::Other;
+        break;
+      }
+      TagLib::Picture picture(asfPicture.picture(),
+                              type,
+                              asfPicture.mimeType(),
+                              asfPicture.description());
+      map.insert(picture);
+    }
+  }
+  return PictureMap(map);
 }
 
 void ASF::Tag::setTitle(const String &value)
@@ -149,26 +231,127 @@ void ASF::Tag::setGenre(const String &value)
   setAttribute("WM/Genre", value);
 }
 
-void ASF::Tag::setYear(uint value)
+void ASF::Tag::setYear(unsigned int value)
 {
   setAttribute("WM/Year", String::number(value));
 }
 
-void ASF::Tag::setTrack(uint value)
+void ASF::Tag::setTrack(unsigned int value)
 {
   setAttribute("WM/TrackNumber", String::number(value));
 }
 
+void ASF::Tag::setPictures(const PictureMap &l)
+{
+    removeItem("WM/Picture");
+    for(PictureMap::ConstIterator pictureMapIt = l.begin();
+        pictureMapIt != l.end();
+        ++pictureMapIt)
+    {
+        PictureList list = pictureMapIt->second;
+        for( PictureList::ConstIterator pictureListIt = list.begin();
+             pictureListIt != list.end();
+             ++pictureListIt)
+        {
+            const TagLib::Picture picture = (*pictureListIt);
+            ASF::Picture asfPicture;
+            asfPicture.setPicture(picture.data());
+            asfPicture.setMimeType(picture.mime());
+            asfPicture.setDescription(picture.description());
+            switch (picture.type()) {
+            case TagLib::Picture::Other:
+                asfPicture.setType(ASF::Picture::Other);
+                break;
+            case TagLib::Picture::FileIcon:
+                asfPicture.setType(ASF::Picture::FileIcon);
+                break;
+            case TagLib::Picture::OtherFileIcon:
+                asfPicture.setType(ASF::Picture::OtherFileIcon);
+                break;
+            case TagLib::Picture::FrontCover:
+                asfPicture.setType(ASF::Picture::FrontCover);
+                break;
+            case TagLib::Picture::BackCover:
+                asfPicture.setType(ASF::Picture::BackCover);
+                break;
+            case TagLib::Picture::LeafletPage:
+                asfPicture.setType(ASF::Picture::LeafletPage);
+                break;
+            case TagLib::Picture::Media:
+                asfPicture.setType(ASF::Picture::Media);
+                break;
+            case TagLib::Picture::LeadArtist:
+                asfPicture.setType(ASF::Picture::LeadArtist);
+                break;
+            case TagLib::Picture::Artist:
+                asfPicture.setType(ASF::Picture::Artist);
+                break;
+            case TagLib::Picture::Conductor:
+                asfPicture.setType(ASF::Picture::Conductor);
+                break;
+            case TagLib::Picture::Band:
+                asfPicture.setType(ASF::Picture::Band);
+                break;
+            case TagLib::Picture::Composer:
+                asfPicture.setType(ASF::Picture::Composer);
+                break;
+            case TagLib::Picture::Lyricist:
+                asfPicture.setType(ASF::Picture::Lyricist);
+                break;
+            case TagLib::Picture::RecordingLocation:
+                asfPicture.setType(ASF::Picture::RecordingLocation);
+                break;
+            case TagLib::Picture::DuringRecording:
+                asfPicture.setType(ASF::Picture::DuringRecording);
+                break;
+            case TagLib::Picture::DuringPerformance:
+                asfPicture.setType(ASF::Picture::DuringPerformance);
+                break;
+            case TagLib::Picture::MovieScreenCapture:
+                asfPicture.setType(ASF::Picture::MovieScreenCapture);
+                break;
+            case TagLib::Picture::ColouredFish:
+                asfPicture.setType(ASF::Picture::ColouredFish);
+                break;
+            case TagLib::Picture::Illustration:
+                asfPicture.setType(ASF::Picture::Illustration);
+                break;
+            case TagLib::Picture::BandLogo:
+                asfPicture.setType(ASF::Picture::BandLogo);
+                break;
+            case TagLib::Picture::PublisherLogo:
+                asfPicture.setType(ASF::Picture::PublisherLogo);
+                break;
+            }
+            addAttribute("WM/Picture", Attribute(asfPicture));
+        }
+    }
+
+}
+
 ASF::AttributeListMap& ASF::Tag::attributeListMap()
 {
   return d->attributeListMap;
 }
 
+const ASF::AttributeListMap &ASF::Tag::attributeListMap() const
+{
+  return d->attributeListMap;
+}
+
+bool ASF::Tag::contains(const String &key) const
+{
+  return d->attributeListMap.contains(key);
+}
+
 void ASF::Tag::removeItem(const String &key)
 {
-  AttributeListMap::Iterator it = d->attributeListMap.find(key);
-  if(it != d->attributeListMap.end())
-    d->attributeListMap.erase(it);
+  d->attributeListMap.erase(key);
+}
+
+ASF::AttributeList ASF::Tag::attribute(const String &name) const
+{
+  return d->attributeListMap[name];
 }
 
 void ASF::Tag::setAttribute(const String &name, const Attribute &attribute)
@@ -178,6 +361,11 @@ void ASF::Tag::setAttribute(const String &name, const Attribute &attribute)
   d->attributeListMap.insert(name, value);
 }
 
+void ASF::Tag::setAttribute(const String &name, const AttributeList &values)
+{
+  d->attributeListMap.insert(name, values);
+}
+
 void ASF::Tag::addAttribute(const String &name, const Attribute &attribute)
 {
   if(d->attributeListMap.contains(name)) {
@@ -196,3 +384,169 @@ bool ASF::Tag::isEmpty() const
          d->attributeListMap.isEmpty();
 }
 
+namespace
+{
+  const char *keyTranslation[][2] = {
+    { "WM/AlbumTitle", "ALBUM" },
+    { "WM/AlbumArtist", "ALBUMARTIST" },
+    { "WM/Composer", "COMPOSER" },
+    { "WM/Writer", "WRITER" },
+    { "WM/Conductor", "CONDUCTOR" },
+    { "WM/ModifiedBy", "REMIXER" },
+    { "WM/Year", "DATE" },
+    { "WM/OriginalReleaseYear", "ORIGINALDATE" },
+    { "WM/Producer", "PRODUCER" },
+    { "WM/ContentGroupDescription", "GROUPING" },
+    { "WM/SubTitle", "SUBTITLE" },
+    { "WM/SetSubTitle", "DISCSUBTITLE" },
+    { "WM/TrackNumber", "TRACKNUMBER" },
+    { "WM/PartOfSet", "DISCNUMBER" },
+    { "WM/Genre", "GENRE" },
+    { "WM/BeatsPerMinute", "BPM" },
+    { "WM/Mood", "MOOD" },
+    { "WM/ISRC", "ISRC" },
+    { "WM/Lyrics", "LYRICS" },
+    { "WM/Media", "MEDIA" },
+    { "WM/Publisher", "LABEL" },
+    { "WM/CatalogNo", "CATALOGNUMBER" },
+    { "WM/Barcode", "BARCODE" },
+    { "WM/EncodedBy", "ENCODEDBY" },
+    { "WM/AlbumSortOrder", "ALBUMSORT" },
+    { "WM/AlbumArtistSortOrder", "ALBUMARTISTSORT" },
+    { "WM/ArtistSortOrder", "ARTISTSORT" },
+    { "WM/TitleSortOrder", "TITLESORT" },
+    { "WM/Script", "SCRIPT" },
+    { "WM/Language", "LANGUAGE" },
+    { "MusicBrainz/Track Id", "MUSICBRAINZ_TRACKID" },
+    { "MusicBrainz/Artist Id", "MUSICBRAINZ_ARTISTID" },
+    { "MusicBrainz/Album Id", "MUSICBRAINZ_ALBUMID" },
+    { "MusicBrainz/Album Artist Id", "MUSICBRAINZ_ALBUMARTISTID" },
+    { "MusicBrainz/Release Group Id", "MUSICBRAINZ_RELEASEGROUPID" },
+    { "MusicBrainz/Work Id", "MUSICBRAINZ_WORKID" },
+    { "MusicIP/PUID", "MUSICIP_PUID" },
+    { "Acoustid/Id", "ACOUSTID_ID" },
+    { "Acoustid/Fingerprint", "ACOUSTID_FINGERPRINT" },
+  };
+  const size_t keyTranslationSize = sizeof(keyTranslation) / sizeof(keyTranslation[0]);
+
+  String translateKey(const String &key)
+  {
+    for(size_t i = 0; i < keyTranslationSize; ++i) {
+      if(key == keyTranslation[i][0])
+        return keyTranslation[i][1];
+    }
+
+    return String();
+  }
+}
+
+PropertyMap ASF::Tag::properties() const
+{
+  PropertyMap props;
+
+  if(!d->title.isEmpty()) {
+    props["TITLE"] = d->title;
+  }
+  if(!d->artist.isEmpty()) {
+    props["ARTIST"] = d->artist;
+  }
+  if(!d->copyright.isEmpty()) {
+    props["COPYRIGHT"] = d->copyright;
+  }
+  if(!d->comment.isEmpty()) {
+    props["COMMENT"] = d->comment;
+  }
+
+  ASF::AttributeListMap::ConstIterator it = d->attributeListMap.begin();
+  for(; it != d->attributeListMap.end(); ++it) {
+    const String key = translateKey(it->first);
+    if(!key.isEmpty()) {
+      AttributeList::ConstIterator it2 = it->second.begin();
+      for(; it2 != it->second.end(); ++it2) {
+        if(key == "TRACKNUMBER") {
+          if(it2->type() == ASF::Attribute::DWordType)
+            props.insert(key, String::number(it2->toUInt()));
+          else
+            props.insert(key, it2->toString());
+        }
+        else {
+          props.insert(key, it2->toString());
+        }
+      }
+    }
+    else {
+      props.unsupportedData().append(it->first);
+    }
+  }
+  return props;
+}
+
+void ASF::Tag::removeUnsupportedProperties(const StringList &props)
+{
+  StringList::ConstIterator it = props.begin();
+  for(; it != props.end(); ++it)
+    d->attributeListMap.erase(*it);
+}
+
+PropertyMap ASF::Tag::setProperties(const PropertyMap &props)
+{
+  static Map<String, String> reverseKeyMap;
+  if(reverseKeyMap.isEmpty()) {
+    int numKeys = sizeof(keyTranslation) / sizeof(keyTranslation[0]);
+    for(int i = 0; i < numKeys; i++) {
+      reverseKeyMap[keyTranslation[i][1]] = keyTranslation[i][0];
+    }
+  }
+
+  PropertyMap origProps = properties();
+  PropertyMap::ConstIterator it = origProps.begin();
+  for(; it != origProps.end(); ++it) {
+    if(!props.contains(it->first) || props[it->first].isEmpty()) {
+      if(it->first == "TITLE") {
+        d->title.clear();
+      }
+      else if(it->first == "ARTIST") {
+        d->artist.clear();
+      }
+      else if(it->first == "COMMENT") {
+        d->comment.clear();
+      }
+      else if(it->first == "COPYRIGHT") {
+        d->copyright.clear();
+      }
+      else {
+        d->attributeListMap.erase(reverseKeyMap[it->first]);
+      }
+    }
+  }
+
+  PropertyMap ignoredProps;
+  it = props.begin();
+  for(; it != props.end(); ++it) {
+    if(reverseKeyMap.contains(it->first)) {
+      String name = reverseKeyMap[it->first];
+      removeItem(name);
+      StringList::ConstIterator it2 = it->second.begin();
+      for(; it2 != it->second.end(); ++it2) {
+        addAttribute(name, *it2);
+      }
+    }
+    else if(it->first == "TITLE") {
+      d->title = it->second.toString();
+    }
+    else if(it->first == "ARTIST") {
+      d->artist = it->second.toString();
+    }
+    else if(it->first == "COMMENT") {
+      d->comment = it->second.toString();
+    }
+    else if(it->first == "COPYRIGHT") {
+      d->copyright = it->second.toString();
+    }
+    else {
+      ignoredProps.insert(it->first, it->second);
+    }
+  }
+
+  return ignoredProps;
+}

taglib/asf/asftag.h

@@ -90,13 +90,15 @@ namespace TagLib {
       /*!
        * Returns the year; if there is no year set, this will return 0.
        */
-      virtual uint year() const;
+      virtual unsigned int year() const;
 
       /*!
        * Returns the track number; if there is no track number set, this will
        * return 0.
        */
-      virtual uint track() const;
+      virtual unsigned int track() const;
+
+      virtual PictureMap pictures() const;
 
       /*!
        * Sets the title to \a s.
@@ -137,12 +139,14 @@ namespace TagLib {
       /*!
        * Sets the year to \a i.  If \a s is 0 then this value will be cleared.
        */
-      virtual void setYear(uint i);
+      virtual void setYear(unsigned int i);
 
       /*!
        * Sets the track to \a i.  If \a s is 0 then this value will be cleared.
        */
-      virtual void setTrack(uint i);
+      virtual void setTrack(unsigned int i);
+
+      virtual void setPictures(const PictureMap &l);
 
       /*!
        * Returns true if the tag does not contain any data.  This should be
@@ -152,30 +156,53 @@ namespace TagLib {
       virtual bool isEmpty() const;
 
       /*!
-       * Returns a reference to the item list map.  This is an AttributeListMap of
-       * all of the items in the tag.
-       *
-       * This is the most powerfull structure for accessing the items of the tag.
+       * \deprecated
        */
       AttributeListMap &attributeListMap();
 
+      /*!
+       * Returns a reference to the item list map.  This is an AttributeListMap of
+       * all of the items in the tag.
+       */
+      const AttributeListMap &attributeListMap() const;
+
+      /*!
+       * \return True if a value for \a attribute is currently set.
+       */
+      bool contains(const String &name) const;
+
       /*!
        * Removes the \a key attribute from the tag
        */
       void removeItem(const String &name);
 
+      /*!
+       * \return The list of values for the key \a name, or an empty list if no
+       * values have been set.
+       */
+      AttributeList attribute(const String &name) const;
+
       /*!
        * Sets the \a key attribute to the value of \a attribute. If an attribute
        * with the \a key is already present, it will be replaced.
        */
       void setAttribute(const String &name, const Attribute &attribute);
 
+      /*!
+       * Sets multiple \a values to the key \a name.
+       */
+      void setAttribute(const String &name, const AttributeList &values);
+
       /*!
        * Sets the \a key attribute to the value of \a attribute. If an attribute
        * with the \a key is already present, it will be added to the list.
        */
       void addAttribute(const String &name, const Attribute &attribute);
 
+      PropertyMap properties() const;
+      void removeUnsupportedProperties(const StringList& properties);
+      PropertyMap setProperties(const PropertyMap &properties);
+
     private:
 
       class TagPrivate;

taglib/asf/asfutils.h

@@ -0,0 +1,104 @@
+/***************************************************************************
+    copyright            : (C) 2015 by Tsuda Kageyu
+    email                : tsuda.kageyu@gmail.com
+ ***************************************************************************/
+
+/***************************************************************************
+ *   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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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_ASFUTILS_H
+#define TAGLIB_ASFUTILS_H
+
+// THIS FILE IS NOT A PART OF THE TAGLIB API
+
+#ifndef DO_NOT_DOCUMENT  // tell Doxygen not to document this header
+
+namespace TagLib
+{
+  namespace ASF
+  {
+    namespace
+    {
+
+      inline unsigned short readWORD(File *file, bool *ok = 0)
+      {
+        const ByteVector v = file->readBlock(2);
+        if(v.size() != 2) {
+          if(ok) *ok = false;
+          return 0;
+        }
+        if(ok) *ok = true;
+        return v.toUInt16LE(0);
+      }
+
+      inline unsigned int readDWORD(File *file, bool *ok = 0)
+      {
+        const ByteVector v = file->readBlock(4);
+        if(v.size() != 4) {
+          if(ok) *ok = false;
+          return 0;
+        }
+        if(ok) *ok = true;
+        return v.toUInt32LE(0);
+      }
+
+      inline long long readQWORD(File *file, bool *ok = 0)
+      {
+        const ByteVector v = file->readBlock(8);
+        if(v.size() != 8) {
+          if(ok) *ok = false;
+          return 0;
+        }
+        if(ok) *ok = true;
+        return v.toInt64LE(0);
+      }
+
+      inline String readString(File *file, int length)
+      {
+        ByteVector data = file->readBlock(length);
+        size_t size = data.size();
+        while (size >= 2) {
+          if(data[size - 1] != '\0' || data[size - 2] != '\0') {
+            break;
+          }
+          size -= 2;
+        }
+        if(size != data.size()) {
+          data.resize(size);
+        }
+        return String(data, String::UTF16LE);
+      }
+
+      inline ByteVector renderString(const String &str, bool includeLength = false)
+      {
+        ByteVector data = str.data(String::UTF16LE) + ByteVector::fromUInt16LE(0);
+        if(includeLength) {
+          data = ByteVector::fromUInt16LE(data.size()) + data;
+        }
+        return data;
+      }
+
+    }
+  }
+}
+
+#endif
+
+#endif

taglib/audioproperties.cpp

@@ -23,29 +23,34 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
+#include <tstringlist.h>
+
 #include "audioproperties.h"
 
 using namespace TagLib;
 
-class AudioProperties::AudioPropertiesPrivate
-{
-
-};
-
 ////////////////////////////////////////////////////////////////////////////////
 // public methods
 ////////////////////////////////////////////////////////////////////////////////
 
 AudioProperties::~AudioProperties()
 {
+}
 
+String AudioProperties::toString() const
+{
+  StringList desc;
+  desc.append("Audio");
+  desc.append(String::number(length()) + " seconds");
+  desc.append(String::number(bitrate()) + " kbps");
+  return desc.toString(", ");
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // protected methods
 ////////////////////////////////////////////////////////////////////////////////
 
-AudioProperties::AudioProperties(ReadStyle)
+AudioProperties::AudioProperties() :
+  d(0)
 {
-
 }

taglib/audioproperties.h

@@ -27,6 +27,7 @@
 #define TAGLIB_AUDIOPROPERTIES_H
 
 #include "taglib_export.h"
+#include "tstring.h"
 
 namespace TagLib {
 
@@ -34,7 +35,7 @@ namespace TagLib {
 
   /*!
    * The values here are common to most audio formats.  For more specific, codec
-   * dependant values, please see see the subclasses APIs.  This is meant to
+   * dependent values, please see see the subclasses APIs.  This is meant to
    * compliment the TagLib::File and TagLib::Tag APIs in providing a simple
    * interface that is sufficient for most applications.
    */
@@ -69,6 +70,21 @@ namespace TagLib {
      */
     virtual int length() const = 0;
 
+    /*!
+     * Returns the length of the file in seconds.  The length is rounded down to
+     * the nearest whole second.
+     *
+     * \see lengthInMilliseconds()
+     */
+    virtual int lengthInSeconds() const = 0;
+
+    /*!
+     * Returns the length of the file in milliseconds.
+     *
+     * \see lengthInSeconds()
+     */
+    virtual int lengthInMilliseconds() const = 0;
+
     /*!
      * Returns the most appropriate bit rate for the file in kb/s.  For constant
      * bitrate formats this is simply the bitrate of the file.  For variable
@@ -86,23 +102,27 @@ namespace TagLib {
      */
     virtual int channels() const = 0;
 
+    /*!
+     * Returns description of the audio file.
+     */
+    virtual String toString() const;
+
   protected:
 
     /*!
-     * Construct an audio properties instance.  This is protected as this class
+     * Constructs an audio properties instance.  This is protected as this class
      * should not be instantiated directly, but should be instantiated via its
      * subclasses and can be fetched from the FileRef or File APIs.
-     *
-     * \see ReadStyle
      */
-    AudioProperties(ReadStyle style);
+    AudioProperties();
 
   private:
+    // Noncopyable. Derived classes as well.
     AudioProperties(const AudioProperties &);
     AudioProperties &operator=(const AudioProperties &);
 
-    class AudioPropertiesPrivate;
-    AudioPropertiesPrivate *d;
+    class PropertiesPrivate;
+    PropertiesPrivate *d;
   };
 
 }

taglib/dsdiff/dsdiffdiintag.cpp

@@ -0,0 +1,166 @@
+/***************************************************************************
+ copyright            : (C) 2016 by Damien Plisson, Audirvana
+ email                : damien78@audirvana.com
+ ***************************************************************************/
+
+/***************************************************************************
+ *   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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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/                                           *
+ ***************************************************************************/
+
+#include "dsdiffdiintag.h"
+#include "tstringlist.h"
+#include "tpropertymap.h"
+#include "tpicturemap.h"
+
+using namespace TagLib;
+using namespace DSDIFF::DIIN;
+
+class DSDIFF::DIIN::Tag::TagPrivate
+{
+public:
+  TagPrivate()
+  {
+  }
+
+  String title;
+  String artist;
+};
+
+DSDIFF::DIIN::Tag::Tag() : TagLib::Tag()
+{
+  d = new TagPrivate;
+}
+
+DSDIFF::DIIN::Tag::~Tag()
+{
+  delete d;
+}
+
+String DSDIFF::DIIN::Tag::title() const
+{
+  return d->title;
+}
+
+String DSDIFF::DIIN::Tag::artist() const
+{
+  return d->artist;
+}
+
+String DSDIFF::DIIN::Tag::album() const
+{
+  return String();
+}
+
+String DSDIFF::DIIN::Tag::comment() const
+{
+  return String();
+}
+
+String DSDIFF::DIIN::Tag::genre() const
+{
+  return String();
+}
+
+unsigned int DSDIFF::DIIN::Tag::year() const
+{
+  return 0;
+}
+
+unsigned int DSDIFF::DIIN::Tag::track() const
+{
+  return 0;
+}
+
+PictureMap DSDIFF::DIIN::Tag::pictures() const
+{
+  return PictureMap();
+}
+
+void DSDIFF::DIIN::Tag::setTitle(const String &title)
+{
+  d->title = title;
+}
+
+void DSDIFF::DIIN::Tag::setArtist(const String &artist)
+{
+  d->artist = artist;
+}
+
+void DSDIFF::DIIN::Tag::setAlbum(const String &)
+{
+}
+
+void DSDIFF::DIIN::Tag::setComment(const String &)
+{
+}
+
+void DSDIFF::DIIN::Tag::setGenre(const String &)
+{
+}
+
+void DSDIFF::DIIN::Tag::setYear(unsigned int)
+{
+}
+
+void DSDIFF::DIIN::Tag::setTrack(unsigned int)
+{
+}
+
+void DSDIFF::DIIN::Tag::setPictures( const PictureMap& l )
+{
+}
+
+PropertyMap DSDIFF::DIIN::Tag::properties() const
+{
+  PropertyMap properties;
+  properties["TITLE"] = d->title;
+  properties["ARTIST"] = d->artist;
+  return properties;
+}
+
+PropertyMap DSDIFF::DIIN::Tag::setProperties(const PropertyMap &origProps)
+{
+  PropertyMap properties(origProps);
+  properties.removeEmpty();
+  StringList oneValueSet;
+
+  if(properties.contains("TITLE")) {
+    d->title = properties["TITLE"].front();
+    oneValueSet.append("TITLE");
+  } else
+    d->title = String();
+
+  if(properties.contains("ARTIST")) {
+    d->artist = properties["ARTIST"].front();
+    oneValueSet.append("ARTIST");
+  } else
+    d->artist = String();
+
+  // for each tag that has been set above, remove the first entry in the corresponding
+  // value list. The others will be returned as unsupported by this format.
+  for(StringList::Iterator it = oneValueSet.begin(); it != oneValueSet.end(); ++it) {
+    if(properties[*it].size() == 1)
+      properties.erase(*it);
+    else
+      properties[*it].erase(properties[*it].begin());
+  }
+
+  return properties;
+}
+

taglib/dsdiff/dsdiffdiintag.h

@@ -0,0 +1,160 @@
+/***************************************************************************
+ copyright            : (C) 2016 by Damien Plisson, Audirvana
+ email                : damien78@audirvana.com
+ ***************************************************************************/
+
+/***************************************************************************
+ *   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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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_DSDIFFDIINTAG_H
+#define TAGLIB_DSDIFFDIINTAG_H
+
+#include "tag.h"
+
+namespace TagLib {
+
+  namespace DSDIFF {
+
+    namespace DIIN {
+
+      /*!
+       * Tags from the Edited Master Chunk Info
+       *
+       * Only Title and Artist tags are supported
+       */
+      class TAGLIB_EXPORT Tag : public TagLib::Tag
+      {
+      public:
+        Tag();
+        virtual ~Tag();
+
+        /*!
+         * Returns the track name; if no track name is present in the tag
+         * String() will be returned.
+         */
+        virtual String title() const;
+
+        /*!
+         * Returns the artist name; if no artist name is present in the tag
+         * String() will be returned.
+         */
+        virtual String artist() const;
+
+        /*!
+         * Not supported.  Therefore always returns String().
+         */
+        virtual String album() const;
+
+        /*!
+         * Not supported.  Therefore always returns String().
+         */
+        virtual String comment() const;
+
+        /*!
+         * Not supported.  Therefore always returns String().
+         */
+        virtual String genre() const;
+
+        /*!
+         * Not supported.  Therefore always returns 0.
+         */
+        virtual unsigned int year() const;
+
+        /*!
+         * Not supported.  Therefore always returns 0.
+         */
+        virtual unsigned int track() const;
+
+        /*!
+         * Not supported.  Therefore always returns an empty list.
+         */
+        virtual PictureMap pictures() const;
+
+        /*!
+         * Sets the title to \a title.  If \a title is String() then this
+         * value will be cleared.
+         */
+        virtual void setTitle(const String &title);
+
+        /*!
+         * Sets the artist to \a artist.  If \a artist is String() then this
+         * value will be cleared.
+         */
+        virtual void setArtist(const String &artist);
+
+        /*!
+         * Not supported and therefore ignored.
+         */
+        virtual void setAlbum(const String &album);
+
+        /*!
+         * Not supported and therefore ignored.
+         */
+        virtual void setComment(const String &comment);
+
+        /*!
+         * Not supported and therefore ignored.
+         */
+        virtual void setGenre(const String &genre);
+
+        /*!
+         * Not supported and therefore ignored.
+         */
+        virtual void setYear(unsigned int year);
+
+        /*!
+         * Not supported and therefore ignored.
+         */
+        virtual void setTrack(unsigned int track);
+
+        /*!
+         * Not supported and therefore ignored.
+         */
+        virtual void setPictures( const PictureMap& l );
+
+        /*!
+         * Implements the unified property interface -- export function.
+         * Since the DIIN tag is very limited, the exported map is as well.
+         */
+        PropertyMap properties() const;
+
+        /*!
+         * Implements the unified property interface -- import function.
+         * Because of the limitations of the DIIN file tag, any tags besides
+         * TITLE and ARTIST, will be
+         * returned. Additionally, if the map contains tags with multiple values,
+         * all but the first will be contained in the returned map of unsupported
+         * properties.
+         */
+        PropertyMap setProperties(const PropertyMap &);
+
+      private:
+        Tag(const Tag &);
+        Tag &operator=(const Tag &);
+
+        class TagPrivate;
+        TagPrivate *d;
+      };
+    }
+  }
+}
+
+#endif
+

taglib/dsdiff/dsdifffile.cpp

@@ -0,0 +1,844 @@
+/***************************************************************************
+ copyright            : (C) 2016 by Damien Plisson, Audirvana
+ email                : damien78@audirvana.com
+ ***************************************************************************/
+
+/***************************************************************************
+ *   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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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/                                           *
+ ***************************************************************************/
+
+#include <tbytevector.h>
+#include <tdebug.h>
+#include <id3v2tag.h>
+#include <tstringlist.h>
+#include <tpropertymap.h>
+#include <tagutils.h>
+#include <tsmartptr.h>
+
+#include "tagunion.h"
+#include "dsdifffile.h"
+
+using namespace TagLib;
+
+struct Chunk64
+{
+  ByteVector name;
+  unsigned long long offset;
+  unsigned long long size;
+  char padding;
+};
+
+namespace
+{
+  enum {
+    ID3v2Index = 0,
+    DIINIndex = 1
+  };
+  enum {
+    PROPChunk = 0,
+    DIINChunk = 1
+  };
+}
+
+class DSDIFF::File::FilePrivate
+{
+public:
+  FilePrivate() :
+  endianness(BigEndian),
+  size(0),
+  isID3InPropChunk(false),
+  duplicateID3V2chunkIndex(-1),
+  id3v2TagChunkID("ID3 "),
+  hasID3v2(false),
+  hasDiin(false)
+  {
+    childChunkIndex[ID3v2Index] = -1;
+    childChunkIndex[DIINIndex] = -1;
+  }
+
+  Endianness endianness;
+  ByteVector type;
+  unsigned long long size;
+  ByteVector format;
+  std::vector<Chunk64> chunks;
+  std::vector<Chunk64> childChunks[2];
+  int childChunkIndex[2];
+  bool isID3InPropChunk; // Two possibilities can be found: ID3V2 chunk inside PROP chunk or at root level
+  int duplicateID3V2chunkIndex; // 2 ID3 chunks are present. This is then the index of the one in
+                                // PROP chunk that will be removed upon next save to remove duplicates.
+
+  SCOPED_PTR<AudioProperties> properties;
+
+  DoubleTagUnion tag;
+
+  ByteVector id3v2TagChunkID;
+
+  bool hasID3v2;
+  bool hasDiin;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// static members
+////////////////////////////////////////////////////////////////////////////////
+
+bool DSDIFF::File::isSupported(IOStream *stream)
+{
+    // A DSDIFF file has to start with "FRM8????????DSD ".
+
+    const ByteVector id = Utils::readHeader(stream, 16, false);
+    return (id.startsWith("FRM8") && id.containsAt("DSD ", 12));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// public members
+////////////////////////////////////////////////////////////////////////////////
+
+DSDIFF::File::File(FileName file, bool readProperties,
+                   AudioProperties::ReadStyle propertiesStyle) : TagLib::File(file)
+{
+  d = new FilePrivate;
+  d->endianness = BigEndian;
+  if(isOpen())
+    read(readProperties, propertiesStyle);
+}
+
+DSDIFF::File::File(IOStream *stream, bool readProperties,
+                   AudioProperties::ReadStyle propertiesStyle) : TagLib::File(stream)
+{
+  d = new FilePrivate;
+  d->endianness = BigEndian;
+  if(isOpen())
+    read(readProperties, propertiesStyle);
+}
+
+DSDIFF::File::~File()
+{
+  delete d;
+}
+
+TagLib::Tag *DSDIFF::File::tag() const
+{
+  return &d->tag;
+}
+
+ID3v2::Tag *DSDIFF::File::ID3v2Tag() const
+{
+  return d->tag.access<ID3v2::Tag>(ID3v2Index, false);
+}
+
+bool DSDIFF::File::hasID3v2Tag() const
+{
+  return d->hasID3v2;
+}
+
+DSDIFF::DIIN::Tag *DSDIFF::File::DIINTag() const
+{
+  return d->tag.access<DSDIFF::DIIN::Tag>(DIINIndex, false);
+}
+
+bool DSDIFF::File::hasDIINTag() const
+{
+  return d->hasDiin;
+}
+
+PropertyMap DSDIFF::File::properties() const
+{
+  if(d->hasID3v2)
+    return d->tag.access<ID3v2::Tag>(ID3v2Index, false)->properties();
+
+  return PropertyMap();
+}
+
+void DSDIFF::File::removeUnsupportedProperties(const StringList &unsupported)
+{
+  if(d->hasID3v2)
+    d->tag.access<ID3v2::Tag>(ID3v2Index, false)->removeUnsupportedProperties(unsupported);
+
+  if(d->hasDiin)
+    d->tag.access<DSDIFF::DIIN::Tag>(DIINIndex, false)->removeUnsupportedProperties(unsupported);
+}
+
+PropertyMap DSDIFF::File::setProperties(const PropertyMap &properties)
+{
+  return d->tag.access<ID3v2::Tag>(ID3v2Index, true)->setProperties(properties);
+}
+
+DSDIFF::AudioProperties *DSDIFF::File::audioProperties() const
+{
+  return d->properties.get();
+}
+
+bool DSDIFF::File::save()
+{
+  if(readOnly()) {
+    debug("DSDIFF::File::save() -- File is read only.");
+    return false;
+  }
+
+  if(!isValid()) {
+    debug("DSDIFF::File::save() -- Trying to save invalid file.");
+    return false;
+  }
+
+  // First: save ID3V2 chunk
+  ID3v2::Tag *id3v2Tag = d->tag.access<ID3v2::Tag>(ID3v2Index, false);
+  if(d->isID3InPropChunk) {
+    if(id3v2Tag != NULL && !id3v2Tag->isEmpty()) {
+      setChildChunkData(d->id3v2TagChunkID, id3v2Tag->render(), PROPChunk);
+      d->hasID3v2 = true;
+    }
+    else {
+      // Empty tag: remove it
+      setChildChunkData(d->id3v2TagChunkID, ByteVector(), PROPChunk);
+      d->hasID3v2 = false;
+    }
+  }
+  else {
+    if(id3v2Tag != NULL && !id3v2Tag->isEmpty()) {
+      setRootChunkData(d->id3v2TagChunkID, id3v2Tag->render());
+      d->hasID3v2 = true;
+    }
+    else {
+      // Empty tag: remove it
+      setRootChunkData(d->id3v2TagChunkID, ByteVector());
+      d->hasID3v2 = false;
+    }
+  }
+
+  // Second: save the DIIN chunk
+  if(d->hasDiin) {
+    DSDIFF::DIIN::Tag *diinTag = d->tag.access<DSDIFF::DIIN::Tag>(DIINIndex, false);
+
+    if(!diinTag->title().isEmpty()) {
+      ByteVector diinTitle;
+      if(d->endianness == BigEndian)
+        diinTitle.append(ByteVector::fromUInt32BE(diinTag->title().size()));
+      else
+        diinTitle.append(ByteVector::fromUInt32LE(diinTag->title().size()));
+      diinTitle.append(ByteVector::fromCString(diinTag->title().toCString()));
+      setChildChunkData("DITI", diinTitle, DIINChunk);
+    }
+    else
+      setChildChunkData("DITI", ByteVector(), DIINChunk);
+
+    if(!diinTag->artist().isEmpty()) {
+      ByteVector diinArtist;
+      if(d->endianness == BigEndian)
+        diinArtist.append(ByteVector::fromUInt32BE(diinTag->artist().size()));
+      else
+        diinArtist.append(ByteVector::fromUInt32LE(diinTag->artist().size()));
+      diinArtist.append(ByteVector::fromCString(diinTag->artist().toCString()));
+      setChildChunkData("DIAR", diinArtist, DIINChunk);
+    }
+    else
+      setChildChunkData("DIAR", ByteVector(), DIINChunk);
+  }
+
+  // Third: remove the duplicate ID3V2 chunk (inside PROP chunk) if any
+  if(d->duplicateID3V2chunkIndex>=0) {
+    setChildChunkData(d->duplicateID3V2chunkIndex, ByteVector(), PROPChunk);
+    d->duplicateID3V2chunkIndex = -1;
+  }
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// private members
+////////////////////////////////////////////////////////////////////////////////
+
+void DSDIFF::File::setRootChunkData(unsigned int i, const ByteVector &data)
+{
+  if(data.isEmpty()) {
+    // Null data: remove chunk
+    // Update global size
+    unsigned long long removedChunkTotalSize = d->chunks[i].size + d->chunks[i].padding + 12;
+    d->size -= removedChunkTotalSize;
+    if(d->endianness == BigEndian)
+      insert(ByteVector::fromUInt64BE(d->size), 4, 8);
+    else
+      insert(ByteVector::fromUInt64LE(d->size), 4, 8);
+
+    removeBlock(d->chunks[i].offset - 12, removedChunkTotalSize);
+
+    // Update the internal offsets
+    for(unsigned long r = i + 1; r < d->chunks.size(); r++)
+      d->chunks[r].offset = d->chunks[r - 1].offset + 12
+        + d->chunks[r - 1].size + d->chunks[r - 1].padding;
+
+    d->chunks.erase(d->chunks.begin() + i);
+  }
+  else {
+    // Non null data: update chunk
+    // First we update the global size
+    d->size += ((data.size() + 1) & ~1) - (d->chunks[i].size + d->chunks[i].padding);
+    if(d->endianness == BigEndian)
+      insert(ByteVector::fromUInt64BE(d->size), 4, 8);
+    else
+      insert(ByteVector::fromUInt64LE(d->size), 4, 8);
+
+    // Now update the specific chunk
+    writeChunk(d->chunks[i].name,
+               data,
+               d->chunks[i].offset - 12,
+               d->chunks[i].size + d->chunks[i].padding + 12);
+
+    d->chunks[i].size = data.size();
+    d->chunks[i].padding = (data.size() & 0x01) ? 1 : 0;
+
+    // Finally update the internal offsets
+    updateRootChunksStructure(i + 1);
+  }
+}
+
+void DSDIFF::File::setRootChunkData(const ByteVector &name, const ByteVector &data)
+{
+  if(d->chunks.size() == 0) {
+    debug("DSDIFF::File::setPropChunkData - No valid chunks found.");
+    return;
+  }
+
+  for(unsigned int i = 0; i < d->chunks.size(); i++) {
+    if(d->chunks[i].name == name) {
+      setRootChunkData(i, data);
+      return;
+    }
+  }
+
+  // Couldn't find an existing chunk, so let's create a new one.
+  unsigned int i = d->chunks.size() - 1;
+  unsigned long offset = d->chunks[i].offset + d->chunks[i].size + d->chunks[i].padding;
+
+  // First we update the global size
+  d->size += (offset & 1) + ((data.size() + 1) & ~1) + 12;
+  if(d->endianness == BigEndian)
+     insert(ByteVector::fromUInt64BE(d->size), 4, 8);
+   else
+     insert(ByteVector::fromUInt64LE(d->size), 4, 8);
+
+  // Now add the chunk to the file
+  writeChunk(name,
+             data,
+             offset,
+             std::max<unsigned long long>(0, length() - offset),
+             (offset & 1) ? 1 : 0);
+
+  Chunk64 chunk;
+  chunk.name = name;
+  chunk.size = data.size();
+  chunk.offset = offset + 12;
+  chunk.padding = (data.size() & 0x01) ? 1 : 0;
+
+  d->chunks.push_back(chunk);
+}
+
+void DSDIFF::File::setChildChunkData(unsigned int i,
+                                     const ByteVector &data,
+                                     unsigned int childChunkNum)
+{
+  std::vector<Chunk64> &childChunks = d->childChunks[childChunkNum];
+
+  if(data.isEmpty()) {
+    // Null data: remove chunk
+    // Update global size
+    unsigned long long removedChunkTotalSize = childChunks[i].size + childChunks[i].padding + 12;
+    d->size -= removedChunkTotalSize;
+    if(d->endianness == BigEndian)
+      insert(ByteVector::fromUInt64BE(d->size), 4, 8);
+    else
+      insert(ByteVector::fromUInt64LE(d->size), 4, 8);
+    // Update child chunk size
+    d->chunks[d->childChunkIndex[childChunkNum]].size -= removedChunkTotalSize;
+    if(d->endianness == BigEndian)
+      insert(ByteVector::fromUInt64BE(d->chunks[d->childChunkIndex[childChunkNum]].size),
+             d->chunks[d->childChunkIndex[childChunkNum]].offset - 8, 8);
+    else
+      insert(ByteVector::fromUInt64LE(d->chunks[d->childChunkIndex[childChunkNum]].size),
+             d->chunks[d->childChunkIndex[childChunkNum]].offset - 8, 8);
+
+    // Remove the chunk
+    removeBlock(childChunks[i].offset - 12, removedChunkTotalSize);
+
+    // Update the internal offsets
+    // For child chunks
+    if((i + 1) < childChunks.size()) {
+      childChunks[i + 1].offset = childChunks[i].offset;
+      i++;
+      for(i++; i < childChunks.size(); i++)
+        childChunks[i].offset = childChunks[i - 1].offset + 12
+          + childChunks[i - 1].size + childChunks[i - 1].padding;
+    }
+
+    // And for root chunks
+    for(i = d->childChunkIndex[childChunkNum] + 1; i < d->chunks.size(); i++)
+      d->chunks[i].offset = d->chunks[i - 1].offset + 12
+        + d->chunks[i - 1].size + d->chunks[i - 1].padding;
+
+    childChunks.erase(childChunks.begin() + i);
+  }
+  else {
+    // Non null data: update chunk
+    // First we update the global size
+    d->size += ((data.size() + 1) & ~1) - (childChunks[i].size + childChunks[i].padding);
+    if(d->endianness == BigEndian)
+      insert(ByteVector::fromUInt64BE(d->size), 4, 8);
+    else
+      insert(ByteVector::fromUInt64LE(d->size), 4, 8);
+    // And the PROP chunk size
+    d->chunks[d->childChunkIndex[childChunkNum]].size += ((data.size() + 1) & ~1)
+      - (childChunks[i].size + childChunks[i].padding);
+    if(d->endianness == BigEndian)
+      insert(ByteVector::fromUInt64BE(d->chunks[d->childChunkIndex[childChunkNum]].size),
+             d->chunks[d->childChunkIndex[childChunkNum]].offset - 8, 8);
+    else
+      insert(ByteVector::fromUInt64LE(d->chunks[d->childChunkIndex[childChunkNum]].size),
+             d->chunks[d->childChunkIndex[childChunkNum]].offset - 8, 8);
+
+    // Now update the specific chunk
+    writeChunk(childChunks[i].name,
+               data,
+               childChunks[i].offset - 12,
+               childChunks[i].size + childChunks[i].padding + 12);
+
+    childChunks[i].size = data.size();
+    childChunks[i].padding = (data.size() & 0x01) ? 1 : 0;
+
+    // Now update the internal offsets
+    // For child Chunks
+    for(i++; i < childChunks.size(); i++)
+      childChunks[i].offset = childChunks[i - 1].offset + 12
+      + childChunks[i - 1].size + childChunks[i - 1].padding;
+
+    // And for root chunks
+    updateRootChunksStructure(d->childChunkIndex[childChunkNum] + 1);
+  }
+}
+
+void DSDIFF::File::setChildChunkData(const ByteVector &name,
+                                     const ByteVector &data,
+                                     unsigned int childChunkNum)
+{
+  std::vector<Chunk64> &childChunks = d->childChunks[childChunkNum];
+
+  if(childChunks.size() == 0) {
+    debug("DSDIFF::File::setPropChunkData - No valid chunks found.");
+    return;
+  }
+
+  for(unsigned int i = 0; i < childChunks.size(); i++) {
+    if(childChunks[i].name == name) {
+      setChildChunkData(i, data, childChunkNum);
+      return;
+    }
+  }
+
+  // Do not attempt to remove a non existing chunk
+  if(data.isEmpty())
+    return;
+
+  // Couldn't find an existing chunk, so let's create a new one.
+  unsigned int i = childChunks.size() - 1;
+  unsigned long offset = childChunks[i].offset + childChunks[i].size + childChunks[i].padding;
+
+  // First we update the global size
+  d->size += (offset & 1) + ((data.size() + 1) & ~1) + 12;
+  if(d->endianness == BigEndian)
+    insert(ByteVector::fromUInt64BE(d->size), 4, 8);
+  else
+    insert(ByteVector::fromUInt64LE(d->size), 4, 8);
+  // And the child chunk size
+  d->chunks[d->childChunkIndex[childChunkNum]].size += (offset & 1)
+    + ((data.size() + 1) & ~1) + 12;
+  if(d->endianness == BigEndian)
+    insert(ByteVector::fromUInt64BE(d->chunks[d->childChunkIndex[childChunkNum]].size),
+            d->chunks[d->childChunkIndex[childChunkNum]].offset - 8, 8);
+  else
+    insert(ByteVector::fromUInt64LE(d->chunks[d->childChunkIndex[childChunkNum]].size),
+           d->chunks[d->childChunkIndex[childChunkNum]].offset - 8, 8);
+
+  // Now add the chunk to the file
+  unsigned long long nextRootChunkIdx = length();
+  if((d->childChunkIndex[childChunkNum] + 1) < static_cast<int>(d->chunks.size()))
+    nextRootChunkIdx = d->chunks[d->childChunkIndex[childChunkNum] + 1].offset - 12;
+
+  writeChunk(name, data, offset,
+             std::max<unsigned long long>(0, nextRootChunkIdx - offset),
+             (offset & 1) ? 1 : 0);
+
+  // For root chunks
+  updateRootChunksStructure(d->childChunkIndex[childChunkNum] + 1);
+
+  Chunk64 chunk;
+  chunk.name = name;
+  chunk.size = data.size();
+  chunk.offset = offset + 12;
+  chunk.padding = (data.size() & 0x01) ? 1 : 0;
+
+  childChunks.push_back(chunk);
+}
+
+static bool isValidChunkID(const ByteVector &name)
+{
+  if(name.size() != 4)
+    return false;
+
+  for(int i = 0; i < 4; i++) {
+    if(name[i] < 32 || name[i] > 127)
+      return false;
+  }
+
+  return true;
+}
+
+void DSDIFF::File::updateRootChunksStructure(unsigned int startingChunk)
+{
+  for(unsigned int i = startingChunk; i < d->chunks.size(); i++)
+    d->chunks[i].offset = d->chunks[i - 1].offset + 12
+      + d->chunks[i - 1].size + d->chunks[i - 1].padding;
+
+  // Update childchunks structure as well
+  if(d->childChunkIndex[PROPChunk] >= static_cast<int>(startingChunk)) {
+    std::vector<Chunk64> &childChunksToUpdate = d->childChunks[PROPChunk];
+    if(childChunksToUpdate.size() > 0) {
+      childChunksToUpdate[0].offset = d->chunks[d->childChunkIndex[PROPChunk]].offset + 12;
+      for(unsigned int i = 1; i < childChunksToUpdate.size(); i++)
+        childChunksToUpdate[i].offset = childChunksToUpdate[i - 1].offset + 12
+          + childChunksToUpdate[i - 1].size + childChunksToUpdate[i - 1].padding;
+    }
+  }
+  if(d->childChunkIndex[DIINChunk] >= static_cast<int>(startingChunk)) {
+    std::vector<Chunk64> &childChunksToUpdate = d->childChunks[DIINChunk];
+    if(childChunksToUpdate.size() > 0) {
+      childChunksToUpdate[0].offset = d->chunks[d->childChunkIndex[DIINChunk]].offset + 12;
+      for(unsigned int i = 1; i < childChunksToUpdate.size(); i++)
+        childChunksToUpdate[i].offset = childChunksToUpdate[i - 1].offset + 12
+          + childChunksToUpdate[i - 1].size + childChunksToUpdate[i - 1].padding;
+    }
+  }
+}
+
+void DSDIFF::File::read(bool readProperties, AudioProperties::ReadStyle propertiesStyle)
+{
+  bool bigEndian = (d->endianness == BigEndian);
+
+  d->type = readBlock(4);
+  d->size = bigEndian ? readBlock(8).toInt64BE(0) : readBlock(8).toInt64LE(0);
+  d->format = readBlock(4);
+
+  // + 12: chunk header at least, fix for additional junk bytes
+  while(tell() + 12 <= length()) {
+    ByteVector chunkName = readBlock(4);
+    unsigned long long chunkSize = bigEndian ? readBlock(8).toInt64BE(0) : readBlock(8).toInt64LE(0);
+
+    if(!isValidChunkID(chunkName)) {
+      debug("DSDIFF::File::read() -- Chunk '" + chunkName + "' has invalid ID");
+      setValid(false);
+      break;
+    }
+
+    if(static_cast<unsigned long long>(tell()) + chunkSize > static_cast<unsigned long long>(length())) {
+      debug("DSDIFF::File::read() -- Chunk '" + chunkName
+            + "' has invalid size (larger than the file size)");
+      setValid(false);
+      break;
+    }
+
+    Chunk64 chunk;
+    chunk.name = chunkName;
+    chunk.size = chunkSize;
+    chunk.offset = tell();
+
+    seek(chunk.size, Current);
+
+    // Check padding
+    chunk.padding = 0;
+    long uPosNotPadded = tell();
+    if((uPosNotPadded & 0x01) != 0) {
+      ByteVector iByte = readBlock(1);
+      if((iByte.size() != 1) || (iByte[0] != 0))
+        // Not well formed, re-seek
+        seek(uPosNotPadded, Beginning);
+      else
+        chunk.padding = 1;
+    }
+    d->chunks.push_back(chunk);
+  }
+
+  unsigned long long lengthDSDSamplesTimeChannels = 0; // For DSD uncompressed
+  unsigned long long audioDataSizeinBytes = 0; // For computing bitrate
+  unsigned long dstNumFrames = 0; // For DST compressed frames
+  unsigned short dstFrameRate = 0; // For DST compressed frames
+
+  for(unsigned int i = 0; i < d->chunks.size(); i++) {
+    if(d->chunks[i].name == "DSD ") {
+      lengthDSDSamplesTimeChannels = d->chunks[i].size * 8;
+      audioDataSizeinBytes = d->chunks[i].size;
+    }
+    else if(d->chunks[i].name == "DST ") {
+      // Now decode the chunks inside the DST chunk to read the DST Frame Information one
+      long long dstChunkEnd = d->chunks[i].offset + d->chunks[i].size;
+      seek(d->chunks[i].offset);
+
+      audioDataSizeinBytes = d->chunks[i].size;
+
+      while(tell() + 12 <= dstChunkEnd) {
+        ByteVector dstChunkName = readBlock(4);
+        long long dstChunkSize = bigEndian ? readBlock(8).toInt64BE(0) : readBlock(8).toInt64LE(0);
+
+        if(!isValidChunkID(dstChunkName)) {
+          debug("DSDIFF::File::read() -- DST Chunk '" + dstChunkName + "' has invalid ID");
+          setValid(false);
+          break;
+        }
+
+        if(static_cast<long long>(tell()) + dstChunkSize > dstChunkEnd) {
+          debug("DSDIFF::File::read() -- DST Chunk '" + dstChunkName
+                + "' has invalid size (larger than the DST chunk)");
+          setValid(false);
+          break;
+        }
+
+        if(dstChunkName == "FRTE") {
+          // Found the DST frame information chunk
+          dstNumFrames = bigEndian ? readBlock(4).toUInt32BE(0) : readBlock(4).toUInt32LE(0);
+          dstFrameRate = bigEndian ? readBlock(2).toUInt16BE(0) : readBlock(2).toUInt16LE(0);
+          break; // Found the wanted one, no need to look at the others
+        }
+
+        seek(dstChunkSize, Current);
+
+        // Check padding
+        long uPosNotPadded = tell();
+        if((uPosNotPadded & 0x01) != 0) {
+          ByteVector iByte = readBlock(1);
+          if((iByte.size() != 1) || (iByte[0] != 0))
+            // Not well formed, re-seek
+            seek(uPosNotPadded, Beginning);
+        }
+      }
+    }
+    else if(d->chunks[i].name == "PROP") {
+      d->childChunkIndex[PROPChunk] = i;
+      // Now decodes the chunks inside the PROP chunk
+      long long propChunkEnd = d->chunks[i].offset + d->chunks[i].size;
+      seek(d->chunks[i].offset + 4); // +4 to remove the 'SND ' marker at beginning of 'PROP' chunk
+      while(tell() + 12 <= propChunkEnd) {
+        ByteVector propChunkName = readBlock(4);
+        long long propChunkSize = bigEndian ? readBlock(8).toInt64BE(0) : readBlock(8).toInt64LE(0);
+
+        if(!isValidChunkID(propChunkName)) {
+          debug("DSDIFF::File::read() -- PROP Chunk '" + propChunkName + "' has invalid ID");
+          setValid(false);
+          break;
+        }
+
+        if(static_cast<long long>(tell()) + propChunkSize > propChunkEnd) {
+          debug("DSDIFF::File::read() -- PROP Chunk '" + propChunkName
+                + "' has invalid size (larger than the PROP chunk)");
+          setValid(false);
+          break;
+        }
+
+        Chunk64 chunk;
+        chunk.name = propChunkName;
+        chunk.size = propChunkSize;
+        chunk.offset = tell();
+
+        seek(chunk.size, Current);
+
+        // Check padding
+        chunk.padding = 0;
+        long uPosNotPadded = tell();
+        if((uPosNotPadded & 0x01) != 0) {
+          ByteVector iByte = readBlock(1);
+          if((iByte.size() != 1) || (iByte[0] != 0))
+            // Not well formed, re-seek
+            seek(uPosNotPadded, Beginning);
+          else
+            chunk.padding = 1;
+        }
+        d->childChunks[PROPChunk].push_back(chunk);
+      }
+    }
+    else if(d->chunks[i].name == "DIIN") {
+      d->childChunkIndex[DIINChunk] = i;
+      d->hasDiin = true;
+      // Now decode the chunks inside the DIIN chunk
+      long long diinChunkEnd = d->chunks[i].offset + d->chunks[i].size;
+      seek(d->chunks[i].offset);
+
+      while(tell() + 12 <= diinChunkEnd) {
+        ByteVector diinChunkName = readBlock(4);
+        long long diinChunkSize = bigEndian ? readBlock(8).toInt64BE(0) : readBlock(8).toInt64LE(0);
+
+        if(!isValidChunkID(diinChunkName)) {
+          debug("DSDIFF::File::read() -- DIIN Chunk '" + diinChunkName + "' has invalid ID");
+          setValid(false);
+          break;
+        }
+
+        if(static_cast<long long>(tell()) + diinChunkSize > diinChunkEnd) {
+          debug("DSDIFF::File::read() -- DIIN Chunk '" + diinChunkName
+                + "' has invalid size (larger than the DIIN chunk)");
+          setValid(false);
+          break;
+        }
+
+        Chunk64 chunk;
+        chunk.name = diinChunkName;
+        chunk.size = diinChunkSize;
+        chunk.offset = tell();
+
+        seek(chunk.size, Current);
+
+        // Check padding
+        chunk.padding = 0;
+        long uPosNotPadded = tell();
+        if((uPosNotPadded & 0x01) != 0) {
+          ByteVector iByte = readBlock(1);
+          if((iByte.size() != 1) || (iByte[0] != 0))
+            // Not well formed, re-seek
+            seek(uPosNotPadded, Beginning);
+          else
+            chunk.padding = 1;
+        }
+        d->childChunks[DIINChunk].push_back(chunk);
+      }
+    }
+    else if(d->chunks[i].name == "ID3 " || d->chunks[i].name == "id3 ") {
+      d->id3v2TagChunkID = d->chunks[i].name;
+      d->tag.set(ID3v2Index, new ID3v2::Tag(this, d->chunks[i].offset));
+      d->isID3InPropChunk = false;
+      d->hasID3v2 = true;
+    }
+  }
+
+  if(!isValid())
+    return;
+
+  if(d->childChunkIndex[PROPChunk] < 0) {
+    debug("DSDIFF::File::read() -- no PROP chunk found");
+    setValid(false);
+    return;
+  }
+
+  // Read properties
+
+  unsigned int sampleRate=0;
+  unsigned short channels=0;
+
+  for(unsigned int i = 0; i < d->childChunks[PROPChunk].size(); i++) {
+    if(d->childChunks[PROPChunk][i].name == "ID3 " || d->childChunks[PROPChunk][i].name == "id3 ") {
+      if(d->hasID3v2) {
+        d->duplicateID3V2chunkIndex = i;
+        continue; // ID3V2 tag has already been found at root level
+      }
+      d->id3v2TagChunkID = d->childChunks[PROPChunk][i].name;
+      d->tag.set(ID3v2Index, new ID3v2::Tag(this, d->childChunks[PROPChunk][i].offset));
+      d->isID3InPropChunk = true;
+      d->hasID3v2 = true;
+    }
+    else if(d->childChunks[PROPChunk][i].name == "FS  ") {
+      // Sample rate
+      seek(d->childChunks[PROPChunk][i].offset);
+      sampleRate = bigEndian ? readBlock(4).toUInt32BE(0) : readBlock(4).toUInt32LE(0);
+    }
+    else if(d->childChunks[PROPChunk][i].name == "CHNL") {
+      // Channels
+      seek(d->childChunks[PROPChunk][i].offset);
+      channels = bigEndian ? readBlock(2).toInt16BE(0) : readBlock(2).toInt16LE(0);
+    }
+  }
+
+  // Read title & artist from DIIN chunk
+  d->tag.access<DSDIFF::DIIN::Tag>(DIINIndex, true);
+
+  if(d->hasDiin) {
+    for(unsigned int i = 0; i < d->childChunks[DIINChunk].size(); i++) {
+      if(d->childChunks[DIINChunk][i].name == "DITI") {
+        seek(d->childChunks[DIINChunk][i].offset);
+        unsigned int titleStrLength = bigEndian ? readBlock(4).toUInt32BE(0) : readBlock(4).toUInt32LE(0);
+        if(titleStrLength <= d->childChunks[DIINChunk][i].size) {
+          ByteVector titleStr = readBlock(titleStrLength);
+          d->tag.access<DSDIFF::DIIN::Tag>(DIINIndex, false)->setTitle(titleStr);
+        }
+      }
+      else if(d->childChunks[DIINChunk][i].name == "DIAR") {
+        seek(d->childChunks[DIINChunk][i].offset);
+        unsigned int artistStrLength = bigEndian ? readBlock(4).toUInt32BE(0) : readBlock(4).toUInt32LE(0);
+        if(artistStrLength <= d->childChunks[DIINChunk][i].size) {
+          ByteVector artistStr = readBlock(artistStrLength);
+          d->tag.access<DSDIFF::DIIN::Tag>(DIINIndex, false)->setArtist(artistStr);
+        }
+      }
+    }
+  }
+
+  if(readProperties) {
+    if(lengthDSDSamplesTimeChannels == 0) {
+      // DST compressed signal : need to compute length of DSD uncompressed frames
+      if(dstFrameRate > 0)
+        lengthDSDSamplesTimeChannels = (unsigned long long)dstNumFrames
+          * (unsigned long long)sampleRate / (unsigned long long)dstFrameRate;
+      else
+        lengthDSDSamplesTimeChannels = 0;
+    }
+    else {
+      // In DSD uncompressed files, the read number of samples is the total for each channel
+      if(channels > 0)
+        lengthDSDSamplesTimeChannels /= channels;
+    }
+    int bitrate = 0;
+    if(lengthDSDSamplesTimeChannels > 0)
+      bitrate = (audioDataSizeinBytes*8*sampleRate) / lengthDSDSamplesTimeChannels / 1000;
+
+    d->properties.reset(new AudioProperties(sampleRate,
+                                            channels,
+                                            lengthDSDSamplesTimeChannels,
+                                            bitrate,
+                                            propertiesStyle));
+  }
+
+  if(!ID3v2Tag()) {
+    d->tag.access<ID3v2::Tag>(ID3v2Index, true);
+    d->isID3InPropChunk = false; // By default, ID3 chunk is at root level
+    d->hasID3v2 = false;
+  }
+}
+
+void DSDIFF::File::writeChunk(const ByteVector &name, const ByteVector &data,
+                              unsigned long long offset, unsigned long replace,
+                              unsigned int leadingPadding)
+{
+  ByteVector combined;
+  if(leadingPadding)
+    combined.append(ByteVector(leadingPadding, '\x00'));
+
+  combined.append(name);
+  if(d->endianness == BigEndian)
+    combined.append(ByteVector::fromUInt64BE(data.size()));
+  else
+    combined.append(ByteVector::fromUInt64LE(data.size()));
+  combined.append(data);
+  if((data.size() & 0x01) != 0)
+    combined.append('\x00');
+
+  insert(combined, offset, replace);
+}
+

taglib/dsdiff/dsdifffile.h

@@ -0,0 +1,260 @@
+/***************************************************************************
+ copyright            : (C) 2016 by Damien Plisson, Audirvana
+ email                : damien78@audirvana.com
+ ***************************************************************************/
+
+/***************************************************************************
+ *   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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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_DSDIFFFILE_H
+#define TAGLIB_DSDIFFFILE_H
+
+#include "rifffile.h"
+#include "id3v2tag.h"
+#include "dsdiffproperties.h"
+#include "dsdiffdiintag.h"
+
+namespace TagLib {
+
+  //! An implementation of DSDIFF metadata
+
+  /*!
+   * This is implementation of DSDIFF metadata.
+   *
+   * This supports an ID3v2 tag as well as reading stream from the ID3 RIFF
+   * chunk as well as properties from the file.
+   * Description of the DSDIFF format is available
+   * at http://dsd-guide.com/sites/default/files/white-papers/DSDIFF_1.5_Spec.pdf
+   * DSDIFF standard does not explictly specify the ID3V2 chunk
+   * It can be found at the root level, but also sometimes inside the PROP chunk
+   * In addition, title and artist info are stored as part of the standard
+   */
+
+  namespace DSDIFF {
+
+    //! An implementation of TagLib::File with DSDIFF specific methods
+
+    /*!
+     * This implements and provides an interface for DSDIFF files to the
+     * TagLib::Tag and TagLib::AudioProperties interfaces by way of implementing
+     * the abstract TagLib::File API as well as providing some additional
+     * information specific to DSDIFF files.
+     */
+
+    class TAGLIB_EXPORT File : public TagLib::File
+    {
+    public:
+      /*!
+       * Constructs an DSDIFF file from \a file.  If \a readProperties is true
+       * the file's audio properties will also be read.
+       *
+       * \note In the current implementation, \a propertiesStyle is ignored.
+       */
+      File(FileName file, bool readProperties = true,
+           AudioProperties::ReadStyle propertiesStyle = AudioProperties::Average);
+
+      /*!
+       * Constructs an DSDIFF file from \a stream.  If \a readProperties is true
+       * the file's audio properties will also be read.
+       *
+       * \note TagLib will *not* take ownership of the stream, the caller is
+       * responsible for deleting it after the File object.
+       *
+       * \note In the current implementation, \a propertiesStyle is ignored.
+       */
+      File(IOStream *stream, bool readProperties = true,
+           AudioProperties::ReadStyle propertiesStyle = AudioProperties::Average);
+
+      /*!
+       * Destroys this instance of the File.
+       */
+      virtual ~File();
+
+      /*!
+       * Returns a pointer to a tag that is the union of the ID3v2 and DIIN
+       * tags. The ID3v2 tag is given priority in reading the information -- if
+       * requested information exists in both the ID3v2 tag and the ID3v1 tag,
+       * the information from the ID3v2 tag will be returned.
+       *
+       * If you would like more granular control over the content of the tags,
+       * with the concession of generality, use the tag-type specific calls.
+       *
+       * \note As this tag is not implemented as an ID3v2 tag or a DIIN tag,
+       * but a union of the two this pointer may not be cast to the specific
+       * tag types.
+       *
+       * \see ID3v2Tag()
+       * \see DIINTag()
+       */
+      virtual Tag *tag() const;
+
+      /*!
+       * Returns the ID3V2 Tag for this file.
+       *
+       * \note This always returns a valid pointer regardless of whether or not
+       * the file on disk has an ID3v2 tag.  Use hasID3v2Tag() to check if the
+       * file on disk actually has an ID3v2 tag.
+       *
+       * \see hasID3v2Tag()
+       */
+      virtual ID3v2::Tag *ID3v2Tag() const;
+
+      /*!
+       * Returns the DSDIFF DIIN Tag for this file
+       *
+       */
+      DSDIFF::DIIN::Tag *DIINTag() const;
+
+      /*!
+       * Implements the unified property interface -- export function.
+       * This method forwards to ID3v2::Tag::properties().
+       */
+      PropertyMap properties() const;
+
+      void removeUnsupportedProperties(const StringList &properties);
+
+      /*!
+       * Implements the unified property interface -- import function.
+       * This method forwards to ID3v2::Tag::setProperties().
+       */
+      PropertyMap setProperties(const PropertyMap &);
+
+      /*!
+       * Returns the DSDIFF::Properties for this file.  If no audio properties
+       * were read then this will return a null pointer.
+       */
+      virtual AudioProperties *audioProperties() const;
+
+      /*!
+       * Save the file.  If at least one tag -- ID3v1 or DIIN -- exists this
+       * will duplicate its content into the other tag.  This returns true
+       * if saving was successful.
+       *
+       * If neither exists or if both tags are empty, this will strip the tags
+       * from the file.
+       *
+       * This is the same as calling save(AllTags);
+       *
+       * If you would like more granular control over the content of the tags,
+       * with the concession of generality, use paramaterized save call below.
+       *
+       * \see save(int tags)
+       */
+      virtual bool save();
+
+      /*!
+       * Save the file.  This will attempt to save all of the tag types that are
+       * specified by OR-ing together TagTypes values.  The save() method above
+       * uses AllTags.  This returns true if saving was successful.
+       *
+       * This strips all tags not included in the mask, but does not modify them
+       * in memory, so later calls to save() which make use of these tags will
+       * remain valid.  This also strips empty tags.
+       */
+      bool save(int tags);
+
+      /*!
+       * Returns whether or not the file on disk actually has an ID3v2 tag.
+       *
+       * \see ID3v2Tag()
+       */
+      bool hasID3v2Tag() const;
+
+      /*!
+       * Returns whether or not the file on disk actually has the DSDIFF
+       * Title & Artist tag.
+       *
+       * \see DIINTag()
+       */
+      bool hasDIINTag() const;
+
+      /*!
+       * Returns whether or not the given \a stream can be opened as a DSDIFF
+       * file.
+       *
+       * \note This method is designed to do a quick check.  The result may
+       * not necessarily be correct.
+       */
+       static bool isSupported(IOStream *stream);
+
+    protected:
+      enum Endianness { BigEndian, LittleEndian };
+
+      File(FileName file, Endianness endianness);
+      File(IOStream *stream, Endianness endianness);
+
+    private:
+      File(const File &);
+      File &operator=(const File &);
+
+      /*!
+       * Sets the data for the the specified chunk at root level to \a data.
+       *
+       * \warning This will update the file immediately.
+       */
+      void setRootChunkData(unsigned int i, const ByteVector &data);
+
+      /*!
+       * Sets the data for the root-level chunk \a name to \a data.
+       * If a root-level chunk with the given name already exists
+       * it will be overwritten, otherwise it will be
+       * created after the existing chunks.
+       *
+       * \warning This will update the file immediately.
+       */
+      void setRootChunkData(const ByteVector &name, const ByteVector &data);
+
+      /*!
+       * Sets the data for the the specified child chunk to \a data.
+       *
+       * If data is null, then remove the chunk
+       *
+       * \warning This will update the file immediately.
+       */
+      void setChildChunkData(unsigned int i, const ByteVector &data,
+                             unsigned int childChunkNum);
+
+      /*!
+       * Sets the data for the child chunk \a name to \a data.  If a chunk with
+       * the given name already exists it will be overwritten, otherwise it will
+       * be created after the existing chunks inside child chunk.
+       *
+       * If data is null, then remove the chunks with \a name name
+       *
+       * \warning This will update the file immediately.
+       */
+      void setChildChunkData(const ByteVector &name, const ByteVector &data,
+                             unsigned int childChunkNum);
+
+      void updateRootChunksStructure(unsigned int startingChunk);
+
+      void read(bool readProperties, AudioProperties::ReadStyle propertiesStyle);
+      void writeChunk(const ByteVector &name, const ByteVector &data,
+                      unsigned long long offset, unsigned long replace = 0,
+                      unsigned int leadingPadding = 0);
+
+      class FilePrivate;
+      FilePrivate *d;
+    };
+  }
+}
+
+#endif
+

taglib/dsdiff/dsdiffproperties.cpp

@@ -0,0 +1,117 @@
+/***************************************************************************
+ copyright            : (C) 2016 by Damien Plisson, Audirvana
+ email                : damien78@audirvana.com
+ ***************************************************************************/
+
+/***************************************************************************
+ *   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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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/                                           *
+ ***************************************************************************/
+
+#include <tstring.h>
+#include <tdebug.h>
+
+#include "dsdiffproperties.h"
+
+using namespace TagLib;
+
+class DSDIFF::AudioProperties::AudioPropertiesPrivate
+{
+public:
+  AudioPropertiesPrivate() :
+  length(0),
+  bitrate(0),
+  sampleRate(0),
+  channels(0),
+  sampleWidth(0),
+  sampleCount(0)
+  {
+  }
+
+  int length;
+  int bitrate;
+  int sampleRate;
+  int channels;
+  int sampleWidth;
+  unsigned long long sampleCount;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// public members
+////////////////////////////////////////////////////////////////////////////////
+
+DSDIFF::AudioProperties::AudioProperties(const unsigned int sampleRate,
+                                         const unsigned short channels,
+                                         const unsigned long long samplesCount,
+                                         const int bitrate,
+                                         ReadStyle style) : TagLib::AudioProperties(), d(new AudioPropertiesPrivate)
+{
+  d->channels    = channels;
+  d->sampleCount = samplesCount;
+  d->sampleWidth = 1;
+  d->sampleRate  = sampleRate;
+  d->bitrate     = bitrate;
+  d->length      = d->sampleRate > 0
+    ? static_cast<int>((d->sampleCount * 1000.0) / d->sampleRate + 0.5)
+    : 0;
+}
+
+DSDIFF::AudioProperties::~AudioProperties()
+{
+  delete d;
+}
+
+int DSDIFF::AudioProperties::length() const
+{
+  return lengthInSeconds();
+}
+
+int DSDIFF::AudioProperties::lengthInSeconds() const
+{
+  return d->length / 1000;
+}
+
+int DSDIFF::AudioProperties::lengthInMilliseconds() const
+{
+  return d->length;
+}
+
+int DSDIFF::AudioProperties::bitrate() const
+{
+  return d->bitrate;
+}
+
+int DSDIFF::AudioProperties::sampleRate() const
+{
+  return d->sampleRate;
+}
+
+int DSDIFF::AudioProperties::channels() const
+{
+  return d->channels;
+}
+
+int DSDIFF::AudioProperties::bitsPerSample() const
+{
+  return d->sampleWidth;
+}
+
+long long DSDIFF::AudioProperties::sampleCount() const
+{
+  return d->sampleCount;
+}

taglib/dsdiff/dsdiffproperties.h

@@ -0,0 +1,83 @@
+/***************************************************************************
+    copyright            : (C) 2016 by Damien Plisson, Audirvana
+    email                : damien78@audirvana.com
+***************************************************************************/
+
+/***************************************************************************
+ *   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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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_DSDIFFPROPERTIES_H
+#define TAGLIB_DSDIFFPROPERTIES_H
+
+#include "audioproperties.h"
+
+namespace TagLib {
+
+  namespace DSDIFF {
+
+    class File;
+
+    //! An implementation of audio property reading for DSDIFF
+
+    /*!
+     * This reads the data from an DSDIFF stream found in the AudioProperties
+     * API.
+     */
+
+    class TAGLIB_EXPORT AudioProperties : public TagLib::AudioProperties
+    {
+    public:
+      /*!
+       * Create an instance of DSDIFF::AudioProperties with the data read from the
+       * ByteVector \a data.
+       */
+      AudioProperties(const unsigned int sampleRate, const unsigned short channels,
+                      const unsigned long long samplesCount, const int bitrate,
+                      ReadStyle style);
+
+      /*!
+       * Destroys this DSDIFF::AudioProperties instance.
+       */
+      virtual ~AudioProperties();
+
+      // Reimplementations.
+
+      virtual int length() const;
+      virtual int lengthInSeconds() const;
+      virtual int lengthInMilliseconds() const;
+      virtual int bitrate() const;
+      virtual int sampleRate() const;
+      virtual int channels() const;
+
+      int bitsPerSample() const;
+      long long sampleCount() const;
+
+    private:
+      AudioProperties(const AudioProperties &);
+      AudioProperties &operator=(const AudioProperties &);
+
+      class AudioPropertiesPrivate;
+      AudioPropertiesPrivate *d;
+    };
+  }
+}
+
+#endif
+

taglib/dsf/dsffile.cpp

@@ -0,0 +1,234 @@
+/***************************************************************************
+   copyright            : (C) 2013 - 2018 by Stephen F. Booth
+   email                : me@sbooth.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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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/                                           *
+ ***************************************************************************/
+
+#include <tbytevector.h>
+#include <tdebug.h>
+#include <id3v2tag.h>
+#include <tstringlist.h>
+#include <tpropertymap.h>
+#include <tsmartptr.h>
+#include <tagutils.h>
+
+#include "dsffile.h"
+
+using namespace TagLib;
+
+// The DSF specification is located at http://dsd-guide.com/sites/default/files/white-papers/DSFFileFormatSpec_E.pdf
+
+class DSF::File::FilePrivate
+{
+public:
+  FilePrivate() :
+    fileSize(0),
+    metadataOffset(0) {}
+
+  long long fileSize;
+  long long metadataOffset;
+
+  SCOPED_PTR<AudioProperties> properties;
+  SCOPED_PTR<ID3v2::Tag> tag;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// static members
+////////////////////////////////////////////////////////////////////////////////
+
+bool DSF::File::isSupported(IOStream *stream)
+{
+    // A DSF file has to start with "DSD "
+    const ByteVector id = Utils::readHeader(stream, 4, false);
+    return id.startsWith("DSD ");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// public members
+////////////////////////////////////////////////////////////////////////////////
+
+DSF::File::File(FileName file, bool readProperties,
+                AudioProperties::ReadStyle propertiesStyle) :
+  TagLib::File(file),
+  d(new FilePrivate())
+{
+  if(isOpen())
+    read(readProperties, propertiesStyle);
+}
+
+DSF::File::File(IOStream *stream, bool readProperties,
+                AudioProperties::ReadStyle propertiesStyle) :
+  TagLib::File(stream),
+  d(new FilePrivate())
+{
+  if(isOpen())
+    read(readProperties, propertiesStyle);
+}
+
+DSF::File::~File()
+{
+  delete d;
+}
+
+ID3v2::Tag *DSF::File::tag() const
+{
+  return d->tag.get();
+}
+
+DSF::AudioProperties *DSF::File::audioProperties() const
+{
+  return d->properties.get();
+}
+
+PropertyMap DSF::File::properties() const
+{
+  return d->tag->properties();
+}
+
+PropertyMap DSF::File::setProperties(const PropertyMap &properties)
+{
+  return d->tag->setProperties(properties);
+}
+
+bool DSF::File::save()
+{
+  if(readOnly()) {
+    debug("DSF::File::save() -- File is read only.");
+    return false;
+  }
+
+  if(!isValid()) {
+    debug("DSF::File::save() -- Trying to save invalid file.");
+    return false;
+  }
+
+  // Three things must be updated: the file size, the tag data, and the metadata offset
+
+  if(d->tag->isEmpty()) {
+    long long newFileSize = d->metadataOffset ? d->metadataOffset : d->fileSize;
+
+    // Update the file size
+    if(d->fileSize != newFileSize) {
+      insert(ByteVector::fromUInt64LE(newFileSize), 12, 8);
+      d->fileSize = newFileSize;
+    }
+
+    // Update the metadata offset to 0 since there is no longer a tag
+    if(d->metadataOffset) {
+      insert(ByteVector::fromUInt64LE(0ULL), 20, 8);
+      d->metadataOffset = 0;
+    }
+
+    // Delete the old tag
+    truncate(newFileSize);
+  }
+  else {
+    ByteVector tagData = d->tag->render();
+
+    long long newMetadataOffset = d->metadataOffset ? d->metadataOffset : d->fileSize;
+    long long newFileSize = newMetadataOffset + tagData.size();
+    long long oldTagSize = d->fileSize - newMetadataOffset;
+
+    // Update the file size
+    if(d->fileSize != newFileSize) {
+      insert(ByteVector::fromUInt64LE(newFileSize), 12, 8);
+      d->fileSize = newFileSize;
+    }
+
+    // Update the metadata offset
+    if(d->metadataOffset != newMetadataOffset) {
+      insert(ByteVector::fromUInt64LE(newMetadataOffset), 20, 8);
+      d->metadataOffset = newMetadataOffset;
+    }
+
+    // Delete the old tag and write the new one
+    insert(tagData, newMetadataOffset, static_cast<size_t>(oldTagSize));
+  }
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// private members
+////////////////////////////////////////////////////////////////////////////////
+
+void DSF::File::read(bool readProperties, AudioProperties::ReadStyle propertiesStyle)
+{
+  // A DSF file consists of four chunks: DSD chunk, format chunk, data chunk, and metadata chunk
+  // The file format is not chunked in the sense of a RIFF File, though
+
+  // DSD chunk
+  ByteVector chunkName = readBlock(4);
+  if(chunkName != "DSD ") {
+    debug("DSF::File::read() -- Not a DSF file.");
+    setValid(false);
+    return;
+  }
+
+  long long chunkSize = readBlock(8).toInt64LE(0);
+
+  // Integrity check
+  if(28 != chunkSize) {
+    debug("DSF::File::read() -- File is corrupted.");
+    setValid(false);
+    return;
+  }
+
+  d->fileSize = readBlock(8).toInt64LE(0);
+
+  // File is malformed or corrupted
+  if(d->fileSize != length()) {
+    debug("DSF::File::read() -- File is corrupted.");
+    setValid(false);
+    return;
+  }
+
+  d->metadataOffset = readBlock(8).toInt64LE(0);
+
+  // File is malformed or corrupted
+  if(d->metadataOffset > d->fileSize) {
+    debug("DSF::File::read() -- Invalid metadata offset.");
+    setValid(false);
+    return;
+  }
+
+  // Format chunk
+  chunkName = readBlock(4);
+  if(chunkName != "fmt ") {
+    debug("DSF::File::read() -- Missing 'fmt ' chunk.");
+    setValid(false);
+    return;
+  }
+
+  chunkSize = readBlock(8).toInt64LE(0);
+
+  d->properties.reset(
+    new AudioProperties(readBlock(static_cast<size_t>(chunkSize)), propertiesStyle));
+
+  // Skip the data chunk
+
+  // A metadata offset of 0 indicates the absence of an ID3v2 tag
+  if(0 == d->metadataOffset)
+    d->tag.reset(new ID3v2::Tag());
+  else
+    d->tag.reset(new ID3v2::Tag(this, d->metadataOffset));
+}

taglib/dsf/dsffile.h

@@ -0,0 +1,127 @@
+/***************************************************************************
+    copyright            : (C) 2013 - 2018 by Stephen F. Booth
+    email                : me@sbooth.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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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_DSFFILE_H
+#define TAGLIB_DSFFILE_H
+
+#include "tfile.h"
+#include "id3v2tag.h"
+#include "dsfproperties.h"
+
+namespace TagLib {
+
+  //! An implementation of DSF metadata
+
+  /*!
+   * This is implementation of DSF metadata.
+   *
+   * This supports an ID3v2 tag as well as properties from the file.
+   */
+
+  namespace DSF {
+
+    //! An implementation of TagLib::File with DSF specific methods
+
+    /*!
+     * This implements and provides an interface for DSF files to the
+     * TagLib::Tag and TagLib::AudioProperties interfaces by way of implementing
+     * the abstract TagLib::File API as well as providing some additional
+     * information specific to DSF files.
+     */
+
+    class TAGLIB_EXPORT File : public TagLib::File
+    {
+    public:
+      /*!
+       * Contructs an DSF file from \a file.  If \a readProperties is true the
+       * file's audio properties will also be read using \a propertiesStyle.  If
+       * false, \a propertiesStyle is ignored.
+       */
+      File(FileName file, bool readProperties = true,
+           AudioProperties::ReadStyle propertiesStyle = AudioProperties::Average);
+
+      /*!
+       * Contructs an DSF file from \a file.  If \a readProperties is true the
+       * file's audio properties will also be read using \a propertiesStyle.  If
+       * false, \a propertiesStyle is ignored.
+       */
+      File(IOStream *stream, bool readProperties = true,
+           AudioProperties::ReadStyle propertiesStyle = AudioProperties::Average);
+
+      /*!
+       * Destroys this instance of the File.
+       */
+      virtual ~File();
+
+      /*!
+       * Returns the Tag for this file.
+       */
+      virtual ID3v2::Tag *tag() const;
+
+      /*!
+       * Returns the DSF::AudioProperties for this file.  If no audio properties
+       * were read then this will return a null pointer.
+       */
+      virtual AudioProperties *audioProperties() const;
+
+       /*!
+        * Implements the unified property interface -- export function.
+        * This method forwards to ID3v2::Tag::properties().
+        */
+      virtual PropertyMap properties() const;
+
+       /*!
+        * Implements the unified property interface -- import function.
+        * This method forwards to ID3v2::Tag::setProperties().
+        */
+       virtual PropertyMap setProperties(const PropertyMap &);
+
+      /*!
+       * Saves the file.
+       */
+      virtual bool save();
+
+      /*!
+       * Returns whether or not the given \a stream can be opened as a DSF
+       * file.
+       *
+       * \note This method is designed to do a quick check.  The result may
+       * not necessarily be correct.
+       */
+      static bool isSupported(IOStream *stream);
+
+    private:
+      File(const File &);
+      File &operator=(const File &);
+
+      void read(bool readProperties, AudioProperties::ReadStyle propertiesStyle);
+
+      class FilePrivate;
+      FilePrivate *d;
+    };
+  }
+}
+
+#endif

taglib/dsf/dsfproperties.cpp

@@ -0,0 +1,158 @@
+/***************************************************************************
+ copyright            : (C) 2013 by Stephen F. Booth
+ email                : me@sbooth.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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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/                                           *
+ ***************************************************************************/
+
+#include <tstring.h>
+#include <tdebug.h>
+
+#include "dsfproperties.h"
+
+using namespace TagLib;
+
+class DSF::AudioProperties::PropertiesPrivate
+{
+public:
+  PropertiesPrivate() :
+    formatVersion(0),
+    formatID(0),
+    channelType(0),
+    channelNum(0),
+    samplingFrequency(0),
+    bitsPerSample(0),
+    sampleCount(0),
+    blockSizePerChannel(0),
+    bitrate(0),
+    length(0) {}
+
+  // Nomenclature is from DSF file format specification
+  unsigned int formatVersion;
+  unsigned int formatID;
+  unsigned int channelType;
+  unsigned int channelNum;
+  unsigned int samplingFrequency;
+  unsigned int bitsPerSample;
+  long long sampleCount;
+  unsigned int blockSizePerChannel;
+
+  // Computed
+  int bitrate;
+  int length;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// public members
+////////////////////////////////////////////////////////////////////////////////
+
+DSF::AudioProperties::AudioProperties(const ByteVector &data, ReadStyle style) :
+  d(new PropertiesPrivate())
+{
+  read(data);
+}
+
+DSF::AudioProperties::~AudioProperties()
+{
+  delete d;
+}
+
+int DSF::AudioProperties::length() const
+{
+  return lengthInSeconds();
+}
+
+int DSF::AudioProperties::lengthInSeconds() const
+{
+  return d->length / 1000;
+}
+
+int DSF::AudioProperties::lengthInMilliseconds() const
+{
+  return d->length;
+}
+
+int DSF::AudioProperties::bitrate() const
+{
+  return d->bitrate;
+}
+
+int DSF::AudioProperties::sampleRate() const
+{
+  return d->samplingFrequency;
+}
+
+int DSF::AudioProperties::channels() const
+{
+  return d->channelNum;
+}
+
+// DSF specific
+int DSF::AudioProperties::formatVersion() const
+{
+  return d->formatVersion;
+}
+
+int DSF::AudioProperties::formatID() const
+{
+  return d->formatID;
+}
+
+int DSF::AudioProperties::channelType() const
+{
+  return d->channelType;
+}
+
+int DSF::AudioProperties::bitsPerSample() const
+{
+  return d->bitsPerSample;
+}
+
+long long DSF::AudioProperties::sampleCount() const
+{
+  return d->sampleCount;
+}
+
+int DSF::AudioProperties::blockSizePerChannel() const
+{
+  return d->blockSizePerChannel;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// private members
+////////////////////////////////////////////////////////////////////////////////
+
+void DSF::AudioProperties::read(const ByteVector &data)
+{
+  d->formatVersion       = data.toUInt32LE(0);
+  d->formatID            = data.toUInt32LE(4);
+  d->channelType         = data.toUInt32LE(8);
+  d->channelNum          = data.toUInt32LE(12);
+  d->samplingFrequency   = data.toUInt32LE(16);
+  d->bitsPerSample       = data.toUInt32LE(20);
+  d->sampleCount         = data.toInt64LE(24);
+  d->blockSizePerChannel = data.toUInt32LE(32);
+
+  d->bitrate = static_cast<int>(d->samplingFrequency * d->bitsPerSample * d->channelNum / 1000.0 + 0.5);
+
+  if(d->samplingFrequency > 0)
+    d->length = static_cast<int>(d->sampleCount * 1000.0 / d->samplingFrequency + 0.5);
+}

taglib/dsf/dsfproperties.h

@@ -0,0 +1,91 @@
+/***************************************************************************
+    copyright            : (C) 2013 by Stephen F. Booth
+    email                : me@sbooth.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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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_DSFPROPERTIES_H
+#define TAGLIB_DSFPROPERTIES_H
+
+#include "audioproperties.h"
+
+namespace TagLib {
+
+  namespace DSF {
+
+    class File;
+
+    //! An implementation of audio property reading for DSF
+
+    /*!
+     * This reads the data from a DSF stream found in the AudioProperties
+     * API.
+     */
+
+    class TAGLIB_EXPORT AudioProperties : public TagLib::AudioProperties
+    {
+    public:
+      /*!
+       * Create an instance of DSF::AudioProperties with the data read from the
+       * ByteVector \a data.
+       */
+      AudioProperties(const ByteVector &data, ReadStyle style);
+
+      /*!
+       * Destroys this DSF::AudioProperties instance.
+        */
+      virtual ~AudioProperties();
+
+      // Reimplementations.
+
+      virtual int length() const;
+      virtual int lengthInSeconds() const;
+      virtual int lengthInMilliseconds() const;
+      virtual int bitrate() const;
+      virtual int sampleRate() const;
+      virtual int channels() const;
+
+      int formatVersion() const;
+      int formatID() const;
+
+      /*!
+       * Channel type values: 1 = mono, 2 = stereo, 3 = 3 channels,
+       * 4 = quad, 5 = 4 channels, 6 = 5 channels, 7 = 5.1 channels
+       */
+      int channelType() const;
+      int bitsPerSample() const;
+      long long sampleCount() const;
+      int blockSizePerChannel() const;
+
+    private:
+      AudioProperties(const AudioProperties &);
+      AudioProperties &operator=(const AudioProperties &);
+
+      void read(const ByteVector &data);
+
+      class PropertiesPrivate;
+      PropertiesPrivate *d;
+    };
+  }
+}
+
+#endif

taglib/ebml/ebmlconstants.h

@@ -0,0 +1,58 @@
+/***************************************************************************
+    copyright            : (C) 2013 by Sebastian Rachuj
+    email                : rachus@web.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *   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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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_EBML_CONSTANTS
+#define TAGLIB_EBML_CONSTANTS
+
+namespace TagLib {
+
+  namespace EBML {
+    //! Shorter representation of the type.
+    typedef unsigned long long int ulli;
+    
+    //! The id of an EBML Void element that is just a placeholder.
+    const ulli Void = 0xecL;
+    
+    //! The id of an EBML CRC32 element that contains a crc32 value.
+    const ulli CRC32 = 0xc3L;
+    
+    //! A namespace containing the ids of the EBML header's elements.
+    namespace Header {
+      const ulli EBML = 0x1a45dfa3L;
+      const ulli EBMLVersion = 0x4286L;
+      const ulli EBMLReadVersion = 0x42f7L;
+      const ulli EBMLMaxIDWidth = 0x42f2L;
+      const ulli EBMLMaxSizeWidth = 0x42f3L;
+      const ulli DocType = 0x4282L;
+      const ulli DocTypeVersion = 0x4287L;
+      const ulli DocTypeReadVersion = 0x4285L;
+    }
+    
+  }
+
+}
+
+
+#endif

taglib/ebml/ebmlelement.cpp

@@ -0,0 +1,489 @@
+/***************************************************************************
+    copyright            : (C) 2013 by Sebastian Rachuj
+    email                : rachus@web.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *   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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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/                                           *
+ ***************************************************************************/
+
+#include "tdebug.h"
+#include "ebmlelement.h"
+
+using namespace TagLib;
+
+class EBML::Element::ElementPrivate
+{
+public:
+  // The id of this element.
+  ulli id;
+
+  // The position of the element, where the header begins.
+  long long position;
+
+  // The size of the element as read from the header. Note: Actually an ulli but
+  // due to the variable integer size limited, thus long long is ok.
+  long long size;
+
+  // The position of the element's data.
+  long long data;
+
+  // The element's children.
+  List<Element *> children;
+
+  // True: Treated this element as container and read children.
+  bool populated;
+
+  // The parent element. If NULL (0) this is the document root.
+  Element *parent;
+
+  // The file used to read and write.
+  File *document;
+
+  // Destructor: Clean up all children.
+  ~ElementPrivate()
+  {
+    for(List<Element *>::Iterator i = children.begin(); i != children.end(); ++i) {
+      delete *i;
+    }
+  }
+
+  // Reads a variable length integer from the file at the given position
+  // and saves its value to result. If cutOne is true the first one of the
+  // binary representation of the result is removed (required for size). If
+  // cutOne is false the one will remain in the result (required for id).
+  // This method returns the position directly after the read integer.
+  long long readVInt(long long position, ulli *result, bool cutOne = true)
+  {
+    document->seek(position);
+
+    // Determine the length of the integer
+    char firstByte = document->readBlock(1)[0];
+    size_t byteSize = 1;
+    for(size_t i = 0; i < 8 && ((firstByte << i) & (1 << 7)) == 0; ++i)
+      ++byteSize;
+
+    // Load the integer
+    document->seek(position);
+    ByteVector vint = document->readBlock(byteSize);
+
+    // Cut the one if requested
+    if(cutOne)
+      vint[0] = (vint[0] & (~(1 << (8 - byteSize))));
+
+    // Store the result and return the current position
+    if(result)
+      *result = static_cast<ulli>(vint.toInt64BE(0));
+    return position + byteSize;
+  }
+
+  // Returns a BytVector containing the given number in the variable integer
+  // format. Truncates numbers > 2^56 (^ means potency in this case).
+  // If addOne is true, the ByteVector will remain the One to determine the
+  // integer's length.
+  // If shortest is true, the ByteVector will be as short as possible (required
+  // for the id)
+  ByteVector createVInt(ulli number, bool addOne = true, bool shortest = true)
+  {
+    ByteVector vint = ByteVector::fromUInt64BE(number);
+
+    // Do we actually need to calculate the length of the variable length
+    // integer? If not, then prepend the 0b0000 0001 if necessary and return the
+    // vint.
+    if(!shortest) {
+      if(addOne)
+        vint[0] = 1;
+      return vint;
+    }
+
+    // Calculate the minimal length of the variable length integer
+    size_t byteSize = vint.size();
+    for(size_t i = 0; byteSize > 0 && vint[i] == 0; ++i)
+      --byteSize;
+
+    if(!addOne)
+      return ByteVector(vint.data() + vint.size() - byteSize, byteSize);
+
+    ulli firstByte = (1ULL << (vint.size() - byteSize));
+    // The most significant byte loses #bytSize bits for storing information.
+    // Therefore, we might need to increase byteSize.
+    if(number >= (firstByte << (8 * (byteSize - 1))) && byteSize < vint.size())
+      ++byteSize;
+    // Add the one at the correct position
+    size_t firstBytePosition = vint.size() - byteSize;
+    vint[firstBytePosition] |= (1 << firstBytePosition);
+    return ByteVector(vint.data() + firstBytePosition, byteSize);
+  }
+
+  // Returns a void element within this element which is at least "least" in
+  // size. Uses best fit method. Returns a null pointer if no suitable element
+  // was found.
+  Element *searchVoid(long long least = 0L)
+  {
+    Element *currentBest = 0;
+    for(List<Element *>::Iterator i = children.begin(); i != children.end(); ++i) {
+      if((*i)->d->id == Void &&
+        // We need room for the header if we don't remove the element.
+        ((((*i)->d->size + (*i)->d->data - (*i)->d->position) == least || ((*i)->d->size >= least)) &&
+        // best fit
+        (!currentBest || (*i)->d->size < currentBest->d->size))
+        ) {
+        currentBest = *i;
+      }
+    }
+    return currentBest;
+  }
+
+  // Replaces this element by a Void element. Returns true on success and false
+  // on error.
+  bool makeVoid()
+  {
+    ulli realSize = size + data - position;
+    ByteVector header(createVInt(Void, false));
+    ulli leftSize = realSize - (header.size() + sizeof(ulli));
+    // Does not make sense to create a Void element
+    if (leftSize > realSize)
+      return false;
+    header.append(createVInt(leftSize, true, false));
+    // Write to file
+    document->seek(position);
+    document->writeBlock(header);
+    // Update data
+    data = position + header.size();
+    size = leftSize;
+    return true;
+
+    // XXX: We actually should merge Voids, if possible.
+  }
+
+    // Reading constructor: Reads all unknown information from the file.
+  ElementPrivate(File *p_document, Element *p_parent = 0, long long p_position = 0) :
+    id(0),
+    position(p_position),
+    data(0),
+    populated(false),
+    parent(p_parent),
+    document(p_document)
+  {
+    if(parent) {
+      ulli ssize;
+      data = readVInt(readVInt(position, &id, false), &ssize);
+      size = static_cast<long long>(ssize);
+    }
+    else {
+      document->seek(0, File::End);
+      size = document->tell();
+    }
+  }
+
+  // Writing constructor: Takes given information, calculates missing information
+  // and writes everything to the file.
+  // Tries to use void elements if available in the parent.
+  ElementPrivate(ulli p_id, File *p_document, Element *p_parent,
+    long long p_position, long long p_size) :
+      id(p_id),
+      position(p_position),
+      size(p_size),
+      populated(true), // It is a new element so we know, there are no children.
+      parent(p_parent),
+      document(p_document)
+  {
+    // header
+    ByteVector content(createVInt(id, false).append(createVInt(size, true, false)));
+    data = position + content.size();
+    // space for children
+    content.resize(static_cast<size_t>(data - position + size));
+
+    Element *freeSpace;
+    if (!(freeSpace = searchVoid(content.size()))) {
+      // We have to make room
+      document->insert(content, position);
+      // Update parents
+      for(Element *current = parent; current->d->parent; current = current->d->parent) {
+        current->d->size += content.size();
+        // Create new header and write it.
+        ByteVector parentHeader(createVInt(current->d->id, false).append(createVInt(current->d->size, true, false)));
+        size_t oldHeaderSize = static_cast<size_t>(current->d->data - current->d->position);
+        if(oldHeaderSize < parentHeader.size()) {
+          ByteVector secondHeader(createVInt(current->d->id, false).append(createVInt(current->d->size)));
+          if(oldHeaderSize == secondHeader.size()) {
+            // Write the header where the old one was.
+            document->seek(current->d->position);
+            document->writeBlock(secondHeader);
+            continue; // Very important here!
+          }
+        }
+        // Insert the new header
+        document->insert(parentHeader, current->d->position, oldHeaderSize);
+        current->d->data = current->d->position + parentHeader.size();
+      }
+    }
+    else {
+      document->seek(freeSpace->d->position);
+      if((freeSpace->d->size + freeSpace->d->data - freeSpace->d->position)
+        == static_cast<long long>(content.size())) {
+        // Write to file
+        document->writeBlock(content);
+        // Update parent
+        for(List<Element *>::Iterator i = parent->d->children.begin();
+          i != parent->d->children.end(); ++i) {
+          if(freeSpace == *i)
+            parent->d->children.erase(i);
+        }
+        delete freeSpace;
+      }
+      else {
+        ulli newSize = freeSpace->d->size - content.size();
+        ByteVector newVoid(createVInt(Void, false).append(createVInt(newSize, true, false)));
+
+        // Check if the original size of the size field was really 8 byte
+        if (static_cast<long long>(newVoid.size()) != (freeSpace->d->data - freeSpace->d->position))
+          newVoid = createVInt(Void, false).append(createVInt(newSize));
+        // Update freeSpace
+        freeSpace->d->size = newSize;
+        freeSpace->d->data = freeSpace->d->position + newVoid.size();
+        // Write to file
+        document->writeBlock(
+          newVoid.resize(static_cast<size_t>(newVoid.size() + newSize)).append(content));
+      }
+    }
+  }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// public members
+////////////////////////////////////////////////////////////////////////////////
+
+EBML::Element::~Element()
+{
+  delete d;
+}
+
+EBML::Element::Element(EBML::File *document)
+  : d(new EBML::Element::ElementPrivate(document))
+{
+}
+
+EBML::Element *EBML::Element::getChild(EBML::ulli id)
+{
+  populate();
+  for(List<Element *>::Iterator i = d->children.begin(); i != d->children.end();
+    ++i) {
+    if ((*i)->d->id == id)
+      return *i;
+  }
+  return 0;
+}
+
+List<EBML::Element *> EBML::Element::getChildren(EBML::ulli id)
+{
+  populate();
+  List<Element *> result;
+  for(List<Element *>::Iterator i = d->children.begin(); i != d->children.end();
+    ++i) {
+    if ((*i)->d->id == id)
+      result.append(*i);
+  }
+  return result;
+}
+
+List<EBML::Element *> EBML::Element::getChildren()
+{
+  populate();
+  return d->children;
+}
+
+EBML::Element *EBML::Element::getParent()
+{
+  return d->parent;
+}
+
+ByteVector EBML::Element::getAsBinary()
+{
+  d->document->seek(d->data);
+  return d->document->readBlock(static_cast<size_t>(d->size));
+}
+
+String EBML::Element::getAsString()
+{
+  return String(getAsBinary(), String::UTF8);
+}
+
+long long EBML::Element::getAsInt()
+{
+  // The debug note about returning 0 because of empty data is irrelevant. The
+  // behavior is as expected.
+  return getAsBinary().toInt64BE(0);
+}
+
+EBML::ulli EBML::Element::getAsUnsigned()
+{
+  // The debug note about returning 0 because of empty data is irrelevant. The
+  // behavior is as expected.
+  return static_cast<ulli>(getAsBinary().toInt64BE(0));
+}
+
+long double EBML::Element::getAsFloat()
+{
+  const ByteVector bin = getAsBinary();
+  switch (bin.size())
+  {
+  case 4:
+    return bin.toFloat32BE(0);
+  case 8:
+    return bin.toFloat64BE(0);
+  case 10:
+    return bin.toFloat80BE(0);
+  default:
+    debug("EBML::Element::getAsFloat() - Invalid data size. Returning 0.");
+    return 0.0;
+  }
+}
+
+EBML::Element *EBML::Element::addElement(EBML::ulli id)
+{
+  Element *elem = new Element(
+    new ElementPrivate(id, d->document, this, d->data + d->size, 0)
+  );
+  d->children.append(elem);
+  return elem;
+}
+
+EBML::Element *EBML::Element::addElement(EBML::ulli id, const ByteVector &binary)
+{
+  Element *elem = new Element(
+    new ElementPrivate(id, d->document, this, d->data + d->size, binary.size())
+  );
+  d->document->seek(elem->d->data);
+  d->document->writeBlock(binary);
+  d->children.append(elem);
+  return elem;
+}
+
+EBML::Element *EBML::Element::addElement(EBML::ulli id, const String &string)
+{
+  return addElement(id, string.data(String::UTF8));
+}
+
+EBML::Element *EBML::Element::addElement(EBML::ulli id, signed long long number)
+{
+  return addElement(id, ByteVector::fromUInt64BE(number));
+}
+
+EBML::Element *EBML::Element::addElement(EBML::ulli id, EBML::ulli number)
+{
+  return addElement(id, ByteVector::fromUInt64BE(number));
+}
+
+EBML::Element *EBML::Element::addElement(EBML::ulli id, long double number)
+{
+  // Probably, we will never need this method.
+  return 0;
+}
+
+bool EBML::Element::removeChildren(EBML::ulli id, bool useVoid)
+{
+  bool result = false;
+  for(List<Element *>::Iterator i = d->children.begin(); i != d->children.end(); ++i)
+    if((*i)->d->id == id) {
+      removeChild(*i, useVoid);
+      result = true;
+    }
+  return result;
+}
+
+bool EBML::Element::removeChildren(bool useVoid)
+{
+  // Maybe a better implementation, because we probably create a lot of voids
+  // in a row where a huge Void would be more appropriate.
+  if (d->children.isEmpty())
+    return false;
+
+  for(List<Element *>::Iterator i = d->children.begin(); i != d->children.end(); ++i)
+    removeChild(*i, useVoid);
+  return true;
+}
+
+bool EBML::Element::removeChild(Element *element, bool useVoid)
+{
+  if (!d->children.contains(element))
+    return false;
+
+  if(!useVoid || !element->d->makeVoid()) {
+    d->document->removeBlock(element->d->position, static_cast<size_t>(element->d->size));
+    // Update parents
+    for(Element* current = this; current; current = current->d->parent)
+      current->d->size -= element->d->size;
+    // Update this element
+    for(List<Element *>::Iterator i = d->children.begin(); i != d->children.end(); ++i)
+      if(element == *i)
+        d->children.erase(i);
+    delete element;
+  }
+  return true;
+}
+
+void EBML::Element::setAsBinary(const ByteVector &binary)
+{
+  // Maybe: Search for void element after this one
+  d->document->insert(binary, d->data, static_cast<size_t>(d->size));
+}
+
+void EBML::Element::setAsString(const String &string)
+{
+  setAsBinary(string.data(String::UTF8));
+}
+
+void EBML::Element::setAsInt(signed long long number)
+{
+  setAsBinary(ByteVector::fromUInt64BE(number));
+}
+
+void EBML::Element::setAsUnsigned(EBML::ulli number)
+{
+  setAsBinary(ByteVector::fromUInt64BE(number));
+}
+
+void EBML::Element::setAsFloat(long double)
+{
+  // Probably, we will never need this method.
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// private members
+////////////////////////////////////////////////////////////////////////////////
+
+void EBML::Element::populate()
+{
+  if(!d->populated) {
+    d->populated = true;
+    long long end = d->data + d->size;
+
+    for(long long i = d->data; i < end;) {
+      Element *elem = new Element(
+        new ElementPrivate(d->document, this, i)
+      );
+      d->children.append(elem);
+      i = elem->d->data + elem->d->size;
+    }
+  }
+}
+
+EBML::Element::Element(EBML::Element::ElementPrivate *pe) : d(pe)
+{}

taglib/ebml/ebmlelement.h

@@ -0,0 +1,276 @@
+/***************************************************************************
+    copyright            : (C) 2013 by Sebastian Rachuj
+    email                : rachus@web.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *   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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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_EBMLELEMENT_H
+#define TAGLIB_EBMLELEMENT_H
+
+#include "tlist.h"
+#include "tbytevector.h"
+#include "tstring.h"
+
+#include "ebmlfile.h"
+
+namespace TagLib {
+
+  namespace EBML {
+
+    /*!
+     * Represents an element of the EBML. The only instance of this child, that
+     * is directly used is the root element. Every other element is accessed
+     * via pointers to the elements within the root element.
+     *
+     * Just create one root instance per file to prevent race conditions.
+     *
+     * Changes of the document tree will be directly written back to the file.
+     * Invalid values (exceeding the maximal value defined in the RFC) will be
+     * truncated.
+     *
+     * This class should not be used by library users since the proper file
+     * class should handle the internals.
+     *
+     * NOTE: Currently does not adjust CRC32 values.
+     */
+    class TAGLIB_EXPORT Element
+    {
+    public:
+      //! Destroys the instance of the element.
+      ~Element();
+
+      /*!
+       * Creates an root element using document.
+       */
+      explicit Element(File *document);
+
+      /*!
+       * Returns the first found child element with the given id. Returns a null
+       * pointer if the child does not exist.
+       *
+       * Do not call this method if *this element is not a container element (see
+       * corresponding DTD)
+       */
+      Element *getChild(const ulli id);
+
+      /*!
+       * Returns a list of all child elements with the given id. Returns an
+       * empty list if no such element exists.
+       *
+       * Do not call this method if *this element is not a container element (see
+       * corresponding DTD)
+       */
+      List<Element *> getChildren(const ulli id);
+
+      /*!
+       * Returns a list of every child elements available. Returns an empty list
+       * if there are no children.
+       *
+       * Do not call this method if *this element is not a container element (see
+       * corresponding DTD)
+       */
+      List<Element *> getChildren();
+
+      /*!
+       * Returns the parent element or null if no such element exists.
+       */
+      Element *getParent();
+
+      /*!
+       * Returns the raw content of the element.
+       */
+      ByteVector getAsBinary();
+
+      /*!
+       * Returns the content of this element interpreted as a string.
+       */
+      String getAsString();
+
+      /*!
+       * Returns the content of this element interpreted as an signed integer.
+       *
+       * Do not call this method if *this element is not an INT element (see
+       * corresponding DTD)
+       */
+      long long getAsInt();
+
+      /*!
+       * Returns the content of this element interpreted as an unsigned integer.
+       *
+       * Do not call this method if *this element is not an UINT element (see
+       * corresponding DTD)
+       */
+      ulli getAsUnsigned();
+
+      /*!
+       * Returns the content of this element interpreted as a floating point
+       * type.
+       *
+       * Do not call this method if *this element is not an FLOAT element (see
+       * corresponding DTD)
+       *
+       * NOTE: There are 10 byte floats defined, therefore we might need a long
+       * double to store the value.
+       */
+      long double getAsFloat();
+
+      /*!
+       * Adds an empty element with given id to this element. Returns a pointer
+       * to the new element.
+       *
+       * Do not call this method if *this element is not a container element (see
+       * corresponding DTD)
+       */
+      Element *addElement(ulli id);
+
+      /*!
+       * Adds a new element, containing the given binary, to this element.
+       * Returns a pointer to the new element.
+       *
+       * Do not call this method if *this element is not a container element (see
+       * corresponding DTD)
+       */
+      Element *addElement(ulli id, const ByteVector &binary);
+
+      /*!
+       * Adds a new element, containing the given string, to this element.
+       * Returns a pointer to the new element.
+       *
+       * Do not call this method if *this element is not a container element (see
+       * corresponding DTD)
+       */
+      Element *addElement(ulli id, const String &string);
+
+      /*!
+       * Adds a new element, containing the given integer, to this element.
+       * Returns a pointer to the new element.
+       *
+       * Do not call this method if *this element is not a container element (see
+       * corresponding DTD)
+       */
+      Element *addElement(ulli id, signed long long number);
+
+      /*!
+       * Adds a new element, containing the given unsigned integer, to this element.
+       * Returns a pointer to the new element.
+       *
+       * Do not call this method if *this element is not a container element (see
+       * corresponding DTD)
+       */
+      Element *addElement(ulli id, ulli number);
+
+      /*!
+       * Adds a new element, containing the given floating point value, to this element.
+       * Returns a pointer to the new element.
+       *
+       * Do not call this method if *this element is not a container element (see
+       * corresponding DTD)
+       *
+       * This method is not implemented!
+       */
+      Element *addElement(ulli id, long double number);
+
+      /*!
+       * Removes all children with the given id. Returns false if there was no
+       * such element.
+       * If useVoid is true, the element will be changed to a void element.
+       *
+       * Do not call this method if *this element is not a container element (see
+       * corresponding DTD)
+       *
+       * Every pointer to a removed element is invalidated.
+       */
+      bool removeChildren(ulli id, bool useVoid = true);
+
+      /*!
+       * Removes all children. Returns false if this element had no children.
+       * If useVoid ist rue, the element will be changed to a void element.
+       *
+       * Do not call this method if *this element is not a container element (see
+       * corresponding DTD)
+       *
+       * Every pointer to a removed element is invalidated.
+       */
+      bool removeChildren(bool useVoid = true);
+
+      /*!
+       * Removes the given element.
+       * If useVoid is true, the element will be changed to a void element.
+       *
+       * Do not call this method if *this element is not a container element (see
+       * corresponding DTD)
+       *
+       * The pointer to the given element is invalidated.
+       */
+      bool removeChild(Element *element, bool useVoid = true);
+
+      /*!
+       * Writes the given binary to this element.
+       */
+      void setAsBinary(const ByteVector &binary);
+
+      /*!
+       * Writes the given string to this element.
+       */
+      void setAsString(const String &string);
+
+      /*!
+       * Writes the given integer to this element.
+       */
+      void setAsInt(signed long long number);
+
+      /*!
+       * Writes the given unsigned integer to this element.
+       */
+      void setAsUnsigned(ulli number);
+
+      /*!
+       * Writes the given floating point variable to this element.
+       *
+       * This method is not implemented!
+       */
+      void setAsFloat(long double number);
+
+    private:
+      //! Non-copyable
+      Element(const Element &);
+      //! Non-copyable
+      Element &operator=(const File &);
+
+      //! Lazy parsing. This method will be triggered when trying to access
+      //! children.
+      void populate();
+
+      class ElementPrivate;
+      ElementPrivate *d;
+
+      //! Creates a new Element from an ElementPrivate. (The constructor takes
+      //! ownership of the pointer and will delete it when the element is
+      //! destroyed.
+      Element(ElementPrivate *pe);
+    };
+
+  }
+}
+
+
+#endif

taglib/ebml/ebmlfile.cpp

@@ -0,0 +1,102 @@
+/***************************************************************************
+    copyright            : (C) 2013 by Sebastian Rachuj
+    email                : rachus@web.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *   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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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/                                           *
+ ***************************************************************************/
+
+#include "ebmlelement.h"
+
+using namespace TagLib;
+
+class EBML::File::FilePrivate
+{
+public:
+  explicit FilePrivate(File *document) : root(document)
+  {
+  }
+  
+  // Performs a few basic checks and creates the FilePrivate if they were
+  // successful.
+  static FilePrivate *checkAndCreate(File* document)
+  {
+    document->seek(0);
+    ByteVector magical = document->readBlock(4);
+    if(static_cast<ulli>(magical.toUInt32BE(0)) != Header::EBML)
+      return 0;
+    FilePrivate *d = new FilePrivate(document);
+    Element *head = d->root.getChild(Header::EBML);
+    Element *p;
+    if(!head ||
+      !((p = head->getChild(Header::EBMLVersion)) && p->getAsUnsigned() == 1L) ||
+      !((p = head->getChild(Header::EBMLReadVersion)) && p->getAsUnsigned() == 1L) ||
+      // Actually 4 is the current maximum of the EBML spec, but we support up to 8
+      !((p = head->getChild(Header::EBMLMaxIDWidth)) && p->getAsUnsigned() <= 8) ||
+      !((p = head->getChild(Header::EBMLMaxSizeWidth)) && p->getAsUnsigned() <= 8)
+    ) {
+      delete d;
+      return 0;
+	}
+	return d;
+  }
+  
+  Element root;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// public members
+////////////////////////////////////////////////////////////////////////////////
+
+EBML::File::~File()
+{
+  delete d;
+}
+
+EBML::Element *EBML::File::getDocumentRoot()
+{
+  if(!d && isValid())
+    d = new FilePrivate(this);
+  return &d->root;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// protected members
+////////////////////////////////////////////////////////////////////////////////
+
+EBML::File::File(FileName file) :
+  TagLib::File(file)
+{
+  if(isOpen()) {
+    d = FilePrivate::checkAndCreate(this);
+    if(!d)
+      setValid(false);
+  }
+}
+
+EBML::File::File(IOStream *stream) :
+  TagLib::File(stream)
+{
+  if(isOpen()) {
+    d = FilePrivate::checkAndCreate(this);
+    if(!d)
+      setValid(false);
+  }
+}

taglib/ebml/ebmlfile.h

@@ -0,0 +1,86 @@
+/***************************************************************************
+    copyright            : (C) 2013 by Sebastian Rachuj
+    email                : rachus@web.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *   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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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_EBMLFILE_H
+#define TAGLIB_EBMLFILE_H
+
+#include "taglib_export.h"
+#include "tfile.h"
+
+#include "ebmlconstants.h"
+
+namespace TagLib {
+
+  //! A namespace for the classes used by EBML-based metadata files
+  namespace EBML {
+  
+    class Element;
+  
+    /*!
+     * Represents an EBML file. It offers access to the root element which can
+     * be used to obtain the necessary information and to change the file
+     * according to changes.
+     */
+    class TAGLIB_EXPORT File : public TagLib::File
+    {
+    public:
+      //! Destroys the instance of the file.
+      virtual ~File();
+      
+      /*!
+       * Returns a pointer to the document root element of the EBML file.
+       */
+      Element *getDocumentRoot();
+      
+    protected:
+      /*!
+       * Constructs an instance of an EBML file from \a file.
+       *
+       * This constructor is protected since an object should be created
+       * through a specific subclass.
+       */
+      explicit File(FileName file);
+      
+      /*!
+       * Constructs an instance of an EBML file from an IOStream.
+       *
+       * This constructor is protected since an object should be created
+       * through a specific subclass.
+       */
+      explicit File(IOStream *stream);
+    
+    private:
+      //! Non-copyable
+      File(const File&);
+      File &operator=(const File &);
+      
+      class FilePrivate;
+      FilePrivate *d;
+    };
+  
+  }
+}
+
+#endif

taglib/ebml/matroska/ebmlmatroskaaudio.cpp

@@ -0,0 +1,135 @@
+/***************************************************************************
+    copyright            : (C) 2013 by Sebastian Rachuj
+    email                : rachus@web.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *   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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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/                                           *
+ ***************************************************************************/
+
+#include "ebmlmatroskaconstants.h"
+#include "ebmlmatroskaaudio.h"
+
+using namespace TagLib;
+
+class EBML::Matroska::AudioProperties::AudioPropertiesPrivate
+{
+public:
+  // Constructor
+  AudioPropertiesPrivate() :
+    length(0),
+    bitrate(0),
+    channels(1),
+    samplerate(8000) {}
+
+  // The length of the file
+  int length;
+
+  // The bitrate
+  int bitrate;
+
+  // The amount of channels
+  int channels;
+
+  // The sample rate
+  int samplerate;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// public members
+////////////////////////////////////////////////////////////////////////////////
+
+EBML::Matroska::AudioProperties::AudioProperties(File *document) :
+  d(new AudioPropertiesPrivate())
+{
+  read(document);
+}
+
+EBML::Matroska::AudioProperties::~AudioProperties()
+{
+  delete d;
+}
+
+int EBML::Matroska::AudioProperties::length() const
+{
+  return lengthInSeconds();
+}
+
+int EBML::Matroska::AudioProperties::lengthInSeconds() const
+{
+  return d->length / 1000;
+}
+
+int EBML::Matroska::AudioProperties::lengthInMilliseconds() const
+{
+  return d->length;
+}
+
+int EBML::Matroska::AudioProperties::bitrate() const
+{
+  return d->bitrate;
+}
+
+int EBML::Matroska::AudioProperties::channels() const
+{
+  return d->channels;
+}
+
+int EBML::Matroska::AudioProperties::sampleRate() const
+{
+  return d->samplerate;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// private members
+////////////////////////////////////////////////////////////////////////////////
+
+void EBML::Matroska::AudioProperties::read(File *document)
+{
+  Element *elem = document->getDocumentRoot()->getChild(Constants::Segment);
+  Element *info = elem->getChild(Constants::SegmentInfo);
+  Element *value;
+
+  if(info && (value = info->getChild(Constants::Duration))) {
+
+    const double length = value->getAsFloat() / 1000000.0;
+
+    if((value = info->getChild(Constants::TimecodeScale)))
+      d->length = static_cast<int>(length * value->getAsUnsigned() + 0.5);
+    else
+      d->length = static_cast<int>(length * 1000000 + 0.5);
+  }
+
+  info = elem->getChild(Constants::Tracks);
+  if(!info || !(info = info->getChild(Constants::TrackEntry)) ||
+    !(info = info->getChild(Constants::Audio))) {
+
+    return;
+  }
+
+  // Dirty bitrate:
+  if(d->length > 0)
+    d->bitrate = static_cast<int>(document->length() * 8.0 / d->length + 0.5);
+
+  if((value = info->getChild(Constants::Channels)))
+    d->channels = static_cast<int>(value->getAsUnsigned());
+
+  if((value = info->getChild(Constants::SamplingFrequency)))
+    d->samplerate = static_cast<int>(value->getAsFloat());
+}

taglib/ebml/matroska/ebmlmatroskaaudio.h

@@ -0,0 +1,92 @@
+/***************************************************************************
+    copyright            : (C) 2013 by Sebastian Rachuj
+    email                : rachus@web.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *   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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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_EBMLMATROSKAAUDIO_H
+#define TAGLIB_EBMLMATROSKAAUDIO_H
+
+#include "ebmlmatroskafile.h"
+
+#include "audioproperties.h"
+
+namespace TagLib {
+
+  namespace EBML {
+
+    namespace Matroska {
+
+      /*!
+       * This class represents the audio properties of a matroska file.
+       * Currently all information are read from the container format and
+       * could be inexact.
+       */
+      class TAGLIB_EXPORT AudioProperties : public TagLib::AudioProperties
+      {
+      public:
+        //! Destructor
+        virtual ~AudioProperties();
+
+        /*!
+         * Constructs an instance from a file.
+         */
+        explicit AudioProperties(File *document);
+
+        /*!
+         * Returns the length of the file.
+         */
+        virtual int length() const;
+        virtual int lengthInSeconds() const;
+        virtual int lengthInMilliseconds() const;
+
+        /*!
+         * Returns the bit rate of the file. Since the container format does not
+         * offer a proper value, it ist currently calculated by dividing the
+         * file size by the length.
+         */
+        virtual int bitrate() const;
+
+        /*!
+         * Returns the amount of channels of the file.
+         */
+        virtual int channels() const;
+
+        /*!
+         * Returns the sample rate of the file.
+         */
+        virtual int sampleRate() const;
+
+      private:
+        void read(File *document);
+
+        class AudioPropertiesPrivate;
+        AudioPropertiesPrivate *d;
+      };
+
+    }
+
+  }
+
+}
+
+#endif

taglib/ebml/matroska/ebmlmatroskaconstants.h

@@ -0,0 +1,140 @@
+/***************************************************************************
+    copyright            : (C) 2013 by Sebastian Rachuj
+    email                : rachus@web.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *   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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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_EBMLMATROSKACONSTANTS_H
+#define TAGLIB_EBMLMATROSKACONSTANTS_H
+
+#include "ebmlconstants.h"
+#include "tstring.h"
+
+namespace TagLib {
+
+  namespace EBML {
+    
+    namespace Matroska {
+        
+      namespace Constants {
+        
+        //! ID of an Matroska segment.
+        const ulli Segment = 0x18538067L;
+        
+        //! ID of the tags element.
+        const ulli Tags = 0x1254c367L;
+        
+        //! ID of the tag element.
+        const ulli Tag = 0x7373L;
+        
+        //! ID of the targets element.
+        const ulli Targets = 0x63c0L;
+        
+        //! ID of the target type value element.
+        const ulli TargetTypeValue = 0x68caL;
+        
+        //! ID of the target type element.
+        const ulli TargetType = 0x63caL;
+        
+        //! ID of a simple tag element.
+        const ulli SimpleTag = 0x67c8L;
+        
+        //! ID of the tag name.
+        const ulli TagName = 0x45a3L;
+        
+        //! ID of the tag content.
+        const ulli TagString = 0x4487L;
+        
+        //! The DocType of a matroska file.
+        const String DocTypeMatroska = "matroska";
+        
+        //! The DocType of a WebM file.
+        const String DocTypeWebM = "webm";
+        
+        
+        
+        //! The TITLE entry
+        const String TITLE = "TITLE";
+        
+        //! The ARTIST entry
+        const String ARTIST = "ARTIST";
+        
+        //! The COMMENT entry
+        const String COMMENT = "COMMENT";
+        
+        //! The GENRE entry
+        const String GENRE = "GENRE";
+        
+        //! The DATE_RELEASE entry
+        const String DATE_RELEASE = "DATE_RELEASE";
+        
+        //! The PART_NUMBER entry
+        const String PART_NUMBER = "PART_NUMBER";
+        
+        //! The TargetTypeValue of the most common grouping level (e.g. album)
+        const ulli MostCommonGroupingValue = 50;
+        
+        //! The TargetTypeValue of the most common parts of a group (e.g. track)
+        const ulli MostCommonPartValue = 30;
+        
+        //! Name of the TargetType of an album.
+        const String ALBUM = "ALBUM";
+        
+        //! Name of the TargetType of a track.
+        const String TRACK = "TRACK";
+        
+        
+        
+        // For AudioProperties
+        
+        //! ID of the Info block within the Segment.
+        const ulli SegmentInfo = 0x1549a966L;
+        
+        //! ID of the duration element.
+        const ulli Duration = 0x4489L;
+        
+        //! ID of TimecodeScale element.
+        const ulli TimecodeScale = 0x2ad7b1L;
+        
+        //! ID of the Tracks container
+        const ulli Tracks = 0x1654ae6bL;
+        
+        //! ID of a TrackEntry element.
+        const ulli TrackEntry = 0xaeL;
+        
+        //! ID of the Audio container.
+        const ulli Audio = 0xe1L;
+        
+        //! ID of the SamplingFrequency element.
+        const ulli SamplingFrequency = 0xb5L;
+        
+        //! ID of the Channels element.
+        const ulli Channels = 0x9fL;
+        
+        //! ID of the BitDepth element.
+        const ulli BitDepth = 0x6264L;
+      }
+    }
+  }
+}
+
+#endif

taglib/ebml/matroska/ebmlmatroskafile.cpp

@@ -0,0 +1,563 @@
+/***************************************************************************
+    copyright            : (C) 2013 by Sebastian Rachuj
+    email                : rachus@web.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *   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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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/                                           *
+ ***************************************************************************/
+
+#include "ebmlmatroskaconstants.h"
+#include "ebmlmatroskaaudio.h"
+
+#include "tpicturemap.h"
+#include "tpropertymap.h"
+
+using namespace TagLib;
+
+class EBML::Matroska::File::FilePrivate
+{
+public:
+  // Returns true if simpleTag has a TagName and TagString child and writes
+  // their contents into name and value.
+  bool extractContent(Element *simpleTag, String &name, String &value)
+  {
+    Element *n = simpleTag->getChild(Constants::TagName);
+    Element *v = simpleTag->getChild(Constants::TagString);
+    if(!n || !v)
+      return false;
+
+    name = n->getAsString();
+    value = v->getAsString();
+    return true;
+  }
+
+  explicit FilePrivate(File *p_document) : tag(0), document(p_document)
+  {
+    // Just get the first segment, because "Typically a Matroska file is
+    // composed of 1 segment."
+    Element* elem = document->getDocumentRoot()->getChild(Constants::Segment);
+
+    // We take the first tags element (there shouldn't be more), if there is
+    // non such element, consider the file as not compatible.
+    if(!elem || !(elem = elem->getChild(Constants::Tags))) {
+      document->setValid(false);
+      return;
+    }
+
+    // Load all Tag entries
+    List<Element *> entries = elem->getChildren(Constants::Tag);
+    for(List<Element *>::Iterator i = entries.begin(); i != entries.end(); ++i) {
+      Element *target = (*i)->getChild(Constants::Targets);
+      ulli ttvalue = 50; // 50 is default (see spec.)
+      if(target && (target = target->getChild(Constants::TargetTypeValue)))
+        ttvalue = target->getAsUnsigned();
+
+      // Load all SimpleTags
+      PropertyMap tagEntries;
+      List<Element *> simpleTags = (*i)->getChildren(Constants::SimpleTag);
+      for(List<Element *>::Iterator j = simpleTags.begin(); j != simpleTags.end();
+        ++j) {
+        String name, value;
+        if(!extractContent(*j, name, value))
+          continue;
+        tagEntries.insert(name, StringList(value));
+      }
+
+      tags.append(std::pair<PropertyMap, std::pair<Element *, ulli> >(tagEntries, std::pair<Element *, ulli>(*i, ttvalue)));
+    }
+  }
+
+  // Creates Tag and AudioProperties. Late creation because both require a fully
+  // functional FilePrivate (well AudioProperties doesn't...)
+  void lateCreate()
+  {
+    tag = new Tag(document);
+    audio = new AudioProperties(document);
+  }
+
+  // Checks the EBML header and creates the FilePrivate.
+  static FilePrivate *checkAndCreate(File *document)
+  {
+    Element *elem = document->getDocumentRoot()->getChild(Header::EBML);
+    Element *child = elem->getChild(Header::DocType);
+    if(child) {
+      String dt = child->getAsString();
+      if (dt == Constants::DocTypeMatroska || dt == Constants::DocTypeWebM) {
+        FilePrivate *fp = new FilePrivate(document);
+        return fp;
+      }
+    }
+
+    return 0;
+  }
+
+  // The tags with their Element and TargetTypeValue
+  List<std::pair<PropertyMap, std::pair<Element *, ulli> > > tags;
+
+  // The tag
+  Tag *tag;
+
+  // The audio properties
+  AudioProperties *audio;
+
+  // The corresponding file.
+  File *document;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// public members
+////////////////////////////////////////////////////////////////////////////////
+
+EBML::Matroska::File::~File()
+{
+  if (d) {
+    delete d->tag;
+    delete d->audio;
+    delete d;
+  }
+}
+
+EBML::Matroska::File::File(FileName file, bool, AudioProperties::ReadStyle) : EBML::File(file), d(0)
+{
+  if(isValid() && isOpen()) {
+    d = FilePrivate::checkAndCreate(this);
+    if(!d)
+      setValid(false);
+    else
+    d->lateCreate();
+  }
+}
+
+EBML::Matroska::File::File(IOStream *stream, bool, AudioProperties::ReadStyle) : EBML::File(stream), d(0)
+{
+  if(isValid() && isOpen()) {
+    d = FilePrivate::checkAndCreate(this);
+    if(!d)
+      setValid(false);
+    else
+      d->lateCreate();
+  }
+}
+
+Tag *EBML::Matroska::File::tag() const
+{
+  return d->tag;
+}
+
+PropertyMap EBML::Matroska::File::properties() const
+{
+  List<std::pair<PropertyMap, std::pair<Element *, ulli> > >::Iterator best = d->tags.end();
+  for(List<std::pair<PropertyMap, std::pair<Element *, ulli> > >::Iterator i = d->tags.begin();
+    i != d->tags.end(); ++i) {
+    if(best == d->tags.end() || best->second.second > i->second.second)
+      best = i;
+  }
+  return best->first;
+}
+
+PropertyMap EBML::Matroska::File::setProperties(const PropertyMap &properties)
+{
+  List<std::pair<PropertyMap, std::pair<Element *, ulli> > >::Iterator best = d->tags.end();
+  for(List<std::pair<PropertyMap, std::pair<Element *, ulli> > >::Iterator i = d->tags.begin();
+    i != d->tags.end(); ++i) {
+    if(best == d->tags.end() || best->second.second > i->second.second)
+      best = i;
+  }
+
+  std::pair<PropertyMap, std::pair<Element *, ulli> > replace(properties, best->second);
+  d->tags.erase(best);
+  d->tags.prepend(replace);
+
+  return PropertyMap();
+}
+
+AudioProperties *EBML::Matroska::File::audioProperties() const
+{
+  return d->audio;
+}
+
+bool EBML::Matroska::File::save()
+{
+  if(readOnly())
+    return false;
+
+  // C++11 features would be nice: for(auto &i : d->tags) { /* ... */ }
+  // Well, here we just iterate each extracted element.
+  for(List<std::pair<PropertyMap, std::pair<Element *, ulli> > >::Iterator i = d->tags.begin();
+    i != d->tags.end(); ++i) {
+
+    for(PropertyMap::Iterator j = i->first.begin(); j != i->first.end(); ++j) {
+
+      // No element? Create it!
+      if(!i->second.first) {
+        // Should be save, since we already checked, when creating the object.
+        Element *container = d->document->getDocumentRoot()
+          ->getChild(Constants::Segment)->getChild(Constants::Tags);
+
+        // Create Targets container
+        i->second.first = container->addElement(Constants::Tag);
+        Element *target = i->second.first->addElement(Constants::Targets);
+
+        if(i->second.second == Constants::MostCommonPartValue)
+          target->addElement(Constants::TargetType, Constants::TRACK);
+        else if(i->second.second == Constants::MostCommonGroupingValue)
+          target->addElement(Constants::TargetType, Constants::ALBUM);
+
+        target->addElement(Constants::TargetTypeValue, i->second.second);
+      }
+
+      // Find entries
+      List<Element *> simpleTags = i->second.first->getChildren(Constants::SimpleTag);
+      StringList::Iterator str = j->second.begin();
+      List<Element *>::Iterator k = simpleTags.begin();
+      for(; k != simpleTags.end(); ++k) {
+
+        String name, value;
+        if(!d->extractContent(*k, name, value))
+          continue;
+
+        // Write entry from StringList
+        if(name == j->first) {
+          if(str == j->second.end()) {
+            // We have all StringList elements but still found another element
+            // with the same name? Let's delete it!
+            i->second.first->removeChild(*k);
+          }
+          else {
+             if(value != *str) {
+              // extractContent already checked for availability
+              (*k)->getChild(Constants::TagString)->setAsString(*str);
+            }
+            ++str;
+          }
+        }
+      }
+
+      // If we didn't write the complete StringList, we have to write the rest.
+      for(; str != j->second.end(); ++str) {
+        Element *stag = i->second.first->addElement(Constants::SimpleTag);
+        stag->addElement(Constants::TagName, j->first);
+        stag->addElement(Constants::TagString, *str);
+      }
+    }
+
+    // Finally, we have to find elements that are not in the PropertyMap and
+    // remove them.
+    List<Element *> simpleTags = i->second.first->getChildren(Constants::SimpleTag);
+    for(List<Element *>::Iterator j = simpleTags.begin(); j != simpleTags.end(); ++j) {
+
+      String name, value;
+      if(!d->extractContent(*j, name, value))
+        continue;
+
+      if(i->first.find(name) == i->first.end()){
+        i->second.first->removeChild(*j);}
+    }
+  }
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Tag
+//
+////////////////////////////////////////////////////////////////////////////////
+
+
+class EBML::Matroska::File::Tag::TagPrivate
+{
+public:
+  // Creates a TagPrivate instance
+  explicit TagPrivate(File *p_document) :
+    document(p_document),
+    title(document->d->tags.end()),
+    artist(document->d->tags.end()),
+    album(document->d->tags.end()),
+    comment(document->d->tags.end()),
+    genre(document->d->tags.end()),
+    year(document->d->tags.end()),
+    track(document->d->tags.end())
+  {
+
+    for(List<std::pair<PropertyMap, std::pair<Element *, ulli> > >::Iterator i =
+      document->d->tags.begin(); i != document->d->tags.end(); ++i) {
+
+      // Just save it, if the title is more specific, or there is no title yet.
+      if(i->first.find(Constants::TITLE) != i->first.end() &&
+        (title == document->d->tags.end() ||
+        title->second.second > i->second.second ||
+        i->second.second == Constants::MostCommonPartValue)) {
+
+        title = i;
+      }
+
+      // Same goes for artist.
+      if(i->first.find(Constants::ARTIST) != i->first.end() &&
+        (artist == document->d->tags.end() ||
+        artist->second.second > i->second.second ||
+        i->second.second == Constants::MostCommonPartValue)) {
+
+        artist = i;
+      }
+
+      // Here, we also look for a title (the album title), but since we
+      // specified the granularity, we have to search for it exactly.
+      // Therefore it is possible, that title and album are the same (if only
+      // the title of the album is given).
+      if(i->first.find(Constants::TITLE) != i->first.end() &&
+        i->second.second == Constants::MostCommonGroupingValue) {
+
+        album = i;
+      }
+
+      // Again the same as title and artist.
+      if(i->first.find(Constants::COMMENT) != i->first.end() &&
+        (comment == document->d->tags.end() ||
+        comment->second.second > i->second.second ||
+        i->second.second == Constants::MostCommonPartValue)) {
+
+        comment = i;
+      }
+
+      // Same goes for genre.
+      if(i->first.find(Constants::GENRE) != i->first.end() &&
+        (genre == document->d->tags.end() ||
+        genre->second.second > i->second.second ||
+        i->second.second == Constants::MostCommonPartValue)) {
+
+        genre = i;
+      }
+
+      // And year (in our case: DATE_REALEASE)
+      if(i->first.find(Constants::DATE_RELEASE) != i->first.end() &&
+        (year == document->d->tags.end() ||
+        year->second.second > i->second.second ||
+        i->second.second == Constants::MostCommonPartValue)) {
+
+        year = i;
+      }
+
+      // And track (in our case: PART_NUMBER)
+      if(i->first.find(Constants::PART_NUMBER) != i->first.end() &&
+        (track == document->d->tags.end() ||
+        track->second.second > i->second.second ||
+        i->second.second == Constants::MostCommonPartValue)) {
+
+        track = i;
+      }
+    }
+  }
+
+  // Searches for the Tag with given TargetTypeValue (returns the first one)
+  List<std::pair<PropertyMap, std::pair<Element *, ulli> > >::Iterator
+  find(ulli ttv)
+  {
+    for(List<std::pair<PropertyMap, std::pair<Element *, ulli> > >::Iterator i =
+      document->d->tags.begin(); i != document->d->tags.end(); ++i) {
+
+      if(i->second.second == ttv)
+        return i;
+    }
+    return document->d->tags.end();
+  }
+
+  // Updates the given information
+  void update(
+    List<std::pair<PropertyMap, std::pair<Element *, ulli> > >::Iterator t,
+    const String &tagname,
+    const String &s
+    )
+  {
+    t->first.find(tagname)->second.front() = s;
+  }
+
+  // Inserts a tag with given information
+  void insert(const String &tagname, const ulli ttv, const String &s)
+  {
+    for(List<std::pair<PropertyMap, std::pair<Element *, ulli> > >::Iterator i =
+      document->d->tags.begin(); i != document->d->tags.end(); ++i) {
+
+      if(i->second.second == ttv) {
+        i->first.insert(tagname, StringList(s));
+        return;
+      }
+    }
+
+    // Not found? Create new!
+    PropertyMap pm;
+    pm.insert(tagname, StringList(s));
+    document->d->tags.append(
+      std::pair<PropertyMap, std::pair<Element *, ulli> >(pm,
+        std::pair<Element *, ulli>(static_cast<Element *>(0), ttv)
+      )
+    );
+  }
+
+  // The PropertyMap from the Matroska::File
+  File *document;
+
+  // Iterators to the tags.
+  List<std::pair<PropertyMap, std::pair<Element *, ulli> > >::Iterator title;
+  List<std::pair<PropertyMap, std::pair<Element *, ulli> > >::Iterator artist;
+  List<std::pair<PropertyMap, std::pair<Element *, ulli> > >::Iterator album;
+  List<std::pair<PropertyMap, std::pair<Element *, ulli> > >::Iterator comment;
+  List<std::pair<PropertyMap, std::pair<Element *, ulli> > >::Iterator genre;
+  List<std::pair<PropertyMap, std::pair<Element *, ulli> > >::Iterator year;
+  List<std::pair<PropertyMap, std::pair<Element *, ulli> > >::Iterator track;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// public members
+////////////////////////////////////////////////////////////////////////////////
+
+EBML::Matroska::File::Tag::~Tag()
+{
+  delete e;
+}
+
+EBML::Matroska::File::Tag::Tag(EBML::Matroska::File *document) :
+  e(new EBML::Matroska::File::Tag::TagPrivate(document))
+{
+}
+
+String EBML::Matroska::File::Tag::title() const
+{
+  if(e->title != e->document->d->tags.end())
+    return e->title->first.find(Constants::TITLE)->second.front();
+  else
+    return String();
+}
+
+String EBML::Matroska::File::Tag::artist() const
+{
+  if(e->artist != e->document->d->tags.end())
+    return e->artist->first.find(Constants::ARTIST)->second.front();
+  else
+    return String();
+}
+
+String EBML::Matroska::File::Tag::album() const
+{
+  if(e->album != e->document->d->tags.end())
+    return e->album->first.find(Constants::TITLE)->second.front();
+  else
+    return String();
+}
+
+PictureMap EBML::Matroska::File::Tag::pictures() const
+{
+  return PictureMap();
+}
+
+String EBML::Matroska::File::Tag::comment() const
+{
+  if(e->comment != e->document->d->tags.end())
+    return e->comment->first.find(Constants::COMMENT)->second.front();
+  else
+    return String();
+}
+
+String EBML::Matroska::File::Tag::genre() const
+{
+  if(e->genre != e->document->d->tags.end())
+    return e->genre->first.find(Constants::GENRE)->second.front();
+  else
+    return String();
+}
+
+unsigned int EBML::Matroska::File::Tag::year() const
+{
+  if(e->year != e->document->d->tags.end())
+    return e->year->first.find(Constants::DATE_RELEASE)->second.front().toInt();
+  else
+    return 0;
+}
+
+unsigned int EBML::Matroska::File::Tag::track() const
+{
+  if(e->track != e->document->d->tags.end())
+    return e->track->first.find(Constants::PART_NUMBER)->second.front().toInt();
+  else
+    return 0;
+}
+
+void EBML::Matroska::File::Tag::setTitle(const String &s)
+{
+  if(e->title != e->document->d->tags.end())
+    e->update(e->title, Constants::TITLE, s);
+  else
+    e->insert(Constants::TITLE, Constants::MostCommonPartValue, s);
+}
+
+void EBML::Matroska::File::Tag::setArtist(const String &s)
+{
+  if(e->artist != e->document->d->tags.end())
+    e->update(e->artist, Constants::ARTIST, s);
+  else
+    e->insert(Constants::ARTIST, Constants::MostCommonPartValue, s);
+}
+
+void EBML::Matroska::File::Tag::setAlbum(const String &s)
+{
+  if(e->album != e->document->d->tags.end())
+    e->update(e->album, Constants::TITLE, s);
+  else
+    e->insert(Constants::TITLE, Constants::MostCommonGroupingValue, s);
+}
+
+void EBML::Matroska::File::Tag::setPictures(const PictureMap& p )
+{
+    (void)p; // avoid warning for unused variable
+}
+
+void EBML::Matroska::File::Tag::setComment(const String &s)
+{
+  if(e->comment != e->document->d->tags.end())
+    e->update(e->comment, Constants::COMMENT, s);
+  else
+    e->insert(Constants::COMMENT, Constants::MostCommonPartValue, s);
+}
+
+void EBML::Matroska::File::Tag::setGenre(const String &s)
+{
+  if(e->genre != e->document->d->tags.end())
+    e->update(e->genre, Constants::GENRE, s);
+  else
+    e->insert(Constants::GENRE, Constants::MostCommonPartValue, s);
+}
+
+void EBML::Matroska::File::Tag::setYear(unsigned int i)
+{
+  String s = String::number(i);
+  if(e->year != e->document->d->tags.end())
+    e->update(e->year, Constants::DATE_RELEASE, s);
+  else
+    e->insert(Constants::DATE_RELEASE, Constants::MostCommonPartValue, s);
+}
+
+void EBML::Matroska::File::Tag::setTrack(unsigned int i)
+{
+  String s = String::number(i);
+  if(e->track != e->document->d->tags.end())
+    e->update(e->track, Constants::PART_NUMBER, s);
+  else
+    e->insert(Constants::PART_NUMBER, Constants::MostCommonPartValue, s);
+}

taglib/ebml/matroska/ebmlmatroskafile.h

@@ -0,0 +1,228 @@
+/***************************************************************************
+    copyright            : (C) 2013 by Sebastian Rachuj
+    email                : rachus@web.de
+ ***************************************************************************/
+
+/***************************************************************************
+ *   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., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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_EBMLMATROSKAFILE_H
+#define TAGLIB_EBMLMATROSKAFILE_H
+
+#include "ebmlelement.h"
+#include "audioproperties.h"
+
+namespace TagLib {
+
+  namespace EBML {
+
+    //! Implementation for reading Matroska tags.
+    namespace Matroska {
+
+      /*!
+       * Implements the TagLib::File API and offers access to the tags of the
+       * matroska file.
+       */
+      class TAGLIB_EXPORT File : public EBML::File
+      {
+      public:
+        //! Destroys the instance of the file.
+        virtual ~File();
+
+        /*!
+         * Constructs a Matroska file from \a file.  If \a readProperties is true the
+         * file's audio properties will also be read using \a propertiesStyle.  If
+         * false, \a propertiesStyle is ignored.
+         *
+         * \note In the current implementation, both \a readProperties and
+         * \a propertiesStyle are ignored.  The audio properties are always
+         * read.
+         */
+        explicit File(FileName file, bool readProperties = true,
+             AudioProperties::ReadStyle propertiesStyle = AudioProperties::Average);
+
+        /*!
+         * Constructs a Matroska file from \a stream.  If \a readProperties is true the
+         * file's audio properties will also be read using \a propertiesStyle.  If
+         * false, \a propertiesStyle is ignored.
+         *
+         * \note In the current implementation, both \a readProperties and
+         * \a propertiesStyle are ignored.  The audio properties are always
+         * read.
+         */
+        explicit File(IOStream *stream, bool readproperties = true,
+             AudioProperties::ReadStyle propertiesStyle = AudioProperties::Average);
+
+        /*!
+         * Returns the pointer to a tag that allow access on common tags.
+         */
+        virtual TagLib::Tag *tag() const;
+
+        /*!
+         * Exports the tags to a PropertyMap. Due to the diversity of the
+         * Matroska format (e.g. multiple media streams in one file, each with
+         * its own tags), only the best fitting tags are taken into account.
+         * There are no unsupported tags.
+         */
+        virtual PropertyMap properties() const;
+
+        /*!
+         * Sets the tags of the file to those specified in properties. The
+         * returned PropertyMap is always empty.
+         * Note: Only the best fitting tags are taken into account.
+         */
+        virtual PropertyMap setProperties(const PropertyMap &properties);
+
+        /*!
+         * Returns a pointer to this file's audio properties.
+         *
+         * I'm glad about not having a setAudioProperties method ;)
+         */
+        virtual AudioProperties *audioProperties() const;
+
+        /*!
+         * Saves the file. Returns true on success.
+         */
+        bool save();
+
+        /*!
+         * Offers access to a few common tag entries.
+         */
+        class Tag : public TagLib::Tag
+        {
+         public:
+          //! Destroys the tag.
+          ~Tag();
+
+          /*!
+           * Creates a new Tag for Matroska files. The given properties are gained
+           * by the Matroska::File.
+           */
+          explicit Tag(File *document);
+
+          /*!
+           * Returns the track name; if no track name is present in the tag
+           * String::null will be returned.
+           */
+          virtual String title() const;
+
+          /*!
+           * Returns the artist name; if no artist name is present in the tag
+           * String::null will be returned.
+           */
+          virtual String artist() const;
+
+          /*!
+           * Returns the album name; if no album name is present in the tag
+           * String::null will be returned.
+           */
+          virtual String album() const;
+
+          /*!
+           * Returns a list of pictures; if no picture is present in the tag
+           * an empty PictureMap is returned
+           */
+          virtual PictureMap pictures() const;
+
+          /*!
+           * Returns the track comment; if no comment is present in the tag
+           * String::null will be returned.
+           */
+          virtual String comment() const;
+
+          /*!
+           * Returns the genre name; if no genre is present in the tag String::null
+           * will be returned.
+           */
+          virtual String genre() const;
+
+          /*!
+           * Returns the year; if there is no year set, this will return 0.
+           */
+          virtual unsigned int year() const;
+
+          /*!
+           * Returns the track number; if there is no track number set, this will
+           * return 0.
+           */
+          virtual unsigned int track() const;
+
+          /*!
+           * Sets the title to s. If s is String::null then this value will be
+           * cleared.
+           */
+          virtual void setTitle(const String &s);
+
+          /*!
+           * Sets the artist to s. If s is String::null then this value will be
+           * cleared.
+           */
+          virtual void setArtist(const String &s);
+
+          /*!
+           * Sets the album to s. If s is String::null then this value will be
+           * cleared.
+           */
+          virtual void setAlbum(const String &s);
+
+          /*!
+           * Sets the picture map to p. If p is empty then this value will be
+           * cleared
+           */
+          virtual void setPictures(const PictureMap& p );
+
+          /*!
+           * Sets the comment to s. If s is String::null then this value will be
+           * cleared.
+           */
+          virtual void setComment(const String &s);
+
+          /*!
+           * Sets the genre to s. If s is String::null then this value will be
+           * cleared.
+           */
+          virtual void setGenre(const String &s);
+
+          /*!
+           * Sets the year to i. If s is 0 then this value will be cleared.
+           */
+          virtual void setYear(unsigned int i);
+
+          /*!
+           * Sets the track to i. If s is 0 then this value will be cleared.
+           */
+          virtual void setTrack(unsigned int i);
+
+        private:
+          class TagPrivate;
+          TagPrivate *e;
+        };
+
+      private:
+        class FilePrivate;
+        FilePrivate *d;
+      };
+
+    }
+  }
+}
+
+#endif

taglib/fileref.cpp

@@ -27,13 +27,11 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <tfile.h>
+#include <tfilestream.h>
 #include <tstring.h>
 #include <tdebug.h>
+#include <tsmartptr.h>
 
 #include "fileref.h"
 #include "asffile.h"
@@ -45,6 +43,7 @@
 #include "mp4file.h"
 #include "wavpackfile.h"
 #include "speexfile.h"
+#include "opusfile.h"
 #include "trueaudiofile.h"
 #include "aifffile.h"
 #include "wavfile.h"
@@ -53,52 +52,216 @@
 #include "s3mfile.h"
 #include "itfile.h"
 #include "xmfile.h"
+#include "dsffile.h"
+#include "dsdifffile.h"
+#include "ebmlmatroskafile.h"
 
 using namespace TagLib;
 
-class FileRef::FileRefPrivate : public RefCounter
+namespace
 {
-public:
-  FileRefPrivate(File *f) : RefCounter(), file(f) {}
-  ~FileRefPrivate() {
-    delete file;
+  typedef List<const FileRef::FileTypeResolver *> ResolverList;
+  ResolverList fileTypeResolvers;
+
+  // Detect the file type by user-defined resolvers.
+
+  File *detectByResolvers(FileName fileName, bool readAudioProperties,
+                          AudioProperties::ReadStyle audioPropertiesStyle)
+  {
+    ResolverList::ConstIterator it = fileTypeResolvers.begin();
+    for(; it != fileTypeResolvers.end(); ++it) {
+      File *file = (*it)->createFile(fileName, readAudioProperties, audioPropertiesStyle);
+      if(file)
+        return file;
+    }
+
+    return 0;
   }
 
-  File *file;
-  static List<const FileTypeResolver *> fileTypeResolvers;
-};
+  // Detect the file type based on the file extension.
 
-List<const FileRef::FileTypeResolver *> FileRef::FileRefPrivate::fileTypeResolvers;
+  File* detectByExtension(IOStream *stream, bool readAudioProperties,
+                          AudioProperties::ReadStyle audioPropertiesStyle)
+  {
+#ifdef _WIN32
+    const String s(stream->name().wstr());
+#else
+    const String s(stream->name());
+#endif
+
+    String ext;
+    const size_t pos = s.rfind(".");
+    if(pos != String::npos())
+      ext = s.substr(pos + 1).upper();
+
+    // If this list is updated, the method defaultFileExtensions() should also be
+    // updated.  However at some point that list should be created at the same time
+    // that a default file type resolver is created.
+
+    if(ext.isEmpty())
+      return 0;
+
+    // .oga can be any audio in the Ogg container. So leave it to content-based detection.
+
+    if(ext == "MP3")
+      return new MPEG::File(stream, ID3v2::FrameFactory::instance(), readAudioProperties, audioPropertiesStyle);
+    if(ext == "OGG")
+      return new Ogg::Vorbis::File(stream, readAudioProperties, audioPropertiesStyle);
+    if(ext == "FLAC")
+      return new FLAC::File(stream, readAudioProperties, audioPropertiesStyle);
+    if(ext == "MPC")
+      return new MPC::File(stream, readAudioProperties, audioPropertiesStyle);
+    if(ext == "WV")
+      return new WavPack::File(stream, readAudioProperties, audioPropertiesStyle);
+    if(ext == "SPX")
+      return new Ogg::Speex::File(stream, readAudioProperties, audioPropertiesStyle);
+    if(ext == "OPUS")
+      return new Ogg::Opus::File(stream, readAudioProperties, audioPropertiesStyle);
+    if(ext == "TTA")
+      return new TrueAudio::File(stream, readAudioProperties, audioPropertiesStyle);
+    if(ext == "M4A" || ext == "M4R" || ext == "M4B" || ext == "M4P" || ext == "MP4" || ext == "3G2" || ext == "M4V")
+      return new MP4::File(stream, readAudioProperties, audioPropertiesStyle);
+    if(ext == "WMA" || ext == "ASF")
+      return new ASF::File(stream, readAudioProperties, audioPropertiesStyle);
+    if(ext == "AIF" || ext == "AIFF" || ext == "AFC" || ext == "AIFC")
+      return new RIFF::AIFF::File(stream, readAudioProperties, audioPropertiesStyle);
+    if(ext == "WAV")
+      return new RIFF::WAV::File(stream, readAudioProperties, audioPropertiesStyle);
+    if(ext == "APE")
+      return new APE::File(stream, readAudioProperties, audioPropertiesStyle);
+    // module, nst and wow are possible but uncommon extensions
+    if(ext == "MOD" || ext == "MODULE" || ext == "NST" || ext == "WOW")
+      return new Mod::File(stream, readAudioProperties, audioPropertiesStyle);
+    if(ext == "S3M")
+      return new S3M::File(stream, readAudioProperties, audioPropertiesStyle);
+    if(ext == "IT")
+      return new IT::File(stream, readAudioProperties, audioPropertiesStyle);
+    if(ext == "XM")
+      return new XM::File(stream, readAudioProperties, audioPropertiesStyle);
+    if(ext == "DFF" || ext == "DSDIFF")
+      return new DSDIFF::File(stream, readAudioProperties, audioPropertiesStyle);
+    if(ext == "DSF")
+      return new DSF::File(stream, readAudioProperties, audioPropertiesStyle);
+    if (ext == "MKA" || ext == "MKV") {
+      return new EBML::Matroska::File(stream, readAudioProperties, audioPropertiesStyle);
+    }
+
+    return 0;
+  }
+
+  // Detect the file type based on the actual content of the stream.
+
+  File *detectByContent(IOStream *stream, bool readAudioProperties,
+                        AudioProperties::ReadStyle audioPropertiesStyle)
+  {
+    File *file = 0;
+
+    if(MPEG::File::isSupported(stream))
+      file = new MPEG::File(stream, ID3v2::FrameFactory::instance(), readAudioProperties, audioPropertiesStyle);
+    else if(Ogg::Vorbis::File::isSupported(stream))
+      file = new Ogg::Vorbis::File(stream, readAudioProperties, audioPropertiesStyle);
+    else if(Ogg::FLAC::File::isSupported(stream))
+      file = new Ogg::FLAC::File(stream, readAudioProperties, audioPropertiesStyle);
+    else if(FLAC::File::isSupported(stream))
+      file = new FLAC::File(stream, readAudioProperties, audioPropertiesStyle);
+    else if(MPC::File::isSupported(stream))
+      file = new MPC::File(stream, readAudioProperties, audioPropertiesStyle);
+    else if(WavPack::File::isSupported(stream))
+      file = new WavPack::File(stream, readAudioProperties, audioPropertiesStyle);
+    else if(Ogg::Speex::File::isSupported(stream))
+      file = new Ogg::Speex::File(stream, readAudioProperties, audioPropertiesStyle);
+    else if(Ogg::Opus::File::isSupported(stream))
+      file = new Ogg::Opus::File(stream, readAudioProperties, audioPropertiesStyle);
+    else if(TrueAudio::File::isSupported(stream))
+      file = new TrueAudio::File(stream, readAudioProperties, audioPropertiesStyle);
+    else if(MP4::File::isSupported(stream))
+      file = new MP4::File(stream, readAudioProperties, audioPropertiesStyle);
+    else if(ASF::File::isSupported(stream))
+      file = new ASF::File(stream, readAudioProperties, audioPropertiesStyle);
+    else if(RIFF::AIFF::File::isSupported(stream))
+      file = new RIFF::AIFF::File(stream, readAudioProperties, audioPropertiesStyle);
+    else if(RIFF::WAV::File::isSupported(stream))
+      file = new RIFF::WAV::File(stream, readAudioProperties, audioPropertiesStyle);
+    else if(APE::File::isSupported(stream))
+      file = new APE::File(stream, readAudioProperties, audioPropertiesStyle);
+    else if(DSDIFF::File::isSupported(stream))
+      file = new DSDIFF::File(stream, readAudioProperties, audioPropertiesStyle);
+    else if(DSF::File::isSupported(stream))
+      file = new DSF::File(stream, readAudioProperties, audioPropertiesStyle);
+
+    // isSupported() only does a quick check, so double check the file here.
+
+    if(file) {
+      if(file->isValid())
+        return file;
+      else
+        delete file;
+    }
+
+    return 0;
+  }
+
+  struct FileRefData
+  {
+    FileRefData() :
+      file(0),
+      stream(0) {}
+
+    ~FileRefData() {
+      delete file;
+      delete stream;
+    }
+
+    File     *file;
+    IOStream *stream;
+  };
+}
+
+class FileRef::FileRefPrivate
+{
+public:
+  FileRefPrivate() :
+    data(new FileRefData()) {}
+
+  SHARED_PTR<FileRefData> data;
+};
 
 ////////////////////////////////////////////////////////////////////////////////
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-FileRef::FileRef()
+FileRef::FileRef() :
+  d(new FileRefPrivate())
 {
-  d = new FileRefPrivate(0);
 }
 
 FileRef::FileRef(FileName fileName, bool readAudioProperties,
-                 AudioProperties::ReadStyle audioPropertiesStyle)
+                 AudioProperties::ReadStyle audioPropertiesStyle) :
+  d(new FileRefPrivate())
 {
-  d = new FileRefPrivate(create(fileName, readAudioProperties, audioPropertiesStyle));
+  parse(fileName, readAudioProperties, audioPropertiesStyle);
 }
 
-FileRef::FileRef(File *file)
+FileRef::FileRef(IOStream* stream, bool readAudioProperties, AudioProperties::ReadStyle audioPropertiesStyle) :
+  d(new FileRefPrivate())
 {
-  d = new FileRefPrivate(file);
+  parse(stream, readAudioProperties, audioPropertiesStyle);
 }
 
-FileRef::FileRef(const FileRef &ref) : d(ref.d)
+FileRef::FileRef(File *file) :
+  d(new FileRefPrivate())
+{
+  d->data->file = file;
+}
+
+FileRef::FileRef(const FileRef &ref) :
+  d(new FileRefPrivate(*ref.d))
 {
-  d->ref();
 }
 
 FileRef::~FileRef()
 {
-  if(d->deref())
-    delete d;
+  delete d;
 }
 
 Tag *FileRef::tag() const
@@ -107,7 +270,37 @@ Tag *FileRef::tag() const
     debug("FileRef::tag() - Called without a valid file.");
     return 0;
   }
-  return d->file->tag();
+  return d->data->file->tag();
+}
+
+PropertyMap FileRef::properties() const
+{
+  if(isNull()) {
+    debug("FileRef::properties() - Called without a valid file.");
+    return PropertyMap();
+  }
+
+  return d->data->file->properties();
+}
+
+void FileRef::removeUnsupportedProperties(const StringList& properties)
+{
+  if(isNull()) {
+    debug("FileRef::removeUnsupportedProperties() - Called without a valid file.");
+    return;
+  }
+
+  d->data->file->removeUnsupportedProperties(properties);
+}
+
+PropertyMap FileRef::setProperties(const PropertyMap &properties)
+{
+  if(isNull()) {
+    debug("FileRef::setProperties() - Called without a valid file.");
+    return PropertyMap();
+  }
+
+  return d->data->file->setProperties(properties);
 }
 
 AudioProperties *FileRef::audioProperties() const
@@ -116,12 +309,12 @@ AudioProperties *FileRef::audioProperties() const
     debug("FileRef::audioProperties() - Called without a valid file.");
     return 0;
   }
-  return d->file->audioProperties();
+  return d->data->file->audioProperties();
 }
 
 File *FileRef::file() const
 {
-  return d->file;
+  return d->data->file;
 }
 
 bool FileRef::save()
@@ -130,12 +323,12 @@ bool FileRef::save()
     debug("FileRef::save() - Called without a valid file.");
     return false;
   }
-  return d->file->save();
+  return d->data->file->save();
 }
 
 const FileRef::FileTypeResolver *FileRef::addFileTypeResolver(const FileRef::FileTypeResolver *resolver) // static
 {
-  FileRefPrivate::fileTypeResolvers.prepend(resolver);
+  fileTypeResolvers.prepend(resolver);
   return resolver;
 }
 
@@ -157,6 +350,7 @@ StringList FileRef::defaultFileExtensions()
   l.append("m4p");
   l.append("3g2");
   l.append("mp4");
+  l.append("m4v");
   l.append("wma");
   l.append("asf");
   l.append("aif");
@@ -170,110 +364,92 @@ StringList FileRef::defaultFileExtensions()
   l.append("s3m");
   l.append("it");
   l.append("xm");
+  l.append("dsf");
+  l.append("dff");
+  l.append("dsdiff"); // alias for "dff"
+  l.append("mka");
+  l.append("mkv");
 
   return l;
 }
 
+bool FileRef::isValid() const
+{
+  return (d->data->file && d->data->file->isValid());
+}
+
 bool FileRef::isNull() const
 {
-  return !d->file || !d->file->isValid();
+  return !isValid();
 }
 
 FileRef &FileRef::operator=(const FileRef &ref)
 {
-  if(&ref == this)
-    return *this;
-
-  if(d->deref())
-    delete d;
-
-  d = ref.d;
-  d->ref();
-
+  FileRef(ref).swap(*this);
   return *this;
 }
 
+void FileRef::swap(FileRef &ref)
+{
+  using std::swap;
+
+  swap(d, ref.d);
+}
+
 bool FileRef::operator==(const FileRef &ref) const
 {
-  return ref.d->file == d->file;
+  return (ref.d->data == d->data);
 }
 
 bool FileRef::operator!=(const FileRef &ref) const
 {
-  return ref.d->file != d->file;
+  return (ref.d->data != d->data);
 }
 
-File *FileRef::create(FileName fileName, bool readAudioProperties,
-                      AudioProperties::ReadStyle audioPropertiesStyle) // static
+////////////////////////////////////////////////////////////////////////////////
+// private members
+////////////////////////////////////////////////////////////////////////////////
+
+void FileRef::parse(FileName fileName, bool readAudioProperties,
+                    AudioProperties::ReadStyle audioPropertiesStyle)
 {
+  // Try user-defined resolvers.
 
-  List<const FileTypeResolver *>::ConstIterator it = FileRefPrivate::fileTypeResolvers.begin();
+  d->data->file = detectByResolvers(fileName, readAudioProperties, audioPropertiesStyle);
+  if(d->data->file)
+    return;
 
-  for(; it != FileRefPrivate::fileTypeResolvers.end(); ++it) {
-    File *file = (*it)->createFile(fileName, readAudioProperties, audioPropertiesStyle);
-    if(file)
-      return file;
-  }
+  // Try to resolve file types based on the file extension.
 
-  // Ok, this is really dumb for now, but it works for testing.
+  d->data->stream = new FileStream(fileName);
+  d->data->file = detectByExtension(d->data->stream, readAudioProperties, audioPropertiesStyle);
+  if(d->data->file)
+    return;
 
-  String s;
+  // At last, try to resolve file types based on the actual content.
 
-#ifdef _WIN32
-  s = (wcslen((const wchar_t *) fileName) > 0) ? String((const wchar_t *) fileName) : String((const char *) fileName);
-#else
-  s = fileName;
-#endif
+  d->data->file = detectByContent(d->data->stream, readAudioProperties, audioPropertiesStyle);
+  if(d->data->file)
+    return;
 
-  // If this list is updated, the method defaultFileExtensions() should also be
-  // updated.  However at some point that list should be created at the same time
-  // that a default file type resolver is created.
+  // Stream have to be closed here if failed to resolve file types.
 
-  int pos = s.rfind(".");
-  if(pos != -1) {
-    String ext = s.substr(pos + 1).upper();
-    if(ext == "MP3")
-      return new MPEG::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "OGG")
-      return new Ogg::Vorbis::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "OGA") {
-      /* .oga can be any audio in the Ogg container. First try FLAC, then Vorbis. */
-      File *file = new Ogg::FLAC::File(fileName, readAudioProperties, audioPropertiesStyle);
-      if (file->isValid())
-        return file;
-      delete file;
-      return new Ogg::Vorbis::File(fileName, readAudioProperties, audioPropertiesStyle);
-    }
-    if(ext == "FLAC")
-      return new FLAC::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "MPC")
-      return new MPC::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "WV")
-      return new WavPack::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "SPX")
-      return new Ogg::Speex::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "TTA")
-      return new TrueAudio::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "M4A" || ext == "M4R" || ext == "M4B" || ext == "M4P" || ext == "MP4" || ext == "3G2")
-      return new MP4::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "WMA" || ext == "ASF")
-      return new ASF::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "AIF" || ext == "AIFF")
-      return new RIFF::AIFF::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "WAV")
-      return new RIFF::WAV::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "APE")
-      return new APE::File(fileName, readAudioProperties, audioPropertiesStyle);
-    // module, nst and wow are possible but uncommon extensions
-    if(ext == "MOD" || ext == "MODULE" || ext == "NST" || ext == "WOW")
-      return new Mod::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "S3M")
-      return new S3M::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "IT")
-      return new IT::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "XM")
-      return new XM::File(fileName, readAudioProperties, audioPropertiesStyle);
-  }
-
-  return 0;
+  delete d->data->stream;
+  d->data->stream = 0;
+}
+
+void FileRef::parse(IOStream *stream, bool readAudioProperties,
+                    AudioProperties::ReadStyle audioPropertiesStyle)
+{
+  // User-defined resolvers won't work with a stream.
+
+  // Try to resolve file types based on the file extension.
+
+  d->data->file = detectByExtension(stream, readAudioProperties, audioPropertiesStyle);
+  if(d->data->file)
+    return;
+
+  // At last, try to resolve file types based on the actual content of the file.
+
+  d->data->file = detectByContent(stream, readAudioProperties, audioPropertiesStyle);
 }

taglib/fileref.h

@@ -26,10 +26,10 @@
 #ifndef TAGLIB_FILEREF_H
 #define TAGLIB_FILEREF_H
 
+#include "taglib_export.h"
 #include "tfile.h"
 #include "tstringlist.h"
-
-#include "taglib_export.h"
+#include "tpropertymap.h"
 #include "audioproperties.h"
 
 namespace TagLib {
@@ -72,7 +72,7 @@ namespace TagLib {
    *
    * class MyFileTypeResolver : FileTypeResolver
    * {
-   *   TagLib::File *createFile(TagLib::FileName *fileName, bool, AudioProperties::ReadStyle)
+   *   TagLib::File *createFile(TagLib::FileName *fileName, bool, AudioProperties::ReadStyle) const
    *   {
    *     if(someCheckForAnMP3File(fileName))
    *       return new TagLib::MPEG::File(fileName);
@@ -91,8 +91,9 @@ namespace TagLib {
 
     class TAGLIB_EXPORT FileTypeResolver
     {
-      TAGLIB_IGNORE_MISSING_DESTRUCTOR
     public:
+      virtual ~FileTypeResolver() {}
+
       /*!
        * This method must be overridden to provide an additional file type
        * resolver.  If the resolver is able to determine the file type it should
@@ -128,7 +129,24 @@ namespace TagLib {
                      audioPropertiesStyle = AudioProperties::Average);
 
     /*!
-     * Contruct a FileRef using \a file.  The FileRef now takes ownership of the
+     * Construct a FileRef from an opened \a IOStream.  If \a readAudioProperties
+     * is true then the audio properties will be read using \a audioPropertiesStyle.
+     * If \a readAudioProperties is false then \a audioPropertiesStyle will be
+     * ignored.
+     *
+     * Also see the note in the class documentation about why you may not want to
+     * use this method in your application.
+     *
+     * \note TagLib will *not* take ownership of the stream, the caller is
+     * responsible for deleting it after the File object.
+     */
+    explicit FileRef(IOStream* stream,
+                     bool readAudioProperties = true,
+                     AudioProperties::ReadStyle
+                     audioPropertiesStyle = AudioProperties::Average);
+
+    /*!
+     * Construct a FileRef using \a file.  The FileRef now takes ownership of the
      * pointer and will delete the File when it passes out of scope.
      */
     explicit FileRef(File *file);
@@ -156,6 +174,41 @@ namespace TagLib {
      */
     Tag *tag() const;
 
+    /*!
+     * Exports the tags of the file as dictionary mapping (human readable) tag
+     * names (uppercase Strings) to StringLists of tag values. Calls the according
+     * specialization in the File subclasses.
+     * For each metadata object of the file that could not be parsed into the PropertyMap
+     * format, the returend map's unsupportedData() list will contain one entry identifying
+     * that object (e.g. the frame type for ID3v2 tags). Use removeUnsupportedProperties()
+     * to remove (a subset of) them.
+     * For files that contain more than one tag (e.g. an MP3 with both an ID3v1 and an ID3v2
+     * tag) only the most "modern" one will be exported (ID3v2 in this case).
+     */
+    PropertyMap properties() const;
+
+    /*!
+     * Removes unsupported properties, or a subset of them, from the file's metadata.
+     * The parameter \a properties must contain only entries from
+     * properties().unsupportedData().
+     */
+    void removeUnsupportedProperties(const StringList& properties);
+
+    /*!
+     * Sets the tags of this File to those specified in \a properties. Calls the
+     * according specialization method in the subclasses of File to do the translation
+     * into the format-specific details.
+     * If some value(s) could not be written imported to the specific metadata format,
+     * the returned PropertyMap will contain those value(s). Otherwise it will be empty,
+     * indicating that no problems occured.
+     * With file types that support several tag formats (for instance, MP3 files can have
+     * ID3v1, ID3v2, and APEv2 tags), this function will create the most appropriate one
+     * (ID3v2 for MP3 files). Older formats will be updated as well, if they exist, but won't
+     * be taken into account for the return value of this function.
+     * See the documentation of the subclass implementations for detailed descriptions.
+     */
+    PropertyMap setProperties(const PropertyMap &properties);
+
     /*!
      * Returns the audio properties for this FileRef.  If no audio properties
      * were read then this will returns a null pointer.
@@ -191,7 +244,7 @@ namespace TagLib {
      * is tried.
      *
      * Returns a pointer to the added resolver (the same one that's passed in --
-     * this is mostly so that static inialializers have something to use for
+     * this is mostly so that static initializers have something to use for
      * assignment).
      *
      * \see FileTypeResolver
@@ -209,15 +262,24 @@ namespace TagLib {
      * by TagLib for resolution is case-insensitive.
      *
      * \note This does not account for any additional file type resolvers that
-     * are plugged in.  Also note that this is not intended to replace a propper
+     * are plugged in.  Also note that this is not intended to replace a proper
      * mime-type resolution system, but is just here for reference.
      *
      * \see FileTypeResolver
      */
     static StringList defaultFileExtensions();
 
+    /*!
+     * Returns true if the file is open and readable.
+     *
+     * \note Just a negative of isNull().
+     */
+    bool isValid() const;
+
     /*!
      * Returns true if the file (and as such other pointers) are null.
+     *
+     * \note Just a negative of isValid().
      */
     bool isNull() const;
 
@@ -226,6 +288,11 @@ namespace TagLib {
      */
     FileRef &operator=(const FileRef &ref);
 
+    /*!
+     * Exchanges the content of the FileRef by the content of \a ref.
+     */
+    void swap(FileRef &ref);
+
     /*!
      * Returns true if this FileRef and \a ref point to the same File object.
      */
@@ -237,23 +304,10 @@ namespace TagLib {
      */
     bool operator!=(const FileRef &ref) const;
 
-    /*!
-     * A simple implementation of file type guessing.  If \a readAudioProperties
-     * is true then the audio properties will be read using
-     * \a audioPropertiesStyle.  If \a readAudioProperties is false then
-     * \a audioPropertiesStyle will be ignored.
-     *
-     * \note You generally shouldn't use this method, but instead the constructor
-     * directly.
-     *
-     * \deprecated
-     */
-    static File *create(FileName fileName,
-                        bool readAudioProperties = true,
-                        AudioProperties::ReadStyle audioPropertiesStyle = AudioProperties::Average);
-
-
   private:
+    void parse(FileName fileName, bool readAudioProperties, AudioProperties::ReadStyle audioPropertiesStyle);
+    void parse(IOStream *stream, bool readAudioProperties, AudioProperties::ReadStyle audioPropertiesStyle);
+
     class FileRefPrivate;
     FileRefPrivate *d;
   };

taglib/flac/flacfile.cpp

@@ -29,6 +29,8 @@
 #include <tdebug.h>
 #include <tagunion.h>
 #include <tpropertymap.h>
+#include <tagutils.h>
+#include <tsmartptr.h>
 
 #include <id3v2header.h>
 #include <id3v2tag.h>
@@ -44,89 +46,96 @@ using namespace TagLib;
 
 namespace
 {
+  typedef List<SHARED_PTR<FLAC::MetadataBlock> > BlockList;
+  typedef BlockList::Iterator BlockIterator;
+  typedef BlockList::Iterator BlockConstIterator;
+
   enum { FlacXiphIndex = 0, FlacID3v2Index = 1, FlacID3v1Index = 2 };
-  enum { MinPaddingLength = 4096 };
-  enum { LastBlockFlag = 0x80 };
+
+  const long long MinPaddingLength = 4096;
+  const long long MaxPaddingLegnth = 1024 * 1024;
+
+  const char LastBlockFlag = '\x80';
+}
+
+namespace TagLib
+{
+  namespace FLAC
+  {
+    // Enables BlockList::find() to take raw pointers.
+
+    bool operator==(SHARED_PTR<MetadataBlock> lhs, MetadataBlock *rhs)
+    {
+      return lhs.get() == rhs;
+    }
+  }
 }
 
 class FLAC::File::FilePrivate
 {
 public:
-  FilePrivate() :
+  explicit FilePrivate(const ID3v2::FrameFactory *frameFactory) :
     ID3v2FrameFactory(ID3v2::FrameFactory::instance()),
     ID3v2Location(-1),
     ID3v2OriginalSize(0),
     ID3v1Location(-1),
-    properties(0),
     flacStart(0),
     streamStart(0),
-    streamLength(0),
-    scanned(false),
-    hasXiphComment(false),
-    hasID3v2(false),
-    hasID3v1(false)
+    scanned(false)
   {
-  }
-
-  ~FilePrivate()
-  {
-    for(uint i = 0; i < blocks.size(); i++) {
-      delete blocks[i];
-    }
-    delete properties;
+    if(frameFactory)
+      ID3v2FrameFactory = frameFactory;
   }
 
   const ID3v2::FrameFactory *ID3v2FrameFactory;
-  long ID3v2Location;
-  uint ID3v2OriginalSize;
+  long long ID3v2Location;
+  long long ID3v2OriginalSize;
 
-  long ID3v1Location;
+  long long ID3v1Location;
 
-  TagUnion tag;
+  TripleTagUnion tag;
 
-  Properties *properties;
-  ByteVector streamInfoData;
+  SCOPED_PTR<AudioProperties> properties;
   ByteVector xiphCommentData;
-  List<MetadataBlock *> blocks;
+  BlockList blocks;
 
-  long flacStart;
-  long streamStart;
-  long streamLength;
+  long long flacStart;
+  long long streamStart;
   bool scanned;
-
-  bool hasXiphComment;
-  bool hasID3v2;
-  bool hasID3v1;
 };
 
+////////////////////////////////////////////////////////////////////////////////
+// static members
+////////////////////////////////////////////////////////////////////////////////
+
+bool FLAC::File::isSupported(IOStream *stream)
+{
+  // A FLAC file has an ID "fLaC" somewhere. An ID3v2 tag may precede.
+
+  const ByteVector buffer = Utils::readHeader(stream, bufferSize(), true);
+  return (buffer.find("fLaC") != ByteVector::npos());
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-FLAC::File::File(FileName file, bool readProperties,
-                 Properties::ReadStyle propertiesStyle) :
-  TagLib::File(file)
+FLAC::File::File(FileName file, bool readProperties, AudioProperties::ReadStyle,
+                 ID3v2::FrameFactory *frameFactory) :
+  TagLib::File(file),
+  d(new FilePrivate(frameFactory))
 {
-  d = new FilePrivate;
-  read(readProperties, propertiesStyle);
+  if(isOpen())
+    read(readProperties);
 }
 
-FLAC::File::File(FileName file, ID3v2::FrameFactory *frameFactory,
-                 bool readProperties, Properties::ReadStyle propertiesStyle) :
-  TagLib::File(file)
+FLAC::File::File(IOStream *stream, bool readProperties, AudioProperties::ReadStyle,
+                 ID3v2::FrameFactory *frameFactory) :
+  TagLib::File(stream),
+  d(new FilePrivate(frameFactory))
 {
-  d = new FilePrivate;
-  d->ID3v2FrameFactory = frameFactory;
-  read(readProperties, propertiesStyle);
-}
-
-FLAC::File::File(IOStream *stream, ID3v2::FrameFactory *frameFactory,
-                 bool readProperties, Properties::ReadStyle propertiesStyle) :
-  TagLib::File(stream)
-{
-  d = new FilePrivate;
-  d->ID3v2FrameFactory = frameFactory;
-  read(readProperties, propertiesStyle);
+  if(isOpen())
+    read(readProperties);
 }
 
 FLAC::File::~File()
@@ -139,47 +148,16 @@ TagLib::Tag *FLAC::File::tag() const
   return &d->tag;
 }
 
-PropertyMap FLAC::File::properties() const
-{
-  // once Tag::properties() is virtual, this case distinction could actually be done
-  // within TagUnion.
-  if(d->hasXiphComment)
-    return d->tag.access<Ogg::XiphComment>(FlacXiphIndex, false)->properties();
-  if(d->hasID3v2)
-    return d->tag.access<ID3v2::Tag>(FlacID3v2Index, false)->properties();
-  if(d->hasID3v1)
-    return d->tag.access<ID3v1::Tag>(FlacID3v1Index, false)->properties();
-  return PropertyMap();
-}
-
-void FLAC::File::removeUnsupportedProperties(const StringList &unsupported)
-{
-  if(d->hasXiphComment)
-    d->tag.access<Ogg::XiphComment>(FlacXiphIndex, false)->removeUnsupportedProperties(unsupported);
-  if(d->hasID3v2)
-    d->tag.access<ID3v2::Tag>(FlacID3v2Index, false)->removeUnsupportedProperties(unsupported);
-  if(d->hasID3v1)
-    d->tag.access<ID3v1::Tag>(FlacID3v1Index, false)->removeUnsupportedProperties(unsupported);
-}
-
 PropertyMap FLAC::File::setProperties(const PropertyMap &properties)
 {
-  if(d->hasXiphComment)
-    return d->tag.access<Ogg::XiphComment>(FlacXiphIndex, false)->setProperties(properties);
-  else if(d->hasID3v2)
-    return d->tag.access<ID3v2::Tag>(FlacID3v2Index, false)->setProperties(properties);
-  else if(d->hasID3v1)
-    return d->tag.access<ID3v1::Tag>(FlacID3v1Index, false)->setProperties(properties);
-  else
-    return d->tag.access<Ogg::XiphComment>(FlacXiphIndex, true)->setProperties(properties);
+  return xiphComment(true)->setProperties(properties);
 }
 
-FLAC::Properties *FLAC::File::audioProperties() const
+FLAC::AudioProperties *FLAC::File::audioProperties() const
 {
-  return d->properties;
+  return d->properties.get();
 }
 
-
 bool FLAC::File::save()
 {
   if(readOnly()) {
@@ -193,93 +171,136 @@ bool FLAC::File::save()
   }
 
   // Create new vorbis comments
-
-  Tag::duplicate(&d->tag, xiphComment(true), false);
+  if(!hasXiphComment())
+    Tag::duplicate(&d->tag, xiphComment(true), false);
 
   d->xiphCommentData = xiphComment()->render(false);
 
   // Replace metadata blocks
 
-  bool foundVorbisCommentBlock = false;
-  List<MetadataBlock *> newBlocks;
-  for(uint i = 0; i < d->blocks.size(); i++) {
-    MetadataBlock *block = d->blocks[i];
-    if(block->code() == MetadataBlock::VorbisComment) {
+  for(BlockIterator it = d->blocks.begin(); it != d->blocks.end(); ++it) {
+    if((*it)->code() == MetadataBlock::VorbisComment) {
       // Set the new Vorbis Comment block
-      delete block;
-      block = new UnknownMetadataBlock(MetadataBlock::VorbisComment, d->xiphCommentData);
-      foundVorbisCommentBlock = true;
+      d->blocks.erase(it);
+      break;
     }
-    if(block->code() == MetadataBlock::Padding) {
-      delete block;
-      continue;
-    }
-    newBlocks.append(block);
   }
-  if(!foundVorbisCommentBlock) {
-    newBlocks.append(new UnknownMetadataBlock(MetadataBlock::VorbisComment, d->xiphCommentData));
-    foundVorbisCommentBlock = true;
-  }
-  d->blocks = newBlocks;
+
+  d->blocks.append(SHARED_PTR<MetadataBlock>(
+    new UnknownMetadataBlock(MetadataBlock::VorbisComment, d->xiphCommentData)));
 
   // Render data for the metadata blocks
 
   ByteVector data;
-  for(uint i = 0; i < newBlocks.size(); i++) {
-    FLAC::MetadataBlock *block = newBlocks[i];
-    ByteVector blockData = block->render();
-    ByteVector blockHeader = ByteVector::fromUInt(blockData.size());
-    blockHeader[0] = block->code();
+  for(BlockConstIterator it = d->blocks.begin(); it != d->blocks.end(); ++it) {
+    ByteVector blockData = (*it)->render();
+    ByteVector blockHeader = ByteVector::fromUInt32BE(blockData.size());
+    blockHeader[0] = (*it)->code();
     data.append(blockHeader);
     data.append(blockData);
   }
 
-  // Adjust the padding block(s)
+  // Compute the amount of padding, and append that to data.
 
-  long originalLength = d->streamStart - d->flacStart;
-  int paddingLength = originalLength - data.size() - 4;
-  if (paddingLength < 0) {
+  long long originalLength = d->streamStart - d->flacStart;
+  long long paddingLength = originalLength - data.size() - 4;
+
+  if(paddingLength <= 0) {
     paddingLength = MinPaddingLength;
   }
-  ByteVector padding = ByteVector::fromUInt(paddingLength);
-  padding.resize(paddingLength + 4);
-  padding[0] = (char)(FLAC::MetadataBlock::Padding | LastBlockFlag);
-  data.append(padding);
+  else {
+    // Padding won't increase beyond 1% of the file size or 1MB.
+
+    long long threshold = length() / 100;
+    threshold = std::max(threshold, MinPaddingLength);
+    threshold = std::min(threshold, MaxPaddingLegnth);
+
+    if(paddingLength > threshold)
+      paddingLength = MinPaddingLength;
+  }
+
+  ByteVector paddingHeader = ByteVector::fromUInt32BE(static_cast<unsigned int>(paddingLength));
+  paddingHeader[0] = static_cast<char>(MetadataBlock::Padding | LastBlockFlag);
+  data.append(paddingHeader);
+  data.resize(static_cast<size_t>(data.size() + paddingLength));
 
   // Write the data to the file
 
-  insert(data, d->flacStart, originalLength);
-  d->hasXiphComment = true;
+  insert(data, d->flacStart, static_cast<size_t>(originalLength));
+
+  d->streamStart += (static_cast<long>(data.size()) - originalLength);
+
+  if(d->ID3v1Location >= 0)
+    d->ID3v1Location += (static_cast<long>(data.size()) - originalLength);
 
   // Update ID3 tags
 
-  if(ID3v2Tag()) {
-    if(d->hasID3v2) {
-      if(d->ID3v2Location < d->flacStart)
-        debug("FLAC::File::save() -- This can't be right -- an ID3v2 tag after the "
-              "start of the FLAC bytestream?  Not writing the ID3v2 tag.");
-      else
-        insert(ID3v2Tag()->render(), d->ID3v2Location, d->ID3v2OriginalSize);
+  if(ID3v2Tag() && !ID3v2Tag()->isEmpty()) {
+
+    // ID3v2 tag is not empty. Update the old one or create a new one.
+
+    if(d->ID3v2Location < 0)
+      d->ID3v2Location = 0;
+
+    data = ID3v2Tag()->render();
+    insert(data, d->ID3v2Location, static_cast<size_t>(d->ID3v2OriginalSize));
+
+    d->flacStart   += (static_cast<long>(data.size()) - d->ID3v2OriginalSize);
+    d->streamStart += (static_cast<long>(data.size()) - d->ID3v2OriginalSize);
+
+    if(d->ID3v1Location >= 0)
+      d->ID3v1Location += (static_cast<long>(data.size()) - d->ID3v2OriginalSize);
+
+    d->ID3v2OriginalSize = data.size();
+  }
+  else {
+
+    // ID3v2 tag is empty. Remove the old one.
+
+    if(d->ID3v2Location >= 0) {
+      removeBlock(d->ID3v2Location, static_cast<size_t>(d->ID3v2OriginalSize));
+
+      d->flacStart   -= d->ID3v2OriginalSize;
+      d->streamStart -= d->ID3v2OriginalSize;
+
+      if(d->ID3v1Location >= 0)
+        d->ID3v1Location -= d->ID3v2OriginalSize;
+
+      d->ID3v2Location = -1;
+      d->ID3v2OriginalSize = 0;
     }
-    else
-      insert(ID3v2Tag()->render(), 0, 0);
   }
 
-  if(ID3v1Tag()) {
-    seek(-128, End);
+  if(ID3v1Tag() && !ID3v1Tag()->isEmpty()) {
+
+    // ID3v1 tag is not empty. Update the old one or create a new one.
+
+    if(d->ID3v1Location >= 0) {
+      seek(d->ID3v1Location);
+    }
+    else {
+      seek(0, End);
+      d->ID3v1Location = tell();
+    }
+
     writeBlock(ID3v1Tag()->render());
   }
+  else {
+
+    // ID3v1 tag is empty. Remove the old one.
+
+    if(d->ID3v1Location >= 0) {
+      truncate(d->ID3v1Location);
+      d->ID3v1Location = -1;
+    }
+  }
 
   return true;
 }
 
 ID3v2::Tag *FLAC::File::ID3v2Tag(bool create)
 {
-  if(!create || d->tag[FlacID3v2Index])
-    return static_cast<ID3v2::Tag *>(d->tag[FlacID3v2Index]);
-
-  d->tag.set(FlacID3v2Index, new ID3v2::Tag);
-  return static_cast<ID3v2::Tag *>(d->tag[FlacID3v2Index]);
+  return d->tag.access<ID3v2::Tag>(FlacID3v2Index, create);
 }
 
 ID3v1::Tag *FLAC::File::ID3v1Tag(bool create)
@@ -292,42 +313,92 @@ Ogg::XiphComment *FLAC::File::xiphComment(bool create)
   return d->tag.access<Ogg::XiphComment>(FlacXiphIndex, create);
 }
 
-void FLAC::File::setID3v2FrameFactory(const ID3v2::FrameFactory *factory)
+List<FLAC::Picture *> FLAC::File::pictureList()
 {
-  d->ID3v2FrameFactory = factory;
+  List<Picture *> pictures;
+  for(BlockConstIterator it = d->blocks.begin(); it != d->blocks.end(); ++it) {
+    Picture *picture = dynamic_cast<Picture *>(it->get());
+    if(picture) {
+      pictures.append(picture);
+    }
+  }
+  return pictures;
 }
 
+void FLAC::File::addPicture(Picture *picture)
+{
+  d->blocks.append(SHARED_PTR<Picture>(picture));
+}
+
+void FLAC::File::removePicture(Picture *picture)
+{
+  BlockIterator it = d->blocks.find(picture);
+  if(it != d->blocks.end())
+    d->blocks.erase(it);
+}
+
+void FLAC::File::removePictures()
+{
+  for(BlockIterator it = d->blocks.begin(); it != d->blocks.end(); ) {
+    if(dynamic_cast<Picture *>(it->get())) {
+      it = d->blocks.erase(it);
+    }
+    else {
+      ++it;
+    }
+  }
+}
+
+void FLAC::File::strip(int tags)
+{
+  if(tags & ID3v1)
+    d->tag.set(FlacID3v1Index, 0);
+
+  if(tags & ID3v2)
+    d->tag.set(FlacID3v2Index, 0);
+
+  if(tags & XiphComment) {
+    xiphComment()->removeAllFields();
+    xiphComment()->removeAllPictures();
+  }
+}
+
+bool FLAC::File::hasXiphComment() const
+{
+  return !d->xiphCommentData.isEmpty();
+}
+
+bool FLAC::File::hasID3v1Tag() const
+{
+  return (d->ID3v1Location >= 0);
+}
+
+bool FLAC::File::hasID3v2Tag() const
+{
+  return (d->ID3v2Location >= 0);
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
-void FLAC::File::read(bool readProperties, Properties::ReadStyle propertiesStyle)
+void FLAC::File::read(bool readProperties)
 {
   // Look for an ID3v2 tag
 
-  d->ID3v2Location = findID3v2();
+  d->ID3v2Location = Utils::findID3v2(this);
 
   if(d->ID3v2Location >= 0) {
-
     d->tag.set(FlacID3v2Index, new ID3v2::Tag(this, d->ID3v2Location, d->ID3v2FrameFactory));
-
     d->ID3v2OriginalSize = ID3v2Tag()->header()->completeTagSize();
-
-    if(ID3v2Tag()->header()->tagSize() <= 0)
-      d->tag.set(FlacID3v2Index, 0);
-    else
-      d->hasID3v2 = true;
   }
 
   // Look for an ID3v1 tag
 
-  d->ID3v1Location = findID3v1();
+  d->ID3v1Location = Utils::findID3v1(this);
 
-  if(d->ID3v1Location >= 0) {
+  if(d->ID3v1Location >= 0)
     d->tag.set(FlacID3v1Index, new ID3v1::Tag(this, d->ID3v1Location));
-    d->hasID3v1 = true;
-  }
 
   // Look for FLAC metadata, including vorbis comments
 
@@ -336,28 +407,26 @@ void FLAC::File::read(bool readProperties, Properties::ReadStyle propertiesStyle
   if(!isValid())
     return;
 
-  if(d->hasXiphComment)
-    d->tag.set(FlacXiphIndex, new Ogg::XiphComment(xiphCommentData()));
+  if(!d->xiphCommentData.isEmpty())
+    d->tag.set(FlacXiphIndex, new Ogg::XiphComment(d->xiphCommentData));
   else
-    d->tag.set(FlacXiphIndex, new Ogg::XiphComment);
+    d->tag.set(FlacXiphIndex, new Ogg::XiphComment());
 
-  if(readProperties)
-    d->properties = new Properties(streamInfoData(), streamLength(), propertiesStyle);
-}
+  if(readProperties) {
 
-ByteVector FLAC::File::streamInfoData()
-{
-  return isValid() ? d->streamInfoData : ByteVector();
-}
+    // First block should be the stream_info metadata
 
-ByteVector FLAC::File::xiphCommentData() const
-{
-  return (isValid() && d->hasXiphComment) ? d->xiphCommentData : ByteVector();
-}
+    const ByteVector infoData = d->blocks.front()->render();
 
-long FLAC::File::streamLength()
-{
-  return d->streamLength;
+    long long streamLength;
+
+    if(d->ID3v1Location >= 0)
+      streamLength = d->ID3v1Location - d->streamStart;
+    else
+      streamLength = length() - d->streamStart;
+
+    d->properties.reset(new AudioProperties(infoData, streamLength));
+  }
 }
 
 void FLAC::File::scan()
@@ -370,9 +439,9 @@ void FLAC::File::scan()
   if(!isValid())
     return;
 
-  long nextBlockOffset;
+  long long nextBlockOffset;
 
-  if(d->hasID3v2)
+  if(d->ID3v2Location >= 0)
     nextBlockOffset = find("fLaC", d->ID3v2Location + d->ID3v2OriginalSize);
   else
     nextBlockOffset = find("fLaC");
@@ -386,172 +455,90 @@ void FLAC::File::scan()
   nextBlockOffset += 4;
   d->flacStart = nextBlockOffset;
 
-  seek(nextBlockOffset);
+  while(true) {
 
-  ByteVector header = readBlock(4);
+    seek(nextBlockOffset);
+    const ByteVector header = readBlock(4);
 
-  // Header format (from spec):
-  // <1> Last-metadata-block flag
-  // <7> BLOCK_TYPE
-  //    0 : STREAMINFO
-  //    1 : PADDING
-  //    ..
-  //    4 : VORBIS_COMMENT
-  //    ..
-  // <24> Length of metadata to follow
+    // Header format (from spec):
+    // <1> Last-metadata-block flag
+    // <7> BLOCK_TYPE
+    //    0 : STREAMINFO
+    //    1 : PADDING
+    //    ..
+    //    4 : VORBIS_COMMENT
+    //    ..
+    //    6 : PICTURE
+    //    ..
+    // <24> Length of metadata to follow
 
-  char blockType = header[0] & 0x7f;
-  bool isLastBlock = (header[0] & 0x80) != 0;
-  uint length = header.mid(1, 3).toUInt();
+    const char blockType = header[0] & ~LastBlockFlag;
+    const bool isLastBlock = (header[0] & LastBlockFlag) != 0;
+    const size_t blockLength = header.toUInt24BE(1);
 
-  // First block should be the stream_info metadata
+    // First block should be the stream_info metadata
 
-  if(blockType != MetadataBlock::StreamInfo) {
-    debug("FLAC::File::scan() -- invalid FLAC stream");
-    setValid(false);
-    return;
-  }
-
-  d->streamInfoData = readBlock(length);
-  d->blocks.append(new UnknownMetadataBlock(blockType, d->streamInfoData));
-  nextBlockOffset += length + 4;
-
-  // Search through the remaining metadata
-  while(!isLastBlock) {
-
-    header = readBlock(4);
-    blockType = header[0] & 0x7f;
-    isLastBlock = (header[0] & 0x80) != 0;
-    length = header.mid(1, 3).toUInt();
-
-    ByteVector data = readBlock(length);
-    if(data.size() != length) {
-      debug("FLAC::File::scan() -- FLAC stream corrupted");
+    if(d->blocks.isEmpty() && blockType != MetadataBlock::StreamInfo) {
+      debug("FLAC::File::scan() -- First block should be the stream_info metadata");
       setValid(false);
       return;
     }
 
-    MetadataBlock *block = 0;
+    if(blockLength == 0
+      && blockType != MetadataBlock::Padding && blockType != MetadataBlock::SeekTable)
+    {
+      debug("FLAC::File::scan() -- Zero-sized metadata block found");
+      setValid(false);
+      return;
+    }
+
+    const ByteVector data = readBlock(blockLength);
+    if(data.size() != blockLength) {
+      debug("FLAC::File::scan() -- Failed to read a metadata block");
+      setValid(false);
+      return;
+    }
+
+    SHARED_PTR<MetadataBlock> block;
 
     // Found the vorbis-comment
     if(blockType == MetadataBlock::VorbisComment) {
-      if(!d->hasXiphComment) {
+      if(d->xiphCommentData.isEmpty()) {
         d->xiphCommentData = data;
-        d->hasXiphComment = true;
+        block.reset(new UnknownMetadataBlock(MetadataBlock::VorbisComment, data));
       }
       else {
-        debug("FLAC::File::scan() -- multiple Vorbis Comment blocks found, using the first one");
+        debug("FLAC::File::scan() -- multiple Vorbis Comment blocks found, discarding");
       }
     }
     else if(blockType == MetadataBlock::Picture) {
-      FLAC::Picture *picture = new FLAC::Picture();
+      SHARED_PTR<FLAC::Picture> picture(new FLAC::Picture());
       if(picture->parse(data)) {
         block = picture;
       }
       else {
-        debug("FLAC::File::scan() -- invalid picture found, discarting");
-        delete picture;
+        debug("FLAC::File::scan() -- invalid picture found, discarding");
       }
     }
-
-    if(!block) {
-      block = new UnknownMetadataBlock(blockType, data);
-    }
-    if(block->code() != MetadataBlock::Padding) {
-      d->blocks.append(block);
+    else if(blockType == MetadataBlock::Padding) {
+      // Skip all padding blocks.
     }
     else {
-      delete block;
+      block.reset(new UnknownMetadataBlock(blockType, data));
     }
 
-    nextBlockOffset += length + 4;
+    if(block)
+      d->blocks.append(block);
 
-    if(nextBlockOffset >= File::length()) {
-      debug("FLAC::File::scan() -- FLAC stream corrupted");
-      setValid(false);
-      return;
-    }
-    seek(nextBlockOffset);
+    nextBlockOffset += blockLength + 4;
+
+    if(isLastBlock)
+      break;
   }
 
   // End of metadata, now comes the datastream
 
   d->streamStart = nextBlockOffset;
-  d->streamLength = File::length() - d->streamStart;
-
-  if(d->hasID3v1)
-    d->streamLength -= 128;
 
   d->scanned = true;
 }
-
-long FLAC::File::findID3v1()
-{
-  if(!isValid())
-    return -1;
-
-  seek(-128, End);
-  long p = tell();
-
-  if(readBlock(3) == ID3v1::Tag::fileIdentifier())
-    return p;
-
-  return -1;
-}
-
-long FLAC::File::findID3v2()
-{
-  if(!isValid())
-    return -1;
-
-  seek(0);
-
-  if(readBlock(3) == ID3v2::Header::fileIdentifier())
-    return 0;
-
-  return -1;
-}
-
-List<FLAC::Picture *> FLAC::File::pictureList()
-{
-  List<Picture *> pictures;
-  for(uint i = 0; i < d->blocks.size(); i++) {
-    Picture *picture = dynamic_cast<Picture *>(d->blocks[i]);
-    if(picture) {
-      pictures.append(picture);
-    }
-  }
-  return pictures;
-}
-
-void FLAC::File::addPicture(Picture *picture)
-{
-  d->blocks.append(picture);
-}
-
-void FLAC::File::removePicture(Picture *picture, bool del)
-{
-  MetadataBlock *block = picture;
-  List<MetadataBlock *>::Iterator it = d->blocks.find(block);
-  if(it != d->blocks.end())
-    d->blocks.erase(it);
-
-  if(del)
-    delete picture;
-}
-
-void FLAC::File::removePictures()
-{
-  List<MetadataBlock *> newBlocks;
-  for(uint i = 0; i < d->blocks.size(); i++) {
-    Picture *picture = dynamic_cast<Picture *>(d->blocks[i]);
-    if(picture) {
-      delete picture;
-    }
-    else {
-      newBlocks.append(d->blocks[i]);
-    }
-  }
-  d->blocks = newBlocks;
-}
-

taglib/flac/flacfile.h

@@ -46,7 +46,7 @@ namespace TagLib {
   /*!
    * This is implementation of FLAC metadata for non-Ogg FLAC files.  At some
    * point when Ogg / FLAC is more common there will be a similar implementation
-   * under the Ogg hiearchy.
+   * under the Ogg hierarchy.
    *
    * This supports ID3v1, ID3v2 and Xiph style comments as well as reading stream
    * properties from the file.
@@ -67,44 +67,52 @@ namespace TagLib {
     {
     public:
       /*!
-       * Contructs a FLAC file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
-       *
-       * \deprecated This constructor will be dropped in favor of the one below
-       * in a future version.
+       * This set of flags is used for various operations and is suitable for
+       * being OR-ed together.
        */
-      File(FileName file, bool readProperties = true,
-           Properties::ReadStyle propertiesStyle = Properties::Average);
+      enum TagTypes {
+        //! Empty set.  Matches no tag types.
+        NoTags      = 0x0000,
+        //! Matches Vorbis comments.
+        XiphComment = 0x0001,
+        //! Matches ID3v1 tags.
+        ID3v1       = 0x0002,
+        //! Matches ID3v2 tags.
+        ID3v2       = 0x0004,
+        //! Matches all tag types.
+        AllTags     = 0xffff
+      };
 
       /*!
-       * Contructs a FLAC file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
+       * Constructs an FLAC file from \a file.  If \a readProperties is true the
+       * file's audio properties will also be read.
        *
        * If this file contains and ID3v2 tag the frames will be created using
        * \a frameFactory.
+       *
+       * \note In the current implementation, \a propertiesStyle is ignored.
        */
-      // BIC: merge with the above constructor
-      File(FileName file, ID3v2::FrameFactory *frameFactory,
+      File(FileName file,
            bool readProperties = true,
-           Properties::ReadStyle propertiesStyle = Properties::Average);
+           AudioProperties::ReadStyle propertiesStyle = AudioProperties::Average,
+           ID3v2::FrameFactory *frameFactory = 0);
 
       /*!
-       * Contructs a FLAC file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
+       * Constructs a FLAC file from \a file.  If \a readProperties is true the
+       * file's audio properties will also be read.
        *
        * If this file contains and ID3v2 tag the frames will be created using
        * \a frameFactory.
        *
+       * \note In the current implementation, \a propertiesStyle is ignored.
+       *
        * \note TagLib will *not* take ownership of the stream, the caller is
        * responsible for deleting it after the File object.
        */
-      // BIC: merge with the above constructor
-      File(IOStream *stream, ID3v2::FrameFactory *frameFactory,
+      File(IOStream *stream,
            bool readProperties = true,
-           Properties::ReadStyle propertiesStyle = Properties::Average);
+           AudioProperties::ReadStyle propertiesStyle = AudioProperties::Average,
+           ID3v2::FrameFactory *frameFactory = 0);
 
       /*!
        * Destroys this instance of the File.
@@ -121,28 +129,20 @@ namespace TagLib {
        */
       virtual TagLib::Tag *tag() const;
 
-      /*!
-       * Implements the unified property interface -- export function.
-       * If the file contains more than one tag (e.g. XiphComment and ID3v1),
-       * only the first one (in the order XiphComment, ID3v2, ID3v1) will be
-       * converted to the PropertyMap.
-       */
-      PropertyMap properties() const;
-
-      void removeUnsupportedProperties(const StringList &);
-
       /*!
        * Implements the unified property interface -- import function.
-       * As with the export, only one tag is taken into account. If the file
-       * has no tag at all, a XiphComment will be created.
+       * This always creates a Xiph comment, if none exists. The return value
+       * relates to the Xiph comment only.
+       * Ignores any changes to ID3v1 or ID3v2 comments since they are not allowed
+       * in the FLAC specification.
        */
-      PropertyMap setProperties(const PropertyMap &);
+      virtual PropertyMap setProperties(const PropertyMap &);
 
       /*!
        * Returns the FLAC::Properties for this file.  If no audio properties
        * were read then this will return a null pointer.
        */
-      virtual Properties *audioProperties() const;
+      virtual AudioProperties *audioProperties() const;
 
       /*!
        * Save the file.  This will primarily save the XiphComment, but
@@ -156,77 +156,69 @@ namespace TagLib {
       /*!
        * Returns a pointer to the ID3v2 tag of the file.
        *
-       * If \a create is false (the default) this will return a null pointer
+       * If \a create is false (the default) this returns a null pointer
        * if there is no valid ID3v2 tag.  If \a create is true it will create
-       * an ID3v2 tag if one does not exist.
+       * an ID3v2 tag if one does not exist and returns a valid pointer.
        *
-       * \note The Tag <b>is still</b> owned by the FLAC::File and should not be
+       * \note This may return a valid pointer regardless of whether or not the
+       * file on disk has an ID3v2 tag.  Use hasID3v2Tag() to check if the file
+       * on disk actually has an ID3v2 tag.
+       *
+       * \note The Tag <b>is still</b> owned by the MPEG::File and should not be
        * deleted by the user.  It will be deleted when the file (object) is
        * destroyed.
+       *
+       * \see hasID3v2Tag()
        */
       ID3v2::Tag *ID3v2Tag(bool create = false);
 
       /*!
        * Returns a pointer to the ID3v1 tag of the file.
        *
-       * If \a create is false (the default) this will return a null pointer
-       * if there is no valid ID3v1 tag.  If \a create is true it will create
-       * an ID3v1 tag if one does not exist.
+       * If \a create is false (the default) this returns a null pointer
+       * if there is no valid APE tag.  If \a create is true it will create
+       * an APE tag if one does not exist and returns a valid pointer.
        *
-       * \note The Tag <b>is still</b> owned by the FLAC::File and should not be
+       * \note This may return a valid pointer regardless of whether or not the
+       * file on disk has an ID3v1 tag.  Use hasID3v1Tag() to check if the file
+       * on disk actually has an ID3v1 tag.
+       *
+       * \note The Tag <b>is still</b> owned by the MPEG::File and should not be
        * deleted by the user.  It will be deleted when the file (object) is
        * destroyed.
+       *
+       * \see hasID3v1Tag()
        */
       ID3v1::Tag *ID3v1Tag(bool create = false);
 
       /*!
        * Returns a pointer to the XiphComment for the file.
        *
-       * If \a create is false (the default) this will return a null pointer
+       * If \a create is false (the default) this returns a null pointer
        * if there is no valid XiphComment.  If \a create is true it will create
-       * a XiphComment if one does not exist.
+       * a XiphComment if one does not exist and returns a valid pointer.
+       *
+       * \note This may return a valid pointer regardless of whether or not the
+       * file on disk has a XiphComment.  Use hasXiphComment() to check if the
+       * file on disk actually has a XiphComment.
        *
        * \note The Tag <b>is still</b> owned by the FLAC::File and should not be
        * deleted by the user.  It will be deleted when the file (object) is
        * destroyed.
+       *
+       * \see hasXiphComment()
        */
       Ogg::XiphComment *xiphComment(bool create = false);
 
-      /*!
-       * Set the ID3v2::FrameFactory to something other than the default.  This
-       * can be used to specify the way that ID3v2 frames will be interpreted
-       * when
-       *
-       * \see ID3v2FrameFactory
-       */
-      void setID3v2FrameFactory(const ID3v2::FrameFactory *factory);
-
-      /*!
-       * Returns the block of data used by FLAC::Properties for parsing the
-       * stream properties.
-       *
-       * \deprecated This method will not be public in a future release.
-       */
-      ByteVector streamInfoData(); // BIC: remove
-
-      /*!
-       * Returns the length of the audio-stream, used by FLAC::Properties for
-       * calculating the bitrate.
-       *
-       * \deprecated This method will not be public in a future release.
-       */
-      long streamLength();  // BIC: remove
-
       /*!
        * Returns a list of pictures attached to the FLAC file.
        */
       List<Picture *> pictureList();
 
       /*!
-       * Removes an attached picture. If \a del is true the picture's memory
-       * will be freed; if it is false, it must be deleted by the user.
+       * Removes an attached picture. The picture's memory will be freed.
        */
-      void removePicture(Picture *picture, bool del = true);
+      void removePicture(Picture *picture);
 
       /*!
        * Remove all attached images.
@@ -241,16 +233,57 @@ namespace TagLib {
        */
       void addPicture(Picture *picture);
 
+      /*!
+       * This will remove the tags that match the OR-ed together TagTypes from
+       * the file.  By default it removes all tags.
+       *
+       * \warning This will also invalidate pointers to the tags as their memory
+       * will be freed.
+       *
+       * \note In order to make the removal permanent save() still needs to be
+       * called.
+       *
+       * \note This won't remove the Vorbis comment block completely.  The
+       * vendor ID will be preserved.
+       */
+      void strip(int tags = AllTags);
+
+      /*!
+       * Returns whether or not the file on disk actually has a XiphComment.
+       *
+       * \see xiphComment()
+       */
+      bool hasXiphComment() const;
+
+      /*!
+       * Returns whether or not the file on disk actually has an ID3v1 tag.
+       *
+       * \see ID3v1Tag()
+       */
+      bool hasID3v1Tag() const;
+
+      /*!
+       * Returns whether or not the file on disk actually has an ID3v2 tag.
+       *
+       * \see ID3v2Tag()
+       */
+      bool hasID3v2Tag() const;
+
+      /*!
+       * Returns whether or not the given \a stream can be opened as a FLAC
+       * file.
+       *
+       * \note This method is designed to do a quick check.  The result may
+       * not necessarily be correct.
+       */
+      static bool isSupported(IOStream *stream);
+
     private:
       File(const File &);
       File &operator=(const File &);
 
-      void read(bool readProperties, Properties::ReadStyle propertiesStyle);
+      void read(bool readProperties);
       void scan();
-      long findID3v2();
-      long findID3v1();
-      ByteVector xiphCommentData() const;
-      long findPaddingBreak(long nextPageOffset, long targetOffset, bool *isLast);
 
       class FilePrivate;
       FilePrivate *d;

taglib/flac/flacmetadatablock.cpp

@@ -23,10 +23,6 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <taglib.h>
 #include <tdebug.h>
 #include "flacmetadatablock.h"

taglib/flac/flacpicture.cpp

@@ -23,10 +23,6 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <taglib.h>
 #include <tdebug.h>
 #include "flacpicture.h"
@@ -54,14 +50,14 @@ public:
   ByteVector data;
 };
 
-FLAC::Picture::Picture()
+FLAC::Picture::Picture() :
+  d(new PicturePrivate())
 {
-  d = new PicturePrivate;
 }
 
-FLAC::Picture::Picture(const ByteVector &data)
+FLAC::Picture::Picture(const ByteVector &data) :
+  d(new PicturePrivate())
 {
-  d = new PicturePrivate;
   parse(data);
 }
 
@@ -82,10 +78,10 @@ bool FLAC::Picture::parse(const ByteVector &data)
     return false;
   }
 
-  int pos = 0;
-  d->type = FLAC::Picture::Type(data.mid(pos, 4).toUInt());
+  size_t pos = 0;
+  d->type = FLAC::Picture::Type(data.toUInt32BE(pos));
   pos += 4;
-  uint mimeTypeLength = data.mid(pos, 4).toUInt();
+  const unsigned int mimeTypeLength = data.toUInt32BE(pos);
   pos += 4;
   if(pos + mimeTypeLength + 24 > data.size()) {
     debug("Invalid picture block.");
@@ -93,7 +89,7 @@ bool FLAC::Picture::parse(const ByteVector &data)
   }
   d->mimeType = String(data.mid(pos, mimeTypeLength), String::UTF8);
   pos += mimeTypeLength;
-  uint descriptionLength = data.mid(pos, 4).toUInt();
+  const unsigned int descriptionLength = data.toUInt32BE(pos);
   pos += 4;
   if(pos + descriptionLength + 20 > data.size()) {
     debug("Invalid picture block.");
@@ -101,15 +97,15 @@ bool FLAC::Picture::parse(const ByteVector &data)
   }
   d->description = String(data.mid(pos, descriptionLength), String::UTF8);
   pos += descriptionLength;
-  d->width = data.mid(pos, 4).toUInt();
+  d->width = data.toUInt32BE(pos);
   pos += 4;
-  d->height = data.mid(pos, 4).toUInt();
+  d->height = data.toUInt32BE(pos);
   pos += 4;
-  d->colorDepth = data.mid(pos, 4).toUInt();
+  d->colorDepth = data.toUInt32BE(pos);
   pos += 4;
-  d->numColors = data.mid(pos, 4).toUInt();
+  d->numColors = data.toUInt32BE(pos);
   pos += 4;
-  uint dataLength = data.mid(pos, 4).toUInt();
+  const unsigned int dataLength = data.toUInt32BE(pos);
   pos += 4;
   if(pos + dataLength > data.size()) {
     debug("Invalid picture block.");
@@ -123,18 +119,18 @@ bool FLAC::Picture::parse(const ByteVector &data)
 ByteVector FLAC::Picture::render() const
 {
   ByteVector result;
-  result.append(ByteVector::fromUInt(d->type));
+  result.append(ByteVector::fromUInt32BE(d->type));
   ByteVector mimeTypeData = d->mimeType.data(String::UTF8);
-  result.append(ByteVector::fromUInt(mimeTypeData.size()));
+  result.append(ByteVector::fromUInt32BE(mimeTypeData.size()));
   result.append(mimeTypeData);
   ByteVector descriptionData = d->description.data(String::UTF8);
-  result.append(ByteVector::fromUInt(descriptionData.size()));
+  result.append(ByteVector::fromUInt32BE(descriptionData.size()));
   result.append(descriptionData);
-  result.append(ByteVector::fromUInt(d->width));
-  result.append(ByteVector::fromUInt(d->height));
-  result.append(ByteVector::fromUInt(d->colorDepth));
-  result.append(ByteVector::fromUInt(d->numColors));
-  result.append(ByteVector::fromUInt(d->data.size()));
+  result.append(ByteVector::fromUInt32BE(d->width));
+  result.append(ByteVector::fromUInt32BE(d->height));
+  result.append(ByteVector::fromUInt32BE(d->colorDepth));
+  result.append(ByteVector::fromUInt32BE(d->numColors));
+  result.append(ByteVector::fromUInt32BE(d->data.size()));
   result.append(d->data);
   return result;
 }

taglib/flac/flacpicture.h

@@ -89,7 +89,7 @@ namespace TagLib {
       };
 
       Picture();
-      Picture(const ByteVector &data);
+      explicit Picture(const ByteVector &data);
       ~Picture();
 
       /*!
@@ -199,8 +199,6 @@ namespace TagLib {
       PicturePrivate *d;
     };
 
-    typedef List<Picture> PictureList;
-
   }
 
 }

taglib/flac/flacproperties.cpp

@@ -31,27 +31,21 @@
 
 using namespace TagLib;
 
-class FLAC::Properties::PropertiesPrivate
+class FLAC::AudioProperties::PropertiesPrivate
 {
 public:
-  PropertiesPrivate(ByteVector d, long st, ReadStyle s) :
-    data(d),
-    streamLength(st),
-    style(s),
+  PropertiesPrivate() :
     length(0),
     bitrate(0),
     sampleRate(0),
-    sampleWidth(0),
+    bitsPerSample(0),
     channels(0),
     sampleFrames(0) {}
 
-  ByteVector data;
-  long streamLength;
-  ReadStyle style;
   int length;
   int bitrate;
   int sampleRate;
-  int sampleWidth;
+  int bitsPerSample;
   int channels;
   unsigned long long sampleFrames;
   ByteVector signature;
@@ -61,54 +55,64 @@ public:
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-FLAC::Properties::Properties(ByteVector data, long streamLength, ReadStyle style) : AudioProperties(style)
+FLAC::AudioProperties::AudioProperties(const ByteVector &data, long long streamLength, ReadStyle) :
+  TagLib::AudioProperties(),
+  d(new PropertiesPrivate())
 {
-  d = new PropertiesPrivate(data, streamLength, style);
-  read();
+  read(data, streamLength);
 }
 
-FLAC::Properties::Properties(File *file, ReadStyle style) : AudioProperties(style)
-{
-  d = new PropertiesPrivate(file->streamInfoData(), file->streamLength(), style);
-  read();
-}
-
-FLAC::Properties::~Properties()
+FLAC::AudioProperties::~AudioProperties()
 {
   delete d;
 }
 
-int FLAC::Properties::length() const
+int FLAC::AudioProperties::length() const
+{
+  return lengthInSeconds();
+}
+
+int FLAC::AudioProperties::lengthInSeconds() const
+{
+  return d->length / 1000;
+}
+
+int FLAC::AudioProperties::lengthInMilliseconds() const
 {
   return d->length;
 }
 
-int FLAC::Properties::bitrate() const
+int FLAC::AudioProperties::bitrate() const
 {
   return d->bitrate;
 }
 
-int FLAC::Properties::sampleRate() const
+int FLAC::AudioProperties::sampleRate() const
 {
   return d->sampleRate;
 }
 
-int FLAC::Properties::sampleWidth() const
+int FLAC::AudioProperties::bitsPerSample() const
 {
-  return d->sampleWidth;
+  return d->bitsPerSample;
 }
 
-int FLAC::Properties::channels() const
+int FLAC::AudioProperties::sampleWidth() const
+{
+  return bitsPerSample();
+}
+
+int FLAC::AudioProperties::channels() const
 {
   return d->channels;
 }
 
-unsigned long long FLAC::Properties::sampleFrames() const
+unsigned long long FLAC::AudioProperties::sampleFrames() const
 {
   return d->sampleFrames;
 }
 
-ByteVector FLAC::Properties::signature() const
+ByteVector FLAC::AudioProperties::signature() const
 {
   return d->signature;
 }
@@ -117,14 +121,14 @@ ByteVector FLAC::Properties::signature() const
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
-void FLAC::Properties::read()
+void FLAC::AudioProperties::read(const ByteVector &data, long long streamLength)
 {
-  if(d->data.size() < 18) {
-    debug("FLAC::Properties::read() - FLAC properties must contain at least 18 bytes.");
+  if(data.size() < 18) {
+    debug("FLAC::AudioProperties::read() - FLAC properties must contain at least 18 bytes.");
     return;
   }
 
-  int pos = 0;
+  size_t pos = 0;
 
   // Minimum block size (in samples)
   pos += 2;
@@ -138,32 +142,28 @@ void FLAC::Properties::read()
   // Maximum frame size (in bytes)
   pos += 3;
 
-  uint flags = d->data.mid(pos, 4).toUInt(true);
+  const unsigned int flags = data.toUInt32BE(pos);
   pos += 4;
 
-  d->sampleRate = flags >> 12;
-  d->channels = ((flags >> 9) & 7) + 1;
-  d->sampleWidth = ((flags >> 4) & 31) + 1;
+  d->sampleRate    = flags >> 12;
+  d->channels      = ((flags >> 9) &  7) + 1;
+  d->bitsPerSample = ((flags >> 4) & 31) + 1;
 
   // The last 4 bits are the most significant 4 bits for the 36 bit
   // stream length in samples. (Audio files measured in days)
 
-  unsigned long long hi = flags & 0xf;
-  unsigned long long lo = d->data.mid(pos, 4).toUInt(true);
+  const unsigned long long hi = flags & 0xf;
+  const unsigned long long lo = data.toUInt32BE(pos);
   pos += 4;
 
   d->sampleFrames = (hi << 32) | lo;
 
-  if(d->sampleRate > 0)
-    d->length = int(d->sampleFrames / d->sampleRate);
+  if(d->sampleFrames > 0 && d->sampleRate > 0) {
+    const double length = d->sampleFrames * 1000.0 / d->sampleRate;
+    d->length  = static_cast<int>(length + 0.5);
+    d->bitrate = static_cast<int>(streamLength * 8.0 / length + 0.5);
+  }
 
-  // Uncompressed bitrate:
-
-  //d->bitrate = ((d->sampleRate * d->channels) / 1000) * d->sampleWidth;
-
-  // Real bitrate:
-
-  d->bitrate = d->length > 0 ? ((d->streamLength * 8UL) / d->length) / 1000 : 0;
-
-  d->signature = d->data.mid(pos, 32);
+  if(data.size() >= pos + 16)
+    d->signature = data.mid(pos, 16);
 }

taglib/flac/flacproperties.h

@@ -42,57 +42,89 @@ namespace TagLib {
      * API.
      */
 
-    class TAGLIB_EXPORT Properties : public AudioProperties
+    class TAGLIB_EXPORT AudioProperties : public TagLib::AudioProperties
     {
     public:
       /*!
-       * Create an instance of FLAC::Properties with the data read from the
-       * ByteVector \a data.
+       * Creates an instance of FLAC::AudioProperties with the data read from
+       * the ByteVector \a data.
        */
-       // BIC: switch to const reference
-      Properties(ByteVector data, long streamLength, ReadStyle style = Average);
+      AudioProperties(const ByteVector &data, long long streamLength, ReadStyle style = Average);
 
       /*!
-       * Create an instance of FLAC::Properties with the data read from the
-       * FLAC::File \a file.
+       * Destroys this FLAC::AudioProperties instance.
        */
-       // BIC: remove
-      Properties(File *file, ReadStyle style = Average);
+      virtual ~AudioProperties();
 
       /*!
-       * Destroys this FLAC::Properties instance.
+       * Returns the length of the file in seconds.  The length is rounded down to
+       * the nearest whole second.
+       *
+       * \note This method is just an alias of lengthInSeconds().
+       *
+       * \deprecated
        */
-      virtual ~Properties();
-
-      // Reimplementations.
-
       virtual int length() const;
+
+      /*!
+       * Returns the length of the file in seconds.  The length is rounded down to
+       * the nearest whole second.
+       *
+       * \see lengthInMilliseconds()
+       */
+      virtual int lengthInSeconds() const;
+
+      /*!
+       * Returns the length of the file in milliseconds.
+       *
+       * \see lengthInSeconds()
+       */
+      virtual int lengthInMilliseconds() const;
+
+      /*!
+       * Returns the average bit rate of the file in kb/s.
+       */
       virtual int bitrate() const;
+
+      /*!
+       * Returns the sample rate in Hz.
+       */
       virtual int sampleRate() const;
+
+      /*!
+       * Returns the number of audio channels.
+       */
       virtual int channels() const;
 
+      /*!
+       * Returns the number of bits per audio sample as read from the FLAC
+       * identification header.
+       */
+      int bitsPerSample() const;
+
       /*!
        * Returns the sample width as read from the FLAC identification
        * header.
+       *
+       * \note This method is just an alias of bitsPerSample().
+       *
+       * \deprecated
        */
       int sampleWidth() const;
 
       /*!
-       * Return the number of sample frames
+       * Return the number of sample frames.
        */
       unsigned long long sampleFrames() const;
 
       /*!
        * Returns the MD5 signature of the uncompressed audio stream as read
-       * from the stream info header header.
+       * from the stream info header.
        */
       ByteVector signature() const;
 
     private:
-      Properties(const Properties &);
-      Properties &operator=(const Properties &);
-
-      void read();
+      void read(const ByteVector &data, long long streamLength);
 
       class PropertiesPrivate;
       PropertiesPrivate *d;

taglib/flac/flacunknownmetadatablock.cpp

@@ -23,10 +23,6 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <taglib.h>
 #include <tdebug.h>
 #include <tstring.h>
@@ -43,11 +39,10 @@ public:
   ByteVector data;
 };
 
-FLAC::UnknownMetadataBlock::UnknownMetadataBlock(int code, const ByteVector &data)
+FLAC::UnknownMetadataBlock::UnknownMetadataBlock(int code, const ByteVector &data) :
+  d(new UnknownMetadataBlockPrivate())
 {
-  d = new UnknownMetadataBlockPrivate;
   d->code = code;
-  //debug(String(data.toHex()));
   d->data = data;
 }
 

taglib/it/itfile.cpp

@@ -5,7 +5,7 @@
 
 /***************************************************************************
  *   This library is free software; you can redistribute it and/or modify  *
- *   it  under the terms of the GNU Lesser General Public License version  *
+ *   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   *
@@ -15,10 +15,15 @@
  *                                                                         *
  *   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., 51 Franklin Street, Fifth Floor, Boston,            *
- *   MA  02110-1301  USA                                                   *
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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/                                           *
  ***************************************************************************/
 
+
 #include "tstringlist.h"
 #include "itfile.h"
 #include "tdebug.h"
@@ -31,13 +36,13 @@ using namespace IT;
 class IT::File::FilePrivate
 {
 public:
-  FilePrivate(AudioProperties::ReadStyle propertiesStyle)
+  explicit FilePrivate(AudioProperties::ReadStyle propertiesStyle)
     : tag(), properties(propertiesStyle)
   {
   }
 
   Mod::Tag       tag;
-  IT::Properties properties;
+  IT::AudioProperties properties;
 };
 
 IT::File::File(FileName file, bool readProperties,
@@ -45,7 +50,8 @@ IT::File::File(FileName file, bool readProperties,
   Mod::FileBase(file),
   d(new FilePrivate(propertiesStyle))
 {
-  read(readProperties);
+  if(isOpen())
+    read(readProperties);
 }
 
 IT::File::File(IOStream *stream, bool readProperties,
@@ -53,7 +59,8 @@ IT::File::File(IOStream *stream, bool readProperties,
   Mod::FileBase(stream),
   d(new FilePrivate(propertiesStyle))
 {
-  read(readProperties);
+  if(isOpen())
+    read(readProperties);
 }
 
 IT::File::~File()
@@ -66,17 +73,7 @@ Mod::Tag *IT::File::tag() const
   return &d->tag;
 }
 
-PropertyMap IT::File::properties() const
-{
-  return d->tag.properties();
-}
-
-PropertyMap IT::File::setProperties(const PropertyMap &properties)
-{
-  return d->tag.setProperties(properties);
-}
-
-IT::Properties *IT::File::audioProperties() const
+IT::AudioProperties *IT::File::audioProperties() const
 {
   return &d->properties;
 }
@@ -94,9 +91,9 @@ bool IT::File::save()
 
   seek(2, Current);
 
-  ushort length = 0;
-  ushort instrumentCount = 0;
-  ushort sampleCount = 0;
+  unsigned short length = 0;
+  unsigned short instrumentCount = 0;
+  unsigned short sampleCount = 0;
 
   if(!readU16L(length) || !readU16L(instrumentCount) || !readU16L(sampleCount))
     return false;
@@ -105,9 +102,9 @@ bool IT::File::save()
 
   // write comment as instrument and sample names:
   StringList lines = d->tag.comment().split("\n");
-  for(ushort i = 0; i < instrumentCount; ++ i) {
+  for(unsigned short i = 0; i < instrumentCount; ++ i) {
     seek(192L + length + ((long)i << 2));
-    ulong instrumentOffset = 0;
+    unsigned int instrumentOffset = 0;
     if(!readU32L(instrumentOffset))
       return false;
 
@@ -116,28 +113,28 @@ bool IT::File::save()
     if(i < lines.size())
       writeString(lines[i], 25);
     else
-      writeString(String::null, 25);
+      writeString(String(), 25);
     writeByte(0);
   }
 
-  for(ushort i = 0; i < sampleCount; ++ i) {
+  for(unsigned short i = 0; i < sampleCount; ++ i) {
     seek(192L + length + ((long)instrumentCount << 2) + ((long)i << 2));
-    ulong sampleOffset = 0;
+    unsigned int sampleOffset = 0;
     if(!readU32L(sampleOffset))
       return false;
 
     seek(sampleOffset + 20);
 
-    if((TagLib::uint)(i + instrumentCount) < lines.size())
+    if((unsigned int)(i + instrumentCount) < lines.size())
       writeString(lines[i + instrumentCount], 25);
     else
-      writeString(String::null, 25);
+      writeString(String(), 25);
     writeByte(0);
   }
 
   // write rest as message:
   StringList messageLines;
-  for(uint i = instrumentCount + sampleCount; i < lines.size(); ++ i)
+  for(unsigned int i = instrumentCount + sampleCount; i < lines.size(); ++ i)
     messageLines.append(lines[i]);
   ByteVector message = messageLines.toString("\r").data(String::Latin1);
 
@@ -147,16 +144,16 @@ bool IT::File::save()
     message.resize(7999);
   message.append((char)0);
 
-  ushort special = 0;
-  ushort messageLength = 0;
-  ulong  messageOffset = 0;
+  unsigned short special = 0;
+  unsigned short messageLength = 0;
+  unsigned int   messageOffset = 0;
 
   seek(46);
   if(!readU16L(special))
     return false;
 
-  ulong fileSize = File::length();
-  if(special & Properties::MessageAttached) {
+  unsigned int fileSize = static_cast<unsigned int>(File::length());
+  if(special & AudioProperties::MessageAttached) {
     seek(54);
     if(!readU16L(messageLength) || !readU32L(messageOffset))
       return false;
@@ -174,7 +171,7 @@ bool IT::File::save()
   if(messageOffset + messageLength >= fileSize) {
     // append new message
     seek(54);
-    writeU16L(message.size());
+    writeU16L(static_cast<unsigned short>(message.size()));
     writeU32L(messageOffset);
     seek(messageOffset);
     writeBlock(message);
@@ -226,14 +223,14 @@ void IT::File::read(bool)
   // sample/instrument names are abused as comments so
   // I just add all together.
   String message;
-  if(special & Properties::MessageAttached) {
+  if(special & AudioProperties::MessageAttached) {
     READ_U16L_AS(messageLength);
     READ_U32L_AS(messageOffset);
     seek(messageOffset);
     ByteVector messageBytes = readBlock(messageLength);
     READ_ASSERT(messageBytes.size() == messageLength);
-    int index = messageBytes.find((char) 0);
-    if(index > -1)
+    const size_t index = messageBytes.find((char) 0);
+    if(index != ByteVector::npos())
       messageBytes.resize(index, 0);
     messageBytes.replace('\r', '\n');
     message = messageBytes;
@@ -257,8 +254,8 @@ void IT::File::read(bool)
   d->properties.setChannels(channels);
 
   // real length might be shorter because of skips and terminator
-  ushort realLength = 0;
-  for(ushort i = 0; i < length; ++ i) {
+  unsigned short realLength = 0;
+  for(unsigned short i = 0; i < length; ++ i) {
     READ_BYTE_AS(order);
     if(order == 255) break;
     if(order != 254) ++ realLength;
@@ -272,7 +269,7 @@ void IT::File::read(bool)
   //       Currently I just discard anything after a nil, but
   //       e.g. VLC seems to interprete a nil as a space. I
   //       don't know what is the proper behaviour.
-  for(ushort i = 0; i < instrumentCount; ++ i) {
+  for(unsigned short i = 0; i < instrumentCount; ++ i) {
     seek(192L + length + ((long)i << 2));
     READ_U32L_AS(instrumentOffset);
     seek(instrumentOffset);
@@ -288,7 +285,7 @@ void IT::File::read(bool)
     comment.append(instrumentName);
   }
 
-  for(ushort i = 0; i < sampleCount; ++ i) {
+  for(unsigned short i = 0; i < sampleCount; ++ i) {
     seek(192L + length + ((long)instrumentCount << 2) + ((long)i << 2));
     READ_U32L_AS(sampleOffset);
 

taglib/it/itfile.h

@@ -36,23 +36,27 @@ namespace TagLib {
     class TAGLIB_EXPORT File : public Mod::FileBase {
       public:
         /*!
-         * Contructs a Impulse Tracker file from \a file. If \a readProperties
-         * is true the file's audio properties will also be read using
-         * \a propertiesStyle. If false, \a propertiesStyle is ignored.
+         * Constructs a Impulse Tracker file from \a file.
+         *
+         * \note In the current implementation, both \a readProperties and
+         * \a propertiesStyle are ignored.  The audio properties are always
+         * read.
          */
         File(FileName file, bool readProperties = true,
              AudioProperties::ReadStyle propertiesStyle =
              AudioProperties::Average);
 
         /*!
-         * Contructs a Impulse Tracker file from \a stream. If \a readProperties
-         * is true the file's audio properties will also be read using
-         * \a propertiesStyle. If false, \a propertiesStyle is ignored.
+         * Constructs a Impulse Tracker file from \a stream.
+         *
+         * \note In the current implementation, both \a readProperties and
+         * \a propertiesStyle are ignored.  The audio properties are always
+         * read.
          *
          * \note TagLib will *not* take ownership of the stream, the caller is
          * responsible for deleting it after the File object.
          */
-        File(IOStream *stram, bool readProperties = true,
+        File(IOStream *stream, bool readProperties = true,
              AudioProperties::ReadStyle propertiesStyle =
              AudioProperties::Average);
 
@@ -63,23 +67,11 @@ namespace TagLib {
 
         Mod::Tag *tag() const;
 
-        /*!
-         * Forwards to Mod::Tag::properties().
-         * BIC: will be removed once File::toDict() is made virtual
-         */
-        PropertyMap properties() const;
-
-        /*!
-         * Forwards to Mod::Tag::setProperties().
-         * BIC: will be removed once File::setProperties() is made virtual
-         */
-        PropertyMap setProperties(const PropertyMap &);
-
         /*!
          * Returns the IT::Properties for this file. If no audio properties
          * were read then this will return a null pointer.
          */
-        IT::Properties *audioProperties() const;
+        IT::AudioProperties *audioProperties() const;
 
         /*!
          * Save the file.

taglib/it/itproperties.cpp

@@ -1,11 +1,11 @@
-/***************************************************************************
+/***************************************************************************
     copyright           :(C) 2011 by Mathias Panzenböck
     email               : grosser.meister.morti@gmx.net
  ***************************************************************************/
 
 /***************************************************************************
  *   This library is free software; you can redistribute it and/or modify  *
- *   it  under the terms of the GNU Lesser General Public License version  *
+ *   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   *
@@ -15,16 +15,21 @@
  *                                                                         *
  *   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., 51 Franklin Street, Fifth Floor, Boston,            *
- *   MA  02110-1301  USA                                                   *
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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/                                           *
  ***************************************************************************/
 
+
 #include "itproperties.h"
 
 using namespace TagLib;
 using namespace IT;
 
-class IT::Properties::PropertiesPrivate
+class IT::AudioProperties::PropertiesPrivate
 {
 public:
   PropertiesPrivate() :
@@ -42,204 +47,220 @@ public:
     tempo(0),
     bpmSpeed(0),
     panningSeparation(0),
-    pitchWheelDepth(0)
-  {
-  }
+    pitchWheelDepth(0) {}
 
-  int    channels;
-  ushort lengthInPatterns;
-  ushort instrumentCount;
-  ushort sampleCount;
-  ushort patternCount;
-  ushort version;
-  ushort compatibleVersion;
-  ushort flags;
-  ushort special;
-  uchar  globalVolume;
-  uchar  mixVolume;
-  uchar  tempo;
-  uchar  bpmSpeed;
-  uchar  panningSeparation;
-  uchar  pitchWheelDepth;
+  int            channels;
+  unsigned short lengthInPatterns;
+  unsigned short instrumentCount;
+  unsigned short sampleCount;
+  unsigned short patternCount;
+  unsigned short version;
+  unsigned short compatibleVersion;
+  unsigned short flags;
+  unsigned short special;
+  unsigned char  globalVolume;
+  unsigned char  mixVolume;
+  unsigned char  tempo;
+  unsigned char  bpmSpeed;
+  unsigned char  panningSeparation;
+  unsigned char  pitchWheelDepth;
 };
 
-IT::Properties::Properties(AudioProperties::ReadStyle propertiesStyle) :
-  AudioProperties(propertiesStyle),
-  d(new PropertiesPrivate)
+////////////////////////////////////////////////////////////////////////////////
+// public members
+////////////////////////////////////////////////////////////////////////////////
+
+IT::AudioProperties::AudioProperties(AudioProperties::ReadStyle) :
+  TagLib::AudioProperties(),
+  d(new PropertiesPrivate())
 {
 }
 
-IT::Properties::~Properties()
+IT::AudioProperties::~AudioProperties()
 {
   delete d;
 }
 
-int IT::Properties::length() const
+int IT::AudioProperties::length() const
 {
   return 0;
 }
 
-int IT::Properties::bitrate() const
+int IT::AudioProperties::lengthInSeconds() const
 {
   return 0;
 }
 
-int IT::Properties::sampleRate() const
+int IT::AudioProperties::lengthInMilliseconds() const
 {
   return 0;
 }
 
-int IT::Properties::channels() const
+int IT::AudioProperties::bitrate() const
+{
+  return 0;
+}
+
+int IT::AudioProperties::sampleRate() const
+{
+  return 0;
+}
+
+int IT::AudioProperties::channels() const
 {
   return d->channels;
 }
 
-TagLib::ushort IT::Properties::lengthInPatterns() const
+unsigned short IT::AudioProperties::lengthInPatterns() const
 {
   return d->lengthInPatterns;
 }
 
-bool IT::Properties::stereo() const
+bool IT::AudioProperties::stereo() const
 {
   return d->flags & Stereo;
 }
 
-TagLib::ushort IT::Properties::instrumentCount() const
+unsigned short IT::AudioProperties::instrumentCount() const
 {
   return d->instrumentCount;
 }
 
-TagLib::ushort IT::Properties::sampleCount() const
+unsigned short IT::AudioProperties::sampleCount() const
 {
   return d->sampleCount;
 }
 
-TagLib::ushort IT::Properties::patternCount() const
+unsigned short IT::AudioProperties::patternCount() const
 {
   return d->patternCount;
 }
 
-TagLib::ushort IT::Properties::version() const
+unsigned short IT::AudioProperties::version() const
 {
   return d->version;
 }
 
-TagLib::ushort IT::Properties::compatibleVersion() const
+unsigned short IT::AudioProperties::compatibleVersion() const
 {
   return d->compatibleVersion;
 }
 
-TagLib::ushort IT::Properties::flags() const
+unsigned short IT::AudioProperties::flags() const
 {
   return d->flags;
 }
 
-TagLib::ushort IT::Properties::special() const
+unsigned short IT::AudioProperties::special() const
 {
   return d->special;
 }
 
-uchar IT::Properties::globalVolume() const
+unsigned char IT::AudioProperties::globalVolume() const
 {
   return d->globalVolume;
 }
 
-uchar IT::Properties::mixVolume() const
+unsigned char IT::AudioProperties::mixVolume() const
 {
   return d->mixVolume;
 }
 
-uchar IT::Properties::tempo() const
+unsigned char IT::AudioProperties::tempo() const
 {
   return d->tempo;
 }
 
-uchar IT::Properties::bpmSpeed() const
+unsigned char IT::AudioProperties::bpmSpeed() const
 {
   return d->bpmSpeed;
 }
 
-uchar IT::Properties::panningSeparation() const
+unsigned char IT::AudioProperties::panningSeparation() const
 {
   return d->panningSeparation;
 }
 
-uchar IT::Properties::pitchWheelDepth() const
+unsigned char IT::AudioProperties::pitchWheelDepth() const
 {
   return d->pitchWheelDepth;
 }
 
-void IT::Properties::setChannels(int channels)
+////////////////////////////////////////////////////////////////////////////////
+// private members
+////////////////////////////////////////////////////////////////////////////////
+
+void IT::AudioProperties::setChannels(int channels)
 {
   d->channels = channels;
 }
 
-void IT::Properties::setLengthInPatterns(ushort lengthInPatterns)
+void IT::AudioProperties::setLengthInPatterns(unsigned short lengthInPatterns)
 {
   d->lengthInPatterns = lengthInPatterns;
 }
 
-void IT::Properties::setInstrumentCount(ushort instrumentCount)
+void IT::AudioProperties::setInstrumentCount(unsigned short instrumentCount)
 {
   d->instrumentCount = instrumentCount;
 }
 
-void IT::Properties::setSampleCount(ushort sampleCount)
+void IT::AudioProperties::setSampleCount(unsigned short sampleCount)
 {
   d->sampleCount = sampleCount;
 }
 
-void IT::Properties::setPatternCount(ushort patternCount)
+void IT::AudioProperties::setPatternCount(unsigned short patternCount)
 {
   d->patternCount = patternCount;
 }
 
-void IT::Properties::setFlags(ushort flags)
+void IT::AudioProperties::setFlags(unsigned short flags)
 {
   d->flags = flags;
 }
 
-void IT::Properties::setSpecial(ushort special)
+void IT::AudioProperties::setSpecial(unsigned short special)
 {
   d->special = special;
 }
 
-void IT::Properties::setCompatibleVersion(ushort compatibleVersion)
+void IT::AudioProperties::setCompatibleVersion(unsigned short compatibleVersion)
 {
   d->compatibleVersion = compatibleVersion;
 }
 
-void IT::Properties::setVersion(ushort version)
+void IT::AudioProperties::setVersion(unsigned short version)
 {
   d->version = version;
 }
 
-void IT::Properties::setGlobalVolume(uchar globalVolume)
+void IT::AudioProperties::setGlobalVolume(unsigned char globalVolume)
 {
   d->globalVolume = globalVolume;
 }
 
-void IT::Properties::setMixVolume(uchar mixVolume)
+void IT::AudioProperties::setMixVolume(unsigned char mixVolume)
 {
   d->mixVolume = mixVolume;
 }
 
-void IT::Properties::setTempo(uchar tempo)
+void IT::AudioProperties::setTempo(unsigned char tempo)
 {
   d->tempo = tempo;
 }
 
-void IT::Properties::setBpmSpeed(uchar bpmSpeed)
+void IT::AudioProperties::setBpmSpeed(unsigned char bpmSpeed)
 {
   d->bpmSpeed = bpmSpeed;
 }
 
-void IT::Properties::setPanningSeparation(uchar panningSeparation)
+void IT::AudioProperties::setPanningSeparation(unsigned char panningSeparation)
 {
   d->panningSeparation = panningSeparation;
 }
 
-void IT::Properties::setPitchWheelDepth(uchar pitchWheelDepth)
+void IT::AudioProperties::setPitchWheelDepth(unsigned char pitchWheelDepth)
 {
   d->pitchWheelDepth = pitchWheelDepth;
 }

taglib/it/itproperties.h

@@ -5,7 +5,7 @@
 
 /***************************************************************************
  *   This library is free software; you can redistribute it and/or modify  *
- *   it  under the terms of the GNU Lesser General Public License version  *
+ *   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   *
@@ -15,8 +15,12 @@
  *                                                                         *
  *   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., 51 Franklin Street, Fifth Floor, Boston,            *
- *   MA  02110-1301  USA                                                   *
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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_ITPROPERTIES_H
@@ -26,9 +30,15 @@
 #include "audioproperties.h"
 
 namespace TagLib {
+
   namespace IT {
-    class TAGLIB_EXPORT Properties : public AudioProperties {
+
+    class File;
+
+    class TAGLIB_EXPORT AudioProperties : public TagLib::AudioProperties 
+    {
       friend class File;
+    
     public:
       /*! Flag bits. */
       enum {
@@ -48,49 +58,48 @@ namespace TagLib {
         MidiConfEmbedded = 8
       };
 
-      Properties(AudioProperties::ReadStyle propertiesStyle);
-      virtual ~Properties();
+      explicit AudioProperties(AudioProperties::ReadStyle propertiesStyle);
+      virtual ~AudioProperties();
 
-      int length()     const;
-      int bitrate()    const;
-      int sampleRate() const;
-      int channels()   const;
+      int length()               const;
+      int lengthInSeconds()      const;
+      int lengthInMilliseconds() const;
+      int bitrate()              const;
+      int sampleRate()           const;
+      int channels()             const;
 
-      ushort lengthInPatterns()  const;
-      bool   stereo()            const;
-      ushort instrumentCount()   const;
-      ushort sampleCount()       const;
-      ushort patternCount()      const;
-      ushort version()           const;
-      ushort compatibleVersion() const;
-      ushort flags()             const;
-      ushort special()           const;
-      uchar  globalVolume()      const;
-      uchar  mixVolume()         const;
-      uchar  tempo()             const;
-      uchar  bpmSpeed()          const;
-      uchar  panningSeparation() const;
-      uchar  pitchWheelDepth()   const;
-
-      void setChannels(int channels);
-      void setLengthInPatterns(ushort lengthInPatterns);
-      void setInstrumentCount(ushort instrumentCount);
-      void setSampleCount (ushort sampleCount);
-      void setPatternCount(ushort patternCount);
-      void setVersion     (ushort version);
-      void setCompatibleVersion(ushort compatibleVersion);
-      void setFlags       (ushort flags);
-      void setSpecial     (ushort special);
-      void setGlobalVolume(uchar globalVolume);
-      void setMixVolume   (uchar mixVolume);
-      void setTempo       (uchar tempo);
-      void setBpmSpeed    (uchar bpmSpeed);
-      void setPanningSeparation(uchar panningSeparation);
-      void setPitchWheelDepth  (uchar pitchWheelDepth);
+      unsigned short lengthInPatterns()  const;
+      bool           stereo()            const;
+      unsigned short instrumentCount()   const;
+      unsigned short sampleCount()       const;
+      unsigned short patternCount()      const;
+      unsigned short version()           const;
+      unsigned short compatibleVersion() const;
+      unsigned short flags()             const;
+      unsigned short special()           const;
+      unsigned char  globalVolume()      const;
+      unsigned char  mixVolume()         const;
+      unsigned char  tempo()             const;
+      unsigned char  bpmSpeed()          const;
+      unsigned char  panningSeparation() const;
+      unsigned char  pitchWheelDepth()   const;
 
     private:
-      Properties(const Properties&);
-      Properties &operator=(const Properties&);
+      void setChannels(int channels);
+      void setLengthInPatterns(unsigned short lengthInPatterns);
+      void setInstrumentCount(unsigned short instrumentCount);
+      void setSampleCount (unsigned short sampleCount);
+      void setPatternCount(unsigned short patternCount);
+      void setVersion     (unsigned short version);
+      void setCompatibleVersion(unsigned short compatibleVersion);
+      void setFlags       (unsigned short flags);
+      void setSpecial     (unsigned short special);
+      void setGlobalVolume(unsigned char globalVolume);
+      void setMixVolume   (unsigned char mixVolume);
+      void setTempo       (unsigned char tempo);
+      void setBpmSpeed    (unsigned char bpmSpeed);
+      void setPanningSeparation(unsigned char panningSeparation);
+      void setPitchWheelDepth  (unsigned char pitchWheelDepth);
 
       class PropertiesPrivate;
       PropertiesPrivate *d;

taglib/mod/modfile.cpp

@@ -5,7 +5,7 @@
 
 /***************************************************************************
  *   This library is free software; you can redistribute it and/or modify  *
- *   it  under the terms of the GNU Lesser General Public License version  *
+ *   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   *
@@ -15,10 +15,15 @@
  *                                                                         *
  *   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., 51 Franklin Street, Fifth Floor, Boston,            *
- *   MA  02110-1301  USA                                                   *
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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/                                           *
  ***************************************************************************/
 
+
 #include "modfile.h"
 #include "tstringlist.h"
 #include "tdebug.h"
@@ -31,13 +36,13 @@ using namespace Mod;
 class Mod::File::FilePrivate
 {
 public:
-  FilePrivate(AudioProperties::ReadStyle propertiesStyle)
+  explicit FilePrivate(AudioProperties::ReadStyle propertiesStyle)
     : properties(propertiesStyle)
   {
   }
 
   Mod::Tag        tag;
-  Mod::Properties properties;
+  Mod::AudioProperties properties;
 };
 
 Mod::File::File(FileName file, bool readProperties,
@@ -45,7 +50,8 @@ Mod::File::File(FileName file, bool readProperties,
   Mod::FileBase(file),
   d(new FilePrivate(propertiesStyle))
 {
-  read(readProperties);
+  if(isOpen())
+    read(readProperties);
 }
 
 Mod::File::File(IOStream *stream, bool readProperties,
@@ -53,7 +59,8 @@ Mod::File::File(IOStream *stream, bool readProperties,
   Mod::FileBase(stream),
   d(new FilePrivate(propertiesStyle))
 {
-  read(readProperties);
+  if(isOpen())
+    read(readProperties);
 }
 
 Mod::File::~File()
@@ -66,21 +73,11 @@ Mod::Tag *Mod::File::tag() const
   return &d->tag;
 }
 
-Mod::Properties *Mod::File::audioProperties() const
+Mod::AudioProperties *Mod::File::audioProperties() const
 {
   return &d->properties;
 }
 
-PropertyMap Mod::File::properties() const
-{
-  return d->tag.properties();
-}
-
-PropertyMap Mod::File::setProperties(const PropertyMap &properties)
-{
-  return d->tag.setProperties(properties);
-}
-
 bool Mod::File::save()
 {
   if(readOnly()) {
@@ -90,14 +87,14 @@ bool Mod::File::save()
   seek(0);
   writeString(d->tag.title(), 20);
   StringList lines = d->tag.comment().split("\n");
-  uint n = std::min(lines.size(), d->properties.instrumentCount());
-  for(uint i = 0; i < n; ++ i) {
+  size_t n = std::min<size_t>(lines.size(), d->properties.instrumentCount());
+  for(size_t i = 0; i < n; ++ i) {
     writeString(lines[i], 22);
     seek(8, Current);
   }
 
-  for(uint i = n; i < d->properties.instrumentCount(); ++ i) {
-    writeString(String::null, 22);
+  for(size_t i = n; i < d->properties.instrumentCount(); ++ i) {
+    writeString(String(), 22);
     seek(8, Current);
   }
   return true;
@@ -112,8 +109,8 @@ void Mod::File::read(bool)
   ByteVector modId = readBlock(4);
   READ_ASSERT(modId.size() == 4);
 
-  int  channels    =  4;
-  uint instruments = 31;
+  int          channels    =  4;
+  unsigned int instruments = 31;
   if(modId == "M.K." || modId == "M!K!" || modId == "M&K!" || modId == "N.T.") {
     d->tag.setTrackerName("ProTracker");
     channels = 4;
@@ -157,7 +154,7 @@ void Mod::File::read(bool)
   READ_STRING(d->tag.setTitle, 20);
 
   StringList comment;
-  for(uint i = 0; i < instruments; ++ i) {
+  for(unsigned int i = 0; i < instruments; ++ i) {
     READ_STRING_AS(instrumentName, 22);
     // value in words, * 2 (<< 1) for bytes:
     READ_U16B_AS(sampleLength);

taglib/mod/modfile.h

@@ -5,7 +5,7 @@
 
 /***************************************************************************
  *   This library is free software; you can redistribute it and/or modify  *
- *   it  under the terms of the GNU Lesser General Public License version  *
+ *   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   *
@@ -15,8 +15,12 @@
  *                                                                         *
  *   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., 51 Franklin Street, Fifth Floor, Boston,            *
- *   MA  02110-1301  USA                                                   *
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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_MODFILE_H
@@ -37,18 +41,22 @@ namespace TagLib {
     {
     public:
       /*!
-       * Contructs a Protracker file from \a file. If \a readProperties
-       * is true the file's audio properties will also be read using
-       * \a propertiesStyle. If false, \a propertiesStyle is ignored.
+       * Constructs a Protracker file from \a file.
+       *
+       * \note In the current implementation, both \a readProperties and
+       * \a propertiesStyle are ignored.  The audio properties are always
+       * read.
        */
       File(FileName file, bool readProperties = true,
            AudioProperties::ReadStyle propertiesStyle =
            AudioProperties::Average);
 
       /*!
-       * Contructs a Protracker file from \a stream. If \a readProperties
-       * is true the file's audio properties will also be read using
-       * \a propertiesStyle. If false, \a propertiesStyle is ignored.
+       * Constructs a Protracker file from \a stream.
+       *
+       * \note In the current implementation, both \a readProperties and
+       * \a propertiesStyle are ignored.  The audio properties are always
+       * read.
        *
        * \note TagLib will *not* take ownership of the stream, the caller is
        * responsible for deleting it after the File object.
@@ -64,22 +72,11 @@ namespace TagLib {
 
       Mod::Tag *tag() const;
 
-      /*!
-       * Implements the unified property interface -- export function.
-       * Forwards to Mod::Tag::properties().
-       */
-      PropertyMap properties() const;
-
-      /*!
-       * Implements the unified property interface -- import function.
-       * Forwards to Mod::Tag::setProperties().
-       */
-      PropertyMap setProperties(const PropertyMap &);
       /*!
        * Returns the Mod::Properties for this file. If no audio properties
        * were read then this will return a null pointer.
        */
-      Mod::Properties *audioProperties() const;
+      Mod::AudioProperties *audioProperties() const;
 
       /*!
        * Save the file.

taglib/mod/modfilebase.cpp

@@ -5,7 +5,7 @@
 
 /***************************************************************************
  *   This library is free software; you can redistribute it and/or modify  *
- *   it  under the terms of the GNU Lesser General Public License version  *
+ *   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   *
@@ -15,10 +15,15 @@
  *                                                                         *
  *   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., 51 Franklin Street, Fifth Floor, Boston,            *
- *   MA  02110-1301  USA                                                   *
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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/                                           *
  ***************************************************************************/
 
+
 #include "tdebug.h"
 #include "modfilebase.h"
 
@@ -33,55 +38,54 @@ Mod::FileBase::FileBase(IOStream *stream) : TagLib::File(stream)
 {
 }
 
-void Mod::FileBase::writeString(const String &s, ulong size, char padding)
+void Mod::FileBase::writeString(const String &s, unsigned int size, char padding)
 {
   ByteVector data(s.data(String::Latin1));
   data.resize(size, padding);
   writeBlock(data);
 }
 
-bool Mod::FileBase::readString(String &s, ulong size)
+bool Mod::FileBase::readString(String &s, unsigned int size)
 {
   ByteVector data(readBlock(size));
   if(data.size() < size) return false;
-  int index = data.find((char) 0);
-  if(index > -1)
-  {
+  const size_t index = data.find((char) 0);
+  if(index != ByteVector::npos()) {
     data.resize(index);
   }
-  data.replace((char) 0xff, ' ');
+  data.replace('\xff', ' ');
 
   s = data;
   return true;
 }
 
-void Mod::FileBase::writeByte(uchar byte)
+void Mod::FileBase::writeByte(unsigned char byte)
 {
   ByteVector data(1, byte);
   writeBlock(data);
 }
 
-void Mod::FileBase::writeU16L(ushort number)
+void Mod::FileBase::writeU16L(unsigned short number)
 {
-  writeBlock(ByteVector::fromShort(number, false));
+  writeBlock(ByteVector::fromUInt16LE(number));
 }
 
-void Mod::FileBase::writeU32L(ulong number)
+void Mod::FileBase::writeU32L(unsigned int number)
 {
-  writeBlock(ByteVector::fromUInt(number, false));
+  writeBlock(ByteVector::fromUInt32LE(number));
 }
 
-void Mod::FileBase::writeU16B(ushort number)
+void Mod::FileBase::writeU16B(unsigned short number)
 {
-  writeBlock(ByteVector::fromShort(number, true));
+  writeBlock(ByteVector::fromUInt16BE(number));
 }
 
-void Mod::FileBase::writeU32B(ulong number)
+void Mod::FileBase::writeU32B(unsigned int number)
 {
-  writeBlock(ByteVector::fromUInt(number, true));
+  writeBlock(ByteVector::fromUInt32BE(number));
 }
 
-bool Mod::FileBase::readByte(uchar &byte)
+bool Mod::FileBase::readByte(unsigned char &byte)
 {
   ByteVector data(readBlock(1));
   if(data.size() < 1) return false;
@@ -89,32 +93,32 @@ bool Mod::FileBase::readByte(uchar &byte)
   return true;
 }
 
-bool Mod::FileBase::readU16L(ushort &number)
+bool Mod::FileBase::readU16L(unsigned short &number)
 {
   ByteVector data(readBlock(2));
   if(data.size() < 2) return false;
-  number = data.toUShort(false);
+  number = data.toUInt16LE(0);
   return true;
 }
 
-bool Mod::FileBase::readU32L(ulong &number) {
+bool Mod::FileBase::readU32L(unsigned int &number) {
   ByteVector data(readBlock(4));
   if(data.size() < 4) return false;
-  number = data.toUInt(false);
+  number = data.toUInt32LE(0);
   return true;
 }
 
-bool Mod::FileBase::readU16B(ushort &number)
+bool Mod::FileBase::readU16B(unsigned short &number)
 {
   ByteVector data(readBlock(2));
   if(data.size() < 2) return false;
-  number = data.toUShort(true);
+  number = data.toUInt16BE(0);
   return true;
 }
 
-bool Mod::FileBase::readU32B(ulong &number) {
+bool Mod::FileBase::readU32B(unsigned int &number) {
   ByteVector data(readBlock(4));
   if(data.size() < 4) return false;
-  number = data.toUInt(true);
+  number = data.toUInt32BE(0);
   return true;
 }

taglib/mod/modfilebase.h

@@ -5,7 +5,7 @@
 
 /***************************************************************************
  *   This library is free software; you can redistribute it and/or modify  *
- *   it  under the terms of the GNU Lesser General Public License version  *
+ *   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   *
@@ -15,8 +15,12 @@
  *                                                                         *
  *   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., 51 Franklin Street, Fifth Floor, Boston,            *
- *   MA  02110-1301  USA                                                   *
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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_MODFILEBASE_H
@@ -37,22 +41,22 @@ namespace TagLib {
     class TAGLIB_EXPORT FileBase : public TagLib::File
     {
     protected:
-      FileBase(FileName file);
-      FileBase(IOStream *stream);
+      explicit FileBase(FileName file);
+      explicit FileBase(IOStream *stream);
 
-      void writeString(const String &s, ulong size, char padding = 0);
-      void writeByte(uchar byte);
-      void writeU16L(ushort number);
-      void writeU32L(ulong number);
-      void writeU16B(ushort number);
-      void writeU32B(ulong number);
+      void writeString(const String &s, unsigned int size, char padding = 0);
+      void writeByte(unsigned char byte);
+      void writeU16L(unsigned short number);
+      void writeU32L(unsigned int number);
+      void writeU16B(unsigned short number);
+      void writeU32B(unsigned int number);
 
-      bool readString(String &s, ulong size);
-      bool readByte(uchar &byte);
-      bool readU16L(ushort &number);
-      bool readU32L(ulong &number);
-      bool readU16B(ushort &number);
-      bool readU32B(ulong &number);
+      bool readString(String &s, unsigned int size);
+      bool readByte(unsigned char &byte);
+      bool readU16L(unsigned short &number);
+      bool readU32L(unsigned int &number);
+      bool readU16B(unsigned short &number);
+      bool readU32B(unsigned int &number);
     };
 
   }

taglib/mod/modfileprivate.h

@@ -37,11 +37,11 @@
     setter(number); \
   }
 
-#define READ_BYTE(setter) READ(setter,uchar,readByte)
-#define READ_U16L(setter) READ(setter,ushort,readU16L)
-#define READ_U32L(setter) READ(setter,ulong,readU32L)
-#define READ_U16B(setter) READ(setter,ushort,readU16B)
-#define READ_U32B(setter) READ(setter,ulong,readU32B)
+#define READ_BYTE(setter) READ(setter,unsigned char,readByte)
+#define READ_U16L(setter) READ(setter,unsigned short,readU16L)
+#define READ_U32L(setter) READ(setter,unsigned int,readU32L)
+#define READ_U16B(setter) READ(setter,unsigned short,readU16B)
+#define READ_U32B(setter) READ(setter,unsigned int,readU32B)
 
 #define READ_STRING(setter,size) \
   { \
@@ -54,11 +54,11 @@
   type name = 0; \
   READ_ASSERT(read(name));
 
-#define READ_BYTE_AS(name) READ_AS(uchar,name,readByte)
-#define READ_U16L_AS(name) READ_AS(ushort,name,readU16L)
-#define READ_U32L_AS(name) READ_AS(ulong,name,readU32L)
-#define READ_U16B_AS(name) READ_AS(ushort,name,readU16B)
-#define READ_U32B_AS(name) READ_AS(ulong,name,readU32B)
+#define READ_BYTE_AS(name) READ_AS(unsigned char,name,readByte)
+#define READ_U16L_AS(name) READ_AS(unsigned short,name,readU16L)
+#define READ_U32L_AS(name) READ_AS(unsigned int,name,readU32L)
+#define READ_U16B_AS(name) READ_AS(unsigned short,name,readU16B)
+#define READ_U32B_AS(name) READ_AS(unsigned int,name,readU32B)
 
 #define READ_STRING_AS(name,size) \
   String name; \

taglib/mod/modproperties.cpp

@@ -1,11 +1,11 @@
-/***************************************************************************
+/***************************************************************************
     copyright           : (C) 2011 by Mathias Panzenböck
     email               : grosser.meister.morti@gmx.net
  ***************************************************************************/
 
 /***************************************************************************
  *   This library is free software; you can redistribute it and/or modify  *
- *   it  under the terms of the GNU Lesser General Public License version  *
+ *   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   *
@@ -15,82 +15,103 @@
  *                                                                         *
  *   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., 51 Franklin Street, Fifth Floor, Boston,            *
- *   MA  02110-1301  USA                                                   *
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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/                                           *
  ***************************************************************************/
 
+
 #include "modproperties.h"
 
 using namespace TagLib;
 using namespace Mod;
 
-class Mod::Properties::PropertiesPrivate
+class Mod::AudioProperties::PropertiesPrivate
 {
 public:
   PropertiesPrivate() :
     channels(0),
     instrumentCount(0),
-    lengthInPatterns(0)
-  {
-  }
+    lengthInPatterns(0) {}
 
-  int   channels;
-  uint  instrumentCount;
-  uchar lengthInPatterns;
+  int           channels;
+  unsigned int  instrumentCount;
+  unsigned char lengthInPatterns;
 };
 
-Mod::Properties::Properties(AudioProperties::ReadStyle propertiesStyle) :
-  AudioProperties(propertiesStyle),
-  d(new PropertiesPrivate)
+////////////////////////////////////////////////////////////////////////////////
+// public members
+////////////////////////////////////////////////////////////////////////////////
+
+Mod::AudioProperties::AudioProperties(AudioProperties::ReadStyle) :
+  TagLib::AudioProperties(),
+  d(new PropertiesPrivate())
 {
 }
 
-Mod::Properties::~Properties()
+Mod::AudioProperties::~AudioProperties()
 {
   delete d;
 }
 
-int Mod::Properties::length() const
+int Mod::AudioProperties::length() const
 {
   return 0;
 }
 
-int Mod::Properties::bitrate() const
+int Mod::AudioProperties::lengthInSeconds() const
 {
   return 0;
 }
 
-int Mod::Properties::sampleRate() const
+int Mod::AudioProperties::lengthInMilliseconds() const
 {
   return 0;
 }
 
-int Mod::Properties::channels() const
+int Mod::AudioProperties::bitrate() const
+{
+  return 0;
+}
+
+int Mod::AudioProperties::sampleRate() const
+{
+  return 0;
+}
+
+int Mod::AudioProperties::channels() const
 {
   return d->channels;
 }
 
-TagLib::uint Mod::Properties::instrumentCount() const
+unsigned int Mod::AudioProperties::instrumentCount() const
 {
   return d->instrumentCount;
 }
 
-uchar Mod::Properties::lengthInPatterns() const
+unsigned char Mod::AudioProperties::lengthInPatterns() const
 {
   return d->lengthInPatterns;
 }
 
-void Mod::Properties::setChannels(int channels)
+////////////////////////////////////////////////////////////////////////////////
+// private members
+////////////////////////////////////////////////////////////////////////////////
+
+void Mod::AudioProperties::setChannels(int channels)
 {
   d->channels = channels;
 }
 
-void Mod::Properties::setInstrumentCount(uint instrumentCount)
+void Mod::AudioProperties::setInstrumentCount(unsigned int instrumentCount)
 {
   d->instrumentCount = instrumentCount;
 }
 
-void Mod::Properties::setLengthInPatterns(uchar lengthInPatterns)
+void Mod::AudioProperties::setLengthInPatterns(unsigned char lengthInPatterns)
 {
   d->lengthInPatterns = lengthInPatterns;
 }

taglib/mod/modproperties.h

@@ -5,7 +5,7 @@
 
 /***************************************************************************
  *   This library is free software; you can redistribute it and/or modify  *
- *   it  under the terms of the GNU Lesser General Public License version  *
+ *   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   *
@@ -15,8 +15,12 @@
  *                                                                         *
  *   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., 51 Franklin Street, Fifth Floor, Boston,            *
- *   MA  02110-1301  USA                                                   *
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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_MODPROPERTIES_H
@@ -29,30 +33,31 @@ namespace TagLib {
 
   namespace Mod {
 
-    class TAGLIB_EXPORT Properties : public AudioProperties
+    class File;
+
+    class TAGLIB_EXPORT AudioProperties : public TagLib::AudioProperties
     {
-    public:
-      Properties(AudioProperties::ReadStyle propertiesStyle);
-      virtual ~Properties();
-
-      int length() const;
-      int bitrate() const;
-      int sampleRate() const;
-      int channels() const;
-
-      uint instrumentCount() const;
-      uchar lengthInPatterns() const;
-
-      void setChannels(int channels);
-
-      void setInstrumentCount(uint sampleCount);
-      void setLengthInPatterns(uchar lengthInPatterns);
-
-    private:
       friend class File;
 
-      Properties(const Properties&);
-      Properties &operator=(const Properties&);
+    public:
+      explicit AudioProperties(AudioProperties::ReadStyle propertiesStyle);
+      virtual ~AudioProperties();
+
+      int length()               const;
+      int lengthInSeconds()      const;
+      int lengthInMilliseconds() const;
+      int bitrate()              const;
+      int sampleRate()           const;
+      int channels()             const;
+
+      unsigned int  instrumentCount()  const;
+      unsigned char lengthInPatterns() const;
+
+    private:
+      void setChannels(int channels);
+
+      void setInstrumentCount(unsigned int sampleCount);
+      void setLengthInPatterns(unsigned char lengthInPatterns);
 
       class PropertiesPrivate;
       PropertiesPrivate *d;

taglib/mod/modtag.cpp

@@ -5,7 +5,7 @@
 
 /***************************************************************************
  *   This library is free software; you can redistribute it and/or modify  *
- *   it  under the terms of the GNU Lesser General Public License version  *
+ *   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   *
@@ -15,13 +15,19 @@
  *                                                                         *
  *   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., 51 Franklin Street, Fifth Floor, Boston,            *
- *   MA  02110-1301  USA                                                   *
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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/                                           *
  ***************************************************************************/
 
+
 #include "modtag.h"
 #include "tstringlist.h"
 #include "tpropertymap.h"
+#include "tpicturemap.h"
 
 using namespace TagLib;
 using namespace Mod;
@@ -38,9 +44,10 @@ public:
   String trackerName;
 };
 
-Mod::Tag::Tag() : TagLib::Tag()
+Mod::Tag::Tag() :
+  TagLib::Tag(),
+  d(new TagPrivate())
 {
-  d = new TagPrivate;
 }
 
 Mod::Tag::~Tag()
@@ -55,12 +62,12 @@ String Mod::Tag::title() const
 
 String Mod::Tag::artist() const
 {
-  return String::null;
+  return String();
 }
 
 String Mod::Tag::album() const
 {
-  return String::null;
+  return String();
 }
 
 String Mod::Tag::comment() const
@@ -70,19 +77,24 @@ String Mod::Tag::comment() const
 
 String Mod::Tag::genre() const
 {
-  return String::null;
+  return String();
 }
 
-TagLib::uint Mod::Tag::year() const
+unsigned int Mod::Tag::year() const
 {
   return 0;
 }
 
-TagLib::uint Mod::Tag::track() const
+unsigned int Mod::Tag::track() const
 {
   return 0;
 }
 
+TagLib::PictureMap Mod::Tag::pictures() const
+{
+    return PictureMap();
+}
+
 String Mod::Tag::trackerName() const
 {
   return d->trackerName;
@@ -110,11 +122,15 @@ void Mod::Tag::setGenre(const String &)
 {
 }
 
-void Mod::Tag::setYear(uint)
+void Mod::Tag::setYear(unsigned int)
 {
 }
 
-void Mod::Tag::setTrack(uint)
+void Mod::Tag::setTrack(unsigned int)
+{
+}
+
+void Mod::Tag::setPictures(const PictureMap &l)
 {
 }
 
@@ -128,7 +144,7 @@ PropertyMap Mod::Tag::properties() const
   PropertyMap properties;
   properties["TITLE"] = d->title;
   properties["COMMENT"] = d->comment;
-  if(!(d->trackerName.isNull()))
+  if(!(d->trackerName.isEmpty()))
     properties["TRACKERNAME"] = d->trackerName;
   return properties;
 }
@@ -142,23 +158,23 @@ PropertyMap Mod::Tag::setProperties(const PropertyMap &origProps)
     d->title = properties["TITLE"].front();
     oneValueSet.append("TITLE");
   } else
-    d->title = String::null;
+    d->title.clear();
 
   if(properties.contains("COMMENT")) {
     d->comment = properties["COMMENT"].front();
     oneValueSet.append("COMMENT");
   } else
-    d->comment = String::null;
+    d->comment.clear();
 
   if(properties.contains("TRACKERNAME")) {
     d->trackerName = properties["TRACKERNAME"].front();
     oneValueSet.append("TRACKERNAME");
   } else
-    d->trackerName = String::null;
+    d->trackerName.clear();
 
   // for each tag that has been set above, remove the first entry in the corresponding
   // value list. The others will be returned as unsupported by this format.
-  for(StringList::Iterator it = oneValueSet.begin(); it != oneValueSet.end(); ++it) {
+  for(StringList::ConstIterator it = oneValueSet.begin(); it != oneValueSet.end(); ++it) {
     if(properties[*it].size() == 1)
       properties.erase(*it);
     else

taglib/mod/modtag.h

@@ -5,7 +5,7 @@
 
 /***************************************************************************
  *   This library is free software; you can redistribute it and/or modify  *
- *   it  under the terms of the GNU Lesser General Public License version  *
+ *   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   *
@@ -15,8 +15,12 @@
  *                                                                         *
  *   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., 51 Franklin Street, Fifth Floor, Boston,            *
- *   MA  02110-1301  USA                                                   *
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  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_MODTAG_H
@@ -50,39 +54,41 @@ namespace TagLib {
        * Returns the track name; if no track name is present in the tag
        * String::null will be returned.
        */
-      String title() const;
+      virtual String title() const;
 
       /*!
        * Not supported by module files.  Therefore always returns String::null.
        */
-      String artist() const;
+      virtual String artist() const;
 
       /*!
        * Not supported by module files.  Therefore always returns String::null.
        */
-      String album() const;
+      virtual String album() const;
 
       /*!
        * Returns the track comment derived from the instrument/sample/pattern
        * names; if no comment is present in the tag String::null will be
        * returned.
        */
-      String comment() const;
+      virtual String comment() const;
 
       /*!
        * Not supported by module files.  Therefore always returns String::null.
        */
-      String genre() const;
+      virtual String genre() const;
 
       /*!
        * Not supported by module files.  Therefore always returns 0.
        */
-      uint year() const;
+      virtual unsigned int year() const;
 
       /*!
        * Not supported by module files.  Therefore always returns 0.
        */
-      uint track() const;
+      virtual unsigned int track() const;
+
+      PictureMap pictures() const;
 
       /*!
        * Returns the name of the tracker used to create/edit the module file.
@@ -97,21 +103,21 @@ namespace TagLib {
        * Sets the title to \a title.  If \a title is String::null then this
        * value will be cleared.
        *
-       * The length limits per file type are (1 characetr = 1 byte):
+       * The length limits per file type are (1 character = 1 byte):
        * Mod 20 characters, S3M 27 characters, IT 25 characters and XM 20
        * characters.
        */
-      void setTitle(const String &title);
+      virtual void setTitle(const String &title);
 
       /*!
        * Not supported by module files and therefore ignored.
        */
-      void setArtist(const String &artist);
+      virtual void setArtist(const String &artist);
 
       /*!
        * Not supported by module files and therefore ignored.
        */
-      void setAlbum(const String &album);
+      virtual void setAlbum(const String &album);
 
       /*!
        * Sets the comment to \a comment.  If \a comment is String::null then
@@ -126,26 +132,28 @@ namespace TagLib {
        * an thus the line length in comments are limited. Too big comments
        * will be truncated.
        *
-       * The line length limits per file type are (1 characetr = 1 byte):
+       * The line length limits per file type are (1 character = 1 byte):
        * Mod 22 characters, S3M 27 characters, IT 25 characters and XM 22
        * characters.
        */
-      void setComment(const String &comment);
+      virtual void setComment(const String &comment);
 
       /*!
        * Not supported by module files and therefore ignored.
        */
-      void setGenre(const String &genre);
+      virtual void setGenre(const String &genre);
 
       /*!
        * Not supported by module files and therefore ignored.
        */
-      void setYear(uint year);
+      virtual void setYear(unsigned int year);
 
       /*!
        * Not supported by module files and therefore ignored.
        */
-      void setTrack(uint track);
+      virtual void setTrack(unsigned int track);
+
+      void setPictures(const PictureMap &l);
 
       /*!
        * Sets the tracker name to \a trackerName.  If \a trackerName is
@@ -169,7 +177,7 @@ namespace TagLib {
        * Implements the unified property interface -- import function.
        * Because of the limitations of the module file tag, any tags besides
        * COMMENT, TITLE and, if it is an XM file, TRACKERNAME, will be
-       * returened. Additionally, if the map contains tags with multiple values,
+       * returned. Additionally, if the map contains tags with multiple values,
        * all but the first will be contained in the returned map of unsupported
        * properties.
        */

taglib/mp4/mp4atom.cpp

@@ -23,27 +23,26 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <tdebug.h>
 #include <tstring.h>
+
 #include "mp4atom.h"
 
 using namespace TagLib;
 
 const char *MP4::Atom::containers[11] = {
-    "moov", "udta", "mdia", "meta", "ilst",
-    "stbl", "minf", "moof", "traf", "trak",
-    "stsd"
+  "moov", "udta", "mdia", "meta", "ilst",
+  "stbl", "minf", "moof", "traf", "trak",
+  "stsd"
 };
 
 MP4::Atom::Atom(File *file)
 {
+  children.setAutoDelete(true);
+
   offset = file->tell();
   ByteVector header = file->readBlock(8);
-  if (header.size() != 8) {
+  if(header.size() != 8) {
     // The atom header must be 8 bytes long, otherwise there is either
     // trailing garbage or the file is truncated
     debug("MP4: Couldn't read 8 bytes of data for atom header");
@@ -52,22 +51,18 @@ MP4::Atom::Atom(File *file)
     return;
   }
 
-  length = header.mid(0, 4).toUInt();
+  length = header.toUInt32BE(0);
 
-  if (length == 1) {
-    long long longLength = file->readBlock(8).toLongLong();
-    if (longLength >= 8 && longLength <= 0xFFFFFFFF) {
-        // The atom has a 64-bit length, but it's actually a 32-bit value
-        length = (long)longLength;
-    }
-    else {
-        debug("MP4: 64-bit atoms are not supported");
-        length = 0;
-        file->seek(0, File::End);
-        return;
-    }
+  if(length == 0) {
+    // The last atom which extends to the end of the file.
+    length = file->length() - offset;
   }
-  if (length < 8) {
+  else if(length == 1) {
+    // The atom has a 64-bit length.
+    length = file->readBlock(8).toInt64BE(0);
+  }
+
+  if(length < 8) {
     debug("MP4: Invalid atom size");
     length = 0;
     file->seek(0, File::End);
@@ -87,7 +82,7 @@ MP4::Atom::Atom(File *file)
       while(file->tell() < offset + length) {
         MP4::Atom *child = new MP4::Atom(file);
         children.append(child);
-        if (child->length == 0)
+        if(child->length == 0)
           return;
       }
       return;
@@ -99,10 +94,6 @@ MP4::Atom::Atom(File *file)
 
 MP4::Atom::~Atom()
 {
-  for(unsigned int i = 0; i < children.size(); i++) {
-    delete children[i];
-  }
-  children.clear();
 }
 
 MP4::Atom *
@@ -111,9 +102,9 @@ MP4::Atom::find(const char *name1, const char *name2, const char *name3, const c
   if(name1 == 0) {
     return this;
   }
-  for(unsigned int i = 0; i < children.size(); i++) {
-    if(children[i]->name == name1) {
-      return children[i]->find(name2, name3, name4);
+  for(AtomList::ConstIterator it = children.begin(); it != children.end(); ++it) {
+    if((*it)->name == name1) {
+      return (*it)->find(name2, name3, name4);
     }
   }
   return 0;
@@ -123,12 +114,12 @@ MP4::AtomList
 MP4::Atom::findall(const char *name, bool recursive)
 {
   MP4::AtomList result;
-  for(unsigned int i = 0; i < children.size(); i++) {
-    if(children[i]->name == name) {
-      result.append(children[i]);
+  for(AtomList::ConstIterator it = children.begin(); it != children.end(); ++it) {
+    if((*it)->name == name) {
+      result.append(*it);
     }
     if(recursive) {
-      result.append(children[i]->findall(name, recursive));
+      result.append((*it)->findall(name, recursive));
     }
   }
   return result;
@@ -141,9 +132,9 @@ MP4::Atom::path(MP4::AtomList &path, const char *name1, const char *name2, const
   if(name1 == 0) {
     return true;
   }
-  for(unsigned int i = 0; i < children.size(); i++) {
-    if(children[i]->name == name1) {
-      return children[i]->path(path, name2, name3);
+  for(AtomList::ConstIterator it = children.begin(); it != children.end(); ++it) {
+    if((*it)->name == name1) {
+      return (*it)->path(path, name2, name3);
     }
   }
   return false;
@@ -151,8 +142,10 @@ MP4::Atom::path(MP4::AtomList &path, const char *name1, const char *name2, const
 
 MP4::Atoms::Atoms(File *file)
 {
+  atoms.setAutoDelete(true);
+
   file->seek(0, File::End);
-  long end = file->tell();
+  long long end = file->tell();
   file->seek(0);
   while(file->tell() + 8 <= end) {
     MP4::Atom *atom = new MP4::Atom(file);
@@ -164,18 +157,14 @@ MP4::Atoms::Atoms(File *file)
 
 MP4::Atoms::~Atoms()
 {
-  for(unsigned int i = 0; i < atoms.size(); i++) {
-    delete atoms[i];
-  }
-  atoms.clear();
 }
 
 MP4::Atom *
 MP4::Atoms::find(const char *name1, const char *name2, const char *name3, const char *name4)
 {
-  for(unsigned int i = 0; i < atoms.size(); i++) {
-    if(atoms[i]->name == name1) {
-      return atoms[i]->find(name2, name3, name4);
+  for(AtomList::ConstIterator it = atoms.begin(); it != atoms.end(); ++it) {
+    if((*it)->name == name1) {
+      return (*it)->find(name2, name3, name4);
     }
   }
   return 0;
@@ -185,9 +174,9 @@ MP4::AtomList
 MP4::Atoms::path(const char *name1, const char *name2, const char *name3, const char *name4)
 {
   MP4::AtomList path;
-  for(unsigned int i = 0; i < atoms.size(); i++) {
-    if(atoms[i]->name == name1) {
-      if(!atoms[i]->path(path, name2, name3, name4)) {
+  for(AtomList::ConstIterator it = atoms.begin(); it != atoms.end(); ++it) {
+    if((*it)->name == name1) {
+      if(!(*it)->path(path, name2, name3, name4)) {
         path.clear();
       }
       return path;
@@ -195,4 +184,3 @@ MP4::Atoms::path(const char *name1, const char *name2, const char *name3, const
   }
   return path;
 }
-

taglib/mp4/mp4atom.h

@@ -59,7 +59,7 @@ namespace TagLib {
       TypeDateTime  = 17, // in UTC, counting seconds since midnight, January 1, 1904; 32 or 64-bits
       TypeGenred    = 18, // a list of enumerated values
       TypeInteger   = 21, // a signed big-endian integer with length one of { 1,2,3,4,8 } bytes
-      TypeRIAAPA    = 24, // RIAA parental advisory; { -1=no, 1=yes, 0=unspecified }, 8-bit ingteger
+      TypeRIAAPA    = 24, // RIAA parental advisory; { -1=no, 1=yes, 0=unspecified }, 8-bit integer
       TypeUPC       = 25, // Universal Product Code, in text UTF-8 format (valid as an ID)
       TypeBMP       = 27, // Windows bitmap image
       TypeUndefined = 255 // undefined
@@ -77,29 +77,29 @@ namespace TagLib {
     class Atom
     {
     public:
-        Atom(File *file);
-        ~Atom();
-        Atom *find(const char *name1, const char *name2 = 0, const char *name3 = 0, const char *name4 = 0);
-        bool path(AtomList &path, const char *name1, const char *name2 = 0, const char *name3 = 0);
-        AtomList findall(const char *name, bool recursive = false);
-        long offset;
-        long length;
-        TagLib::ByteVector name;
-        AtomList children;
+      explicit Atom(File *file);
+      ~Atom();
+      Atom *find(const char *name1, const char *name2 = 0, const char *name3 = 0, const char *name4 = 0);
+      bool path(AtomList &path, const char *name1, const char *name2 = 0, const char *name3 = 0);
+      AtomList findall(const char *name, bool recursive = false);
+      long long offset;
+      long long length;
+      TagLib::ByteVector name;
+      AtomList children;
     private:
-        static const int numContainers = 11;
-        static const char *containers[11];
+      static const int numContainers = 11;
+      static const char *containers[11];
     };
 
     //! Root-level atoms
     class Atoms
     {
     public:
-        Atoms(File *file);
-        ~Atoms();
-        Atom *find(const char *name1, const char *name2 = 0, const char *name3 = 0, const char *name4 = 0);
-        AtomList path(const char *name1, const char *name2 = 0, const char *name3 = 0, const char *name4 = 0);
-        AtomList atoms;
+      explicit Atoms(File *file);
+      ~Atoms();
+      Atom *find(const char *name1, const char *name2 = 0, const char *name3 = 0, const char *name4 = 0);
+      AtomList path(const char *name1, const char *name2 = 0, const char *name3 = 0, const char *name4 = 0);
+      AtomList atoms;
     };
 
   }

taglib/mp4/mp4coverart.cpp

@@ -23,64 +23,77 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <taglib.h>
-#include <tdebug.h>
+#include "taglib.h"
+#include "tdebug.h"
+#include "tsmartptr.h"
 #include "mp4coverart.h"
 
 using namespace TagLib;
 
-class MP4::CoverArt::CoverArtPrivate : public RefCounter
+namespace
 {
-public:
-  CoverArtPrivate() : RefCounter(), format(MP4::CoverArt::JPEG) {}
-
-  Format format;
-  ByteVector data;
-};
-
-MP4::CoverArt::CoverArt(Format format, const ByteVector &data)
-{
-  d = new CoverArtPrivate;
-  d->format = format;
-  d->data = data;
+  struct CoverArtData
+  {
+    MP4::CoverArt::Format format;
+    ByteVector data;
+  };
 }
 
-MP4::CoverArt::CoverArt(const CoverArt &item) : d(item.d)
+class MP4::CoverArt::CoverArtPrivate
+{
+public:
+  CoverArtPrivate(Format f, const ByteVector &v) :
+    data(new CoverArtData())
+  {
+    data->format = f;
+    data->data   = v;
+  }
+
+  SHARED_PTR<CoverArtData> data;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// public members
+////////////////////////////////////////////////////////////////////////////////
+
+MP4::CoverArt::CoverArt(Format format, const ByteVector &data) :
+  d(new CoverArtPrivate(format, data))
+{
+}
+
+MP4::CoverArt::CoverArt(const CoverArt &item) :
+  d(new CoverArtPrivate(*item.d))
 {
-  d->ref();
 }
 
 MP4::CoverArt &
 MP4::CoverArt::operator=(const CoverArt &item)
 {
-  if(d->deref()) {
-    delete d;
-  }
-  d = item.d;
-  d->ref();
+  CoverArt(item).swap(*this);
   return *this;
 }
 
+void
+MP4::CoverArt::swap(CoverArt &item)
+{
+  using std::swap;
+
+  swap(d, item.d);
+}
+
 MP4::CoverArt::~CoverArt()
 {
-  if(d->deref()) {
-    delete d;
-  }
+  delete d;
 }
 
 MP4::CoverArt::Format
 MP4::CoverArt::format() const
 {
-  return d->format;
+  return d->data->format;
 }
 
 ByteVector
 MP4::CoverArt::data() const
 {
-  return d->data;
+  return d->data->data;
 }
-