TextToPreset.h

Go to the documentation of this file.

#pragma once
 
namespace krotos
{
 
#define AUDIO_METADATA_TAGS 1
#define PRESET_FILENAME_TAGS 0
 
constexpr char embeddingsFileName[] = ".ttpEmbCache";
constexpr char ttpStatusFileName[] = ".ttpStatus";
constexpr char ttpStatusDateProperty[] = "date modified";
constexpr char ttpNumericalMetadata[] = "-0123456789";
constexpr char wavMetadataFieldInFile[] = "bwav description";
constexpr char presetNameField[] = "presetName";
constexpr char embeddingsNameField[] = "embeddings";
constexpr char tagsNameField[] = "tags";
const static String ttpThreadName{"TTPThread"};
 
static constexpr size_t BUF_SIZE = 32; // Key size - must be 32
constexpr size_t BUFFER_SIZE = 1024;
constexpr size_t IV_SIZE = 16;
 
class TextToPreset : public Thread
{
  public:
    TextToPreset();
    ~TextToPreset();
    
    float computeSimilarity(const std::vector<float>& queryEmbedding, const std::vector<float>& resultEmbedding) const;
    
    StringArray combineSearch(const String& searchTerm, const StringArray& classicResults, const StringArray& ttpResults, std::map<String, std::vector<float>>& embeddingsCache, const size_t& maxResults = 25);
 
    StringArray findClosestPresets(String searchTerm, int maxNumPresetsToFind) const;
 
    std::string getPresetPath(std::string presetNameToLoad) const
    {
        return m_presetNameAndPresetPathMap.at(presetNameToLoad);
    }
 
    String logString() const { return m_logString; }
 
    bool processFileList(Array<File>& filesToProcess);
 
    bool calculateEmbeddingsForPresetFile(File presetFile);
 
    bool appendDataToEmbeddingsFile(/*CriticalSection& cs*/);
 
    File createFilePath(String filename);
 
    void loadEmbeddings();
 
    StringArray performSearch(String query);
 
    // TODO: this needs to be picked up from decryption code, copied it here, untill
    // there  is a consistent way to inter-include km3 modules.
    void getSampleMetadata(const std::string& input, unsigned char* byteArray)
    {
        for (size_t i = 0, j = 0; i < input.length(); i += 2, j++)
        {
            std::string byteStr = input.substr(i, 2);
            unsigned int byteValue;
            std::istringstream(byteStr) >> std::hex >> byteValue;
            byteArray[j] = static_cast<unsigned char>(byteValue);
        }
    }
 
  private:
    void clear();
 
    // on a thread
    void run() override;
 
    // log string
    String m_logString;
 
    void getPresetAssetNames(ValueTree& root);
 
    bool assetNamesToTags(bool eliminateDuplicates);
 
    void searchForTagAndProperty(ValueTree& root, Identifier tag, Identifier property);
 
    std::vector<float> destringify(String stringWithNumbers);
 
    bool saveToFile(File file);
 
    bool readFromFile(File file);
 
    template <class T> String stringify(std::vector<T> numbers);
 
    // simple struct to hold preset tags and embeddings
    struct Data
    {
        StringArray tags;
        std::vector<float> embeddings;
        Data(StringArray tags = StringArray(), std::vector<float> embeddings = std::vector<float>())
            : tags(tags), embeddings(embeddings)
        {
        }
    };
 
    // asset sample paths
    StringArray m_samplePaths;
 
    // asset file names
    StringArray m_sampleFilenames;
 
    // preset file to process
    File m_presetFile;
 
    // preset name to process
    String m_presetName;
 
    // will keep the tags for each preset file
    StringArray m_presetTags;
 
    // map that holds preset tags and embeddings
    std::map<String, Data> m_presetData;
 
    // map that holds preset name and preset path
    std::map<std::string, std::string> m_presetNameAndPresetPathMap;
 
    // includes words within preset asset names that are tag irrelevant and need to be excluded
    StringArray excludeTerms{"Woje",      "woje",   "SNDBTS_CAS1", "SNDBTS_CAS4", ".wav", "wav", "kaf",  ".kaf",
                             "sndbts",    "krotos", "krt",         "krts",        "mf",   "ks",  "mono", "stereo",
                             "ambisonic", "and",    "in",          "on",          "up",   "or",  "i",    "ii",
                             "type1",     "type2",  "type3",       "type4",       "type5"};
 
    // Multiple asset paths per engine are currently split by the following string .. this is a temp fix till its sorted
    // out
    String assetPathsDelimiter{"\n"};
 
    // split by the delimiter above if necessary and keep treated paths inside
    StringArray m_treatedAssetPaths;
 
    // delimiters TODO: see if more needed by inspecting asset file names and paths
    String delimiters{",|._- "};
 
    // the sentence transformer (bert)
    SentenceTransformer m_sentenceTransformer;
 
    // class that holds UCS CatIDs
    SharedResourcePointer<UniversalCategorySystem> m_UCS;
 
    // KD-Tree for nearest neighbour search
    KDTreeND m_kNN;
 
    // vector of preset names
    std::vector<String> m_presetNames;
 
    // critical section for thread safety
    CriticalSection m_cs;
 
    // data will hold the hex representation of the encryption key
    unsigned char m_data[BUFFER_SIZE];
 
    // model file available
    bool m_modelFileAvailable{false};
};
 
class TextToPresetShared
{
  public:
    SharedResourcePointer<TextToPreset> m_textToPreset;
};
 
class DirectoryWatcher : private TimeSliceClient
{
  public:
    DirectoryWatcher(const File& dirToWatch);
 
    ~DirectoryWatcher() override;
 
    bool handleContentUpdate();
 
    void getAllPresetFiles(const File& directory, Array<File>& fileArray);
 
  private:
    // the thread the watcher runs on
    TimeSliceThread thread{" Directory Watcher Thread"};
 
    int useTimeSlice() override;
 
    // dir modification date
    String m_dirModificationDate;
 
    // root dir
    File m_directory;
 
    // shared ttp instance
    TextToPresetShared m_textToPresetSharedInstance;
 
    // presets file array
    Array<File> m_presetFilesArray;
 
    // presets already existing in the embeddings file
    StringArray m_presetsWithEmbeddings;
 
    // list of presets file to process
    Array<File> m_presetFilesToProcess;
};
 
} // namespace krotos