IDVoice (speaker verification)

#include <voicesdk/media/quality_check.h>

// ...

voicesdk::QualityCheckEngine::Ptr engine = voicesdk::QualityCheckEngine::Create("/path/to/init_data");


// create quality check thresholds object, GetRecommendedThresholds method can be used
// to obtain recommended thresholds for the specified scenario (TI enrollment, TD verification, liveness check etc.)
voicesdk::QualityCheckMetricsThresholds thresholds = engine->GetRecommendedThresholds(voicesdk::QualityCheckScenario::kVerifyTiEnrollment);

// we assume that voice sample is provided within a WAV file
// check audio quality

voicesdk::QualityCheckEngineResult quality = engine->CheckQuality("/path/to/wav/file", thresholds);

switch (quality.quality_check_short_description) {
    case voicesdk::QualityCheckEngineResult::QualityCheckShortDescription::kTooNoisy:
        // ask user to repeat the recording in more quiet conditions
        break;
    case voicesdk::QualityCheckEngineResult::QualityCheckShortDescription::kTooSmallSpeechLength:
        // ask user to repeat the recording and provide more net speech
        break;
    case voicesdk::QualityCheckEngineResult::QualityCheckShortDescription::kTooSmallSpeechRelativeLength:
        // ask user to repeat the recording, speech relative length is too small
        break;
    case voicesdk::QualityCheckEngineResult::QualityCheckShortDescription::kMultipleSpeakersDetected:
        // ask user to repeat the recording, multiple speakers were detected
        break;
    case voicesdk::QualityCheckEngineResult::QualityCheckShortDescription::kOk:
        // audio quality is sufficient, audio can be used for enrollment
        break;
}

// ...

import net.idrnd.voicesdk.media.QualityCheckEngine;
import net.idrnd.voicesdk.media.QualityCheckEngineResult;
import net.idrnd.voicesdk.verify.QualityCheckShortDescription;

// ...

QualityCheckEngine engine = new VoiceTemplateFactory("/path/to/init_data");

// create quality check thresholds object, getRecommendedThresholds method can be used
// to obtain recommended thresholds for the specified scenario (TI enrollment, TD verification, liveness check etc.)
QualityCheckMetricsThresholds thresholds = engine.getRecommendedThresholds(QualityCheckScenario.VERIFY_TI_ENROLLMENT);

// we assume that voice sample is provided within a WAV file
// check audio quality

QualityCheckEngineResult quality = engine->checkQuality("/path/to/wav/file", thresholds);

switch (quality.getQualityCheckShortDescription()) {
    case QualityCheckShortDescription.TOO_NOISY:
        // ask user to repeat the recording in more quiet conditions
        break;
    case QualityCheckShortDescription.TOO_SMALL_SPEECH_TOTAL_LENGTH:
        // ask user to repeat the recording and provide more net speech
        break;
    case QualityCheckShortDescription.TOO_SMALL_SPEECH_RELATIVE_LENGTH:
        // ask user to repeat the recording, speech relative length is too small
        break;
    case QualityCheckShortDescription.MULTIPLE_SPEAKERS_DETECTED:
        // ask user to repeat the recording, multiple speakers were detected
        break;
    case QualityCheckShortDescription.OK:
        // audio quality is sufficient, audio can be used for enrollment
        break;
}

// ...

from voicesdk.media import QualityCheckEngine, QualityCheckMetricsThresholds, QualityCheckShortDescription

# ...

engine = QualityCheckEngine("/path/to/init_data")

# create quality check thresholds object, get_recommended_thresholds method can be used
# to obtain recommended thresholds for the specified scenario (TI enrollment, TD verification, liveness check etc.)
thresholds = engine.get_recommended_thresholds(QualityCheckScenario.VERIFY_TI_ENROLLMENT)


# we assume that voice sample is provided within a WAV file

# check audio quality before creating voice template

quality = engine.check_quality("/path/to/wav/file", thresholds)

if quality.quality_check_short_description == QualityCheckShortDescription.TOO_NOISY:
    # ask user to repeat the recording in more quiet conditions
    # ...
elif quality.quality_check_short_description == QualityCheckShortDescription.TOO_SMALL_SPEECH_TOTAL_LENGTH:
    # ask user to repeat the recording and provide more net speech
    # ...
elif quality.quality_check_short_description == QualityCheckShortDescription.TOO_SMALL_SPEECH_RELATIVE_LENGTH:
    # ask user to repeat the recording, speech relative length is too small
    # ...
elif quality.quality_check_short_description == QualityCheckShortDescription.MULTIPLE_SPEAKERS_DETECTED:
    # ask user to repeat the recording, multiple speakers were detected
    # ...
else:
    # audio quality is sufficient, audio can be used for enrollment
    # ...

# ...

let qualityCheckEngine = QualityCheckEngine(path: voiceTemplateFactoryAndMatcherTDInitDataPath)

