Update version to 1.12.0

More unit tests and bug fixes

.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,5 +44,6 @@ CMakeFiles/
 /taglib/tag.dir/Release
 /ALL_BUILD.dir
 /ZERO_CHECK.dir
+taglib.h.stamp
 taglib.xcodeproj
 CMakeScripts

.travis.yml

@@ -6,10 +6,15 @@ os:
   - linux
   - osx
 
+dist: trusty
+
 compiler:
   - gcc
   - clang
 
+arch:
+  - ppc64le
+
 addons:
   apt:
     packages:
@@ -24,5 +29,4 @@ matrix:
 install:
   - if [ "$TRAVIS_OS_NAME" = "osx" ]; then brew install cppunit; fi
 
-script: cmake -DBUILD_TESTS=ON -DBUILD_EXAMPLES=ON -DBUILD_BINDINGS=ON . && make && make check
-
+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

@@ -4,6 +4,8 @@ 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>
@@ -12,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,11 +1,7 @@
-cmake_minimum_required(VERSION 2.8.0 FATAL_ERROR)
+cmake_minimum_required(VERSION 3.0.0 FATAL_ERROR)
 
 project(taglib)
 
-if(NOT ${CMAKE_VERSION} VERSION_LESS 2.8.12)
-  cmake_policy(SET CMP0022 OLD)
-endif()
-
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
 
 if(DEFINED ENABLE_STATIC)
@@ -13,6 +9,14 @@ if(DEFINED ENABLE_STATIC)
 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)
 endif()
@@ -28,16 +32,17 @@ if(ENABLE_CCACHE)
 endif()
 
 option(VISIBILITY_HIDDEN "Build with -fvisibility=hidden" OFF)
