antispoof.h

/* Copyright 2023 ID R&D Inc. All Rights Reserved. */
 
#pragma once
#include <string>
#include <iostream>
#include <utility>
#include <vector>
#include <memory>
#include <voicesdk/core/config.h>
 
namespace voicesdk {
 
    struct AntispoofResult {
 
        float score        = 0.0; 
        float score_Replay = 0.0; 
        float score_TTS    = 0.0; 
        float score_VC     = 0.0; 
        std::string unsuitableInputMessage; 
        friend std::ostream& operator<<(std::ostream& os, const AntispoofResult& obj) {
            os << "AntispoofResult["
                << "score: "         << obj.score         << ", "
                << "score_Replay: "  << obj.score_Replay  << ", "
                << "score_TTS: "     << obj.score_TTS     << ", "
                << "score_VC: "      << obj.score_VC;
            if (!obj.unsuitableInputMessage.empty()) {
                os << ", ";
                os << "unsuitableInputMessage: " << obj.unsuitableInputMessage;
            }
            os << "]";
            return os;
        }
 
        AntispoofResult(
            float score,
            float score_Replay,
            float score_TTS,
            float score_VC,
            std::string unsuitableInputMessage = "")
        :
            score        (score),
            score_Replay (score_Replay),
            score_TTS    (score_TTS),
            score_VC     (score_VC),
            unsuitableInputMessage(std::move(unsuitableInputMessage))
        {}
 
        AntispoofResult()                             = default;
        AntispoofResult(const AntispoofResult& other) = default;
 
        bool operator== (const AntispoofResult& other) const {
            return score        == other.score
                && score_Replay == other.score_Replay
                && score_TTS    == other.score_TTS
                && score_VC     == other.score_VC
                && unsuitableInputMessage == other.unsuitableInputMessage;
        }
 
        bool isValid() {
            auto isScoreValid = [](float score) -> bool {
                return 0.0 <= score && score <= 1.0;
            };
            return isScoreValid(score)
                && isScoreValid(score_Replay)
                && isScoreValid(score_TTS)
                && isScoreValid(score_VC);
        }
    };
 
 
    class VOICE_SDK_API AntispoofEngine {
    public:
        using Ptr = std::shared_ptr<AntispoofEngine>;
 
        static AntispoofEngine::Ptr create(const std::string& initPath);
 
        virtual AntispoofResult isSpoof(
            const uint8_t* pcm16Bytes,
            size_t bytesNum,
            int sampleRate) const = 0;
 
        virtual AntispoofResult isSpoof(
            const int16_t* pcm16Samples,
            size_t samplesNum,
            int sampleRate) const = 0;
 
        virtual AntispoofResult isSpoof(
            const float* floatSamples,
            size_t samplesNum,
            int sampleRate) const = 0;
 
         virtual AntispoofResult isSpoof(const std::string& audioFile) const = 0;
 
         virtual ~AntispoofEngine() = default;
    };
}