// Create quality check thresholds object, getRecommendedThresholds method can be used
// to obtain recommended thresholds for the specified scenario (TI enrollment, TD verification, liveness check etc.)
let thresholds = try! qualityCheckEngine.getRecommendedThresholds(QualityCheckScenario.QUALITY_CHECK_SCENARIO_VERIFY_TI_ENROLLMENT)

// We assume that voice sample is provided within a WAV file
let pathToWavFile: String = "/path/to/wav/file"

let result: QualityCheckEngineResult? = self.qualityCheckEngine?.checkQuality(pathToWavFile, thresholds:thresholds)
let qualityDescription = result.qualityCheckShortDescription

switch qualityDescription {
case .QUALITY_SHORT_DESCRIPTION_OK:
// Audio quality is sufficient, audio can be used for enrollment

case .QUALITY_SHORT_DESCRIPTION_TOO_SMALL_SPEECH_TOTAL_LENGTH:
// Ask user to repeat the recording and provide more net speech

case .QUALITY_SHORT_DESCRIPTION_TOO_SMALL_SPEECH_RELATIVE_LENGTH:
// Ask user to repeat the recording, speech relative length is too small

case .QUALITY_SHORT_DESCRIPTION_MULTIPLE_SPEAKERS_DETECTED:
// Ask user to repeat the recording, multiple speakers were detected

case .QUALITY_SHORT_DESCRIPTION_TOO_NOISY:
// Ask user to repeat the recording in a quiet environment

}

let pcm16AudioSamples = ...;
let sampleRate = ...;

