Merge branch 'master' of https://github.com/supermihi/taglib

taglib/ape/apefile.cpp

@@ -36,6 +36,7 @@
 #include <tdebug.h>
 #include <tagunion.h>
 #include <id3v1tag.h>
+#include <tpropertymap.h>
 
 #include "apefile.h"
 
@@ -109,6 +110,33 @@ TagLib::Tag *APE::File::tag() const
   return &d->tag;
 }
 
+PropertyMap APE::File::properties() const
+{
+  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 APE::File::removeUnsupportedProperties(const StringList &properties)
+{
+  if(d->hasAPE)
+    d->tag.access<APE::Tag>(APEIndex, false)->removeUnsupportedProperties(properties);
+  if(d->hasID3v1)
+    d->tag.access<ID3v1::Tag>(ID3v1Index, false)->removeUnsupportedProperties(properties);
+}
+
+PropertyMap APE::File::setProperties(const PropertyMap &properties)
+{
+  if(d->hasAPE)
+    return d->tag.access<APE::Tag>(APEIndex, false)->setProperties(properties);
+  else if(d->hasID3v1)
+    return d->tag.access<ID3v1::Tag>(ID3v1Index, false)->setProperties(properties);
+  else
+    return d->tag.access<APE::Tag>(APEIndex, true)->setProperties(properties);
+}
+
 APE::Properties *APE::File::audioProperties() const
 {
   return d->properties;

taglib/ape/apefile.h

@@ -110,6 +110,25 @@ namespace TagLib {
        */
       virtual TagLib::Tag *tag() const;
 
+      /*!
+       * Implements the unified property interface -- export function.
+       * If the file contains both an APE and an ID3v1 tag, only APE
+       * will be converted to the PropertyMap.
+       */
+      PropertyMap properties() const;
+
+      /*!
+       * Removes unsupported properties. Forwards to the actual Tag's
+       * removeUnsupportedProperties() function.
+       */
+      void removeUnsupportedProperties(const StringList &properties);
+
+      /*!
+       * Implements the unified property interface -- import function.
+       * As for the export, only one tag is taken into account. If the file
+       * has no tag at all, APE will be created.
+       */
+      PropertyMap setProperties(const PropertyMap &);
       /*!
        * Returns the APE::Properties for this file.  If no audio properties
        * were read then this will return a null pointer.

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"
@@ -174,6 +175,86 @@ 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 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 = PropertyMap::prepareKey(it->first);
+    // 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 = PropertyMap::prepareKey(remIt->first);
+    // 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();
+  for(; it != properties.end(); ++it) {
+    const String &tagName = it->first;
+    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 PropertyMap();
+}
+
 APE::Footer *APE::Tag::footer() const
 {
   return &d->footer;

taglib/ape/apetag.h

@@ -103,6 +103,30 @@ 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.
+       */
+      PropertyMap setProperties(const PropertyMap &);
+
       /*!
        * Returns a pointer to the tag's footer.
        */