verify.h

/* Copyright 2021 ID R&D Inc. All Rights Reserved. */
 
#pragma once
 
#include <voicesdk/core/config.h>
#include <voicesdk/core/common/voice_template.h>
 
#include <vector>
#include <memory>
#include <iostream>
#include <unordered_map>
 
namespace voicesdk {
    struct VerifyResult {
        float score;
 
        float probability;
 
        VerifyResult(float score, float probability) : score(score), probability(probability) {}
 
        friend std::ostream& operator<<(std::ostream& os, const VerifyResult& obj) {
            os << "VerifyResult["
               << "score: "        << obj.score        << ", "
               << "probability: "  << obj.probability  << "]";
            return os;
        }
 
        bool operator==(const VerifyResult& other) const {
            return score == other.score && probability == other.probability;
        }
    };
 
    class VOICE_SDK_API VoiceTemplateMatcher
    {
    public:
        using Ptr = std::shared_ptr<VoiceTemplateMatcher>;
 
        virtual ~VoiceTemplateMatcher() = default;
 
        static Ptr create(const std::string& initPath);
 
        virtual VerifyResult matchVoiceTemplates(const VoiceTemplate::Ptr& template1, const VoiceTemplate::Ptr& template2) const = 0;
 
        virtual const std::string& getInitDataId() const = 0;
    };
 
    struct QualityCheckThresholds {
        float minimumSnrDb = 0;
 
        float minimumSpeechLengthMs = 0;
    };
 
    struct VerifyFileBatchElement {
 
        std::string wav_file_path;
 
        ChannelType channel_type;
    };
 
    template <class T>
    struct VerifySamplesBatchElement {
        VerifySamplesBatchElement(const T* data, size_t data_size, size_t sample_rate, ChannelType channel_type)
            : data(data), data_size(data_size), sample_rate(sample_rate), channel_type(channel_type) {}
 
        const T* data;
 
        size_t data_size;
 
        size_t sample_rate;
 
        ChannelType channel_type;
    };
 
    class VOICE_SDK_API VoiceTemplateFactory
    {
    public:
 
        using Ptr = std::shared_ptr<VoiceTemplateFactory>;
 
        static Ptr create(const std::string& initPath);
 
        virtual VoiceTemplate::Ptr createVoiceTemplate(
            const std::string& audioPath,
            const ChannelType& channelType = ChannelType::TEL) const = 0;
 
        virtual VoiceTemplate::Ptr createVoiceTemplate(
            const float *floatSamples,
            size_t numSamples,
            size_t sampleRate,
            const ChannelType& channelType = ChannelType::TEL) const = 0;
 
        virtual VoiceTemplate::Ptr createVoiceTemplate(
            const int16_t *pcm16Samples,
            size_t numSamples,
            size_t sampleRate,
            const ChannelType& channelType = ChannelType::TEL) const = 0;
 
        virtual VoiceTemplate::Ptr createVoiceTemplate(
            const uint8_t *pcm16Bytes,
            size_t numBytes,
            size_t sampleRate,
            const ChannelType& channelType = ChannelType::TEL) const = 0;
 
        virtual std::vector<VoiceTemplate::Ptr> createVoiceTemplateBatch(
            const std::vector<VerifyFileBatchElement>& input_batch) const = 0;
 
        virtual std::vector<VoiceTemplate::Ptr> createVoiceTemplateBatch(
            const std::vector<VerifySamplesBatchElement<float>>& input_batch) const = 0;
 
        virtual std::vector<VoiceTemplate::Ptr> createVoiceTemplateBatch(
            const std::vector<VerifySamplesBatchElement<int16_t>>& input_batch) const = 0;
 
        virtual std::vector<VoiceTemplate::Ptr> createVoiceTemplateBatch(
            const std::vector<VerifySamplesBatchElement<uint8_t>>& input_batch) const = 0;
 
        virtual VoiceTemplate::Ptr mergeVoiceTemplates(const std::vector<VoiceTemplate::Ptr>& voiceTemplates) const = 0;
 
        virtual const std::string& getInitDataId() const = 0;
 
        virtual const size_t& getMinimumAudioSampleRate() const = 0;
 
        virtual ~VoiceTemplateFactory() = default;
    };
}