createVoiceSdkModule().then(voicesdk => {
    fileSelector.addEventListener('change', (event) => {
        try {
            // Create quality check thresholds object, getRecommendedThresholds method can be used
            // to obtain recommended thresholds for the specified scenario (TI enrollment, TD verification, liveness check etc.)
            const thresholds = engine.getRecommendedThresholds(voicesdk.QualityCheckScenario.VERIFY_TI_ENROLLMENT);

            // Path to the init data is specified within virtual filesystem of SDK wasm module
            var engine = new voicesdk.QualityCheckEngine("/home/quality_check");

            // Check quality
            var result = engine.checkQualityFromPcm16Samples(audioSamples, sampleRate, thresholds);

            switch (result.qualityCheckShortDescription) {
                case voicesdk.QualityCheckShortDescription.OK:
                    // Audio quality is sufficient, audio can be used for enrollment
                    break;
                case voicesdk.QualityCheckShortDescription.TOO_SMALL_SPEECH_TOTAL_LENGTH:
                    // Ask user to repeat the recording and provide more net speech
                    break;
                case voicesdk.QualityCheckShortDescription.TOO_NOISY:
                    // Ask user to repeat the recording in a quiet environment
                    break;
                case voicesdk.QualityCheckShortDescription.TOO_SMALL_SPEECH_RELATIVE_LENGTH:
                    // ask user to repeat the recording, speech relative length is too small
                    break;
                case voicesdk.QualityCheckShortDescription.MULTIPLE_SPEAKERS_DETECTED:
                    // ask user to repeat the recording, multiple speakers were detected
            }
        } catch (error) {
            if (typeof error === 'number') {
                console.log(voicesdk.getExceptionMessage(error));
            } else {
                console.log(error);
            }
        } finally {
            // Both VoiceSDK objects constructed from the JavaScript side as well as those returned
            // from VoiceSDK methods must be explicitly deleted (if they have delete() method, see docs).
            engine.delete();
        }
    });

#include <voicesdk/verify/verify.h>

// ...

VoiceTemplateFactory::Ptr factory = VoiceTemplateFactory::create("/path/to/init_data");

// create voice template from wav file.
// you don't need to re-initialize the factory for creating next templates
VoiceTemplate::Ptr voiceTmpl = factory->createVoiceTemplate("/path/to/wav/file");

import net.idrnd.voicesdk.verify.VoiceTemplateFactory;
import net.idrnd.voicesdk.core.common.VoiceTemplate;

// ...

VoiceTemplateFactory factory = new VoiceTemplateFactory("/path/to/init_data");

// create voice template from wav file.
// you don't need to re-initialize the factory for creating next templates
VoiceTemplate voiceTmpl = factory.createVoiceTemplate("/path/to/wav/file");

from voicesdk.verify import VoiceTemplateFactory
from voicesdk.core import VoiceTemplate

# ...

factory = VoiceTemplateFactory("/path/to/init_data")

# create voice template from wav file.
# you don't need to re-initialize the factory for creating next templates
voice_template = factory.create_voice_template_from_file("/path/to/wav/file")

#include <voicesdk/verify/verify.h>

// ...

const std::string initDataPath = "/path/to/init/data/mic-v2";

// use the same init data for both factory and matcher
VoiceTemplateFactory::Ptr factory = VoiceTemplateFactory::create(initDataPath);
VoiceTemplateMatcher::Ptr matcher = VoiceTemplateMatcher::create(initDataPath);

// create voice templates
VoiceTemplatePtr voiceTmpl1 = factory->createVoiceTemplate("/path/to/wav/file1");
VoiceTemplatePtr voiceTmpl2 = factory->createVoiceTemplate("/path/to/wav/file2");

// match voice templates
VerifyResult verifyResult = matcher->matchVoiceTemplates(voiceTmpl1, voiceTmpl2);

// output the resulting score and probability
std::cout << std::fixed; // for better float formatting
std::cout << verifyResult << std::endl;

import net.idrnd.voicesdk.verify.VoiceTemplateFactory;
import net.idrnd.voicesdk.verify.VoiceTemplateMatcher;
import net.idrnd.voicesdk.core.common.VoiceTemplate;

// ...

String initDataPath = "/path/to/init/data/mic-v2";

// use the same init data for both factory and matcher
VoiceTemplateFactory factory = new VoiceTemplateFactory(initDataPath);
VoiceTemplateMatcher matcher = new VoiceTemplateMatcher(initDataPath);

// create voice templates
VoiceTemplate voiceTmpl1 = factory.createVoiceTemplate("/path/to/wav/file1");
VoiceTemplate voiceTmpl2 = factory.createVoiceTemplate("/path/to/wav/file2");

// match voice templates
System.out.println("Results follow:");
VerifyResult result = matcher.matchVoiceTemplates(voiceTmpl1, voiceTmpl2);
System.out.println(String.format("Verification result: %s", result));

from voicesdk.verify import VoiceTemplateFactory, VoiceTemplateMatcher
from voicesdk.core import VoiceTemplate

# ...

init_data_path = "/path/to/init/data/mic-v2"

// use the same init data for both factory and matcher
factory = VoiceTemplateFactory(init_data_path)
matcher = VoiceTemplateMatcher(init_data_path)

# create voice templates
voice_template1 = factory.create_voice_template_from_file("/path/to/wav/file1")
voice_template2 = factory.create_voice_template_from_file("/path/to/wav/file2")

# match voice templates
res = matcher.match_voice_templates(voice_template1, voice_template2)
print("Verification result: ", res)

let voiceTemplateFactory = VoiceTemplateFactory(path: Globals.voiceTemplateFactoryAndMatcherTDInitDataPath)

// Array for storing all created templates during enrollment session
var templates: [VoiceTemplate] = []
// Variable for storing the reference template
var referenceTemplate: VoiceTemplate?

// We assume that voice sample is provided within a WAV file
let pathToWavFile: String = "/path/to/wav/file"
let voiceTemplate = voiceTemplateFactory.createVoiceTemplate(pathToWavFile)
templates.append(voiceTemplate)
referenceTemplate = voiceTemplate

// Recommended matching threshold for this check is 0.5 (50%)
let matchingThreshold = 0.5

let voiceTemplate = voiceTemplateFactory.createVoiceTemplate(pathToWavFile)
let matchingResult = voiceTemplateMatcher.matchVoiceTemplates(referenceTemplate, template2: voiceTemplate)
if matchingResult.probability > matchingThreshold {
    templates.append(voiceTemplate)
} else {
    // Inform the user that the current recording does not match the reference one and ask to try again ensuring that the speaker is the same.
}

import numpy as np
import pyaudio
from voicesdk.verify import VoiceTemplateFactory, VoiceTemplateMatcher, VoiceVerifyStream
from voicesdk.core import VoiceTemplate

# 0.1. Init voice template factory and matcher

init_data_path = "../../init_data/verify/mic-v2"

factory = VoiceTemplateFactory(init_data_path)
matcher = VoiceTemplateMatcher(init_data_path)

# 0.2. Set recording params

sample_rate = 16000
buffer_length_samples = 1024

# 1. Create voice template using the provided enrollment WAV file

template1 = factory.create_voice_template_from_file("../wav/verify/f001_04_001.wav")
template2 = factory.create_voice_template_from_file("../wav/verify/f002_01_001.wav")

# 2. Create verify stream

verify_stream = VoiceVerifyStream(factory, matcher, [template1, template2], sample_rate)

# 3. Perform streaming verification

input("Press enter key to start recording")
p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paInt16, channels=1, rate=sample_rate, input=True, frames_per_buffer=buffer_length_samples)
print("Press Ctrl-C to exit")
print("Recording...")

while True:
     # 3.1. Feed a chunk of size ‘buffer_length_samples’ of a captured signal to verify_stream
     audio_samples = np.frombuffer(stream.read(buffer_length_samples), dtype=np.int16)
     verify_stream.add_samples(audio_samples)

     # 3.2. Check if stream produced verification results, retrieve them if there are any
     while verify_stream.has_verify_results():
         print(verify_stream.get_verify_result())

stream.close()