types.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2021  Music Technology Group - Universitat Pompeu Fabra
 *
 * This file is part of Essentia
 *
 * Essentia is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Affero General Public License as published by the Free
 * Software Foundation (FSF), either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program 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 General Public License for more
 * details.
 *
 * You should have received a copy of the Affero GNU General Public License
 * version 3 along with this program.  If not, see http://www.gnu.org/licenses/
 */
 
#ifndef ESSENTIA_TYPES_H
#define ESSENTIA_TYPES_H
 
#include <map>
#include <vector>
#include <cctype>
#include <cassert>
#include <sstream>
#include <typeinfo>
#include <string.h>
#include "config.h"
#include "debugging.h"
#include "streamutil.h"
#include <unsupported/Eigen/CXX11/Tensor>
 
 
// fixed-size int types
 
#ifndef OS_WIN32
 
#include <inttypes.h>
 
typedef uint16_t uint16;
typedef uint32_t uint32;
typedef uint64_t uint64;
typedef int16_t sint16;
typedef int32_t sint32;
typedef int64_t sint64;
 
typedef unsigned int uint;
 
#else // OS_WIN32
 
typedef unsigned __int16 uint16;
typedef unsigned __int32 uint32;
typedef unsigned __int64 uint64;
typedef __int16 sint16;
typedef __int32 sint32;
typedef __int64 sint64;
 
#endif // OS_WIN32
 
 
 
namespace essentia {
 
typedef float Real;
 
 
class EssentiaException : public std::exception {
 
 public:
  EssentiaException(const char* msg) : exception(), _msg(msg) {}
  EssentiaException(const std::string& msg) : exception(), _msg(msg) {}
  EssentiaException(const std::ostringstream& msg) : exception(), _msg(msg.str()) {}
 
  template <typename T, typename U>
  EssentiaException(const T& a, const U& b) : exception() {
    std::ostringstream oss; oss << a << b; _msg = oss.str();
  }
 
  template <typename T, typename U, typename V>
  EssentiaException(const T& a, const U& b, const V& c) : exception() {
    std::ostringstream oss; oss << a << b << c; _msg = oss.str();
  }
 
  template <typename T, typename U, typename V, typename W>
  EssentiaException(const T& a, const U& b, const V& c, const W& d) : exception() {
    std::ostringstream oss; oss << a << b << c << d; _msg = oss.str();
  }
 
  virtual ~EssentiaException() throw() {}
  virtual const char* what() const throw() { return _msg.c_str(); }
 
 protected:
  std::string _msg;
 
};
 
 
inline bool case_insensitive_char_cmp(char a, char b) {
  return std::tolower(a) < std::tolower(b);
}
 
struct case_insensitive_str_cmp
  : public std::binary_function<const std::string&, const std::string&, bool> {
  bool operator()(const std::string& str1, const std::string& str2) const {
    return std::lexicographical_compare(str1.begin(), str1.end(),
                                        str2.begin(), str2.end(),
                                        case_insensitive_char_cmp);
  }
};
 
 
template <class T>
class OrderedMap : public std::vector<std::pair<std::string, T*> > {
 public:
  typedef typename std::vector<std::pair<std::string, T*> > BaseClass;
 
  int size() const { return (int)BaseClass::size(); }
 
  const std::pair<std::string, T*>& operator[](uint idx) const {
    return BaseClass::operator[](idx);
  }
 
  std::pair<std::string, T*>& operator[](uint idx) {
    return BaseClass::operator[](idx);
  }
 
  const T* operator[](const char* str) const {
    const uint size = this->size();
    for (uint i=0; i<size; i++) {
      if (charptr_cmp((*this)[i].first.c_str(), str) == 0) {
        return (*this)[i].second;
      }
    }
 
    throw EssentiaException("Value not found: '", str, "'\nAvailable keys: ", keys());
  }
 
  T* operator[](const char* str) {
    return const_cast<T*>(const_cast<const OrderedMap<T>*>(this)->operator[](str));
  }
 
  const T* operator[](const std::string& str) const {
    return operator[](str.c_str());
  }
 
  T* operator[](const std::string& str) {
    return operator[](str.c_str());
  }
 
  std::vector<std::string> keys() const {
    std::vector<std::string> result(this->size());
    for (int i=0; i<this->size(); i++) {
      result[i] = this->at(i).first;
    }
    return result;
  }
 
  void insert(const std::string& key, T* value) {
    this->push_back(std::make_pair(key, value));
  }
};
 
 
 
template <typename KeyType, typename ValueType, typename Compare = std::less<KeyType> >
class EssentiaMap : public std::map<KeyType, ValueType, Compare> {
 
 public:
  typedef std::map<KeyType, ValueType, Compare> BaseClass;
 
  ValueType& operator[](const KeyType& key) {
    typename BaseClass::iterator it = this->find(key);
    if (it == BaseClass::end()) {
      throw EssentiaException("Value not found: '", key, "'\nAvailable keys: ", keys());
    }
    return it->second;
  }
 
