These files should not be marked as executable

Update Windows INSTALL notes.

.gitignore

@@ -1,5 +1,7 @@
 cmake_install.cmake
+cmake_uninstall.cmake
 Makefile
+CTestTestfile.cmake
 CMakeFiles/
 *.so
 *.so.*
@@ -16,6 +18,7 @@ CMakeFiles/
 /config.h
 /taglib.pc
 /tests/test_runner
+/tests/Testing
 /taglib_config.h
 /taglib-config
 /bindings/c/taglib_c.pc

.travis.yml

@@ -0,0 +1,7 @@
+language: cpp
+compiler:
+  - gcc
+  - clang
+install: sudo apt-get install libcppunit-dev zlib1g-dev
+script: cmake -DBUILD_TESTS=ON -DBUILD_EXAMPLES=ON . && make && make check
+

AUTHORS

@@ -10,6 +10,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
+Tsuda Kageyu <tsuda.kageyu@gmail.com>
+ A lot of fixes and improvements, i.e. memory copy reduction etc.
 
 Please send all patches and questions to taglib-devel@kde.org rather than to
 individual developers!

CMakeLists.txt

@@ -9,6 +9,12 @@ if(ENABLE_STATIC)
 else()
   set(BUILD_SHARED_LIBS ON)
 endif()
+OPTION(ENABLE_STATIC_RUNTIME "Visual Studio, link with runtime statically"  OFF)
+
+option(VISIBILITY_HIDDEN "Build with -fvisibility=hidden"  OFF)
+if(VISIBILITY_HIDDEN)
+  add_definitions (-fvisibility=hidden)
+endif()
 
 option(BUILD_TESTS "Build the test suite"  OFF)
 option(BUILD_EXAMPLES "Build the examples"  OFF)
@@ -34,9 +40,14 @@ if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
 endif()
+if (MSVC AND ENABLE_STATIC_RUNTIME)
+  foreach(flag_var CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+    string(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
+  endforeach(flag_var)
+endif()
 
 set(TAGLIB_LIB_MAJOR_VERSION "1")
-set(TAGLIB_LIB_MINOR_VERSION "7")
+set(TAGLIB_LIB_MINOR_VERSION "9")
 set(TAGLIB_LIB_PATCH_VERSION "0")
 
 set(TAGLIB_LIB_VERSION_STRING "${TAGLIB_LIB_MAJOR_VERSION}.${TAGLIB_LIB_MINOR_VERSION}.${TAGLIB_LIB_PATCH_VERSION}")
@@ -45,9 +56,9 @@ set(TAGLIB_LIB_VERSION_STRING "${TAGLIB_LIB_MAJOR_VERSION}.${TAGLIB_LIB_MINOR_VE
 # 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  11)
+set(TAGLIB_SOVERSION_CURRENT  14)
 set(TAGLIB_SOVERSION_REVISION 0)
-set(TAGLIB_SOVERSION_AGE      10)
+set(TAGLIB_SOVERSION_AGE      13)
 
 math(EXPR TAGLIB_SOVERSION_MAJOR "${TAGLIB_SOVERSION_CURRENT} - ${TAGLIB_SOVERSION_AGE}")
 math(EXPR TAGLIB_SOVERSION_MINOR "${TAGLIB_SOVERSION_AGE}")
@@ -55,8 +66,15 @@ math(EXPR TAGLIB_SOVERSION_PATCH "${TAGLIB_SOVERSION_REVISION}")
 
 include(ConfigureChecks.cmake)
 
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/taglib-config.cmake ${CMAKE_CURRENT_BINARY_DIR}/taglib-config )
-install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/taglib-config DESTINATION ${BIN_INSTALL_DIR})
+if(NOT WIN32)
+  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/taglib-config.cmake ${CMAKE_CURRENT_BINARY_DIR}/taglib-config )
+  install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/taglib-config DESTINATION ${BIN_INSTALL_DIR})
+endif()
+
+if(WIN32)
+  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/taglib-config.cmd.cmake ${CMAKE_CURRENT_BINARY_DIR}/taglib-config.cmd )
+  install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/taglib-config.cmd DESTINATION ${BIN_INSTALL_DIR})
+endif()
 
 if(NOT WIN32 AND NOT BUILD_FRAMEWORK)
   configure_file(${CMAKE_CURRENT_SOURCE_DIR}/taglib.pc.cmake ${CMAKE_CURRENT_BINARY_DIR}/taglib.pc )
@@ -64,20 +82,28 @@ if(NOT WIN32 AND NOT BUILD_FRAMEWORK)
 endif()
 
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
-configure_file(config-taglib.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config.h)
+configure_file(config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config.h)
 
 if(WITH_ASF)
-    set(TAGLIB_WITH_ASF TRUE)
+  set(TAGLIB_WITH_ASF TRUE)
 endif()
 if(WITH_MP4)
-    set(TAGLIB_WITH_MP4 TRUE)
+  set(TAGLIB_WITH_MP4 TRUE)
+endif()
+
+option(TRACE_IN_RELEASE "Output debug messages even in release mode"  OFF)
+if(TRACE_IN_RELEASE)
+  set(TRACE_IN_RELEASE TRUE)
 endif()
 
 configure_file(taglib/taglib_config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/taglib_config.h)
 
 add_subdirectory(taglib) 
 add_subdirectory(bindings)
-add_subdirectory(tests)
+if(BUILD_TESTS)
+    enable_testing()
+    add_subdirectory(tests)
+endif(BUILD_TESTS)
 add_subdirectory(examples)
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.cmake ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)

ConfigureChecks.cmake

@@ -5,19 +5,222 @@ include(CheckFunctionExists)
 include(CheckLibraryExists)
 include(CheckTypeSize)
 include(CheckCXXSourceCompiles)
