verify.h

Go to the documentation of this file.

/* Copyright 2017 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 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::MIC) const = 0;

        virtual VoiceTemplate::Ptr createVoiceTemplate(
            const float *floatSamples,
            size_t numSamples,
            size_t sampleRate,
            const ChannelType& channelType = ChannelType::MIC) const = 0;

        virtual VoiceTemplate::Ptr createVoiceTemplate(
            const int16_t *pcm16Samples,
            size_t numSamples,
            size_t sampleRate,
            const ChannelType& channelType = ChannelType::MIC) const = 0;

        virtual VoiceTemplate::Ptr createVoiceTemplate(
            const uint8_t *pcm16Bytes,
            size_t numBytes,
            size_t sampleRate,
            const ChannelType& channelType = ChannelType::MIC) 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;
    };
}