  const ValueType& operator[](const KeyType& key) const {
    typename BaseClass::const_iterator it = this->find(key);
    if (it == BaseClass::end()) {
      throw EssentiaException("Value not found: '", key, "'\nAvailable keys: ", keys());
    }
    return it->second;
  }
 
  std::pair<typename BaseClass::iterator, bool> insert(const KeyType& key, const ValueType& value) {
    return BaseClass::insert(std::make_pair(key, value));
  }
 
  std::vector<std::string> keys() const {
    std::vector<std::string> result;
    result.reserve(BaseClass::size());
    std::ostringstream stream;
    typename BaseClass::const_iterator it = this->begin();
    for (; it != this->end(); ++it) {
      stream.str("");
      stream << it->first;
      result.push_back(stream.str());
    }
    return result;
  }
 
};
 
 
typedef EssentiaMap<std::string, std::string, string_cmp> DescriptionMap;
 
 
 
 
#if SAFE_TYPE_COMPARISONS
 
// comparison of the type is done using the name() method, because type_info
// are not shared between different linking units.
inline bool sameType(const std::type_info& t1, const std::type_info& t2) {
  return strcmp(t1.name(), t2.name()) == 0;
}
 
#else // SAFE_TYPE_COMPARISONS
 
inline bool sameType(const std::type_info& t1, const std::type_info& t2) {
  return t1 == t2;
}
 
#endif // SAFE_TYPE_COMPARISONS
 
 
// defined in src/base/essentia.cpp
std::string nameOfType(const std::type_info& type);
 
class TypeProxy {
 protected:
  std::string _name;
 
 public:
  TypeProxy() {}
  TypeProxy(const std::string& name) : _name(name) {}
 
  virtual ~TypeProxy() {}
 
  const std::string& name() const { return _name; }
  void setName(const std::string& name) { _name = name; }
 
  inline void checkType(const std::type_info& received,
                        const std::type_info& expected) const {
    if (!sameType(received, expected)) {
      std::ostringstream msg;
      msg << "Error when checking types. Expected: " << nameOfType(expected)
          << ", received: " << nameOfType(received);
      throw EssentiaException(msg);
    }
  }
 
  template <typename Type>
  void checkType() const {
    checkType(typeid(Type), typeInfo());
  }
 
  void checkSameTypeAs(const TypeProxy& obj) const {
    checkType(obj.typeInfo(), typeInfo());
  }
 
  void checkVectorSameTypeAs(const TypeProxy& obj) const {
    checkType(obj.vectorTypeInfo(), typeInfo());
  }
 
  virtual const std::type_info& typeInfo() const = 0;
  virtual const std::type_info& vectorTypeInfo() const = 0;
};
 
inline std::string nameOfType(const TypeProxy& tproxy) {
  return nameOfType(tproxy.typeInfo());
}
 
inline bool sameType(const TypeProxy& lhs, const TypeProxy& rhs) {
  return sameType(lhs.typeInfo(), rhs.typeInfo());
}
 
#define USE_TYPE_INFO(TokenType)                           \
  virtual const std::type_info& typeInfo() const {         \
    return typeid(TokenType);                              \
  }                                                        \
  virtual const std::type_info& vectorTypeInfo() const {   \
    return typeid(std::vector<TokenType>);                 \
  }
 
 
typedef int ReaderID;
 
typedef Real AudioSample;
 
template <typename T>
class Tuple2 {
 public:
  T first;
  T second;
 
  const T& left() const { return first; }
  const T& right() const { return second; }
  const T& x() const { return first; }
  const T& y() const { return second; }
 
  T& left() { return first; }
  T& right() { return second; }
  T& x() { return first; }
  T& y() { return second; }
};
 
typedef Tuple2<Real> StereoSample;
 
#define TENSORRANK 4
 
template<typename T>
using Tensor = Eigen::Tensor<T, TENSORRANK, Eigen::RowMajor>;
 
template<typename T>
using TensorMap = Eigen::TensorMap<Tensor<T>, 0>;
 
using TensorScalar = Eigen::Tensor<Real, 0, Eigen::RowMajor>;
 
using Tensor1D = Eigen::Tensor<Real, 1, Eigen::RowMajor>;
 
using Tensor2D = Eigen::Tensor<Real, 2, Eigen::RowMajor>;
 
using Tensor3D = Eigen::Tensor<Real, 3, Eigen::RowMajor>;
 
 
namespace streaming {
 
class BufferInfo {
 public:
  int size;
  int maxContiguousElements;
 
  BufferInfo(int size = 0, int contiguous = 0) :
    size(size), maxContiguousElements(contiguous) {}
};
 
namespace BufferUsage {
 
enum BufferUsageType {
  forSingleFrames,
  forMultipleFrames,
  forAudioStream,
  forLargeAudioStream
};
 
} // namespace BufferUsage
 
} // namespace streaming
} // namespace essentia
 
#endif // ESSENTIA_TYPES_H