+include(TestBigEndian)
+
+# Check if the size of integral types are suitable.
+
+check_type_size("short" SIZEOF_SHORT)
+if(NOT ${SIZEOF_SHORT} EQUAL 2)
+  MESSAGE(FATAL_ERROR "TagLib requires that short is 16-bit wide.")
+endif()
+
+check_type_size("int" SIZEOF_INT)
+if(NOT ${SIZEOF_INT} EQUAL 4)
+  MESSAGE(FATAL_ERROR "TagLib requires that int is 32-bit wide.")
+endif()
+
+check_type_size("long long" SIZEOF_LONGLONG)
+if(NOT ${SIZEOF_LONGLONG} EQUAL 8)
+  MESSAGE(FATAL_ERROR "TagLib requires that long long is 64-bit wide.")
+endif()
+
+check_type_size("wchar_t" SIZEOF_WCHAR_T)
+if(${SIZEOF_WCHAR_T} LESS 2)
+  MESSAGE(FATAL_ERROR "TagLib requires that wchar_t is sufficient to store a UTF-16 char.")
+endif()
+
+# Determine the CPU byte order.
+
+test_big_endian(IS_BIG_ENDIAN)
+
+if(NOT IS_BIG_ENDIAN)
+  set(SYSTEM_BYTEORDER 1)
+else()
+  set(SYSTEM_BYTEORDER 2)
+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)
+
+if(NOT HAVE_STD_ATOMIC)
+  check_cxx_source_compiles("
+    #include <boost/atomic.hpp>
+    int main() { 
+      boost::atomic<unsigned int> x(1);
+      x.fetch_add(1);
+      x.fetch_sub(1);
+      return 0; 
+    }
+  " HAVE_BOOST_ATOMIC)
+
+  if(NOT HAVE_BOOST_ATOMIC)
+    check_cxx_source_compiles("
+      int main() { 
+        volatile int x;
+        __sync_add_and_fetch(&x, 1);
+        int y = __sync_sub_and_fetch(&x, 1);
+        return 0; 
+      }
+    " HAVE_GCC_ATOMIC)
+
+    if(NOT HAVE_GCC_ATOMIC)
+      check_cxx_source_compiles("
+        #include <libkern/OSAtomic.h>
+        int main() { 
+          volatile int32_t x;
+          OSAtomicIncrement32Barrier(&x);
+          int32_t y = OSAtomicDecrement32Barrier(&x);
+          return 0; 
+        }
+      " HAVE_MAC_ATOMIC)
+
+      if(NOT HAVE_MAC_ATOMIC)
+        check_cxx_source_compiles("
+          #include <windows.h>
+          int main() { 
+            volatile LONG x;
+            InterlockedIncrement(&x);
+            LONG y = InterlockedDecrement(&x);
+            return 0; 
+          }
+        " HAVE_WIN_ATOMIC)
+
+        if(NOT HAVE_WIN_ATOMIC)
+          check_cxx_source_compiles("
+            #include <ia64intrin.h>
+            int main() { 
+              volatile int x;
+              __sync_add_and_fetch(&x, 1);
+              int y = __sync_sub_and_fetch(&x, 1);
+              return 0; 
+            }
+          " HAVE_IA64_ATOMIC)
+        endif()
+      endif()
+    endif()
+  endif()
+endif()
+
+# Determine which kind of byte swap functions your compiler supports.
+
+# GCC's __builtin_bswap* should be checked individually 
+# because some of them can be missing depends on the GCC version.
+check_cxx_source_compiles("
+  int main() {
+    __builtin_bswap16(0);
+    return 0; 
+  }
+" HAVE_GCC_BYTESWAP_16)
+
+check_cxx_source_compiles("
+  int main() {
+    __builtin_bswap32(0);
+    return 0; 
+  }
+" HAVE_GCC_BYTESWAP_32)
+
+check_cxx_source_compiles("
+  int main() {
+    __builtin_bswap64(0);
+    return 0; 
+  }
+" HAVE_GCC_BYTESWAP_64)
+
+if(NOT HAVE_GCC_BYTESWAP_16 OR NOT HAVE_GCC_BYTESWAP_32 OR NOT HAVE_GCC_BYTESWAP_64)
+  check_cxx_source_compiles("
+    #include <byteswap.h>
+    int main() {
+      __bswap_16(0);
+      __bswap_32(0);
+      __bswap_64(0);
+      return 0; 
+    }
+  " HAVE_GLIBC_BYTESWAP)
+
+  if(NOT HAVE_GLIBC_BYTESWAP)
+    check_cxx_source_compiles("
+      #include <stdlib.h>
+      int main() {
+        _byteswap_ushort(0);
+        _byteswap_ulong(0);
+        _byteswap_uint64(0);
+        return 0; 
+      }
+    " HAVE_MSC_BYTESWAP)
+
+    if(NOT HAVE_MSC_BYTESWAP)
+      check_cxx_source_compiles("
+        #include <libkern/OSByteOrder.h>
+        int main() {
+          OSSwapInt16(0);
+          OSSwapInt32(0);
+          OSSwapInt64(0);
+          return 0; 
+        }
+      " HAVE_MAC_BYTESWAP)
+
+      if(NOT HAVE_MAC_BYTESWAP)
+        check_cxx_source_compiles("
+          #include <sys/endian.h>
+          int main() {
+            swap16(0);
+            swap32(0);
+            swap64(0);
+            return 0; 
+          }
+        " HAVE_OPENBSD_BYTESWAP)
+      endif()
+    endif()
+  endif()
+endif()
+
+# Determine whether your compiler supports some safer version of sprintf.
+
+check_cxx_source_compiles("
+  #include <cstdio>
+  int main() { char buf[20]; snprintf(buf, 20, \"%d\", 1); return 0; }
+" HAVE_SNPRINTF)
+
+if(NOT HAVE_SNPRINTF)
+  check_cxx_source_compiles("
+    #include <cstdio>
+    int main() { char buf[20]; sprintf_s(buf, \"%d\", 1);  return 0; }
+  " HAVE_SPRINTF_S)
+endif()
+
+# Determine whether your compiler supports codecvt.
+
+check_cxx_source_compiles("
+  #include <codecvt>
+  int main() { 
+    std::codecvt_utf8_utf16<wchar_t> x; 
+    return 0; 
+  }
+" HAVE_STD_CODECVT)
+
+# Check for libz using the cmake supplied FindZLIB.cmake
 
-# check for libz using the cmake supplied FindZLIB.cmake
 find_package(ZLIB)
 if(ZLIB_FOUND)
-	set(HAVE_ZLIB 1)
+  set(HAVE_ZLIB 1)
 else()
-	set(HAVE_ZLIB 0)
+  set(HAVE_ZLIB 0)
 endif()
 
+
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
+
 find_package(CppUnit)
 if(NOT CppUnit_FOUND AND BUILD_TESTS)
-	message(STATUS "CppUnit not found, disabling tests.")
-	set(BUILD_TESTS OFF)
+  message(STATUS "CppUnit not found, disabling tests.")
+  set(BUILD_TESTS OFF)
 endif()
-

INSTALL

@@ -16,8 +16,8 @@ In order to build the included examples, use the BUILD_EXAMPLES option:
 See http://www.cmake.org/cmake/help/runningcmake.html for generic help on
 running CMake.
 
-Mac OS X Framework
-------------------
+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
@@ -30,14 +30,128 @@ an Universal Binary framework with Mac OS X 10.4 as the deployment target:
     -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;i368;x86_64"
+    -DCMAKE_OSX_ARCHITECTURES="ppc;i386;x86_64"
+
+For a 10.6 Snow Leopard static library with both 32-bit and 64-bit code, use:
+
+  cmake -DCMAKE_BUILD_TYPE=Release \
+    -DCMAKE_OSX_DEPLOYMENT_TARGET=10.6 \
+    -DCMAKE_OSX_ARCHITECTURES="i386;x86_64" \
+    -DENABLE_STATIC=ON \
+    -DCMAKE_INSTALL_PREFIX="<folder you want to build to>"
+
+After 'make', and 'make install', add libtag.a to your XCode project, and add
+the include folder to the project's User Header Search Paths.
+
+Windows
+-------
+
+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.
+  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 enable the following two options with CMake.
+  -DENABLE_STATIC=ON -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. The test suite has a custom target
-in the build system, so you can run the tests using make:
+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,9 +1,73 @@
-TagLib 1.8 (In Development)
+TagLib 1.9 (Oct 6, 2013)
+==========================
+
+ * Added support for the Ogg Opus file format.
+ * Added support for INFO tags in WAV files.
+ * Changed FileStream to use Windows file API.
+ * Included taglib-config.cmd script for Windows.
+ * New ID3v1::Tag methods for working directly with genre numbers.
+ * New MPEG::File methods for checking which tags are saved in the file.
+ * Added support for the PropertyMap API to ASF and MP4 files.
+ * Added MusicBrainz identifiers to the PropertyMap API.
+ * Allowed reading of MP4 cover art without an explicitly specified format.
+ * Better parsing of corrupted FLAC files.
+ * Fixed saving of PropertyMap comments without description into ID3v2 tags.
+ * Fixed crash when parsing certain XM files.
+ * Fixed compilation of unit test with clang.
+ * Better handling of files that can't be open or have read-only permissions.
+ * Improved atomic reference counting.
+ * New hookable API for debug messages.
+ * More complete Windows install instructions.
+ * Many smaller bug fixes and performance improvements.
+
+TagLib 1.8 (Sep 6, 2012)
+========================
+
+1.8:
+
+ * Added support for OWNE ID3 frames.
+ * Changed key validation in the new PropertyMap API.
+ * ID3v1::Tag::setStringHandler will no londer delete the previous handler,
+   the caller is responsible for this.
+ * File objects will also no longer delete the passed IOStream objects. It
+   should be done in the caller code after the File object is no longer
+   used.
+ * Added ID3v2::Tag::setLatin1StringHandler for custom handling of
+   latin1-encoded text in ID3v2 frames.
+ * Fixed validation of ID3v2 frame IDs (IDs with '0' were ignored).
+
+1.8 BETA:
+
+ * New API for accessing tags by name.
+ * New abstract I/O stream layer to allow custom I/O handlers.
+ * Support for writing ID3v2.3 tags.
+ * Support for various module file formats (MOD, S3M, IT, XM).
+ * Support for MP4 and ASF is now enabled by default.
+ * Started using atomic int operations for reference counting.
+ * Added methods for checking if WMA and MP4 files are DRM-protected.
+ * Added taglib_free to the C bindings.
+ * New method to allow removing pictures from FLAC files.
+ * Support for reading audio properties from ALAC and Musepack SV8 files.
+ * Added replay-gain information to Musepack audio properties.
+ * Support for APEv2 binary tags.
+ * Many AudioProperties subclasses now provide information about the total number of samples.
+ * Various small bug fixes.
+
+TagLib 1.7.2 (Apr 20, 2012)
 ===========================
 
- * Support for writing ID3v2.3 tags.
- * Added methods for checking if WMA and MP4 files are DRM-protected.
- * Started using atomic int operations for reference counting.
+ * Fixed division by zero while parsing corrupted MP4 files (CVE-2012-2396).
+ * Fixed compilation on Haiku.
+
+TagLib 1.7.1 (Mar 17, 2012)
+===========================
+
+ * Improved parsing of corrupted WMA, RIFF and OGG files.
+ * Fixed a memory leak in the WMA parser.
+ * Fixed a memory leak in the FLAC parser.
+ * Fixed a possible division by zero in the APE parser.
+ * Added detection of TTA2 files.
+ * Fixed saving of multiple identically named tags to Vorbis Comments.
 
 TagLib 1.7 (Mar 11, 2011)
 =========================

bindings/c/tag_c.cpp

@@ -19,10 +19,6 @@
  *   USA                                                                   *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
 #include <stdlib.h>
 #include <fileref.h>
 #include <tfile.h>
@@ -58,6 +54,11 @@ void taglib_set_string_management_enabled(BOOL management)
   stringManagementEnabled = bool(management);
 }
 
+void taglib_free(void* pointer)
+{
+  free(pointer);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // TagLib::File wrapper
 ////////////////////////////////////////////////////////////////////////////////
@@ -104,7 +105,7 @@ void taglib_file_free(TagLib_File *file)
 
 BOOL taglib_file_is_valid(const TagLib_File *file)
 {
-	return reinterpret_cast<const File *>(file)->isValid();
+  return reinterpret_cast<const File *>(file)->isValid();
 }
 
 TagLib_Tag *taglib_file_tag(const TagLib_File *file)

bindings/c/tag_c.h

@@ -29,7 +29,9 @@
 extern "C" {
 #endif
 
-#if defined(_WIN32) || defined(_WIN64)
+#if defined(TAGLIB_STATIC)
+#define TAGLIB_C_EXPORT
+#elif defined(_WIN32) || defined(_WIN64)
 #ifdef MAKE_TAGLIB_C_LIB
 #define TAGLIB_C_EXPORT __declspec(dllexport)
 #else
@@ -79,6 +81,11 @@ TAGLIB_C_EXPORT void taglib_set_strings_unicode(BOOL unicode);
  */
 TAGLIB_C_EXPORT void taglib_set_string_management_enabled(BOOL management);
 
+/*!
+ * Explicitly free a string returned from TagLib
+ */
+TAGLIB_C_EXPORT void taglib_free(void* pointer);
+
 /*******************************************************************************
  * File API
  ******************************************************************************/
@@ -99,7 +106,7 @@ typedef enum {
 /*!
  * Creates a TagLib file based on \a filename.  TagLib will try to guess the file
  * type.
- * 
+ *
  * \returns NULL if the file type cannot be determined or the file cannot
  * be opened.
  */

config-taglib.h.cmake

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

config.h.cmake

@@ -0,0 +1,37 @@
+/* config.h. Generated by cmake from config.h.cmake */
+
+/* Indicates the byte order of your target system */
+/* 1 if little-endian, 2 if big-endian. */
+#cmakedefine   SYSTEM_BYTEORDER ${SYSTEM_BYTEORDER}
+
+/* Defined if your compiler supports some byte swap functions */
+#cmakedefine   HAVE_GCC_BYTESWAP_16 1
+#cmakedefine   HAVE_GCC_BYTESWAP_32 1
+#cmakedefine   HAVE_GCC_BYTESWAP_64 1
+#cmakedefine   HAVE_GLIBC_BYTESWAP 1
+#cmakedefine   HAVE_MSC_BYTESWAP 1
+#cmakedefine   HAVE_MAC_BYTESWAP 1
+#cmakedefine   HAVE_OPENBSD_BYTESWAP 1
+
+/* Defined if your compiler supports codecvt */
+#cmakedefine   HAVE_STD_CODECVT 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
+#cmakedefine   HAVE_IA64_ATOMIC 1
+
+/* Defined if your compiler supports some safer version of sprintf */
+#cmakedefine   HAVE_SNPRINTF 1
+#cmakedefine   HAVE_SPRINTF_S 1
+
+/* Defined if you have libz */
+#cmakedefine   HAVE_ZLIB 1
+
+/* Indicates whether debug messages are shown even in release mode */
+#cmakedefine   TRACE_IN_RELEASE 1
+
+#cmakedefine TESTS_DIR "@TESTS_DIR@"

examples/framelist.cpp

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

examples/tagreader.cpp

@@ -23,10 +23,12 @@
  */
 
 #include <iostream>
+#include <iomanip>
 #include <stdio.h>
 
 #include <fileref.h>
 #include <tag.h>
+#include <tpropertymap.h>
 
 using namespace std;
 
@@ -49,7 +51,7 @@ int main(int argc, char *argv[])
 
       TagLib::Tag *tag = f.tag();
 
-      cout << "-- TAG --" << endl;
+      cout << "-- TAG (basic) --" << endl;
       cout << "title   - \"" << tag->title()   << "\"" << endl;
       cout << "artist  - \"" << tag->artist()  << "\"" << endl;
       cout << "album   - \"" << tag->album()   << "\"" << endl;
@@ -57,6 +59,23 @@ int main(int argc, char *argv[])
       cout << "comment - \"" << tag->comment() << "\"" << endl;
       cout << "track   - \"" << tag->track()   << "\"" << endl;
       cout << "genre   - \"" << tag->genre()   << "\"" << endl;
+
+      TagLib::PropertyMap tags = f.file()->properties();
+
+      unsigned int longest = 0;
+      for(TagLib::PropertyMap::ConstIterator i = tags.begin(); i != tags.end(); ++i) {
+        if (i->first.size() > longest) {
+          longest = i->first.size();
+        }
+      }
+
+      cout << "-- TAG (properties) --" << endl;
+      for(TagLib::PropertyMap::ConstIterator i = tags.begin(); i != tags.end(); ++i) {
+        for(TagLib::StringList::ConstIterator j = i->second.begin(); j != i->second.end(); ++j) {
+          cout << left << std::setw(longest) << i->first << " - " << '"' << *j << '"' << endl;
+        }
+      }
+
     }
 
     if(!f.isNull() && f.audioProperties()) {

taglib-config.cmd.cmake

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

taglib/CMakeLists.txt

@@ -10,6 +10,7 @@ include_directories(
   ${CMAKE_CURRENT_SOURCE_DIR}/mp4
   ${CMAKE_CURRENT_SOURCE_DIR}/ogg/vorbis
   ${CMAKE_CURRENT_SOURCE_DIR}/ogg/speex
+  ${CMAKE_CURRENT_SOURCE_DIR}/ogg/opus
   ${CMAKE_CURRENT_SOURCE_DIR}/mpeg/id3v2
   ${CMAKE_CURRENT_SOURCE_DIR}/mpeg/id3v2/frames
   ${CMAKE_CURRENT_SOURCE_DIR}/mpeg/id3v1
@@ -48,6 +49,9 @@ set(tag_HDRS
   toolkit/tfilestream.h
   toolkit/tmap.h
   toolkit/tmap.tcc
+  toolkit/tpropertymap.h
+  toolkit/trefcounter.h
+  toolkit/tdebuglistener.h
   mpeg/mpegfile.h
   mpeg/mpegproperties.h
   mpeg/mpegheader.h
@@ -64,6 +68,7 @@ set(tag_HDRS
   mpeg/id3v2/frames/attachedpictureframe.h
   mpeg/id3v2/frames/commentsframe.h
   mpeg/id3v2/frames/generalencapsulatedobjectframe.h
+  mpeg/id3v2/frames/ownershipframe.h
   mpeg/id3v2/frames/popularimeterframe.h
   mpeg/id3v2/frames/privateframe.h
   mpeg/id3v2/frames/relativevolumeframe.h
@@ -81,6 +86,8 @@ set(tag_HDRS
   ogg/flac/oggflacfile.h
   ogg/speex/speexfile.h
   ogg/speex/speexproperties.h
+  ogg/opus/opusfile.h
+  ogg/opus/opusproperties.h
   flac/flacfile.h
   flac/flacpicture.h
   flac/flacproperties.h
@@ -101,6 +108,7 @@ set(tag_HDRS
   riff/aiff/aiffproperties.h
   riff/wav/wavfile.h
   riff/wav/wavproperties.h
+  riff/wav/infotag.h
   asf/asffile.h
   asf/asfproperties.h
   asf/asftag.h
@@ -150,6 +158,7 @@ set(frames_SRCS
   mpeg/id3v2/frames/attachedpictureframe.cpp
   mpeg/id3v2/frames/commentsframe.cpp
   mpeg/id3v2/frames/generalencapsulatedobjectframe.cpp
+  mpeg/id3v2/frames/ownershipframe.cpp
   mpeg/id3v2/frames/popularimeterframe.cpp
   mpeg/id3v2/frames/privateframe.cpp
   mpeg/id3v2/frames/relativevolumeframe.cpp
@@ -216,6 +225,11 @@ set(speex_SRCS
   ogg/speex/speexproperties.cpp
 )
 
+set(opus_SRCS
+  ogg/opus/opusfile.cpp
+  ogg/opus/opusproperties.cpp
+)
+
 set(trueaudio_SRCS
   trueaudio/trueaudiofile.cpp
   trueaudio/trueaudioproperties.cpp
@@ -241,6 +255,7 @@ set(aiff_SRCS
 set(wav_SRCS
   riff/wav/wavfile.cpp
   riff/wav/wavproperties.cpp
+  riff/wav/infotag.cpp
 )
 
 set(mod_SRCS
@@ -275,6 +290,9 @@ set(toolkit_SRCS
   toolkit/tfile.cpp
   toolkit/tfilestream.cpp
   toolkit/tdebug.cpp
+  toolkit/tpropertymap.cpp
+  toolkit/trefcounter.cpp
+  toolkit/tdebuglistener.cpp
   toolkit/unicode.cpp
 )
 
@@ -282,7 +300,7 @@ set(tag_LIB_SRCS
   ${mpeg_SRCS} ${id3v1_SRCS} ${id3v2_SRCS} ${frames_SRCS} ${ogg_SRCS}
   ${vorbis_SRCS} ${oggflacs_SRCS} ${mpc_SRCS} ${ape_SRCS} ${toolkit_SRCS} ${flacs_SRCS}
   ${wavpack_SRCS} ${speex_SRCS} ${trueaudio_SRCS} ${riff_SRCS} ${aiff_SRCS} ${wav_SRCS}
-  ${asf_SRCS} ${mp4_SRCS} ${mod_SRCS} ${s3m_SRCS} ${it_SRCS} ${xm_SRCS}
+  ${asf_SRCS} ${mp4_SRCS} ${mod_SRCS} ${s3m_SRCS} ${it_SRCS} ${xm_SRCS} ${opus_SRCS}
   tag.cpp
   tagunion.cpp
   fileref.cpp

taglib/ape/apefile.cpp

@@ -36,6 +36,7 @@
 #include <tdebug.h>
 #include <tagunion.h>
 #include <id3v1tag.h>
+#include <tpropertymap.h>
 
 #include "apefile.h"
 
@@ -46,7 +47,7 @@ using namespace TagLib;
 
 namespace
 {
-  enum { APEIndex, ID3v1Index };
+  enum { ApeAPEIndex = 0, ApeID3v1Index = 1 };
 }
 
 class APE::File::FilePrivate
@@ -89,14 +90,16 @@ APE::File::File(FileName file, bool readProperties,
                 Properties::ReadStyle propertiesStyle) : TagLib::File(file)
 {
   d = new FilePrivate;
-  read(readProperties, propertiesStyle);
+  if(isOpen())
+    read(readProperties, propertiesStyle);
 }
 
 APE::File::File(IOStream *stream, bool readProperties,
                 Properties::ReadStyle propertiesStyle) : TagLib::File(stream)
 {
   d = new FilePrivate;
-  read(readProperties, propertiesStyle);
+  if(isOpen())
+    read(readProperties, propertiesStyle);
 }
 
 APE::File::~File()
@@ -109,6 +112,30 @@ TagLib::Tag *APE::File::tag() const
   return &d->tag;
 }
 
+PropertyMap APE::File::properties() const
+{
+  if(d->hasAPE)
+    return d->tag.access<APE::Tag>(ApeAPEIndex, false)->properties();
+  if(d->hasID3v1)
+    return d->tag.access<ID3v1::Tag>(ApeID3v1Index, false)->properties();
+  return PropertyMap();
+}
+
+void APE::File::removeUnsupportedProperties(const StringList &properties)
+{
+  if(d->hasAPE)
+    d->tag.access<APE::Tag>(ApeAPEIndex, false)->removeUnsupportedProperties(properties);
+  if(d->hasID3v1)
+    d->tag.access<ID3v1::Tag>(ApeID3v1Index, false)->removeUnsupportedProperties(properties);
+}
+
+PropertyMap APE::File::setProperties(const PropertyMap &properties)
+{
+  if(d->hasID3v1)
+    d->tag.access<ID3v1::Tag>(ApeID3v1Index, false)->setProperties(properties);
+  return d->tag.access<APE::Tag>(ApeAPEIndex, true)->setProperties(properties);
+}
+
 APE::Properties *APE::File::audioProperties() const
 {
   return d->properties;
@@ -185,29 +212,39 @@ bool APE::File::save()
 
 ID3v1::Tag *APE::File::ID3v1Tag(bool create)
 {
-  return d->tag.access<ID3v1::Tag>(ID3v1Index, create);
+  return d->tag.access<ID3v1::Tag>(ApeID3v1Index, create);
 }
 
 APE::Tag *APE::File::APETag(bool create)
 {
-  return d->tag.access<APE::Tag>(APEIndex, create);
+  return d->tag.access<APE::Tag>(ApeAPEIndex, create);
 }
 
 void APE::File::strip(int tags)
 {
   if(tags & ID3v1) {
-    d->tag.set(ID3v1Index, 0);
+    d->tag.set(ApeID3v1Index, 0);
     APETag(true);
   }
 
   if(tags & APE) {
-    d->tag.set(APEIndex, 0);
+    d->tag.set(ApeAPEIndex, 0);
 
     if(!ID3v1Tag())
       APETag(true);
   }
 }
 
+bool APE::File::hasAPETag() const
+{
+  return d->hasAPE;
+}
+
+bool APE::File::hasID3v1Tag() const
+{
+  return d->hasID3v1;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // private members
 ////////////////////////////////////////////////////////////////////////////////
@@ -219,7 +256,7 @@ void APE::File::read(bool readProperties, Properties::ReadStyle /* propertiesSty
   d->ID3v1Location = findID3v1();
 
   if(d->ID3v1Location >= 0) {
-    d->tag.set(ID3v1Index, new ID3v1::Tag(this, d->ID3v1Location));
+    d->tag.set(ApeID3v1Index, new ID3v1::Tag(this, d->ID3v1Location));
     d->hasID3v1 = true;
   }
 
@@ -228,7 +265,7 @@ void APE::File::read(bool readProperties, Properties::ReadStyle /* propertiesSty
   d->APELocation = findAPE();
 
   if(d->APELocation >= 0) {
-    d->tag.set(APEIndex, new APE::Tag(this, d->APELocation));
+    d->tag.set(ApeAPEIndex, new APE::Tag(this, d->APELocation));
     d->APESize = APETag()->footer()->completeTagSize();
     d->APELocation = d->APELocation + APETag()->footer()->size() - d->APESize;
     d->hasAPE = true;

taglib/ape/apefile.h

@@ -59,7 +59,7 @@ namespace TagLib {
     //! An implementation of TagLib::File with APE specific methods
 
     /*!
-     * This implements and provides an interface APE WavPack files to the
+     * This implements and provides an interface for APE files to the
      * TagLib::Tag and TagLib::AudioProperties interfaces by way of implementing
      * the abstract TagLib::File API as well as providing some additional
      * information specific to APE files.
@@ -84,17 +84,22 @@ namespace TagLib {
       };
 
       /*!
-       * Contructs an WavPack file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
+       * Constructs an APE file from \a file.  If \a readProperties is true the
+       * file's audio properties will also be read.
+       *
+       * \note In the current implementation, \a propertiesStyle is ignored.
        */
       File(FileName file, bool readProperties = true,
            Properties::ReadStyle propertiesStyle = Properties::Average);
 
       /*!
-       * Contructs an WavPack file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
+       * Constructs an APE file from \a stream.  If \a readProperties is true the
+       * file's audio properties will also be read.
+       *
+       * \note TagLib will *not* take ownership of the stream, the caller is
+       * responsible for deleting it after the File object.
+       *
+       * \note In the current implementation, \a propertiesStyle is ignored.
        */
       File(IOStream *stream, bool readProperties = true,
            Properties::ReadStyle propertiesStyle = Properties::Average);
@@ -110,6 +115,26 @@ namespace TagLib {
        */
       virtual TagLib::Tag *tag() const;
 
+      /*!
+       * Implements the unified property interface -- export function.
+       * If the file contains both an APE and an ID3v1 tag, only APE
+       * will be converted to the PropertyMap.
+       */
+      PropertyMap properties() const;
+
+      /*!
+       * Removes unsupported properties. Forwards to the actual Tag's
+       * removeUnsupportedProperties() function.
+       */
+      void removeUnsupportedProperties(const StringList &properties);
+
+      /*!
+       * Implements the unified property interface -- import function.
+       * Creates an APEv2 tag if necessary. A pontentially existing ID3v1
+       * tag will be updated as well.
+       */
+      PropertyMap setProperties(const PropertyMap &);
+
       /*!
        * Returns the APE::Properties for this file.  If no audio properties
        * were read then this will return a null pointer.
@@ -127,27 +152,38 @@ namespace TagLib {
       /*!
        * Returns a pointer to the ID3v1 tag of the file.
        *
-       * If \a create is false (the default) this will return a null pointer
+       * If \a create is false (the default) this may return a null pointer
        * if there is no valid ID3v1 tag.  If \a create is true it will create
-       * an ID3v1 tag if one does not exist. If there is already an APE tag, the
-       * new ID3v1 tag will be placed after it.
+       * an ID3v1 tag if one does not exist and returns a valid pointer.
        *
-       * \note The Tag <b>is still</b> owned by the APE::File and should not be
+       * \note This may return a valid pointer regardless of whether or not the 
+       * file on disk has an ID3v1 tag.  Use hasID3v1Tag() to check if the file 
+       * on disk actually has an ID3v1 tag.
+       *
+       * \note The Tag <b>is still</b> owned by the MPEG::File and should not be
        * deleted by the user.  It will be deleted when the file (object) is
        * destroyed.
+       *
+       * \see hasID3v1Tag()
        */
       ID3v1::Tag *ID3v1Tag(bool create = false);
 
       /*!
        * Returns a pointer to the APE tag of the file.
        *
-       * If \a create is false (the default) this will return a null pointer
+       * If \a create is false (the default) this may return a null pointer
        * if there is no valid APE tag.  If \a create is true it will create
-       * a APE tag if one does not exist.
+       * an APE tag if one does not exist and returns a valid pointer.
        *
-       * \note The Tag <b>is still</b> owned by the APE::File and should not be
+       * \note This may return a valid pointer regardless of whether or not the 
+       * file on disk has an APE tag.  Use hasAPETag() to check if the file 
+       * on disk actually has an APE tag.
+       *
+       * \note The Tag <b>is still</b> owned by the MPEG::File and should not be
        * deleted by the user.  It will be deleted when the file (object) is
        * destroyed.
+       *
+       * \see hasAPETag()
        */
       APE::Tag *APETag(bool create = false);
 
@@ -161,6 +197,20 @@ namespace TagLib {
        */
       void strip(int tags = AllTags);
 
+      /*!
+       * Returns whether or not the file on disk actually has an APE tag.
+       *
+       * \see APETag()
+       */
+      bool hasAPETag() const;
+
+      /*!
+       * Returns whether or not the file on disk actually has an ID3v1 tag.
+       *
+       * \see ID3v1Tag()
+       */
+      bool hasID3v1Tag() const;
+
     private:
       File(const File &);
       File &operator=(const File &);

taglib/ape/apefooter.cpp

@@ -24,7 +24,7 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#include <ostream>
+#include <iostream>
 #include <bitset>
 
 #include <tstring.h>
@@ -35,7 +35,7 @@
 using namespace TagLib;
 using namespace APE;
 
-class Footer::FooterPrivate
+class APE::Footer::FooterPrivate
 {
 public:
   FooterPrivate() : version(0),
@@ -64,12 +64,12 @@ public:
 // static members
 ////////////////////////////////////////////////////////////////////////////////
 
-TagLib::uint Footer::size()
+TagLib::uint APE::Footer::size()
 {
   return FooterPrivate::size;
 }
 
-ByteVector Footer::fileIdentifier()
+ByteVector APE::Footer::fileIdentifier()
 {
   return ByteVector::fromCString("APETAGEX");
 }
@@ -78,63 +78,63 @@ ByteVector Footer::fileIdentifier()
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-Footer::Footer()
+APE::Footer::Footer()
 {
   d = new FooterPrivate;
 }
 
-Footer::Footer(const ByteVector &data)
+APE::Footer::Footer(const ByteVector &data)
 {
   d = new FooterPrivate;
   parse(data);
 }
 
-Footer::~Footer()
+APE::Footer::~Footer()
 {
   delete d;
 }
 
-TagLib::uint Footer::version() const
+TagLib::uint APE::Footer::version() const
 {
   return d->version;
 }
 
-bool Footer::headerPresent() const
+bool APE::Footer::headerPresent() const
 {
   return d->headerPresent;
 }
 
-bool Footer::footerPresent() const
+bool APE::Footer::footerPresent() const
 {
   return d->footerPresent;
 }
 
-bool Footer::isHeader() const
+bool APE::Footer::isHeader() const
 {
   return d->isHeader;
 }
 
-void Footer::setHeaderPresent(bool b) const
+void APE::Footer::setHeaderPresent(bool b) const
 {
   d->headerPresent = b;
 }
 
-TagLib::uint Footer::itemCount() const
+TagLib::uint APE::Footer::itemCount() const
 {
   return d->itemCount;
 }
 
-void Footer::setItemCount(uint s)
+void APE::Footer::setItemCount(uint s)
 {
   d->itemCount = s;
 }
 
-TagLib::uint Footer::tagSize() const
+TagLib::uint APE::Footer::tagSize() const
 {
   return d->tagSize;
 }
 
-TagLib::uint Footer::completeTagSize() const
+TagLib::uint APE::Footer::completeTagSize() const
 {
   if(d->headerPresent)
     return d->tagSize + d->size;
@@ -142,22 +142,22 @@ TagLib::uint Footer::completeTagSize() const
     return d->tagSize;
 }
 
-void Footer::setTagSize(uint s)
+void APE::Footer::setTagSize(uint s)
 {
   d->tagSize = s;
 }
 
-void Footer::setData(const ByteVector &data)
+void APE::Footer::setData(const ByteVector &data)
 {
   parse(data);
 }
 
-ByteVector Footer::renderFooter() const
+ByteVector APE::Footer::renderFooter() const
 {
     return render(false);
 }
 
-ByteVector Footer::renderHeader() const
+ByteVector APE::Footer::renderHeader() const
 {
     if (!d->headerPresent) return ByteVector();
 
@@ -168,7 +168,7 @@ ByteVector Footer::renderHeader() const
 // protected members
 ////////////////////////////////////////////////////////////////////////////////
 
-void Footer::parse(const ByteVector &data)
+void APE::Footer::parse(const ByteVector &data)
 {
   if(data.size() < size())
     return;
@@ -177,19 +177,19 @@ void Footer::parse(const ByteVector &data)
 
   // Read the version number
 
-  d->version = data.mid(8, 4).toUInt(false);
+  d->version = data.toUInt(8, false);
 
   // Read the tag size
 
-  d->tagSize = data.mid(12, 4).toUInt(false);
+  d->tagSize = data.toUInt(12, false);
 
   // Read the item count
 
-  d->itemCount = data.mid(16, 4).toUInt(false);
+  d->itemCount = data.toUInt(16, false);
 
   // Read the flags
 
-  std::bitset<32> flags(TAGLIB_CONSTRUCT_BITSET(data.mid(20, 4).toUInt(false)));
+  std::bitset<32> flags(TAGLIB_CONSTRUCT_BITSET(data.toUInt(20, false)));
 
   d->headerPresent = flags[31];
   d->footerPresent = !flags[30];
@@ -197,7 +197,7 @@ void Footer::parse(const ByteVector &data)
 
 }
 
-ByteVector Footer::render(bool isHeader) const
+ByteVector APE::Footer::render(bool isHeader) const
 {
   ByteVector v;
 

taglib/ape/apeitem.cpp

@@ -62,6 +62,18 @@ APE::Item::Item(const String &key, const StringList &values)
   d->text = values;
 }
 
+APE::Item::Item(const String &key, const ByteVector &value, bool binary)
+{
+  d = new ItemPrivate;
+  d->key = key;
+  if(binary) {
+    d->type = Binary;
+    d->value = value;
+  }
+  else
+    d->text.append(value);
+}
+
 APE::Item::Item(const Item &item)
 {
   d = new ItemPrivate(*item.d);
@@ -104,6 +116,18 @@ String APE::Item::key() const
   return d->key;
 }
 
+ByteVector APE::Item::binaryData() const
+{
+  return d->value;
+}
+
+void APE::Item::setBinaryData(const ByteVector &value)
+{
+  d->type = Binary;
+  d->value = value;
+  d->text.clear();
+}
+
 ByteVector APE::Item::value() const
 {
   // This seems incorrect as it won't be actually rendering the value to keep it
@@ -114,32 +138,59 @@ ByteVector APE::Item::value() const
 
 void APE::Item::setKey(const String &key)
 {
-    d->key = key;
+  d->key = key;
 }
 
 void APE::Item::setValue(const String &value)
 {
-    d->text = value;
+  d->type = Text;
+  d->text = value;
+  d->value.clear();
 }
 
 void APE::Item::setValues(const StringList &value)
 {
-    d->text = value;
+  d->type = Text;
+  d->text = value;
+  d->value.clear();
 }
 
 void APE::Item::appendValue(const String &value)
 {
-    d->text.append(value);
+  d->type = Text;
+  d->text.append(value);
+  d->value.clear();
 }
 
 void APE::Item::appendValues(const StringList &values)
 {
-    d->text.append(values);
+  d->type = Text;
+  d->text.append(values);
+  d->value.clear();
 }
 
 int APE::Item::size() const
 {
-  return 8 + d->key.size() + 1 + d->value.size();
+  // SFB: Why is d->key.size() used when size() returns the length in UniChars and not UTF-8?
+  int result = 8 + d->key.size() /* d->key.data(String::UTF8).size() */ + 1;
+  switch (d->type) {
+    case Text:
+      if(d->text.size()) {
+        StringList::ConstIterator it = d->text.begin();
+
+        result += it->data(String::UTF8).size();
+        it++;
+        for(; it != d->text.end(); ++it)
+          result += 1 + it->data(String::UTF8).size();
+      }
+      break;
+
+    case Binary:
+    case Locator:
+      result += d->value.size();
+      break;
+  }
+  return result;
 }
 
 StringList APE::Item::toStringList() const
@@ -154,19 +205,22 @@ StringList APE::Item::values() const
 
 String APE::Item::toString() const
 {
-  return isEmpty() ? String::null : d->text.front();
+  if(d->type == Text && !isEmpty())
+    return d->text.front();
+  else
+    return String::null;
 }
 
 bool APE::Item::isEmpty() const
 {
   switch(d->type) {
     case Text:
-    case Binary:
       if(d->text.isEmpty())
         return true;
       if(d->text.size() == 1 && d->text.front().isEmpty())
         return true;
       return false;
+    case Binary:
     case Locator:
       return d->value.isEmpty();
     default:
@@ -183,18 +237,20 @@ void APE::Item::parse(const ByteVector &data)
     return;
   }
 
-  uint valueLength  = data.mid(0, 4).toUInt(false);
-  uint flags        = data.mid(4, 4).toUInt(false);
+  const uint valueLength  = data.toUInt(0, false);
+  const uint flags        = data.toUInt(4, false);
 
   d->key = String(data.mid(8), String::UTF8);
 
-  d->value = data.mid(8 + d->key.size() + 1, valueLength);
+  const ByteVector value = data.mid(8 + d->key.size() + 1, valueLength);
 
   setReadOnly(flags & 1);
   setType(ItemTypes((flags >> 1) & 3));
 
-  if(int(d->type) < 2)
-    d->text = StringList(ByteVectorList::split(d->value, '\0'), String::UTF8);
+  if(Text == d->type) 
+    d->text = StringList(ByteVectorList::split(value, '\0'), String::UTF8);
+  else
+    d->value = value;
 }
 
 ByteVector APE::Item::render() const

taglib/ape/apeitem.h

@@ -59,16 +59,22 @@ namespace TagLib {
       Item();
 
       /*!
-       * Constructs an item with \a key and \a value.
+       * Constructs a text item with \a key and \a value.
        */
       // BIC: Remove this, StringList has a constructor from a single string
       Item(const String &key, const String &value);
 
       /*!
-       * Constructs an item with \a key and \a values.
+       * Constructs a text item with \a key and \a values.
        */
       Item(const String &key, const StringList &values);
 
+      /*!
+       * Constructs an item with \a key and \a value.
+       * If \a binary is true a Binary item will be created, otherwise \a value will be interpreted as text
+       */
+      Item(const String &key, const ByteVector &value, bool binary);
+
       /*!
        * Construct an item as a copy of \a item.
        */
@@ -91,12 +97,20 @@ namespace TagLib {
 
       /*!
        * Returns the binary value.
-       *
-       * \deprecated This will be removed in the next binary incompatible version
-       * as it is not kept in sync with the things that are set using setValue()
-       * and friends.
+       * If the item type is not \a Binary, always returns an empty ByteVector.
        */
+      ByteVector binaryData() const;
+
+     /*!
+      * Set the binary value to \a value
+      * The item's type will also be set to \a Binary
+      */
+      void setBinaryData(const ByteVector &value);
+
+#ifndef DO_NOT_DOCUMENT
+      /* Remove in next binary incompatible release */
       ByteVector value() const;
+#endif
 
       /*!
        * Sets the key for the item to \a key.
@@ -104,14 +118,14 @@ namespace TagLib {
       void setKey(const String &key);
 
       /*!
-       * Sets the value of the item to \a value and clears any previous contents.
+       * Sets the text value of the item to \a value and clears any previous contents.
        *
        * \see toString()
        */
       void setValue(const String &value);
 
       /*!
-       * Sets the value of the item to the list of values in \a value and clears
+       * Sets the text value of the item to the list of values in \a value and clears
        * any previous contents.
        *
        * \see toStringList()
@@ -119,14 +133,14 @@ namespace TagLib {
       void setValues(const StringList &values);
 
       /*!
-       * Appends \a value to create (or extend) the current list of values.
+       * Appends \a value to create (or extend) the current list of text values.
        *
        * \see toString()
        */
       void appendValue(const String &value);
 
       /*!
-       * Appends \a values to extend the current list of values.
+       * Appends \a values to extend the current list of text values.
        *
        * \see toStringList()
        */
@@ -138,19 +152,20 @@ namespace TagLib {
       int size() const;
 
       /*!
-       * Returns the value as a single string. In case of multiple strings,
-       * the first is returned.
+       * Returns the value as a single string.  In case of multiple strings,
+       * the first is returned.  If the data type is not \a Text, always returns 
+       * an empty String.
        */
       String toString() const;
 
-      /*!
-       * \deprecated
-       * \see values
-       */
+#ifndef DO_NOT_DOCUMENT
+      /* Remove in next binary incompatible release */
       StringList toStringList() const;
+#endif
 
       /*!
-       * Returns the list of values.
+       * Returns the list of text values.  If the data type is not \a Text, always 
+       * returns an empty StringList.
        */
       StringList values() const;
 

taglib/ape/apeproperties.cpp

@@ -46,6 +46,7 @@ public:
     channels(0),
     version(0),
     bitsPerSample(0),
+    sampleFrames(0),
     file(file),
     streamLength(streamLength) {}
 
@@ -55,6 +56,7 @@ public:
   int channels;
   int version;
   int bitsPerSample;
+  uint sampleFrames;
   File *file;
   long streamLength;
 };
@@ -104,6 +106,11 @@ int APE::Properties::bitsPerSample() const
   return d->bitsPerSample;
 }
 
+TagLib::uint APE::Properties::sampleFrames() const
+{
+  return d->sampleFrames;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // private members
 ////////////////////////////////////////////////////////////////////////////////
@@ -118,10 +125,10 @@ void APE::Properties::read()
 
   // Then we read the header common for all versions of APE
   d->file->seek(offset);
-  ByteVector commonHeader=d->file->readBlock(6);
+  ByteVector commonHeader = d->file->readBlock(6);
   if(!commonHeader.startsWith("MAC "))
     return;
-  d->version = commonHeader.mid(4).toUInt(false);
+  d->version = commonHeader.toUShort(4, false);
 
   if(d->version >= 3980) {
     analyzeCurrent();
@@ -137,7 +144,7 @@ long APE::Properties::findDescriptor()
   long ID3v2OriginalSize = 0;
   bool hasID3v2 = false;
   if(ID3v2Location >= 0) {
-    ID3v2::Tag tag(d->file, ID3v2Location, 0);
+    ID3v2::Tag tag(d->file, ID3v2Location);
     ID3v2OriginalSize = tag.header()->completeTagSize();
     if(tag.header()->tagSize() > 0)
       hasID3v2 = true;
@@ -175,7 +182,7 @@ void APE::Properties::analyzeCurrent()
   // Read the descriptor
   d->file->seek(2, File::Current);
   ByteVector descriptor = d->file->readBlock(44);
-  uint descriptorBytes = descriptor.mid(0,4).toUInt(false);
+  const uint descriptorBytes = descriptor.toUInt(0, false);
 
   if ((descriptorBytes - 52) > 0)
     d->file->seek(descriptorBytes - 52, File::Current);
@@ -184,29 +191,29 @@ void APE::Properties::analyzeCurrent()
   ByteVector header = d->file->readBlock(24);
 
   // Get the APE info
-  d->channels = header.mid(18, 2).toShort(false);
-  d->sampleRate = header.mid(20, 4).toUInt(false);
-  d->bitsPerSample = header.mid(16, 2).toShort(false);
+  d->channels      = header.toShort(18, false);
+  d->sampleRate    = header.toUInt(20, false);
+  d->bitsPerSample = header.toShort(16, false);
   //d->compressionLevel =
 
-  uint totalFrames = header.mid(12, 4).toUInt(false);
-  uint blocksPerFrame = header.mid(4, 4).toUInt(false);
-  uint finalFrameBlocks = header.mid(8, 4).toUInt(false);
-  uint totalBlocks = totalFrames > 0 ? (totalFrames -  1) * blocksPerFrame + finalFrameBlocks : 0;
-  d->length = totalBlocks / d->sampleRate;
+  const uint totalFrames      = header.toUInt(12, false);
+  const uint blocksPerFrame   = header.toUInt(4, false);
+  const uint finalFrameBlocks = header.toUInt(8, false);
+  d->sampleFrames = totalFrames > 0 ? (totalFrames -  1) * blocksPerFrame + finalFrameBlocks : 0;
+  d->length = d->sampleRate > 0 ? d->sampleFrames / d->sampleRate : 0;
   d->bitrate = d->length > 0 ? ((d->streamLength * 8L) / d->length) / 1000 : 0;
 }
 
 void APE::Properties::analyzeOld()
 {
   ByteVector header = d->file->readBlock(26);
-  uint totalFrames = header.mid(18, 4).toUInt(false);
+  const uint totalFrames = header.toUInt(18, false);
 
   // Fail on 0 length APE files (catches non-finalized APE files)
   if(totalFrames == 0)
     return;
 
-  short compressionLevel = header.mid(0, 2).toShort(false);
+  const short compressionLevel = header.toShort(0, false);
   uint blocksPerFrame;
   if(d->version >= 3950)
     blocksPerFrame = 73728 * 4;
@@ -214,10 +221,11 @@ void APE::Properties::analyzeOld()
     blocksPerFrame = 73728;
   else
     blocksPerFrame = 9216;
-  d->channels = header.mid(4, 2).toShort(false);
-  d->sampleRate = header.mid(6, 4).toUInt(false);
-  uint finalFrameBlocks = header.mid(22, 4).toUInt(false);
-  uint totalBlocks = totalFrames > 0 ? (totalFrames - 1) * blocksPerFrame + finalFrameBlocks : 0;
+  d->channels   = header.toShort(4, false);
+  d->sampleRate = header.toUInt(6, false);
+  const uint finalFrameBlocks = header.toUInt(22, false);
+  const uint totalBlocks 
+    = totalFrames > 0 ? (totalFrames - 1) * blocksPerFrame + finalFrameBlocks : 0;
   d->length = totalBlocks / d->sampleRate;
   d->bitrate = d->length > 0 ? ((d->streamLength * 8L) / d->length) / 1000 : 0;
 }

taglib/ape/apeproperties.h

@@ -71,6 +71,7 @@ namespace TagLib {
        * Returns number of bits per sample.
        */
       int bitsPerSample() const;
+      uint sampleFrames() const;
 
       /*!
        * Returns APE version.

taglib/ape/apetag.cpp

@@ -34,6 +34,7 @@
 #include <tfile.h>
 #include <tstring.h>
 #include <tmap.h>
+#include <tpropertymap.h>
 
 #include "apetag.h"
 #include "apefooter.h"
@@ -47,7 +48,7 @@ class APE::Tag::TagPrivate
 public:
   TagPrivate() : file(0), footerLocation(-1), tagLength(0) {}
 
-  File *file;
+  TagLib::File *file;
   long footerLocation;
   long tagLength;
 
@@ -65,7 +66,7 @@ APE::Tag::Tag() : TagLib::Tag()
   d = new TagPrivate;
 }
 
-APE::Tag::Tag(File *file, long footerLocation) : TagLib::Tag()
+APE::Tag::Tag(TagLib::File *file, long footerLocation) : TagLib::Tag()
 {
   d = new TagPrivate;
   d->file = file;
@@ -174,6 +175,103 @@ void APE::Tag::setTrack(uint i)
     addValue("TRACK", String::number(i), true);
 }
 
+// conversions of tag keys between what we use in PropertyMap and what's usual
+// for APE tags
+static const TagLib::uint keyConversionsSize = 5; //usual,         APE
+static const char *keyConversions[][2] =  {{"TRACKNUMBER", "TRACK"       },
+                                           {"DATE",        "YEAR"        },
+                                           {"ALBUMARTIST", "ALBUM ARTIST"},
+                                           {"DISCNUMBER",  "DISC"        },
+                                           {"REMIXER",     "MIXARTIST"   }};
+
+PropertyMap APE::Tag::properties() const
+{
+  PropertyMap properties;
+  ItemListMap::ConstIterator it = itemListMap().begin();
+  for(; it != itemListMap().end(); ++it) {
+    String tagName = it->first.upper();
+    // if the item is Binary or Locator, or if the key is an invalid string,
+    // add to unsupportedData
+    if(it->second.type() != Item::Text || tagName.isNull())
+      properties.unsupportedData().append(it->first);
+    else {
+      // Some tags need to be handled specially
+      for(uint i = 0; i < keyConversionsSize; ++i)
+        if(tagName == keyConversions[i][1])
+          tagName = keyConversions[i][0];
+        properties[tagName].append(it->second.toStringList());
+    }
+  }
+  return properties;
+}
+
+void APE::Tag::removeUnsupportedProperties(const StringList &properties)
+{
+  StringList::ConstIterator it = properties.begin();
+  for(; it != properties.end(); ++it)
+    removeItem(*it);
+}
+
+PropertyMap APE::Tag::setProperties(const PropertyMap &origProps)
+{
+  PropertyMap properties(origProps); // make a local copy that can be modified
+
+  // see comment in properties()
+  for(uint i = 0; i < keyConversionsSize; ++i)
+    if(properties.contains(keyConversions[i][0])) {
+      properties.insert(keyConversions[i][1], properties[keyConversions[i][0]]);
+      properties.erase(keyConversions[i][0]);
+    }
+
+  // first check if tags need to be removed completely
+  StringList toRemove;
+  ItemListMap::ConstIterator remIt = itemListMap().begin();
+  for(; remIt != itemListMap().end(); ++remIt) {
+    String key = remIt->first.upper();
+    // only remove if a) key is valid, b) type is text, c) key not contained in new properties
+    if(!key.isNull() && remIt->second.type() == APE::Item::Text && !properties.contains(key))
+      toRemove.append(remIt->first);
+  }
+
+  for (StringList::Iterator removeIt = toRemove.begin(); removeIt != toRemove.end(); removeIt++)
+    removeItem(*removeIt);
+
+  // now sync in the "forward direction"
+  PropertyMap::ConstIterator it = properties.begin();
+  PropertyMap invalid;
+  for(; it != properties.end(); ++it) {
+    const String &tagName = it->first;
+    if(!checkKey(tagName))
+      invalid.insert(it->first, it->second);
+    else if(!(itemListMap().contains(tagName)) || !(itemListMap()[tagName].values() == it->second)) {
+      if(it->second.size() == 0)
+        removeItem(tagName);
+      else {
+        StringList::ConstIterator valueIt = it->second.begin();
+        addValue(tagName, *valueIt, true);
+        ++valueIt;
+        for(; valueIt != it->second.end(); ++valueIt)
+          addValue(tagName, *valueIt, false);
+      }
+    }
+  }
+  return invalid;
+}
+
+bool APE::Tag::checkKey(const String &key)
+{
+  if(key.size() < 2 || key.size() > 16)
+      return false;
+    for(String::ConstIterator it = key.begin(); it != key.end(); it++)
+        // only allow printable ASCII including space (32..127)
+        if (*it < 32 || *it >= 128)
+          return false;
+    String upperKey = key.upper();
+    if (upperKey=="ID3" || upperKey=="TAG" || upperKey=="OGGS" || upperKey=="MP+")
+      return false;
+    return true;
+}
+
 APE::Footer *APE::Tag::footer() const
 {
   return &d->footer;
@@ -195,17 +293,31 @@ void APE::Tag::addValue(const String &key, const String &value, bool replace)
 {
   if(replace)
     removeItem(key);
-  if(!value.isEmpty()) {
-    if(d->itemListMap.contains(key) || !replace)
-      d->itemListMap[key.upper()].appendValue(value);
+  if(!key.isEmpty() && !value.isEmpty()) {
+    if(!replace && d->itemListMap.contains(key)) {
+      // Text items may contain more than one value
+      if(APE::Item::Text == d->itemListMap.begin()->second.type())
+        d->itemListMap[key.upper()].appendValue(value);
+      // Binary or locator items may have only one value
+      else
+        setItem(key, Item(key, value));
+    }
     else
       setItem(key, Item(key, value));
   }
 }
 
+void APE::Tag::setData(const String &key, const ByteVector &value)
+{
+  removeItem(key);
+  if(!key.isEmpty() && !value.isEmpty())
+    setItem(key, Item(key, value, true));
+}
+
 void APE::Tag::setItem(const String &key, const Item &item)
 {
-  d->itemListMap.insert(key.upper(), item);
+  if(!key.isEmpty())
+    d->itemListMap.insert(key.upper(), item);
 }
 
 bool APE::Tag::isEmpty() const

taglib/ape/apetag.h

@@ -103,6 +103,37 @@ namespace TagLib {
       virtual void setYear(uint i);
       virtual void setTrack(uint i);
 
+      /*!
+       * Implements the unified tag dictionary interface -- export function.
+       * APE tags are perfectly compatible with the dictionary interface because they
+       * support both arbitrary tag names and multiple values. Currently only
+       * APE items of type *Text* are handled by the dictionary interface; all *Binary*
+       * and *Locator* items will be put into the unsupportedData list and can be
+       * deleted on request using removeUnsupportedProperties(). The same happens
+       * to Text items if their key is invalid for PropertyMap (which should actually
+       * never happen).
+       *
+       * The only conversion done by this export function is to rename the APE tags
+       * TRACK to TRACKNUMBER, YEAR to DATE, and ALBUM ARTIST to ALBUMARTIST, respectively,
+       * in order to be compliant with the names used in other formats.
+       */
+      PropertyMap properties() const;
+
+      void removeUnsupportedProperties(const StringList &properties);
+
+      /*!
+       * Implements the unified tag dictionary interface -- import function. The same
+       * comments as for the export function apply; additionally note that the APE tag
+       * specification requires keys to have between 2 and 16 printable ASCII characters
+       * with the exception of the fixed strings "ID3", "TAG", "OGGS", and "MP+".
+       */
+      PropertyMap setProperties(const PropertyMap &);
+
+      /*!
+       * Check if the given String is a valid APE tag key.
+       */
+      static bool checkKey(const String&);
+
       /*!
        * Returns a pointer to the tag's footer.
        */
@@ -128,12 +159,19 @@ namespace TagLib {
       void removeItem(const String &key);
 
       /*!
-       * Adds to the item specified by \a key the data \a value.  If \a replace
+       * Adds to the text item specified by \a key the data \a value.  If \a replace
        * is true, then all of the other values on the same key will be removed
-       * first.
+       * first.  If a binary item exists for \a key it will be removed first.
        */
       void addValue(const String &key, const String &value, bool replace = true);
 
+     /*!
+      * Set the binary data for the key specified by \a item to \a value
+      * This will convert the item to type \a Binary if it isn't already and
+      * all of the other values on the same key will be removed.
+      */
+      void setData(const String &key, const ByteVector &value);
+
       /*!
        * Sets the \a key item to the value of \a item. If an item with the \a key is already
        * present, it will be replaced.

taglib/asf/asfattribute.cpp

@@ -23,12 +23,9 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <taglib.h>
 #include <tdebug.h>
+#include "trefcounter.h"
 #include "asfattribute.h"
 #include "asffile.h"
 

taglib/asf/asfattribute.h

@@ -70,7 +70,7 @@ namespace TagLib
       /*!
        * Constructs an attribute with \a key and a BytesType \a value.
        */
-      Attribute(const ByteVector &value);      
+      Attribute(const ByteVector &value);
 
       /*!
        * Constructs an attribute with \a key and a Picture \a value.

taglib/asf/asffile.cpp

@@ -23,12 +23,9 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <tdebug.h>
 #include <tbytevectorlist.h>
+#include <tpropertymap.h>
 #include <tstring.h>
 #include "asffile.h"
 #include "asftag.h"
@@ -142,11 +139,19 @@ class ASF::File::HeaderExtensionObject : public ASF::File::BaseObject
 {
 public:
   List<ASF::File::BaseObject *> objects;
+  ~HeaderExtensionObject();
   ByteVector guid();
   void parse(ASF::File *file, uint size);
   ByteVector render(ASF::File *file);
 };
 
+ASF::File::HeaderExtensionObject::~HeaderExtensionObject()
+{
+  for(unsigned int i = 0; i < objects.size(); i++) {
+    delete objects[i];
+  }
+}
+
 void ASF::File::BaseObject::parse(ASF::File *file, unsigned int size)
 {
   data.clear();
@@ -178,7 +183,8 @@ ByteVector ASF::File::FilePropertiesObject::guid()
 void ASF::File::FilePropertiesObject::parse(ASF::File *file, uint size)
 {
   BaseObject::parse(file, size);
-  file->d->properties->setLength((int)(data.mid(40, 8).toLongLong(false) / 10000000L - data.mid(56, 8).toLongLong(false) / 1000L));
+  file->d->properties->setLength(
+    (int)(data.toLongLong(40, false) / 10000000L - data.toLongLong(56, false) / 1000L));
 }
 
 ByteVector ASF::File::StreamPropertiesObject::guid()
@@ -189,9 +195,9 @@ ByteVector ASF::File::StreamPropertiesObject::guid()
 void ASF::File::StreamPropertiesObject::parse(ASF::File *file, uint size)
 {
   BaseObject::parse(file, size);
-  file->d->properties->setChannels(data.mid(56, 2).toShort(false));
-  file->d->properties->setSampleRate(data.mid(58, 4).toUInt(false));
-  file->d->properties->setBitrate(data.mid(62, 4).toUInt(false) * 8 / 1000);
+  file->d->properties->setChannels(data.toShort(56, false));
+  file->d->properties->setSampleRate(data.toUInt(58, false));
+  file->d->properties->setBitrate(data.toUInt(62, false) * 8 / 1000);
 }
 
 ByteVector ASF::File::ContentDescriptionObject::guid()
@@ -340,7 +346,7 @@ void ASF::File::HeaderExtensionObject::parse(ASF::File *file, uint /*size*/)
     else {
       obj = new UnknownObject(guid);
     }
-    obj->parse(file, size);
+    obj->parse(file, (unsigned int)size);
     objects.append(obj);
     dataPos += size;
   }
@@ -360,18 +366,20 @@ ByteVector ASF::File::HeaderExtensionObject::render(ASF::File *file)
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
-ASF::File::File(FileName file, bool readProperties, Properties::ReadStyle propertiesStyle) 
+ASF::File::File(FileName file, bool readProperties, Properties::ReadStyle propertiesStyle)
   : TagLib::File(file)
 {
   d = new FilePrivate;
-  read(readProperties, propertiesStyle);
+  if(isOpen())
+    read(readProperties, propertiesStyle);
 }
 
-ASF::File::File(IOStream *stream, bool readProperties, Properties::ReadStyle propertiesStyle) 
+ASF::File::File(IOStream *stream, bool readProperties, Properties::ReadStyle propertiesStyle)
   : TagLib::File(stream)
 {
   d = new FilePrivate;
-  read(readProperties, propertiesStyle);
+  if(isOpen())
+    read(readProperties, propertiesStyle);
 }
 
 ASF::File::~File()
@@ -393,6 +401,21 @@ ASF::Tag *ASF::File::tag() const
   return d->tag;
 }
 
+PropertyMap ASF::File::properties() const
+{
+  return d->tag->properties();
+}
+
+void ASF::File::removeUnsupportedProperties(const StringList &properties)
+{
+  d->tag->removeUnsupportedProperties(properties);
+}
+
+PropertyMap ASF::File::setProperties(const PropertyMap &properties)
+{
+  return d->tag->setProperties(properties);
+}
+
 ASF::Properties *ASF::File::audioProperties() const
 {
   return d->properties;
@@ -527,7 +550,7 @@ bool ASF::File::save()
     data.append(d->objects[i]->render(this));
   }
   data = headerGuid + ByteVector::fromLongLong(data.size() + 30, false) + ByteVector::fromUInt(d->objects.size(), false) + ByteVector("\x01\x02", 2) + data;
-  insert(data, 0, d->size);
+  insert(data, 0, (TagLib::ulong)d->size);
 
   return true;
 }

taglib/asf/asffile.h

@@ -48,24 +48,27 @@ namespace TagLib {
     public:
 
       /*!
-       * Contructs an ASF file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
+       * Constructs an ASF file from \a file.
        *
        * \note In the current implementation, both \a readProperties and
-       * \a propertiesStyle are ignored.
+       * \a propertiesStyle are ignored.  The audio properties are always
+       * read.
        */
-      File(FileName file, bool readProperties = true, Properties::ReadStyle propertiesStyle = Properties::Average);
+      File(FileName file, bool readProperties = true, 
+           Properties::ReadStyle propertiesStyle = Properties::Average);
 
       /*!
-       * Contructs an ASF file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
+       * Constructs an ASF file from \a stream.
        *
        * \note In the current implementation, both \a readProperties and
-       * \a propertiesStyle are ignored.
+       * \a propertiesStyle are ignored.  The audio properties are always
+       * read.
+       *
+       * \note TagLib will *not* take ownership of the stream, the caller is
+       * responsible for deleting it after the File object.
        */
-      File(IOStream *stream, bool readProperties = true, Properties::ReadStyle propertiesStyle = Properties::Average);
+      File(IOStream *stream, bool readProperties = true, 
+           Properties::ReadStyle propertiesStyle = Properties::Average);
 
       /*!
        * Destroys this instance of the File.
@@ -84,6 +87,22 @@ namespace TagLib {
        */
       virtual Tag *tag() const;
 
+      /*!
+       * Implements the unified property interface -- export function.
+       */
+      PropertyMap properties() const;
+
+      /*!
+       * Removes unsupported properties. Forwards to the actual Tag's
+       * removeUnsupportedProperties() function.
+       */
+      void removeUnsupportedProperties(const StringList &properties);
+
+      /*!
+       * Implements the unified property interface -- import function.
+       */
+      PropertyMap setProperties(const PropertyMap &);
+
       /*!
        * Returns the ASF audio properties for this file.
        */
@@ -97,7 +116,6 @@ namespace TagLib {
       virtual bool save();
 
     private:
-
       int readBYTE(bool *ok = 0);
       int readWORD(bool *ok = 0);
       unsigned int readDWORD(bool *ok = 0);

taglib/asf/asfpicture.cpp

@@ -23,19 +23,16 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <taglib.h>
 #include <tdebug.h>
+#include "trefcounter.h"
 #include "asfattribute.h"
 #include "asffile.h"
 #include "asfpicture.h"
 
 using namespace TagLib;
 
-class ASF::Picture::PicturePriavte : public RefCounter
+class ASF::Picture::PicturePrivate : public RefCounter
 {
 public:
   bool valid;
@@ -51,7 +48,7 @@ public:
 
 ASF::Picture::Picture()
 {
-  d = new PicturePriavte();
+  d = new PicturePrivate();
   d->valid = true;
 }
 
@@ -149,7 +146,7 @@ void ASF::Picture::parse(const ByteVector& bytes)
     return;
   int pos = 0;
   d->type = (Type)bytes[0]; ++pos;
-  uint dataLen = bytes.mid(pos, 4).toUInt(false); pos+=4;
+  const uint dataLen = bytes.toUInt(pos, false); pos+=4;
 
   const ByteVector nullStringTerminator(2, 0);
 

taglib/asf/asfpicture.h

@@ -208,8 +208,8 @@ namespace TagLib
       friend class Attribute;
 #endif
       private:
-        struct PicturePriavte;
-        PicturePriavte *d;
+        class PicturePrivate;
+        PicturePrivate *d;
       };
   }
 }

taglib/asf/asfproperties.cpp

@@ -23,10 +23,6 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <tdebug.h>
 #include <tstring.h>
 #include "asfproperties.h"
@@ -56,7 +52,7 @@ ASF::Properties::Properties() : AudioProperties(AudioProperties::Average)
 ASF::Properties::~Properties()
 {
   if(d)
-    delete d;  
+    delete d;
 }
 
 int ASF::Properties::length() const
@@ -77,7 +73,7 @@ int ASF::Properties::sampleRate() const
 int ASF::Properties::channels() const
 {
   return d->channels;
-} 
+}
 
 bool ASF::Properties::isEncrypted() const
 {

taglib/asf/asfproperties.h

@@ -73,4 +73,4 @@ namespace TagLib {
 
 }
 
-#endif 
+#endif

taglib/asf/asftag.cpp

@@ -23,10 +23,7 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
+#include <tpropertymap.h>
 #include "asftag.h"
 
 using namespace TagLib;
@@ -196,3 +193,162 @@ bool ASF::Tag::isEmpty() const
          d->attributeListMap.isEmpty();
 }
 
+static const char *keyTranslation[][2] = {
+  { "WM/AlbumTitle", "ALBUM" },
+  { "WM/Composer", "COMPOSER" },
+  { "WM/Writer", "WRITER" },
+  { "WM/Conductor", "CONDUCTOR" },
+  { "WM/ModifiedBy", "REMIXER" },
+  { "WM/Year", "DATE" },
+  { "WM/OriginalReleaseYear", "ORIGINALDATE" },
+  { "WM/Producer", "PRODUCER" },
+  { "WM/ContentGroupDescription", "GROUPING" },
+  { "WM/SubTitle", "SUBTITLE" },
+  { "WM/SetSubTitle", "DISCSUBTITLE" },
+  { "WM/TrackNumber", "TRACKNUMBER" },
+  { "WM/PartOfSet", "DISCNUMBER" },
+  { "WM/Genre", "GENRE" },
+  { "WM/BeatsPerMinute", "BPM" },
+  { "WM/Mood", "MOOD" },
+  { "WM/ISRC", "ISRC" },
+  { "WM/Lyrics", "LYRICS" },
+  { "WM/Media", "MEDIA" },
+  { "WM/Publisher", "LABEL" },
+  { "WM/CatalogNo", "CATALOGNUMBER" },
+  { "WM/Barcode", "BARCODE" },
+  { "WM/EncodedBy", "ENCODEDBY" },
+  { "WM/AlbumSortOrder", "ALBUMSORT" },
+  { "WM/AlbumArtistSortOrder", "ALBUMARTISTSORT" },
+  { "WM/ArtistSortOrder", "ARTISTSORT" },
+  { "WM/TitleSortOrder", "TITLESORT" },
+  { "WM/Script", "SCRIPT" },
+  { "WM/Language", "LANGUAGE" },
+  { "MusicBrainz/Track Id", "MUSICBRAINZ_TRACKID" },
+  { "MusicBrainz/Artist Id", "MUSICBRAINZ_ARTISTID" },
+  { "MusicBrainz/Album Id", "MUSICBRAINZ_ALBUMID" },
+  { "MusicBrainz/Album Artist Id", "MUSICBRAINZ_ALBUMARTISTID" },
+  { "MusicBrainz/Release Group Id", "MUSICBRAINZ_RELEASEGROUPID" },
+  { "MusicBrainz/Work Id", "MUSICBRAINZ_WORKID" },
+  { "MusicIP/PUID", "MUSICIP_PUID" },
+  { "Acoustid/Id", "ACOUSTID_ID" },
+  { "Acoustid/Fingerprint", "ACOUSTID_FINGERPRINT" },
+};
+
+PropertyMap ASF::Tag::properties() const
+{
+  static Map<String, String> keyMap;
+  if(keyMap.isEmpty()) {
+    int numKeys = sizeof(keyTranslation) / sizeof(keyTranslation[0]);
+    for(int i = 0; i < numKeys; i++) {
+      keyMap[keyTranslation[i][0]] = keyTranslation[i][1];
+    }
+  }
+
+  PropertyMap props;
+
+  if(!d->title.isEmpty()) {
+    props["TITLE"] = d->title;
+  }
+  if(!d->artist.isEmpty()) {
+    props["ARTIST"] = d->artist;
+  }
+  if(!d->copyright.isEmpty()) {
+    props["COPYRIGHT"] = d->copyright;
+  }
+  if(!d->comment.isEmpty()) {
+    props["COMMENT"] = d->comment;
+  }
+
+  ASF::AttributeListMap::ConstIterator it = d->attributeListMap.begin();
+  for(; it != d->attributeListMap.end(); ++it) {
+    if(keyMap.contains(it->first)) {
+      String key = keyMap[it->first];
+      AttributeList::ConstIterator it2 = it->second.begin();
+      for(; it2 != it->second.end(); ++it2) {
+        if(key == "TRACKNUMBER") {
+          if(it2->type() == ASF::Attribute::DWordType)
+            props.insert(key, String::number(it2->toUInt()));
+          else
+            props.insert(key, it2->toString());
+        }
+        else {
+          props.insert(key, it2->toString());
+        }
+      }
+    }
+    else {
+      props.unsupportedData().append(it->first);
+    }
+  }
+  return props;
+}
+
+void ASF::Tag::removeUnsupportedProperties(const StringList &props)
+{
+  StringList::ConstIterator it = props.begin();
+  for(; it != props.end(); ++it)
+    d->attributeListMap.erase(*it);
+}
+
+PropertyMap ASF::Tag::setProperties(const PropertyMap &props)
+{
+  static Map<String, String> reverseKeyMap;
+  if(reverseKeyMap.isEmpty()) {
+    int numKeys = sizeof(keyTranslation) / sizeof(keyTranslation[0]);
+    for(int i = 0; i < numKeys; i++) {
+      reverseKeyMap[keyTranslation[i][1]] = keyTranslation[i][0];
+    }
+  }
+
+  PropertyMap origProps = properties();
+  PropertyMap::ConstIterator it = origProps.begin();
+  for(; it != origProps.end(); ++it) {
+    if(!props.contains(it->first) || props[it->first].isEmpty()) {
+      if(it->first == "TITLE") {
+        d->title = String::null;
+      }
+      else if(it->first == "ARTIST") {
+        d->artist = String::null;
+      }
+      else if(it->first == "COMMENT") {
+        d->comment = String::null;
+      }
+      else if(it->first == "COPYRIGHT") {
+        d->copyright = String::null;
+      }
+      else {
+        d->attributeListMap.erase(reverseKeyMap[it->first]);
+      }
+    }
+  }
+
+  PropertyMap ignoredProps;
+  it = props.begin();
+  for(; it != props.end(); ++it) {
+    if(reverseKeyMap.contains(it->first)) {
+      String name = reverseKeyMap[it->first];
+      removeItem(name);
+      StringList::ConstIterator it2 = it->second.begin();
+      for(; it2 != it->second.end(); ++it2) {
+        addAttribute(name, *it2);
+      }
+    }
+    else if(it->first == "TITLE") {
+      d->title = it->second.toString();
+    }
+    else if(it->first == "ARTIST") {
+      d->artist = it->second.toString();
+    }
+    else if(it->first == "COMMENT") {
+      d->comment = it->second.toString();
+    }
+    else if(it->first == "COPYRIGHT") {
+      d->copyright = it->second.toString();
+    }
+    else {
+      ignoredProps.insert(it->first, it->second);
+    }
+  }
+
+  return ignoredProps;
+}

taglib/asf/asftag.h

@@ -120,17 +120,17 @@ namespace TagLib {
       virtual void setComment(const String &s);
 
       /*!
-       * Sets the rating to \a s. 
+       * Sets the rating to \a s.
        */
       virtual void setRating(const String &s);
 
       /*!
-       * Sets the copyright to \a s. 
+       * Sets the copyright to \a s.
        */
       virtual void setCopyright(const String &s);
 
       /*!
-       * Sets the genre to \a s. 
+       * Sets the genre to \a s.
        */
       virtual void setGenre(const String &s);
 
@@ -176,6 +176,10 @@ namespace TagLib {
        */
       void addAttribute(const String &name, const Attribute &attribute);
 
+      PropertyMap properties() const;
+      void removeUnsupportedProperties(const StringList& properties);
+      PropertyMap setProperties(const PropertyMap &properties);
+
     private:
 
       class TagPrivate;

taglib/fileref.cpp

@@ -1,7 +1,7 @@
 /***************************************************************************
     copyright            : (C) 2002 - 2008 by Scott Wheeler
     email                : wheeler@kde.org
-    
+
     copyright            : (C) 2010 by Alex Novichkov
     email                : novichko@atnet.ru
                            (added APE file support)
@@ -27,13 +27,10 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <tfile.h>
 #include <tstring.h>
 #include <tdebug.h>
+#include "trefcounter.h"
 
 #include "fileref.h"
 #include "asffile.h"
@@ -45,6 +42,7 @@
 #include "mp4file.h"
 #include "wavpackfile.h"
 #include "speexfile.h"
+#include "opusfile.h"
 #include "trueaudiofile.h"
 #include "aifffile.h"
 #include "wavfile.h"
@@ -152,6 +150,7 @@ StringList FileRef::defaultFileExtensions()
   l.append("spx");
   l.append("tta");
   l.append("m4a");
+  l.append("m4r");
   l.append("m4b");
   l.append("m4p");
   l.append("3g2");
@@ -216,21 +215,28 @@ File *FileRef::create(FileName fileName, bool readAudioProperties,
 
   // Ok, this is really dumb for now, but it works for testing.
 
-  String s;
-
+  String ext;
+  {
 #ifdef _WIN32
-  s = (wcslen((const wchar_t *) fileName) > 0) ? String((const wchar_t *) fileName) : String((const char *) fileName);
+
+    String s = fileName.toString();
+
 #else
-  s = fileName;
-#endif
+
+    String s = fileName;
+
+ #endif
+
+    const int pos = s.rfind(".");
+    if(pos != -1)
+      ext = s.substr(pos + 1).upper();
+  }
 
   // If this list is updated, the method defaultFileExtensions() should also be
   // updated.  However at some point that list should be created at the same time
   // that a default file type resolver is created.
 
-  int pos = s.rfind(".");
-  if(pos != -1) {
-    String ext = s.substr(pos + 1).upper();
+  if(!ext.isEmpty()) {
     if(ext == "MP3")
       return new MPEG::File(fileName, readAudioProperties, audioPropertiesStyle);
     if(ext == "OGG")
@@ -251,9 +257,11 @@ File *FileRef::create(FileName fileName, bool readAudioProperties,
       return new WavPack::File(fileName, readAudioProperties, audioPropertiesStyle);
     if(ext == "SPX")
       return new Ogg::Speex::File(fileName, readAudioProperties, audioPropertiesStyle);
+    if(ext == "OPUS")
+      return new Ogg::Opus::File(fileName, readAudioProperties, audioPropertiesStyle);
     if(ext == "TTA")
       return new TrueAudio::File(fileName, readAudioProperties, audioPropertiesStyle);
-    if(ext == "M4A" || ext == "M4B" || ext == "M4P" || ext == "MP4" || ext == "3G2")
+    if(ext == "M4A" || ext == "M4R" || ext == "M4B" || ext == "M4P" || ext == "MP4" || ext == "3G2")
       return new MP4::File(fileName, readAudioProperties, audioPropertiesStyle);
     if(ext == "WMA" || ext == "ASF")
       return new ASF::File(fileName, readAudioProperties, audioPropertiesStyle);

taglib/flac/flacfile.cpp

@@ -28,6 +28,7 @@
 #include <tlist.h>
 #include <tdebug.h>
 #include <tagunion.h>
+#include <tpropertymap.h>
 
 #include <id3v2header.h>
 #include <id3v2tag.h>
@@ -43,7 +44,7 @@ using namespace TagLib;
 
 namespace
 {
-  enum { XiphIndex = 0, ID3v2Index = 1, ID3v1Index = 2 };
+  enum { FlacXiphIndex = 0, FlacID3v2Index = 1, FlacID3v1Index = 2 };
   enum { MinPaddingLength = 4096 };
   enum { LastBlockFlag = 0x80 };
 }
@@ -69,7 +70,8 @@ public:
 
   ~FilePrivate()
   {
-    for(uint i = 0; i < blocks.size(); i++) {
+    uint size = blocks.size();
+    for(uint i = 0; i < size; i++) {
       delete blocks[i];
     }
     delete properties;
@@ -107,7 +109,8 @@ FLAC::File::File(FileName file, bool readProperties,
   TagLib::File(file)
 {
   d = new FilePrivate;
-  read(readProperties, propertiesStyle);
+  if(isOpen())
+    read(readProperties, propertiesStyle);
 }
 
 FLAC::File::File(FileName file, ID3v2::FrameFactory *frameFactory,
@@ -116,7 +119,8 @@ FLAC::File::File(FileName file, ID3v2::FrameFactory *frameFactory,
 {
   d = new FilePrivate;
   d->ID3v2FrameFactory = frameFactory;
-  read(readProperties, propertiesStyle);
+  if(isOpen())
+    read(readProperties, propertiesStyle);
 }
 
 FLAC::File::File(IOStream *stream, ID3v2::FrameFactory *frameFactory,
@@ -125,7 +129,8 @@ FLAC::File::File(IOStream *stream, ID3v2::FrameFactory *frameFactory,
 {
   d = new FilePrivate;
   d->ID3v2FrameFactory = frameFactory;
-  read(readProperties, propertiesStyle);
+  if(isOpen())
+    read(readProperties, propertiesStyle);
 }
 
 FLAC::File::~File()
@@ -138,6 +143,34 @@ TagLib::Tag *FLAC::File::tag() const
   return &d->tag;
 }
 
+PropertyMap FLAC::File::properties() const
+{
+  // once Tag::properties() is virtual, this case distinction could actually be done
+  // within TagUnion.
+  if(d->hasXiphComment)
+    return d->tag.access<Ogg::XiphComment>(FlacXiphIndex, false)->properties();
+  if(d->hasID3v2)
+    return d->tag.access<ID3v2::Tag>(FlacID3v2Index, false)->properties();
+  if(d->hasID3v1)
+    return d->tag.access<ID3v1::Tag>(FlacID3v1Index, false)->properties();
+  return PropertyMap();
+}
+
+void FLAC::File::removeUnsupportedProperties(const StringList &unsupported)
+{
+  if(d->hasXiphComment)
+    d->tag.access<Ogg::XiphComment>(FlacXiphIndex, false)->removeUnsupportedProperties(unsupported);
+  if(d->hasID3v2)
+    d->tag.access<ID3v2::Tag>(FlacID3v2Index, false)->removeUnsupportedProperties(unsupported);
+  if(d->hasID3v1)
+    d->tag.access<ID3v1::Tag>(FlacID3v1Index, false)->removeUnsupportedProperties(unsupported);
+}
+
+PropertyMap FLAC::File::setProperties(const PropertyMap &properties)
+{
+  return d->tag.access<Ogg::XiphComment>(FlacXiphIndex, true)->setProperties(properties);
+}
+
 FLAC::Properties *FLAC::File::audioProperties() const
 {
   return d->properties;
@@ -207,7 +240,7 @@ bool FLAC::File::save()
   }
   ByteVector padding = ByteVector::fromUInt(paddingLength);
   padding.resize(paddingLength + 4);
-  padding[0] = FLAC::MetadataBlock::Padding | LastBlockFlag;
+  padding[0] = (char)(FLAC::MetadataBlock::Padding | LastBlockFlag);
   data.append(padding);
 
   // Write the data to the file
@@ -239,21 +272,21 @@ bool FLAC::File::save()
 
 ID3v2::Tag *FLAC::File::ID3v2Tag(bool create)
 {
-  if(!create || d->tag[ID3v2Index])
-    return static_cast<ID3v2::Tag *>(d->tag[ID3v2Index]);
+  if(!create || d->tag[FlacID3v2Index])
+    return static_cast<ID3v2::Tag *>(d->tag[FlacID3v2Index]);
 
-  d->tag.set(ID3v2Index, new ID3v2::Tag);
-  return static_cast<ID3v2::Tag *>(d->tag[ID3v2Index]);
+  d->tag.set(FlacID3v2Index, new ID3v2::Tag);
+  return static_cast<ID3v2::Tag *>(d->tag[FlacID3v2Index]);
 }
 
 ID3v1::Tag *FLAC::File::ID3v1Tag(bool create)
 {
-  return d->tag.access<ID3v1::Tag>(ID3v1Index, create);
+  return d->tag.access<ID3v1::Tag>(FlacID3v1Index, create);
 }
 
 Ogg::XiphComment *FLAC::File::xiphComment(bool create)
 {
-  return d->tag.access<Ogg::XiphComment>(XiphIndex, create);
+  return d->tag.access<Ogg::XiphComment>(FlacXiphIndex, create);
 }
 
 void FLAC::File::setID3v2FrameFactory(const ID3v2::FrameFactory *factory)
@@ -274,12 +307,12 @@ void FLAC::File::read(bool readProperties, Properties::ReadStyle propertiesStyle
 
   if(d->ID3v2Location >= 0) {
 
-    d->tag.set(ID3v2Index, new ID3v2::Tag(this, d->ID3v2Location, d->ID3v2FrameFactory));
+    d->tag.set(FlacID3v2Index, new ID3v2::Tag(this, d->ID3v2Location, d->ID3v2FrameFactory));
 
     d->ID3v2OriginalSize = ID3v2Tag()->header()->completeTagSize();
 
     if(ID3v2Tag()->header()->tagSize() <= 0)
-      d->tag.set(ID3v2Index, 0);
+      d->tag.set(FlacID3v2Index, 0);
     else
       d->hasID3v2 = true;
   }
@@ -289,7 +322,7 @@ void FLAC::File::read(bool readProperties, Properties::ReadStyle propertiesStyle
   d->ID3v1Location = findID3v1();
 
   if(d->ID3v1Location >= 0) {
-    d->tag.set(ID3v1Index, new ID3v1::Tag(this, d->ID3v1Location));
+    d->tag.set(FlacID3v1Index, new ID3v1::Tag(this, d->ID3v1Location));
     d->hasID3v1 = true;
   }
 
@@ -301,9 +334,9 @@ void FLAC::File::read(bool readProperties, Properties::ReadStyle propertiesStyle
     return;
 
   if(d->hasXiphComment)
-    d->tag.set(XiphIndex, new Ogg::XiphComment(xiphCommentData()));
+    d->tag.set(FlacXiphIndex, new Ogg::XiphComment(xiphCommentData()));
   else
-    d->tag.set(XiphIndex, new Ogg::XiphComment);
+    d->tag.set(FlacXiphIndex, new Ogg::XiphComment);
 
   if(readProperties)
     d->properties = new Properties(streamInfoData(), streamLength(), propertiesStyle);
@@ -366,7 +399,7 @@ void FLAC::File::scan()
 
   char blockType = header[0] & 0x7f;
   bool isLastBlock = (header[0] & 0x80) != 0;
-  uint length = header.mid(1, 3).toUInt();
+  uint length = header.toUInt(1U, 3U);
 
   // First block should be the stream_info metadata
 
@@ -386,10 +419,10 @@ void FLAC::File::scan()
     header = readBlock(4);
     blockType = header[0] & 0x7f;
     isLastBlock = (header[0] & 0x80) != 0;
-    length = header.mid(1, 3).toUInt();
+    length = header.toUInt(1U, 3U);
 
     ByteVector data = readBlock(length);
-    if(data.size() != length) {
+    if(data.size() != length || length == 0) {
       debug("FLAC::File::scan() -- FLAC stream corrupted");
       setValid(false);
       return;
@@ -493,6 +526,17 @@ void FLAC::File::addPicture(Picture *picture)
   d->blocks.append(picture);
 }
 
+void FLAC::File::removePicture(Picture *picture, bool del)
+{
+  MetadataBlock *block = picture;
+  List<MetadataBlock *>::Iterator it = d->blocks.find(block);
+  if(it != d->blocks.end())
+    d->blocks.erase(it);
+
+  if(del)
+    delete picture;
+}
+
 void FLAC::File::removePictures()
 {
   List<MetadataBlock *> newBlocks;
@@ -508,3 +552,17 @@ void FLAC::File::removePictures()
   d->blocks = newBlocks;
 }
 
+bool FLAC::File::hasXiphComment() const
+{
+  return d->hasXiphComment;
+}
+
+bool FLAC::File::hasID3v1Tag() const
+{
+  return d->hasID3v1;
+}
+
+bool FLAC::File::hasID3v2Tag() const
+{
+  return d->hasID3v2;
+}

taglib/flac/flacfile.h

@@ -29,6 +29,7 @@
 #include "taglib_export.h"
 #include "tfile.h"
 #include "tlist.h"
+#include "tag.h"
 
 #include "flacpicture.h"
 #include "flacproperties.h"
@@ -36,7 +37,6 @@
 namespace TagLib {
 
   class Tag;
-
   namespace ID3v2 { class FrameFactory; class Tag; }
   namespace ID3v1 { class Tag; }
   namespace Ogg { class XiphComment; }
@@ -67,9 +67,10 @@ namespace TagLib {
     {
     public:
       /*!
-       * Contructs a FLAC file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
+       * Constructs a FLAC file from \a file.  If \a readProperties is true the
+       * file's audio properties will also be read.
+       *
+       * \note In the current implementation, \a propertiesStyle is ignored.
        *
        * \deprecated This constructor will be dropped in favor of the one below
        * in a future version.
@@ -78,12 +79,13 @@ namespace TagLib {
            Properties::ReadStyle propertiesStyle = Properties::Average);
 
       /*!
-       * Contructs a FLAC file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
+       * Constructs an APE file from \a file.  If \a readProperties is true the
+       * file's audio properties will also be read.
        *
        * If this file contains and ID3v2 tag the frames will be created using
        * \a frameFactory.
+       *
+       * \note In the current implementation, \a propertiesStyle is ignored.
        */
       // BIC: merge with the above constructor
       File(FileName file, ID3v2::FrameFactory *frameFactory,
@@ -91,12 +93,16 @@ namespace TagLib {
            Properties::ReadStyle propertiesStyle = Properties::Average);
 
       /*!
-       * Contructs a FLAC file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
+       * Constructs a FLAC file from \a stream.  If \a readProperties is true the
+       * file's audio properties will also be read.
+       *
+       * \note TagLib will *not* take ownership of the stream, the caller is
+       * responsible for deleting it after the File object.
        *
        * If this file contains and ID3v2 tag the frames will be created using
        * \a frameFactory.
+       *
+       * \note In the current implementation, \a propertiesStyle is ignored.
        */
       // BIC: merge with the above constructor
       File(IOStream *stream, ID3v2::FrameFactory *frameFactory,
@@ -118,6 +124,25 @@ namespace TagLib {
        */
       virtual TagLib::Tag *tag() const;
 
+      /*!
+       * Implements the unified property interface -- export function.
+       * If the file contains more than one tag (e.g. XiphComment and ID3v1),
+       * only the first one (in the order XiphComment, ID3v2, ID3v1) will be
+       * converted to the PropertyMap.
+       */
+      PropertyMap properties() const;
+
+      void removeUnsupportedProperties(const StringList &);
+
+      /*!
+       * Implements the unified property interface -- import function.
+       * This always creates a Xiph comment, if none exists. The return value
+       * relates to the Xiph comment only.
+       * Ignores any changes to ID3v1 or ID3v2 comments since they are not allowed
+       * in the FLAC specification.
+       */
+      PropertyMap setProperties(const PropertyMap &);
+
       /*!
        * Returns the FLAC::Properties for this file.  If no audio properties
        * were read then this will return a null pointer.
@@ -136,39 +161,57 @@ namespace TagLib {
       /*!
        * Returns a pointer to the ID3v2 tag of the file.
        *
-       * If \a create is false (the default) this will return a null pointer
+       * If \a create is false (the default) this returns a null pointer
        * if there is no valid ID3v2 tag.  If \a create is true it will create
-       * an ID3v2 tag if one does not exist.
+       * an ID3v2 tag if one does not exist and returns a valid pointer.
        *
-       * \note The Tag <b>is still</b> owned by the FLAC::File and should not be
+       * \note This may return a valid pointer regardless of whether or not the 
+       * file on disk has an ID3v2 tag.  Use hasID3v2Tag() to check if the file 
+       * on disk actually has an ID3v2 tag.
+       *
+       * \note The Tag <b>is still</b> owned by the MPEG::File and should not be
        * deleted by the user.  It will be deleted when the file (object) is
        * destroyed.
+       *
+       * \see hasID3v2Tag()
        */
       ID3v2::Tag *ID3v2Tag(bool create = false);
 
       /*!
        * Returns a pointer to the ID3v1 tag of the file.
        *
-       * If \a create is false (the default) this will return a null pointer
-       * if there is no valid ID3v1 tag.  If \a create is true it will create
-       * an ID3v1 tag if one does not exist.
+       * If \a create is false (the default) this returns a null pointer
+       * if there is no valid APE tag.  If \a create is true it will create
+       * an APE tag if one does not exist and returns a valid pointer.
        *
-       * \note The Tag <b>is still</b> owned by the FLAC::File and should not be
+       * \note This may return a valid pointer regardless of whether or not the 
+       * file on disk has an ID3v1 tag.  Use hasID3v1Tag() to check if the file 
+       * on disk actually has an ID3v1 tag.
+       *
+       * \note The Tag <b>is still</b> owned by the MPEG::File and should not be
        * deleted by the user.  It will be deleted when the file (object) is
        * destroyed.
+       *
+       * \see hasID3v1Tag()
        */
       ID3v1::Tag *ID3v1Tag(bool create = false);
 
       /*!
        * Returns a pointer to the XiphComment for the file.
        *
-       * If \a create is false (the default) this will return a null pointer
+       * If \a create is false (the default) this returns a null pointer
        * if there is no valid XiphComment.  If \a create is true it will create
-       * a XiphComment if one does not exist.
+       * a XiphComment if one does not exist and returns a valid pointer.
        *
+       * \note This may return a valid pointer regardless of whether or not the 
+       * file on disk has a XiphComment.  Use hasXiphComment() to check if the 
+       * file on disk actually has a XiphComment.
+       * 
        * \note The Tag <b>is still</b> owned by the FLAC::File and should not be
        * deleted by the user.  It will be deleted when the file (object) is
        * destroyed.
+       *
+       * \see hasXiphComment()
        */
       Ogg::XiphComment *xiphComment(bool create = false);
 
@@ -202,6 +245,12 @@ namespace TagLib {
        */
       List<Picture *> pictureList();
 
+      /*!
+       * Removes an attached picture. If \a del is true the picture's memory
+       * will be freed; if it is false, it must be deleted by the user.
+       */
+      void removePicture(Picture *picture, bool del = true);
+
       /*!
        * Remove all attached images.
        */
@@ -215,6 +264,27 @@ namespace TagLib {
        */
       void addPicture(Picture *picture);
 
+      /*!
+       * Returns whether or not the file on disk actually has a XiphComment.
+       *
+       * \see xiphComment()
+       */
+      bool hasXiphComment() const;
+
+      /*!
+       * Returns whether or not the file on disk actually has an ID3v1 tag.
+       *
+       * \see ID3v1Tag()
+       */
+      bool hasID3v1Tag() const;
+
+      /*!
+       * Returns whether or not the file on disk actually has an ID3v2 tag.
+       *
+       * \see ID3v2Tag()
+       */
+      bool hasID3v2Tag() const;
+
     private:
       File(const File &);
       File &operator=(const File &);

taglib/flac/flacmetadatablock.cpp

@@ -23,17 +23,13 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <taglib.h>
 #include <tdebug.h>
 #include "flacmetadatablock.h"
 
 using namespace TagLib;
 
-class FLAC::MetadataBlock::MetadataBlockPrivate 
+class FLAC::MetadataBlock::MetadataBlockPrivate
 {
 public:
   MetadataBlockPrivate() {}

taglib/flac/flacpicture.cpp

@@ -23,17 +23,13 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <taglib.h>
 #include <tdebug.h>
 #include "flacpicture.h"
 
 using namespace TagLib;
 
-class FLAC::Picture::PicturePrivate 
+class FLAC::Picture::PicturePrivate
 {
 public:
   PicturePrivate() :
@@ -82,10 +78,10 @@ bool FLAC::Picture::parse(const ByteVector &data)
     return false;
   }
 
-  int pos = 0;
-  d->type = FLAC::Picture::Type(data.mid(pos, 4).toUInt());
+  uint pos = 0;
+  d->type = FLAC::Picture::Type(data.toUInt(pos));
   pos += 4;
-  uint mimeTypeLength = data.mid(pos, 4).toUInt();
+  uint mimeTypeLength = data.toUInt(pos);
   pos += 4;
   if(pos + mimeTypeLength + 24 > data.size()) {
     debug("Invalid picture block.");
@@ -93,7 +89,7 @@ bool FLAC::Picture::parse(const ByteVector &data)
   }
   d->mimeType = String(data.mid(pos, mimeTypeLength), String::UTF8);
   pos += mimeTypeLength;
-  uint descriptionLength = data.mid(pos, 4).toUInt();
+  uint descriptionLength = data.toUInt(pos);
   pos += 4;
   if(pos + descriptionLength + 20 > data.size()) {
     debug("Invalid picture block.");
@@ -101,15 +97,15 @@ bool FLAC::Picture::parse(const ByteVector &data)
   }
   d->description = String(data.mid(pos, descriptionLength), String::UTF8);
   pos += descriptionLength;
-  d->width = data.mid(pos, 4).toUInt();
+  d->width = data.toUInt(pos);
   pos += 4;
-  d->height = data.mid(pos, 4).toUInt();
+  d->height = data.toUInt(pos);
   pos += 4;
-  d->colorDepth = data.mid(pos, 4).toUInt();
+  d->colorDepth = data.toUInt(pos);
   pos += 4;
-  d->numColors = data.mid(pos, 4).toUInt();
+  d->numColors = data.toUInt(pos);
   pos += 4;
-  uint dataLength = data.mid(pos, 4).toUInt();
+  uint dataLength = data.toUInt(pos);
   pos += 4;
   if(pos + dataLength > data.size()) {
     debug("Invalid picture block.");
@@ -117,7 +113,7 @@ bool FLAC::Picture::parse(const ByteVector &data)
   }
   d->data = data.mid(pos, dataLength);
 
-  return true;  
+  return true;
 }
 
 ByteVector FLAC::Picture::render() const

taglib/flac/flacproperties.cpp

@@ -42,7 +42,8 @@ public:
     bitrate(0),
     sampleRate(0),
     sampleWidth(0),
-    channels(0) {}
+    channels(0),
+    sampleFrames(0) {}
 
   ByteVector data;
   long streamLength;
@@ -52,6 +53,7 @@ public:
   int sampleRate;
   int sampleWidth;
   int channels;
+  unsigned long long sampleFrames;
   ByteVector signature;
 };
 
@@ -101,6 +103,11 @@ int FLAC::Properties::channels() const
   return d->channels;
 }
 
+unsigned long long FLAC::Properties::sampleFrames() const
+{
+  return d->sampleFrames;
+}
+
 ByteVector FLAC::Properties::signature() const
 {
   return d->signature;
@@ -117,7 +124,7 @@ void FLAC::Properties::read()
     return;
   }
 
-  int pos = 0;
+  uint pos = 0;
 
   // Minimum block size (in samples)
   pos += 2;
@@ -131,7 +138,9 @@ void FLAC::Properties::read()
   // Maximum frame size (in bytes)
   pos += 3;
 
-  uint flags = d->data.mid(pos, 4).toUInt(true);
+  uint flags = d->data.toUInt(pos, true);
+  pos += 4;
+
   d->sampleRate = flags >> 12;
   d->channels = ((flags >> 9) & 7) + 1;
   d->sampleWidth = ((flags >> 4) & 31) + 1;
@@ -139,12 +148,14 @@ void FLAC::Properties::read()
   // The last 4 bits are the most significant 4 bits for the 36 bit
   // stream length in samples. (Audio files measured in days)
 
-  uint highLength =d->sampleRate > 0 ? (((flags & 0xf) << 28) / d->sampleRate) << 4 : 0;
+  unsigned long long hi = flags & 0xf;
+  unsigned long long lo = d->data.toUInt(pos, true);
   pos += 4;
 
-  d->length = d->sampleRate > 0 ?
-      (d->data.mid(pos, 4).toUInt(true)) / d->sampleRate + highLength : 0;
-  pos += 4;
+  d->sampleFrames = (hi << 32) | lo;
+
+  if(d->sampleRate > 0)
+    d->length = int(d->sampleFrames / d->sampleRate);
 
   // Uncompressed bitrate:
 

taglib/flac/flacproperties.h

@@ -77,6 +77,11 @@ namespace TagLib {
        */
       int sampleWidth() const;
 
+      /*!
+       * Return the number of sample frames
+       */
+      unsigned long long sampleFrames() const;
+
       /*!
        * Returns the MD5 signature of the uncompressed audio stream as read
        * from the stream info header header.

taglib/flac/flacunknownmetadatablock.cpp

@@ -23,10 +23,6 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <taglib.h>
 #include <tdebug.h>
 #include <tstring.h>
@@ -34,7 +30,7 @@
 
 using namespace TagLib;
 
-class FLAC::UnknownMetadataBlock::UnknownMetadataBlockPrivate 
+class FLAC::UnknownMetadataBlock::UnknownMetadataBlockPrivate
 {
 public:
   UnknownMetadataBlockPrivate() : code(0) {}

taglib/it/itfile.cpp

@@ -23,6 +23,7 @@
 #include "itfile.h"
 #include "tdebug.h"
 #include "modfileprivate.h"
+#include "tpropertymap.h"
 
 using namespace TagLib;
 using namespace IT;
@@ -44,7 +45,8 @@ IT::File::File(FileName file, bool readProperties,
   Mod::FileBase(file),
   d(new FilePrivate(propertiesStyle))
 {
-  read(readProperties);
+  if(isOpen())
+    read(readProperties);
 }
 
 IT::File::File(IOStream *stream, bool readProperties,
@@ -52,7 +54,8 @@ IT::File::File(IOStream *stream, bool readProperties,
   Mod::FileBase(stream),
   d(new FilePrivate(propertiesStyle))
 {
-  read(readProperties);
+  if(isOpen())
+    read(readProperties);
 }
 
 IT::File::~File()
@@ -65,6 +68,16 @@ Mod::Tag *IT::File::tag() const
   return &d->tag;
 }
 
+PropertyMap IT::File::properties() const
+{
+  return d->tag.properties();
+}
+
+PropertyMap IT::File::setProperties(const PropertyMap &properties)
+{
+  return d->tag.setProperties(properties);
+}
+
 IT::Properties *IT::File::audioProperties() const
 {
   return &d->properties;
@@ -114,10 +127,10 @@ bool IT::File::save()
     ulong sampleOffset = 0;
     if(!readU32L(sampleOffset))
       return false;
-    
+
     seek(sampleOffset + 20);
 
-    if((i + instrumentCount) < lines.size())
+    if((TagLib::uint)(i + instrumentCount) < lines.size())
       writeString(lines[i + instrumentCount], 25);
     else
       writeString(String::null, 25);
@@ -144,7 +157,7 @@ bool IT::File::save()
   if(!readU16L(special))
     return false;
 
-  long fileSize = this->length();
+  ulong fileSize = File::length();
   if(special & Properties::MessageAttached) {
     seek(54);
     if(!readU16L(messageLength) || !readU32L(messageOffset))
@@ -160,7 +173,7 @@ bool IT::File::save()
     writeU16L(special | 0x1);
   }
 
-  if((messageOffset + messageLength) >= fileSize) {
+  if(messageOffset + messageLength >= fileSize) {
     // append new message
     seek(54);
     writeU16L(message.size());
@@ -195,7 +208,7 @@ void IT::File::read(bool)
   READ_U16L_AS(length);
   READ_U16L_AS(instrumentCount);
   READ_U16L_AS(sampleCount);
-  
+
   d->properties.setInstrumentCount(instrumentCount);
   d->properties.setSampleCount(sampleCount);
   READ_U16L(d->properties.setPatternCount);
@@ -240,10 +253,11 @@ void IT::File::read(bool)
     // But this always gives 64 channels for all my files anyway.
     // Strangely VLC does report other values. I wonder how VLC
     // gets it's values.
-    if(pannings[i] < 128 && volumes[i] > 0) ++ channels;
+    if((unsigned char) pannings[i] < 128 && volumes[i] > 0)
+        ++channels;
   }
   d->properties.setChannels(channels);
-  
+
   // real length might be shorter because of skips and terminator
   ushort realLength = 0;
   for(ushort i = 0; i < length; ++ i) {
@@ -275,11 +289,11 @@ void IT::File::read(bool)
     READ_STRING_AS(instrumentName, 26);
     comment.append(instrumentName);
   }
-  
+
   for(ushort i = 0; i < sampleCount; ++ i) {
     seek(192L + length + ((long)instrumentCount << 2) + ((long)i << 2));
     READ_U32L_AS(sampleOffset);
-    
+
     seek(sampleOffset);
 
     ByteVector sampleMagic = readBlock(4);
@@ -305,7 +319,7 @@ void IT::File::read(bool)
     READ_BYTE_AS(vibratoRate);
     READ_BYTE_AS(vibratoType);
     */
-    
+
     comment.append(sampleName);
   }
 

taglib/it/itfile.h

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

taglib/it/itproperties.cpp

@@ -94,7 +94,7 @@ int IT::Properties::channels() const
   return d->channels;
 }
 
-ushort IT::Properties::lengthInPatterns() const
+TagLib::ushort IT::Properties::lengthInPatterns() const
 {
   return d->lengthInPatterns;
 }
@@ -104,37 +104,37 @@ bool IT::Properties::stereo() const
   return d->flags & Stereo;
 }
 
-ushort IT::Properties::instrumentCount() const
+TagLib::ushort IT::Properties::instrumentCount() const
 {
   return d->instrumentCount;
 }
 
-ushort IT::Properties::sampleCount() const
+TagLib::ushort IT::Properties::sampleCount() const
 {
   return d->sampleCount;
 }
 
-ushort IT::Properties::patternCount() const
+TagLib::ushort IT::Properties::patternCount() const
 {
   return d->patternCount;
 }
 
-ushort IT::Properties::version() const
+TagLib::ushort IT::Properties::version() const
 {
   return d->version;
 }
 
-ushort IT::Properties::compatibleVersion() const
+TagLib::ushort IT::Properties::compatibleVersion() const
 {
   return d->compatibleVersion;
 }
 
-ushort IT::Properties::flags() const
+TagLib::ushort IT::Properties::flags() const
 {
   return d->flags;
 }
 
-ushort IT::Properties::special() const
+TagLib::ushort IT::Properties::special() const
 {
   return d->special;
 }

taglib/it/itproperties.h

@@ -50,7 +50,7 @@ namespace TagLib {
 
       Properties(AudioProperties::ReadStyle propertiesStyle);
       virtual ~Properties();
-      
+
       int length()     const;
       int bitrate()    const;
       int sampleRate() const;
@@ -72,9 +72,7 @@ namespace TagLib {
       uchar  panningSeparation() const;
       uchar  pitchWheelDepth()   const;
 
-    protected:
       void setChannels(int channels);
-
       void setLengthInPatterns(ushort lengthInPatterns);
       void setInstrumentCount(ushort instrumentCount);
       void setSampleCount (ushort sampleCount);

taglib/mod/modfile.cpp

@@ -23,6 +23,7 @@
 #include "tstringlist.h"
 #include "tdebug.h"
 #include "modfileprivate.h"
+#include "tpropertymap.h"
 
 using namespace TagLib;
 using namespace Mod;
@@ -44,7 +45,8 @@ Mod::File::File(FileName file, bool readProperties,
   Mod::FileBase(file),
   d(new FilePrivate(propertiesStyle))
 {
-  read(readProperties);
+  if(isOpen())
+    read(readProperties);
 }
 
 Mod::File::File(IOStream *stream, bool readProperties,
@@ -52,7 +54,8 @@ Mod::File::File(IOStream *stream, bool readProperties,
   Mod::FileBase(stream),
   d(new FilePrivate(propertiesStyle))
 {
-  read(readProperties);
+  if(isOpen())
+    read(readProperties);
 }
 
 Mod::File::~File()
@@ -70,6 +73,16 @@ Mod::Properties *Mod::File::audioProperties() const
   return &d->properties;
 }
 
+PropertyMap Mod::File::properties() const
+{
+  return d->tag.properties();
+}
+
+PropertyMap Mod::File::setProperties(const PropertyMap &properties)
+{
+  return d->tag.setProperties(properties);
+}
+
 bool Mod::File::save()
 {
   if(readOnly()) {

taglib/mod/modfile.h

@@ -33,57 +33,78 @@ namespace TagLib {
 
   namespace Mod {
 
-    class TAGLIB_EXPORT File : public TagLib::Mod::FileBase {
-      public:
-        /*!
-         * Contructs a Protracker file from \a file. If \a readProperties
-         * is true the file's audio properties will also be read using
-         * \a propertiesStyle. If false, \a propertiesStyle is ignored.
-         */
-        File(FileName file, bool readProperties = true,
-             AudioProperties::ReadStyle propertiesStyle =
-             AudioProperties::Average);
+    class TAGLIB_EXPORT File : public TagLib::Mod::FileBase
+    {
+    public:
+      /*!
+       * Constructs a Protracker file from \a file.
+       *
+       * \note In the current implementation, both \a readProperties and
+       * \a propertiesStyle are ignored.  The audio properties are always
+       * read.
+       */
+      File(FileName file, bool readProperties = true,
+           AudioProperties::ReadStyle propertiesStyle =
+           AudioProperties::Average);
 
-        /*!
-         * Contructs a Protracker file from \a stream. If \a readProperties
-         * is true the file's audio properties will also be read using
-         * \a propertiesStyle. If false, \a propertiesStyle is ignored.
-         */
-        File(IOStream *stream, bool readProperties = true,
-             AudioProperties::ReadStyle propertiesStyle =
-             AudioProperties::Average);
+      /*!
+       * Constructs a Protracker file from \a stream.
+       *
+       * \note In the current implementation, both \a readProperties and
+       * \a propertiesStyle are ignored.  The audio properties are always
+       * read.
+       *
+       * \note TagLib will *not* take ownership of the stream, the caller is
+       * responsible for deleting it after the File object.
+       */
+      File(IOStream *stream, bool readProperties = true,
+           AudioProperties::ReadStyle propertiesStyle =
+           AudioProperties::Average);
 
-        /*!
-         * Destroys this instance of the File.
-         */
-        virtual ~File();
+      /*!
+       * Destroys this instance of the File.
+       */
+      virtual ~File();
 
-        Mod::Tag *tag() const;
+      Mod::Tag *tag() const;
 
-        /*!
-         * Returns the Mod::Properties for this file. If no audio properties
-         * were read then this will return a null pointer.
-         */
-        Mod::Properties *audioProperties() const;
+      /*!
+       * Implements the unified property interface -- export function.
+       * Forwards to Mod::Tag::properties().
+       */
+      PropertyMap properties() const;
 
-        /*!
-         * Save the file.
-         * This is the same as calling save(AllTags);
-         *
-         * \note Saving Protracker tags is not supported.
-         */
-        bool save();
+      /*!
+       * Implements the unified property interface -- import function.
+       * Forwards to Mod::Tag::setProperties().
+       */
+      PropertyMap setProperties(const PropertyMap &);
+      /*!
+       * Returns the Mod::Properties for this file. If no audio properties
+       * were read then this will return a null pointer.
+       */
+      Mod::Properties *audioProperties() const;
 
-      private:
-        File(const File &);
-        File &operator=(const File &);
+      /*!
+       * Save the file.
+       * This is the same as calling save(AllTags);
+       *
+       * \note Saving Protracker tags is not supported.
+       */
+      bool save();
 
-        void read(bool readProperties);
+    private:
+      File(const File &);
+      File &operator=(const File &);
 
-        class FilePrivate;
-        FilePrivate *d;
+      void read(bool readProperties);
+
+      class FilePrivate;
+      FilePrivate *d;
     };
+
   }
+
 }
 
 #endif

taglib/mod/modfilebase.h

@@ -31,7 +31,9 @@
 #include <algorithm>
 
 namespace TagLib {
+
   namespace Mod {
+
     class TAGLIB_EXPORT FileBase : public TagLib::File
     {
     protected:
@@ -52,7 +54,9 @@ namespace TagLib {
       bool readU16B(ushort &number);
       bool readU32B(ulong &number);
     };
+
   }
+
 }
 
 #endif

taglib/mod/modproperties.cpp

@@ -33,7 +33,7 @@ public:
     lengthInPatterns(0)
   {
   }
-  
+
   int   channels;
   uint  instrumentCount;
   uchar lengthInPatterns;
@@ -70,7 +70,7 @@ int Mod::Properties::channels() const
   return d->channels;
 }
 
-uint Mod::Properties::instrumentCount() const
+TagLib::uint Mod::Properties::instrumentCount() const
 {
   return d->instrumentCount;
 }

taglib/mod/modproperties.h

@@ -26,35 +26,40 @@
 #include "audioproperties.h"
 
 namespace TagLib {
+
   namespace Mod {
-    class TAGLIB_EXPORT Properties : public AudioProperties {
-      friend class File;
+
+    class TAGLIB_EXPORT Properties : public AudioProperties
+    {
     public:
       Properties(AudioProperties::ReadStyle propertiesStyle);
       virtual ~Properties();
-      
-      int length()     const;
-      int bitrate()    const;
-      int sampleRate() const;
-      int channels()   const;
 
-      uint  instrumentCount()  const;
+      int length() const;
+      int bitrate() const;
+      int sampleRate() const;
+      int channels() const;
+
+      uint instrumentCount() const;
       uchar lengthInPatterns() const;
 
-    protected:
       void setChannels(int channels);
 
       void setInstrumentCount(uint sampleCount);
       void setLengthInPatterns(uchar lengthInPatterns);
 
     private:
+      friend class File;
+
       Properties(const Properties&);
       Properties &operator=(const Properties&);
 
       class PropertiesPrivate;
       PropertiesPrivate *d;
     };
+
   }
+
 }
 
 #endif

taglib/mod/modtag.cpp

@@ -20,6 +20,8 @@
  ***************************************************************************/
 
 #include "modtag.h"
+#include "tstringlist.h"
+#include "tpropertymap.h"
 
 using namespace TagLib;
 using namespace Mod;
@@ -71,12 +73,12 @@ String Mod::Tag::genre() const
   return String::null;
 }
 
-uint Mod::Tag::year() const
+TagLib::uint Mod::Tag::year() const
 {
   return 0;
 }
 
-uint Mod::Tag::track() const
+TagLib::uint Mod::Tag::track() const
 {
   return 0;
 }
@@ -120,3 +122,47 @@ void Mod::Tag::setTrackerName(const String &trackerName)
 {
   d->trackerName = trackerName;
 }
+
+PropertyMap Mod::Tag::properties() const
+{
+  PropertyMap properties;
+  properties["TITLE"] = d->title;
+  properties["COMMENT"] = d->comment;
+  if(!(d->trackerName.isNull()))
+    properties["TRACKERNAME"] = d->trackerName;
+  return properties;
+}
+
+PropertyMap Mod::Tag::setProperties(const PropertyMap &origProps)
+{
+  PropertyMap properties(origProps);
+  properties.removeEmpty();
+  StringList oneValueSet;
+  if(properties.contains("TITLE")) {
+    d->title = properties["TITLE"].front();
+    oneValueSet.append("TITLE");
+  } else
+    d->title = String::null;
+
+  if(properties.contains("COMMENT")) {
+    d->comment = properties["COMMENT"].front();
+    oneValueSet.append("COMMENT");
+  } else
+    d->comment = String::null;
+
+  if(properties.contains("TRACKERNAME")) {
+    d->trackerName = properties["TRACKERNAME"].front();
+    oneValueSet.append("TRACKERNAME");
+  } else
+    d->trackerName = String::null;
+
+  // for each tag that has been set above, remove the first entry in the corresponding
+  // value list. The others will be returned as unsupported by this format.
+  for(StringList::Iterator it = oneValueSet.begin(); it != oneValueSet.end(); ++it) {
+    if(properties[*it].size() == 1)
+      properties.erase(*it);
+    else
+      properties[*it].erase( properties[*it].begin() );
+  }
+  return properties;
+}

taglib/mod/modtag.h

@@ -25,7 +25,9 @@
 #include "tag.h"
 
 namespace TagLib {
+
   namespace Mod {
+
     /*!
      * Tags for module files (Mod, S3M, IT, XM).
      *
@@ -148,15 +150,31 @@ namespace TagLib {
       /*!
        * Sets the tracker name to \a trackerName.  If \a trackerName is
        * String::null then this value will be cleared.
-       * 
+       *
        * Note that only XM files support this tag.  Setting the
        * tracker name for other module file formats will be ignored.
-       * 
+       *
        * The length of this tag is limited to 20 characters (1 character
        * = 1 byte).
        */
       void setTrackerName(const String &trackerName);
 
+      /*!
+       * Implements the unified property interface -- export function.
+       * Since the module tag is very limited, the exported map is as well.
+       */
+      PropertyMap properties() const;
+
+      /*!
+       * Implements the unified property interface -- import function.
+       * Because of the limitations of the module file tag, any tags besides
+       * COMMENT, TITLE and, if it is an XM file, TRACKERNAME, will be
+       * returened. Additionally, if the map contains tags with multiple values,
+       * all but the first will be contained in the returned map of unsupported
+       * properties.
+       */
+      PropertyMap setProperties(const PropertyMap &);
+
     private:
       Tag(const Tag &);
       Tag &operator=(const Tag &);
@@ -164,7 +182,9 @@ namespace TagLib {
       class TagPrivate;
       TagPrivate *d;
     };
+
   }
+
 }
 
 #endif

taglib/mp4/mp4atom.cpp

@@ -23,10 +23,6 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <tdebug.h>
 #include <tstring.h>
 #include "mp4atom.h"
@@ -52,10 +48,10 @@ MP4::Atom::Atom(File *file)
     return;
   }
 
-  length = header.mid(0, 4).toUInt();
+  length = header.toUInt();
 
   if (length == 1) {
-    long long longLength = file->readBlock(8).toLongLong();
+    const long long longLength = file->readBlock(8).toLongLong();
     if (longLength >= 8 && longLength <= 0xFFFFFFFF) {
         // The atom has a 64-bit length, but it's actually a 32-bit value
         length = (long)longLength;

taglib/mp4/mp4atom.h

@@ -1,5 +1,5 @@
 /**************************************************************************
-    copyright            : (C) 2007 by Lukáš Lalinský
+    copyright            : (C) 2007,2011 by Lukáš Lalinský
     email                : lalinsky@gmail.com
  **************************************************************************/
 
@@ -40,6 +40,40 @@ namespace TagLib {
     class Atom;
     typedef TagLib::List<Atom *> AtomList;
 
+    enum AtomDataType
+    {
+      TypeImplicit  = 0,  // for use with tags for which no type needs to be indicated because only one type is allowed
+      TypeUTF8      = 1,  // without any count or null terminator
+      TypeUTF16     = 2,  // also known as UTF-16BE
+      TypeSJIS      = 3,  // deprecated unless it is needed for special Japanese characters
+      TypeHTML      = 6,  // the HTML file header specifies which HTML version
+      TypeXML       = 7,  // the XML header must identify the DTD or schemas
+      TypeUUID      = 8,  // also known as GUID; stored as 16 bytes in binary (valid as an ID)
+      TypeISRC      = 9,  // stored as UTF-8 text (valid as an ID)
+      TypeMI3P      = 10, // stored as UTF-8 text (valid as an ID)
+      TypeGIF       = 12, // (deprecated) a GIF image
+      TypeJPEG      = 13, // a JPEG image
+      TypePNG       = 14, // a PNG image
+      TypeURL       = 15, // absolute, in UTF-8 characters
+      TypeDuration  = 16, // in milliseconds, 32-bit integer
+      TypeDateTime  = 17, // in UTC, counting seconds since midnight, January 1, 1904; 32 or 64-bits
+      TypeGenred    = 18, // a list of enumerated values
+      TypeInteger   = 21, // a signed big-endian integer with length one of { 1,2,3,4,8 } bytes
+      TypeRIAAPA    = 24, // RIAA parental advisory; { -1=no, 1=yes, 0=unspecified }, 8-bit ingteger
+      TypeUPC       = 25, // Universal Product Code, in text UTF-8 format (valid as an ID)
+      TypeBMP       = 27, // Windows bitmap image
+      TypeUndefined = 255 // undefined
+    };
+
+    struct AtomData {
+      AtomData(AtomDataType type, ByteVector data) : type(type), locale(0), data(data) {}
+      AtomDataType type;
+      int locale;
+      ByteVector data;
+    };
+
+    typedef TagLib::List<AtomData> AtomDataList;
+
     class Atom
     {
     public:

taglib/mp4/mp4coverart.cpp

@@ -23,12 +23,9 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <taglib.h>
 #include <tdebug.h>
+#include "trefcounter.h"
 #include "mp4coverart.h"
 
 using namespace TagLib;

taglib/mp4/mp4coverart.h

@@ -29,6 +29,7 @@
 #include "tlist.h"
 #include "tbytevector.h"
 #include "taglib_export.h"
+#include "mp4atom.h"
 
 namespace TagLib {
 
@@ -41,8 +42,11 @@ namespace TagLib {
        * This describes the image type.
        */
       enum Format {
-        JPEG = 0x0D,
-        PNG  = 0x0E
+        JPEG    = TypeJPEG,
+        PNG     = TypePNG,
+        BMP     = TypeBMP,
+        GIF     = TypeGIF,
+        Unknown = TypeImplicit,
       };
 
       CoverArt(Format format, const ByteVector &data);

taglib/mp4/mp4file.cpp

@@ -23,12 +23,9 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <tdebug.h>
 #include <tstring.h>
+#include <tpropertymap.h>
 #include "mp4atom.h"
 #include "mp4tag.h"
 #include "mp4file.h"
@@ -67,14 +64,16 @@ MP4::File::File(FileName file, bool readProperties, AudioProperties::ReadStyle a
     : TagLib::File(file)
 {
   d = new FilePrivate;
-  read(readProperties, audioPropertiesStyle);
+  if(isOpen())
+    read(readProperties, audioPropertiesStyle);
 }
 
 MP4::File::File(IOStream *stream, bool readProperties, AudioProperties::ReadStyle audioPropertiesStyle)
     : TagLib::File(stream)
 {
   d = new FilePrivate;
-  read(readProperties, audioPropertiesStyle);
+  if(isOpen())
+    read(readProperties, audioPropertiesStyle);
 }
 
 MP4::File::~File()
@@ -88,6 +87,21 @@ MP4::File::tag() const
   return d->tag;
 }
 
+PropertyMap MP4::File::properties() const
+{
+  return d->tag->properties();
+}
+
+void MP4::File::removeUnsupportedProperties(const StringList &properties)
+{
+  d->tag->removeUnsupportedProperties(properties);
+}
+
+PropertyMap MP4::File::setProperties(const PropertyMap &properties)
+{
+  return d->tag->setProperties(properties);
+}
+
 MP4::Properties *
 MP4::File::audioProperties() const
 {

taglib/mp4/mp4file.h

@@ -49,24 +49,25 @@ namespace TagLib {
     {
     public:
       /*!
-       * Contructs a MP4 file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
+       * Constructs an MP4 file from \a file.  If \a readProperties is true the
+       * file's audio properties will also be read.
        *
-       * \note In the current implementation, both \a readProperties and
-       * \a propertiesStyle are ignored.
+       * \note In the current implementation, \a propertiesStyle is ignored.
        */
-      File(FileName file, bool readProperties = true, Properties::ReadStyle audioPropertiesStyle = Properties::Average);
+      File(FileName file, bool readProperties = true, 
+           Properties::ReadStyle audioPropertiesStyle = Properties::Average);
 
       /*!
-       * Contructs a MP4 file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
+       * Constructs an MP4 file from \a stream.  If \a readProperties is true the
+       * file's audio properties will also be read.
        *
-       * \note In the current implementation, both \a readProperties and
-       * \a propertiesStyle are ignored.
+       * \note TagLib will *not* take ownership of the stream, the caller is
+       * responsible for deleting it after the File object.
+       *
+       * \note In the current implementation, \a propertiesStyle is ignored.
        */
-      File(IOStream *stream, bool readProperties = true, Properties::ReadStyle audioPropertiesStyle = Properties::Average);
+      File(IOStream *stream, bool readProperties = true, 
+           Properties::ReadStyle audioPropertiesStyle = Properties::Average);
 
       /*!
        * Destroys this instance of the File.
@@ -85,6 +86,22 @@ namespace TagLib {
        */
       Tag *tag() const;
 
+      /*!
+       * Implements the unified property interface -- export function.
+       */
+      PropertyMap properties() const;
+
+      /*!
+       * Removes unsupported properties. Forwards to the actual Tag's
+       * removeUnsupportedProperties() function.
+       */
+      void removeUnsupportedProperties(const StringList &properties);
+
+      /*!
+       * Implements the unified property interface -- import function.
+       */
+      PropertyMap setProperties(const PropertyMap &);
+
       /*!
        * Returns the MP4 audio properties for this file.
        */

taglib/mp4/mp4item.cpp

@@ -23,12 +23,9 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <taglib.h>
 #include <tdebug.h>
+#include "trefcounter.h"
 #include "mp4item.h"
 
 using namespace TagLib;
@@ -36,15 +33,20 @@ using namespace TagLib;
 class MP4::Item::ItemPrivate : public RefCounter
 {
 public:
-  ItemPrivate() : RefCounter(), valid(true) {}
+  ItemPrivate() : RefCounter(), valid(true), atomDataType(TypeUndefined) {}
 
   bool valid;
+  AtomDataType atomDataType;
   union {
     bool m_bool;
     int m_int;
     IntPair m_intPair;
+    uchar m_byte;
+    uint m_uint;
+    long long m_longlong;
   };
   StringList m_stringList;
+  ByteVectorList m_byteVectorList;
   MP4::CoverArtList m_coverArtList;
 };
 
@@ -89,6 +91,24 @@ MP4::Item::Item(int value)
   d->m_int = value;
 }
 
+MP4::Item::Item(uchar value)
+{
+  d = new ItemPrivate;
+  d->m_byte = value;
+}
+
+MP4::Item::Item(uint value)
+{
+  d = new ItemPrivate;
+  d->m_uint = value;
+}
+
+MP4::Item::Item(long long value)
+{
+  d = new ItemPrivate;
+  d->m_longlong = value;
+}
+
 MP4::Item::Item(int value1, int value2)
 {
   d = new ItemPrivate;
@@ -96,6 +116,12 @@ MP4::Item::Item(int value1, int value2)
   d->m_intPair.second = value2;
 }
 
+MP4::Item::Item(const ByteVectorList &value)
+{
+  d = new ItemPrivate;
+  d->m_byteVectorList = value;
+}
+
 MP4::Item::Item(const StringList &value)
 {
   d = new ItemPrivate;
@@ -108,6 +134,16 @@ MP4::Item::Item(const MP4::CoverArtList &value)
   d->m_coverArtList = value;
 }
 
+void MP4::Item::setAtomDataType(MP4::AtomDataType type)
+{
+  d->atomDataType = type;
+}
+
+MP4::AtomDataType MP4::Item::atomDataType() const
+{
+  return d->atomDataType;
+}
+
 bool
 MP4::Item::toBool() const
 {
@@ -120,6 +156,24 @@ MP4::Item::toInt() const
   return d->m_int;
 }
 
+uchar
+MP4::Item::toByte() const
+{
+  return d->m_byte;
+}
+
+TagLib::uint
+MP4::Item::toUInt() const
+{
+  return d->m_uint;
+}
+
+long long
+MP4::Item::toLongLong() const
+{
+  return d->m_longlong;
+}
+
 MP4::Item::IntPair
 MP4::Item::toIntPair() const
 {
@@ -132,6 +186,12 @@ MP4::Item::toStringList() const
   return d->m_stringList;
 }
 
+ByteVectorList
+MP4::Item::toByteVectorList() const
+{
+  return d->m_byteVectorList;
+}
+
 MP4::CoverArtList
 MP4::Item::toCoverArtList() const
 {

taglib/mp4/mp4item.h

@@ -47,15 +47,26 @@ namespace TagLib {
       ~Item();
 
       Item(int value);
+      Item(uchar value);
+      Item(uint value);
+      Item(long long value);
       Item(bool value);
       Item(int first, int second);
       Item(const StringList &value);
+      Item(const ByteVectorList &value);
       Item(const CoverArtList &value);
 
+      void setAtomDataType(AtomDataType type);
+      AtomDataType atomDataType() const;
+
       int toInt() const;
+      uchar toByte() const;
+      uint toUInt() const;
+      long long toLongLong() const;
       bool toBool() const;
       IntPair toIntPair() const;
       StringList toStringList() const;
+      ByteVectorList toByteVectorList() const;
       CoverArtList toCoverArtList() const;
 
       bool isValid() const;

taglib/mp4/mp4properties.cpp

@@ -23,10 +23,6 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <tdebug.h>
 #include <tstring.h>
 #include "mp4file.h"
@@ -90,15 +86,24 @@ MP4::Properties::Properties(File *file, MP4::Atoms *atoms, ReadStyle style)
 
   file->seek(mdhd->offset);
   data = file->readBlock(mdhd->length);
-  if(data[8] == 0) {
-    unsigned int unit = data.mid(20, 4).toUInt();
-    unsigned int length = data.mid(24, 4).toUInt();
-    d->length = length / unit;
+  uint version = data[8];
+  if(version == 1) {
+    if (data.size() < 36 + 8) {
+      debug("MP4: Atom 'trak.mdia.mdhd' is smaller than expected");
+      return;
+    }
+    const long long unit   = data.toLongLong(28U);
+    const long long length = data.toLongLong(36U);
+    d->length = unit ? int(length / unit) : 0;
   }
   else {
-    long long unit = data.mid(28, 8).toLongLong();
-    long long length = data.mid(36, 8).toLongLong();
-    d->length = int(length / unit);
+    if (data.size() < 24 + 4) {
+      debug("MP4: Atom 'trak.mdia.mdhd' is smaller than expected");
+      return;
+    }
+    const unsigned int unit   = data.toUInt(20U);
+    const unsigned int length = data.toUInt(24U);
+    d->length = unit ? length / unit : 0;
   }
 
   MP4::Atom *atom = trak->find("mdia", "minf", "stbl", "stsd");
@@ -109,11 +114,11 @@ MP4::Properties::Properties(File *file, MP4::Atoms *atoms, ReadStyle style)
   file->seek(atom->offset);
   data = file->readBlock(atom->length);
   if(data.mid(20, 4) == "mp4a") {
-    d->channels = data.mid(40, 2).toShort();
-    d->bitsPerSample = data.mid(42, 2).toShort();
-    d->sampleRate = data.mid(46, 4).toUInt();
+    d->channels      = data.toShort(40U);
+    d->bitsPerSample = data.toShort(42U);
+    d->sampleRate    = data.toUInt(46U);
     if(data.mid(56, 4) == "esds" && data[64] == 0x03) {
-      long pos = 65;
+      uint pos = 65;
       if(data.mid(pos, 3) == "\x80\x80\x80") {
         pos += 3;
       }
@@ -124,16 +129,16 @@ MP4::Properties::Properties(File *file, MP4::Atoms *atoms, ReadStyle style)
           pos += 3;
         }
         pos += 10;
-        d->bitrate = (data.mid(pos, 4).toUInt() + 500) / 1000;
+        d->bitrate = (data.toUInt(pos) + 500) / 1000;
       }
     }
   }
   else if (data.mid(20, 4) == "alac") {
     if (atom->length == 88 && data.mid(56, 4) == "alac") {
       d->bitsPerSample = data.at(69);
-      d->channels = data.at(73);
-      d->bitrate = data.mid(80, 4).toUInt() / 1000;
-      d->sampleRate = data.mid(84, 4).toUInt();
+      d->channels   = data.at(73);
+      d->bitrate    = data.toUInt(80U) / 1000;
+      d->sampleRate = data.toUInt(84U);
     }
   }
 

taglib/mp4/mp4tag.cpp

@@ -1,5 +1,5 @@
 /**************************************************************************
-    copyright            : (C) 2007 by Lukáš Lalinský
+    copyright            : (C) 2007,2011 by Lukáš Lalinský
     email                : lalinsky@gmail.com
  **************************************************************************/
 
@@ -23,12 +23,9 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #include <tdebug.h>
 #include <tstring.h>
+#include <tpropertymap.h>
 #include "mp4atom.h"
 #include "mp4tag.h"
 #include "id3v1genres.h"
@@ -71,12 +68,23 @@ MP4::Tag::Tag(TagLib::File *file, MP4::Atoms *atoms)
     else if(atom->name == "trkn" || atom->name == "disk") {
       parseIntPair(atom, file);
     }
-    else if(atom->name == "cpil" || atom->name == "pgap" || atom->name == "pcst") {
+    else if(atom->name == "cpil" || atom->name == "pgap" || atom->name == "pcst" ||
+            atom->name == "hdvd") {
       parseBool(atom, file);
     }
     else if(atom->name == "tmpo") {
       parseInt(atom, file);
     }
+    else if(atom->name == "tvsn" || atom->name == "tves" || atom->name == "cnID" ||
+            atom->name == "sfID" || atom->name == "atID" || atom->name == "geID") {
+      parseUInt(atom, file);
+    }
+    else if(atom->name == "plID") {
+      parseLongLong(atom, file);
+    }
+    else if(atom->name == "stik" || atom->name == "rtng" || atom->name == "akID") {
+      parseByte(atom, file);
+    }
     else if(atom->name == "gnre") {
       parseGnre(atom, file);
     }
@@ -94,17 +102,17 @@ MP4::Tag::~Tag()
   delete d;
 }
 
-ByteVectorList
-MP4::Tag::parseData(MP4::Atom *atom, TagLib::File *file, int expectedFlags, bool freeForm)
+MP4::AtomDataList
+MP4::Tag::parseData2(MP4::Atom *atom, TagLib::File *file, int expectedFlags, bool freeForm)
 {
-  ByteVectorList result;
+  AtomDataList result;
   ByteVector data = file->readBlock(atom->length - 8);
   int i = 0;
   unsigned int pos = 0;
   while(pos < data.size()) {
-    int length = data.mid(pos, 4).toUInt();
+    const int length = static_cast<int>(data.toUInt(pos));
     ByteVector name = data.mid(pos + 4, 4);
-    int flags = data.mid(pos + 8, 4).toUInt();
+    const int flags = static_cast<int>(data.toUInt(pos + 8));
     if(freeForm && i < 2) {
       if(i == 0 && name != "mean") {
         debug("MP4: Unexpected atom \"" + name + "\", expecting \"mean\"");
@@ -114,7 +122,7 @@ MP4::Tag::parseData(MP4::Atom *atom, TagLib::File *file, int expectedFlags, bool
         debug("MP4: Unexpected atom \"" + name + "\", expecting \"name\"");
         return result;
       }
-      result.append(data.mid(pos + 12, length - 12));
+      result.append(AtomData(AtomDataType(flags), data.mid(pos + 12, length - 12)));
     }
     else {
       if(name != "data") {
@@ -122,7 +130,7 @@ MP4::Tag::parseData(MP4::Atom *atom, TagLib::File *file, int expectedFlags, bool
         return result;
       }
       if(expectedFlags == -1 || flags == expectedFlags) {
-        result.append(data.mid(pos + 16, length - 16));
+        result.append(AtomData(AtomDataType(flags), data.mid(pos + 16, length - 16)));
       }
     }
     pos += length;
@@ -131,12 +139,50 @@ MP4::Tag::parseData(MP4::Atom *atom, TagLib::File *file, int expectedFlags, bool
   return result;
 }
 
+ByteVectorList
+MP4::Tag::parseData(MP4::Atom *atom, TagLib::File *file, int expectedFlags, bool freeForm)
+{
+  AtomDataList data = parseData2(atom, file, expectedFlags, freeForm);
+  ByteVectorList result;
+  for(uint i = 0; i < data.size(); i++) {
+    result.append(data[i].data);
+  }
+  return result;
+}
+
 void
 MP4::Tag::parseInt(MP4::Atom *atom, TagLib::File *file)
 {
   ByteVectorList data = parseData(atom, file);
   if(data.size()) {
-    d->items.insert(atom->name, (int)data[0].toShort());
+    addItem(atom->name, (int)data[0].toShort());
+  }
+}
+
+void
+MP4::Tag::parseUInt(MP4::Atom *atom, TagLib::File *file)
+{
+  ByteVectorList data = parseData(atom, file);
+  if(data.size()) {
+    addItem(atom->name, data[0].toUInt());
+  }
+}
+
+void
+MP4::Tag::parseLongLong(MP4::Atom *atom, TagLib::File *file)
+{
+  ByteVectorList data = parseData(atom, file);
+  if(data.size()) {
+    addItem(atom->name, data[0].toLongLong());
+  }
+}
+
+void
+MP4::Tag::parseByte(MP4::Atom *atom, TagLib::File *file)
+{
+  ByteVectorList data = parseData(atom, file);
+  if(data.size()) {
+    addItem(atom->name, (uchar)data[0].at(0));
   }
 }
 
@@ -146,8 +192,8 @@ MP4::Tag::parseGnre(MP4::Atom *atom, TagLib::File *file)
   ByteVectorList data = parseData(atom, file);
   if(data.size()) {
     int idx = (int)data[0].toShort();
-    if(!d->items.contains("\251gen") && idx > 0) {
-      d->items.insert("\251gen", StringList(ID3v1::genre(idx - 1)));
+    if(idx > 0) {
+      addItem("\251gen", StringList(ID3v1::genre(idx - 1)));
     }
   }
 }
@@ -157,9 +203,9 @@ MP4::Tag::parseIntPair(MP4::Atom *atom, TagLib::File *file)
 {
   ByteVectorList data = parseData(atom, file);
   if(data.size()) {
-    int a = data[0].mid(2, 2).toShort();
-    int b = data[0].mid(4, 2).toShort();
-    d->items.insert(atom->name, MP4::Item(a, b));
+    const int a = data[0].toShort(2U);
+    const int b = data[0].toShort(4U);
+    addItem(atom->name, MP4::Item(a, b));
   }
 }
 
@@ -169,7 +215,7 @@ MP4::Tag::parseBool(MP4::Atom *atom, TagLib::File *file)
   ByteVectorList data = parseData(atom, file);
   if(data.size()) {
     bool value = data[0].size() ? data[0][0] != '\0' : false;
-    d->items.insert(atom->name, value);
+    addItem(atom->name, value);
   }
 }
 
@@ -182,21 +228,41 @@ MP4::Tag::parseText(MP4::Atom *atom, TagLib::File *file, int expectedFlags)
     for(unsigned int i = 0; i < data.size(); i++) {
       value.append(String(data[i], String::UTF8));
     }
-    d->items.insert(atom->name, value);
+    addItem(atom->name, value);
   }
 }
 
 void
 MP4::Tag::parseFreeForm(MP4::Atom *atom, TagLib::File *file)
 {
-  ByteVectorList data = parseData(atom, file, 1, true);
+  AtomDataList data = parseData2(atom, file, -1, true);
   if(data.size() > 2) {
-    StringList value;
-    for(unsigned int i = 2; i < data.size(); i++) {
-      value.append(String(data[i], String::UTF8));
+    String name = "----:" + String(data[0].data, String::UTF8) + ':' + String(data[1].data, String::UTF8);
+    AtomDataType type = data[2].type;
+    for(uint i = 2; i < data.size(); i++) {
+      if(data[i].type != type) {
+        debug("MP4: We currently don't support values with multiple types");
+        break;
+      }
+    }
+    if(type == TypeUTF8) {
+      StringList value;
+      for(uint i = 2; i < data.size(); i++) {
+        value.append(String(data[i].data, String::UTF8));
+      }
+      Item item(value);
+      item.setAtomDataType(type);
+      addItem(name, item);
+    }
+    else {
+      ByteVectorList value;
+      for(uint i = 2; i < data.size(); i++) {
+        value.append(data[i].data);
+      }
+      Item item(value);
+      item.setAtomDataType(type);
+      addItem(name, item);
     }
-    String name = "----:" + data[0] + ':' + data[1];
-    d->items.insert(name, value);
   }
 }
 
@@ -207,21 +273,24 @@ MP4::Tag::parseCovr(MP4::Atom *atom, TagLib::File *file)
   ByteVector data = file->readBlock(atom->length - 8);
   unsigned int pos = 0;
   while(pos < data.size()) {
-    int length = data.mid(pos, 4).toUInt();
+    const int length = static_cast<int>(data.toUInt(pos));
     ByteVector name = data.mid(pos + 4, 4);
-    int flags = data.mid(pos + 8, 4).toUInt();
+    const int flags = static_cast<int>(data.toUInt(pos + 8));
     if(name != "data") {
       debug("MP4: Unexpected atom \"" + name + "\", expecting \"data\"");
       break;
     }
-    if(flags == MP4::CoverArt::PNG || flags == MP4::CoverArt::JPEG) {
+    if(flags == TypeJPEG || flags == TypePNG || flags == TypeBMP || flags == TypeGIF || flags == TypeImplicit) {
       value.append(MP4::CoverArt(MP4::CoverArt::Format(flags),
                                  data.mid(pos + 16, length - 16)));
     }
+    else {
+      debug("MP4: Unknown covr format " + String::number(flags));
+    }
     pos += length;
   }
   if(value.size() > 0)
-    d->items.insert(atom->name, value);
+    addItem(atom->name, value);
 }
 
 ByteVector
@@ -254,7 +323,7 @@ MP4::Tag::renderBool(const ByteVector &name, MP4::Item &item)
 {
   ByteVectorList data;
   data.append(ByteVector(1, item.toBool() ? '\1' : '\0'));
-  return renderData(name, 0x15, data);
+  return renderData(name, TypeInteger, data);
 }
 
 ByteVector
@@ -262,7 +331,31 @@ MP4::Tag::renderInt(const ByteVector &name, MP4::Item &item)
 {
   ByteVectorList data;
   data.append(ByteVector::fromShort(item.toInt()));
-  return renderData(name, 0x15, data);
+  return renderData(name, TypeInteger, data);
+}
+
+ByteVector
+MP4::Tag::renderUInt(const ByteVector &name, MP4::Item &item)
+{
+  ByteVectorList data;
+  data.append(ByteVector::fromUInt(item.toUInt()));
+  return renderData(name, TypeInteger, data);
+}
+
+ByteVector
+MP4::Tag::renderLongLong(const ByteVector &name, MP4::Item &item)
+{
+  ByteVectorList data;
+  data.append(ByteVector::fromLongLong(item.toLongLong()));
+  return renderData(name, TypeInteger, data);
+}
+
+ByteVector
+MP4::Tag::renderByte(const ByteVector &name, MP4::Item &item)
+{
+  ByteVectorList data;
+  data.append(ByteVector(1, item.toByte()));
+  return renderData(name, TypeInteger, data);
 }
 
 ByteVector
@@ -273,7 +366,7 @@ MP4::Tag::renderIntPair(const ByteVector &name, MP4::Item &item)
               ByteVector::fromShort(item.toIntPair().first) +
               ByteVector::fromShort(item.toIntPair().second) +
               ByteVector(2, '\0'));
-  return renderData(name, 0x00, data);
+  return renderData(name, TypeImplicit, data);
 }
 
 ByteVector
@@ -283,7 +376,7 @@ MP4::Tag::renderIntPairNoTrailing(const ByteVector &name, MP4::Item &item)
   data.append(ByteVector(2, '\0') +
               ByteVector::fromShort(item.toIntPair().first) +
               ByteVector::fromShort(item.toIntPair().second));
-  return renderData(name, 0x00, data);
+  return renderData(name, TypeImplicit, data);
 }
 
 ByteVector
@@ -320,9 +413,26 @@ MP4::Tag::renderFreeForm(const String &name, MP4::Item &item)
   ByteVector data;
   data.append(renderAtom("mean", ByteVector::fromUInt(0) + header[1].data(String::UTF8)));
   data.append(renderAtom("name", ByteVector::fromUInt(0) + header[2].data(String::UTF8)));
-  StringList value = item.toStringList();
-  for(unsigned int i = 0; i < value.size(); i++) {
-    data.append(renderAtom("data", ByteVector::fromUInt(1) + ByteVector(4, '\0') + value[i].data(String::UTF8)));
+  AtomDataType type = item.atomDataType();
+  if(type == TypeUndefined) {
+    if(!item.toStringList().isEmpty()) {
+      type = TypeUTF8;
+    }
+    else {
+      type = TypeImplicit;
+    }
+  }
+  if(type == TypeUTF8) {
+    StringList value = item.toStringList();
+    for(unsigned int i = 0; i < value.size(); i++) {
+      data.append(renderAtom("data", ByteVector::fromUInt(type) + ByteVector(4, '\0') + value[i].data(String::UTF8)));
+    }
+  }
+  else {
+    ByteVectorList value = item.toByteVectorList();
+    for(unsigned int i = 0; i < value.size(); i++) {
+      data.append(renderAtom("data", ByteVector::fromUInt(type) + ByteVector(4, '\0') + value[i]));
+    }
   }
   return renderAtom("----", data);
 }
@@ -342,12 +452,22 @@ MP4::Tag::save()
     else if(name == "disk") {
       data.append(renderIntPairNoTrailing(name.data(String::Latin1), i->second));
     }
-    else if(name == "cpil" || name == "pgap" || name == "pcst") {
+    else if(name == "cpil" || name == "pgap" || name == "pcst" || name == "hdvd") {
       data.append(renderBool(name.data(String::Latin1), i->second));
     }
     else if(name == "tmpo") {
       data.append(renderInt(name.data(String::Latin1), i->second));
     }
+    else if(name == "tvsn" || name == "tves" || name == "cnID" ||
+            name == "sfID" || name == "atID" || name == "geID") {
+      data.append(renderUInt(name.data(String::Latin1), i->second));
+    }
+    else if(name == "plID") {
+      data.append(renderLongLong(name.data(String::Latin1), i->second));
+    }
+    else if(name == "stik" || name == "rtng" || name == "akID") {
+      data.append(renderByte(name.data(String::Latin1), i->second));
+    }
     else if(name == "covr") {
       data.append(renderCovr(name.data(String::Latin1), i->second));
     }
@@ -406,11 +526,11 @@ MP4::Tag::updateOffsets(long delta, long offset)
       }
       d->file->seek(atom->offset + 12);
       ByteVector data = d->file->readBlock(atom->length - 12);
-      unsigned int count = data.mid(0, 4).toUInt();
+      unsigned int count = data.toUInt();
       d->file->seek(atom->offset + 16);
-      int pos = 4;
+      uint pos = 4;
       while(count--) {
-        long o = data.mid(pos, 4).toUInt();
+        long o = static_cast<long>(data.toUInt(pos));
         if(o > offset) {
           o += delta;
         }
@@ -427,11 +547,11 @@ MP4::Tag::updateOffsets(long delta, long offset)
       }
       d->file->seek(atom->offset + 12);
       ByteVector data = d->file->readBlock(atom->length - 12);
-      unsigned int count = data.mid(0, 4).toUInt();
+      unsigned int count = data.toUInt();
       d->file->seek(atom->offset + 16);
-      int pos = 4;
+      uint pos = 4;
       while(count--) {
-        long long o = data.mid(pos, 8).toLongLong();
+        long long o = data.toLongLong(pos);
         if(o > offset) {
           o += delta;
         }
@@ -450,10 +570,10 @@ MP4::Tag::updateOffsets(long delta, long offset)
         atom->offset += delta;
       }
       d->file->seek(atom->offset + 9);
-      ByteVector data = d->file->readBlock(atom->offset - 9);
-      unsigned int flags = (ByteVector(1, '\0') + data.mid(0, 3)).toUInt();
+      ByteVector data = d->file->readBlock(atom->length - 9);
+      const unsigned int flags = data.toUInt(0, 3, true);
       if(flags & 1) {
-        long long o = data.mid(7, 8).toLongLong();
+        long long o = data.toLongLong(7U);
         if(o > offset) {
           o += delta;
         }
@@ -636,3 +756,162 @@ MP4::Tag::itemListMap()
   return d->items;
 }
 
+static const char *keyTranslation[][2] = {
+  { "\251nam", "TITLE" },
+  { "\251ART", "ARTIST" },
+  { "\251alb", "ALBUM" },
+  { "\251cmt", "COMMENT" },
+  { "\251gen", "GENRE" },
+  { "\251day", "DATE" },
+  { "\251wrt", "COMPOSER" },
+  { "\251grp", "GROUPING" },
+  { "trkn", "TRACKNUMBER" },
+  { "disk", "DISCNUMBER" },
+  { "cpil", "COMPILATION" },
+  { "tmpo", "BPM" },
+  { "cprt", "COPYRIGHT" },
+  { "\251lyr", "LYRICS" },
+  { "\251too", "ENCODEDBY" },
+  { "soal", "ALBUMSORT" },
+  { "soaa", "ALBUMARTISTSORT" },
+  { "soar", "ARTISTSORT" },
+  { "sonm", "TITLESORT" },
+  { "soco", "COMPOSERSORT" },
+  { "sosn", "SHOWSORT" },
+  { "----: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 Work Id", "MUSICBRAINZ_WORKID" },
+  { "----:com.apple.iTunes:ASIN", "ASIN" },
+  { "----:com.apple.iTunes:LABEL", "LABEL" },
+  { "----:com.apple.iTunes:LYRICIST", "LYRICIST" },
+  { "----:com.apple.iTunes:CONDUCTOR", "CONDUCTOR" },
+  { "----:com.apple.iTunes:REMIXER", "REMIXER" },
+  { "----:com.apple.iTunes:ENGINEER", "ENGINEER" },
+  { "----:com.apple.iTunes:PRODUCER", "PRODUCER" },
+  { "----:com.apple.iTunes:DJMIXER", "DJMIXER" },
+  { "----:com.apple.iTunes:MIXER", "MIXER" },
+  { "----:com.apple.iTunes:SUBTITLE", "SUBTITLE" },
+  { "----:com.apple.iTunes:DISCSUBTITLE", "DISCSUBTITLE" },
+  { "----:com.apple.iTunes:MOOD", "MOOD" },
+  { "----:com.apple.iTunes:ISRC", "ISRC" },
+  { "----:com.apple.iTunes:CATALOGNUMBER", "CATALOGNUMBER" },
+  { "----:com.apple.iTunes:BARCODE", "BARCODE" },
+  { "----:com.apple.iTunes:SCRIPT", "SCRIPT" },
+  { "----:com.apple.iTunes:LANGUAGE", "LANGUAGE" },
+  { "----:com.apple.iTunes:LICENSE", "LICENSE" },
+  { "----:com.apple.iTunes:MEDIA", "MEDIA" },
+};
+
+PropertyMap MP4::Tag::properties() const
+{
+  static Map<String, String> keyMap;
+  if(keyMap.isEmpty()) {
+    int numKeys = sizeof(keyTranslation) / sizeof(keyTranslation[0]);
+    for(int i = 0; i < numKeys; i++) {
+      keyMap[keyTranslation[i][0]] = keyTranslation[i][1];
+    }
+  }
+
+  PropertyMap props;
+  MP4::ItemListMap::ConstIterator it = d->items.begin();
+  for(; it != d->items.end(); ++it) {
+    if(keyMap.contains(it->first)) {
+      String key = keyMap[it->first];
+      if(key == "TRACKNUMBER" || key == "DISCNUMBER") {
+        MP4::Item::IntPair ip = it->second.toIntPair();
+        String value = String::number(ip.first);
+        if(ip.second) {
+          value += "/" + String::number(ip.second);
+        }
+        props[key] = value;
+      }
+      else if(key == "BPM") {
+        props[key] = String::number(it->second.toInt());
+      }
+      else if(key == "COMPILATION") {
+        props[key] = String::number(it->second.toBool());
+      }
+      else {
+        props[key] = it->second.toStringList();
+      }
+    }
+    else {
+      props.unsupportedData().append(it->first);
+    }
+  }
+  return props;
+}
+
+void MP4::Tag::removeUnsupportedProperties(const StringList &props)
+{
+  StringList::ConstIterator it = props.begin();
+  for(; it != props.end(); ++it)
+    d->items.erase(*it);
+}
+
+PropertyMap MP4::Tag::setProperties(const PropertyMap &props)
+{
+  static Map<String, String> reverseKeyMap;
+  if(reverseKeyMap.isEmpty()) {
+    int numKeys = sizeof(keyTranslation) / sizeof(keyTranslation[0]);
+    for(int i = 0; i < numKeys; i++) {
+      reverseKeyMap[keyTranslation[i][1]] = keyTranslation[i][0];
+    }
+  }
+
+  PropertyMap origProps = properties();
+  PropertyMap::ConstIterator it = origProps.begin();
+  for(; it != origProps.end(); ++it) {
+    if(!props.contains(it->first) || props[it->first].isEmpty()) {
+      d->items.erase(reverseKeyMap[it->first]);
+    }
+  }
+
+  PropertyMap ignoredProps;
+  it = props.begin();
+  for(; it != props.end(); ++it) {
+    if(reverseKeyMap.contains(it->first)) {
+      String name = reverseKeyMap[it->first];
+      if(it->first == "TRACKNUMBER" || it->first == "DISCNUMBER") {
+        int first = 0, second = 0;
+        StringList parts = StringList::split(it->second.front(), "/");
+        if(parts.size() > 0) {
+          first = parts[0].toInt();
+          if(parts.size() > 1) {
+            second = parts[1].toInt();
+          }
+          d->items[name] = MP4::Item(first, second);
+        }
+      }
+      else if(it->first == "BPM") {
+        int value = it->second.front().toInt();
+        d->items[name] = MP4::Item(value);
+      }
+      else if(it->first == "COMPILATION") {
+        bool value = (it->second.front().toInt() != 0);
+        d->items[name] = MP4::Item(value);
+      }
+      else {
+        d->items[name] = it->second;
+      }
+    }
+    else {
+      ignoredProps.insert(it->first, it->second);
+    }
+  }
+
+  return ignoredProps;
+}
+
+void MP4::Tag::addItem(const String &name, const Item &value)
+{
+  if(!d->items.contains(name)) {
+    d->items.insert(name, value);
+  }
+  else {
+    debug("MP4: Ignoring duplicate atom \"" + name + "\"");
+  }
+}

taglib/mp4/mp4tag.h

@@ -1,5 +1,5 @@
 /**************************************************************************
-    copyright            : (C) 2007 by Lukáš Lalinský
+    copyright            : (C) 2007,2011 by Lukáš Lalinský
     email                : lalinsky@gmail.com
  **************************************************************************/
 
@@ -67,11 +67,19 @@ namespace TagLib {
 
         ItemListMap &itemListMap();
 
+        PropertyMap properties() const;
+        void removeUnsupportedProperties(const StringList& properties);
+        PropertyMap setProperties(const PropertyMap &properties);
+
     private:
+        AtomDataList parseData2(Atom *atom, TagLib::File *file, int expectedFlags = -1, bool freeForm = false);
         TagLib::ByteVectorList parseData(Atom *atom, TagLib::File *file, int expectedFlags = -1, bool freeForm = false);
         void parseText(Atom *atom, TagLib::File *file, int expectedFlags = 1);
         void parseFreeForm(Atom *atom, TagLib::File *file);
         void parseInt(Atom *atom, TagLib::File *file);
+        void parseByte(Atom *atom, TagLib::File *file);
+        void parseUInt(Atom *atom, TagLib::File *file);
+        void parseLongLong(Atom *atom, TagLib::File *file);
         void parseGnre(Atom *atom, TagLib::File *file);
         void parseIntPair(Atom *atom, TagLib::File *file);
         void parseBool(Atom *atom, TagLib::File *file);
@@ -80,10 +88,13 @@ namespace TagLib {
         TagLib::ByteVector padIlst(const ByteVector &data, int length = -1);
         TagLib::ByteVector renderAtom(const ByteVector &name, const TagLib::ByteVector &data);
         TagLib::ByteVector renderData(const ByteVector &name, int flags, const TagLib::ByteVectorList &data);
-        TagLib::ByteVector renderText(const ByteVector &name, Item &item, int flags = 1);
+        TagLib::ByteVector renderText(const ByteVector &name, Item &item, int flags = TypeUTF8);
         TagLib::ByteVector renderFreeForm(const String &name, Item &item);
         TagLib::ByteVector renderBool(const ByteVector &name, Item &item);
         TagLib::ByteVector renderInt(const ByteVector &name, Item &item);
+        TagLib::ByteVector renderByte(const ByteVector &name, Item &item);
+        TagLib::ByteVector renderUInt(const ByteVector &name, Item &item);
+        TagLib::ByteVector renderLongLong(const ByteVector &name, Item &item);
         TagLib::ByteVector renderIntPair(const ByteVector &name, Item &item);
         TagLib::ByteVector renderIntPairNoTrailing(const ByteVector &name, Item &item);
         TagLib::ByteVector renderCovr(const ByteVector &name, Item &item);
@@ -94,6 +105,8 @@ namespace TagLib {
         void saveNew(TagLib::ByteVector &data);
         void saveExisting(TagLib::ByteVector &data, AtomList &path);
 
+        void addItem(const String &name, const Item &value);
+
         class TagPrivate;
         TagPrivate *d;
     };

taglib/mpc/mpcfile.cpp

@@ -27,6 +27,7 @@
 #include <tstring.h>
 #include <tagunion.h>
 #include <tdebug.h>
+#include <tpropertymap.h>
 
 #include "mpcfile.h"
 #include "id3v1tag.h"
@@ -38,7 +39,7 @@ using namespace TagLib;
 
 namespace
 {
-  enum { APEIndex, ID3v1Index };
+  enum { MPCAPEIndex = 0, MPCID3v1Index = 1 };
 }
 
 class MPC::File::FilePrivate
@@ -93,14 +94,16 @@ MPC::File::File(FileName file, bool readProperties,
                 Properties::ReadStyle propertiesStyle) : TagLib::File(file)
 {
   d = new FilePrivate;
-  read(readProperties, propertiesStyle);
+  if(isOpen())
+    read(readProperties, propertiesStyle);
 }
 
 MPC::File::File(IOStream *stream, bool readProperties,
                 Properties::ReadStyle propertiesStyle) : TagLib::File(stream)
 {
   d = new FilePrivate;
-  read(readProperties, propertiesStyle);
+  if(isOpen())
+    read(readProperties, propertiesStyle);
 }
 
 MPC::File::~File()
@@ -113,6 +116,30 @@ TagLib::Tag *MPC::File::tag() const
   return &d->tag;
 }
 
+PropertyMap MPC::File::properties() const
+{
+  if(d->hasAPE)
+    return d->tag.access<APE::Tag>(MPCAPEIndex, false)->properties();
+  if(d->hasID3v1)
+    return d->tag.access<ID3v1::Tag>(MPCID3v1Index, false)->properties();
+  return PropertyMap();
+}
+
+void MPC::File::removeUnsupportedProperties(const StringList &properties)
+{
+  if(d->hasAPE)
+    d->tag.access<APE::Tag>(MPCAPEIndex, false)->removeUnsupportedProperties(properties);
+  if(d->hasID3v1)
+    d->tag.access<ID3v1::Tag>(MPCID3v1Index, false)->removeUnsupportedProperties(properties);
+}
+
+PropertyMap MPC::File::setProperties(const PropertyMap &properties)
+{
+  if(d->hasID3v1)
+    d->tag.access<APE::Tag>(MPCID3v1Index, false)->setProperties(properties);
+  return d->tag.access<APE::Tag>(MPCAPEIndex, true)->setProperties(properties);
+}
+
 MPC::Properties *MPC::File::audioProperties() const
 {
   return d->properties;
@@ -196,18 +223,18 @@ bool MPC::File::save()
 
 ID3v1::Tag *MPC::File::ID3v1Tag(bool create)
 {
-  return d->tag.access<ID3v1::Tag>(ID3v1Index, create);
+  return d->tag.access<ID3v1::Tag>(MPCID3v1Index, create);
 }
 
 APE::Tag *MPC::File::APETag(bool create)
 {
-  return d->tag.access<APE::Tag>(APEIndex, create);
+  return d->tag.access<APE::Tag>(MPCAPEIndex, create);
 }
 
 void MPC::File::strip(int tags)
 {
   if(tags & ID3v1) {
-    d->tag.set(ID3v1Index, 0);
+    d->tag.set(MPCID3v1Index, 0);
     APETag(true);
   }
 
@@ -217,7 +244,7 @@ void MPC::File::strip(int tags)
   }
 
   if(tags & APE) {
-    d->tag.set(APEIndex, 0);
+    d->tag.set(MPCAPEIndex, 0);
 
     if(!ID3v1Tag())
       APETag(true);
@@ -229,6 +256,15 @@ void MPC::File::remove(int tags)
   strip(tags);
 }
 
+bool MPC::File::hasID3v1Tag() const
+{
+  return d->hasID3v1;
+}
+
+bool MPC::File::hasAPETag() const
+{
+  return d->hasAPE;
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 // private members
@@ -241,7 +277,7 @@ void MPC::File::read(bool readProperties, Properties::ReadStyle /* propertiesSty
   d->ID3v1Location = findID3v1();
 
   if(d->ID3v1Location >= 0) {
-    d->tag.set(ID3v1Index, new ID3v1::Tag(this, d->ID3v1Location));
+    d->tag.set(MPCID3v1Index, new ID3v1::Tag(this, d->ID3v1Location));
     d->hasID3v1 = true;
   }
 
@@ -252,7 +288,7 @@ void MPC::File::read(bool readProperties, Properties::ReadStyle /* propertiesSty
   d->APELocation = findAPE();
 
   if(d->APELocation >= 0) {
-    d->tag.set(APEIndex, new APE::Tag(this, d->APELocation));
+    d->tag.set(MPCAPEIndex, new APE::Tag(this, d->APELocation));
 
     d->APESize = APETag()->footer()->completeTagSize();
     d->APELocation = d->APELocation + APETag()->footer()->size() - d->APESize;
@@ -281,8 +317,7 @@ void MPC::File::read(bool readProperties, Properties::ReadStyle /* propertiesSty
   // Look for MPC metadata
 
   if(readProperties) {
-    d->properties = new Properties(readBlock(MPC::HeaderSize),
-                                   length() - d->ID3v2Size - d->APESize);
+    d->properties = new Properties(this, length() - d->ID3v2Size - d->APESize);
   }
 }
 

taglib/mpc/mpcfile.h

@@ -28,9 +28,12 @@
 
 #include "taglib_export.h"
 #include "tfile.h"
+#include "tag.h"
 
 #include "mpcproperties.h"
 
+#include "tlist.h"
+
 namespace TagLib {
 
   class Tag;
@@ -81,17 +84,22 @@ namespace TagLib {
       };
 
       /*!
-       * Contructs an MPC file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
+       * Constructs an MPC file from \a file.  If \a readProperties is true the
+       * file's audio properties will also be read.
+       *
+       * \note In the current implementation, \a propertiesStyle is ignored.
        */
       File(FileName file, bool readProperties = true,
            Properties::ReadStyle propertiesStyle = Properties::Average);
 
       /*!
-       * Contructs an MPC file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
+       * Constructs an MPC file from \a stream.  If \a readProperties is true the
+       * file's audio properties will also be read.
+       *
+       * \note TagLib will *not* take ownership of the stream, the caller is
+       * responsible for deleting it after the File object.
+       *
+       * \note In the current implementation, \a propertiesStyle is ignored.
        */
       File(IOStream *stream, bool readProperties = true,
            Properties::ReadStyle propertiesStyle = Properties::Average);
@@ -107,6 +115,22 @@ namespace TagLib {
        */
       virtual TagLib::Tag *tag() const;
 
+      /*!
+       * Implements the unified property interface -- export function.
+       * If the file contains both an APE and an ID3v1 tag, only the APE
+       * tag  will be converted to the PropertyMap.
+       */
+      PropertyMap properties() const;
+
+      void removeUnsupportedProperties(const StringList &properties);
+
+      /*!
+       * Implements the unified property interface -- import function.
+       * Affects only the APEv2 tag which will be created if necessary.
+       * If an ID3v1 tag exists, it will be updated as well.
+       */
+      PropertyMap setProperties(const PropertyMap &);
+
       /*!
        * Returns the MPC::Properties for this file.  If no audio properties
        * were read then this will return a null pointer.
@@ -121,28 +145,39 @@ namespace TagLib {
       /*!
        * Returns a pointer to the ID3v1 tag of the file.
        *
-       * If \a create is false (the default) this will return a null pointer
-       * if there is no valid ID3v1 tag.  If \a create is true it will create
-       * an ID3v1 tag if one does not exist. If there is already an APE tag, the
-       * new ID3v1 tag will be placed after it.
+       * If \a create is false (the default) this returns a null pointer
+       * if there is no valid APE tag.  If \a create is true it will create
+       * an APE tag if one does not exist and returns a valid pointer.
        *
-       * \note The Tag <b>is still</b> owned by the APE::File and should not be
+       * \note This may return a valid pointer regardless of whether or not the 
+       * file on disk has an ID3v1 tag.  Use hasID3v1Tag() to check if the file 
+       * on disk actually has an ID3v1 tag.
+       *
+       * \note The Tag <b>is still</b> owned by the MPEG::File and should not be
        * deleted by the user.  It will be deleted when the file (object) is
        * destroyed.
+       *
+       * \see hasID3v1Tag()
        */
       ID3v1::Tag *ID3v1Tag(bool create = false);
 
       /*!
        * Returns a pointer to the APE tag of the file.
        *
-       * If \a create is false (the default) this will return a null pointer
+       * If \a create is false (the default) this may return a null pointer
        * if there is no valid APE tag.  If \a create is true it will create
-       * a APE tag if one does not exist. If there is already an ID3v1 tag, thes
-       * new APE tag will be placed before it.
+       * an APE tag if one does not exist and returns a valid pointer.  If 
+       * there already be an ID3v1 tag, the new APE tag will be placed before it.
        *
-       * \note The Tag <b>is still</b> owned by the APE::File and should not be
+       * \note This may return a valid pointer regardless of whether or not the 
+       * file on disk has an APE tag.  Use hasAPETag() to check if the file 
+       * on disk actually has an APE tag.
+       *
+       * \note The Tag <b>is still</b> owned by the MPEG::File and should not be
        * deleted by the user.  It will be deleted when the file (object) is
        * destroyed.
+       *
+       * \see hasAPETag()
        */
       APE::Tag *APETag(bool create = false);
 
@@ -163,6 +198,19 @@ namespace TagLib {
        */
       void remove(int tags = AllTags);
 
+      /*!
+       * Returns whether or not the file on disk actually has an ID3v1 tag.
+       *
+       * \see ID3v1Tag()
+       */
+      bool hasID3v1Tag() const;
+
+      /*!
+       * Returns whether or not the file on disk actually has an APE tag.
+       *
+       * \see APETag()
+       */
+      bool hasAPETag() const;
 
     private:
       File(const File &);

taglib/mpc/mpcproperties.cpp

@@ -26,6 +26,7 @@
 #include <tstring.h>
 #include <tdebug.h>
 #include <bitset>
+#include <math.h>
 
 #include "mpcproperties.h"
 #include "mpcfile.h"
@@ -35,17 +36,21 @@ using namespace TagLib;
 class MPC::Properties::PropertiesPrivate
 {
 public:
-  PropertiesPrivate(const ByteVector &d, long length, ReadStyle s) :
-    data(d),
+  PropertiesPrivate(long length, ReadStyle s) :
     streamLength(length),
     style(s),
     version(0),
     length(0),
     bitrate(0),
     sampleRate(0),
-    channels(0) {}
+    channels(0),
+    totalFrames(0),
+    sampleFrames(0),
+    trackGain(0),
+    trackPeak(0),
+    albumGain(0),
+    albumPeak(0) {}
 
-  ByteVector data;
   long streamLength;
   ReadStyle style;
   int version;
@@ -53,6 +58,13 @@ public:
   int bitrate;
   int sampleRate;
   int channels;
+  uint totalFrames;
+  uint sampleFrames;
+  uint trackGain;
+  uint trackPeak;
+  uint albumGain;
+  uint albumPeak;
+  String flags;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -61,8 +73,22 @@ public:
 
 MPC::Properties::Properties(const ByteVector &data, long streamLength, ReadStyle style) : AudioProperties(style)
 {
-  d = new PropertiesPrivate(data, streamLength, style);
-  read();
+  d = new PropertiesPrivate(streamLength, style);
+  readSV7(data);
+}
+
+MPC::Properties::Properties(File *file, long streamLength, ReadStyle style) : AudioProperties(style)
+{
+  d = new PropertiesPrivate(streamLength, style);
+  ByteVector magic = file->readBlock(4);
+  if(magic == "MPCK") {
+    // Musepack version 8
+    readSV8(file);
+  }
+  else {
+    // Musepack version 7 or older, fixed size header
+    readSV7(magic + file->readBlock(MPC::HeaderSize - 4));
+  }
 }
 
 MPC::Properties::~Properties()
@@ -95,30 +121,179 @@ int MPC::Properties::mpcVersion() const
   return d->version;
 }
 
+TagLib::uint MPC::Properties::totalFrames() const
+{
+  return d->totalFrames;
+}
+
+TagLib::uint MPC::Properties::sampleFrames() const
+{
+  return d->sampleFrames;
+}
+
+int MPC::Properties::trackGain() const
+{
+  return d->trackGain;
+}
+
+int MPC::Properties::trackPeak() const
+{
+  return d->trackPeak;
+}
+
+int MPC::Properties::albumGain() const
+{
+  return d->albumGain;
+}
+
+int MPC::Properties::albumPeak() const
+{
+  return d->albumPeak;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // private members
 ////////////////////////////////////////////////////////////////////////////////
 
+unsigned long readSize(File *file, TagLib::uint &sizelength)
+{
+  unsigned char tmp;
+  unsigned long size = 0;
+
+  do {
+    ByteVector b = file->readBlock(1);
+    tmp = b[0];
+    size = (size << 7) | (tmp & 0x7F);
+    sizelength++;
+  } while((tmp & 0x80));
+  return size;
+}
+
+unsigned long readSize(const ByteVector &data, TagLib::uint &sizelength)
+{
+  unsigned char tmp;
+  unsigned long size = 0;
+  unsigned long pos = 0;
+
+  do {
+    tmp = data[pos++];
+    size = (size << 7) | (tmp & 0x7F);
+    sizelength++;
+  } while((tmp & 0x80) && (pos < data.size()));
+  return size;
+}
+
 static const unsigned short sftable [4] = { 44100, 48000, 37800, 32000 };
 
-void MPC::Properties::read()
+void MPC::Properties::readSV8(File *file)
 {
-  if(!d->data.startsWith("MP+"))
-    return;
+  bool readSH = false, readRG = false;
 
-  d->version = d->data[3] & 15;
+  while(!readSH && !readRG) {
+    ByteVector packetType = file->readBlock(2);
+    uint packetSizeLength = 0;
+    unsigned long packetSize = readSize(file, packetSizeLength);
+    unsigned long dataSize = packetSize - 2 - packetSizeLength;
 
-  unsigned int frames;
+    if(packetType == "SH") {
+      // Stream Header
+      // http://trac.musepack.net/wiki/SV8Specification#StreamHeaderPacket
+      ByteVector data = file->readBlock(dataSize);
+      readSH = true;
 
-  if(d->version >= 7) {
-    frames = d->data.mid(4, 4).toUInt(false);
+      TagLib::uint pos = 4;
+      d->version = data[pos];
+      pos += 1;
+      d->sampleFrames = readSize(data.mid(pos), pos);
+      ulong begSilence = readSize(data.mid(pos), pos);
 
-    std::bitset<32> flags(TAGLIB_CONSTRUCT_BITSET(d->data.mid(8, 4).toUInt(false)));
+      std::bitset<16> flags(TAGLIB_CONSTRUCT_BITSET(data.toUShort(pos, true)));
+      pos += 2;
+
+      d->sampleRate = sftable[flags[15] * 4 + flags[14] * 2 + flags[13]];
+      d->channels = flags[7] * 8 + flags[6] * 4 + flags[5] * 2 + flags[4] + 1;
+
+      if((d->sampleFrames - begSilence) != 0)
+        d->bitrate = (int)(d->streamLength * 8.0 * d->sampleRate / (d->sampleFrames - begSilence));
+      d->bitrate = d->bitrate / 1000;
+
+      d->length = (d->sampleFrames - begSilence) / d->sampleRate;
+    }
+
+    else if (packetType == "RG") {
+      // Replay Gain
+      // http://trac.musepack.net/wiki/SV8Specification#ReplaygainPacket
+      ByteVector data = file->readBlock(dataSize);
+      readRG = true;
+
+      int replayGainVersion = data[0];
+      if(replayGainVersion == 1) {
+        d->trackGain = data.toShort(1, true);
+        d->trackPeak = data.toShort(3, true);
+        d->albumGain = data.toShort(5, true);
+        d->albumPeak = data.toShort(7, true);
+      }
+    }
+
+    else if(packetType == "SE") {
+      break;
+    }
+
+    else {
+      file->seek(dataSize, File::Current);
+    }
+  }
+}
+
+void MPC::Properties::readSV7(const ByteVector &data)
+{
+  if(data.startsWith("MP+")) {
+    d->version = data[3] & 15;
+    if(d->version < 7)
+      return;
+
+    d->totalFrames = data.toUInt(4, false);
+
+    std::bitset<32> flags(TAGLIB_CONSTRUCT_BITSET(data.toUInt(8, false)));
     d->sampleRate = sftable[flags[17] * 2 + flags[16]];
     d->channels = 2;
+
+    uint gapless = data.toUInt(5, false);
+
+    d->trackGain = data.toShort(14, false);
+    d->trackPeak = data.toShort(12, false);
+    d->albumGain = data.toShort(18, false);
+    d->albumPeak = data.toShort(16, false);
+
+    // convert gain info
+    if(d->trackGain != 0) {
+      int tmp = (int)((64.82 - (short)d->trackGain / 100.) * 256. + .5);
+      if(tmp >= (1 << 16) || tmp < 0) tmp = 0;
+      d->trackGain = tmp;
+    }
+
+    if(d->albumGain != 0) {
+      int tmp = (int)((64.82 - d->albumGain / 100.) * 256. + .5);
+      if(tmp >= (1 << 16) || tmp < 0) tmp = 0;
+      d->albumGain = tmp;
+    }
+
+    if (d->trackPeak != 0)
+      d->trackPeak = (int)(log10((double)d->trackPeak) * 20 * 256 + .5);
+
+    if (d->albumPeak != 0)
+      d->albumPeak = (int)(log10((double)d->albumPeak) * 20 * 256 + .5);
+
+    bool trueGapless = (gapless >> 31) & 0x0001;
+    if(trueGapless) {
+      uint lastFrameSamples = (gapless >> 20) & 0x07FF;
+      d->sampleFrames = d->totalFrames * 1152 - lastFrameSamples;
+    }
+    else
+      d->sampleFrames = d->totalFrames * 1152 - 576;
   }
   else {
-    uint headerData = d->data.mid(0, 4).toUInt(false);
+    uint headerData = data.toUInt(0, false);
 
     d->bitrate = (headerData >> 23) & 0x01ff;
     d->version = (headerData >> 11) & 0x03ff;
@@ -126,15 +301,16 @@ void MPC::Properties::read()
     d->channels = 2;
 
     if(d->version >= 5)
-      frames = d->data.mid(4, 4).toUInt(false);
+      d->totalFrames = data.toUInt(4, false);
     else
-      frames = d->data.mid(6, 2).toUInt(false);
+      d->totalFrames = data.toUShort(6, false);
+
+    d->sampleFrames = d->totalFrames * 1152 - 576;
   }
 
-  uint samples = frames * 1152 - 576;
-
-  d->length = d->sampleRate > 0 ? (samples + (d->sampleRate / 2)) / d->sampleRate : 0;
+  d->length = d->sampleRate > 0 ? (d->sampleFrames + (d->sampleRate / 2)) / d->sampleRate : 0;
 
   if(!d->bitrate)
     d->bitrate = d->length > 0 ? ((d->streamLength * 8L) / d->length) / 1000 : 0;
 }
+

taglib/mpc/mpcproperties.h

@@ -50,9 +50,17 @@ namespace TagLib {
       /*!
        * Create an instance of MPC::Properties with the data read from the
        * ByteVector \a data.
+       *
+       * This constructor is deprecated. It only works for MPC version up to 7.
        */
       Properties(const ByteVector &data, long streamLength, ReadStyle style = Average);
 
+      /*!
+       * Create an instance of MPC::Properties with the data read directly
+       * from a MPC::File.
+       */
+      Properties(File *file, long streamLength, ReadStyle style = Average);
+
       /*!
        * Destroys this MPC::Properties instance.
        */
@@ -66,15 +74,44 @@ namespace TagLib {
       virtual int channels() const;
 
       /*!
-       * Returns the version of the bitstream (SV4-SV7)
+       * Returns the version of the bitstream (SV4-SV8)
        */
       int mpcVersion() const;
+      uint totalFrames() const;
+      uint sampleFrames() const;
+
+      /*!
+      * Returns the track gain as an integer value,
+      * to convert to dB: trackGain in dB = 64.82 - (trackGain / 256)
+      */
+      int trackGain() const;
+
+      /*!
+      * Returns the track peak as an integer value,
+      * to convert to dB: trackPeak in dB = trackPeak / 256
+      * to convert to floating [-1..1]: trackPeak = 10^(trackPeak / 256 / 20)/32768
+      */
+      int trackPeak() const;
+
+      /*!
+      * Returns the album gain as an integer value,
+      * to convert to dB: albumGain in dB = 64.82 - (albumGain / 256)
+      */
+      int albumGain() const;
+
+      /*!
+      * Returns the album peak as an integer value,
+      * to convert to dB: albumPeak in dB = albumPeak / 256
+      * to convert to floating [-1..1]: albumPeak = 10^(albumPeak / 256 / 20)/32768
+      */
+      int albumPeak() const;
 
     private:
       Properties(const Properties &);
       Properties &operator=(const Properties &);
 
-      void read();
+      void readSV7(const ByteVector &data);
+      void readSV8(File *file);
 
       class PropertiesPrivate;
       PropertiesPrivate *d;

taglib/mpeg/id3v1/id3v1tag.cpp

@@ -51,12 +51,17 @@ public:
   static const StringHandler *stringHandler;
 };
 
-const ID3v1::StringHandler *ID3v1::Tag::TagPrivate::stringHandler = new StringHandler;
+static const StringHandler defaultStringHandler;
+const ID3v1::StringHandler *ID3v1::Tag::TagPrivate::stringHandler = &defaultStringHandler;
 
 ////////////////////////////////////////////////////////////////////////////////
 // StringHandler implementation
 ////////////////////////////////////////////////////////////////////////////////
 
+StringHandler::StringHandler()
+{
+}
+
 String ID3v1::StringHandler::parse(const ByteVector &data) const
 {
   return String(data, String::Latin1).stripWhiteSpace();
@@ -177,20 +182,32 @@ void ID3v1::Tag::setGenre(const String &s)
   d->genre = ID3v1::genreIndex(s);
 }
 
-void ID3v1::Tag::setYear(uint i)
+void ID3v1::Tag::setYear(TagLib::uint i)
 {
   d->year = i > 0 ? String::number(i) : String::null;
 }
 
-void ID3v1::Tag::setTrack(uint i)
+void ID3v1::Tag::setTrack(TagLib::uint i)
 {
   d->track = i < 256 ? i : 0;
 }
 
+TagLib::uint ID3v1::Tag::genreNumber() const
+{
+  return d->genre;
+}
+
+void ID3v1::Tag::setGenreNumber(TagLib::uint i)
+{
+  d->genre = i < 256 ? i : 255;
+}
+
 void ID3v1::Tag::setStringHandler(const StringHandler *handler)
 {
-  delete TagPrivate::stringHandler;
-  TagPrivate::stringHandler = handler;
+  if (handler)
+    TagPrivate::stringHandler = handler;
+  else
+    TagPrivate::stringHandler = &defaultStringHandler;
 }
 
 ////////////////////////////////////////////////////////////////////////////////

taglib/mpeg/id3v1/id3v1tag.h

@@ -62,6 +62,7 @@ namespace TagLib {
       TAGLIB_IGNORE_MISSING_DESTRUCTOR
     public:
       // BIC: Add virtual destructor.
+      StringHandler();
 
       /*!
        * Decode a string from \a data.  The default implementation assumes that
@@ -139,20 +140,40 @@ namespace TagLib {
       virtual String album() const;
       virtual String comment() const;
       virtual String genre() const;
-      virtual uint year() const;
-      virtual uint track() const;
+      virtual TagLib::uint year() const;
+      virtual TagLib::uint track() const;
 
       virtual void setTitle(const String &s);
       virtual void setArtist(const String &s);
       virtual void setAlbum(const String &s);
       virtual void setComment(const String &s);
       virtual void setGenre(const String &s);
-      virtual void setYear(uint i);
-      virtual void setTrack(uint i);
+      virtual void setYear(TagLib::uint i);
+      virtual void setTrack(TagLib::uint i);
+
+      /*!
+       * Returns the genre in number.
+       *
+       * /note Normally 255 indicates that this tag contains no genre.
+       */
+      TagLib::uint genreNumber() const;
+
+      /*!
+       * Sets the genre in number to \a i.
+       *
+       * /note Valid value is from 0 up to 255. Normally 255 indicates that
+       * this tag contains no genre.
+       */
+      void setGenreNumber(TagLib::uint i);
 
       /*!
        * Sets the string handler that decides how the ID3v1 data will be
        * converted to and from binary data.
+       * If the parameter \a handler is null, the previous handler is
+       * released and default ISO-8859-1 handler is restored.
+       *
+       * \note The caller is responsible for deleting the previous handler
+       * as needed after it is released.
        *
        * \see StringHandler
        */

taglib/mpeg/id3v2/frames/commentsframe.cpp

@@ -29,6 +29,7 @@
 #include <tstringlist.h>
 
 #include "commentsframe.h"
+#include "tpropertymap.h"
 
 using namespace TagLib;
 using namespace ID3v2;
@@ -109,6 +110,19 @@ void CommentsFrame::setTextEncoding(String::Type encoding)
   d->textEncoding = encoding;
 }
 
+PropertyMap CommentsFrame::asProperties() const
+{
+  String key = description().upper();
+  PropertyMap map;
+  if(key.isEmpty() || key == "COMMENT")
+    map.insert("COMMENT", text());
+  else if(key.isNull())
+    map.unsupportedData().append(L"COMM/" + description());
+  else
+    map.insert("COMMENT:" + key, text());
+  return map;
+}
+
 CommentsFrame *CommentsFrame::findByDescription(const ID3v2::Tag *tag, const String &d) // static
 {
   ID3v2::FrameList comments = tag->frameList("COMM");
@@ -144,8 +158,13 @@ void CommentsFrame::parseFields(const ByteVector &data)
   ByteVectorList l = ByteVectorList::split(data.mid(4), textDelimiter(d->textEncoding), byteAlign, 2);
 
   if(l.size() == 2) {
-    d->description = String(l.front(), d->textEncoding);
-    d->text = String(l.back(), d->textEncoding);
+    if(d->textEncoding == String::Latin1) {
+      d->description = Tag::latin1StringHandler()->parse(l.front());
+      d->text = Tag::latin1StringHandler()->parse(l.back());
+    } else {
+      d->description = String(l.front(), d->textEncoding);
+      d->text = String(l.back(), d->textEncoding);
+    }  
   }
 }
 

taglib/mpeg/id3v2/frames/commentsframe.h

@@ -136,6 +136,17 @@ namespace TagLib {
        */
       void setTextEncoding(String::Type encoding);
 
+      /*!
+       * Parses this frame as PropertyMap with a single key.
+       * - if description() is empty or "COMMENT", the key will be "COMMENT"
+       * - if description() is not a valid PropertyMap key, the frame will be
+       *   marked unsupported by an entry "COMM/<description>" in the unsupportedData()
+       *   attribute of the returned map.
+       * - otherwise, the key will be "COMMENT:<description>"
+       * - The single value will be the frame's text().
+       */
+      PropertyMap asProperties() const;
+
       /*!
        * Comments each have a unique description.  This searches for a comment
        * frame with the decription \a d and returns a pointer to it.  If no

taglib/mpeg/id3v2/frames/ownershipframe.cpp

@@ -0,0 +1,162 @@
+/***************************************************************************
+    copyright            : (C) 2012 by Rupert Daniel
+    email                : rupert@cancelmonday.com
+ ***************************************************************************/
+
+/***************************************************************************
+ *   This library is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU Lesser General Public License version   *
+ *   2.1 as published by the Free Software Foundation.                     *
+ *                                                                         *
+ *   This library is distributed in the hope that it will be useful, but   *
+ *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
+ *   Lesser General Public License for more details.                       *
+ *                                                                         *
+ *   You should have received a copy of the GNU Lesser General Public      *
+ *   License along with this library; if not, write to the Free Software   *
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  USA                                                       *
+ *                                                                         *
+ *   Alternatively, this file is available under the Mozilla Public        *
+ *   License Version 1.1.  You may obtain a copy of the License at         *
+ *   http://www.mozilla.org/MPL/                                           *
+ ***************************************************************************/
+
+#include <tdebug.h>
+
+#include "ownershipframe.h"
+#include <id3v2tag.h>
+
+using namespace TagLib;
+using namespace ID3v2;
+
+class OwnershipFrame::OwnershipFramePrivate
+{
+public:
+  String pricePaid;
+  String datePurchased;
+  String seller;
+  String::Type textEncoding;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// public members
+////////////////////////////////////////////////////////////////////////////////
+
+OwnershipFrame::OwnershipFrame(String::Type encoding) : Frame("OWNE")
+{
+  d = new OwnershipFramePrivate;
+  d->textEncoding = encoding;
+}
+
+OwnershipFrame::OwnershipFrame(const ByteVector &data) : Frame(data)
+{
+  d = new OwnershipFramePrivate;
+  setData(data);
+}
+
+OwnershipFrame::~OwnershipFrame()
+{
+  delete d;
+}
+
+String OwnershipFrame::toString() const
+{
+  return "pricePaid=" + d->pricePaid + " datePurchased=" + d->datePurchased + " seller=" + d->seller;
+}
+
+String OwnershipFrame::pricePaid() const
+{
+  return d->pricePaid;
+}
+
+void OwnershipFrame::setPricePaid(const String &s)
+{
+  d->pricePaid = s;
+}
+
+String OwnershipFrame::datePurchased() const
+{
+  return d->datePurchased;
+}
+
+void OwnershipFrame::setDatePurchased(const String &s)
+{
+  d->datePurchased = s;
+}
+
+String OwnershipFrame::seller() const
+{
+  return d->seller;
+}
+
+void OwnershipFrame::setSeller(const String &s)
+{
+  d->seller = s;
+}
+
+String::Type OwnershipFrame::textEncoding() const
+{
+  return d->textEncoding;
+}
+
+void OwnershipFrame::setTextEncoding(String::Type encoding)
+{
+  d->textEncoding = encoding;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// protected members
+////////////////////////////////////////////////////////////////////////////////
+
+void OwnershipFrame::parseFields(const ByteVector &data)
+{
+  int pos = 0;
+  
+  // Get the text encoding
+  d->textEncoding = String::Type(data[0]);
+  pos += 1;
+  
+  // Read the price paid this is a null terminate string
+  d->pricePaid = readStringField(data, String::Latin1, &pos);
+  
+  // If we don't have at least 8 bytes left then don't parse the rest of the
+  // data
+  if(data.size() - pos < 8) {
+    return;
+  }
+  
+  // Read the date purchased YYYYMMDD
+  d->datePurchased = String(data.mid(pos, 8));
+  pos += 8;
+  
+  // Read the seller
+  if(d->textEncoding == String::Latin1)
+    d->seller = Tag::latin1StringHandler()->parse(data.mid(pos));
+  else
+    d->seller = String(data.mid(pos), d->textEncoding);
+}
+
+ByteVector OwnershipFrame::renderFields() const
+{
+  ByteVector v;
+  
+  v.append(char(d->textEncoding));
+  v.append(d->pricePaid.data(String::Latin1));
+  v.append(textDelimiter(String::Latin1));
+  v.append(d->datePurchased.data(String::Latin1));
+  v.append(d->seller.data(d->textEncoding));
+ 
+  return v;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// private members
+////////////////////////////////////////////////////////////////////////////////
+
+OwnershipFrame::OwnershipFrame(const ByteVector &data, Header *h) : Frame(h)
+{
+  d = new OwnershipFramePrivate;
+  parseFields(fieldData(data));
+}

taglib/mpeg/id3v2/frames/ownershipframe.h

@@ -0,0 +1,151 @@
+/***************************************************************************
+    copyright            : (C) 2012 by Rupert Daniel
+    email                : rupert@cancelmonday.com
+ ***************************************************************************/
+
+/***************************************************************************
+ *   This library is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU Lesser General Public License version   *
+ *   2.1 as published by the Free Software Foundation.                     *
+ *                                                                         *
+ *   This library is distributed in the hope that it will be useful, but   *
+ *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
+ *   Lesser General Public License for more details.                       *
+ *                                                                         *
+ *   You should have received a copy of the GNU Lesser General Public      *
+ *   License along with this library; if not, write to the Free Software   *
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA         *
+ *   02110-1301  USA                                                       *
+ *                                                                         *
+ *   Alternatively, this file is available under the Mozilla Public        *
+ *   License Version 1.1.  You may obtain a copy of the License at         *
+ *   http://www.mozilla.org/MPL/                                           *
+ ***************************************************************************/
+
+#ifndef TAGLIB_OWNERSHIPFRAME_H
+#define TAGLIB_OWNERSHIPFRAME_H
+
+#include "id3v2frame.h"
+#include "taglib_export.h"
+
+namespace TagLib {
+
+  namespace ID3v2 {
+
+    //! An implementation of ID3v2 "ownership"
+
+    /*!
+     * This implements the ID3v2 ownership (OWNE frame).  It consists of
+     * a price paid, a date purchased (YYYYMMDD) and the name of the seller.
+     */
+
+    class TAGLIB_EXPORT OwnershipFrame : public Frame
+    {
+      friend class FrameFactory;
+
+    public:
+      /*!
+       * Construct an empty ownership frame.
+       */
+      explicit OwnershipFrame(String::Type encoding = String::Latin1);
+
+      /*!
+       * Construct a ownership based on the data in \a data.
+       */
+      explicit OwnershipFrame(const ByteVector &data);
+
+      /*!
+       * Destroys this OwnershipFrame instance.
+       */
+      virtual ~OwnershipFrame();
+
+      /*!
+       * Returns the text of this popularimeter.
+       *
+       * \see text()
+       */
+      virtual String toString() const;
+
+      /*!
+       * Returns the date purchased.
+       *
+       * \see setDatePurchased()
+       */
+      String datePurchased() const;
+
+      /*!
+       * Set the date purchased.
+       *
+       * \see datePurchased()
+       */
+      void setDatePurchased(const String &datePurchased);
+
+      /*!
+       * Returns the price paid.
+       *
+       * \see setPricePaid()
+       */
+      String pricePaid() const;
+
+      /*!
+       * Set the price paid.
+       *
+       * \see pricePaid()
+       */
+      void setPricePaid(const String &pricePaid);
+      
+      /*!
+       * Returns the seller.
+       *
+       * \see setSeller()
+       */
+      String seller() const;
+      
+      /*!
+       * Set the seller.
+       *
+       * \see seller()
+       */
+      void setSeller(const String &seller);
+      
+      /*!
+       * Returns the text encoding that will be used in rendering this frame.
+       * This defaults to the type that was either specified in the constructor
+       * or read from the frame when parsed.
+       *
+       * \see setTextEncoding()
+       * \see render()
+       */
+      String::Type textEncoding() const;
+      
+      /*!
+       * Sets the text encoding to be used when rendering this frame to
+       * \a encoding.
+       *
+       * \see textEncoding()
+       * \see render()
+       */
+      void setTextEncoding(String::Type encoding);
+
+    protected:
+      // Reimplementations.
+
+      virtual void parseFields(const ByteVector &data);
+      virtual ByteVector renderFields() const;
+
+    private:
+      /*!
+       * The constructor used by the FrameFactory.
+       */
+      OwnershipFrame(const ByteVector &data, Header *h);
+      OwnershipFrame(const OwnershipFrame &);
+      OwnershipFrame &operator=(const OwnershipFrame &);
+
+      class OwnershipFramePrivate;
+      OwnershipFramePrivate *d;
+    };
+
+  }
+}
+#endif

taglib/mpeg/id3v2/frames/popularimeterframe.cpp

@@ -109,7 +109,7 @@ void PopularimeterFrame::parseFields(const ByteVector &data)
   if(pos < size) {
     d->rating = (unsigned char)(data[pos++]);
     if(pos < size) {
-      d->counter = data.mid(pos, 4).toUInt();
+      d->counter = data.toUInt(static_cast<uint>(pos));
     }
   }
 }

taglib/mpeg/id3v2/frames/privateframe.cpp

@@ -98,7 +98,7 @@ void PrivateFrame::parseFields(const ByteVector &data)
   }
 
   // Owner identifier is assumed to be Latin1
-  
+
   const int byteAlign =  1;
   const int endOfOwner = data.find(textDelimiter(String::Latin1), 0, byteAlign);
 

taglib/mpeg/id3v2/frames/relativevolumeframe.cpp

@@ -191,7 +191,7 @@ void RelativeVolumeFrame::parseFields(const ByteVector &data)
 
     ChannelData &channel = d->channels[type];
 
-    channel.volumeAdjustment = data.mid(pos, 2).toShort();
+    channel.volumeAdjustment = data.toShort(static_cast<uint>(pos));
     pos += 2;
 
     channel.peakVolume.bitsRepresentingPeak = data[pos];

taglib/mpeg/id3v2/frames/textidentificationframe.cpp

@@ -25,8 +25,9 @@
 
 #include <tbytevectorlist.h>
 #include <id3v2tag.h>
-
 #include "textidentificationframe.h"
+#include "tpropertymap.h"
+#include "id3v1genres.h"
 
 using namespace TagLib;
 using namespace ID3v2;
@@ -57,6 +58,32 @@ TextIdentificationFrame::TextIdentificationFrame(const ByteVector &data) :
   setData(data);
 }
 
+TextIdentificationFrame *TextIdentificationFrame::createTIPLFrame(const PropertyMap &properties) // static
+{
+  TextIdentificationFrame *frame = new TextIdentificationFrame("TIPL");
+  StringList l;
+  for(PropertyMap::ConstIterator it = properties.begin(); it != properties.end(); ++it){
+    l.append(it->first);
+    l.append(it->second.toString(",")); // comma-separated list of names
+  }
+  frame->setText(l);
+  return frame;
+}
+
+TextIdentificationFrame *TextIdentificationFrame::createTMCLFrame(const PropertyMap &properties) // static
+{
+  TextIdentificationFrame *frame = new TextIdentificationFrame("TMCL");
+  StringList l;
+  for(PropertyMap::ConstIterator it = properties.begin(); it != properties.end(); ++it){
+    if(!it->first.startsWith(instrumentPrefix)) // should not happen
+      continue;
+    l.append(it->first.substr(instrumentPrefix.size()));
+    l.append(it->second.toString(","));
+  }
+  frame->setText(l);
+  return frame;
+}
+
 TextIdentificationFrame::~TextIdentificationFrame()
 {
   delete d;
@@ -92,6 +119,61 @@ void TextIdentificationFrame::setTextEncoding(String::Type encoding)
   d->textEncoding = encoding;
 }
 
+// array of allowed TIPL prefixes and their corresponding key value
+static const TagLib::uint involvedPeopleSize = 5;
+static const char* involvedPeople[][2] = {
+    {"ARRANGER", "ARRANGER"},
+    {"ENGINEER", "ENGINEER"},
+    {"PRODUCER", "PRODUCER"},
+    {"DJ-MIX", "DJMIXER"},
+    {"MIX", "MIXER"},
+};
+
+const KeyConversionMap &TextIdentificationFrame::involvedPeopleMap() // static
+{
+  static KeyConversionMap m;
+  if(m.isEmpty())
+    for(uint i = 0; i < involvedPeopleSize; ++i)
+      m.insert(involvedPeople[i][1], involvedPeople[i][0]);
+  return m;
+}
+
+PropertyMap TextIdentificationFrame::asProperties() const
+{
+  if(frameID() == "TIPL")
+    return makeTIPLProperties();
+  if(frameID() == "TMCL")
+    return makeTMCLProperties();
+  PropertyMap map;
+  String tagName = frameIDToKey(frameID());
+  if(tagName.isNull()) {
+    map.unsupportedData().append(frameID());
+    return map;
+  }
+  StringList values = fieldList();
+  if(tagName == "GENRE") {
+    // Special case: Support ID3v1-style genre numbers. They are not officially supported in
+    // ID3v2, however it seems that still a lot of programs use them.
+    for(StringList::Iterator it = values.begin(); it != values.end(); ++it) {
+      bool ok = false;
+      int test = it->toInt(&ok); // test if the genre value is an integer
+      if(ok)
+        *it = ID3v1::genre(test);
+    }
+  } else if(tagName == "DATE") {
+    for(StringList::Iterator it = values.begin(); it != values.end(); ++it) {
+      // ID3v2 specifies ISO8601 timestamps which contain a 'T' as separator between date and time.
+      // Since this is unusual in other formats, the T is removed.
+      int tpos = it->find("T");
+      if(tpos != -1)
+        (*it)[tpos] = ' ';
+    }
+  }
+  PropertyMap ret;
+  ret.insert(tagName, values);
+  return ret;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // TextIdentificationFrame protected members
 ////////////////////////////////////////////////////////////////////////////////
@@ -131,8 +213,10 @@ void TextIdentificationFrame::parseFields(const ByteVector &data)
 
   for(ByteVectorList::Iterator it = l.begin(); it != l.end(); it++) {
     if(!(*it).isEmpty()) {
-      String s(*it, d->textEncoding);
-      d->fieldList.append(s);
+      if(d->textEncoding == String::Latin1)
+        d->fieldList.append(Tag::latin1StringHandler()->parse(*it));
+      else
+        d->fieldList.append(String(*it, d->textEncoding));    
     }
   }
 }
@@ -170,6 +254,55 @@ TextIdentificationFrame::TextIdentificationFrame(const ByteVector &data, Header
   parseFields(fieldData(data));
 }
 
+PropertyMap TextIdentificationFrame::makeTIPLProperties() const
+{
+  PropertyMap map;
+  if(fieldList().size() % 2 != 0){
+    // according to the ID3 spec, TIPL must contain an even number of entries
+    map.unsupportedData().append(frameID());
+    return map;
+  }
+  StringList l = fieldList();
+  for(StringList::ConstIterator it = l.begin(); it != l.end(); ++it) {
+    bool found = false;
+    for(uint i = 0; i < involvedPeopleSize; ++i)
+      if(*it == involvedPeople[i][0]) {
+        map.insert(involvedPeople[i][1], (++it)->split(","));
+        found = true;
+        break;
+      }
+    if(!found){
+      // invalid involved role -> mark whole frame as unsupported in order to be consisten with writing
+      map.clear();
+      map.unsupportedData().append(frameID());
+      return map;
+    }
+  }
+  return map;
+}
+
+PropertyMap TextIdentificationFrame::makeTMCLProperties() const
+{
+  PropertyMap map;
+  if(fieldList().size() % 2 != 0){
+    // according to the ID3 spec, TMCL must contain an even number of entries
+    map.unsupportedData().append(frameID());
+    return map;
+  }
+  StringList l = fieldList();
+  for(StringList::ConstIterator it = l.begin(); it != l.end(); ++it) {
+    String instrument = it->upper();
+    if(instrument.isNull()) {
+      // instrument is not a valid key -> frame unsupported
+      map.clear();
+      map.unsupportedData().append(frameID());
+      return map;
+    }
+    map.insert(L"PERFORMER:" + instrument, (++it)->split(","));
+  }
+  return map;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // UserTextIdentificationFrame public members
 ////////////////////////////////////////////////////////////////////////////////
@@ -191,6 +324,14 @@ UserTextIdentificationFrame::UserTextIdentificationFrame(const ByteVector &data)
   checkFields();
 }
 
+UserTextIdentificationFrame::UserTextIdentificationFrame(const String &description, const StringList &values, String::Type encoding) :
+    TextIdentificationFrame("TXXX", encoding),
+    d(0)
+{
+  setDescription(description);
+  setText(values);
+}
+
 String UserTextIdentificationFrame::toString() const
 {
   return "[" + description() + "] " + fieldList().toString();
@@ -238,6 +379,17 @@ void UserTextIdentificationFrame::setDescription(const String &s)
   TextIdentificationFrame::setText(l);
 }
 
+PropertyMap UserTextIdentificationFrame::asProperties() const
+{
+  PropertyMap map;
+  String tagName = txxxToKey(description());
+  StringList v = fieldList();
+  for(StringList::ConstIterator it = v.begin(); it != v.end(); ++it)
+    if(it != v.begin())
+      map.insert(tagName, *it);
+  return map;
+}
+
 UserTextIdentificationFrame *UserTextIdentificationFrame::find(
   ID3v2::Tag *tag, const String &description) // static
 {

taglib/mpeg/id3v2/frames/textidentificationframe.h

@@ -27,6 +27,7 @@
 #define TAGLIB_TEXTIDENTIFICATIONFRAME_H
 
 #include "tstringlist.h"
+#include "tmap.h"
 #include "taglib_export.h"
 
 #include "id3v2frame.h"
@@ -36,6 +37,7 @@ namespace TagLib {
   namespace ID3v2 {
 
     class Tag;
+    typedef Map<String, String> KeyConversionMap;
 
     //! An ID3v2 text identification frame implementation
 
@@ -123,6 +125,20 @@ namespace TagLib {
        */
       explicit TextIdentificationFrame(const ByteVector &data);
 
+      /*!
+       * This is a special factory method to create a TIPL (involved people list)
+       * frame from the given \a properties. Will parse key=[list of values] data
+       * into the TIPL format as specified in the ID3 standard.
+       */
+      static TextIdentificationFrame *createTIPLFrame(const PropertyMap &properties);
+
+      /*!
+       * This is a special factory method to create a TMCL (musician credits list)
+       * frame from the given \a properties. Will parse key=[list of values] data
+       * into the TMCL format as specified in the ID3 standard, where key should be
+       * of the form instrumentPrefix:instrument.
+       */
+      static TextIdentificationFrame *createTMCLFrame(const PropertyMap &properties);
       /*!
        * Destroys this TextIdentificationFrame instance.
        */
@@ -173,6 +189,14 @@ namespace TagLib {
        */
       StringList fieldList() const;
 
+      /*!
+       * Returns a KeyConversionMap mapping a role as it would be  used in a PropertyMap
+       * to the corresponding key used in a TIPL ID3 frame to describe that role.
+       */
+      static const KeyConversionMap &involvedPeopleMap();
+
+      PropertyMap asProperties() const;
+
     protected:
       // Reimplementations.
 
@@ -188,6 +212,16 @@ namespace TagLib {
       TextIdentificationFrame(const TextIdentificationFrame &);
       TextIdentificationFrame &operator=(const TextIdentificationFrame &);
 
+      /*!
+       * Parses the special structure of a TIPL frame
+       * Only the whitelisted roles "ARRANGER", "ENGINEER", "PRODUCER",
+       * "DJMIXER" (ID3: "DJ-MIX") and "MIXER" (ID3: "MIX") are allowed.
+       */
+      PropertyMap makeTIPLProperties() const;
+      /*!
+       * Parses the special structure of a TMCL frame.
+       */
+      PropertyMap makeTMCLProperties() const;
       class TextIdentificationFramePrivate;
       TextIdentificationFramePrivate *d;
     };
@@ -218,6 +252,12 @@ namespace TagLib {
        */
       explicit UserTextIdentificationFrame(const ByteVector &data);
 
+      /*!
+       * Creates a user defined text identification frame with the given \a description
+       * and \a values.
+       */
+      UserTextIdentificationFrame(const String &description, const StringList &values, String::Type encoding = String::UTF8);
+
       virtual String toString() const;
 
       /*!
@@ -236,6 +276,21 @@ namespace TagLib {
       void setText(const String &text);
       void setText(const StringList &fields);
 
+      /*!
+       * A UserTextIdentificationFrame is parsed into a PropertyMap as follows:
+       * - the key is the frame's description, uppercased
+       * - if the description contains '::', only the substring after that
+       *   separator is considered as key (compatibility with exfalso)
+       * - if the above rules don't yield a valid key (e.g. containing non-ASCII
+       *   characters), the returned map will contain an entry "TXXX/<description>"
+       *   in its unsupportedData() list.
+       * - The values will be copies of the fieldList().
+       * - If the description() appears as value in fieldList(), it will be omitted
+       *   in the value list, in order to be compatible with TagLib which copies
+       *   the description() into the fieldList().
+       */
+      PropertyMap asProperties() const;
+
       /*!
        * Searches for the user defined text frame with the description \a description
        * in \a tag.  This returns null if no matching frames were found.

taglib/mpeg/id3v2/frames/uniquefileidentifierframe.cpp

@@ -24,8 +24,10 @@
  ***************************************************************************/
 
 #include <tbytevectorlist.h>
+#include <tpropertymap.h>
 #include <tdebug.h>
 
+#include "id3v2tag.h"
 #include "uniquefileidentifierframe.h"
 
 using namespace TagLib;
@@ -87,6 +89,34 @@ String UniqueFileIdentifierFrame::toString() const
   return String::null;
 }
 
+PropertyMap UniqueFileIdentifierFrame::asProperties() const
+{
+  PropertyMap map;
+  if(d->owner == "http://musicbrainz.org") {
+    map.insert("MUSICBRAINZ_TRACKID", String(d->identifier));
+  }
+  else {
+    map.unsupportedData().append(frameID() + String("/") + d->owner);
+  }
+  return map;
+}
+
+UniqueFileIdentifierFrame *UniqueFileIdentifierFrame::findByOwner(const ID3v2::Tag *tag, const String &o) // static
+{
+  ID3v2::FrameList comments = tag->frameList("UFID");
+
+  for(ID3v2::FrameList::ConstIterator it = comments.begin();
+      it != comments.end();
+      ++it)
+  {
+    UniqueFileIdentifierFrame *frame = dynamic_cast<UniqueFileIdentifierFrame *>(*it);
+    if(frame && frame->owner() == o)
+      return frame;
+  }
+
+  return 0;
+}
+
 void UniqueFileIdentifierFrame::parseFields(const ByteVector &data)
 {
   if(data.size() < 1) {

taglib/mpeg/id3v2/frames/uniquefileidentifierframe.h

@@ -94,13 +94,23 @@ namespace TagLib {
 
       virtual String toString() const;
 
+      PropertyMap asProperties() const;
+
+      /*!
+       * UFID frames each have a unique owner. This searches for a UFID
+       * frame with the owner \a o and returns a pointer to it.
+       *
+       * \see owner()
+       */
+      static UniqueFileIdentifierFrame *findByOwner(const Tag *tag, const String &o);
+
     protected:
       virtual void parseFields(const ByteVector &data);
       virtual ByteVector renderFields() const;
 
     private:
       UniqueFileIdentifierFrame(const UniqueFileIdentifierFrame &);
-      UniqueFileIdentifierFrame &operator=(UniqueFileIdentifierFrame &);
+      UniqueFileIdentifierFrame &operator=(const UniqueFileIdentifierFrame &);
 
       UniqueFileIdentifierFrame(const ByteVector &data, Header *h);
 

taglib/mpeg/id3v2/frames/unsynchronizedlyricsframe.cpp

@@ -27,7 +27,9 @@
 
 #include "unsynchronizedlyricsframe.h"
 #include <tbytevectorlist.h>
+#include <id3v2tag.h>
 #include <tdebug.h>
+#include <tpropertymap.h>
 
 using namespace TagLib;
 using namespace ID3v2;
@@ -111,6 +113,30 @@ void UnsynchronizedLyricsFrame::setTextEncoding(String::Type encoding)
   d->textEncoding = encoding;
 }
 
+PropertyMap UnsynchronizedLyricsFrame::asProperties() const
+{
+  PropertyMap map;
+  String key = description().upper();
+  if(key.isEmpty() || key.upper() == "LYRICS")
+    map.insert("LYRICS", text());
+  else if(key.isNull())
+    map.unsupportedData().append(L"USLT/" + description());
+  else
+    map.insert("LYRICS:" + key, text());
+  return map;
+}
+
+UnsynchronizedLyricsFrame *UnsynchronizedLyricsFrame::findByDescription(const ID3v2::Tag *tag, const String &d) // static
+{
+  ID3v2::FrameList lyrics = tag->frameList("USLT");
+
+  for(ID3v2::FrameList::ConstIterator it = lyrics.begin(); it != lyrics.end(); ++it){
+    UnsynchronizedLyricsFrame *frame = dynamic_cast<UnsynchronizedLyricsFrame *>(*it);
+    if(frame && frame->description() == d)
+      return frame;
+  }
+  return 0;
+}
 ////////////////////////////////////////////////////////////////////////////////
 // protected members
 ////////////////////////////////////////////////////////////////////////////////
@@ -132,8 +158,13 @@ void UnsynchronizedLyricsFrame::parseFields(const ByteVector &data)
     ByteVectorList::split(data.mid(4), textDelimiter(d->textEncoding), byteAlign, 2);
 
   if(l.size() == 2) {
-    d->description = String(l.front(), d->textEncoding);
-    d->text = String(l.back(), d->textEncoding);
+    if(d->textEncoding == String::Latin1) {
+      d->description = Tag::latin1StringHandler()->parse(l.front());
+      d->text = Tag::latin1StringHandler()->parse(l.back());
+    } else {
+      d->description = String(l.front(), d->textEncoding);
+      d->text = String(l.back(), d->textEncoding);
+    }  
   }
 }
 

taglib/mpeg/id3v2/frames/unsynchronizedlyricsframe.h

@@ -134,6 +134,28 @@ namespace TagLib {
        */
       void setTextEncoding(String::Type encoding);
 
+
+      /*! Parses this frame as PropertyMap with a single key.
+       * - if description() is empty or "LYRICS", the key will be "LYRICS"
+       * - if description() is not a valid PropertyMap key, the frame will be
+       *   marked unsupported by an entry "USLT/<description>" in the unsupportedData()
+       *   attribute of the returned map.
+       * - otherwise, the key will be "LYRICS:<description>"
+       * - The single value will be the frame's text().
+       * Note that currently the language() field is not supported by the PropertyMap
+       * interface.
+       */
+      PropertyMap asProperties() const;
+
+      /*!
+       * LyricsFrames each have a unique description.  This searches for a lyrics
+       * frame with the decription \a d and returns a pointer to it.  If no
+       * frame is found that matches the given description null is returned.
+       *
+       * \see description()
+       */
+      static UnsynchronizedLyricsFrame *findByDescription(const Tag *tag, const String &d);
+
     protected:
       // Reimplementations.
 

taglib/mpeg/id3v2/frames/urllinkframe.cpp

@@ -26,8 +26,10 @@
  ***************************************************************************/
 
 #include "urllinkframe.h"
+#include "id3v2tag.h"
 #include <tdebug.h>
 #include <tstringlist.h>
+#include <tpropertymap.h>
 
 using namespace TagLib;
 using namespace ID3v2;
@@ -78,6 +80,18 @@ String UrlLinkFrame::toString() const
   return url();
 }
 
+PropertyMap UrlLinkFrame::asProperties() const
+{
+  String key = frameIDToKey(frameID());
+  PropertyMap map;
+  if(key.isNull())
+    // unknown W*** frame - this normally shouldn't happen
+    map.unsupportedData().append(frameID());
+  else
+    map.insert(key, url());
+  return map;
+}
+
 void UrlLinkFrame::parseFields(const ByteVector &data)
 {
   d->url = String(data);
@@ -139,6 +153,30 @@ void UserUrlLinkFrame::setDescription(const String &s)
   d->description = s;
 }
 
+PropertyMap UserUrlLinkFrame::asProperties() const
+{
+  PropertyMap map;
+  String key = description().upper();
+  if(key.isEmpty() || key.upper() == "URL")
+    map.insert("URL", url());
+  else if(key.isNull())
+    map.unsupportedData().append(L"WXXX/" + description());
+  else
+    map.insert("URL:" + key, url());
+  return map;
+}
+
+UserUrlLinkFrame *UserUrlLinkFrame::find(ID3v2::Tag *tag, const String &description) // static
+{
+  FrameList l = tag->frameList("WXXX");
+  for(FrameList::Iterator it = l.begin(); it != l.end(); ++it) {
+    UserUrlLinkFrame *f = dynamic_cast<UserUrlLinkFrame *>(*it);
+    if(f && f->description() == description)
+      return f;
+  }
+  return 0;
+}
+
 void UserUrlLinkFrame::parseFields(const ByteVector &data)
 {
   if(data.size() < 2) {

taglib/mpeg/id3v2/frames/urllinkframe.h

@@ -68,6 +68,7 @@ namespace TagLib {
 
       virtual void setText(const String &s);
       virtual String toString() const;
+      PropertyMap asProperties() const;
 
     protected:
       virtual void parseFields(const ByteVector &data);
@@ -150,6 +151,22 @@ namespace TagLib {
        */
       void setDescription(const String &s);
 
+      /*!
+       * Parses the UserUrlLinkFrame as PropertyMap. The description() is taken as key,
+       * and the URL as single value.
+       * - if description() is empty, the key will be "URL".
+       * - otherwise, if description() is not a valid key (e.g. containing non-ASCII
+       *   characters), the returned map will contain an entry "WXXX/<description>"
+       *   in its unsupportedData() list.
+       */
+      PropertyMap asProperties() const;
+
+      /*!
+       * Searches for the user defined url frame with the description \a description
+       * in \a tag.  This returns null if no matching frames were found.
+       */
+      static UserUrlLinkFrame *find(Tag *tag, const String &description);
+
     protected:
       virtual void parseFields(const ByteVector &data);
       virtual ByteVector renderFields() const;

taglib/mpeg/id3v2/id3v2frame.cpp

@@ -23,7 +23,7 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifndef HAVE_ZLIB
+#ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 
@@ -36,8 +36,16 @@
 #include <tdebug.h>
 #include <tstringlist.h>
 
+#include "id3v2tag.h"
 #include "id3v2frame.h"
 #include "id3v2synchdata.h"
+#include "tpropertymap.h"
+#include "frames/textidentificationframe.h"
+#include "frames/urllinkframe.h"
+#include "frames/unsynchronizedlyricsframe.h"
+#include "frames/commentsframe.h"
+#include "frames/uniquefileidentifierframe.h"
+#include "frames/unknownframe.h"
 
 using namespace TagLib;
 using namespace ID3v2;
@@ -65,7 +73,7 @@ namespace
       return false;
 
     for(ByteVector::ConstIterator it = frameID.begin(); it != frameID.end(); it++) {
-      if( (*it < 'A' || *it > 'Z') && (*it < '1' || *it > '9') ) {
+      if( (*it < 'A' || *it > 'Z') && (*it < '0' || *it > '9') ) {
         return false;
       }
     }
@@ -95,10 +103,62 @@ ByteVector Frame::textDelimiter(String::Type t)
   return d;
 }
 
+const String Frame::instrumentPrefix("PERFORMER:");
+const String Frame::commentPrefix("COMMENT:");
+const String Frame::lyricsPrefix("LYRICS:");
+const String Frame::urlPrefix("URL:");
+
 ////////////////////////////////////////////////////////////////////////////////
 // public members
 ////////////////////////////////////////////////////////////////////////////////
 
+Frame *Frame::createTextualFrame(const String &key, const StringList &values) //static
+{
+  // check if the key is contained in the key<=>frameID mapping
+  ByteVector frameID = keyToFrameID(key);
+  if(!frameID.isNull()) {
+    if(frameID[0] == 'T'){ // text frame
+      TextIdentificationFrame *frame = new TextIdentificationFrame(frameID, String::UTF8);
+      frame->setText(values);
+      return frame;
+    } else if((frameID[0] == 'W') && (values.size() == 1)){  // URL frame (not WXXX); support only one value
+        UrlLinkFrame* frame = new UrlLinkFrame(frameID);
+        frame->setUrl(values.front());
+        return frame;
+    }
+  }
+  if(key == "MUSICBRAINZ_TRACKID" && values.size() == 1) {
+    UniqueFileIdentifierFrame *frame = new UniqueFileIdentifierFrame("http://musicbrainz.org", values.front().data(String::UTF8));
+    return frame;
+  }
+  // now we check if it's one of the "special" cases:
+  // -LYRICS: depending on the number of values, use USLT or TXXX (with description=LYRICS)
+  if((key == "LYRICS" || key.startsWith(lyricsPrefix)) && values.size() == 1){
+    UnsynchronizedLyricsFrame *frame = new UnsynchronizedLyricsFrame(String::UTF8);
+    frame->setDescription(key == "LYRICS" ? key : key.substr(lyricsPrefix.size()));
+    frame->setText(values.front());
+    return frame;
+  }
+  // -URL: depending on the number of values, use WXXX or TXXX (with description=URL)
+  if((key == "URL" || key.startsWith(urlPrefix)) && values.size() == 1){
+    UserUrlLinkFrame *frame = new UserUrlLinkFrame(String::UTF8);
+    frame->setDescription(key == "URL" ? key : key.substr(urlPrefix.size()));
+    frame->setUrl(values.front());
+    return frame;
+  }
+  // -COMMENT: depending on the number of values, use COMM or TXXX (with description=COMMENT)
+  if((key == "COMMENT" || key.startsWith(commentPrefix)) && values.size() == 1){
+    CommentsFrame *frame = new CommentsFrame(String::UTF8);
+    if (key != "COMMENT"){
+      frame->setDescription(key.substr(commentPrefix.size()));
+    }
+    frame->setText(values.front());
+    return frame;
+  }
+  // if non of the above cases apply, we use a TXXX frame with the key as description
+  return new UserTextIdentificationFrame(keyToTXXX(key), values, String::UTF8);
+}
+
 Frame::~Frame()
 {
   delete d;
@@ -221,7 +281,11 @@ String Frame::readStringField(const ByteVector &data, String::Type encoding, int
   if(end < *position)
     return String::null;
 
-  String str = String(data.mid(*position, end - *position), encoding);
+  String str;
+  if(encoding == String::Latin1)
+    str = Tag::latin1StringHandler()->parse(data.mid(*position, end - *position));
+  else
+    str = String(data.mid(*position, end - *position), encoding);
 
   *position = end + delimiter.size();
 
@@ -262,6 +326,209 @@ String::Type Frame::checkTextEncoding(const StringList &fields, String::Type enc
   return checkEncoding(fields, encoding, header()->version());
 }
 
+static const TagLib::uint frameTranslationSize = 51;
+static const char *frameTranslation[][2] = {
+  // Text information frames
+  { "TALB", "ALBUM"},
+  { "TBPM", "BPM" },
+  { "TCOM", "COMPOSER" },
+  { "TCON", "GENRE" },
+  { "TCOP", "COPYRIGHT" },
+  { "TDEN", "ENCODINGTIME" },
+  { "TDLY", "PLAYLISTDELAY" },
+  { "TDOR", "ORIGINALDATE" },
+  { "TDRC", "DATE" },
+  // { "TRDA", "DATE" }, // id3 v2.3, replaced by TDRC in v2.4
+  // { "TDAT", "DATE" }, // id3 v2.3, replaced by TDRC in v2.4
+  // { "TYER", "DATE" }, // id3 v2.3, replaced by TDRC in v2.4
+  // { "TIME", "DATE" }, // id3 v2.3, replaced by TDRC in v2.4
+  { "TDRL", "RELEASEDATE" },
+  { "TDTG", "TAGGINGDATE" },
+  { "TENC", "ENCODEDBY" },
+  { "TEXT", "LYRICIST" },
+  { "TFLT", "FILETYPE" },
+  //{ "TIPL", "INVOLVEDPEOPLE" }, handled separately
+  { "TIT1", "CONTENTGROUP" },
+  { "TIT2", "TITLE"},
+  { "TIT3", "SUBTITLE" },
+  { "TKEY", "INITIALKEY" },
+  { "TLAN", "LANGUAGE" },
+  { "TLEN", "LENGTH" },
+  //{ "TMCL", "MUSICIANCREDITS" }, handled separately
+  { "TMED", "MEDIA" },
+  { "TMOO", "MOOD" },
+  { "TOAL", "ORIGINALALBUM" },
+  { "TOFN", "ORIGINALFILENAME" },
+  { "TOLY", "ORIGINALLYRICIST" },
+  { "TOPE", "ORIGINALARTIST" },
+  { "TOWN", "OWNER" },
+  { "TPE1", "ARTIST"},
+  { "TPE2", "ALBUMARTIST" }, // id3's spec says 'PERFORMER', but most programs use 'ALBUMARTIST'
+  { "TPE3", "CONDUCTOR" },
+  { "TPE4", "REMIXER" }, // could also be ARRANGER
+  { "TPOS", "DISCNUMBER" },
+  { "TPRO", "PRODUCEDNOTICE" },
+  { "TPUB", "LABEL" },
+  { "TRCK", "TRACKNUMBER" },
+  { "TRSN", "RADIOSTATION" },
+  { "TRSO", "RADIOSTATIONOWNER" },
+  { "TSOA", "ALBUMSORT" },
+  { "TSOP", "ARTISTSORT" },
+  { "TSOT", "TITLESORT" },
+  { "TSO2", "ALBUMARTISTSORT" }, // non-standard, used by iTunes
+  { "TSRC", "ISRC" },
+  { "TSSE", "ENCODING" },
+  // URL frames
+  { "WCOP", "COPYRIGHTURL" },
+  { "WOAF", "FILEWEBPAGE" },
+  { "WOAR", "ARTISTWEBPAGE" },
+  { "WOAS", "AUDIOSOURCEWEBPAGE" },
+  { "WORS", "RADIOSTATIONWEBPAGE" },
+  { "WPAY", "PAYMENTWEBPAGE" },
+  { "WPUB", "PUBLISHERWEBPAGE" },
+  //{ "WXXX", "URL"}, handled specially
+  // Other frames
+  { "COMM", "COMMENT" },
+  //{ "USLT", "LYRICS" }, handled specially
+};
+
+static const TagLib::uint txxxFrameTranslationSize = 7;
+static const char *txxxFrameTranslation[][2] = {
+  { "MusicBrainz Album Id", "MUSICBRAINZ_ALBUMID" },
+  { "MusicBrainz Artist Id", "MUSICBRAINZ_ARTISTID" },
+  { "MusicBrainz Album Artist Id", "MUSICBRAINZ_ALBUMARTISTID" },
+  { "MusicBrainz Release Group Id", "MUSICBRAINZ_RELEASEGROUPID" },
+  { "MusicBrainz Work Id", "MUSICBRAINZ_WORKID" },
+  { "Acoustid Id", "ACOUSTID_ID" },
+  { "Acoustid Fingerprint", "ACOUSTID_FINGERPRINT" },
+  { "MusicIP PUID", "MUSICIP_PUID" },
+};
+
+Map<ByteVector, String> &idMap()
+{
+  static Map<ByteVector, String> m;
+  if(m.isEmpty())
+    for(size_t i = 0; i < frameTranslationSize; ++i)
+      m[frameTranslation[i][0]] = frameTranslation[i][1];
+  return m;
+}
+
+Map<String, String> &txxxMap()
+{
+  static Map<String, String> m;
+  if(m.isEmpty()) {
+    for(size_t i = 0; i < txxxFrameTranslationSize; ++i) {
+      String key = String(txxxFrameTranslation[i][0]).upper();
+      m[key] = txxxFrameTranslation[i][1];
+    }
+  }
+  return m;
+}
+
+// list of deprecated frames and their successors
+static const TagLib::uint deprecatedFramesSize = 4;
+static const char *deprecatedFrames[][2] = {
+  {"TRDA", "TDRC"}, // 2.3 -> 2.4 (http://en.wikipedia.org/wiki/ID3)
+  {"TDAT", "TDRC"}, // 2.3 -> 2.4
+  {"TYER", "TDRC"}, // 2.3 -> 2.4
+  {"TIME", "TDRC"}, // 2.3 -> 2.4
+};
+
+Map<ByteVector,ByteVector> &deprecationMap()
+{
+  static Map<ByteVector,ByteVector> depMap;
+  if(depMap.isEmpty())
+    for(TagLib::uint i = 0; i < deprecatedFramesSize; ++i)
+      depMap[deprecatedFrames[i][0]] = deprecatedFrames[i][1];
+  return depMap;
+}
+
+String Frame::frameIDToKey(const ByteVector &id)
+{
+  Map<ByteVector, String> &m = idMap();
+  if(m.contains(id))
+    return m[id];
+  if(deprecationMap().contains(id))
+    return m[deprecationMap()[id]];
+  return String::null;
+}
+
+ByteVector Frame::keyToFrameID(const String &s)
+{
+  static Map<String, ByteVector> m;
+  if(m.isEmpty())
+    for(size_t i = 0; i < frameTranslationSize; ++i)
+      m[frameTranslation[i][1]] = frameTranslation[i][0];
+  if(m.contains(s.upper()))
+    return m[s];
+  return ByteVector::null;
+}
+
+String Frame::txxxToKey(const String &description)
+{
+  Map<String, String> &m = txxxMap();
+  String d = description.upper();
+  if(m.contains(d))
+    return m[d];
+  return d;
+}
+
+String Frame::keyToTXXX(const String &s)
+{
+  static Map<String, String> m;
+  if(m.isEmpty())
+    for(size_t i = 0; i < txxxFrameTranslationSize; ++i)
+      m[txxxFrameTranslation[i][1]] = txxxFrameTranslation[i][0];
+  if(m.contains(s.upper()))
+    return m[s];
+  return s;
+}
+
+PropertyMap Frame::asProperties() const
+{
+  if(dynamic_cast< const UnknownFrame *>(this)) {
+    PropertyMap m;
+    m.unsupportedData().append("UNKNOWN/" + frameID());
+    return m;
+  }
+  const ByteVector &id = frameID();
+  // workaround until this function is virtual
+  if(id == "TXXX")
+    return dynamic_cast< const UserTextIdentificationFrame* >(this)->asProperties();
+  else if(id[0] == 'T')
+    return dynamic_cast< const TextIdentificationFrame* >(this)->asProperties();
+  else if(id == "WXXX")
+    return dynamic_cast< const UserUrlLinkFrame* >(this)->asProperties();
+  else if(id[0] == 'W')
+    return dynamic_cast< const UrlLinkFrame* >(this)->asProperties();
+  else if(id == "COMM")
+    return dynamic_cast< const CommentsFrame* >(this)->asProperties();
+  else if(id == "USLT")
+    return dynamic_cast< const UnsynchronizedLyricsFrame* >(this)->asProperties();
+  else if(id == "UFID")
+    return dynamic_cast< const UniqueFileIdentifierFrame* >(this)->asProperties();
+  PropertyMap m;
+  m.unsupportedData().append(id);
+  return m;
+}
+
+void Frame::splitProperties(const PropertyMap &original, PropertyMap &singleFrameProperties,
+          PropertyMap &tiplProperties, PropertyMap &tmclProperties)
+{
+
+  singleFrameProperties.clear();
+  tiplProperties.clear();
+  tmclProperties.clear();
+  for(PropertyMap::ConstIterator it = original.begin(); it != original.end(); ++it) {
+    if(TextIdentificationFrame::involvedPeopleMap().contains(it->first))
+      tiplProperties.insert(it->first, it->second);
+    else if(it->first.startsWith(TextIdentificationFrame::instrumentPrefix))
+      tmclProperties.insert(it->first, it->second);
+    else
+      singleFrameProperties.insert(it->first, it->second);
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Frame::Header class
 ////////////////////////////////////////////////////////////////////////////////
@@ -375,7 +642,7 @@ void Frame::Header::setData(const ByteVector &data, uint version)
       return;
     }
 
-    d->frameSize = data.mid(3, 3).toUInt();
+    d->frameSize = data.toUInt(3, 3, true);
 
     break;
   }
@@ -403,7 +670,7 @@ void Frame::Header::setData(const ByteVector &data, uint version)
     // Set the size -- the frame size is the four bytes starting at byte four in
     // the frame header (structure 4)
 
-    d->frameSize = data.mid(4, 4).toUInt();
+    d->frameSize = data.toUInt(4U);
 
     { // read the first byte of flags
       std::bitset<8> flags(data[8]);
@@ -450,7 +717,7 @@ void Frame::Header::setData(const ByteVector &data, uint version)
     // iTunes writes v2.4 tags with v2.3-like frame sizes
     if(d->frameSize > 127) {
       if(!isValidFrameID(data.mid(d->frameSize + 10, 4))) {
-        unsigned int uintSize = data.mid(4, 4).toUInt();
+        unsigned int uintSize = data.toUInt(4U);
         if(isValidFrameID(data.mid(uintSize + 10, 4))) {
           d->frameSize = uintSize;
         }

taglib/mpeg/id3v2/id3v2frame.h

@@ -33,6 +33,7 @@
 namespace TagLib {
 
   class StringList;
+  class PropertyMap;
 
   namespace ID3v2 {
 
@@ -56,6 +57,14 @@ namespace TagLib {
       friend class FrameFactory;
 
     public:
+
+      /*!
+       * Creates a textual frame which corresponds to a single key in the PropertyMap
+       * interface. These are all (User)TextIdentificationFrames except TIPL and TMCL,
+       * all (User)URLLinkFrames, CommentsFrames, and UnsynchronizedLyricsFrame.
+       */
+      static Frame *createTextualFrame(const String &key, const StringList &values);
+
       /*!
        * Destroys this Frame instance.
        */
@@ -126,6 +135,28 @@ namespace TagLib {
        */
       static ByteVector textDelimiter(String::Type t);
 
+      /*!
+       * The string with which an instrument name is prefixed to build a key in a PropertyMap;
+       * used to translate PropertyMaps to TMCL frames. In the current implementation, this
+       * is "PERFORMER:".
+       */
+      static const String instrumentPrefix;
+      /*!
+       * The PropertyMap key prefix which triggers the use of a COMM frame instead of a TXXX
+       * frame for a non-standard key. In the current implementation, this is "COMMENT:".
+       */
+      static const String commentPrefix;
+      /*!
+       * The PropertyMap key prefix which triggers the use of a USLT frame instead of a TXXX
+       * frame for a non-standard key. In the current implementation, this is "LYRICS:".
+       */
+      static const String lyricsPrefix;
+      /*!
+       * The PropertyMap key prefix which triggers the use of a WXXX frame instead of a TXX
+       * frame for a non-standard key. In the current implementation, this is "URL:".
+       */
+      static const String urlPrefix;
+
     protected:
       class Header;
 
@@ -222,6 +253,53 @@ namespace TagLib {
       String::Type checkTextEncoding(const StringList &fields,
                                      String::Type encoding) const;
 
+
+      /*!
+       * Parses the contents of this frame as PropertyMap. If that fails, the returend
+       * PropertyMap will be empty, and its unsupportedData() will contain this frame's
+       * ID.
+       * BIC: Will be a virtual function in future releases.
+       */
+      PropertyMap asProperties() const;
+
+      /*!
+       * Returns an appropriate ID3 frame ID for the given free-form tag key. This method
+       * will return ByteVector::null if no specialized translation is found.
+       */
+      static ByteVector keyToFrameID(const String &);
+
+      /*!
+       * Returns a free-form tag name for the given ID3 frame ID. Note that this does not work
+       * for general frame IDs such as TXXX or WXXX; in such a case String::null is returned.
+       */
+      static String frameIDToKey(const ByteVector &);
+
+      /*!
+       * Returns an appropriate TXXX frame description for the given free-form tag key.
+       */
+      static String keyToTXXX(const String &);
+
+      /*!
+       * Returns a free-form tag name for the given ID3 frame description.
+       */
+      static String txxxToKey(const String &);
+
+      /*!
+       * This helper function splits the PropertyMap \a original into three ProperytMaps
+       * \a singleFrameProperties, \a tiplProperties, and \a tmclProperties, such that:
+       * - \a singleFrameProperties contains only of keys which can be represented with
+       *   exactly one ID3 frame per key. In the current implementation
+       *   this is everything except for the fixed "involved people" keys and keys of the
+       *   form "TextIdentificationFrame::instrumentPrefix" + "instrument", which are
+       *   mapped to a TMCL frame.
+       * - \a tiplProperties will consist of those keys that are present in
+       *   TextIdentificationFrame::involvedPeopleMap()
+       * - \a tmclProperties contains the "musician credits" keys which should be mapped
+       *   to a TMCL frame
+       */
+      static void splitProperties(const PropertyMap &original, PropertyMap &singleFrameProperties,
+          PropertyMap &tiplProperties, PropertyMap &tmclProperties);
+
     private:
       Frame(const Frame &);
       Frame &operator=(const Frame &);

taglib/mpeg/id3v2/id3v2framefactory.cpp

@@ -23,7 +23,7 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#ifndef HAVE_ZLIB
+#ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 
@@ -44,6 +44,7 @@
 #include "frames/unsynchronizedlyricsframe.h"
 #include "frames/popularimeterframe.h"
 #include "frames/privateframe.h"
+#include "frames/ownershipframe.h"
 
 using namespace TagLib;
 using namespace ID3v2;
@@ -65,7 +66,7 @@ public:
   }
 };
 
-FrameFactory *FrameFactory::factory = 0;
+FrameFactory FrameFactory::factory;
 
 ////////////////////////////////////////////////////////////////////////////////
 // public members
@@ -73,9 +74,7 @@ FrameFactory *FrameFactory::factory = 0;
 
 FrameFactory *FrameFactory::instance()
 {
-  if(!factory)
-    factory = new FrameFactory;
-  return factory;
+  return &factory;
 }
 
 Frame *FrameFactory::createFrame(const ByteVector &data, bool synchSafeInts) const
@@ -100,7 +99,7 @@ Frame *FrameFactory::createFrame(const ByteVector &origData, Header *tagHeader)
   // A quick sanity check -- make sure that the frameID is 4 uppercase Latin1
   // characters.  Also make sure that there is data in the frame.
 
-  if(!frameID.size() == (version < 3 ? 3 : 4) ||
+  if(frameID.size() != (version < 3 ? 3 : 4) ||
      header->frameSize() <= uint(header->dataLengthIndicator() ? 4 : 0) ||
      header->frameSize() > data.size())
   {
@@ -108,8 +107,19 @@ Frame *FrameFactory::createFrame(const ByteVector &origData, Header *tagHeader)
     return 0;
   }
 
+#ifndef NO_ITUNES_HACKS
+  if(version == 3 && frameID.size() == 4 && frameID[3] == '\0') {
+    // iTunes v2.3 tags store v2.2 frames - convert now
+    frameID = frameID.mid(0, 3);
+    header->setFrameID(frameID);
+    header->setVersion(2);
+    updateFrame(header);
+    header->setVersion(3);
+  }
+#endif
+
   for(ByteVector::ConstIterator it = frameID.begin(); it != frameID.end(); it++) {
-    if( (*it < 'A' || *it > 'Z') && (*it < '1' || *it > '9') ) {
+    if( (*it < 'A' || *it > 'Z') && (*it < '0' || *it > '9') ) {
       delete header;
       return 0;
     }
@@ -126,7 +136,7 @@ Frame *FrameFactory::createFrame(const ByteVector &origData, Header *tagHeader)
   // TagLib doesn't mess with encrypted frames, so just treat them
   // as unknown frames.
 
-#if HAVE_ZLIB == 0
+#if !defined(HAVE_ZLIB) || HAVE_ZLIB == 0
   if(header->compression()) {
     debug("Compressed frames are currently not supported.");
     return new UnknownFrame(data, header);
@@ -240,6 +250,14 @@ Frame *FrameFactory::createFrame(const ByteVector &origData, Header *tagHeader)
 
   if(frameID == "PRIV")
     return new PrivateFrame(data, header);
+  
+  // Ownership (frames 4.22)
+  
+  if(frameID == "OWNE") {
+    OwnershipFrame *f = new OwnershipFrame(data, header);
+    d->setTextEncoding(f);
+    return f;
+  }
 
   return new UnknownFrame(data, header);
 }
@@ -310,6 +328,7 @@ bool FrameFactory::updateFrame(Frame::Header *header) const
     convertFrame("TBP", "TBPM", header);
     convertFrame("TCM", "TCOM", header);
     convertFrame("TCO", "TCON", header);
+    convertFrame("TCP", "TCMP", header);
     convertFrame("TCR", "TCOP", header);
     convertFrame("TDY", "TDLY", header);
     convertFrame("TEN", "TENC", header);
@@ -332,7 +351,12 @@ bool FrameFactory::updateFrame(Frame::Header *header) const
     convertFrame("TRC", "TSRC", header);
     convertFrame("TRD", "TDRC", header);
     convertFrame("TRK", "TRCK", header);
+    convertFrame("TS2", "TSO2", header);
+    convertFrame("TSA", "TSOA", header);
+    convertFrame("TSC", "TSOC", header);
+    convertFrame("TSP", "TSOP", header);
     convertFrame("TSS", "TSSE", header);
+    convertFrame("TST", "TSOT", header);
     convertFrame("TT1", "TIT1", header);
     convertFrame("TT2", "TIT2", header);
     convertFrame("TT3", "TIT3", header);

taglib/mpeg/id3v2/id3v2framefactory.h

@@ -123,8 +123,7 @@ namespace TagLib {
       FrameFactory();
 
       /*!
-       * Destroys the frame factory.  In most cases this will never be called (as
-       * is typical of singletons).
+       * Destroys the frame factory.
        */
       virtual ~FrameFactory();
 
@@ -155,7 +154,7 @@ namespace TagLib {
 
       void updateGenre(TextIdentificationFrame *frame) const;
 
-      static FrameFactory *factory;
+      static FrameFactory factory;
 
       class FrameFactoryPrivate;
       FrameFactoryPrivate *d;

taglib/mpeg/id3v2/id3v2header.cpp

@@ -23,7 +23,7 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#include <ostream>
+#include <iostream>
 #include <bitset>
 
 #include <tstring.h>

taglib/mpeg/id3v2/id3v2synchdata.cpp

@@ -23,7 +23,7 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
-#include <ostream>
+#include <iostream>
 
 #include "id3v2synchdata.h"
 
@@ -49,7 +49,14 @@ TagLib::uint SynchData::toUInt(const ByteVector &data)
     // Invalid data; assume this was created by some buggy software that just
     // put normal integers here rather than syncsafe ones, and try it that
     // way.
-    sum = (data.size() > 4) ? data.mid(0, 4).toUInt() : data.toUInt();
+    if(data.size() >= 4) {
+      sum = data.toUInt(0, true);
+    }
+    else {
+      ByteVector tmp(data);
+      tmp.resize(4);
+      sum = tmp.toUInt(0, true);
+    }
   }
 
   return sum;

taglib/mpeg/id3v2/id3v2tag.cpp

@@ -23,19 +23,28 @@
  *   http://www.mozilla.org/MPL/                                           *
  ***************************************************************************/
 
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
 #include <tfile.h>
-#include <tdebug.h>
 
 #include "id3v2tag.h"
 #include "id3v2header.h"
 #include "id3v2extendedheader.h"
 #include "id3v2footer.h"
 #include "id3v2synchdata.h"
-
+#include "tbytevector.h"
 #include "id3v1genres.h"
+#include "tpropertymap.h"
+#include <tdebug.h>
 
 #include "frames/textidentificationframe.h"
 #include "frames/commentsframe.h"
+#include "frames/urllinkframe.h"
+#include "frames/uniquefileidentifierframe.h"
+#include "frames/unsynchronizedlyricsframe.h"
+#include "frames/unknownframe.h"
 
 using namespace TagLib;
 using namespace ID3v2;
@@ -65,8 +74,30 @@ public:
 
   FrameListMap frameListMap;
   FrameList frameList;
+
+  static const Latin1StringHandler *stringHandler;
 };
 
+static const Latin1StringHandler defaultStringHandler;
+const ID3v2::Latin1StringHandler *ID3v2::Tag::TagPrivate::stringHandler = &defaultStringHandler;
+
+////////////////////////////////////////////////////////////////////////////////
+// StringHandler implementation
+////////////////////////////////////////////////////////////////////////////////
+
+Latin1StringHandler::Latin1StringHandler()
+{
+}
+
+Latin1StringHandler::~Latin1StringHandler()
+{
+}
+
+String Latin1StringHandler::parse(const ByteVector &data) const
+{
+  return String(data, String::Latin1);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // public members
 ////////////////////////////////////////////////////////////////////////////////
@@ -324,9 +355,103 @@ void ID3v2::Tag::removeFrame(Frame *frame, bool del)
 
 void ID3v2::Tag::removeFrames(const ByteVector &id)
 {
-    FrameList l = d->frameListMap[id];
-    for(FrameList::Iterator it = l.begin(); it != l.end(); ++it)
-      removeFrame(*it, true);
+  FrameList l = d->frameListMap[id];
+  for(FrameList::Iterator it = l.begin(); it != l.end(); ++it)
+    removeFrame(*it, true);
+}
+
+PropertyMap ID3v2::Tag::properties() const
+{
+  PropertyMap properties;
+  for(FrameList::ConstIterator it = frameList().begin(); it != frameList().end(); ++it) {
+    PropertyMap props = (*it)->asProperties();
+    properties.merge(props);
+  }
+  return properties;
+}
+
+void ID3v2::Tag::removeUnsupportedProperties(const StringList &properties)
+{
+  for(StringList::ConstIterator it = properties.begin(); it != properties.end(); ++it){
+    if(it->startsWith("UNKNOWN/")) {
+      String frameID = it->substr(String("UNKNOWN/").size());
+      if(frameID.size() != 4)
+        continue; // invalid specification
+      ByteVector id = frameID.data(String::Latin1);
+      // delete all unknown frames of given type
+      FrameList l = frameList(id);
+      for(FrameList::ConstIterator fit = l.begin(); fit != l.end(); fit++)
+        if (dynamic_cast<const UnknownFrame *>(*fit) != 0)
+          removeFrame(*fit);
+    }
+    else if(it->size() == 4){
+      ByteVector id = it->data(String::Latin1);
+      removeFrames(id);
+    }
+    else {
+      ByteVector id = it->substr(0,4).data(String::Latin1);
+      if(it->size() <= 5)
+        continue; // invalid specification
+      String description = it->substr(5);
+      Frame *frame = 0;
+      if(id == "TXXX")
+        frame = UserTextIdentificationFrame::find(this, description);
+      else if(id == "WXXX")
+        frame = UserUrlLinkFrame::find(this, description);
+      else if(id == "COMM")
+        frame = CommentsFrame::findByDescription(this, description);
+      else if(id == "USLT")
+        frame = UnsynchronizedLyricsFrame::findByDescription(this, description);
+      else if(id == "UFID")
+        frame = UniqueFileIdentifierFrame::findByOwner(this, description);
+      if(frame)
+        removeFrame(frame);
+    }
+  }
+}
+
+PropertyMap ID3v2::Tag::setProperties(const PropertyMap &origProps)
+{
+  FrameList framesToDelete;
+  // we split up the PropertyMap into the "normal" keys and the "complicated" ones,
+  // which are those according to TIPL or TMCL frames.
+  PropertyMap properties;
+  PropertyMap tiplProperties;
+  PropertyMap tmclProperties;
+  Frame::splitProperties(origProps, properties, tiplProperties, tmclProperties);
+  for(FrameListMap::ConstIterator it = frameListMap().begin(); it != frameListMap().end(); ++it){
+    for(FrameList::ConstIterator lit = it->second.begin(); lit != it->second.end(); ++lit){
+      PropertyMap frameProperties = (*lit)->asProperties();
+      if(it->first == "TIPL") {
+        if (tiplProperties != frameProperties)
+          framesToDelete.append(*lit);
+        else
+          tiplProperties.erase(frameProperties);
+      } else if(it->first == "TMCL") {
+        if (tmclProperties != frameProperties)
+          framesToDelete.append(*lit);
+        else
+          tmclProperties.erase(frameProperties);
+      } else if(!properties.contains(frameProperties))
+        framesToDelete.append(*lit);
+      else
+        properties.erase(frameProperties);
+    }
+  }
+  for(FrameList::ConstIterator it = framesToDelete.begin(); it != framesToDelete.end(); ++it)
+    removeFrame(*it);
+
+  // now create remaining frames:
+  // start with the involved people list (TIPL)
+  if(!tiplProperties.isEmpty())
+      addFrame(TextIdentificationFrame::createTIPLFrame(tiplProperties));
+  // proceed with the musician credit list (TMCL)
+  if(!tmclProperties.isEmpty())
+      addFrame(TextIdentificationFrame::createTMCLFrame(tmclProperties));
+  // now create the "one key per frame" frames
+  for(PropertyMap::ConstIterator it = properties.begin(); it != properties.end(); ++it)
+    addFrame(Frame::createTextualFrame(it->first, it->second));
+  return PropertyMap(); // ID3 implements the complete PropertyMap interface, so an empty map is returned
 }
 
 ByteVector ID3v2::Tag::render() const
@@ -489,6 +614,19 @@ ByteVector ID3v2::Tag::render(int version) const
   return d->header.render() + tagData;
 }
 
+Latin1StringHandler const *ID3v2::Tag::latin1StringHandler()
+{
+  return TagPrivate::stringHandler;
+}
+
+void ID3v2::Tag::setLatin1StringHandler(const Latin1StringHandler *handler)
+{
+  if(handler)
+    TagPrivate::stringHandler = handler;
+  else
+    TagPrivate::stringHandler = &defaultStringHandler;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // protected members
 ////////////////////////////////////////////////////////////////////////////////
@@ -550,8 +688,9 @@ void ID3v2::Tag::parse(const ByteVector &origData)
     // portion of the frame data.
 
     if(data.at(frameDataPosition) == 0) {
-      if(d->header.footerPresent())
+      if(d->header.footerPresent()) {
         debug("Padding *and* a footer found.  This is not allowed by the spec.");
+      }
 
       d->paddingSize = frameDataLength - frameDataPosition;
       return;

taglib/mpeg/id3v2/id3v2tag.h

@@ -57,6 +57,36 @@ namespace TagLib {
     typedef List<Frame *> FrameList;
     typedef Map<ByteVector, FrameList> FrameListMap;
 
+    //! An abstraction for the ISO-8859-1 string to data encoding in ID3v2 tags.
+
+    /*!
+     * ID3v2 tag can store strings in ISO-8859-1 (Latin1), and TagLib only 
+     * supports genuine ISO-8859-1 by default.  However, in practice, non 
+     * ISO-8859-1 encodings are often used instead of ISO-8859-1, such as 
+     * Windows-1252 for western languages, Shift_JIS for Japanese and so on.
+     *
+     * Here is an option to read such tags by subclassing this class,
+     * reimplementing parse() and setting your reimplementation as the default 
+     * with ID3v2::Tag::setStringHandler().
+     *
+     * \note Writing non-ISO-8859-1 tags is not implemented intentionally.
+     * Use UTF-16 or UTF-8 instead.
+     *
+     * \see ID3v2::Tag::setStringHandler()
+     */
+    class TAGLIB_EXPORT Latin1StringHandler
+    {
+    public:
+      Latin1StringHandler();
+      virtual ~Latin1StringHandler();
+
+      /*!
+       * Decode a string from \a data.  The default implementation assumes that
+       * \a data is an ISO-8859-1 (Latin1) character array.
+       */
+      virtual String parse(const ByteVector &data) const;
+    };
+
     //! The main class in the ID3v2 implementation
 
     /*!
@@ -260,6 +290,56 @@ namespace TagLib {
        */
       void removeFrames(const ByteVector &id);
 
+      /*!
+       * Implements the unified property interface -- export function.
+       * This function does some work to translate the hard-specified ID3v2
+       * frame types into a free-form string-to-stringlist PropertyMap:
+       *  - if ID3v2 frame ID is known by Frame::frameIDToKey(), the returned
+       *    key is used
+       *  - if the frame ID is "TXXX" (user text frame), the description() is
+       *    used as key
+       *  - if the frame ID is "WXXX" (user url frame),
+       *    - if the description is empty or "URL", the key "URL" is used
+       *    - otherwise, the key "URL:<description>" is used;
+       *  - if the frame ID is "COMM" (comments frame),
+       *    - if the description is empty or "COMMENT", the key "COMMENT"
+       *      is used
+       *    - otherwise, the key "COMMENT:<description>" is used;
+       *  - if the frame ID is "USLT" (unsynchronized lyrics),
+       *    - if the description is empty or "LYRICS", the key "LYRICS" is used
+       *    - 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
+       *  - if the frame ID is "TMCL" (musician credit list), then
+       *    "PERFORMER:<instrument>=<name>" will be contained in the returned
+       *    PropertyMap for each defined musician
+       *  In any other case, the unsupportedData() of the returned object will contain
+       *  the frame's ID and, in case of a frame ID which is allowed to appear more than
+       *  once, the description, separated by a "/".
+       *
+       */
+      PropertyMap properties() const;
+
+      /*!
+       * Removes unsupported frames given by \a properties. The elements of
+       * \a properties must be taken from properties().unsupportedData(); they
+       * are of one of the following forms:
+       *  - a four-character frame ID, if the ID3 specification allows only one
+       *    frame with that ID (thus, the frame is uniquely determined)
+       *  - frameID + "/" + description(), when the ID is one of "TXXX", "WXXX",
+       *    "COMM", or "USLT",
+       *  - "UNKNOWN/" + frameID, for frames that could not be parsed by TagLib.
+       *    In that case, *all* unknown frames with the given ID will be removed.
+       */
+      void removeUnsupportedProperties(const StringList &properties);
+
+      /*!
+       * Implements the unified property interface -- import function.
+       * See the comments in properties().
+       */
+      PropertyMap setProperties(const PropertyMap &);
+
       /*!
        * Render the tag back to binary data, suitable to be written to disk.
        */
@@ -273,6 +353,27 @@ namespace TagLib {
        */
       // BIC: combine with the above method
       ByteVector render(int version) const;
+      
+      /*!
+       * Gets the current string handler that decides how the "Latin-1" data 
+       * will be converted to and from binary data.
+       *
+       * \see Latin1StringHandler
+       */
+      static Latin1StringHandler const *latin1StringHandler();
+
+      /*!
+       * Sets the string handler that decides how the "Latin-1" data will be
+       * converted to and from binary data.
+       * If the parameter \a handler is null, the previous handler is
+       * released and default ISO-8859-1 handler is restored.
+       *
+       * \note The caller is responsible for deleting the previous handler
+       * as needed after it is released. 
+       *
+       * \see Latin1StringHandler
+       */
+      static void setLatin1StringHandler(const Latin1StringHandler *handler);
 
     protected:
       /*!

taglib/mpeg/mpegfile.cpp

@@ -35,6 +35,7 @@
 
 #include "mpegfile.h"
 #include "mpegheader.h"
+#include "tpropertymap.h"
 
 using namespace TagLib;
 
@@ -133,6 +134,37 @@ TagLib::Tag *MPEG::File::tag() const
   return &d->tag;
 }
 
+PropertyMap MPEG::File::properties() const
+{
+  // once Tag::properties() is virtual, this case distinction could actually be done
+  // within TagUnion.
+  if(d->hasID3v2)
+    return d->tag.access<ID3v2::Tag>(ID3v2Index, false)->properties();
+  if(d->hasAPE)
+    return d->tag.access<APE::Tag>(APEIndex, false)->properties();
+  if(d->hasID3v1)
+    return d->tag.access<ID3v1::Tag>(ID3v1Index, false)->properties();
+  return PropertyMap();
+}
+
+void MPEG::File::removeUnsupportedProperties(const StringList &properties)
+{
+  if(d->hasID3v2)
+    d->tag.access<ID3v2::Tag>(ID3v2Index, false)->removeUnsupportedProperties(properties);
+  else if(d->hasAPE)
+    d->tag.access<APE::Tag>(APEIndex, false)->removeUnsupportedProperties(properties);
+  else if(d->hasID3v1)
+    d->tag.access<ID3v1::Tag>(ID3v1Index, false)->removeUnsupportedProperties(properties);
+}
+
+PropertyMap MPEG::File::setProperties(const PropertyMap &properties)
+{
+  if(d->hasID3v1)
+    // update ID3v1 tag if it exists, but ignore the return value
+    d->tag.access<ID3v1::Tag>(ID3v1Index, false)->setProperties(properties);
+  return d->tag.access<ID3v2::Tag>(ID3v2Index, true)->setProperties(properties);
+}
+
 MPEG::Properties *MPEG::File::audioProperties() const
 {
   return d->properties;
@@ -154,6 +186,11 @@ bool MPEG::File::save(int tags, bool stripOthers)
 }
 
 bool MPEG::File::save(int tags, bool stripOthers, int id3v2Version)
+{
+  return save(tags, stripOthers, id3v2Version, true);
+}
+
+bool MPEG::File::save(int tags, bool stripOthers, int id3v2Version, bool duplicateTags)
 {
   if(tags == NoTags && stripOthers)
     return strip(AllTags);
@@ -171,14 +208,19 @@ bool MPEG::File::save(int tags, bool stripOthers, int id3v2Version)
     return false;
   }
 
-  // Create the tags if we've been asked to.  Copy the values from the tag that
-  // does exist into the new tag.
+  // Create the tags if we've been asked to.
 
-  if((tags & ID3v2) && ID3v1Tag())
-    Tag::duplicate(ID3v1Tag(), ID3v2Tag(true), false);
+  if (duplicateTags) {
 
-  if((tags & ID3v1) && d->tag[ID3v2Index])
-    Tag::duplicate(ID3v2Tag(), ID3v1Tag(true), false);
+    // 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)))
+      Tag::duplicate(ID3v1Tag(), ID3v2Tag(true), false);
+
+    if((tags & ID3v1) && d->tag[ID3v2Index] && !(stripOthers && !(tags & ID3v2)))
+      Tag::duplicate(ID3v2Tag(), ID3v1Tag(true), false);
+  }
 
   bool success = true;
 
@@ -402,6 +444,21 @@ long MPEG::File::lastFrameOffset()
   return previousFrameOffset(ID3v1Tag() ? d->ID3v1Location - 1 : length());
 }
 
+bool MPEG::File::hasID3v1Tag() const
+{
+  return d->hasID3v1;
+}
+
+bool MPEG::File::hasID3v2Tag() const
+{
+  return d->hasID3v2;
+}
+
+bool MPEG::File::hasAPETag() const
+{
+  return d->hasAPE;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // private members
 ////////////////////////////////////////////////////////////////////////////////
@@ -599,9 +656,6 @@ void MPEG::File::findAPE()
 
 bool MPEG::File::secondSynchByte(char byte)
 {
-  if(uchar(byte) == 0xff)
-    return false;
-
   std::bitset<8> b(byte);
 
   // check to see if the byte matches 111xxxxx

taglib/mpeg/mpegfile.h

@@ -28,6 +28,7 @@
 
 #include "taglib_export.h"
 #include "tfile.h"
+#include "tag.h"
 
 #include "mpegproperties.h"
 
@@ -70,9 +71,10 @@ namespace TagLib {
       };
 
       /*!
-       * Contructs an MPEG file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.
+       * Constructs an MPEG file from \a file.  If \a readProperties is true the
+       * file's audio properties will also be read.
+       *
+       * \note In the current implementation, \a propertiesStyle is ignored.
        *
        * \deprecated This constructor will be dropped in favor of the one below
        * in a future version.
@@ -81,25 +83,31 @@ namespace TagLib {
            Properties::ReadStyle propertiesStyle = Properties::Average);
 
       /*!
-       * Contructs an MPEG file from \a file.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.  The frames will be created using
+       * Constructs an MPEG file from \a file.  If \a readProperties is true the
+       * file's audio properties will also be read.
+       *
+       * If this file contains and ID3v2 tag the frames will be created using
        * \a frameFactory.
        *
-       * \deprecated This constructor will be dropped in favor of the one below
-       * in a future version.
+       * \note In the current implementation, \a propertiesStyle is ignored.
        */
+      // BIC: merge with the above constructor
       File(FileName file, ID3v2::FrameFactory *frameFactory,
            bool readProperties = true,
            Properties::ReadStyle propertiesStyle = Properties::Average);
 
       /*!
-       * Contructs an MPEG file from \a stream.  If \a readProperties is true the
-       * file's audio properties will also be read using \a propertiesStyle.  If
-       * false, \a propertiesStyle is ignored.  The frames will be created using
+       * Constructs an MPEG file from \a stream.  If \a readProperties is true the
+       * file's audio properties will also be read.
+       *
+       * \note TagLib will *not* take ownership of the stream, the caller is
+       * responsible for deleting it after the File object.
+       *
+       * If this file contains and ID3v2 tag the frames will be created using
        * \a frameFactory.
+       *
+       * \note In the current implementation, \a propertiesStyle is ignored.
        */
-      // BIC: merge with the above constructor
       File(IOStream *stream, ID3v2::FrameFactory *frameFactory,
            bool readProperties = true,
            Properties::ReadStyle propertiesStyle = Properties::Average);
@@ -128,6 +136,26 @@ namespace TagLib {
        */
       virtual Tag *tag() const;
 
+      /*!
+       * Implements the reading part of the unified property interface.
+       * If the file contains more than one tag, only the
+       * first one (in the order ID3v2, APE, ID3v1) will be converted to the
+       * PropertyMap.
+       */
+      PropertyMap properties() const;
+
+      void removeUnsupportedProperties(const StringList &properties);
+
+      /*!
+       * Implements the writing part of the unified tag dictionary interface.
+       * In order to avoid problems with deprecated tag formats, this method
+       * always creates an ID3v2 tag if necessary.
+       * If an ID3v1 tag  exists, it will be updated as well, within the
+       * limitations of that format.
+       * The returned PropertyMap refers to the ID3v2 tag only.
+       */
+      PropertyMap setProperties(const PropertyMap &);
+
       /*!
        * Returns the MPEG::Properties for this file.  If no audio properties
        * were read then this will return a null pointer.
@@ -189,42 +217,78 @@ namespace TagLib {
       // 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);
+
       /*!
        * Returns a pointer to the ID3v2 tag of the file.
        *
-       * If \a create is false (the default) this will return a null pointer
+       * If \a create is false (the default) this may return a null pointer
        * if there is no valid ID3v2 tag.  If \a create is true it will create
-       * an ID3v2 tag if one does not exist.
+       * an ID3v2 tag if one does not exist and returns a valid pointer.
+       *
+       * \note This may return a valid pointer regardless of whether or not the 
+       * file on disk has an ID3v2 tag.  Use hasID3v2Tag() to check if the file 
+       * on disk actually has an ID3v2 tag.
        *
        * \note The Tag <b>is still</b> owned by the MPEG::File and should not be
        * deleted by the user.  It will be deleted when the file (object) is
        * destroyed.
+       *
+       * \see hasID3v2Tag()
        */
       ID3v2::Tag *ID3v2Tag(bool create = false);
 
       /*!
        * Returns a pointer to the ID3v1 tag of the file.
        *
-       * If \a create is false (the default) this will return a null pointer
+       * If \a create is false (the default) this may return a null pointer
        * if there is no valid ID3v1 tag.  If \a create is true it will create
-       * an ID3v1 tag if one does not exist.
+       * an ID3v1 tag if one does not exist and returns a valid pointer.
+       *
+       * \note This may return a valid pointer regardless of whether or not the 
+       * file on disk has an ID3v1 tag.  Use hasID3v1Tag() to check if the file 
+       * on disk actually has an ID3v1 tag.
        *
        * \note The Tag <b>is still</b> owned by the MPEG::File and should not be
        * deleted by the user.  It will be deleted when the file (object) is
        * destroyed.
+       *
+       * \see hasID3v1Tag()
        */
       ID3v1::Tag *ID3v1Tag(bool create = false);
 
       /*!
        * Returns a pointer to the APE tag of the file.
        *
-       * If \a create is false (the default) this will return a null pointer
+       * If \a create is false (the default) this may return a null pointer
        * if there is no valid APE tag.  If \a create is true it will create
-       * an APE tag if one does not exist.
+       * an APE tag if one does not exist and returns a valid pointer.
+       *
+       * \note This may return a valid pointer regardless of whether or not the 
+       * file on disk has an APE tag.  Use hasAPETag() to check if the file 
+       * on disk actually has an APE tag.
        *
        * \note The Tag <b>is still</b> owned by the MPEG::File and should not be
        * deleted by the user.  It will be deleted when the file (object) is
        * destroyed.
+       *
+       * \see hasAPETag()
        */
       APE::Tag *APETag(bool create = false);
 
@@ -280,6 +344,27 @@ namespace TagLib {
        */
       long lastFrameOffset();
 
+      /*!
+       * Returns whether or not the file on disk actually has an ID3v1 tag.
+       *
+       * \see ID3v1Tag()
+       */
+      bool hasID3v1Tag() const;
+
+      /*!
+       * Returns whether or not the file on disk actually has an ID3v2 tag.
+       *
+       * \see ID3v2Tag()
+       */
+      bool hasID3v2Tag() const;
+
+      /*!
+       * Returns whether or not the file on disk actually has an APE tag.
+       *
+       * \see APETag()
+       */
+      bool hasAPETag() const;
+
     private:
       File(const File &);
       File &operator=(const File &);

taglib/mpeg/mpegheader.cpp

@@ -28,6 +28,7 @@
 #include <tbytevector.h>
 #include <tstring.h>
 #include <tdebug.h>
+#include "trefcounter.h"
 
 #include "mpegheader.h"
 

taglib/mpeg/mpegproperties.cpp

@@ -221,7 +221,7 @@ void MPEG::Properties::read()
       double length = timePerFrame * d->xingHeader->totalFrames();
 
       d->length = int(length);
-      d->bitrate = d->length > 0 ? d->xingHeader->totalSize() * 8 / length / 1000 : 0;
+      d->bitrate = d->length > 0 ? (int)(d->xingHeader->totalSize() * 8 / length / 1000) : 0;
   }
   else {
     // Since there was no valid Xing header found, we hope that we're in a constant

taglib/mpeg/xingheader.cpp

@@ -108,8 +108,8 @@ void MPEG::XingHeader::parse(const ByteVector &data)
     return;
   }
 
-  d->frames = data.mid(8, 4).toUInt();
-  d->size = data.mid(12, 4).toUInt();
+  d->frames = data.toUInt(8U);
+  d->size   = data.toUInt(12U);
 
   d->valid = true;
 }

taglib/ogg/flac/oggflacfile.cpp

@@ -26,6 +26,7 @@
 #include <tbytevector.h>
 #include <tstring.h>
 #include <tdebug.h>
+#include <tpropertymap.h>
 
 #include <xiphcomment.h>
 #include "oggflacfile.h"
@@ -72,14 +73,16 @@ Ogg::FLAC::File::File(FileName file, bool readProperties,
                       Properties::ReadStyle propertiesStyle) : Ogg::File(file)
 {
   d = new FilePrivate;
-  read(readProperties, propertiesStyle);
+  if(isOpen())
+    read(readProperties, propertiesStyle);
 }
 
 Ogg::FLAC::File::File(IOStream *stream, bool readProperties,
                       Properties::ReadStyle propertiesStyle) : Ogg::File(stream)
 {
   d = new FilePrivate;
-  read(readProperties, propertiesStyle);
+  if(isOpen())
+    read(readProperties, propertiesStyle);
 }
 
 Ogg::FLAC::File::~File()
@@ -92,6 +95,16 @@ Ogg::XiphComment *Ogg::FLAC::File::tag() const
   return d->comment;
 }
 
+PropertyMap Ogg::FLAC::File::properties() const
+{
+  return d->comment->properties();
+}
+
+PropertyMap Ogg::FLAC::File::setProperties(const PropertyMap &properties)
+{
+  return d->comment->setProperties(properties);
+}  
+
 Properties *Ogg::FLAC::File::audioProperties() const
 {
   return d->properties;
@@ -124,6 +137,11 @@ bool Ogg::FLAC::File::save()
   return Ogg::File::save();
 }
 
+bool Ogg::FLAC::File::hasXiphComment() const
+{
+  return d->hasXiphComment;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // private members
 ////////////////////////////////////////////////////////////////////////////////
@@ -228,7 +246,7 @@ void Ogg::FLAC::File::scan()
 
   char blockType = header[0] & 0x7f;
   bool lastBlock = (header[0] & 0x80) != 0;
-  uint length = header.mid(1, 3).toUInt();
+  uint length = header.toUInt(1, 3, true);
   overhead += length;
 
   // Sanity: First block should be the stream_info metadata
@@ -238,7 +256,7 @@ void Ogg::FLAC::File::scan()
     return;
   }
 
-  d->streamInfoData = metadataHeader.mid(4,length);
+  d->streamInfoData = metadataHeader.mid(4, length);
 
   // Search through the remaining metadata
 
@@ -251,7 +269,7 @@ void Ogg::FLAC::File::scan()
     header = metadataHeader.mid(0, 4);
     blockType = header[0] & 0x7f;
     lastBlock = (header[0] & 0x80) != 0;
-    length = header.mid(1, 3).toUInt();
+    length = header.toUInt(1, 3, true);
     overhead += length;
 
     if(blockType == 1) {
@@ -263,9 +281,9 @@ void Ogg::FLAC::File::scan()
       d->hasXiphComment = true;
       d->commentPacket = ipacket;
     }
-    else if(blockType > 5)
+    else if(blockType > 5) {
       debug("Ogg::FLAC::File::scan() -- Unknown metadata block");
-
+    }
   }
 
   // End of metadata, now comes the datastream