AudioPluginCache.hpp

#pragma once
 
// Versioned persistence for the audio plug-in scan caches (VST2 / VST3 /
// CLAP / LV2), replacing the raw QVariant metatype blobs in QSettings.
//
// The old scheme stored `QVariant::fromValue(std::vector<Info>)`: any change
// to the Info datastream layout made old blobs decode as garbage that
// `QVariant::canConvert` happily accepted (the "vst_invalid_format" global
// hack in the VST2 plug-in was a workaround for exactly this). The new blob
// is explicit: magic, format version, element count, elements — and
// deserialization fails cleanly instead of producing garbage when anything
// does not line up.
//
// deduplicated() / dropShadowedInvalidEntries() heal caches that already
// accumulated duplicates (each plug-in could end up multiplied by hundreds:
// scan replies from *other* score instances used to be appended to whichever
// instance owned the fixed notification port, and nothing ever pruned them).
 
#include <ossia/detail/algorithms.hpp>
 
#include <QByteArray>
#include <QDataStream>
#include <QIODevice>
#include <QSet>
#include <QSettings>
#include <QString>
 
#include <optional>
#include <type_traits>
#include <vector>
 
namespace Media
{
inline constexpr quint32 pluginCacheMagic = 0x53435043; // "SCPC"
 
template <typename T>
QByteArray serializePluginCache(quint32 version, const std::vector<T>& vec)
{
  QByteArray res;
  {
    QDataStream str{&res, QIODevice::WriteOnly};
    str << pluginCacheMagic << version << (quint32)vec.size();
    for(const auto& elt : vec)
    {
      QByteArray blob;
      {
        QDataStream es{&blob, QIODevice::WriteOnly};
        es << elt;
      }
      str << blob;
    }
  }
  return res;
}
 
template <typename T>
std::optional<std::vector<T>>
deserializePluginCache(quint32 version, const QByteArray& data)
{
  if(data.isEmpty())
    return std::nullopt;
 
  QDataStream str{data};
  quint32 magic{}, ver{}, count{};
  str >> magic >> ver >> count;
  if(str.status() != QDataStream::Ok || magic != pluginCacheMagic || ver != version)
    return std::nullopt;
 
  // Each element blob costs at least its 4-byte length prefix; a larger
  // count is a corrupt header, not a plausible plug-in collection.
  if(count > (quint32)data.size() / 4)
    return std::nullopt;
 
  std::vector<T> res;
  res.reserve(count);
  for(quint32 i = 0; i < count; i++)
  {
    QByteArray blob;
    str >> blob;
    if(str.status() != QDataStream::Ok)
      return std::nullopt;
 
    QDataStream es{blob};
    T elt;
    es >> elt;
    // An element that does not consume its blob exactly decoded with a
    // different layout than it was written with
    if(es.status() != QDataStream::Ok || !es.atEnd())
      return std::nullopt;
    res.push_back(std::move(elt));
  }
 
  if(!str.atEnd())
    return std::nullopt;
 
  return res;
}
 
template <typename T>
std::vector<T> loadPluginCache(
    quint32 version, const QString& key, const QString& legacyKey)
{
  QSettings set;
 
  std::optional<std::vector<T>> versioned;
  if(const auto val = set.value(key); val.canConvert<QByteArray>())
    versioned = deserializePluginCache<T>(version, val.toByteArray());
 
  std::vector<T> legacy;
  if(!legacyKey.isEmpty())
  {
    if(!versioned)
    {
      if(const auto val = set.value(legacyKey); val.canConvert<std::vector<T>>())
        legacy = val.value<std::vector<T>>();
    }
    // Removed even when the versioned cache won: an older score run may have
    // rewritten it since the migration, and it must not resurrect stale
    // entries after a future format-version bump.
    set.remove(legacyKey);
  }
 
  return versioned ? *std::move(versioned) : legacy;
}
 
template <typename T>
void savePluginCache(quint32 version, const QString& key, const std::vector<T>& vec)
{
  QSettings{}.setValue(key, serializePluginCache(version, vec));
}
 
template <typename T, typename KeyFn>
void deduplicate(std::vector<T>& vec, KeyFn&& key_of)
{
  // `[](const Info& i) { return i.path + "|" + i.id; }` deduces a
  // QStringBuilder return type. The outer builder holds a reference to the
  // inner one, which is a temporary of the return statement, so the object
  // handed back here points at freed memory and converting it reads a garbage
  // length (std::bad_alloc, on the caller's first plug-in). Demanding QString
  // makes the concatenation happen where its operands are still alive.
  static_assert(
      std::is_same_v<std::invoke_result_t<KeyFn&, const T&>, QString>,
      "the key function must return QString: a deduced QStringBuilder return "
      "type dangles past the end of the return statement");
  QSet<QString> seen;
  ossia::remove_erase_if(vec, [&](const T& elt) {
    const QString k = key_of(elt);
    if(seen.contains(k))
      return true;
    seen.insert(k);
    return false;
  });
}
 
template <typename T, typename PathFn, typename ValidFn>
void dropShadowedInvalidEntries(std::vector<T>& vec, PathFn&& path_of, ValidFn&& is_valid)
{
  static_assert(
      std::is_same_v<std::invoke_result_t<PathFn&, const T&>, QString>,
      "the path function must return QString: see deduplicate()");
  QSet<QString> valid_paths;
  for(const auto& elt : vec)
    if(is_valid(elt))
      valid_paths.insert(path_of(elt));
 
  ossia::remove_erase_if(vec, [&](const T& elt) {
    return !is_valid(elt) && valid_paths.contains(path_of(elt));
  });
}
 
template <typename T, typename KeyFn, typename PathFn, typename ValidFn>
void sanitizePluginCache(
    std::vector<T>& vec, KeyFn&& key_of, PathFn&& path_of, ValidFn&& is_valid)
{
  ossia::remove_erase_if(
      vec, [&](const T& elt) { return path_of(elt).isEmpty(); });
  dropShadowedInvalidEntries(vec, path_of, is_valid);
  deduplicate(vec, key_of);
}
}