-if(VISIBILITY_HIDDEN)
-  add_definitions(-fvisibility=hidden)
-endif()
-
 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(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/")
 
@@ -48,11 +53,6 @@ set(BIN_INSTALL_DIR "${EXEC_INSTALL_PREFIX}/bin" CACHE PATH "The subdirectory to
 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(APPLE)
-  option(BUILD_FRAMEWORK "Build an OS X framework" OFF)
-  set(FRAMEWORK_INSTALL_DIR "/Library/Frameworks" CACHE STRING "Directory to install frameworks to.")
-endif()
-
 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")
@@ -90,9 +90,9 @@ endif()
 # 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  18)
+set(TAGLIB_SOVERSION_CURRENT  19)
 set(TAGLIB_SOVERSION_REVISION 0)
-set(TAGLIB_SOVERSION_AGE      17)
+set(TAGLIB_SOVERSION_AGE      18)
 
 math(EXPR TAGLIB_SOVERSION_MAJOR "${TAGLIB_SOVERSION_CURRENT} - ${TAGLIB_SOVERSION_AGE}")
 math(EXPR TAGLIB_SOVERSION_MINOR "${TAGLIB_SOVERSION_AGE}")
@@ -100,8 +100,12 @@ math(EXPR TAGLIB_SOVERSION_PATCH "${TAGLIB_SOVERSION_REVISION}")
 
 include(ConfigureChecks.cmake)
 
+if(${ZLIB_FOUND})
+  set(ZLIB_LIBRARIES_FLAGS -lz)
+endif()
+
 if(NOT WIN32)
-  configure_file("${CMAKE_CURRENT_SOURCE_DIR}/taglib-config.cmake" "${CMAKE_CURRENT_BINARY_DIR}/taglib-config")
+  configure_file("${CMAKE_CURRENT_SOURCE_DIR}/taglib-config.cmake" "${CMAKE_CURRENT_BINARY_DIR}/taglib-config" @ONLY)
   install(PROGRAMS "${CMAKE_CURRENT_BINARY_DIR}/taglib-config" DESTINATION "${BIN_INSTALL_DIR}")
 endif()
 

ConfigureChecks.cmake

@@ -34,77 +34,49 @@ if(NOT ${SIZEOF_DOUBLE} EQUAL 8)
   message(FATAL_ERROR "TagLib requires that double is 64-bit wide.")
 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<unsigned int> x;
-    x.fetch_add(1);
-    x.fetch_sub(1);
-    return 0;
-  }
-" HAVE_STD_ATOMIC)
+    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_STD_ATOMIC)
-  find_package(Boost COMPONENTS atomic)
-  if(Boost_ATOMIC_FOUND)
-    set(HAVE_BOOST_ATOMIC 1)
-  else()
-    set(HAVE_BOOST_ATOMIC 0)
-  endif()
-
-  if(NOT HAVE_BOOST_ATOMIC)
-    check_cxx_source_compiles("
+if(NOT HAVE_GCC_ATOMIC)
+  check_cxx_source_compiles("
+      #include <libkern/OSAtomic.h>
       int main() {
-        volatile int x;
-        __sync_add_and_fetch(&x, 1);
-        int y = __sync_sub_and_fetch(&x, 1);
+        volatile int32_t x;
+        OSAtomicIncrement32Barrier(&x);
+        int32_t y = OSAtomicDecrement32Barrier(&x);
         return 0;
       }
-    " HAVE_GCC_ATOMIC)
+    " HAVE_MAC_ATOMIC)
 
-    if(NOT HAVE_GCC_ATOMIC)
-      check_cxx_source_compiles("
-        #include <libkern/OSAtomic.h>
+  if(NOT HAVE_MAC_ATOMIC)
+    check_cxx_source_compiles("
+        #include <windows.h>
         int main() {
-          volatile int32_t x;
-          OSAtomicIncrement32Barrier(&x);
-          int32_t y = OSAtomicDecrement32Barrier(&x);
+          volatile LONG x;
+          InterlockedIncrement(&x);
+          LONG y = InterlockedDecrement(&x);
           return 0;
         }
-      " HAVE_MAC_ATOMIC)
+      " HAVE_WIN_ATOMIC)
 
-      if(NOT HAVE_MAC_ATOMIC)
-        check_cxx_source_compiles("
-          #include <windows.h>
+    if(NOT HAVE_WIN_ATOMIC)
+      check_cxx_source_compiles("
+          #include <ia64intrin.h>
           int main() {
-            volatile LONG x;
-            InterlockedIncrement(&x);
-            LONG y = InterlockedDecrement(&x);
+            volatile int x;
+            __sync_add_and_fetch(&x, 1);
+            int y = __sync_sub_and_fetch(&x, 1);
             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()
+        " HAVE_IA64_ATOMIC)
     endif()
   endif()
 endif()
@@ -112,69 +84,57 @@ endif()
 # Determine which kind of byte swap functions your compiler supports.
 
 check_cxx_source_compiles("
-  #include <boost/endian/conversion.hpp>
   int main() {
-    boost::endian::endian_reverse(static_cast<uint16_t>(1));
-    boost::endian::endian_reverse(static_cast<uint32_t>(1));
-    boost::endian::endian_reverse(static_cast<uint64_t>(1));
+    __builtin_bswap16(0);
+    __builtin_bswap32(0);
+    __builtin_bswap64(0);
     return 0;
   }
-" HAVE_BOOST_BYTESWAP)
+" HAVE_GCC_BYTESWAP)
 
-if(NOT HAVE_BOOST_BYTESWAP)
+if(NOT HAVE_GCC_BYTESWAP)
   check_cxx_source_compiles("
+    #include <byteswap.h>
     int main() {
-      __builtin_bswap16(0);
-      __builtin_bswap32(0);
-      __builtin_bswap64(0);
+      __bswap_16(0);
+      __bswap_32(0);
+      __bswap_64(0);
       return 0;
     }
-  " HAVE_GCC_BYTESWAP)
+  " HAVE_GLIBC_BYTESWAP)
 
-  if(NOT HAVE_GCC_BYTESWAP)
+  if(NOT HAVE_GLIBC_BYTESWAP)
     check_cxx_source_compiles("
-      #include <byteswap.h>
+      #include <stdlib.h>
       int main() {
-        __bswap_16(0);
-        __bswap_32(0);
-        __bswap_64(0);
+        _byteswap_ushort(0);
+        _byteswap_ulong(0);
+        _byteswap_uint64(0);
         return 0;
       }
-    " HAVE_GLIBC_BYTESWAP)
+    " HAVE_MSC_BYTESWAP)
 
-    if(NOT HAVE_GLIBC_BYTESWAP)
+    if(NOT HAVE_MSC_BYTESWAP)
       check_cxx_source_compiles("
-        #include <stdlib.h>
+        #include <libkern/OSByteOrder.h>
         int main() {
-          _byteswap_ushort(0);
-          _byteswap_ulong(0);
-          _byteswap_uint64(0);
+          OSSwapInt16(0);
+          OSSwapInt32(0);
+          OSSwapInt64(0);
           return 0;
         }
-      " HAVE_MSC_BYTESWAP)
+      " HAVE_MAC_BYTESWAP)
 
-      if(NOT HAVE_MSC_BYTESWAP)
+      if(NOT HAVE_MAC_BYTESWAP)
         check_cxx_source_compiles("
-          #include <libkern/OSByteOrder.h>
+          #include <sys/endian.h>
           int main() {
-            OSSwapInt16(0);
-            OSSwapInt32(0);
-            OSSwapInt64(0);
+            swap16(0);
+            swap32(0);
+            swap64(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()
+        " HAVE_OPENBSD_BYTESWAP)
       endif()
     endif()
   endif()
@@ -225,15 +185,6 @@ if(NOT ZLIB_SOURCE)
   else()
     set(HAVE_ZLIB 0)
   endif()
-
-  if(NOT HAVE_ZLIB)
-    find_package(Boost COMPONENTS iostreams zlib)
-    if(Boost_IOSTREAMS_FOUND AND Boost_ZLIB_FOUND)
-      set(HAVE_BOOST_ZLIB 1)
-    else()
-      set(HAVE_BOOST_ZLIB 0)
-    endif()
-  endif()
 endif()
 
 # Determine whether CppUnit is installed.
@@ -246,3 +197,7 @@ if(BUILD_TESTS AND NOT BUILD_SHARED_LIBS)
   endif()
 endif()
 
+# Detect WinRT mode
+if(CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
+	set(PLATFORM WINRT 1)
+endif()

INSTALL

@@ -1,159 +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_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.a 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
-  Gcc by mingw-w64.sf.net v4.6.3 (Strawberry Perl 32b)
-  MinGW32-4.8.0
-
-Requirements:
-  1. Tool chain, Build Environment, Whatever ya want to call it ...
-     Installed and working.
-  2. CMake program. (Available at: www.cmake.org)
-     Installed and working.
-
-Optional:
-  1. 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.
-  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.
-  MSVS 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 X" where X is the single or two digit version.
-       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"
-          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.
-       5. 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
-       6. 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
-       MinGW:
-         C:\GitRoot\taglib> gmake
-           OR (Depending on MinGW install)
-         C:\GitRoot\taglib> mingw32-make
-
-     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)
-
-  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
-       MinGW:
-         C:\GitRoot\taglib> gmake install
-           OR (Depending on MinGW install)
-         C:\GitRoot\taglib> mingw32-make install
-
-     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
-
-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
-

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,3 +1,38 @@
+============================
+
+ * Added support for WinRT.
+ * Added support for Linux on POWER.
+ * 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.
+ * Added support for 'GRP1' ID3v2 frame.
+ * Added support for extensible WAV subformat.
+ * 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.
+ * More tolerant handling of RIFF padding, WAV files, broken MPEG streams.
+ * Improved calculation of Ogg, Opus, Speex, WAV, MP4 bitrates.
+ * Improved Windows compatibility by storing FLAC picture after comments.
+ * Fixed numerical genres in ID3v2.3.0 'TCON' frames.
+ * Fixed consistency of API removing MP4 items when empty values are set.
+ * Fixed consistency of API preferring COMM frames with no description.
+ * Fixed OOB read on invalid Ogg FLAC files (CVE-2018-11439).
+ * Fixed handling of empty MPEG files.
+ * Fixed parsing MP4 mdhd timescale.
+ * 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.
+ * Fixed handling of non-audio blocks, sampling rates, DSD audio in WavPack files.
+ * TableOfContentsFrame::toString() improved.
+ * UserTextIdentificationFrame::toString() improved.
+ * Marked FileRef::create() deprecated.
+ * Marked MPEG::File::save() with boolean parameters deprecated,
+   provide overloads with enum parameters.
+ * Several smaller bug fixes and performance improvements.
+
 TagLib 1.11.1 (Oct 24, 2016)
 ============================
 
@@ -222,7 +257,7 @@ TagLib 1.6.3 (Apr 17, 2010)
  * Fixed definitions of the TAGLIB_WITH_MP4 and TAGLIB_WITH_ASF macros.
  * Fixed upgrading of ID3v2.3 genre frame with ID3v1 code 0 (Blues).
  * New method `int String::toInt(bool *ok)` which can return whether the
-   conversion to a number was successfull.
+   conversion to a number was successful.
  * Fixed parsing of incorrectly written lengths in ID3v2 (affects mainly
    compressed frames). (BUG:231075)
 
@@ -230,7 +265,7 @@ TagLib 1.6.2 (Apr 9, 2010)
 ==========================
 
  * Read Vorbis Comments from the first FLAC metadata block, if there are
-   multipe ones. (BUG:211089)
+   multiple ones. (BUG:211089)
  * Fixed a memory leak in FileRef's OGA format detection.
  * Fixed compilation with the Sun Studio compiler. (BUG:215225)
  * Handle WM/TrackNumber attributes with DWORD content in WMA files.
@@ -265,7 +300,7 @@ TagLib 1.6 (Sep 13, 2009)
  * Added support for disabling dllimport/dllexport on Windows using the
    TAGLIB_STATIC macro.
  * Support for parsing the obsolete 'gnre' MP4 atom.
- * New cpp macros TAGLIB_WITH_MP4 and TAGLIB_WITH_ASF to determin if
+ * New cpp macros TAGLIB_WITH_MP4 and TAGLIB_WITH_ASF to determine if
    TagLib was built with MP4/ASF support.
 
 1.6 RC1:

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,
+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()

config.h.cmake

@@ -1,7 +1,9 @@
 /* config.h. Generated by cmake from config.h.cmake */
 
+#ifndef TAGLIB_CONFIG_H
+#define TAGLIB_CONFIG_H
+
 /* Defined if your compiler supports some byte swap functions */
-#cmakedefine   HAVE_BOOST_BYTESWAP 1
 #cmakedefine   HAVE_GCC_BYTESWAP 1
 #cmakedefine   HAVE_GLIBC_BYTESWAP 1
 #cmakedefine   HAVE_MSC_BYTESWAP 1
@@ -9,8 +11,6 @@
 #cmakedefine   HAVE_OPENBSD_BYTESWAP 1
 
 /* Defined if your compiler supports some atomic operations */
-#cmakedefine   HAVE_STD_ATOMIC 1
-#cmakedefine   HAVE_BOOST_ATOMIC 1
 #cmakedefine   HAVE_GCC_ATOMIC 1
 #cmakedefine   HAVE_MAC_ATOMIC 1
 #cmakedefine   HAVE_WIN_ATOMIC 1
@@ -25,9 +25,10 @@
 
 /* Defined if zlib is installed */
 #cmakedefine   HAVE_ZLIB 1
-#cmakedefine   HAVE_BOOST_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

@@ -5,6 +5,7 @@ include_directories(
   ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/mpeg
   ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/mpeg/id3v1
   ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/mpeg/id3v2
+  ${CMAKE_CURRENT_SOURCE_DIR}/../taglib/mpeg/id3v2/frames
   ${CMAKE_CURRENT_SOURCE_DIR}/../bindings/c/
 )
 

examples/framelist.cpp

@@ -32,6 +32,7 @@
 #include <id3v2tag.h>
 #include <id3v2frame.h>
 #include <id3v2header.h>
+#include <commentsframe.h>
 
 #include <id3v1tag.h>
 
@@ -65,8 +66,15 @@ int main(int argc, char *argv[])
            << endl;
 
       ID3v2::FrameList::ConstIterator it = id3v2tag->frameList().begin();
-      for(; it != id3v2tag->frameList().end(); it++)
-        cout << (*it)->frameID() << " - \"" << (*it)->toString() << "\"" << endl;
+      for(; it != id3v2tag->frameList().end(); it++) {
+        cout << (*it)->frameID();
+
+        if(ID3v2::CommentsFrame *comment = dynamic_cast<ID3v2::CommentsFrame *>(*it))
+          if(!comment->description().isEmpty())
+            cout << " [" << comment->description() << "]";
+
+        cout << " - \"" << (*it)->toString() << "\"" << endl;
+      }
     }
     else
       cout << "file does not have a valid id3v2 tag" << endl;

taglib-config.cmake

@@ -14,10 +14,10 @@ EOH
 	exit 1;
 }
 
-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@
 
 flags=""
 
@@ -29,13 +29,13 @@ while test $# -gt 0
 do
   case $1 in
     --libs)
-	  flags="$flags -L$libdir -ltag"
+	  flags="$flags -L$libdir -ltag @ZLIB_LIBRARIES_FLAGS@"
 	  ;;
     --cflags)
-	  flags="$flags -I$includedir/taglib"
+	  flags="$flags -I$includedir -I$includedir/taglib"
 	  ;;
     --version)
-	  echo ${TAGLIB_LIB_VERSION_STRING}
+	  echo @TAGLIB_LIB_VERSION_STRING@
 	  ;;
     --prefix)
 	  echo $prefix

taglib-config.cmd.cmake

@@ -28,7 +28,7 @@ goto theend
   * 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#" == "--cflags#"  echo -I${INCLUDE_INSTALL_DIR} -I${INCLUDE_INSTALL_DIR}/taglib
 if /i "%1#" == "--version#" echo ${TAGLIB_LIB_VERSION_STRING}
 if /i "%1#" == "--prefix#"  echo ${CMAKE_INSTALL_PREFIX}
 

taglib.pc.cmake

@@ -7,5 +7,5 @@ Name: TagLib
 Description: Audio meta-data library
 Requires: 
 Version: @TAGLIB_LIB_VERSION_STRING@
-Libs: -L${libdir} -ltag
-Cflags: -I${includedir}/taglib
+Libs: -L${libdir} -ltag @ZLIB_LIBRARIES_FLAGS@
+Cflags: -I${includedir} -I${includedir}/taglib

taglib/CMakeLists.txt

@@ -24,6 +24,7 @@ include_directories(
   ${CMAKE_CURRENT_SOURCE_DIR}/s3m
   ${CMAKE_CURRENT_SOURCE_DIR}/it
   ${CMAKE_CURRENT_SOURCE_DIR}/xm
+  ${taglib_SOURCE_DIR}/3rdparty
 )
 
 if(ZLIB_FOUND)
@@ -32,10 +33,6 @@ elseif(HAVE_ZLIB_SOURCE)
   include_directories(${ZLIB_SOURCE})
 endif()
 
-if(HAVE_BOOST_BYTESWAP OR HAVE_BOOST_ATOMIC OR HAVE_BOOST_ZLIB)
-  include_directories(${Boost_INCLUDE_DIR})
-endif()
-
 set(tag_HDRS
   tag.h
   fileref.h
@@ -64,6 +61,7 @@ set(tag_HDRS
   mpeg/xingheader.h
   mpeg/id3v1/id3v1tag.h
   mpeg/id3v1/id3v1genres.h
+  mpeg/id3v2/id3v2.h
   mpeg/id3v2/id3v2extendedheader.h
   mpeg/id3v2/id3v2frame.h
   mpeg/id3v2/id3v2header.h
@@ -312,12 +310,6 @@ set(toolkit_SRCS
   toolkit/tzlib.cpp
 )
 
-if(NOT WIN32)
-  set(unicode_SRCS
-    toolkit/unicode.cpp
-  )
-endif()
-
 if(HAVE_ZLIB_SOURCE)
   set(zlib_SRCS
     ${ZLIB_SOURCE}/adler32.c
@@ -334,7 +326,7 @@ set(tag_LIB_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} ${opus_SRCS}
-  ${unicode_SRCS} ${zlib_SRCS}
+  ${zlib_SRCS}
   tag.cpp
   tagunion.cpp
   fileref.cpp
@@ -343,19 +335,12 @@ set(tag_LIB_SRCS
 )
 
 add_library(tag ${tag_LIB_SRCS} ${tag_HDRS})
+set_property(TARGET tag PROPERTY CXX_STANDARD 98)
 
-if(ZLIB_FOUND)
+if(HAVE_ZLIB AND NOT HAVE_ZLIB_SOURCE)
   target_link_libraries(tag ${ZLIB_LIBRARIES})
 endif()
 
-if(HAVE_BOOST_ATOMIC)
-  target_link_libraries(tag ${Boost_ATOMIC_LIBRARY})
-endif()
-
-if(HAVE_BOOST_ZLIB)
-  target_link_libraries(tag ${Boost_IOSTREAMS_LIBRARY} ${Boost_ZLIB_LIBRARY})
-endif()
-
 set_target_properties(tag PROPERTIES
   VERSION ${TAGLIB_SOVERSION_MAJOR}.${TAGLIB_SOVERSION_MINOR}.${TAGLIB_SOVERSION_PATCH}
   SOVERSION ${TAGLIB_SOVERSION_MAJOR}
@@ -364,8 +349,18 @@ 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

taglib/ape/ape-tag-format.txt

@@ -49,8 +49,8 @@ APE Tag Version 2.000 (with header, recommended):
 
 APE tag items should be sorted ascending by size.  When streaming, parts of the
 APE tag may be dropped to reduce the danger of drop outs between tracks.  This
-is not required, but is strongly recommended.  It would be desirable for the i
-tems to be sorted by importance / size, but this is not feasible.  This
+is not required, but is strongly recommended.  It would be desirable for the
+items to be sorted by importance / size, but this is not feasible.  This
 convention should only be broken when adding less important small items and it
 is not desirable to rewrite the entire tag.  An APE tag at the end of a file
 (the recommended location) must have at least a footer; an APE tag at the

taglib/ape/apefile.cpp

@@ -83,6 +83,18 @@ public:
   Properties *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 ") >= 0);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // public members
 ////////////////////////////////////////////////////////////////////////////////

taglib/ape/apefile.h

@@ -211,6 +211,15 @@ namespace TagLib {
        */
       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 &);

taglib/ape/apeproperties.h

@@ -55,7 +55,7 @@ namespace TagLib {
        *
        * \deprecated
        */
-      Properties(File *file, ReadStyle style = Average);
+      TAGLIB_DEPRECATED Properties(File *file, ReadStyle style = Average);
 
       /*!
        * Create an instance of APE::Properties with the data read from the
@@ -76,7 +76,7 @@ namespace TagLib {
        *
        * \deprecated
        */
-      virtual int length() const;
+      TAGLIB_DEPRECATED virtual int length() const;
 
       /*!
        * Returns the length of the file in seconds.  The length is rounded down to

taglib/ape/apetag.cpp

@@ -47,23 +47,24 @@ using namespace APE;
 
 namespace
 {
-  bool isKeyValid(const char *key, size_t length)
+  const unsigned int MinKeyLength = 2;
+  const unsigned int MaxKeyLength = 255;
+
+  bool isKeyValid(const ByteVector &key)
   {
     const char *invalidKeys[] = { "ID3", "TAG", "OGGS", "MP+", 0 };
 
-    if(length < 2 || length > 255)
-      return false;
-
     // only allow printable ASCII including space (32..126)
 
-    for(const char *p = key; p < key + length; ++p) {
-      const int c = static_cast<unsigned char>(*p);
+    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(Utils::equalsIgnoreCase(key, invalidKeys[i]))
+      if(upperKey == invalidKeys[i])
         return false;
     }
 
@@ -191,7 +192,7 @@ void APE::Tag::setGenre(const String &s)
 
 void APE::Tag::setYear(unsigned int i)
 {
-  if(i <= 0)
+  if(i == 0)
     removeItem("YEAR");
   else
     addValue("YEAR", String::number(i), true);
@@ -199,7 +200,7 @@ void APE::Tag::setYear(unsigned int i)
 
 void APE::Tag::setTrack(unsigned int i)
 {
-  if(i <= 0)
+  if(i == 0)
     removeItem("TRACK");
   else
     addValue("TRACK", String::number(i), true);
@@ -214,7 +215,9 @@ namespace
                                       {"DATE",        "YEAR"        },
                                       {"ALBUMARTIST", "ALBUM ARTIST"},
                                       {"DISCNUMBER",  "DISC"        },
-                                      {"REMIXER",     "MIXARTIST"   }};
+                                      {"REMIXER",     "MIXARTIST"   },
+                                      {"RELEASESTATUS", "MUSICBRAINZ_ALBUMSTATUS" },
+                                      {"RELEASETYPE", "MUSICBRAINZ_ALBUMTYPE" }};
   const size_t keyConversionsSize = sizeof(keyConversions) / sizeof(keyConversions[0]);
 }
 
@@ -296,11 +299,10 @@ PropertyMap APE::Tag::setProperties(const PropertyMap &origProps)
 
 bool APE::Tag::checkKey(const String &key)
 {
-  if(!key.isLatin1())
+  if(key.size() < MinKeyLength || key.size() > MaxKeyLength)
     return false;
 
-  const std::string data = key.to8Bit(false);
-  return isKeyValid(data.c_str(), data.size());
+  return isKeyValid(key.data(String::UTF8));
 }
 
 APE::Footer *APE::Tag::footer() const
@@ -419,7 +421,10 @@ void APE::Tag::parse(const ByteVector &data)
     const unsigned int keyLength = nullPos - pos - 8;
     const unsigned int valLegnth = data.toUInt(pos, false);
 
-    if(isKeyValid(&data[pos + 8], keyLength)){
+    if(keyLength >= MinKeyLength
+      && keyLength <= MaxKeyLength
+      && isKeyValid(data.mid(pos + 8, keyLength)))
+    {
       APE::Item item;
       item.parse(data.mid(pos));
 

taglib/asf/asfattribute.cpp

@@ -36,20 +36,16 @@ using namespace TagLib;
 class ASF::Attribute::AttributePrivate : public RefCounter
 {
 public:
-  AttributePrivate()
-    : pictureValue(ASF::Picture::fromInvalid()),
-      stream(0),
-      language(0) {}
+  AttributePrivate() :
+    pictureValue(ASF::Picture::fromInvalid()),
+    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;
-  };
+  unsigned long long numericValue;
   int stream;
   int language;
 };
@@ -95,28 +91,28 @@ ASF::Attribute::Attribute(unsigned int value) :
   d(new AttributePrivate())
 {
   d->type = DWordType;
-  d->intValue = value;
+  d->numericValue = value;
 }
 
 ASF::Attribute::Attribute(unsigned long long value) :
   d(new AttributePrivate())
 {
   d->type = QWordType;
-  d->longLongValue = value;
+  d->numericValue = value;
 }
 
 ASF::Attribute::Attribute(unsigned short value) :
   d(new AttributePrivate())
 {
   d->type = WordType;
-  d->shortValue = value;
+  d->numericValue = value;
 }
 
 ASF::Attribute::Attribute(bool value) :
   d(new AttributePrivate())
 {
   d->type = BoolType;
-  d->boolValue = value;
+  d->numericValue = value;
 }
 
 ASF::Attribute &ASF::Attribute::operator=(const ASF::Attribute &other)
@@ -157,22 +153,22 @@ ByteVector ASF::Attribute::toByteVector() const
 
 unsigned short ASF::Attribute::toBool() const
 {
-  return d->shortValue;
+  return d->numericValue ? 1 : 0;
 }
 
 unsigned short ASF::Attribute::toUShort() const
 {
-  return d->shortValue;
+  return static_cast<unsigned short>(d->numericValue);
 }
 
 unsigned int ASF::Attribute::toUInt() const
 {
-  return d->intValue;
+  return static_cast<unsigned int>(d->numericValue);
 }
 
 unsigned long long ASF::Attribute::toULongLong() const
 {
-  return d->longLongValue;
+  return static_cast<unsigned long long>(d->numericValue);
 }
 
 ASF::Picture ASF::Attribute::toPicture() const
@@ -212,24 +208,24 @@ String ASF::Attribute::parse(ASF::File &f, int kind)
 
   switch(d->type) {
   case WordType:
-    d->shortValue = readWORD(&f);
+    d->numericValue = readWORD(&f);
     break;
 
   case BoolType:
     if(kind == 0) {
-      d->boolValue = (readDWORD(&f) == 1);
+      d->numericValue = (readDWORD(&f) != 0);
     }
     else {
-      d->boolValue = (readWORD(&f) == 1);
+      d->numericValue = (readWORD(&f) != 0);
     }
     break;
 
   case DWordType:
-    d->intValue = readDWORD(&f);
+    d->numericValue = readDWORD(&f);
     break;
 
   case QWordType:
-    d->longLongValue = readQWORD(&f);
+    d->numericValue = readQWORD(&f);
     break;
 
   case UnicodeType:
@@ -280,24 +276,24 @@ ByteVector ASF::Attribute::render(const String &name, int kind) const
 
   switch (d->type) {
   case WordType:
-    data.append(ByteVector::fromShort(d->shortValue, false));
+    data.append(ByteVector::fromShort(toUShort(), false));
     break;
 
   case BoolType:
     if(kind == 0) {
-      data.append(ByteVector::fromUInt(d->boolValue ? 1 : 0, false));
+      data.append(ByteVector::fromUInt(toBool(), false));
     }
     else {
-      data.append(ByteVector::fromShort(d->boolValue ? 1 : 0, false));
+      data.append(ByteVector::fromShort(toBool(), false));
     }
     break;
 
   case DWordType:
-    data.append(ByteVector::fromUInt(d->intValue, false));
+    data.append(ByteVector::fromUInt(toUInt(), false));
     break;
 
   case QWordType:
-    data.append(ByteVector::fromLongLong(d->longLongValue, false));
+    data.append(ByteVector::fromLongLong(toULongLong(), false));
     break;
 
   case UnicodeType:

taglib/asf/asfattribute.h

@@ -113,7 +113,7 @@ 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.

taglib/asf/asffile.cpp

@@ -27,6 +27,7 @@
 #include <tbytevectorlist.h>
 #include <tpropertymap.h>
 #include <tstring.h>
+#include <tagutils.h>
 
 #include "asffile.h"
 #include "asftag.h"
@@ -258,7 +259,6 @@ ByteVector ASF::File::FilePrivate::ContentDescriptionObject::guid() const
 
 void ASF::File::FilePrivate::ContentDescriptionObject::parse(ASF::File *file, unsigned int /*size*/)
 {
-  file->d->contentDescriptionObject = this;
   const int titleLength     = readWORD(file);
   const int artistLength    = readWORD(file);
   const int copyrightLength = readWORD(file);
@@ -299,7 +299,6 @@ ByteVector ASF::File::FilePrivate::ExtendedContentDescriptionObject::guid() cons
 
 void ASF::File::FilePrivate::ExtendedContentDescriptionObject::parse(ASF::File *file, unsigned int /*size*/)
 {
-  file->d->extendedContentDescriptionObject = this;
   int count = readWORD(file);
   while(count--) {
     ASF::Attribute attribute;
@@ -323,7 +322,6 @@ ByteVector ASF::File::FilePrivate::MetadataObject::guid() const
 
 void ASF::File::FilePrivate::MetadataObject::parse(ASF::File *file, unsigned int /*size*/)
 {
-  file->d->metadataObject = this;
   int count = readWORD(file);
   while(count--) {
     ASF::Attribute attribute;
@@ -347,7 +345,6 @@ ByteVector ASF::File::FilePrivate::MetadataLibraryObject::guid() const
 
 void ASF::File::FilePrivate::MetadataLibraryObject::parse(ASF::File *file, unsigned int /*size*/)
 {
-  file->d->metadataLibraryObject = this;
   int count = readWORD(file);
   while(count--) {
     ASF::Attribute attribute;
@@ -376,7 +373,6 @@ ByteVector ASF::File::FilePrivate::HeaderExtensionObject::guid() const
 
 void ASF::File::FilePrivate::HeaderExtensionObject::parse(ASF::File *file, unsigned int /*size*/)
 {
-  file->d->headerExtensionObject = this;
   file->seek(18, File::Current);
   long long dataSize = readDWORD(file);
   long long dataPos = 0;
@@ -394,10 +390,12 @@ void ASF::File::FilePrivate::HeaderExtensionObject::parse(ASF::File *file, unsig
     }
     BaseObject *obj;
     if(guid == metadataGuid) {
-      obj = new MetadataObject();
+      file->d->metadataObject = new MetadataObject();
+      obj = file->d->metadataObject;
     }
     else if(guid == metadataLibraryGuid) {
-      obj = new MetadataLibraryObject();
+      file->d->metadataLibraryObject = new MetadataLibraryObject();
+      obj = file->d->metadataLibraryObject;
     }
     else {
       obj = new UnknownObject(guid);
@@ -473,6 +471,18 @@ void ASF::File::FilePrivate::CodecListObject::parse(ASF::File *file, unsigned in
   }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// 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
 ////////////////////////////////////////////////////////////////////////////////
@@ -616,9 +626,8 @@ void ASF::File::read()
   if(!isValid())
     return;
 
-  ByteVector guid = readBlock(16);
-  if(guid != headerGuid) {
-    debug("ASF: Not an ASF file.");
+  if(readBlock(16) != headerGuid) {
+    debug("ASF::File::read(): Not an ASF file.");
     setValid(false);
     return;
   }
@@ -639,8 +648,10 @@ void ASF::File::read()
   }
   seek(2, Current);
 
+  FilePrivate::FilePropertiesObject   *filePropertiesObject   = 0;
+  FilePrivate::StreamPropertiesObject *streamPropertiesObject = 0;
   for(int i = 0; i < numObjects; i++) {
-    guid = readBlock(16);
+    const ByteVector guid = readBlock(16);
     if(guid.size() != 16) {
       setValid(false);
       break;
@@ -652,19 +663,24 @@ void ASF::File::read()
     }
     FilePrivate::BaseObject *obj;
     if(guid == filePropertiesGuid) {
-      obj = new FilePrivate::FilePropertiesObject();
+      filePropertiesObject = new FilePrivate::FilePropertiesObject();
+      obj = filePropertiesObject;
     }
     else if(guid == streamPropertiesGuid) {
-      obj = new FilePrivate::StreamPropertiesObject();
+      streamPropertiesObject = new FilePrivate::StreamPropertiesObject();
+      obj = streamPropertiesObject;
     }
     else if(guid == contentDescriptionGuid) {
-      obj = new FilePrivate::ContentDescriptionObject();
+      d->contentDescriptionObject = new FilePrivate::ContentDescriptionObject();
+      obj = d->contentDescriptionObject;
     }
     else if(guid == extendedContentDescriptionGuid) {
-      obj = new FilePrivate::ExtendedContentDescriptionObject();
+      d->extendedContentDescriptionObject = new FilePrivate::ExtendedContentDescriptionObject();
+      obj = d->extendedContentDescriptionObject;
     }
     else if(guid == headerExtensionGuid) {
-      obj = new FilePrivate::HeaderExtensionObject();
+      d->headerExtensionObject = new FilePrivate::HeaderExtensionObject();
+      obj = d->headerExtensionObject;
     }
     else if(guid == codecListGuid) {
       obj = new FilePrivate::CodecListObject();
@@ -680,4 +696,10 @@ void ASF::File::read()
     obj->parse(this, size);
     d->objects.append(obj);
   }
+
+  if(!filePropertiesObject || !streamPropertiesObject) {
+    debug("ASF::File::read(): Missing mandatory header objects.");
+    setValid(false);
+    return;
+  }
 }

taglib/asf/asffile.h

@@ -115,6 +115,15 @@ 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:
       void read();
 

taglib/asf/asfproperties.h

@@ -88,7 +88,7 @@ namespace TagLib {
        *
        * \deprecated
        */
-      virtual int length() const;
+      TAGLIB_DEPRECATED virtual int length() const;
 
       /*!
        * Returns the length of the file in seconds.  The length is rounded down to

taglib/asf/asftag.cpp

@@ -39,10 +39,10 @@ public:
   AttributeListMap attributeListMap;
 };
 
-ASF::Tag::Tag()
-: TagLib::Tag()
+ASF::Tag::Tag() :
+  TagLib::Tag(),
+  d(new TagPrivate())
 {
-  d = new TagPrivate;
 }
 
 ASF::Tag::~Tag()
@@ -216,7 +216,7 @@ namespace
     { "WM/AlbumTitle", "ALBUM" },
     { "WM/AlbumArtist", "ALBUMARTIST" },
     { "WM/Composer", "COMPOSER" },
-    { "WM/Writer", "WRITER" },
+    { "WM/Writer", "LYRICIST" },
     { "WM/Conductor", "CONDUCTOR" },
     { "WM/ModifiedBy", "REMIXER" },
     { "WM/Year", "DATE" },
@@ -243,11 +243,17 @@ namespace
     { "WM/TitleSortOrder", "TITLESORT" },
     { "WM/Script", "SCRIPT" },
     { "WM/Language", "LANGUAGE" },
+    { "WM/ARTISTS", "ARTISTS" },
+    { "ASIN", "ASIN" },
     { "MusicBrainz/Track Id", "MUSICBRAINZ_TRACKID" },
     { "MusicBrainz/Artist Id", "MUSICBRAINZ_ARTISTID" },
     { "MusicBrainz/Album Id", "MUSICBRAINZ_ALBUMID" },
     { "MusicBrainz/Album Artist Id", "MUSICBRAINZ_ALBUMARTISTID" },
+    { "MusicBrainz/Album Release Country", "RELEASECOUNTRY" },
+    { "MusicBrainz/Album Status", "RELEASESTATUS" },
+    { "MusicBrainz/Album Type", "RELEASETYPE" },
     { "MusicBrainz/Release Group Id", "MUSICBRAINZ_RELEASEGROUPID" },
+    { "MusicBrainz/Release Track Id", "MUSICBRAINZ_RELEASETRACKID" },
     { "MusicBrainz/Work Id", "MUSICBRAINZ_WORKID" },
     { "MusicIP/PUID", "MUSICIP_PUID" },
     { "Acoustid/Id", "ACOUSTID_ID" },

taglib/asf/asftag.h

@@ -160,6 +160,7 @@ namespace TagLib {
        * Returns a reference to the item list map.  This is an AttributeListMap of
        * all of the items in the tag.
        */
+      // BIC: return by value
       const AttributeListMap &attributeListMap() const;
 
       /*!

taglib/audioproperties.cpp

@@ -43,6 +43,39 @@
 
 using namespace TagLib;
 
+// This macro is a workaround for the fact that we can't add virtual functions.
+// Should be true virtual functions in taglib2.
+
+#define VIRTUAL_FUNCTION_WORKAROUND(function_name, default_value)               \
+  if(dynamic_cast<const APE::Properties*>(this))                                \
+    return dynamic_cast<const APE::Properties*>(this)->function_name();         \
+  else if(dynamic_cast<const ASF::Properties*>(this))                           \
+    return dynamic_cast<const ASF::Properties*>(this)->function_name();         \
+  else if(dynamic_cast<const FLAC::Properties*>(this))                          \
+    return dynamic_cast<const FLAC::Properties*>(this)->function_name();        \
+  else if(dynamic_cast<const MP4::Properties*>(this))                           \
+    return dynamic_cast<const MP4::Properties*>(this)->function_name();         \
+  else if(dynamic_cast<const MPC::Properties*>(this))                           \
+    return dynamic_cast<const MPC::Properties*>(this)->function_name();         \
+  else if(dynamic_cast<const MPEG::Properties*>(this))                          \
+    return dynamic_cast<const MPEG::Properties*>(this)->function_name();        \
+  else if(dynamic_cast<const Ogg::Opus::Properties*>(this))                     \
+    return dynamic_cast<const Ogg::Opus::Properties*>(this)->function_name();   \
+  else if(dynamic_cast<const Ogg::Speex::Properties*>(this))                    \
+    return dynamic_cast<const Ogg::Speex::Properties*>(this)->function_name();  \
+  else if(dynamic_cast<const TrueAudio::Properties*>(this))                     \
+    return dynamic_cast<const TrueAudio::Properties*>(this)->function_name();   \
+  else if(dynamic_cast<const RIFF::AIFF::Properties*>(this))                    \
+    return dynamic_cast<const RIFF::AIFF::Properties*>(this)->function_name();  \
+  else if(dynamic_cast<const RIFF::WAV::Properties*>(this))                     \
+    return dynamic_cast<const RIFF::WAV::Properties*>(this)->function_name();   \
+  else if(dynamic_cast<const Vorbis::Properties*>(this))                        \
+    return dynamic_cast<const Vorbis::Properties*>(this)->function_name();      \
+  else if(dynamic_cast<const WavPack::Properties*>(this))                       \
+    return dynamic_cast<const WavPack::Properties*>(this)->function_name();     \
+  else                                                                          \
+    return (default_value);
+
 class AudioProperties::AudioPropertiesPrivate
 {
 
@@ -59,98 +92,12 @@ AudioProperties::~AudioProperties()
 
 int AudioProperties::lengthInSeconds() const
 {
-  // This is an ugly workaround but we can't add a virtual function.
-  // Should be virtual in taglib2.
-
-  if(dynamic_cast<const APE::Properties*>(this))
-    return dynamic_cast<const APE::Properties*>(this)->lengthInSeconds();
-
-  else if(dynamic_cast<const ASF::Properties*>(this))
-    return dynamic_cast<const ASF::Properties*>(this)->lengthInSeconds();
-
-  else if(dynamic_cast<const FLAC::Properties*>(this))
-    return dynamic_cast<const FLAC::Properties*>(this)->lengthInSeconds();
-
-  else if(dynamic_cast<const MP4::Properties*>(this))
-    return dynamic_cast<const MP4::Properties*>(this)->lengthInSeconds();
-
-  else if(dynamic_cast<const MPC::Properties*>(this))
-    return dynamic_cast<const MPC::Properties*>(this)->lengthInSeconds();
-
-  else if(dynamic_cast<const MPEG::Properties*>(this))
-    return dynamic_cast<const MPEG::Properties*>(this)->lengthInSeconds();
-
-  else if(dynamic_cast<const Ogg::Opus::Properties*>(this))
-    return dynamic_cast<const Ogg::Opus::Properties*>(this)->lengthInSeconds();
-
-  else if(dynamic_cast<const Ogg::Speex::Properties*>(this))
-    return dynamic_cast<const Ogg::Speex::Properties*>(this)->lengthInSeconds();
-
-  else if(dynamic_cast<const TrueAudio::Properties*>(this))
-    return dynamic_cast<const TrueAudio::Properties*>(this)->lengthInSeconds();
-
-  else if (dynamic_cast<const RIFF::AIFF::Properties*>(this))
-    return dynamic_cast<const RIFF::AIFF::Properties*>(this)->lengthInSeconds();
-
-  else if(dynamic_cast<const RIFF::WAV::Properties*>(this))
-    return dynamic_cast<const RIFF::WAV::Properties*>(this)->lengthInSeconds();
-
-  else if(dynamic_cast<const Vorbis::Properties*>(this))
-    return dynamic_cast<const Vorbis::Properties*>(this)->lengthInSeconds();
-
-  else if(dynamic_cast<const WavPack::Properties*>(this))
-    return dynamic_cast<const WavPack::Properties*>(this)->lengthInSeconds();
-
-  else
-    return 0;
+  VIRTUAL_FUNCTION_WORKAROUND(lengthInSeconds, 0)
 }
 
 int AudioProperties::lengthInMilliseconds() const
 {
-  // This is an ugly workaround but we can't add a virtual function.
-  // Should be virtual in taglib2.
-
-  if(dynamic_cast<const APE::Properties*>(this))
-    return dynamic_cast<const APE::Properties*>(this)->lengthInMilliseconds();
-
-  else if(dynamic_cast<const ASF::Properties*>(this))
-    return dynamic_cast<const ASF::Properties*>(this)->lengthInMilliseconds();
-
-  else if(dynamic_cast<const FLAC::Properties*>(this))
-    return dynamic_cast<const FLAC::Properties*>(this)->lengthInMilliseconds();
-
-  else if(dynamic_cast<const MP4::Properties*>(this))
-    return dynamic_cast<const MP4::Properties*>(this)->lengthInMilliseconds();
-
-  else if(dynamic_cast<const MPC::Properties*>(this))
-    return dynamic_cast<const MPC::Properties*>(this)->lengthInMilliseconds();
-
-  else if(dynamic_cast<const MPEG::Properties*>(this))
-    return dynamic_cast<const MPEG::Properties*>(this)->lengthInMilliseconds();
-
-  else if(dynamic_cast<const Ogg::Opus::Properties*>(this))
-    return dynamic_cast<const Ogg::Opus::Properties*>(this)->lengthInMilliseconds();
-
-  else if(dynamic_cast<const Ogg::Speex::Properties*>(this))
-    return dynamic_cast<const Ogg::Speex::Properties*>(this)->lengthInMilliseconds();
-
-  else if(dynamic_cast<const TrueAudio::Properties*>(this))
-    return dynamic_cast<const TrueAudio::Properties*>(this)->lengthInMilliseconds();
-
-  else if(dynamic_cast<const RIFF::AIFF::Properties*>(this))
-    return dynamic_cast<const RIFF::AIFF::Properties*>(this)->lengthInMilliseconds();
-
-  else if(dynamic_cast<const RIFF::WAV::Properties*>(this))
-    return dynamic_cast<const RIFF::WAV::Properties*>(this)->lengthInMilliseconds();
-
-  else if(dynamic_cast<const Vorbis::Properties*>(this))
-    return dynamic_cast<const Vorbis::Properties*>(this)->lengthInMilliseconds();
-
-  else if(dynamic_cast<const WavPack::Properties*>(this))
-    return dynamic_cast<const WavPack::Properties*>(this)->lengthInMilliseconds();
-
-  else
-    return 0;
+  VIRTUAL_FUNCTION_WORKAROUND(lengthInMilliseconds, 0)
 }
 
 ////////////////////////////////////////////////////////////////////////////////

taglib/fileref.cpp

@@ -27,7 +27,10 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
+#include <cstring>
+
 #include <tfile.h>
+#include <tfilestream.h>
 #include <tstring.h>
 #include <tdebug.h>
 #include <trefcounter.h>
@@ -59,49 +62,16 @@ namespace
   typedef List<const FileRef::FileTypeResolver *> ResolverList;
   ResolverList fileTypeResolvers;
 
-  // Templatized internal functions. T should be String or IOStream*.
+  // Detect the file type by user-defined resolvers.
 
-  template <typename T>
-  FileName toFileName(T arg)
-  {
-    debug("FileRef::toFileName<T>(): This version should never be called.");
-    return FileName(L"");
-  }
-
-  template <>
-  FileName toFileName<IOStream *>(IOStream *arg)
-  {
-    return arg->name();
-  }
-
-  template <>
-  FileName toFileName<FileName>(FileName arg)
-  {
-    return arg;
-  }
-
-  template <typename T>
-  File *resolveFileType(T arg, bool readProperties,
-                        AudioProperties::ReadStyle style)
-  {
-    debug("FileRef::resolveFileType<T>(): This version should never be called.");
-    return 0;
-  }
-
-  template <>
-  File *resolveFileType<IOStream *>(IOStream *arg, bool readProperties,
-                                    AudioProperties::ReadStyle style)
-  {
-    return 0;
-  }
-
-  template <>
-  File *resolveFileType<FileName>(FileName arg, bool readProperties,
-                                  AudioProperties::ReadStyle style)
+  File *detectByResolvers(FileName fileName, bool readAudioProperties,
+                          AudioProperties::ReadStyle audioPropertiesStyle)
   {
+    if(::strlen(fileName) == 0)
+      return 0;
     ResolverList::ConstIterator it = fileTypeResolvers.begin();
     for(; it != fileTypeResolvers.end(); ++it) {
-      File *file = (*it)->createFile(arg, readProperties, style);
+      File *file = (*it)->createFile(fileName, readAudioProperties, audioPropertiesStyle);
       if(file)
         return file;
     }
@@ -109,18 +79,15 @@ namespace
     return 0;
   }
 
-  template <typename T>
-  File* createInternal(T arg, bool readAudioProperties,
-                       AudioProperties::ReadStyle audioPropertiesStyle)
-  {
-    File *file = resolveFileType(arg, readAudioProperties, audioPropertiesStyle);
-    if(file)
-      return file;
+  // Detect the file type based on the file extension.
 
+  File* detectByExtension(IOStream *stream, bool readAudioProperties,
+                          AudioProperties::ReadStyle audioPropertiesStyle)
+  {
 #ifdef _WIN32
-    const String s = toFileName(arg).toString();
+    const String s = stream->name().toString();
 #else
-    const String s(toFileName(arg));
+    const String s(stream->name());
 #endif
 
     String ext;
@@ -135,49 +102,163 @@ namespace
     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(arg, ID3v2::FrameFactory::instance(), readAudioProperties, audioPropertiesStyle);
+      return new MPEG::File(stream, ID3v2::FrameFactory::instance(), readAudioProperties, audioPropertiesStyle);
     if(ext == "OGG")
-      return new Ogg::Vorbis::File(arg, readAudioProperties, audioPropertiesStyle);
+      return new Ogg::Vorbis::File(stream, readAudioProperties, audioPropertiesStyle);
+    if(ext == "FLAC")
+      return new FLAC::File(stream, ID3v2::FrameFactory::instance(), 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);
+
+    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, ID3v2::FrameFactory::instance(), 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);
+
+    // isSupported() only does a quick check, so double check the file here.
+
+    if(file) {
+      if(file->isValid())
+        return file;
+      else
+        delete file;
+    }
+
+    return 0;
+  }
+
+  // Internal function that supports FileRef::create().
+  // This looks redundant, but necessary in order not to change the previous
+  // behavior of FileRef::create().
+
+  File* createInternal(FileName fileName, bool readAudioProperties,
+                       AudioProperties::ReadStyle audioPropertiesStyle)
+  {
+    File *file = detectByResolvers(fileName, readAudioProperties, audioPropertiesStyle);
+    if(file)
+      return file;
+
+#ifdef _WIN32
+    const String s = fileName.toString();
+#else
+    const String s(fileName);
+#endif
+
+    String ext;
+    const int pos = s.rfind(".");
+    if(pos != -1)
+      ext = s.substr(pos + 1).upper();
+
+    if(ext.isEmpty())
+      return 0;
+
+    if(ext == "MP3")
+      return new MPEG::File(fileName, ID3v2::FrameFactory::instance(), 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(arg, readAudioProperties, audioPropertiesStyle);
+      File *file = new Ogg::FLAC::File(fileName, readAudioProperties, audioPropertiesStyle);
       if(file->isValid())
         return file;
       delete file;
-      return new Ogg::Vorbis::File(arg, readAudioProperties, audioPropertiesStyle);
+      return new Ogg::Vorbis::File(fileName, readAudioProperties, audioPropertiesStyle);
     }
     if(ext == "FLAC")
-      return new FLAC::File(arg, ID3v2::FrameFactory::instance(), readAudioProperties, audioPropertiesStyle);
+      return new FLAC::File(fileName, ID3v2::FrameFactory::instance(), readAudioProperties, audioPropertiesStyle);
     if(ext == "MPC")
-      return new MPC::File(arg, readAudioProperties, audioPropertiesStyle);
+      return new MPC::File(fileName, readAudioProperties, audioPropertiesStyle);
     if(ext == "WV")
-      return new WavPack::File(arg, readAudioProperties, audioPropertiesStyle);
+      return new WavPack::File(fileName, readAudioProperties, audioPropertiesStyle);
     if(ext == "SPX")
-      return new Ogg::Speex::File(arg, readAudioProperties, audioPropertiesStyle);
+      return new Ogg::Speex::File(fileName, readAudioProperties, audioPropertiesStyle);
     if(ext == "OPUS")
-      return new Ogg::Opus::File(arg, readAudioProperties, audioPropertiesStyle);
+      return new Ogg::Opus::File(fileName, readAudioProperties, audioPropertiesStyle);
     if(ext == "TTA")
-      return new TrueAudio::File(arg, readAudioProperties, audioPropertiesStyle);
+      return new TrueAudio::File(fileName, readAudioProperties, audioPropertiesStyle);
     if(ext == "M4A" || ext == "M4R" || ext == "M4B" || ext == "M4P" || ext == "MP4" || ext == "3G2" || ext == "M4V")
-      return new MP4::File(arg, readAudioProperties, audioPropertiesStyle);
+      return new MP4::File(fileName, readAudioProperties, audioPropertiesStyle);
     if(ext == "WMA" || ext == "ASF")
-      return new ASF::File(arg, readAudioProperties, audioPropertiesStyle);
+      return new ASF::File(fileName, readAudioProperties, audioPropertiesStyle);
     if(ext == "AIF" || ext == "AIFF" || ext == "AFC" || ext == "AIFC")
-      return new RIFF::AIFF::File(arg, readAudioProperties, audioPropertiesStyle);
+      return new RIFF::AIFF::File(fileName, readAudioProperties, audioPropertiesStyle);
     if(ext == "WAV")
-      return new RIFF::WAV::File(arg, readAudioProperties, audioPropertiesStyle);
+      return new RIFF::WAV::File(fileName, readAudioProperties, audioPropertiesStyle);
     if(ext == "APE")
-      return new APE::File(arg, readAudioProperties, audioPropertiesStyle);
+      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(arg, readAudioProperties, audioPropertiesStyle);
+      return new Mod::File(fileName, readAudioProperties, audioPropertiesStyle);
     if(ext == "S3M")
-      return new S3M::File(arg, readAudioProperties, audioPropertiesStyle);
+      return new S3M::File(fileName, readAudioProperties, audioPropertiesStyle);
     if(ext == "IT")
-      return new IT::File(arg, readAudioProperties, audioPropertiesStyle);
+      return new IT::File(fileName, readAudioProperties, audioPropertiesStyle);
     if(ext == "XM")
-      return new XM::File(arg, readAudioProperties, audioPropertiesStyle);
+      return new XM::File(fileName, readAudioProperties, audioPropertiesStyle);
 
     return 0;
   }
@@ -186,15 +267,18 @@ namespace
 class FileRef::FileRefPrivate : public RefCounter
 {
 public:
-  FileRefPrivate(File *f) :
+  FileRefPrivate() :
     RefCounter(),
-    file(f) {}
+    file(0),
+    stream(0) {}
 
   ~FileRefPrivate() {
     delete file;
+    delete stream;
   }
 
-  File *file;
+  File     *file;
+  IOStream *stream;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -202,24 +286,27 @@ public:
 ////////////////////////////////////////////////////////////////////////////////
 
 FileRef::FileRef() :
-  d(new FileRefPrivate(0))
+  d(new FileRefPrivate())
 {
 }
 
 FileRef::FileRef(FileName fileName, bool readAudioProperties,
                  AudioProperties::ReadStyle audioPropertiesStyle) :
-  d(new FileRefPrivate(createInternal(fileName, readAudioProperties, audioPropertiesStyle)))
+  d(new FileRefPrivate())
 {
+  parse(fileName, readAudioProperties, audioPropertiesStyle);
 }
 
 FileRef::FileRef(IOStream* stream, bool readAudioProperties, AudioProperties::ReadStyle audioPropertiesStyle) :
-  d(new FileRefPrivate(createInternal(stream, readAudioProperties, audioPropertiesStyle)))
+  d(new FileRefPrivate())
 {
+  parse(stream, readAudioProperties, audioPropertiesStyle);
 }
 
 FileRef::FileRef(File *file) :
-  d(new FileRefPrivate(file))
+  d(new FileRefPrivate())
 {
+  d->file = file;
 }
 
 FileRef::FileRef(const FileRef &ref) :
@@ -279,6 +366,7 @@ StringList FileRef::defaultFileExtensions()
   l.append("ogg");
   l.append("flac");
   l.append("oga");
+  l.append("opus");
   l.append("mp3");
   l.append("mpc");
   l.append("wv");
@@ -295,6 +383,8 @@ StringList FileRef::defaultFileExtensions()
   l.append("asf");
   l.append("aif");
   l.append("aiff");
+  l.append("afc");
+  l.append("aifc");
   l.append("wav");
   l.append("ape");
   l.append("mod");
@@ -341,3 +431,55 @@ File *FileRef::create(FileName fileName, bool readAudioProperties,
 {
   return createInternal(fileName, readAudioProperties, audioPropertiesStyle);
 }
+
+////////////////////////////////////////////////////////////////////////////////
+// private members
+////////////////////////////////////////////////////////////////////////////////
+
+void FileRef::parse(FileName fileName, bool readAudioProperties,
+                    AudioProperties::ReadStyle audioPropertiesStyle)
+{
+  // Try user-defined resolvers.
+
+  d->file = detectByResolvers(fileName, readAudioProperties, audioPropertiesStyle);
+  if(d->file)
+    return;
+
+  // Try to resolve file types based on the file extension.
+
+  d->stream = new FileStream(fileName);
+  d->file = detectByExtension(d->stream, readAudioProperties, audioPropertiesStyle);
+  if(d->file)
+    return;
+
+  // At last, try to resolve file types based on the actual content.
+
+  d->file = detectByContent(d->stream, readAudioProperties, audioPropertiesStyle);
+  if(d->file)
+    return;
+
+  // Stream have to be closed here if failed to resolve file types.
+
+  delete d->stream;
+  d->stream = 0;
+}
+
+void FileRef::parse(IOStream *stream, bool readAudioProperties,
+                    AudioProperties::ReadStyle audioPropertiesStyle)
+{
+  // Try user-defined resolvers.
+
+  d->file = detectByResolvers(stream->name(), readAudioProperties, audioPropertiesStyle);
+  if(d->file)
+    return;
+
+  // Try to resolve file types based on the file extension.
+
+  d->file = detectByExtension(stream, readAudioProperties, audioPropertiesStyle);
+  if(d->file)
+    return;
+
+  // At last, try to resolve file types based on the actual content of the file.
+
+  d->file = detectByContent(stream, readAudioProperties, audioPropertiesStyle);
+}

taglib/fileref.h

@@ -274,8 +274,10 @@ namespace TagLib {
                         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

@@ -95,6 +95,18 @@ public:
   bool scanned;
 };
 
+////////////////////////////////////////////////////////////////////////////////
+// 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") >= 0);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // public members
 ////////////////////////////////////////////////////////////////////////////////
@@ -168,23 +180,31 @@ 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
 
-  for(BlockIterator it = d->blocks.begin(); it != d->blocks.end(); ++it) {
+  MetadataBlock *commentBlock =
+      new UnknownMetadataBlock(MetadataBlock::VorbisComment, d->xiphCommentData);
+  for(BlockIterator it = d->blocks.begin(); it != d->blocks.end();) {
     if((*it)->code() == MetadataBlock::VorbisComment) {
-      // Set the new Vorbis Comment block
+      // Remove the old Vorbis Comment block
       delete *it;
-      d->blocks.erase(it);
-      break;
+      it = d->blocks.erase(it);
+      continue;
     }
+    if(commentBlock && (*it)->code() == MetadataBlock::Picture) {
+      // Set the new Vorbis Comment block before the first picture block
+      d->blocks.insert(it, commentBlock);
+      commentBlock = 0;
+    }
+    ++it;
   }
-
-  d->blocks.append(new UnknownMetadataBlock(MetadataBlock::VorbisComment, d->xiphCommentData));
+  if(commentBlock)
+    d->blocks.append(commentBlock);
 
   // Render data for the metadata blocks
 
@@ -198,7 +218,6 @@ bool FLAC::File::save()
   }
 
   // Compute the amount of padding, and append that to data.
-  // TODO: Should be calculated in offset_t in taglib2.
 
   long originalLength = d->streamStart - d->flacStart;
   long paddingLength = originalLength - data.size() - 4;
@@ -298,11 +317,7 @@ bool FLAC::File::save()
 
 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)
@@ -507,7 +522,9 @@ void FLAC::File::scan()
       return;
     }
 
-    if(blockLength == 0 && blockType != MetadataBlock::Padding) {
+    if(blockLength == 0
+      && blockType != MetadataBlock::Padding && blockType != MetadataBlock::SeekTable)
+    {
       debug("FLAC::File::scan() -- Zero-sized metadata block found");
       setValid(false);
       return;

taglib/flac/flacfile.h

@@ -240,7 +240,7 @@ namespace TagLib {
        * \see ID3v2FrameFactory
        * \deprecated This value should be passed in via the constructor
        */
-      void setID3v2FrameFactory(const ID3v2::FrameFactory *factory);
+      TAGLIB_DEPRECATED void setID3v2FrameFactory(const ID3v2::FrameFactory *factory);
 
       /*!
        * Returns the block of data used by FLAC::Properties for parsing the
@@ -248,7 +248,7 @@ namespace TagLib {
        *
        * \deprecated Always returns an empty vector.
        */
-      ByteVector streamInfoData(); // BIC: remove
+      TAGLIB_DEPRECATED ByteVector streamInfoData(); // BIC: remove
 
       /*!
        * Returns the length of the audio-stream, used by FLAC::Properties for
@@ -256,7 +256,7 @@ namespace TagLib {
        *
        * \deprecated Always returns zero.
        */
-      long streamLength();  // BIC: remove
+      TAGLIB_DEPRECATED long streamLength();  // BIC: remove
 
       /*!
        * Returns a list of pictures attached to the FLAC file.
@@ -318,6 +318,15 @@ namespace TagLib {
        */
       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 &);

taglib/flac/flacpicture.cpp

@@ -50,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);
 }
 

taglib/flac/flacproperties.h

@@ -72,7 +72,7 @@ namespace TagLib {
        *
        * \deprecated
        */
-      virtual int length() const;
+      TAGLIB_DEPRECATED virtual int length() const;
 
       /*!
        * Returns the length of the file in seconds.  The length is rounded down to
@@ -120,7 +120,7 @@ namespace TagLib {
        *
        * \deprecated
        */
-      int sampleWidth() const;
+      TAGLIB_DEPRECATED int sampleWidth() const;
 
       /*!
        * Return the number of sample frames.

taglib/flac/flacunknownmetadatablock.cpp

@@ -39,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

@@ -277,7 +277,7 @@ void IT::File::read(bool)
   //       in the instrument/sample names and more characters
   //       afterwards. The spec does not mention such a case.
   //       Currently I just discard anything after a nil, but
-  //       e.g. VLC seems to interprete a nil as a space. I
+  //       e.g. VLC seems to interpret a nil as a space. I
   //       don't know what is the proper behaviour.
   for(unsigned short i = 0; i < instrumentCount; ++ i) {
     seek(192L + length + ((long)i << 2));

taglib/it/itproperties.cpp

@@ -70,7 +70,7 @@ public:
 
 IT::Properties::Properties(AudioProperties::ReadStyle propertiesStyle) :
   AudioProperties(propertiesStyle),
-  d(new PropertiesPrivate)
+  d(new PropertiesPrivate())
 {
 }
 

taglib/mod/modproperties.cpp

@@ -46,7 +46,7 @@ public:
 
 Mod::Properties::Properties(AudioProperties::ReadStyle propertiesStyle) :
   AudioProperties(propertiesStyle),
-  d(new PropertiesPrivate)
+  d(new PropertiesPrivate())
 {
 }
 

taglib/mod/modtag.cpp

@@ -43,9 +43,10 @@ public:
   String trackerName;
 };
 
-Mod::Tag::Tag() : TagLib::Tag()
+Mod::Tag::Tag() :
+  TagLib::Tag(),
+  d(new TagPrivate())
 {
-  d = new TagPrivate;
 }
 
 Mod::Tag::~Tag()

taglib/mp4/mp4atom.cpp

@@ -54,24 +54,25 @@ MP4::Atom::Atom(File *file)
 
   length = header.toUInt();
 
-  if(length == 1) {
+  if(length == 0) {
+    // The last atom which extends to the end of the file.
+    length = file->length() - offset;
+  }
+  else if(length == 1) {
+    // The atom has a 64-bit length.
     const long long longLength = file->readBlock(8).toLongLong();
-    if(sizeof(long) == sizeof(long long)) {
+    if(longLength <= LONG_MAX) {
+      // The actual length fits in long. That's always the case if long is 64-bit.
       length = static_cast<long>(longLength);
     }
     else {
-      if(longLength <= LONG_MAX) {
-        // The atom has a 64-bit length, but it's actually a 31-bit value
-        length = static_cast<long>(longLength);
-      }
-      else {
-        debug("MP4: 64-bit atoms are not supported");
-        length = 0;
-        file->seek(0, File::End);
-        return;
-      }
+      debug("MP4: 64-bit atoms are not supported");
+      length = 0;
+      file->seek(0, File::End);
+      return;
     }
   }
+
   if(length < 8) {
     debug("MP4: Invalid atom size");
     length = 0;

taglib/mp4/mp4file.cpp

@@ -26,6 +26,8 @@
 #include <tdebug.h>
 #include <tstring.h>
 #include <tpropertymap.h>
+#include <tagutils.h>
+
 #include "mp4atom.h"
 #include "mp4tag.h"
 #include "mp4file.h"
@@ -69,6 +71,22 @@ public:
   MP4::Properties *properties;
 };
 
+////////////////////////////////////////////////////////////////////////////////
+// static members
+////////////////////////////////////////////////////////////////////////////////
+
+bool MP4::File::isSupported(IOStream *stream)
+{
+  // An MP4 file has to have an "ftyp" box first.
+
+  const ByteVector id = Utils::readHeader(stream, 8, false);
+  return id.containsAt("ftyp", 4);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// public members
+////////////////////////////////////////////////////////////////////////////////
+
 MP4::File::File(FileName file, bool readProperties, AudioProperties::ReadStyle) :
   TagLib::File(file),
   d(new FilePrivate())

taglib/mp4/mp4file.h

@@ -120,6 +120,15 @@ namespace TagLib {
        */
       bool hasMP4Tag() const;
 
+      /*!
+       * 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:
       void read(bool readProperties);
 

taglib/mp4/mp4properties.cpp

@@ -31,6 +31,27 @@
 
 using namespace TagLib;
 
+namespace
+{
+  // Calculate the total bytes used by audio data, used to calculate the bitrate
+  long long calculateMdatLength(const MP4::AtomList &list)
+  {
+    long long totalLength = 0;
+    for(MP4::AtomList::ConstIterator it = list.begin(); it != list.end(); ++it) {
+      long length = (*it)->length;
+      if(length == 0)
+        return 0; // for safety, see checkValid() in mp4file.cpp
+
+      if((*it)->name == "mdat")
+        totalLength += length;
+
+      totalLength += calculateMdatLength((*it)->children);
+    }
+
+    return totalLength;
+  }
+}
+
 class MP4::Properties::PropertiesPrivate
 {
 public:
@@ -175,11 +196,11 @@ MP4::Properties::read(File *file, Atoms *atoms)
       debug("MP4: Atom 'trak.mdia.mdhd' is smaller than expected");
       return;
     }
-    unit   = data.toLongLong(28U);
-    length = data.toLongLong(36U);
+    unit   = data.toUInt(28U);
+    length = data.toLongLong(32U);
   }
   else {
-    if(data.size() < 24 + 4) {
+    if(data.size() < 24 + 8) {
       debug("MP4: Atom 'trak.mdia.mdhd' is smaller than expected");
       return;
     }
@@ -213,7 +234,14 @@ MP4::Properties::read(File *file, Atoms *atoms)
           pos += 3;
         }
         pos += 10;
-        d->bitrate = static_cast<int>((data.toUInt(pos) + 500) / 1000.0 + 0.5);
+        const unsigned int bitrateValue = data.toUInt(pos);
+        if(bitrateValue != 0 || d->length <= 0) {
+          d->bitrate = static_cast<int>((bitrateValue + 500) / 1000.0 + 0.5);
+        }
+        else {
+          d->bitrate = static_cast<int>(
+                (calculateMdatLength(atoms->atoms) * 8) / d->length);
+        }
       }
     }
   }
@@ -224,6 +252,13 @@ MP4::Properties::read(File *file, Atoms *atoms)
       d->channels      = data.at(73);
       d->bitrate       = static_cast<int>(data.toUInt(80U) / 1000.0 + 0.5);
       d->sampleRate    = data.toUInt(84U);
+
+      if(d->bitrate == 0 && d->length > 0) {
+        // There are files which do not contain a nominal bitrate, e.g. those
+        // generated by refalac64.exe. Calculate the bitrate from the audio
+        // data size (mdat atoms) and the duration.
+        d->bitrate = (calculateMdatLength(atoms->atoms) * 8) / d->length;
+      }
     }
   }
 

taglib/mp4/mp4properties.h

@@ -57,7 +57,7 @@ namespace TagLib {
        *
        * \deprecated
        */
-      virtual int length() const;
+      TAGLIB_DEPRECATED virtual int length() const;
 
       /*!
        * Returns the length of the file in seconds.  The length is rounded down to

taglib/mp4/mp4tag.cpp

@@ -71,14 +71,26 @@ MP4::Tag::Tag(TagLib::File *file, MP4::Atoms *atoms) :
       parseIntPair(atom);
     }
     else if(atom->name == "cpil" || atom->name == "pgap" || atom->name == "pcst" ||
-            atom->name == "hdvd") {
+            atom->name == "hdvd" || atom->name == "shwm") {
       parseBool(atom);
     }
-    else if(atom->name == "tmpo") {
+    else if(atom->name == "tmpo" || atom->name == "\251mvi" || atom->name == "\251mvc") {
       parseInt(atom);
     }
+    else if(atom->name == "rate") {
+      AtomDataList data = parseData2(atom);
+      if(!data.isEmpty()) {
+        AtomData val = data[0];
+        if (val.type == TypeUTF8) {
+          addItem(atom->name, StringList(String(val.data, String::UTF8)));
+        } else {
+          addItem(atom->name, (int)(val.data.toShort()));
+        }
+      }
+    }
     else if(atom->name == "tvsn" || atom->name == "tves" || atom->name == "cnID" ||
-            atom->name == "sfID" || atom->name == "atID" || atom->name == "geID") {
+            atom->name == "sfID" || atom->name == "atID" || atom->name == "geID" ||
+            atom->name == "cmID") {
       parseUInt(atom);
     }
     else if(atom->name == "plID") {
@@ -93,6 +105,9 @@ MP4::Tag::Tag(TagLib::File *file, MP4::Atoms *atoms) :
     else if(atom->name == "covr") {
       parseCovr(atom);
     }
+    else if(atom->name == "purl" || atom->name == "egid") {
+      parseText(atom, -1);
+    }
     else {
       parseText(atom);
     }
@@ -290,7 +305,7 @@ MP4::Tag::parseCovr(const MP4::Atom *atom)
     const int length = static_cast<int>(data.toUInt(pos));
     if(length < 12) {
       debug("MP4: Too short atom");
-      break;;
+      break;
     }
 
     const ByteVector name = data.mid(pos + 4, 4);
@@ -472,14 +487,26 @@ MP4::Tag::save()
     else if(name == "disk") {
       data.append(renderIntPairNoTrailing(name.data(String::Latin1), it->second));
     }
-    else if(name == "cpil" || name == "pgap" || name == "pcst" || name == "hdvd") {
+    else if(name == "cpil" || name == "pgap" || name == "pcst" || name == "hdvd" ||
+            name == "shwm") {
       data.append(renderBool(name.data(String::Latin1), it->second));
     }
-    else if(name == "tmpo") {
+    else if(name == "tmpo" || name == "\251mvi" || name == "\251mvc") {
       data.append(renderInt(name.data(String::Latin1), it->second));
     }
+    else if (name == "rate") {
+      const MP4::Item& item = it->second;
+      StringList value = item.toStringList();
+      if (value.isEmpty()) {
+        data.append(renderInt(name.data(String::Latin1), item));
+      }
+      else {
+        data.append(renderText(name.data(String::Latin1), item));
+      }
+    }
     else if(name == "tvsn" || name == "tves" || name == "cnID" ||
-            name == "sfID" || name == "atID" || name == "geID") {
+            name == "sfID" || name == "atID" || name == "geID" ||
+            name == "cmID") {
       data.append(renderUInt(name.data(String::Latin1), it->second));
     }
     else if(name == "plID") {
@@ -491,6 +518,9 @@ MP4::Tag::save()
     else if(name == "covr") {
       data.append(renderCovr(name.data(String::Latin1), it->second));
     }
+    else if(name == "purl" || name == "egid") {
+      data.append(renderText(name.data(String::Latin1), it->second, TypeImplicit));
+    }
     else if(name.size() == 4){
       data.append(renderText(name.data(String::Latin1), it->second));
     }
@@ -745,43 +775,63 @@ MP4::Tag::track() const
 void
 MP4::Tag::setTitle(const String &value)
 {
-  d->items["\251nam"] = StringList(value);
+  setTextItem("\251nam", value);
 }
 
 void
 MP4::Tag::setArtist(const String &value)
 {
-  d->items["\251ART"] = StringList(value);
+  setTextItem("\251ART", value);
 }
 
 void
 MP4::Tag::setAlbum(const String &value)
 {
-  d->items["\251alb"] = StringList(value);
+  setTextItem("\251alb", value);
 }
 
 void
 MP4::Tag::setComment(const String &value)
 {
-  d->items["\251cmt"] = StringList(value);
+  setTextItem("\251cmt", value);
 }
 
 void
 MP4::Tag::setGenre(const String &value)
 {
-  d->items["\251gen"] = StringList(value);
+  setTextItem("\251gen", value);
+}
+
+void
+MP4::Tag::setTextItem(const String &key, const String &value)
+{
+  if (!value.isEmpty()) {
+    d->items[key] = StringList(value);
+  } else {
+    d->items.erase(key);
+  }
 }
 
 void
 MP4::Tag::setYear(unsigned int value)
 {
-  d->items["\251day"] = StringList(String::number(value));
+  if (value == 0) {
+    d->items.erase("\251day");
+  }
+  else {
+    d->items["\251day"] = StringList(String::number(value));
+  }
 }
 
 void
 MP4::Tag::setTrack(unsigned int value)
 {
-  d->items["trkn"] = MP4::Item(value, 0);
+  if (value == 0) {
+    d->items.erase("trkn");
+  }
+  else {
+    d->items["trkn"] = MP4::Item(value, 0);
+  }
 }
 
 bool MP4::Tag::isEmpty() const
@@ -844,12 +894,34 @@ namespace
     { "sonm", "TITLESORT" },
     { "soco", "COMPOSERSORT" },
     { "sosn", "SHOWSORT" },
+    { "shwm", "SHOWWORKMOVEMENT" },
+    { "pgap", "GAPLESSPLAYBACK" },
+    { "pcst", "PODCAST" },
+    { "catg", "PODCASTCATEGORY" },
+    { "desc", "PODCASTDESC" },
+    { "egid", "PODCASTID" },
+    { "purl", "PODCASTURL" },
+    { "tves", "TVEPISODE" },
+    { "tven", "TVEPISODEID" },
+    { "tvnn", "TVNETWORK" },
+    { "tvsn", "TVSEASON" },
+    { "tvsh", "TVSHOW" },
+    { "\251wrk", "WORK" },
+    { "\251mvn", "MOVEMENTNAME" },
+    { "\251mvi", "MOVEMENTNUMBER" },
+    { "\251mvc", "MOVEMENTCOUNT" },
     { "----:com.apple.iTunes:MusicBrainz Track Id", "MUSICBRAINZ_TRACKID" },
     { "----:com.apple.iTunes:MusicBrainz Artist Id", "MUSICBRAINZ_ARTISTID" },
     { "----:com.apple.iTunes:MusicBrainz Album Id", "MUSICBRAINZ_ALBUMID" },
     { "----:com.apple.iTunes:MusicBrainz Album Artist Id", "MUSICBRAINZ_ALBUMARTISTID" },
     { "----:com.apple.iTunes:MusicBrainz Release Group Id", "MUSICBRAINZ_RELEASEGROUPID" },
+    { "----:com.apple.iTunes:MusicBrainz Release Track Id", "MUSICBRAINZ_RELEASETRACKID" },
     { "----:com.apple.iTunes:MusicBrainz Work Id", "MUSICBRAINZ_WORKID" },
+    { "----:com.apple.iTunes:MusicBrainz Album Release Country", "RELEASECOUNTRY" },
+    { "----:com.apple.iTunes:MusicBrainz Album Status", "RELEASESTATUS" },
+    { "----:com.apple.iTunes:MusicBrainz Album Type", "RELEASETYPE" },
+    { "----:com.apple.iTunes:ARTISTS", "ARTISTS" },
+    { "----:com.apple.iTunes:originaldate", "ORIGINALDATE" },
     { "----:com.apple.iTunes:ASIN", "ASIN" },
     { "----:com.apple.iTunes:LABEL", "LABEL" },
     { "----:com.apple.iTunes:LYRICIST", "LYRICIST" },
@@ -897,10 +969,12 @@ PropertyMap MP4::Tag::properties() const
         }
         props[key] = value;
       }
-      else if(key == "BPM") {
+      else if(key == "BPM" || key == "MOVEMENTNUMBER" || key == "MOVEMENTCOUNT" ||
+              key == "TVEPISODE" || key == "TVSEASON") {
         props[key] = String::number(it->second.toInt());
       }
-      else if(key == "COMPILATION") {
+      else if(key == "COMPILATION" || key == "SHOWWORKMOVEMENT" ||
+              key == "GAPLESSPLAYBACK" || key == "PODCAST") {
         props[key] = String::number(it->second.toBool());
       }
       else {
@@ -942,21 +1016,25 @@ PropertyMap MP4::Tag::setProperties(const PropertyMap &props)
     if(reverseKeyMap.contains(it->first)) {
       String name = reverseKeyMap[it->first];
       if((it->first == "TRACKNUMBER" || it->first == "DISCNUMBER") && !it->second.isEmpty()) {
-        int first = 0, second = 0;
         StringList parts = StringList::split(it->second.front(), "/");
         if(!parts.isEmpty()) {
-          first = parts[0].toInt();
+          int first = parts[0].toInt();
+          int second = 0;
           if(parts.size() > 1) {
             second = parts[1].toInt();
           }
           d->items[name] = MP4::Item(first, second);
         }
       }
-      else if(it->first == "BPM" && !it->second.isEmpty()) {
+      else if((it->first == "BPM" || it->first == "MOVEMENTNUMBER" ||
+               it->first == "MOVEMENTCOUNT" || it->first == "TVEPISODE" ||
+               it->first == "TVSEASON") && !it->second.isEmpty()) {
         int value = it->second.front().toInt();
         d->items[name] = MP4::Item(value);
       }
-      else if(it->first == "COMPILATION" && !it->second.isEmpty()) {
+      else if((it->first == "COMPILATION" || it->first == "SHOWWORKMOVEMENT" ||
+               it->first == "GAPLESSPLAYBACK" || it->first == "PODCAST") &&
+              !it->second.isEmpty()) {
         bool value = (it->second.front().toInt() != 0);
         d->items[name] = MP4::Item(value);
       }

taglib/mp4/mp4tag.h

@@ -42,7 +42,7 @@ namespace TagLib {
     /*!
      * \deprecated
      */
-    typedef TagLib::Map<String, Item> ItemListMap;
+    TAGLIB_DEPRECATED typedef TagLib::Map<String, Item> ItemListMap;
     typedef TagLib::Map<String, Item> ItemMap;
 
     class TAGLIB_EXPORT Tag: public TagLib::Tag
@@ -74,7 +74,7 @@ namespace TagLib {
         /*!
          * \deprecated Use the item() and setItem() API instead
          */
-        ItemMap &itemListMap();
+        TAGLIB_DEPRECATED ItemMap &itemListMap();
 
         /*!
          * Returns a string-keyed map of the MP4::Items for this tag.
@@ -106,6 +106,13 @@ namespace TagLib {
         void removeUnsupportedProperties(const StringList& properties);
         PropertyMap setProperties(const PropertyMap &properties);
 
+    protected:
+        /*!
+         * Sets the value of \a key to \a value, overwriting any previous value.
+         * If \a value is empty, the item is removed.
+         */
+        void setTextItem(const String &key, const String &value);
+
     private:
         AtomDataList parseData2(const Atom *atom, int expectedFlags = -1,
                                 bool freeForm = false);

taglib/mpc/mpcfile.cpp

@@ -75,6 +75,19 @@ public:
   Properties *properties;
 };
 
+////////////////////////////////////////////////////////////////////////////////
+// static members
+////////////////////////////////////////////////////////////////////////////////
+
+bool MPC::File::isSupported(IOStream *stream)
+{
+  // A newer MPC file has to start with "MPCK" or "MP+", but older files don't
+  // have keys to do a quick check.
+
+  const ByteVector id = Utils::readHeader(stream, 4, false);
+  return (id == "MPCK" || id.startsWith("MP+"));
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // public members
 ////////////////////////////////////////////////////////////////////////////////

taglib/mpc/mpcfile.h

@@ -198,7 +198,7 @@ namespace TagLib {
        * \deprecated
        * \see strip
        */
-      void remove(int tags = AllTags);
+      TAGLIB_DEPRECATED void remove(int tags = AllTags);
 
       /*!
        * Returns whether or not the file on disk actually has an ID3v1 tag.
@@ -214,6 +214,15 @@ namespace TagLib {
        */
       bool hasAPETag() const;
 
+      /*!
+       * Returns whether or not the given \a stream can be opened as an MPC
+       * 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 &);

taglib/mpc/mpcproperties.cpp

@@ -49,18 +49,17 @@ public:
     albumGain(0),
     albumPeak(0) {}
 
-  int          version;
-  int          length;
-  int          bitrate;
-  int          sampleRate;
-  int          channels;
+  int version;
+  int length;
+  int bitrate;
+  int sampleRate;
+  int channels;
   unsigned int totalFrames;
   unsigned int sampleFrames;
-  unsigned int trackGain;
-  unsigned int trackPeak;
-  unsigned int albumGain;
-  unsigned int albumPeak;
-  String       flags;
+  int trackGain;
+  int trackPeak;
+  int albumGain;
+  int albumPeak;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -312,9 +311,9 @@ void MPC::Properties::readSV7(const ByteVector &data, long streamLength)
     const unsigned int gapless = data.toUInt(5, false);
 
     d->trackGain = data.toShort(14, false);
-    d->trackPeak = data.toShort(12, false);
+    d->trackPeak = data.toUShort(12, false);
     d->albumGain = data.toShort(18, false);
-    d->albumPeak = data.toShort(16, false);
+    d->albumPeak = data.toUShort(16, false);
 
     // convert gain info
     if(d->trackGain != 0) {

taglib/mpc/mpcproperties.h

@@ -74,7 +74,7 @@ namespace TagLib {
        *
        * \deprecated
        */
-      virtual int length() const;
+      TAGLIB_DEPRECATED virtual int length() const;
 
       /*!
        * Returns the length of the file in seconds.  The length is rounded down to

taglib/mpeg/id3v1/id3v1genres.cpp

@@ -59,7 +59,7 @@ namespace
     L"Ambient",
     L"Trip-Hop",
     L"Vocal",
-    L"Jazz+Funk",
+    L"Jazz-Funk",
     L"Fusion",
     L"Trance",
     L"Classical",
@@ -111,16 +111,16 @@ namespace
     L"Rock & Roll",
     L"Hard Rock",
     L"Folk",
-    L"Folk/Rock",
+    L"Folk Rock",
     L"National Folk",
     L"Swing",
-    L"Fusion",
-    L"Bebob",
+    L"Fast Fusion",
+    L"Bebop",
     L"Latin",
     L"Revival",
     L"Celtic",
     L"Bluegrass",
-    L"Avantgarde",
+    L"Avant-garde",
     L"Gothic Rock",
     L"Progressive Rock",
     L"Psychedelic Rock",
@@ -155,15 +155,15 @@ namespace
     L"Drum Solo",
     L"A Cappella",
     L"Euro-House",
-    L"Dance Hall",
+    L"Dancehall",
     L"Goa",
     L"Drum & Bass",
     L"Club-House",
-    L"Hardcore",
+    L"Hardcore Techno",
     L"Terror",
     L"Indie",
-    L"BritPop",
-    L"Negerpunk",
+    L"Britpop",
+    L"Worldbeat",
     L"Polsk Punk",
     L"Beat",
     L"Christian Gangsta Rap",
@@ -261,5 +261,26 @@ int ID3v1::genreIndex(const String &name)
       return i;
   }
 
+  // If the name was not found, try the names which have been changed
+  static const struct {
+    const wchar_t *genre;
+    int code;
+  } fixUpGenres[] = {
+    { L"Jazz+Funk", 29 },
+    { L"Folk/Rock", 81 },
+    { L"Bebob", 85 },
+    { L"Avantgarde", 90 },
+    { L"Dance Hall", 125 },
+    { L"Hardcore", 129 },
+    { L"BritPop", 132 },
+    { L"Negerpunk", 133 }
+  };
+  static const int fixUpGenresSize =
+      sizeof(fixUpGenres) / sizeof(fixUpGenres[0]);
+  for(int i = 0; i < fixUpGenresSize; ++i) {
+    if(name == fixUpGenres[i].genre)
+      return fixUpGenres[i].code;
+  }
+
   return 255;
 }

taglib/mpeg/id3v2/frames/attachedpictureframe.cpp

@@ -48,14 +48,16 @@ public:
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-AttachedPictureFrame::AttachedPictureFrame() : Frame("APIC")
+AttachedPictureFrame::AttachedPictureFrame() :
+  Frame("APIC"),
+  d(new AttachedPictureFramePrivate())
 {
-  d = new AttachedPictureFramePrivate;
 }
 
-AttachedPictureFrame::AttachedPictureFrame(const ByteVector &data) : Frame(data)
+AttachedPictureFrame::AttachedPictureFrame(const ByteVector &data) :
+  Frame(data),
+  d(new AttachedPictureFramePrivate())
 {
-  d = new AttachedPictureFramePrivate;
   setData(data);
 }
 
@@ -169,9 +171,10 @@ ByteVector AttachedPictureFrame::renderFields() const
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
-AttachedPictureFrame::AttachedPictureFrame(const ByteVector &data, Header *h) : Frame(h)
+AttachedPictureFrame::AttachedPictureFrame(const ByteVector &data, Header *h) :
+  Frame(h),
+  d(new AttachedPictureFramePrivate())
 {
-  d = new AttachedPictureFramePrivate;
   parseFields(fieldData(data));
 }
 

taglib/mpeg/id3v2/frames/chapterframe.cpp

@@ -37,7 +37,11 @@ class ChapterFrame::ChapterFramePrivate
 {
 public:
   ChapterFramePrivate() :
-    tagHeader(0)
+    tagHeader(0),
+    startTime(0),
+    endTime(0),
+    startOffset(0),
+    endOffset(0)
   {
     embeddedFrameList.setAutoDelete(true);
   }
@@ -57,9 +61,9 @@ public:
 ////////////////////////////////////////////////////////////////////////////////
 
 ChapterFrame::ChapterFrame(const ID3v2::Header *tagHeader, const ByteVector &data) :
-    ID3v2::Frame(data)
+  ID3v2::Frame(data),
+  d(new ChapterFramePrivate())
 {
-  d = new ChapterFramePrivate;
   d->tagHeader = tagHeader;
   setData(data);
 }
@@ -68,10 +72,9 @@ ChapterFrame::ChapterFrame(const ByteVector &elementID,
                            unsigned int startTime, unsigned int endTime,
                            unsigned int startOffset, unsigned int endOffset,
                            const FrameList &embeddedFrames) :
-    ID3v2::Frame("CHAP")
+  ID3v2::Frame("CHAP"),
+  d(new ChapterFramePrivate())
 {
-  d = new ChapterFramePrivate;
-
   // setElementID has a workaround for a previously silly API where you had to
   // specifically include the null byte.
 
@@ -264,7 +267,7 @@ void ChapterFrame::parseFields(const ByteVector &data)
     return;
 
   while(embPos < size - header()->size()) {
-    Frame *frame = FrameFactory::instance()->createFrame(data.mid(pos + embPos), (d->tagHeader != 0));
+    Frame *frame = FrameFactory::instance()->createFrame(data.mid(pos + embPos), d->tagHeader);
 
     if(!frame)
       return;
@@ -298,9 +301,9 @@ ByteVector ChapterFrame::renderFields() const
 }
 
 ChapterFrame::ChapterFrame(const ID3v2::Header *tagHeader, const ByteVector &data, Header *h) :
-  Frame(h)
+  Frame(h),
+  d(new ChapterFramePrivate())
 {
-  d = new ChapterFramePrivate;
   d->tagHeader = tagHeader;
   parseFields(fieldData(data));
 }

taglib/mpeg/id3v2/frames/chapterframe.h

@@ -57,7 +57,7 @@ namespace TagLib {
        * \a startTime, end time \a endTime, start offset \a startOffset,
        * end offset \a endOffset and optionally a list of embedded frames,
        * whose ownership will then be taken over by this Frame, in
-       * \a embeededFrames;
+       * \a embeddedFrames;
        *
        * All times are in milliseconds.
        */

taglib/mpeg/id3v2/frames/commentsframe.cpp

@@ -48,15 +48,17 @@ public:
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-CommentsFrame::CommentsFrame(String::Type encoding) : Frame("COMM")
+CommentsFrame::CommentsFrame(String::Type encoding) :
+  Frame("COMM"),
+  d(new CommentsFramePrivate())
 {
-  d = new CommentsFramePrivate;
   d->textEncoding = encoding;
 }
 
-CommentsFrame::CommentsFrame(const ByteVector &data) : Frame(data)
+CommentsFrame::CommentsFrame(const ByteVector &data) :
+  Frame(data),
+  d(new CommentsFramePrivate())
 {
-  d = new CommentsFramePrivate;
   setData(data);
 }
 
@@ -188,8 +190,9 @@ ByteVector CommentsFrame::renderFields() const
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
-CommentsFrame::CommentsFrame(const ByteVector &data, Header *h) : Frame(h)
+CommentsFrame::CommentsFrame(const ByteVector &data, Header *h) :
+  Frame(h),
+  d(new CommentsFramePrivate())
 {
-  d = new CommentsFramePrivate();
   parseFields(fieldData(data));
 }

taglib/mpeg/id3v2/frames/eventtimingcodesframe.cpp

@@ -46,15 +46,15 @@ public:
 ////////////////////////////////////////////////////////////////////////////////
 
 EventTimingCodesFrame::EventTimingCodesFrame() :
-  Frame("ETCO")
+  Frame("ETCO"),
+  d(new EventTimingCodesFramePrivate())
 {
-  d = new EventTimingCodesFramePrivate;
 }
 
 EventTimingCodesFrame::EventTimingCodesFrame(const ByteVector &data) :
-  Frame(data)
+  Frame(data),
+  d(new EventTimingCodesFramePrivate())
 {
-  d = new EventTimingCodesFramePrivate;
   setData(data);
 }
 
@@ -136,9 +136,9 @@ ByteVector EventTimingCodesFrame::renderFields() const
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
-EventTimingCodesFrame::EventTimingCodesFrame(const ByteVector &data, Header *h)
-  : Frame(h)
+EventTimingCodesFrame::EventTimingCodesFrame(const ByteVector &data, Header *h) :
+  Frame(h),
+  d(new EventTimingCodesFramePrivate())
 {
-  d = new EventTimingCodesFramePrivate();
   parseFields(fieldData(data));
 }

taglib/mpeg/id3v2/frames/generalencapsulatedobjectframe.cpp

@@ -50,14 +50,16 @@ public:
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-GeneralEncapsulatedObjectFrame::GeneralEncapsulatedObjectFrame() : Frame("GEOB")
+GeneralEncapsulatedObjectFrame::GeneralEncapsulatedObjectFrame() :
+  Frame("GEOB"),
+  d(new GeneralEncapsulatedObjectFramePrivate())
 {
-    d = new GeneralEncapsulatedObjectFramePrivate;
 }
 
-GeneralEncapsulatedObjectFrame::GeneralEncapsulatedObjectFrame(const ByteVector &data) : Frame(data)
+GeneralEncapsulatedObjectFrame::GeneralEncapsulatedObjectFrame(const ByteVector &data) :
+  Frame(data),
+  d(new GeneralEncapsulatedObjectFramePrivate())
 {
-  d = new GeneralEncapsulatedObjectFramePrivate;
   setData(data);
 }
 
@@ -177,8 +179,9 @@ ByteVector GeneralEncapsulatedObjectFrame::renderFields() const
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
-GeneralEncapsulatedObjectFrame::GeneralEncapsulatedObjectFrame(const ByteVector &data, Header *h) : Frame(h)
+GeneralEncapsulatedObjectFrame::GeneralEncapsulatedObjectFrame(const ByteVector &data, Header *h) :
+  Frame(h),
+  d(new GeneralEncapsulatedObjectFramePrivate())
 {
-  d = new GeneralEncapsulatedObjectFramePrivate;
   parseFields(fieldData(data));
 }

taglib/mpeg/id3v2/frames/ownershipframe.cpp

@@ -45,15 +45,17 @@ public:
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-OwnershipFrame::OwnershipFrame(String::Type encoding) : Frame("OWNE")
+OwnershipFrame::OwnershipFrame(String::Type encoding) :
+  Frame("OWNE"),
+  d(new OwnershipFramePrivate())
 {
-  d = new OwnershipFramePrivate;
   d->textEncoding = encoding;
 }
 
-OwnershipFrame::OwnershipFrame(const ByteVector &data) : Frame(data)
+OwnershipFrame::OwnershipFrame(const ByteVector &data) :
+  Frame(data),
+  d(new OwnershipFramePrivate())
 {
-  d = new OwnershipFramePrivate;
   setData(data);
 }
 
@@ -161,8 +163,9 @@ ByteVector OwnershipFrame::renderFields() const
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
-OwnershipFrame::OwnershipFrame(const ByteVector &data, Header *h) : Frame(h)
+OwnershipFrame::OwnershipFrame(const ByteVector &data, Header *h) :
+  Frame(h),
+  d(new OwnershipFramePrivate())
 {
-  d = new OwnershipFramePrivate;
   parseFields(fieldData(data));
 }

taglib/mpeg/id3v2/frames/podcastframe.cpp

@@ -24,6 +24,7 @@
  ***************************************************************************/
 
 #include "podcastframe.h"
+#include <tpropertymap.h>
 
 using namespace TagLib;
 using namespace ID3v2;
@@ -38,9 +39,10 @@ public:
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-PodcastFrame::PodcastFrame() : Frame("PCST")
+PodcastFrame::PodcastFrame() :
+  Frame("PCST"),
+  d(new PodcastFramePrivate())
 {
-  d = new PodcastFramePrivate;
   d->fieldData = ByteVector(4, '\0');
 }
 
@@ -54,6 +56,13 @@ String PodcastFrame::toString() const
   return String();
 }
 
+PropertyMap PodcastFrame::asProperties() const
+{
+  PropertyMap map;
+  map.insert("PODCAST", StringList());
+  return map;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // protected members
 ////////////////////////////////////////////////////////////////////////////////
@@ -72,8 +81,9 @@ ByteVector PodcastFrame::renderFields() const
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
-PodcastFrame::PodcastFrame(const ByteVector &data, Header *h) : Frame(h)
+PodcastFrame::PodcastFrame(const ByteVector &data, Header *h) :
+  Frame(h),
+  d(new PodcastFramePrivate())
 {
-  d = new PodcastFramePrivate;
   parseFields(fieldData(data));
 }

taglib/mpeg/id3v2/frames/podcastframe.h

@@ -57,6 +57,8 @@ namespace TagLib {
        */
       virtual String toString() const;
 
+      PropertyMap asProperties() const;
+
     protected:
       // Reimplementations.
 

taglib/mpeg/id3v2/frames/popularimeterframe.cpp

@@ -43,14 +43,16 @@ public:
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-PopularimeterFrame::PopularimeterFrame() : Frame("POPM")
+PopularimeterFrame::PopularimeterFrame() :
+  Frame("POPM"),
+  d(new PopularimeterFramePrivate())
 {
-  d = new PopularimeterFramePrivate;
 }
 
-PopularimeterFrame::PopularimeterFrame(const ByteVector &data) : Frame(data)
+PopularimeterFrame::PopularimeterFrame(const ByteVector &data) :
+  Frame(data),
+  d(new PopularimeterFramePrivate())
 {
-  d = new PopularimeterFramePrivate;
   setData(data);
 }
 
@@ -130,8 +132,9 @@ ByteVector PopularimeterFrame::renderFields() const
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
-PopularimeterFrame::PopularimeterFrame(const ByteVector &data, Header *h) : Frame(h)
+PopularimeterFrame::PopularimeterFrame(const ByteVector &data, Header *h) :
+  Frame(h),
+  d(new PopularimeterFramePrivate())
 {
-  d = new PopularimeterFramePrivate;
   parseFields(fieldData(data));
 }

taglib/mpeg/id3v2/frames/privateframe.cpp

@@ -45,15 +45,17 @@ public:
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-PrivateFrame::PrivateFrame() : Frame("PRIV")
+PrivateFrame::PrivateFrame() :
+  Frame("PRIV"),
+  d(new PrivateFramePrivate())
 {
-  d = new PrivateFramePrivate;
 }
 
-PrivateFrame::PrivateFrame(const ByteVector &data) : Frame(data)
+PrivateFrame::PrivateFrame(const ByteVector &data) :
+  Frame(data),
+  d(new PrivateFramePrivate())
 {
-  d = new PrivateFramePrivate;
-  setData(data);
+  Frame::setData(data);
 }
 
 PrivateFrame::~PrivateFrame()
@@ -121,8 +123,9 @@ ByteVector PrivateFrame::renderFields() const
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
-PrivateFrame::PrivateFrame(const ByteVector &data, Header *h) : Frame(h)
+PrivateFrame::PrivateFrame(const ByteVector &data, Header *h) :
+  Frame(h),
+  d(new PrivateFramePrivate())
 {
-  d = new PrivateFramePrivate();
   parseFields(fieldData(data));
 }

taglib/mpeg/id3v2/frames/relativevolumeframe.cpp

@@ -51,14 +51,16 @@ public:
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-RelativeVolumeFrame::RelativeVolumeFrame() : Frame("RVA2")
+RelativeVolumeFrame::RelativeVolumeFrame() :
+  Frame("RVA2"),
+  d(new RelativeVolumeFramePrivate())
 {
-  d = new RelativeVolumeFramePrivate;
 }
 
-RelativeVolumeFrame::RelativeVolumeFrame(const ByteVector &data) : Frame(data)
+RelativeVolumeFrame::RelativeVolumeFrame(const ByteVector &data) :
+  Frame(data),
+  d(new RelativeVolumeFramePrivate())
 {
-  d = new RelativeVolumeFramePrivate;
   setData(data);
 }
 
@@ -223,8 +225,9 @@ ByteVector RelativeVolumeFrame::renderFields() const
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
-RelativeVolumeFrame::RelativeVolumeFrame(const ByteVector &data, Header *h) : Frame(h)
+RelativeVolumeFrame::RelativeVolumeFrame(const ByteVector &data, Header *h) :
+  Frame(h),
+  d(new RelativeVolumeFramePrivate())
 {
-  d = new RelativeVolumeFramePrivate;
   parseFields(fieldData(data));
 }

taglib/mpeg/id3v2/frames/relativevolumeframe.h

@@ -131,12 +131,12 @@ namespace TagLib {
       /*!
        * \deprecated Always returns master volume.
        */
-      ChannelType channelType() const;
+      TAGLIB_DEPRECATED ChannelType channelType() const;
 
       /*!
        * \deprecated This method no longer has any effect.
        */
-      void setChannelType(ChannelType t);
+      TAGLIB_DEPRECATED void setChannelType(ChannelType t);
 
       /*
        * There was a terrible API goof here, and while this can't be changed to
@@ -155,7 +155,7 @@ namespace TagLib {
        * available and returns 0 if the specified channel does not exist.
        *
        * \see setVolumeAdjustmentIndex()
-       * \see volumeAjustment()
+       * \see volumeAdjustment()
        */
       short volumeAdjustmentIndex(ChannelType type = MasterVolume) const;
 
@@ -167,7 +167,7 @@ namespace TagLib {
        * By default this sets the value for the master volume.
        *
        * \see volumeAdjustmentIndex()
-       * \see setVolumeAjustment()
+       * \see setVolumeAdjustment()
        */
       void setVolumeAdjustmentIndex(short index, ChannelType type = MasterVolume);
 

taglib/mpeg/id3v2/frames/synchronizedlyricsframe.cpp

@@ -52,16 +52,16 @@ public:
 ////////////////////////////////////////////////////////////////////////////////
 
 SynchronizedLyricsFrame::SynchronizedLyricsFrame(String::Type encoding) :
-  Frame("SYLT")
+  Frame("SYLT"),
+  d(new SynchronizedLyricsFramePrivate())
 {
-  d = new SynchronizedLyricsFramePrivate;
   d->textEncoding = encoding;
 }
 
 SynchronizedLyricsFrame::SynchronizedLyricsFrame(const ByteVector &data) :
-  Frame(data)
+  Frame(data),
+  d(new SynchronizedLyricsFramePrivate())
 {
-  d = new SynchronizedLyricsFramePrivate;
   setData(data);
 }
 
@@ -189,7 +189,7 @@ void SynchronizedLyricsFrame::parseFields(const ByteVector &data)
       }
     }
     String text = readStringField(data, enc, &pos);
-    if(text.isEmpty() || pos + 4 > end)
+    if(pos + 4 > end)
       return;
 
     unsigned int time = data.toUInt(pos, true);
@@ -234,9 +234,9 @@ ByteVector SynchronizedLyricsFrame::renderFields() const
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
-SynchronizedLyricsFrame::SynchronizedLyricsFrame(const ByteVector &data, Header *h)
-  : Frame(h)
+SynchronizedLyricsFrame::SynchronizedLyricsFrame(const ByteVector &data, Header *h) :
+  Frame(h),
+  d(new SynchronizedLyricsFramePrivate())
 {
-  d = new SynchronizedLyricsFramePrivate();
   parseFields(fieldData(data));
 }

taglib/mpeg/id3v2/frames/tableofcontentsframe.cpp

@@ -36,7 +36,9 @@ class TableOfContentsFrame::TableOfContentsFramePrivate
 {
 public:
   TableOfContentsFramePrivate() :
-    tagHeader(0)
+    tagHeader(0),
+    isTopLevel(false),
+    isOrdered(false)
   {
     embeddedFrameList.setAutoDelete(true);
   }
@@ -53,7 +55,7 @@ public:
 namespace {
 
   // These functions are needed to try to aim for backward compatibility with
-  // an API that previously (unreasonably) required null bytes to be appeneded
+  // an API that previously (unreasonably) required null bytes to be appended
   // at the end of identifiers explicitly by the API user.
 
   // BIC: remove these
@@ -80,9 +82,9 @@ namespace {
 ////////////////////////////////////////////////////////////////////////////////
 
 TableOfContentsFrame::TableOfContentsFrame(const ID3v2::Header *tagHeader, const ByteVector &data) :
-    ID3v2::Frame(data)
+  ID3v2::Frame(data),
+  d(new TableOfContentsFramePrivate())
 {
-  d = new TableOfContentsFramePrivate;
   d->tagHeader = tagHeader;
   setData(data);
 }
@@ -90,9 +92,9 @@ TableOfContentsFrame::TableOfContentsFrame(const ID3v2::Header *tagHeader, const
 TableOfContentsFrame::TableOfContentsFrame(const ByteVector &elementID,
                                            const ByteVectorList &children,
                                            const FrameList &embeddedFrames) :
-    ID3v2::Frame("CTOC")
+  ID3v2::Frame("CTOC"),
+  d(new TableOfContentsFramePrivate())
 {
-  d = new TableOfContentsFramePrivate;
   d->elementID = elementID;
   strip(d->elementID);
   d->childElements = children;
@@ -166,7 +168,8 @@ void TableOfContentsFrame::removeChildElement(const ByteVector &cE)
   if(it == d->childElements.end())
     it = d->childElements.find(cE + ByteVector("\0"));
 
-  d->childElements.erase(it);
+  if(it != d->childElements.end())
+    d->childElements.erase(it);
 }
 
 const FrameListMap &TableOfContentsFrame::embeddedFrameListMap() const
@@ -194,11 +197,14 @@ void TableOfContentsFrame::removeEmbeddedFrame(Frame *frame, bool del)
 {
   // remove the frame from the frame list
   FrameList::Iterator it = d->embeddedFrameList.find(frame);
-  d->embeddedFrameList.erase(it);
+  if(it != d->embeddedFrameList.end())
+    d->embeddedFrameList.erase(it);
 
   // ...and from the frame list map
-  it = d->embeddedFrameListMap[frame->frameID()].find(frame);
-  d->embeddedFrameListMap[frame->frameID()].erase(it);
+  FrameList &mappedList = d->embeddedFrameListMap[frame->frameID()];
+  it = mappedList.find(frame);
+  if(it != mappedList.end())
+    mappedList.erase(it);
 
   // ...and delete as desired
   if(del)
@@ -214,7 +220,23 @@ void TableOfContentsFrame::removeEmbeddedFrames(const ByteVector &id)
 
 String TableOfContentsFrame::toString() const
 {
-  return String();
+  String s = String(d->elementID) +
+             ": top level: " + (d->isTopLevel ? "true" : "false") +
+             ", ordered: " + (d->isOrdered ? "true" : "false");
+
+  if(!d->childElements.isEmpty()) {
+    s+= ", chapters: [ " + String(d->childElements.toByteVector(", ")) + " ]";
+  }
+
+  if(!d->embeddedFrameList.isEmpty()) {
+    StringList frameIDs;
+    for(FrameList::ConstIterator it = d->embeddedFrameList.begin();
+        it != d->embeddedFrameList.end(); ++it)
+      frameIDs.append((*it)->frameID());
+    s += ", sub-frames: [ " + frameIDs.toString(", ") + " ]";
+  }
+
+  return s;
 }
 
 PropertyMap TableOfContentsFrame::asProperties() const
@@ -286,7 +308,7 @@ void TableOfContentsFrame::parseFields(const ByteVector &data)
     return;
 
   while(embPos < size - header()->size()) {
-    Frame *frame = FrameFactory::instance()->createFrame(data.mid(pos + embPos), (d->tagHeader != 0));
+    Frame *frame = FrameFactory::instance()->createFrame(data.mid(pos + embPos), d->tagHeader);
 
     if(!frame)
       return;
@@ -330,9 +352,9 @@ ByteVector TableOfContentsFrame::renderFields() const
 
 TableOfContentsFrame::TableOfContentsFrame(const ID3v2::Header *tagHeader,
                                            const ByteVector &data, Header *h) :
-  Frame(h)
+  Frame(h),
+  d(new TableOfContentsFramePrivate())
 {
-  d = new TableOfContentsFramePrivate;
   d->tagHeader = tagHeader;
   parseFields(fieldData(data));
 }

taglib/mpeg/id3v2/frames/tableofcontentsframe.h

@@ -29,6 +29,8 @@
 #include "id3v2tag.h"
 #include "id3v2frame.h"
 
+#include "tbytevectorlist.h"
+
 namespace TagLib {
 
   namespace ID3v2 {

taglib/mpeg/id3v2/frames/textidentificationframe.cpp

@@ -45,16 +45,16 @@ public:
 ////////////////////////////////////////////////////////////////////////////////
 
 TextIdentificationFrame::TextIdentificationFrame(const ByteVector &type, String::Type encoding) :
-  Frame(type)
+  Frame(type),
+  d(new TextIdentificationFramePrivate())
 {
-  d = new TextIdentificationFramePrivate;
   d->textEncoding = encoding;
 }
 
 TextIdentificationFrame::TextIdentificationFrame(const ByteVector &data) :
-  Frame(data)
+  Frame(data),
+  d(new TextIdentificationFramePrivate())
 {
-  d = new TextIdentificationFramePrivate;
   setData(data);
 }
 
@@ -63,7 +63,10 @@ TextIdentificationFrame *TextIdentificationFrame::createTIPLFrame(const Property
   TextIdentificationFrame *frame = new TextIdentificationFrame("TIPL");
   StringList l;
   for(PropertyMap::ConstIterator it = properties.begin(); it != properties.end(); ++it){
-    l.append(it->first);
+    const String role = involvedPeopleMap()[it->first];
+    if(role.isEmpty()) // should not happen
+      continue;
+    l.append(role);
     l.append(it->second.toString(",")); // comma-separated list of names
   }
   frame->setText(l);
@@ -252,9 +255,10 @@ ByteVector TextIdentificationFrame::renderFields() const
 // TextIdentificationFrame private members
 ////////////////////////////////////////////////////////////////////////////////
 
-TextIdentificationFrame::TextIdentificationFrame(const ByteVector &data, Header *h) : Frame(h)
+TextIdentificationFrame::TextIdentificationFrame(const ByteVector &data, Header *h) :
+  Frame(h),
+  d(new TextIdentificationFramePrivate())
 {
-  d = new TextIdentificationFramePrivate;
   parseFields(fieldData(data));
 }
 
@@ -276,7 +280,7 @@ PropertyMap TextIdentificationFrame::makeTIPLProperties() const
         break;
       }
     if(!found){
-      // invalid involved role -> mark whole frame as unsupported in order to be consisten with writing
+      // invalid involved role -> mark whole frame as unsupported in order to be consistent with writing
       map.clear();
       map.unsupportedData().append(frameID());
       return map;
@@ -338,7 +342,13 @@ UserTextIdentificationFrame::UserTextIdentificationFrame(const String &descripti
 
 String UserTextIdentificationFrame::toString() const
 {
-  return "[" + description() + "] " + fieldList().toString();
+  // first entry is the description itself, drop from values list
+  StringList l = fieldList();
+  for(StringList::Iterator it = l.begin(); it != l.end(); ++it) {
+    l.erase(it);
+    break;
+  }
+  return "[" + description() + "] " + l.toString();
 }
 
 String UserTextIdentificationFrame::description() const

taglib/mpeg/id3v2/frames/uniquefileidentifierframe.cpp

@@ -45,16 +45,16 @@ public:
 ////////////////////////////////////////////////////////////////////////////////
 
 UniqueFileIdentifierFrame::UniqueFileIdentifierFrame(const ByteVector &data) :
-    ID3v2::Frame(data)
+  ID3v2::Frame(data),
+  d(new UniqueFileIdentifierFramePrivate())
 {
-  d = new UniqueFileIdentifierFramePrivate;
   setData(data);
 }
 
 UniqueFileIdentifierFrame::UniqueFileIdentifierFrame(const String &owner, const ByteVector &id) :
-    ID3v2::Frame("UFID")
+  ID3v2::Frame("UFID"),
+  d(new UniqueFileIdentifierFramePrivate())
 {
-  d = new UniqueFileIdentifierFramePrivate;
   d->owner = owner;
   d->identifier = id;
 }
@@ -141,8 +141,8 @@ ByteVector UniqueFileIdentifierFrame::renderFields() const
 }
 
 UniqueFileIdentifierFrame::UniqueFileIdentifierFrame(const ByteVector &data, Header *h) :
-  Frame(h)
+  Frame(h),
+  d(new UniqueFileIdentifierFramePrivate())
 {
-  d = new UniqueFileIdentifierFramePrivate;
   parseFields(fieldData(data));
 }

taglib/mpeg/id3v2/frames/unknownframe.cpp

@@ -38,9 +38,10 @@ public:
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-UnknownFrame::UnknownFrame(const ByteVector &data) : Frame(data)
+UnknownFrame::UnknownFrame(const ByteVector &data) :
+  Frame(data),
+  d(new UnknownFramePrivate())
 {
-  d = new UnknownFramePrivate;
   setData(data);
 }
 
@@ -77,8 +78,9 @@ ByteVector UnknownFrame::renderFields() const
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
-UnknownFrame::UnknownFrame(const ByteVector &data, Header *h) : Frame(h)
+UnknownFrame::UnknownFrame(const ByteVector &data, Header *h) :
+  Frame(h),
+  d(new UnknownFramePrivate())
 {
-  d = new UnknownFramePrivate;
   parseFields(fieldData(data));
 }

taglib/mpeg/id3v2/frames/unsynchronizedlyricsframe.cpp

@@ -50,16 +50,16 @@ public:
 ////////////////////////////////////////////////////////////////////////////////
 
 UnsynchronizedLyricsFrame::UnsynchronizedLyricsFrame(String::Type encoding) :
-  Frame("USLT")
+  Frame("USLT"),
+  d(new UnsynchronizedLyricsFramePrivate())
 {
-  d = new UnsynchronizedLyricsFramePrivate;
   d->textEncoding = encoding;
 }
 
 UnsynchronizedLyricsFrame::UnsynchronizedLyricsFrame(const ByteVector &data) :
-  Frame(data)
+  Frame(data),
+  d(new UnsynchronizedLyricsFramePrivate())
 {
-  d = new UnsynchronizedLyricsFramePrivate;
   setData(data);
 }
 
@@ -118,7 +118,7 @@ PropertyMap UnsynchronizedLyricsFrame::asProperties() const
 {
   PropertyMap map;
   String key = description().upper();
-  if(key.isEmpty() || key.upper() == "LYRICS")
+  if(key.isEmpty() || key == "LYRICS")
     map.insert("LYRICS", text());
   else
     map.insert("LYRICS:" + key, text());
@@ -190,9 +190,9 @@ ByteVector UnsynchronizedLyricsFrame::renderFields() const
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
-UnsynchronizedLyricsFrame::UnsynchronizedLyricsFrame(const ByteVector &data, Header *h)
-  : Frame(h)
+UnsynchronizedLyricsFrame::UnsynchronizedLyricsFrame(const ByteVector &data, Header *h) :
+  Frame(h),
+  d(new UnsynchronizedLyricsFramePrivate())
 {
-  d = new UnsynchronizedLyricsFramePrivate();
   parseFields(fieldData(data));
 }

taglib/mpeg/id3v2/frames/urllinkframe.cpp

@@ -49,10 +49,14 @@ public:
   String description;
 };
 
+////////////////////////////////////////////////////////////////////////////////
+// UrlLinkFrame public members
+////////////////////////////////////////////////////////////////////////////////
+
 UrlLinkFrame::UrlLinkFrame(const ByteVector &data) :
-  Frame(data)
+  Frame(data),
+  d(new UrlLinkFramePrivate())
 {
-  d = new UrlLinkFramePrivate;
   setData(data);
 }
 
@@ -93,6 +97,10 @@ PropertyMap UrlLinkFrame::asProperties() const
   return map;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// UrlLinkFrame protected members
+////////////////////////////////////////////////////////////////////////////////
+
 void UrlLinkFrame::parseFields(const ByteVector &data)
 {
   d->url = String(data);
@@ -103,24 +111,28 @@ ByteVector UrlLinkFrame::renderFields() const
   return d->url.data(String::Latin1);
 }
 
-UrlLinkFrame::UrlLinkFrame(const ByteVector &data, Header *h) : Frame(h)
+UrlLinkFrame::UrlLinkFrame(const ByteVector &data, Header *h) :
+  Frame(h),
+  d(new UrlLinkFramePrivate())
 {
-  d = new UrlLinkFramePrivate;
   parseFields(fieldData(data));
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// UserUrlLinkFrame public members
+////////////////////////////////////////////////////////////////////////////////
 
 UserUrlLinkFrame::UserUrlLinkFrame(String::Type encoding) :
-  UrlLinkFrame("WXXX")
+  UrlLinkFrame("WXXX"),
+  d(new UserUrlLinkFramePrivate())
 {
-  d = new UserUrlLinkFramePrivate;
   d->textEncoding = encoding;
 }
 
 UserUrlLinkFrame::UserUrlLinkFrame(const ByteVector &data) :
-  UrlLinkFrame(data)
+  UrlLinkFrame(data),
+  d(new UserUrlLinkFramePrivate())
 {
-  d = new UserUrlLinkFramePrivate;
   setData(data);
 }
 
@@ -158,7 +170,7 @@ PropertyMap UserUrlLinkFrame::asProperties() const
 {
   PropertyMap map;
   String key = description().upper();
-  if(key.isEmpty() || key.upper() == "URL")
+  if(key.isEmpty() || key == "URL")
     map.insert("URL", url());
   else
     map.insert("URL:" + key, url());
@@ -176,6 +188,10 @@ UserUrlLinkFrame *UserUrlLinkFrame::find(ID3v2::Tag *tag, const String &descript
   return 0;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// UserUrlLinkFrame protected members
+////////////////////////////////////////////////////////////////////////////////
+
 void UserUrlLinkFrame::parseFields(const ByteVector &data)
 {
   if(data.size() < 2) {
@@ -222,8 +238,9 @@ ByteVector UserUrlLinkFrame::renderFields() const
   return v;
 }
 
-UserUrlLinkFrame::UserUrlLinkFrame(const ByteVector &data, Header *h) : UrlLinkFrame(data, h)
+UserUrlLinkFrame::UserUrlLinkFrame(const ByteVector &data, Header *h) :
+  UrlLinkFrame(data, h),
+  d(new UserUrlLinkFramePrivate())
 {
-  d = new UserUrlLinkFramePrivate;
   parseFields(fieldData(data));
 }

taglib/mpeg/id3v2/id3v2.h

@@ -0,0 +1,24 @@
+#ifndef TAGLIB_ID3V2_H
+#define TAGLIB_ID3V2_H
+
+namespace TagLib {
+  //! An ID3v2 implementation
+
+  /*!
+   * This is a relatively complete and flexible framework for working with ID3v2
+   * tags.
+   *
+   * \see ID3v2::Tag
+   */
+  namespace ID3v2 {
+    /*!
+     * Used to specify which version of the ID3 standard to use when saving tags.
+     */
+    enum Version {
+      v3 = 3, //<! ID3v2.3
+      v4 = 4  //<! ID3v2.4
+    };
+  }
+}
+
+#endif

taglib/mpeg/id3v2/id3v2extendedheader.cpp

@@ -41,9 +41,9 @@ public:
 // public methods
 ////////////////////////////////////////////////////////////////////////////////
 
-ExtendedHeader::ExtendedHeader()
+ExtendedHeader::ExtendedHeader() :
+  d(new ExtendedHeaderPrivate())
 {
-  d = new ExtendedHeaderPrivate();
 }
 
 ExtendedHeader::~ExtendedHeader()

taglib/mpeg/id3v2/id3v2extendedheader.h

@@ -38,7 +38,7 @@ namespace TagLib {
 
     /*!
      * This class implements ID3v2 extended headers.  It attempts to follow,
-     * both semantically and programatically, the structure specified in
+     * both semantically and programmatically, the structure specified in
      * the ID3v2 standard.  The API is based on the properties of ID3v2 extended
      * headers specified there.  If any of the terms used in this documentation
      * are unclear please check the specification in the linked section.

taglib/mpeg/id3v2/id3v2frame.cpp

@@ -40,6 +40,7 @@
 #include "frames/commentsframe.h"
 #include "frames/uniquefileidentifierframe.h"
 #include "frames/unknownframe.h"
+#include "frames/podcastframe.h"
 
 using namespace TagLib;
 using namespace ID3v2;
@@ -111,8 +112,8 @@ Frame *Frame::createTextualFrame(const String &key, const StringList &values) //
   // check if the key is contained in the key<=>frameID mapping
   ByteVector frameID = keyToFrameID(key);
   if(!frameID.isEmpty()) {
-    // Apple proprietary WFED (Podcast URL) is in fact a text frame.
-    if(frameID[0] == 'T' || frameID == "WFED"){ // text frame
+    // Apple proprietary WFED (Podcast URL), MVNM (Movement Name), MVIN (Movement Number), GRP1 (Grouping) are in fact text frames.
+    if(frameID[0] == 'T' || frameID == "WFED" || frameID == "MVNM" || frameID == "MVIN" || frameID == "GRP1"){ // text frame
       TextIdentificationFrame *frame = new TextIdentificationFrame(frameID, String::UTF8);
       frame->setText(values);
       return frame;
@@ -120,6 +121,8 @@ Frame *Frame::createTextualFrame(const String &key, const StringList &values) //
         UrlLinkFrame* frame = new UrlLinkFrame(frameID);
         frame->setUrl(values.front());
         return frame;
+    } else if(frameID == "PCST") {
+      return new PodcastFrame();
     }
   }
   if(key == "MUSICBRAINZ_TRACKID" && values.size() == 1) {
@@ -198,15 +201,15 @@ ByteVector Frame::render() const
 // protected members
 ////////////////////////////////////////////////////////////////////////////////
 
-Frame::Frame(const ByteVector &data)
+Frame::Frame(const ByteVector &data) :
+  d(new FramePrivate())
 {
-  d = new FramePrivate;
   d->header = new Header(data);
 }
 
-Frame::Frame(Header *h)
+Frame::Frame(Header *h) :
+  d(new FramePrivate())
 {
-  d = new FramePrivate;
   d->header = h;
 }
 
@@ -344,7 +347,7 @@ namespace
     { "TEXT", "LYRICIST" },
     { "TFLT", "FILETYPE" },
     //{ "TIPL", "INVOLVEDPEOPLE" }, handled separately
-    { "TIT1", "CONTENTGROUP" },
+    { "TIT1", "CONTENTGROUP" }, // 'Work' in iTunes
     { "TIT2", "TITLE"},
     { "TIT3", "SUBTITLE" },
     { "TKEY", "INITIALKEY" },
@@ -369,6 +372,7 @@ namespace
     { "TRSN", "RADIOSTATION" },
     { "TRSO", "RADIOSTATIONOWNER" },
     { "TSOA", "ALBUMSORT" },
+    { "TSOC", "COMPOSERSORT" },
     { "TSOP", "ARTISTSORT" },
     { "TSOT", "TITLESORT" },
     { "TSO2", "ALBUMARTISTSORT" }, // non-standard, used by iTunes
@@ -392,6 +396,9 @@ namespace
     { "TDES", "PODCASTDESC" },
     { "TGID", "PODCASTID" },
     { "WFED", "PODCASTURL" },
+    { "MVNM", "MOVEMENTNAME" },
+    { "MVIN", "MOVEMENTNUMBER" },
+    { "GRP1", "GROUPING" },
   };
   const size_t frameTranslationSize = sizeof(frameTranslation) / sizeof(frameTranslation[0]);
 
@@ -399,7 +406,11 @@ namespace
     { "MUSICBRAINZ ALBUM ID",         "MUSICBRAINZ_ALBUMID" },
     { "MUSICBRAINZ ARTIST ID",        "MUSICBRAINZ_ARTISTID" },
     { "MUSICBRAINZ ALBUM ARTIST ID",  "MUSICBRAINZ_ALBUMARTISTID" },
+    { "MUSICBRAINZ ALBUM RELEASE COUNTRY", "RELEASECOUNTRY" },
+    { "MUSICBRAINZ ALBUM STATUS", "RELEASESTATUS" },
+    { "MUSICBRAINZ ALBUM TYPE", "RELEASETYPE" },
     { "MUSICBRAINZ RELEASE GROUP ID", "MUSICBRAINZ_RELEASEGROUPID" },
+    { "MUSICBRAINZ RELEASE TRACK ID", "MUSICBRAINZ_RELEASETRACKID" },
     { "MUSICBRAINZ WORK ID",          "MUSICBRAINZ_WORKID" },
     { "ACOUSTID ID",                  "ACOUSTID_ID" },
     { "ACOUSTID FINGERPRINT",         "ACOUSTID_FINGERPRINT" },
@@ -414,7 +425,7 @@ namespace
     {"TYER", "TDRC"}, // 2.3 -> 2.4
     {"TIME", "TDRC"}, // 2.3 -> 2.4
   };
-  const size_t deprecatedFramesSize = sizeof(deprecatedFrames) / sizeof(deprecatedFrames[0]);;
+  const size_t deprecatedFramesSize = sizeof(deprecatedFrames) / sizeof(deprecatedFrames[0]);
 }
 
 String Frame::frameIDToKey(const ByteVector &id)
@@ -474,8 +485,8 @@ PropertyMap Frame::asProperties() const
   // workaround until this function is virtual
   if(id == "TXXX")
     return dynamic_cast< const UserTextIdentificationFrame* >(this)->asProperties();
-  // Apple proprietary WFED (Podcast URL) is in fact a text frame.
-  else if(id[0] == 'T' || id == "WFED")
+  // Apple proprietary WFED (Podcast URL), MVNM (Movement Name), MVIN (Movement Number), GRP1 (Grouping) are in fact text frames.
+  else if(id[0] == 'T' || id == "WFED" || id == "MVNM" || id == "MVIN" || id == "GRP1")
     return dynamic_cast< const TextIdentificationFrame* >(this)->asProperties();
   else if(id == "WXXX")
     return dynamic_cast< const UserUrlLinkFrame* >(this)->asProperties();
@@ -487,6 +498,8 @@ PropertyMap Frame::asProperties() const
     return dynamic_cast< const UnsynchronizedLyricsFrame* >(this)->asProperties();
   else if(id == "UFID")
     return dynamic_cast< const UniqueFileIdentifierFrame* >(this)->asProperties();
+  else if(id == "PCST")
+    return dynamic_cast< const PodcastFrame* >(this)->asProperties();
   PropertyMap m;
   m.unsupportedData().append(id);
   return m;
@@ -571,15 +584,15 @@ unsigned int Frame::Header::size(unsigned int version)
 // public members (Frame::Header)
 ////////////////////////////////////////////////////////////////////////////////
 
-Frame::Header::Header(const ByteVector &data, bool synchSafeInts)
+Frame::Header::Header(const ByteVector &data, bool synchSafeInts) :
+  d(new HeaderPrivate())
 {
-  d = new HeaderPrivate;
   setData(data, synchSafeInts);
 }
 
-Frame::Header::Header(const ByteVector &data, unsigned int version)
+Frame::Header::Header(const ByteVector &data, unsigned int version) :
+  d(new HeaderPrivate())
 {
-  d = new HeaderPrivate;
   setData(data, version);
 }
 

taglib/mpeg/id3v2/id3v2frame.h

@@ -47,7 +47,7 @@ namespace TagLib {
      * split between a collection of frames (which are in turn split into fields
      * (Structure, <a href="id3v2-structure.html#4">4</a>)
      * (<a href="id3v2-frames.html">Frames</a>).  This class provides an API for
-     * gathering information about and modifying ID3v2 frames.  Funtionallity
+     * gathering information about and modifying ID3v2 frames.  Functionality
      * specific to a given frame type is handed in one of the many subclasses.
      */
 
@@ -89,14 +89,15 @@ namespace TagLib {
        * non-binary compatible release this will be made into a non-static
        * member that checks the internal ID3v2 version.
        */
-      static unsigned int headerSize(); // BIC: remove and make non-static
+      static unsigned int headerSize(); // BIC: make non-static
 
       /*!
        * Returns the size of the frame header for the given ID3v2 version.
        *
        * \deprecated Please see the explanation above.
        */
-      static unsigned int headerSize(unsigned int version); // BIC: remove and make non-static
+      // BIC: remove
+      static unsigned int headerSize(unsigned int version);
 
       /*!
        * Sets the data that will be used as the frame.  Since the length is not
@@ -224,7 +225,7 @@ namespace TagLib {
        * This is useful for reading strings sequentially.
        */
       String readStringField(const ByteVector &data, String::Type encoding,
-                             int *positon = 0);
+                             int *position = 0);
 
       /*!
        * Checks a the list of string values to see if they can be used with the
@@ -255,7 +256,7 @@ namespace TagLib {
 
 
       /*!
-       * Parses the contents of this frame as PropertyMap. If that fails, the returend
+       * Parses the contents of this frame as PropertyMap. If that fails, the returned
        * PropertyMap will be empty, and its unsupportedData() will contain this frame's
        * ID.
        * BIC: Will be a virtual function in future releases.
@@ -334,7 +335,7 @@ namespace TagLib {
        * \deprecated Please use the constructor below that accepts a version
        * number.
        */
-      Header(const ByteVector &data, bool synchSafeInts);
+      TAGLIB_DEPRECATED Header(const ByteVector &data, bool synchSafeInts);
 
       /*!
        * Construct a Frame Header based on \a data.  \a data must at least
@@ -356,7 +357,7 @@ namespace TagLib {
        * \deprecated Please use the version below that accepts an ID3v2 version
        * number.
        */
-      void setData(const ByteVector &data, bool synchSafeInts);
+      TAGLIB_DEPRECATED void setData(const ByteVector &data, bool synchSafeInts);
 
       /*!
        * Sets the data for the Header.  \a version should indicate the ID3v2
@@ -411,6 +412,7 @@ namespace TagLib {
        * removed in the next binary incompatible release (2.0) and will be
        * replaced with a non-static method that checks the frame version.
        */
+      // BIC: make non-static
       static unsigned int size();
 
       /*!
@@ -419,6 +421,7 @@ namespace TagLib {
        *
        * \deprecated Please see the explanation in the version above.
        */
+      // BIC: remove
       static unsigned int size(unsigned int version);
 
       /*!
@@ -502,7 +505,7 @@ namespace TagLib {
       /*!
        * \deprecated
        */
-      bool frameAlterPreservation() const;
+      TAGLIB_DEPRECATED bool frameAlterPreservation() const;
 
     private:
       Header(const Header &);

taglib/mpeg/id3v2/id3v2framefactory.cpp

@@ -60,22 +60,24 @@ namespace
 
     for(StringList::ConstIterator it = fields.begin(); it != fields.end(); ++it) {
       String s = *it;
-      int end = s.find(")");
+      int offset = 0;
+      int end = 0;
 
-      if(s.startsWith("(") && end > 0) {
+      while(s.length() > offset && s[offset] == '(' &&
+            (end = s.find(")", offset + 1)) > offset) {
         // "(12)Genre"
-        String text = s.substr(end + 1);
+        const String genreCode = s.substr(offset + 1, end - 1);
+        s = s.substr(end + 1);
         bool ok;
-        int number = s.substr(1, end - 1).toInt(&ok);
-        if(ok && number >= 0 && number <= 255 && !(ID3v1::genre(number) == text))
-          newfields.append(s.substr(1, end - 1));
-        if(!text.isEmpty())
-          newfields.append(text);
+        int number = genreCode.toInt(&ok);
+        if((ok && number >= 0 && number <= 255 &&
+            !(ID3v1::genre(number) == s)) ||
+           genreCode == "RX" || genreCode == "CR")
+          newfields.append(genreCode);
       }
-      else {
+      if(!s.isEmpty())
         // "Genre" or "12"
         newfields.append(s);
-      }
     }
 
     if(newfields.isEmpty())
@@ -126,6 +128,11 @@ Frame *FrameFactory::createFrame(const ByteVector &data, unsigned int version) c
 }
 
 Frame *FrameFactory::createFrame(const ByteVector &origData, Header *tagHeader) const
+{
+    return createFrame(origData, const_cast<const Header *>(tagHeader));
+}
+
+Frame *FrameFactory::createFrame(const ByteVector &origData, const Header *tagHeader) const
 {
   ByteVector data = origData;
   unsigned int version = tagHeader->majorVersion();
@@ -198,8 +205,8 @@ Frame *FrameFactory::createFrame(const ByteVector &origData, Header *tagHeader)
 
   // Text Identification (frames 4.2)
 
-  // Apple proprietary WFED (Podcast URL) is in fact a text frame.
-  if(frameID.startsWith("T") || frameID == "WFED") {
+  // Apple proprietary WFED (Podcast URL), MVNM (Movement Name), MVIN (Movement Number), GRP1 (Grouping) are in fact text frames.
+  if(frameID.startsWith("T") || frameID == "WFED" || frameID == "MVNM" || frameID == "MVIN" || frameID == "GRP1") {
 
     TextIdentificationFrame *f = frameID != "TXXX"
       ? new TextIdentificationFrame(data, header)
@@ -277,7 +284,7 @@ Frame *FrameFactory::createFrame(const ByteVector &origData, Header *tagHeader)
     return f;
   }
 
-  // Synchronised lyrics/text (frames 4.9)
+  // Synchronized lyrics/text (frames 4.9)
 
   if(frameID == "SYLT") {
     SynchronizedLyricsFrame *f = new SynchronizedLyricsFrame(data, header);
@@ -334,10 +341,11 @@ void FrameFactory::rebuildAggregateFrames(ID3v2::Tag *tag) const
      tag->frameList("TDAT").size() == 1)
   {
     TextIdentificationFrame *tdrc =
-      static_cast<TextIdentificationFrame *>(tag->frameList("TDRC").front());
+      dynamic_cast<TextIdentificationFrame *>(tag->frameList("TDRC").front());
     UnknownFrame *tdat = static_cast<UnknownFrame *>(tag->frameList("TDAT").front());
 
-    if(tdrc->fieldList().size() == 1 &&
+    if(tdrc &&
+       tdrc->fieldList().size() == 1 &&
        tdrc->fieldList().front().size() == 4 &&
        tdat->data().size() >= 5)
     {
@@ -456,6 +464,9 @@ namespace
     { "TDS", "TDES" },
     { "TID", "TGID" },
     { "WFD", "WFED" },
+    { "MVN", "MVNM" },
+    { "MVI", "MVIN" },
+    { "GP1", "GRP1" },
   };
   const size_t frameConversion2Size = sizeof(frameConversion2) / sizeof(frameConversion2[0]);
 

taglib/mpeg/id3v2/id3v2framefactory.h

@@ -46,7 +46,7 @@ namespace TagLib {
      *
      * Reimplementing this factory is the key to adding support for frame types
      * not directly supported by TagLib to your application.  To do so you would
-     * subclass this factory reimplement createFrame().  Then by setting your
+     * subclass this factory and reimplement createFrame().  Then by setting your
      * factory to be the default factory in ID3v2::Tag constructor you can
      * implement behavior that will allow for new ID3v2::Frame subclasses (also
      * provided by you) to be used.
@@ -74,7 +74,7 @@ namespace TagLib {
        * \deprecated Please use the method below that accepts a ID3v2::Header
        * instance in new code.
        */
-      Frame *createFrame(const ByteVector &data, bool synchSafeInts) const;
+      TAGLIB_DEPRECATED Frame *createFrame(const ByteVector &data, bool synchSafeInts) const;
 
       /*!
        * Create a frame based on \a data.  \a version should indicate the ID3v2
@@ -84,14 +84,19 @@ namespace TagLib {
        * \deprecated Please use the method below that accepts a ID3v2::Header
        * instance in new code.
        */
-      Frame *createFrame(const ByteVector &data, unsigned int version = 4) const;
+      TAGLIB_DEPRECATED Frame *createFrame(const ByteVector &data, unsigned int version = 4) const;
 
+      /*!
+       * \deprecated
+       */
+      // BIC: remove
+      Frame *createFrame(const ByteVector &data, Header *tagHeader) const;
       /*!
        * Create a frame based on \a data.  \a tagHeader should be a valid
        * ID3v2::Header instance.
        */
       // BIC: make virtual
-      Frame *createFrame(const ByteVector &data, Header *tagHeader) const;
+      Frame *createFrame(const ByteVector &data, const Header *tagHeader) const;
 
       /*!
        * After a tag has been read, this tries to rebuild some of them

taglib/mpeg/id3v2/id3v2header.h

@@ -28,6 +28,7 @@
 
 #include "tbytevector.h"
 #include "taglib_export.h"
+#include "id3v2.h"
 
 namespace TagLib {
 

taglib/mpeg/id3v2/id3v2tag.cpp

@@ -54,12 +54,23 @@ namespace
 
   const long MinPaddingSize = 1024;
   const long MaxPaddingSize = 1024 * 1024;
+
+  bool contains(const char **a, const ByteVector &v)
+  {
+    for(int i = 0; a[i]; i++)
+    {
+      if(v == a[i])
+        return true;
+    }
+    return false;
+  }
 }
 
 class ID3v2::Tag::TagPrivate
 {
 public:
   TagPrivate() :
+    factory(0),
     file(0),
     tagOffset(0),
     extendedHeader(0),
@@ -249,13 +260,24 @@ void ID3v2::Tag::setComment(const String &s)
     return;
   }
 
-  if(!d->frameListMap["COMM"].isEmpty())
-    d->frameListMap["COMM"].front()->setText(s);
-  else {
-    CommentsFrame *f = new CommentsFrame(d->factory->defaultTextEncoding());
-    addFrame(f);
-    f->setText(s);
+  const FrameList &comments = d->frameListMap["COMM"];
+
+  if(!comments.isEmpty()) {
+    for(FrameList::ConstIterator it = comments.begin(); it != comments.end(); ++it) {
+      CommentsFrame *frame = dynamic_cast<CommentsFrame *>(*it);
+      if(frame && frame->description().isEmpty()) {
+        (*it)->setText(s);
+        return;
+      }
+    }
+
+    comments.front()->setText(s);
+    return;
   }
+
+  CommentsFrame *f = new CommentsFrame(d->factory->defaultTextEncoding());
+  addFrame(f);
+  f->setText(s);
 }
 
 void ID3v2::Tag::setGenre(const String &s)
@@ -286,7 +308,7 @@ void ID3v2::Tag::setGenre(const String &s)
 
 void ID3v2::Tag::setYear(unsigned int i)
 {
-  if(i <= 0) {
+  if(i == 0) {
     removeFrames("TDRC");
     return;
   }
@@ -295,7 +317,7 @@ void ID3v2::Tag::setYear(unsigned int i)
 
 void ID3v2::Tag::setTrack(unsigned int i)
 {
-  if(i <= 0) {
+  if(i == 0) {
     removeFrames("TRCK");
     return;
   }
@@ -461,19 +483,19 @@ PropertyMap ID3v2::Tag::setProperties(const PropertyMap &origProps)
 
 ByteVector ID3v2::Tag::render() const
 {
-  return render(4);
+  return render(ID3v2::v4);
 }
 
 void ID3v2::Tag::downgradeFrames(FrameList *frames, FrameList *newFrames) const
 {
 #ifdef NO_ITUNES_HACKS
-  const char *unsupportedFrames[] = {
+  static const char *unsupportedFrames[] = {
     "ASPI", "EQU2", "RVA2", "SEEK", "SIGN", "TDRL", "TDTG",
     "TMOO", "TPRO", "TSOA", "TSOT", "TSST", "TSOP", 0
   };
 #else
   // iTunes writes and reads TSOA, TSOT, TSOP to ID3v2.3.
-  const char *unsupportedFrames[] = {
+  static const char *unsupportedFrames[] = {
     "ASPI", "EQU2", "RVA2", "SEEK", "SIGN", "TDRL", "TDTG",
     "TMOO", "TPRO", "TSST", 0
   };
@@ -482,60 +504,62 @@ void ID3v2::Tag::downgradeFrames(FrameList *frames, FrameList *newFrames) const
   ID3v2::TextIdentificationFrame *frameTDRC = 0;
   ID3v2::TextIdentificationFrame *frameTIPL = 0;
   ID3v2::TextIdentificationFrame *frameTMCL = 0;
+  ID3v2::TextIdentificationFrame *frameTCON = 0;
+
   for(FrameList::ConstIterator it = d->frameList.begin(); it != d->frameList.end(); it++) {
     ID3v2::Frame *frame = *it;
     ByteVector frameID = frame->header()->frameID();
-    for(int i = 0; unsupportedFrames[i]; i++) {
-      if(frameID == unsupportedFrames[i]) {
-        debug("A frame that is not supported in ID3v2.3 \'"
-          + String(frameID) + "\' has been discarded");
-        frame = 0;
-        break;
-      }
+
+    if(contains(unsupportedFrames, frameID))
+    {
+      debug("A frame that is not supported in ID3v2.3 \'" + String(frameID) +
+            "\' has been discarded");
+      continue;
     }
-    if(frame && frameID == "TDOR") {
+
+    if(frameID == "TDOR")
       frameTDOR = dynamic_cast<ID3v2::TextIdentificationFrame *>(frame);
-      frame = 0;
-    }
-    if(frame && frameID == "TDRC") {
+    else if(frameID == "TDRC")
       frameTDRC = dynamic_cast<ID3v2::TextIdentificationFrame *>(frame);
-      frame = 0;
-    }
-    if(frame && frameID == "TIPL") {
+    else if(frameID == "TIPL")
       frameTIPL = dynamic_cast<ID3v2::TextIdentificationFrame *>(frame);
-      frame = 0;
-    }
-    if(frame && frameID == "TMCL") {
+    else if(frameID == "TMCL")
       frameTMCL = dynamic_cast<ID3v2::TextIdentificationFrame *>(frame);
-      frame = 0;
-    }
-    if(frame) {
+    else if(frame && frameID == "TCON")
+      frameTCON = dynamic_cast<ID3v2::TextIdentificationFrame *>(frame);
+    else
       frames->append(frame);
-    }
   }
+
   if(frameTDOR) {
     String content = frameTDOR->toString();
+
     if(content.size() >= 4) {
-      ID3v2::TextIdentificationFrame *frameTORY = new ID3v2::TextIdentificationFrame("TORY", String::Latin1);
+      ID3v2::TextIdentificationFrame *frameTORY =
+          new ID3v2::TextIdentificationFrame("TORY", String::Latin1);
       frameTORY->setText(content.substr(0, 4));
       frames->append(frameTORY);
       newFrames->append(frameTORY);
     }
   }
+
   if(frameTDRC) {
     String content = frameTDRC->toString();
     if(content.size() >= 4) {
-      ID3v2::TextIdentificationFrame *frameTYER = new ID3v2::TextIdentificationFrame("TYER", String::Latin1);
+      ID3v2::TextIdentificationFrame *frameTYER =
+          new ID3v2::TextIdentificationFrame("TYER", String::Latin1);
       frameTYER->setText(content.substr(0, 4));
       frames->append(frameTYER);
       newFrames->append(frameTYER);
       if(content.size() >= 10 && content[4] == '-' && content[7] == '-') {
-        ID3v2::TextIdentificationFrame *frameTDAT = new ID3v2::TextIdentificationFrame("TDAT", String::Latin1);
+        ID3v2::TextIdentificationFrame *frameTDAT =
+            new ID3v2::TextIdentificationFrame("TDAT", String::Latin1);
         frameTDAT->setText(content.substr(8, 2) + content.substr(5, 2));
         frames->append(frameTDAT);
         newFrames->append(frameTDAT);
         if(content.size() >= 16 && content[10] == 'T' && content[13] == ':') {
-          ID3v2::TextIdentificationFrame *frameTIME = new ID3v2::TextIdentificationFrame("TIME", String::Latin1);
+          ID3v2::TextIdentificationFrame *frameTIME =
+              new ID3v2::TextIdentificationFrame("TIME", String::Latin1);
           frameTIME->setText(content.substr(11, 2) + content.substr(14, 2));
           frames->append(frameTIME);
           newFrames->append(frameTIME);
@@ -543,9 +567,13 @@ void ID3v2::Tag::downgradeFrames(FrameList *frames, FrameList *newFrames) const
       }
     }
   }
+
   if(frameTIPL || frameTMCL) {
-    ID3v2::TextIdentificationFrame *frameIPLS = new ID3v2::TextIdentificationFrame("IPLS", String::Latin1);
+    ID3v2::TextIdentificationFrame *frameIPLS =
+      new ID3v2::TextIdentificationFrame("IPLS", String::Latin1);
+
     StringList people;
+
     if(frameTMCL) {
       StringList v24People = frameTMCL->fieldList();
       for(unsigned int i = 0; i + 1 < v24People.size(); i += 2) {
@@ -560,24 +588,53 @@ void ID3v2::Tag::downgradeFrames(FrameList *frames, FrameList *newFrames) const
         people.append(v24People[i+1]);
       }
     }
+
     frameIPLS->setText(people);
     frames->append(frameIPLS);
     newFrames->append(frameIPLS);
   }
+
+  if(frameTCON) {
+    StringList genres = frameTCON->fieldList();
+    String combined;
+    String genreText;
+    const bool hasMultipleGenres = genres.size() > 1;
+
+    // If there are multiple genres, add them as multiple references to ID3v1
+    // genres if such a reference exists. The first genre for which no ID3v1
+    // genre number exists can be finally added as a refinement.
+    for(StringList::ConstIterator it = genres.begin(); it != genres.end(); ++it) {
+      bool ok = false;
+      int number = it->toInt(&ok);
+      if((ok && number >= 0 && number <= 255) || *it == "RX" || *it == "CR")
+        combined += '(' + *it + ')';
+      else if(hasMultipleGenres && (number = ID3v1::genreIndex(*it)) != 255)
+        combined += '(' + String::number(number) + ')';
+      else if(genreText.isEmpty())
+        genreText = *it;
+    }
+    if(!genreText.isEmpty())
+      combined += genreText;
+
+    frameTCON = new ID3v2::TextIdentificationFrame("TCON", String::Latin1);
+    frameTCON->setText(combined);
+    frames->append(frameTCON);
+    newFrames->append(frameTCON);
+  }
 }
 
 ByteVector ID3v2::Tag::render(int version) const
+{
+  return render(version == 3 ? v3 : v4);
+}
+
+ByteVector ID3v2::Tag::render(Version version) const
 {
   // We need to render the "tag data" first so that we have to correct size to
   // render in the tag's header.  The "tag data" -- everything that is included
   // in ID3v2::Header::tagSize() -- includes the extended header, frames and
   // padding, but does not include the tag's header or footer.
 
-  if(version != 3 && version != 4) {
-    debug("Unknown ID3v2 version, using ID3v2.4");
-    version = 4;
-  }
-
   // TODO: Render the extended header.
 
   // Downgrade the frames that ID3v2.3 doesn't support.
@@ -586,7 +643,7 @@ ByteVector ID3v2::Tag::render(int version) const
   newFrames.setAutoDelete(true);
 
   FrameList frameList;
-  if(version == 4) {
+  if(version == v4) {
     frameList = d->frameList;
   }
   else {
@@ -600,7 +657,7 @@ ByteVector ID3v2::Tag::render(int version) const
   // Loop through the frames rendering them and adding them to the tagData.
 
   for(FrameList::ConstIterator it = frameList.begin(); it != frameList.end(); it++) {
-    (*it)->header()->setVersion(version);
+    (*it)->header()->setVersion(version == v3 ? 3 : 4);
     if((*it)->header()->frameID().size() != 4) {
       debug("An ID3v2 frame of unsupported or unknown type \'"
           + String((*it)->header()->frameID()) + "\' has been discarded");
@@ -618,7 +675,6 @@ ByteVector ID3v2::Tag::render(int version) const
   }
 
   // Compute the amount of padding, and append that to tagData.
-  // TODO: Should be calculated in long long in taglib2.
 
   long originalSize = d->header.tagSize();
   long paddingSize = originalSize - (tagData.size() - Header::size());
@@ -723,7 +779,7 @@ void ID3v2::Tag::parse(const ByteVector &origData)
 
   if(d->header.extendedHeader()) {
     if(!d->extendedHeader)
-      d->extendedHeader = new ExtendedHeader;
+      d->extendedHeader = new ExtendedHeader();
     d->extendedHeader->setData(data);
     if(d->extendedHeader->size() <= data.size()) {
       frameDataPosition += d->extendedHeader->size();

taglib/mpeg/id3v2/id3v2tag.h

@@ -33,21 +33,13 @@
 #include "tmap.h"
 #include "taglib_export.h"
 
+#include "id3v2.h"
 #include "id3v2framefactory.h"
 
 namespace TagLib {
 
   class File;
 
-  //! An ID3v2 implementation
-
-  /*!
-   * This is a relatively complete and flexible framework for working with ID3v2
-   * tags.
-   *
-   * \see ID3v2::Tag
-   */
-
   namespace ID3v2 {
 
     class Header;
@@ -201,7 +193,7 @@ namespace TagLib {
        * prone to change my mind, so this gets to stay around until near a
        * release.
        */
-      Footer *footer() const;
+      TAGLIB_DEPRECATED Footer *footer() const;
 
       /*!
        * Returns a reference to the frame list map.  This is an FrameListMap of
@@ -310,7 +302,7 @@ namespace TagLib {
        *    - otherwise, the key "LYRICS:<description>" is used;
        *  - if the frame ID is "TIPL" (involved peoples list), and if all the
        *    roles defined in the frame are known in TextIdentificationFrame::involvedPeopleMap(),
-       *    then "<role>=<name>" will be contained in the returned obejct for each
+       *    then "<role>=<name>" will be contained in the returned object for each
        *  - if the frame ID is "TMCL" (musician credit list), then
        *    "PERFORMER:<instrument>=<name>" will be contained in the returned
        *    PropertyMap for each defined musician
@@ -345,14 +337,18 @@ namespace TagLib {
        */
       ByteVector render() const;
 
+      /*!
+       * \deprecated
+       */
+      TAGLIB_DEPRECATED ByteVector render(int version) const;
+
       /*!
        * Render the tag back to binary data, suitable to be written to disk.
        *
-       * The \a version parameter specifies the version of the rendered
-       * ID3v2 tag. It can be either 4 or 3.
+       * The \a version parameter specifies whether ID3v2.4 (default) or ID3v2.3
+       * should be used.
        */
-      // BIC: combine with the above method
-      ByteVector render(int version) const;
+      ByteVector render(Version version) const;
 
       /*!
        * Gets the current string handler that decides how the "Latin-1" data
@@ -396,6 +392,9 @@ namespace TagLib {
        */
       void setTextFrame(const ByteVector &id, const String &value);
 
+      /*!
+       * Downgrade frames from ID3v2.4 (used internally and by default) to ID3v2.3.
+       */
       void downgradeFrames(FrameList *existingFrames, FrameList *newFrames) const;
 
     private:

taglib/mpeg/mpegfile.cpp

@@ -76,6 +76,58 @@ public:
   Properties *properties;
 };
 
+////////////////////////////////////////////////////////////////////////////////
+// static members
+////////////////////////////////////////////////////////////////////////////////
+
+namespace
+{
+  // Dummy file class to make a stream work with MPEG::Header.
+
+  class AdapterFile : public TagLib::File
+  {
+  public:
+    AdapterFile(IOStream *stream) : File(stream) {}
+
+    Tag *tag() const { return 0; }
+    AudioProperties *audioProperties() const { return 0; }
+    bool save() { return false; }
+  };
+}
+
+bool MPEG::File::isSupported(IOStream *stream)
+{
+  if(!stream || !stream->isOpen())
+    return false;
+
+  // An MPEG file has MPEG frame headers. An ID3v2 tag may precede.
+
+  // MPEG frame headers are really confusing with irrelevant binary data.
+  // So we check if a frame header is really valid.
+
+  long headerOffset;
+  const ByteVector buffer = Utils::readHeader(stream, bufferSize(), true, &headerOffset);
+
+  if(buffer.isEmpty())
+      return false;
+
+  const long originalPosition = stream->tell();
+  AdapterFile file(stream);
+
+  for(unsigned int i = 0; i < buffer.size() - 1; ++i) {
+    if(isFrameSync(buffer, i)) {
+      const Header header(&file, headerOffset + i, true);
+      if(header.isValid()) {
+        stream->seek(originalPosition);
+        return true;
+      }
+    }
+  }
+
+  stream->seek(originalPosition);
+  return false;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // public members
 ////////////////////////////////////////////////////////////////////////////////
@@ -148,20 +200,30 @@ bool MPEG::File::save()
 
 bool MPEG::File::save(int tags)
 {
-  return save(tags, true);
+  return save(tags, StripOthers);
 }
 
 bool MPEG::File::save(int tags, bool stripOthers)
 {
-  return save(tags, stripOthers, 4);
+  return save(tags, stripOthers ? StripOthers : StripNone, ID3v2::v4);
 }
 
 bool MPEG::File::save(int tags, bool stripOthers, int id3v2Version)
 {
-  return save(tags, stripOthers, id3v2Version, true);
+  return save(tags,
+              stripOthers ? StripOthers : StripNone,
+              id3v2Version == 3 ? ID3v2::v3 : ID3v2::v4);
 }
 
 bool MPEG::File::save(int tags, bool stripOthers, int id3v2Version, bool duplicateTags)
+{
+  return save(tags,
+              stripOthers ? StripOthers : StripNone,
+              id3v2Version == 3 ? ID3v2::v3 : ID3v2::v4,
+              duplicateTags ? Duplicate : DoNotDuplicate);
+}
+
+bool MPEG::File::save(int tags, StripTags strip, ID3v2::Version version, DuplicateTags duplicate)
 {
   if(readOnly()) {
     debug("MPEG::File::save() -- File is read only.");
@@ -170,22 +232,22 @@ bool MPEG::File::save(int tags, bool stripOthers, int id3v2Version, bool duplica
 
   // Create the tags if we've been asked to.
 
-  if(duplicateTags) {
+  if(duplicate == Duplicate) {
 
     // Copy the values from the tag that does exist into the new tag,
     // except if the existing tag is to be stripped.
 
-    if((tags & ID3v2) && ID3v1Tag() && !(stripOthers && !(tags & ID3v1)))
+    if((tags & ID3v2) && ID3v1Tag() && !(strip == StripOthers && !(tags & ID3v1)))
       Tag::duplicate(ID3v1Tag(), ID3v2Tag(true), false);
 
-    if((tags & ID3v1) && d->tag[ID3v2Index] && !(stripOthers && !(tags & ID3v2)))
+    if((tags & ID3v1) && d->tag[ID3v2Index] && !(strip == StripOthers && !(tags & ID3v2)))
       Tag::duplicate(ID3v2Tag(), ID3v1Tag(true), false);
   }
 
   // Remove all the tags not going to be saved.
 
-  if(stripOthers)
-    strip(~tags, false);
+  if(strip == StripOthers)
+    File::strip(~tags, false);
 
   if(ID3v2 & tags) {
 
@@ -196,7 +258,7 @@ bool MPEG::File::save(int tags, bool stripOthers, int id3v2Version, bool duplica
       if(d->ID3v2Location < 0)
         d->ID3v2Location = 0;
 
-      const ByteVector data = ID3v2Tag()->render(id3v2Version);
+      const ByteVector data = ID3v2Tag()->render(version);
       insert(data, d->ID3v2Location, d->ID3v2OriginalSize);
 
       if(d->APELocation >= 0)
@@ -211,7 +273,7 @@ bool MPEG::File::save(int tags, bool stripOthers, int id3v2Version, bool duplica
 
       // ID3v2 tag is empty. Remove the old one.
 
-      strip(ID3v2, false);
+      File::strip(ID3v2, false);
     }
   }
 
@@ -235,7 +297,7 @@ bool MPEG::File::save(int tags, bool stripOthers, int id3v2Version, bool duplica
 
       // ID3v1 tag is empty. Remove the old one.
 
-      strip(ID3v1, false);
+      File::strip(ID3v1, false);
     }
   }
 
@@ -264,7 +326,7 @@ bool MPEG::File::save(int tags, bool stripOthers, int id3v2Version, bool duplica
 
       // APE tag is empty. Remove the old one.
 
-      strip(APE, false);
+      File::strip(APE, false);
     }
   }
 
@@ -346,55 +408,50 @@ void MPEG::File::setID3v2FrameFactory(const ID3v2::FrameFactory *factory)
 
 long MPEG::File::nextFrameOffset(long position)
 {
-  bool foundLastSyncPattern = false;
-
-  ByteVector buffer;
+  ByteVector frameSyncBytes(2, '\0');
 
   while(true) {
     seek(position);
-    buffer = readBlock(bufferSize());
-
-    if(buffer.size() <= 0)
+    const ByteVector buffer = readBlock(bufferSize());
+    if(buffer.isEmpty())
       return -1;
 
-    if(foundLastSyncPattern && secondSynchByte(buffer[0]))
-      return position - 1;
-
-    for(unsigned int i = 0; i < buffer.size() - 1; i++) {
-      if(firstSyncByte(buffer[i]) && secondSynchByte(buffer[i + 1]))
-        return position + i;
+    for(unsigned int i = 0; i < buffer.size(); ++i) {
+      frameSyncBytes[0] = frameSyncBytes[1];
+      frameSyncBytes[1] = buffer[i];
+      if(isFrameSync(frameSyncBytes)) {
+        const Header header(this, position + i - 1, true);
+        if(header.isValid())
+          return position + i - 1;
+      }
     }
 
-    foundLastSyncPattern = firstSyncByte(buffer[buffer.size() - 1]);
-    position += buffer.size();
+    position += bufferSize();
   }
 }
 
 long MPEG::File::previousFrameOffset(long position)
 {
-  bool foundFirstSyncPattern = false;
-  ByteVector buffer;
+  ByteVector frameSyncBytes(2, '\0');
 
-  while (position > 0) {
-    long size = std::min<long>(position, bufferSize());
-    position -= size;
+  while(position > 0) {
+    const long bufferLength = std::min<long>(position, bufferSize());
+    position -= bufferLength;
 
     seek(position);
-    buffer = readBlock(size);
+    const ByteVector buffer = readBlock(bufferLength);
 
-    if(buffer.size() <= 0)
-      break;
-
-    if(foundFirstSyncPattern && firstSyncByte(buffer[buffer.size() - 1]))
-      return position + buffer.size() - 1;
-
-    for(int i = buffer.size() - 2; i >= 0; i--) {
-      if(firstSyncByte(buffer[i]) && secondSynchByte(buffer[i + 1]))
-        return position + i;
+    for(int i = buffer.size() - 1; i >= 0; --i) {
+      frameSyncBytes[1] = frameSyncBytes[0];
+      frameSyncBytes[0] = buffer[i];
+      if(isFrameSync(frameSyncBytes)) {
+        const Header header(this, position + i, true);
+        if(header.isValid())
+          return position + i + header.frameLength();
+      }
     }
-
-    foundFirstSyncPattern = secondSynchByte(buffer[0]);
   }
+
   return -1;
 }
 
@@ -488,28 +545,41 @@ long MPEG::File::findID3v2()
   const ByteVector headerID = ID3v2::Header::fileIdentifier();
 
   seek(0);
-
-  const ByteVector data = readBlock(headerID.size());
-  if(data.size() < headerID.size())
-    return -1;
-
-  if(data == headerID)
+  if(readBlock(headerID.size()) == headerID)
     return 0;
 
-  if(firstSyncByte(data[0]) && secondSynchByte(data[1]))
+  const Header firstHeader(this, 0, true);
+  if(firstHeader.isValid())
     return -1;
 
-  // Look for the entire file, if neither an MEPG frame or ID3v2 tag was found
-  // at the beginning of the file.
-  // We don't care about the inefficiency of the code, since this is a seldom case.
+  // Look for an ID3v2 tag until reaching the first valid MPEG frame.
 
-  const long tagOffset = find(headerID);
-  if(tagOffset < 0)
-    return -1;
+  ByteVector frameSyncBytes(2, '\0');
+  ByteVector tagHeaderBytes(3, '\0');
+  long position = 0;
 
-  const long frameOffset = firstFrameOffset();
-  if(frameOffset < tagOffset)
-    return -1;
+  while(true) {
+    seek(position);
+    const ByteVector buffer = readBlock(bufferSize());
+    if(buffer.isEmpty())
+      return -1;
 
-  return tagOffset;
+    for(unsigned int i = 0; i < buffer.size(); ++i) {
+      frameSyncBytes[0] = frameSyncBytes[1];
+      frameSyncBytes[1] = buffer[i];
+      if(isFrameSync(frameSyncBytes)) {
+        const Header header(this, position + i - 1, true);
+        if(header.isValid())
+          return -1;
+      }
+
+      tagHeaderBytes[0] = tagHeaderBytes[1];
+      tagHeaderBytes[1] = tagHeaderBytes[2];
+      tagHeaderBytes[2] = buffer[i];
+      if(tagHeaderBytes == headerID)
+        return position + i - 2;
+    }
+
+    position += bufferSize();
+  }
 }

taglib/mpeg/mpegfile.h

@@ -32,6 +32,8 @@
 
 #include "mpegproperties.h"
 
+#include "id3v2.h"
+
 namespace TagLib {
 
   namespace ID3v2 { class Tag; class FrameFactory; }
@@ -191,49 +193,39 @@ namespace TagLib {
       bool save(int tags);
 
       /*!
-       * 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.
-       *
-       * If \a stripOthers is true 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.
+       * \deprecated
        */
       // BIC: combine with the above method
-      bool save(int tags, bool stripOthers);
+      TAGLIB_DEPRECATED bool save(int tags, bool stripOthers);
+
+      /*!
+       * \deprecated
+       */
+      // BIC: combine with the above method
+      TAGLIB_DEPRECATED bool save(int tags, bool stripOthers, int id3v2Version);
+
+      /*!
+       * \deprecated
+       */
+      // BIC: combine with the above method
+      TAGLIB_DEPRECATED bool save(int tags, bool stripOthers, int id3v2Version, bool duplicateTags);
 
       /*!
        * 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.
+       * specified by OR-ing together TagTypes values.
        *
-       * If \a stripOthers is true 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.
+       * \a strip can be set to strip all tags except those in \a tags.  Those
+       * tags will not be modified in memory, and thus remain valid.
        *
-       * The \a id3v2Version parameter specifies the version of the saved
-       * ID3v2 tag. It can be either 4 or 3.
+       * \a version specifies the ID3v2 version to be used for writing tags.  By
+       * default, the latest standard, ID3v2.4 is used.
+       *
+       * If \a duplicate is set to DuplicateTags and at least one tag -- ID3v1
+       * or ID3v2 -- exists this will duplicate its content into the other tag.
        */
-      // BIC: combine with the above method
-      bool save(int tags, bool stripOthers, int id3v2Version);
-
-      /*!
-       * 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.
-       *
-       * If \a stripOthers is true 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.
-       *
-       * The \a id3v2Version parameter specifies the version of the saved
-       * ID3v2 tag. It can be either 4 or 3.
-       *
-       * If \a duplicateTags is true and at least one tag -- ID3v1 or ID3v2 --
-       * exists this will duplicate its content into the other tag.
-       */
-      // BIC: combine with the above method
-      bool save(int tags, bool stripOthers, int id3v2Version, bool duplicateTags);
+      bool save(int tags, StripTags strip,
+                ID3v2::Version version = ID3v2::v4,
+                DuplicateTags duplicate = Duplicate);
 
       /*!
        * Returns a pointer to the ID3v2 tag of the file.
@@ -325,7 +317,7 @@ namespace TagLib {
        * \see ID3v2FrameFactory
        * \deprecated This value should be passed in via the constructor
        */
-      void setID3v2FrameFactory(const ID3v2::FrameFactory *factory);
+      TAGLIB_DEPRECATED void setID3v2FrameFactory(const ID3v2::FrameFactory *factory);
 
       /*!
        * Returns the position in the file of the first MPEG frame.
@@ -370,6 +362,15 @@ namespace TagLib {
        */
       bool hasAPETag() const;
 
+      /*!
+       * Returns whether or not the given \a stream can be opened as an MPEG
+       * 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 &);

taglib/mpeg/mpegheader.cpp

@@ -182,7 +182,7 @@ void MPEG::Header::parse(File *file, long offset, bool checkLength)
 
   // Check for the MPEG synch bytes.
 
-  if(!firstSyncByte(data[0]) || !secondSynchByte(data[1])) {
+  if(!isFrameSync(data)) {
     debug("MPEG::Header::parse() -- MPEG header did not match MPEG synch.");
     return;
   }
@@ -197,10 +197,8 @@ void MPEG::Header::parse(File *file, long offset, bool checkLength)
     d->version = Version2;
   else if(versionBits == 3)
     d->version = Version1;
-  else {
-    debug("MPEG::Header::parse() -- Invalid MPEG version bits.");
+  else
     return;
-  }
 
   // Set the MPEG layer
 
@@ -212,10 +210,8 @@ void MPEG::Header::parse(File *file, long offset, bool checkLength)
     d->layer = 2;
   else if(layerBits == 3)
     d->layer = 1;
-  else {
-    debug("MPEG::Header::parse() -- Invalid MPEG layer bits.");
+  else
     return;
-  }
 
   d->protectionEnabled = (static_cast<unsigned char>(data[1] & 0x01) == 0);
 
@@ -244,10 +240,8 @@ void MPEG::Header::parse(File *file, long offset, bool checkLength)
 
   d->bitrate = bitrates[versionIndex][layerIndex][bitrateIndex];
 
-  if(d->bitrate == 0) {
-    debug("MPEG::Header::parse() -- Invalid bit rate.");
+  if(d->bitrate == 0)
     return;
-  }
 
   // Set the sample rate
 
@@ -264,7 +258,6 @@ void MPEG::Header::parse(File *file, long offset, bool checkLength)
   d->sampleRate = sampleRates[d->version][samplerateIndex];
 
   if(d->sampleRate == 0) {
-    debug("MPEG::Header::parse() -- Invalid sample rate.");
     return;
   }
 
@@ -311,20 +304,16 @@ void MPEG::Header::parse(File *file, long offset, bool checkLength)
     file->seek(offset + d->frameLength);
     const ByteVector nextData = file->readBlock(4);
 
-    if(nextData.size() < 4) {
-      debug("MPEG::Header::parse() -- Could not read the next frame header.");
+    if(nextData.size() < 4)
       return;
-    }
 
     const unsigned int HeaderMask = 0xfffe0c00;
 
     const unsigned int header     = data.toUInt(0, true)     & HeaderMask;
     const unsigned int nextHeader = nextData.toUInt(0, true) & HeaderMask;
 
-    if(header != nextHeader) {
-      debug("MPEG::Header::parse() -- The next frame was not consistent with this frame.");
+    if(header != nextHeader)
       return;
-    }
   }
 
   // Now that we're done parsing, set this to be a valid frame.

taglib/mpeg/mpegheader.h

@@ -52,7 +52,7 @@ namespace TagLib {
        *
        * \deprecated
        */
-      Header(const ByteVector &data);
+      TAGLIB_DEPRECATED Header(const ByteVector &data);
 
       /*!
        * Parses an MPEG header based on \a file and \a offset.

taglib/mpeg/mpegproperties.cpp

@@ -157,23 +157,13 @@ void MPEG::Properties::read(File *file)
 {
   // Only the first valid frame is required if we have a VBR header.
 
-  long firstFrameOffset = file->firstFrameOffset();
+  const long firstFrameOffset = file->firstFrameOffset();
   if(firstFrameOffset < 0) {
     debug("MPEG::Properties::read() -- Could not find an MPEG frame in the stream.");
     return;
   }
 
-  Header firstHeader(file, firstFrameOffset);
-
-  while(!firstHeader.isValid()) {
-    firstFrameOffset = file->nextFrameOffset(firstFrameOffset + 1);
-    if(firstFrameOffset < 0) {
-      debug("MPEG::Properties::read() -- Could not find a valid first MPEG frame in the stream.");
-      return;
-    }
-
-    firstHeader = Header(file, firstFrameOffset);
-  }
+  const Header firstHeader(file, firstFrameOffset, false);
 
   // Check for a VBR header that will help us in gathering information about a
   // VBR stream.
@@ -207,27 +197,17 @@ void MPEG::Properties::read(File *file)
 
     // Look for the last MPEG audio frame to calculate the stream length.
 
-    long lastFrameOffset = file->lastFrameOffset();
+    const long lastFrameOffset = file->lastFrameOffset();
     if(lastFrameOffset < 0) {
       debug("MPEG::Properties::read() -- Could not find an MPEG frame in the stream.");
-      return;
     }
-
-    Header lastHeader(file, lastFrameOffset, false);
-
-    while(!lastHeader.isValid()) {
-      lastFrameOffset = file->previousFrameOffset(lastFrameOffset);
-      if(lastFrameOffset < 0) {
-        debug("MPEG::Properties::read() -- Could not find a valid last MPEG frame in the stream.");
-        return;
-      }
-
-      lastHeader = Header(file, lastFrameOffset, false);
+    else
+    {
+      const Header lastHeader(file, lastFrameOffset, false);
+      const long streamLength = lastFrameOffset - firstFrameOffset + lastHeader.frameLength();
+      if (streamLength > 0)
+        d->length = static_cast<int>(streamLength * 8.0 / d->bitrate + 0.5);
     }
-
-    const long streamLength = lastFrameOffset - firstFrameOffset + lastHeader.frameLength();
-    if(streamLength > 0)
-      d->length = static_cast<int>(streamLength * 8.0 / d->bitrate + 0.5);
   }
 
   d->sampleRate        = firstHeader.sampleRate();

taglib/mpeg/mpegproperties.h

@@ -67,7 +67,7 @@ namespace TagLib {
        *
        * \deprecated
        */
-      virtual int length() const;
+      TAGLIB_DEPRECATED virtual int length() const;
 
       /*!
        * Returns the length of the file in seconds.  The length is rounded down to

taglib/mpeg/mpegutils.h

@@ -41,17 +41,17 @@ namespace TagLib
        * MPEG frames can be recognized by the bit pattern 11111111 111, so the
        * first byte is easy to check for, however checking to see if the second byte
        * starts with \e 111 is a bit more tricky, hence these functions.
+       *
+       * \note This does not check the length of the vector, since this is an
+       * internal utility function.
        */
-      inline bool firstSyncByte(unsigned char byte)
+      inline bool isFrameSync(const ByteVector &bytes, unsigned int offset = 0)
       {
-        return (byte == 0xFF);
-      }
+        // 0xFF in the second byte is possible in theory, but it's very unlikely.
 
-      inline bool secondSynchByte(unsigned char byte)
-      {
-        // 0xFF is possible in theory, but it's very unlikely be a header.
-
-        return (byte != 0xFF && ((byte & 0xE0) == 0xE0));
+        const unsigned char b1 = bytes[offset + 0];
+        const unsigned char b2 = bytes[offset + 1];
+        return (b1 == 0xFF && b2 != 0xFF && (b2 & 0xE0) == 0xE0);
       }
 
     }

taglib/mpeg/xingheader.h

@@ -111,8 +111,8 @@ namespace TagLib {
        *
        * \deprecated Always returns 0.
        */
-      static int xingHeaderOffset(TagLib::MPEG::Header::Version v,
-                                  TagLib::MPEG::Header::ChannelMode c);
+      TAGLIB_DEPRECATED static int xingHeaderOffset(TagLib::MPEG::Header::Version v,
+                                                    TagLib::MPEG::Header::ChannelMode c);
 
     private:
       XingHeader(const XingHeader &);

taglib/ogg/flac/oggflacfile.cpp

@@ -27,6 +27,7 @@
 #include <tstring.h>
 #include <tdebug.h>
 #include <tpropertymap.h>
+#include <tagutils.h>
 
 #include <xiphcomment.h>
 #include "oggflacfile.h"
@@ -65,22 +66,36 @@ public:
   int commentPacket;
 };
 
+////////////////////////////////////////////////////////////////////////////////
+// static members
+////////////////////////////////////////////////////////////////////////////////
+
+bool Ogg::FLAC::File::isSupported(IOStream *stream)
+{
+  // An Ogg FLAC file has IDs "OggS" and "fLaC" somewhere.
+
+  const ByteVector buffer = Utils::readHeader(stream, bufferSize(), false);
+  return (buffer.find("OggS") >= 0 && buffer.find("fLaC") >= 0);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
 Ogg::FLAC::File::File(FileName file, bool readProperties,
-                      Properties::ReadStyle propertiesStyle) : Ogg::File(file)
+                      Properties::ReadStyle propertiesStyle) :
+  Ogg::File(file),
+  d(new FilePrivate())
 {
-  d = new FilePrivate;
   if(isOpen())
     read(readProperties, propertiesStyle);
 }
 
 Ogg::FLAC::File::File(IOStream *stream, bool readProperties,
-                      Properties::ReadStyle propertiesStyle) : Ogg::File(stream)
+                      Properties::ReadStyle propertiesStyle) :
+  Ogg::File(stream),
+  d(new FilePrivate())
 {
-  d = new FilePrivate;
   if(isOpen())
     read(readProperties, propertiesStyle);
 }
@@ -172,7 +187,7 @@ void Ogg::FLAC::File::read(bool readProperties, Properties::ReadStyle properties
   if(d->hasXiphComment)
     d->comment = new Ogg::XiphComment(xiphCommentData());
   else
-    d->comment = new Ogg::XiphComment;
+    d->comment = new Ogg::XiphComment();
 
 
   if(readProperties)
@@ -216,11 +231,21 @@ void Ogg::FLAC::File::scan()
 
   if(!metadataHeader.startsWith("fLaC"))  {
     // FLAC 1.1.2+
+    // See https://xiph.org/flac/ogg_mapping.html for the header specification.
+    if(metadataHeader.size() < 13)
+      return;
+
+    if(metadataHeader[0] != 0x7f)
+      return;
+
     if(metadataHeader.mid(1, 4) != "FLAC")
       return;
 
-    if(metadataHeader[5] != 1)
-      return; // not version 1
+    if(metadataHeader[5] != 1 && metadataHeader[6] != 0)
+      return; // not version 1.0
+
+    if(metadataHeader.mid(9, 4) != "fLaC")
+      return;
 
     metadataHeader = metadataHeader.mid(13);
   }

taglib/ogg/flac/oggflacfile.h

@@ -127,9 +127,6 @@ namespace TagLib {
       /*!
        * Save the file.  This will primarily save and update the XiphComment.
        * Returns true if the save is successful.
-       *
-       * \warning In the current implementation, it's dangerous to call save()
-       * repeatedly.  It leads to a segfault.
        */
       virtual bool save();
 
@@ -146,6 +143,14 @@ namespace TagLib {
        */
       bool hasXiphComment() const;
 
+      /*!
+       * Check if the given \a stream can be opened as an Ogg 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 &);

taglib/ogg/oggfile.cpp

@@ -253,7 +253,7 @@ void Ogg::File::writePacket(unsigned int i, const ByteVector &packet)
   ByteVectorList packets = firstPage->packets();
   packets[i - firstPage->firstPacketIndex()] = packet;
 
-  if(firstPage != lastPage && lastPage->packetCount() > 2) {
+  if(firstPage != lastPage && lastPage->packetCount() > 1) {
     ByteVectorList lastPagePackets = lastPage->packets();
     lastPagePackets.erase(lastPagePackets.begin());
     packets.append(lastPagePackets);

taglib/ogg/oggpage.cpp

@@ -208,15 +208,15 @@ List<Ogg::Page *> Ogg::Page::paginate(const ByteVectorList &packets,
 
   static const unsigned int SplitSize = 32 * 255;
 
-  // Force repagination if the packets are too large for a page.
+  // Force repagination if the segment table will exceed the size limit.
 
   if(strategy != Repaginate) {
 
-    size_t totalSize = packets.size();
+    size_t tableSize = 0;
     for(ByteVectorList::ConstIterator it = packets.begin(); it != packets.end(); ++it)
-      totalSize += it->size();
+      tableSize += it->size() / 255 + 1;
 
-    if(totalSize > 255 * 255)
+    if(tableSize > 255)
       strategy = Repaginate;
   }
 

taglib/ogg/oggpage.h

@@ -93,7 +93,7 @@ namespace TagLib {
        *
        * \deprecated Always returns null.
        */
-      Page* getCopyWithNewPageSequenceNumber(int sequenceNumber);
+      TAGLIB_DEPRECATED Page *getCopyWithNewPageSequenceNumber(int sequenceNumber);
 
       /*!
        * Returns the index of the first packet wholly or partially contained in

taglib/ogg/oggpageheader.h

@@ -156,7 +156,7 @@ namespace TagLib {
       /*!
        * A special value of containing the position of the packet to be
        * interpreted by the codec.  It is only supported here so that it may be
-       * coppied from one page to another.
+       * copied from one page to another.
        *
        * \see absoluteGranularPosition()
        */